Navegador multicuenta: identidades aisladas

Introducción

Ejecutar múltiples cuentas o identidades dentro de un solo navegador es uno de los requisitos de privacidad más comunes. Ya sea que gestiones cuentas de redes sociales, pruebes contenido localizado en diferentes regiones o ejecutes sesiones de investigación en paralelo, cada identidad necesita ser verdaderamente independiente. Las cookies compartidas, señales de huella digital o rutas de red entre identidades comprometen el aislamiento.

BotBrowser proporciona un verdadero aislamiento por contexto donde cada contexto del navegador tiene sus propias señales de huella digital, proxy, configuración geográfica, cookies y almacenamiento. Este artículo cubre la arquitectura del modelo de aislamiento de BotBrowser, los enfoques de configuración tanto para Playwright como para Puppeteer, y las mejores prácticas para mantener una separación de identidades limpia.

Impacto en la privacidad

Cuando múltiples identidades comparten cualquier aspecto de su entorno de navegación, la correlación se vuelve posible. Los riesgos incluyen:

• Direcciones IP compartidas: si dos cuentas usan el mismo proxy, su tráfico puede vincularse por IP
• Superposición de huellas digitales: si dos contextos comparten valores de Canvas, WebGL o huella de audio, pueden identificarse como provenientes del mismo navegador
• Fugas de cookies y almacenamiento: las cookies o localStorage compartidos entre contextos vinculan directamente las identidades
• Inconsistencia geográfica: una cuenta que dice estar en Alemania pero comparte una zona horaria con una cuenta de EE.UU. revela el entorno compartido
• Correlación temporal: las cuentas que siempre están activas al mismo tiempo desde la misma instancia del navegador pueden vincularse a través de patrones de actividad

El verdadero aislamiento requiere independencia en todas estas dimensiones. El aislamiento por contexto de BotBrowser aborda cada una de ellas.

Contexto técnico

Contextos del navegador y límites de aislamiento

En los navegadores basados en Chromium, un contexto del navegador es un entorno de navegación aislado. Cada contexto tiene su propio:

• Almacén de cookies
• localStorage y sessionStorage
• IndexedDB
• Cache storage
• Service workers
• Credenciales de autenticación HTTP

Chromium estándar proporciona este aislamiento de almacenamiento de forma nativa. Sin embargo, muchas señales de huella digital se comparten entre contextos porque provienen del hardware y el sistema operativo: el renderizado de Canvas, las cadenas de vendor/renderer de WebGL, las características de procesamiento de audio, las dimensiones de pantalla y las propiedades del navigator son idénticas en todos los contextos de un navegador estándar.

Aislamiento extendido de BotBrowser

BotBrowser extiende el límite de aislamiento más allá del almacenamiento para incluir señales de huella digital. Cuando BotBrowser carga un perfil, configura las señales de huella digital a nivel del motor. Combinado con el soporte de proxy por contexto, cada contexto puede presentar:

• Señales de huella digital únicas: diferentes hashes de Canvas, cadenas de renderer de WebGL, huellas de audio y propiedades del navigator
• Identidad de red independiente: diferente IP de proxy, con alineación geográfica automática
• Almacenamiento aislado: aislamiento de contexto estándar de Chromium para cookies, localStorage e IndexedDB
• Metadatos geográficos coincidentes: zona horaria, locale e idioma alineados con el proxy del contexto

Instancia única vs. múltiples instancias

Existen dos enfoques para la operación multiidentidad:

Una sola instancia del navegador con múltiples contextos (Playwright): un proceso del navegador ejecuta múltiples contextos. Cada contexto puede tener su propio proxy. BotBrowser proporciona aislamiento de huella digital por contexto dentro de esta única instancia.

Múltiples instancias del navegador (Playwright o Puppeteer): cada instancia es un proceso del navegador separado con su propio perfil, proxy y directorio de datos de usuario. Esto proporciona el aislamiento más fuerte porque las instancias no comparten nada a nivel de proceso.

Ambos enfoques son válidos. La multicontexto de instancia única es más eficiente en recursos. Las múltiples instancias proporcionan un aislamiento más fuerte a costa de un mayor uso de recursos.

Enfoques comunes y sus limitaciones

Directorios de perfil del navegador

Los navegadores estándar usan directorios de perfil para separar identidades. Cada perfil tiene sus propias cookies y marcadores pero comparte la misma huella digital del navegador. Las señales de Canvas, WebGL, audio y navigator son idénticas entre perfiles porque provienen del mismo hardware.

Pestañas contenedoras (Firefox)

Los contenedores multicuenta de Firefox aíslan cookies y almacenamiento por contenedor. Sin embargo, las señales de huella digital se comparten. Todos los contenedores reportan el mismo hash de Canvas, renderer de WebGL y huella de audio.

Instalaciones de navegador separadas

Ejecutar instalaciones de navegador completamente separadas (diferentes rutas de binario, diferentes directorios de datos de usuario) proporciona un aislamiento fuerte pero es operacionalmente costoso. Cada instalación necesita su propio ciclo de actualización y no hay gestión centralizada.

Máquinas virtuales

Las VMs proporcionan el aislamiento más fuerte: sistema operativo separado, perfil de hardware separado, pila de red separada. Pero las VMs consumen muchos recursos. Ejecutar 10 identidades significa ejecutar 10 VMs, cada una consumiendo gigabytes de RAM y CPU significativa.

Enfoque de BotBrowser

Aislamiento de huella digital por contexto

BotBrowser proporciona aislamiento de huella digital por contexto a través de su sistema de perfiles. Cada instancia del navegador carga un perfil que define la huella digital. Para configuraciones de múltiples instancias, cada una puede cargar un perfil diferente:

# Instancia 1: identidad US con Perfil A
chrome --bot-profile="/profiles/profile-a.enc" \
       --proxy-server="socks5://us-proxy:1080" \
       --user-data-dir="/tmp/session-us"

# Instancia 2: identidad DE con Perfil B
chrome --bot-profile="/profiles/profile-b.enc" \
       --proxy-server="socks5://de-proxy:1080" \
       --user-data-dir="/tmp/session-de"

Cada instancia reporta diferentes hashes de Canvas, cadenas de renderer de WebGL, huellas de audio, propiedades del navigator, dimensiones de pantalla y disponibilidad de fuentes.

Configuración multicontexto con Playwright

Para aislamiento por contexto dentro de una sola instancia del navegador:

const { chromium } = require('playwright-core');

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-local-dns',
    '--bot-webrtc-ice=google',
  ],
  headless: true,
});

// Contexto 1: identidad US
const usContext = await browser.newContext({
  proxy: { server: 'socks5://us-proxy:1080', username: 'user', password: 'pass' },
  locale: 'en-US',
  timezoneId: 'America/New_York',
});

// Contexto 2: identidad UK
const ukContext = await browser.newContext({
  proxy: { server: 'socks5://uk-proxy:1080', username: 'user', password: 'pass' },
  locale: 'en-GB',
  timezoneId: 'Europe/London',
});

// Contexto 3: identidad Japón
const jpContext = await browser.newContext({
  proxy: { server: 'socks5://jp-proxy:1080', username: 'user', password: 'pass' },
  locale: 'ja-JP',
  timezoneId: 'Asia/Tokyo',
});

const page1 = await usContext.newPage();
const page2 = await ukContext.newPage();
const page3 = await jpContext.newPage();

Configuración multi-instancia con Puppeteer

Puppeteer funciona mejor con instancias de navegador separadas para un aislamiento completo de huella digital:

const puppeteer = require('puppeteer-core');

async function createIdentity(profile, proxy, timezone, locale, languages) {
  const userDataDir = '/tmp/session-' + Math.random().toString(36).slice(2);
  return puppeteer.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      `--bot-profile=${profile}`,
      `--proxy-server=${proxy}`,
      `--bot-config-timezone=${timezone}`,
      `--bot-config-locale=${locale}`,
      `--bot-config-languages=${languages}`,
      `--user-data-dir=${userDataDir}`,
      '--bot-local-dns',
      '--bot-webrtc-ice=google',
    ],
    headless: true,
    defaultViewport: null,
  });
}

const usBrowser = await createIdentity(
  '/profiles/us.enc', 'socks5://us-proxy:1080',
  'America/New_York', 'en-US', 'en-US,en'
);

const deBrowser = await createIdentity(
  '/profiles/de.enc', 'socks5://de-proxy:1080',
  'Europe/Berlin', 'de-DE', 'de-DE,de,en'
);

Seeds de ruido determinísticos para consistencia

Usa diferentes valores de --bot-noise-seed por identidad para producir ruido de huella digital consistente pero único:

# Identidad A
chrome --bot-profile="/profiles/profile.enc" \
       --bot-noise-seed=12345 \
       --proxy-server="socks5://proxy-a:1080"

# Identidad B (mismo perfil, diferente noise seed = diferente ruido de huella)
chrome --bot-profile="/profiles/profile.enc" \
       --bot-noise-seed=67890 \
       --proxy-server="socks5://proxy-b:1080"

Cada seed produce un patrón de ruido único y estable. El mismo seed siempre produce el mismo ruido, haciendo las identidades reproducibles entre sesiones.

Configuración y uso

Configuración completa multiidentidad (CLI)

# Identidad 1: usuario Chrome en EE.UU.
chrome --bot-profile="/profiles/us-chrome.enc" \
       --proxy-server="socks5://user:pass@us-proxy:1080" \
       --bot-config-timezone="America/New_York" \
       --bot-config-locale="en-US" \
       --bot-config-languages="en-US,en" \
       --bot-noise-seed=11111 \
       --bot-local-dns \
       --bot-webrtc-ice=google \
       --bot-port-protection \
       --user-data-dir="/data/session-us"

# Identidad 2: usuario Edge en Alemania
chrome --bot-profile="/profiles/de-edge.enc" \
       --bot-config-browser-brand=edge \
       --proxy-server="socks5://user:pass@de-proxy:1080" \
       --bot-config-timezone="Europe/Berlin" \
       --bot-config-locale="de-DE" \
       --bot-config-languages="de-DE,de,en" \
       --bot-noise-seed=22222 \
       --bot-local-dns \
       --bot-webrtc-ice=google \
       --bot-port-protection \
       --user-data-dir="/data/session-de"

Multiidentidad escalada con Playwright

const { chromium } = require('playwright-core');

const identities = [
  {
    name: 'us-user',
    proxy: 'socks5://us-proxy:1080',
    locale: 'en-US',
    timezone: 'America/New_York',
  },
  {
    name: 'uk-user',
    proxy: 'socks5://uk-proxy:1080',
    locale: 'en-GB',
    timezone: 'Europe/London',
  },
  {
    name: 'jp-user',
    proxy: 'socks5://jp-proxy:1080',
    locale: 'ja-JP',
    timezone: 'Asia/Tokyo',
  },
];

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-local-dns',
    '--bot-webrtc-ice=google',
  ],
  headless: true,
});

for (const identity of identities) {
  const context = await browser.newContext({
    proxy: { server: identity.proxy, username: 'user', password: 'pass' },
    locale: identity.locale,
    timezoneId: identity.timezone,
  });

  const page = await context.newPage();
  await page.goto('https://example.com');
  console.log(`${identity.name}: loaded`);
  // Realizar tareas específicas de la identidad...
}

Verificación

Después de configurar múltiples identidades, verifica el aislamiento en todas las dimensiones:

async function verifyIdentity(context, label) {
  const page = await context.newPage();

  // Verificar IP
  await page.goto('https://httpbin.org/ip');
  const ip = JSON.parse(await page.textContent('body'));
  console.log(`${label} IP:`, ip.origin);

  // Verificar zona horaria
  const tz = await page.evaluate(() =>
    Intl.DateTimeFormat().resolvedOptions().timeZone
  );
  console.log(`${label} Timezone:`, tz);

  // Verificar hash de Canvas
  const canvasHash = await page.evaluate(() => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    ctx.fillText('test', 10, 10);
    return canvas.toDataURL().slice(-20);
  });
  console.log(`${label} Canvas:`, canvasHash);

  // Verificar renderer de WebGL
  const renderer = await page.evaluate(() => {
    const canvas = document.createElement('canvas');
    const gl = canvas.getContext('webgl');
    const ext = gl.getExtension('WEBGL_debug_renderer_info');
    return ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : 'N/A';
  });
  console.log(`${label} WebGL:`, renderer);

  await page.close();
}

await verifyIdentity(usContext, 'US');
await verifyIdentity(ukContext, 'UK');
await verifyIdentity(jpContext, 'JP');

Confirma que cada identidad muestra:

1. Una dirección IP diferente
2. Una zona horaria diferente que coincida con la región de su proxy
3. Diferentes hashes de Canvas (al usar diferentes perfiles o noise seeds)
4. Diferentes cadenas de renderer de WebGL (al usar diferentes perfiles)
5. Sin cookies ni almacenamiento compartido entre contextos

Mejores prácticas

1. Usa perfiles separados para identidades separadas. Si bien los noise seeds crean variación dentro de un perfil, los perfiles separados proporcionan el aislamiento de huella digital más fuerte.

2. Siempre haz coincidir la geografía del proxy con el locale. Un locale japonés con un proxy de EE.UU. crea una inconsistencia obvia.

3. Usa directorios de datos de usuario separados. Cada instancia necesita su propio --user-data-dir para prevenir conflictos de datos de perfil.

4. Habilita la protección de DNS y WebRTC globalmente. Establece --bot-local-dns y --bot-webrtc-ice en cada instancia para cerrar las vías de fuga de red.

5. Cierra los contextos cuando ya no sean necesarios. Los contextos abiertos consumen memoria. Ciérralos para liberar recursos.

6. No compartas cookies entre identidades. Cada identidad debe tener su propio estado de cookies. Nunca transfieras cookies de un contexto a otro.

Preguntas frecuentes

¿Cuántas identidades puedo ejecutar simultáneamente? No hay un límite estricto. El aislamiento por contexto dentro de una sola instancia del navegador es eficiente en memoria. En la práctica, el límite depende de la RAM disponible y la complejidad de las páginas cargadas en cada contexto.

¿Puedo usar el mismo perfil para múltiples identidades? Sí, cuando se combina con diferentes valores de --bot-noise-seed. El noise seed cambia el ruido de las huellas de Canvas, WebGL y audio, creando identidades distintas a partir del mismo perfil base.

¿Los contextos comparten la caché del navegador? No. Cada contexto tiene su propia caché, cookies, localStorage e IndexedDB. No hay intercambio de datos entre contextos.

¿Debería usar Playwright o Puppeteer para configuraciones multiidentidad? Playwright proporciona soporte nativo de proxy por contexto, lo que lo convierte en la mejor opción para configuraciones multicontexto dentro de una sola instancia del navegador. Puppeteer funciona mejor con instancias de navegador separadas por identidad.

¿Puedo persistir el estado de la identidad entre sesiones? Sí. Usa --user-data-dir con un directorio persistente para conservar cookies, caché y almacenamiento entre sesiones. Cada identidad debe usar un directorio separado.

¿Cómo manejo diferentes marcas de navegador entre identidades? Usa --bot-config-browser-brand para establecer diferentes marcas por instancia. Consulta Cambio de marca de navegador para más detalles.

¿El aislamiento por contexto protege contra la huella digital de GPU? BotBrowser controla las señales de WebGL y WebGPU a través de perfiles. Cada perfil reporta diferentes valores relacionados con la GPU. El aislamiento por contexto asegura que estos valores sean consistentes dentro de cada contexto.

Resumen

El aislamiento multicuenta del navegador requiere independencia en las señales de huella digital, la identidad de red, los metadatos geográficos y el almacenamiento. BotBrowser proporciona todo esto a través de su sistema de perfiles, soporte de proxy por contexto y control de huella digital a nivel del motor. Ya sea que uses el enfoque multicontexto de Playwright o el enfoque multi-instancia de Puppeteer, cada identidad presenta un entorno de navegador completo e independiente.

Para la configuración de proxy, consulta Configuración de proxy y Cambio dinámico de proxy. Para la configuración geográfica, consulta Configuración de zona horaria, locale e idioma. Para la identidad de marca, consulta Cambio de marca de navegador.