takana/recipes/atuq/extensions/proxy/fondo.js

// atuq — proxy por contenedor (SDD 26 §6.8).
//
// QUÉ HACE: cada contenedor de Firefox («contextual identity») puede salir por su propio proxy.
// El contenedor «Banco» por un SOCKS de la oficina, el «Compras» directo, y ninguno de los dos se
// entera del otro. Ningún navegador trae esto de fábrica: en todos hace falta instalar una
// extensión de terceros, que es exactamente el eslabón que una distro no debería pedirle al usuario.
//
// ⚠ LO QUE ESTO **NO** ES, Y VA PRIMERO A PROPÓSITO (SDD 26 §4): esto es **separación de tráfico,
// no anonimato**. Cambia por dónde salen los paquetes; no toca la huella del navegador, ni el
// user-agent, ni los timers, ni el canvas. Un sitio sigue reconociendo el mismo atuq del otro lado
// de dos proxies distintos. Para anonimato existe Tor Browser y lo decimos nosotros primero.
//
// ── POR QUÉ MV2 CON FONDO PERSISTENTE ─────────────────────────────────────────────────────────
// Un event page se descarga cuando está ocioso y se despierta con el evento. Acá eso significaría
// reconstruir el mapa nombre→contenedor DENTRO del camino crítico de la primera petición, con la
// resolución del proxy esperando. Persistente cuesta unos MB y quita ese riesgo entero.

// ── EL MURO ───────────────────────────────────────────────────────────────────────────────────
// Adónde se manda un contenedor que TIENE proxy configurado y no lo pudimos honrar (entrada
// inválida, API que falla, mapa a medio construir). No es «directo»: si alguien pidió que ese
// contenedor no salga por su línea, la respuesta correcta a un fallo nuestro es que NO SALGA, y que
// se vea. El puerto 9 es `discard`, cerrado en cualquier máquina normal ⇒ el navegador muestra un
// error de proxy en la cara en vez de mandar el tráfico por donde el usuario no quería.
//
// Es la misma postura que el resto del repo: un ausente falla ruidosamente, un vacío llega hasta el
// final diciendo que todo fue bien. Acá el «vacío» sería una fuga silenciosa.
const MURO = { type: "socks", host: "127.0.0.1", port: 9, proxyDNS: true };
const DIRECTO = { type: "direct" };

const TIPOS = new Set(["direct", "http", "https", "socks", "socks4"]);

// Estado, reconstruible entero: nombre de contenedor → ProxyInfo ya validado.
let porNombre = new Map();
// cookieStoreId → ProxyInfo. Es el que consulta el listener; se recalcula cuando cambia cualquiera
// de los dos lados (la config o la lista de contenedores).
let porContenedor = new Map();

function aviso(msg, e) {
  console.error(`atuq/proxy: ${msg}${e ? ` — ${e}` : ""}`);
}

// ── VALIDACIÓN ────────────────────────────────────────────────────────────────────────────────
// Devuelve el ProxyInfo, o `null` si la entrada no sirve. Nunca «arregla» una entrada a medias:
// una entrada rota y una entrada ausente son cosas distintas y el llamador las trata distinto —la
// ausente es directo, la rota es el MURO—, así que confundirlas acá borraría esa diferencia.
function validar(entrada) {
  if (!entrada || typeof entrada !== "object") return null;
  const tipo = entrada.type;
  if (!TIPOS.has(tipo)) return null;
  if (tipo === "direct") return DIRECTO;
  const host = entrada.host;
  const port = Number(entrada.port);
  if (typeof host !== "string" || !host.trim()) return null;
  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
  const info = { type: tipo, host: host.trim(), port };
  // `proxyDNS` sólo existe para SOCKS, y NO es cosmético: sin él el navegador resuelve el nombre
  // por su cuenta ANTES de hablar con el proxy, así que la consulta DNS sale por la línea que se
  // quería evitar. Es la fuga clásica de este tipo de configuración; por eso el default es `true`
  // y hay que apagarlo a mano, no al revés.
  if (tipo === "socks" || tipo === "socks4") {
    info.proxyDNS = entrada.proxyDNS !== false;
  }
  return info;
}

// ── LA CONFIGURACIÓN: DOS CAPAS ───────────────────────────────────────────────────────────────
// `storage.managed` es la de FÁBRICA y la pone la distro por política (`3rdparty.Extensions` en
// `distribution/policies.json`); `storage.local` es la del USUARIO y pisa a la anterior por
// contenedor. Es la misma postura que `defaultPref` en `atuq.cfg`: la distro propone un arranque,
// no una cárcel.
//
// `storage.managed.get()` LANZA «Managed storage manifest not found» cuando no hay política —no
// devuelve vacío—, así que el catch no es decorativo: sin él, no tener política rompería la capa
// del usuario también.
async function leerConfig() {
  const fusion = new Map();
  const invalidas = [];

  const capas = [];
  try {
    capas.push(await browser.storage.managed.get("proxies"));
  } catch (e) {
    // Normal en un perfil sin política; se anota en la consola y se sigue.
    console.info(`atuq/proxy: sin configuración de fábrica (${e})`);
  }
  try {
    capas.push(await browser.storage.local.get("proxies"));
  } catch (e) {
    aviso("no pude leer storage.local", e);
  }

  for (const capa of capas) {
    const proxies = capa && capa.proxies;
    if (!proxies || typeof proxies !== "object") continue;
    for (const [nombre, entrada] of Object.entries(proxies)) {
      const info = validar(entrada);
      if (info) {
        fusion.set(nombre, info);
      } else {
        // Se RECUERDA la entrada rota en vez de ignorarla: el contenedor queda al MURO, que es lo
        // que la vuelve visible. Ignorarla lo dejaría saliendo directo, que es la fuga.
        fusion.set(nombre, MURO);
        invalidas.push(nombre);
      }
    }
  }
  if (invalidas.length) {
    aviso(`entradas inválidas, esos contenedores quedan al muro: ${invalidas.join(", ")}`);
  }
  return fusion;
}

// ── EL MAPA CONTRA LOS CONTENEDORES REALES ────────────────────────────────────────────────────
// La configuración se escribe por NOMBRE («Banco») y no por `cookieStoreId`
// («firefox-container-3»), por dos razones: el nombre es lo que el usuario ve y lo que la política
// de la distro declara, y el id depende del ORDEN en que se crearon los contenedores, o sea que la
// misma config aplicada a otro perfil apuntaría a otro contenedor. Un identificador que cambia de
// significado entre máquinas no sirve para configurar una distro.
async function reconstruir() {
  const mapa = new Map();
  let identidades = [];
  try {
    identidades = await browser.contextualIdentities.query({});
  } catch (e) {
    // Pasa si los contenedores están apagados (`privacy.userContext.enabled=false`). Sin
    // contenedores no hay nada que enrutar y el listener manda todo directo, que es correcto: no
    // hay tráfico «de un contenedor» que pueda fugarse.
    aviso("no pude listar los contenedores", e);
  }
  const sinContenedor = new Set(porNombre.keys());
  for (const id of identidades) {
    const info = porNombre.get(id.name);
    if (info) {
      mapa.set(id.cookieStoreId, info);
      sinContenedor.delete(id.name);
    }
  }
  porContenedor = mapa;
  if (sinContenedor.size) {
    // No es un error: se puede configurar un contenedor que todavía no existe. Pero es la causa
    // número uno de «configuré el proxy y no pasa nada», así que se dice por su nombre.
    console.info(
      `atuq/proxy: configurados sin contenedor que les corresponda: ${[...sinContenedor].join(", ")}`
    );
  }
  console.info(`atuq/proxy: ${mapa.size} contenedor(es) enrutado(s)`);
}

// `listo` es la promesa del arranque. El listener la espera: así no hay ventana en la que una
// petición temprana se resuelva con el mapa a medio llenar.
let listo = recargar();

async function recargar() {
  porNombre = await leerConfig();
  await reconstruir();
}

// ── EL LISTENER, REGISTRADO YA ────────────────────────────────────────────────────────────────
// Se registra en el primer tick, ANTES de que la configuración esté leída, y a propósito: si se
// registrara después del `await`, las peticiones de ese intervalo saldrían directas sin pasar por
// acá. Registrado desde el principio, esas peticiones simplemente esperan a `listo`.
//
// ⚠ Lo que esto NO cierra, dicho: las peticiones que Gecko haga ANTES de que la extensión arranque
// (arranque en frío, actualización de la extensión) no ven este listener. Es un límite del
// mecanismo de extensión, no de esta implementación; cerrarlo del todo exige que el ruteo viva en
// el motor. Se anota acá porque un límite que no está escrito se lee como que no existe.
browser.proxy.onRequest.addListener(
  async details => {
    try {
      await listo;
    } catch (e) {
      aviso("el arranque falló", e);
      // Si ni siquiera pudimos leer la configuración no sabemos si este contenedor tenía proxy ⇒
      // no se puede afirmar que salir directo sea seguro, pero tampoco se puede mandar al muro el
      // navegador entero. Se manda al muro sólo lo que tiene contenedor, que es de lo único que
      // alguien pudo haber pedido separación.
      return esDeContenedor(details) ? MURO : DIRECTO;
    }
    const id = details.cookieStoreId;
    if (!id) return DIRECTO;
    return porContenedor.get(id) || DIRECTO;
  },
  { urls: ["<all_urls>"] }
);

function esDeContenedor(details) {
  return typeof details.cookieStoreId === "string" && details.cookieStoreId.startsWith("firefox-container-");
}

// `onError` es lo que convierte «no anda» en un mensaje. Sin esto, un fallo del propio resolvedor
// de proxy no aparece en ningún lado.
browser.proxy.onError.addListener(e => aviso("el resolvedor falló", e));

// Los contenedores se crean, se renombran y se borran en caliente, y la config está indexada por
// NOMBRE ⇒ renombrar uno cambia a qué proxy corresponde. Se reconstruye el mapa en los tres casos.
for (const ev of ["onCreated", "onUpdated", "onRemoved"]) {
  browser.contextualIdentities[ev].addListener(() => {
    listo = reconstruir();
  });
}

// La página de opciones escribe en `storage.local`; esto es lo que hace que el cambio valga sin
// reiniciar el navegador.
browser.storage.onChanged.addListener((cambios, area) => {
  if (area === "local" && "proxies" in cambios) {
    listo = recargar();
  }
});