In this Article
La huella digital WebGL es una técnica de identificación ampliamente utilizada por los sistemas antibot para detectar actividades automatizadas. Como utiliza señales a nivel de hardware, es bastante difícil de manejar, lo que supone otro desafío para quienes dependen del web scraping con fines comerciales. Sin embargo, existen formas de mantener un perfil bajo y recopilar datos: sigue leyendo para obtener más información.
Qué es WebGL: una explicación detallada
WebGL significa Web Graphics Library, que es una API de JavaScript. Los navegadores la usan para mostrar gráficos dinámicos 2D y 3D sin requerir la instalación de plugins. Para realizar estas tareas de renderizado, la API depende en gran medida de la GPU, o unidad de procesamiento gráfico. Hoy en día, los sitios web utilizan WebGL ampliamente para efectos visuales, juegos e interfaces gráficas complejas. De hecho, WebGL 2 ahora está ganando terreno activamente, ya que ofrece más funciones. Los navegadores modernos, como Chrome, Edge y Safari, tienen un soporte de WebGL 2 del 95-99%, mientras que los navegadores más antiguos y headless aún carecen de él.
Como hay cientos de GPU disponibles e incluso los modelos del mismo fabricante difieren drásticamente, la misma imagen se renderizaría de manera diferente. Además, el navegador, los controladores instalados e incluso las variaciones de hardware, como la forma en que la GPU y la placa base están conectadas, también influirían en el resultado. Es como visitar una tienda de tecnología para el hogar y ver varias docenas de televisores en exhibición, todos mostrando el mismo anuncio, pero con imágenes ligeramente diferentes. Esto se convirtió en la base de la huella digital WebGL. Ten en cuenta que la huella digital WebGL solo ocurre cuando interviene JavaScript. Una página HTML estática no puede realizarla.
Huella digital WebGL: resumen paso a paso
En términos generales, todo el proceso se ve así:
- Un sitio web crea un elemento <canvas>, que está oculto en el HTML de una página. Inicializa el entorno de renderizado WebGL.
- JavaScript usa llamadas gl.getParameter() para extraer características de la GPU, como el proveedor y el modelo.
- Un script de huella digital requiere que un navegador renderice una imagen de prueba, y se usa readPixels() para extraer datos de píxeles.
Puedes visitar BrowserLeaks, hacer clic en WebGL Report y ver tu huella digital única. Se ve así:
A continuación, encontrará un ejemplo de un script que usan los sitios web. También puede usarlo con fines de prueba, como diagnósticos, informes de errores, pruebas de compatibilidad y más. Recuerde ejecutar el script en dispositivos de su propiedad o estrictamente después de recibir consentimiento explícito. Evite usar el script para rastreo o desanonimización. Trate los resultados como datos sensibles y no los comparta con terceros a menos que obtenga permiso. DataImpulse no asume responsabilidad por el uso ilegal del script.
Paso 1. Inicie el entorno WebGL
// Lightweight FNV-1a hash for strings/byte arrays (synchronous, simple)
function fnv1aHashFromBytes(bytes) {
let h = 0x811c9dc5 >>> 0;
for (let i = 0; i < bytes.length; i++) {
h ^= bytes[i];
// multiply by FNV prime (mod 2^32)
h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
}
return ('00000000' + (h >>> 0).toString(16)).slice(-8);
}
function fnv1aHashFromString(s) {
const bytes = new Uint8Array(s.length);
for (let i = 0; i < s.length; i++) bytes[i] = s.charCodeAt(i) & 0xff;
return fnv1aHashFromBytes(bytes);
}
// Create an (optionally hidden) canvas and return WebGLRenderingContext / WebGL2RenderingContext
function createWebGLContext(opts = {webgl2Preferred: true, preserveDrawingBuffer: false}) {
const canvas = document.createElement('canvas');
canvas.width = 256; canvas.height = 256;
// optionally keep canvas off-DOM so it stays invisible
canvas.style.display = 'none';
document.body && document.body.appendChild(canvas); // append only if available
let gl = null;
if (opts.webgl2Preferred) {
try { gl = canvas.getContext('webgl2', {preserveDrawingBuffer: opts.preserveDrawingBuffer}); } catch (e) {}
}
if (!gl) {
try { gl = canvas.getContext('webgl', {preserveDrawingBuffer: opts.preserveDrawingBuffer}) || canvas.getContext('experimental-webgl'); } catch (e) {}
}
return {gl, canvas};
}
Este fragmento crea un lienzo invisible que se ejecuta en segundo plano mientras navegas y define su resolución. Además, si WebGL 2 no es compatible, recurrirá sin problemas a WebGL.
Paso 2. Obtener información del hardware
function getWebGLHardwareInfo(gl) {
const info = {};
// Standard parameters
info.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
info.maxCombinedTextureImageUnits = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
info.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
info.maxVertexUniformVectors = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS);
info.maxFragmentUniformVectors = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);
info.shaderPrecision = {
vertexHighFloat: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT),
fragmentHighFloat: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT)
};
// Try to get unmasked renderer/vendor (if browser exposes WEBGL_debug_renderer_info)
const dbg = gl.getExtension('WEBGL_debug_renderer_info');
if (dbg) {
info.unmaskedVendor = gl.getParameter(dbg.UNMASKED_VENDOR_WEBGL);
info.unmaskedRenderer = gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL);
} else {
info.unmaskedVendor = null;
info.unmaskedRenderer = null;
}
// Extensions list (useful fingerprinting signal)
info.extensions = gl.getSupportedExtensions() || [];
// Anisotropy (if available)
const extAniso = gl.getExtension('EXT_texture_filter_anisotropic') ||
gl.getExtension('MOZ_EXT_texture_filter_anisotropic') ||
gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic');
if (extAniso) {
const maxAniso = gl.getParameter(extAniso.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
info.maxAnisotropy = maxAniso;
}
return info;
}
Recopila varios detalles como el proveedor, el modelo, el tamaño de la memoria, el tamaño máximo de textura, los límites uniformes de sombreadores, las extensiones WebGL compatibles y otros datos sobre tu GPU.
Paso 3. Sondear las precisiones de sombreadores
function probeShaderPrecisions(gl) {
const precisions = {};
const shaderTypes = [
{type: gl.VERTEX_SHADER, name: 'vertex'},
{type: gl.FRAGMENT_SHADER, name: 'fragment'}
];
const levels = [{p: gl.LOW_FLOAT, name: 'low'}, {p: gl.MEDIUM_FLOAT, name: 'medium'}, {p: gl.HIGH_FLOAT, name: 'high'}];
for (const sh of shaderTypes) {
precisions[sh.name] = {};
for (const lv of levels) {
const pf = gl.getShaderPrecisionFormat(sh.type, lv.p);
precisions[sh.name][lv.name] = {rangeMin: pf.rangeMin, rangeMax: pf.rangeMax, precision: pf.precision};
}
}
return precisions;
}
Luego, los sitios web le preguntan a la GPU qué niveles de precisión son compatibles con las operaciones de punto flotante y los sombreadores de fragmentos, y registran sus rangos numéricos.
Ahora que un script terminó de recopilar información de hardware y software, continúa con el siguiente paso: la renderización de imágenes.
Paso 4. Renderización de la escena de prueba
// Simple shader pair: position-only vertex shader and color-fragment that depends on coords
const VERT = `#version 300 es
in vec2 a_pos;
out vec2 v_uv;
void main() {
v_uv = a_pos * 0.5 + 0.5;
gl_Position = vec4(a_pos, 0.0, 1.0);
}`;
const FRAG = `#version 300 es
precision highp float;
in vec2 v_uv;
out vec4 outColor;
void main() {
// deterministic function of coordinates that will exercise GPU math
float r = sin(v_uv.x * 123.456) * 0.5 + 0.5;
float g = cos(v_uv.y * 78.9) * 0.5 + 0.5;
float b = fract((v_uv.x + v_uv.y) * 9876.54321);
outColor = vec4(r, g, b, 1.0);
}`;
function createProgramWebGL2(gl, vertSrc, fragSrc) {
function compile(src, type) {
const s = gl.createShader(type);
gl.shaderSource(s, src);
gl.compileShader(s);
if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
const err = gl.getShaderInfoLog(s);
gl.deleteShader(s);
throw new Error('Shader compile error: ' + err);
}
return s;
}
const vs = compile(vertSrc, gl.VERTEX_SHADER);
const fs = compile(fragSrc, gl.FRAGMENT_SHADER);
const program = gl.createProgram();
gl.attachShader(program, vs);
gl.attachShader(program, fs);
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
const err = gl.getProgramInfoLog(program);
throw new Error('Program link error: ' + err);
}
gl.deleteShader(vs);
gl.deleteShader(fs);
return program;
}
function renderTestAndHash(gl, canvas) {
const isWebGL2 = typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext;
if (!isWebGL2) {
// For WebGL1 we'd need slightly different shaders (no #version, use attribute/varying)
// but the concept is the same. For clarity this example uses WebGL2 if available.
console.warn('Example uses WebGL2 for deterministic shader pipeline; falling back may require shader edits.');
}
// Create program & buffer
const prog = createProgramWebGL2(gl, VERT, FRAG);
gl.useProgram(prog);
const posLoc = gl.getAttribLocation(prog, 'a_pos');
const quad = new Float32Array([
-1, -1,
1, -1,
-1, 1,
1, 1
]);
const vb = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vb);
gl.bufferData(gl.ARRAY_BUFFER, quad, gl.STATIC_DRAW);
gl.enableVertexAttribArray(posLoc);
gl.vertexAttribPointer(posLoc, 2, gl.FLOAT, false, 0, 0);
// Render to the canvas
gl.viewport(0, 0, canvas.width, canvas.height);
gl.clearColor(0,0,0,1);
gl.clear(gl.COLOR_BUFFER_BIT);
const t0 = performance.now();
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
gl.finish(); // ensure rendering completes
const t1 = performance.now();
const renderTime = t1 - t0; // render timing in ms
// Read pixels
const px = new Uint8Array(canvas.width * canvas.height * 4);
gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, px);
const pixelHash = fnv1aHashFromBytes(px);
// Clean up (optional)
gl.deleteBuffer(vb);
gl.deleteProgram(prog);
return {pixelHash, renderTime};
}
El script le pide a tu navegador que muestre una escena 2D o 3D que puede contener tonos, degradados o efectos específicos. Luego lee los bytes de píxeles y obtiene información sobre los colores de los píxeles, la textura de la imagen, el sombreado y los degradados, calcula un hash de esos valores y mide el tiempo de renderizado.
Paso 5. Combinar datos en una huella digital
function collectWebGLFingerprint(opts = {}) {
const {gl, canvas} = createWebGLContext({webgl2Preferred: true, preserveDrawingBuffer: true});
if (!gl) throw new Error('No WebGL available');
const hw = getWebGLHardwareInfo(gl);
const precisions = probeShaderPrecisions(gl);
// optional: probe more capabilities
const supportsFloatTextures = !!gl.getExtension('OES_texture_float') || !!gl.getExtension('EXT_color_buffer_float');
// Render test and get pixel hash + timing
const {pixelHash, renderTime} = renderTestAndHash(gl, canvas);
// Combine into a fingerprint string
const parts = [
navigator.userAgent || '',
hw.unmaskedVendor || '',
hw.unmaskedRenderer || '',
hw.maxTextureSize,
hw.maxCombinedTextureImageUnits,
hw.maxVertexAttribs,
supportsFloatTextures ? 'floatTex' : '',
hw.extensions ? hw.extensions.join(',') : '',
JSON.stringify(precisions),
pixelHash,
String(Math.round(renderTime)) // include rounded render time
];
const raw = parts.join('|');
const fingerprint = fnv1aHashFromString(raw);
// Return a readable object
return {
fingerprint,
raw,
components: {
ua: navigator.userAgent,
hardware: hw,
precisions,
pixelHash,
renderTime
}
};
}
// Example usage:
try {
const fp = collectWebGLFingerprint();
console.log('WebGL fingerprint:', fp.fingerprint);
console.log('Components:', fp.components);
} catch (e) {
console.error('Could not collect WebGL fingerprint:', e);
}
Finalmente, el script llama a todos los pasos anteriores, combina todos los datos obtenidos en una única cadena larga y vuelve a aplicarle hash para crear un ID de huella digital más compacto y utilizable.
Todo este proceso ocurre en milisegundos y permanece invisible para ti. Después de recopilar tus huellas digitales, los sitios web las almacenan y las comparan con bases de datos internas o las envían a servicios anti-bot para su análisis. Si una huella digital coincide con un bot conocido o un usuario sospechoso, corres el riesgo de recibir un bloqueo.
Desafíos de la suplantación de WebGL
Hay varias razones por las que alinearse con las pautas de tráfico puede ser complicado.
- Las diferencias en el comportamiento de renderizado de la GPU pueden ser invisibles para el ojo humano, pero son evidentes para los sitios web y se mantienen consistentes entre páginas. Borrar las cookies o usar el modo incógnito no ayuda.
- El renderizado depende de datos provenientes del hardware físico, lo cual queda fuera del alcance de las modificaciones de JavaScript y las extensiones del navegador.
- Puedes cambiar los parámetros de WebGL cada vez que cargas una página; sin embargo, si afirmas que tu GPU es Intel, pero renderiza como NVIDIA, los sitios web detectarán la inconsistencia, y esto es suficiente para activar los sistemas anti-bot.
- La mayoría de los sistemas de detección modernos detectarán los intentos de manipular la API de WebGL.
¿Significa esto que no hay forma de superar la huella digital de WebGL? No, existen varias técnicas que realmente funcionan. Sin embargo, vayamos por partes.
¿Es legal suplantar una huella digital de WebGL?
Tienes derecho a proteger tu privacidad, por lo que es incorrecto decir que suplantar una huella digital de WebGL es ilegal. También se utiliza con fines de prueba. Sin embargo, depender de la suplantación para cometer fraude o violar los Términos de Servicio de los sitios web va contra la ley. Siempre debes leer los ToS y evitar cualquier acción ilegal que pueda perjudicar la privacidad de otras partes. La información adicional se proporciona únicamente con fines educativos. DataImpulse no te alienta a tomar ninguna acción y no asume responsabilidad por posibles resultados.
Formas comprobadas de suplantar huellas digitales de WebGL
- Usa navegadores headless con bibliotecas adicionales
Herramientas populares como Playwright o Selenium, respaldadas por herramientas como Playwright Stealth o Undetected Chrome Driver, pueden modificar ligeramente parámetros como el tamaño de pantalla y otros. Sin embargo, debes tener cuidado para que las variables falsas y las imágenes renderizadas coincidan entre sí. Este método no funcionará con proyectos a gran escala ni al intentar extraer datos de sitios web que usan el algoritmo de detección de bots más reciente. Lo mismo aplica para extensiones de navegador como WebGL Fingerprint Defender o CanvasBlocker. Interceptan llamadas a la API de WebGL y devuelven datos alterados, pero la imagen renderizada aún podría no coincidir con ellos.
- Opta por la virtualización de GPU
Puedes hacer que la GPU y/o los controladores del navegador parezcan diferentes de una GPU física real. Hay varios enfoques que puedes adoptar, por ejemplo, reemplazar una GPU real por un renderizador de software como Switch Shader o usar máquinas virtuales con diversos controladores de GPU. Por otro lado, si tu presupuesto es ajustado o no tienes habilidades técnicas sólidas, piénsalo dos veces antes de adoptar esos métodos. Además, escalar tus proyectos de scraping puede ser una tarea desafiante.
- Solicita APIs estáticas
Este método funciona si extraes datos públicos y el sitio web objetivo proporciona una API pública u oculta que devuelve JSON. En sitios web dinámicos protegidos, esa no es una opción, pero en otros casos es una alternativa que merece atención, ya que los endpoints de API generalmente están menos protegidos.
- Desactiva WebGL
Desactivar WebGL corta todas las señales principales de huella digital de WebGL (vendor/renderer, extensions, precision, pixel hashes, render timings).
Cómo desactivar WebGL
Chrome
Método 1 – mediante Chrome Flags:
En la barra de direcciones, escribe chrome://flags, presiona Enter y selecciona “Disable WebGL” o –disable-webgl. Configura la flag como “Disabled”. Para activar los cambios, reinicia Chrome.
Método 2 – mediante la línea de comandos:
Haz clic derecho en el ícono de Google Chrome y ve a “Properties”. Busca la línea “Target”. Debería terminar con algo como chrome.exe. Al final de la línea, agrega un espacio y escribe –disable-webgl. Haz clic en “Apply” >”OK”.
Firefox
En la barra de direcciones, escribe about:config y presiona Enter. Si aparece una advertencia, acéptala. Busca webgl.disable. Haz doble clic y establece su valor en true.
Safari
Ve a las preferencias de Safari, abre la pestaña “Advanced” y selecciona “Develop” (si está disponible). Navega a Experimental Features y encuentra la opción de WebGL via Metal. Desmarca la casilla y reinicia el navegador.
Sin embargo, ten cuidado, ya que muchos sitios web pueden dejar de funcionar correctamente con WebGL desactivado.
Explotar vulnerabilidades de la huella digital de WebGL
Puedes usar algunos pequeños trucos. Por ejemplo, los scripts suelen almacenar resultados en caché y reutilizarlos en lugar de recalcularlos desde cero. Puedes detectarlo y cambiar tu entorno antes de que se reutilice la caché (para evitar que te vinculen con una identidad registrada anteriormente) o hacer que un sitio recalcule un valor.
Detector:
// Helper: run the fingerprinting routine and return {time, result}
async function runFingerprintTrial(triggerFn) {
const t0 = performance.now();
const result = await triggerFn(); // should return fingerprint/hash if available
const time = performance.now() - t0;
return { time, result };
}
async function detectCachingRobust(triggerFingerprinting, trials = 5) {
const runs = [];
for (let i = 0; i < trials; i++) {
// small delay to reduce micro-scheduling bias
if (i > 0) await new Promise(r => setTimeout(r, 30));
runs.push(await runFingerprintTrial(triggerFingerprinting));
}
// compute median time
const times = runs.map(r => r.time).sort((a,b) => a-b);
const medianTime = times[Math.floor(times.length/2)];
// compare first vs median of later runs
const firstTime = runs[0].time;
const laterMedian = times.slice(1).length ? times.slice(1)[Math.floor((times.length-1)/2)] : medianTime;
// check result stability (if trigger returns a fingerprint/hash)
const results = runs.map(r => r.result);
const allSame = results.every(x => x === results[0]);
// simple heuristic: if first run is much slower *and* results identical, likely cached
const speedRatio = firstTime / (laterMedian || 1);
const likelyCached = (speedRatio > 5) && allSame;
return {
runs,
medianTime,
firstTime,
laterMedian,
speedRatio,
results,
allSame,
likelyCached
};
}
Forzar un entorno nuevo:
function newWebGLContext(w=256,h=256) {
const c = document.createElement('canvas');
c.width = w; c.height = h;
const gl = c.getContext('webgl2') || c.getContext('webgl') || c.getContext('experimental-webgl');
return {c, gl};
}
Forzar recálculo:
localStorage.removeItem('fp_token'); // only if you can identify it
// or flush likely storage (be careful: may break site)
localStorage.clear();
indexedDB.deleteDatabase('site-db-name'); // needs precise names
Otro enfoque es detectar cuándo una página agrega un script de fingerprinting y ejecutar previamente un script de spoofing. Sin embargo, ten en cuenta que esto se detecta fácilmente y puede alterar el comportamiento de la página; este método es más adecuado para pruebas o fines defensivos.
// Robust script interception (best run at document_start)
(function() {
if (window.__scriptInterceptorInstalled) return;
window.__scriptInterceptorInstalled = true;
// Your spoofing routine — define this to patch WebGL or other APIs.
function injectSpoofing() {
try {
// Example: block debug info (replace with your real routine)
const origGetExt = WebGLRenderingContext.prototype.getExtension;
WebGLRenderingContext.prototype.getExtension = function(name) {
if (name === 'WEBGL_debug_renderer_info') return null;
return origGetExt.call(this, name);
};
// mark that spoofing ran
window.__spoofingInjected = true;
} catch (e) {
// swallow errors — don't break page
console.error('injectSpoofing error', e);
}
}
// Helper: decide whether a script looks like fingerprinting (tweak to match)
function looksLikeFingerprintScript(srcOrContent) {
if (!srcOrContent) return false;
const s = String(srcOrContent).toLowerCase();
return s.includes('fingerprint') || s.includes('fingerprinting') || s.includes('fingerprintjs') || s.includes('fingerprint2');
}
// 1) Hook HTMLScriptElement.prototype.src property (setter)
try {
const proto = HTMLScriptElement.prototype;
const srcDesc = Object.getOwnPropertyDescriptor(proto, 'src');
if (srcDesc && srcDesc.configurable) {
Object.defineProperty(proto, 'src', {
configurable: true,
enumerable: srcDesc.enumerable,
get: function() { return srcDesc.get.call(this); },
set: function(val) {
try {
// If the script's src looks suspicious, inject before setting
if (looksLikeFingerprintScript(val) && !window.__spoofingInjected) {
injectSpoofing();
}
} catch (e) { /* ignore */ }
return srcDesc.set.call(this, val);
}
});
}
} catch (e) {
// non-fatal
}
// 2) Hook setAttribute on script elements (covers element.setAttribute('src', ...))
try {
const origSetAttr = HTMLScriptElement.prototype.setAttribute;
HTMLScriptElement.prototype.setAttribute = function(name, value) {
try {
if ((name + '').toLowerCase() === 'src' && looksLikeFingerprintScript(value) && !window.__spoofingInjected) {
injectSpoofing();
}
} catch (e) {}
return origSetAttr.call(this, name, value);
};
} catch (e) {}
// 3) As a fallback, monitor append/insert to catch scripts that already had src set
try {
const origAppend = Node.prototype.appendChild;
Node.prototype.appendChild = function(node) {
try {
if (node && node.tagName && node.tagName.toLowerCase() === 'script') {
const src = node.src || node.getAttribute && node.getAttribute('src');
if (looksLikeFingerprintScript(src) && !window.__spoofingInjected) {
injectSpoofing();
}
}
} catch (e) {}
return origAppend.call(this, node);
};
const origInsertBefore = Node.prototype.insertBefore;
Node.prototype.insertBefore = function(node, ref) {
try {
if (node && node.tagName && node.tagName.toLowerCase() === 'script') {
const src = node.src || node.getAttribute && node.getAttribute('src');
if (looksLikeFingerprintScript(src) && !window.__spoofingInjected) {
injectSpoofing();
}
}
} catch (e) {}
return origInsertBefore.call(this, node, ref);
};
} catch (e) {}
// 4) Small DOM observer as an extra safety net (lightweight)
try {
const obs = new MutationObserver((mutations) => {
for (const m of mutations) {
for (const n of m.addedNodes || []) {
try {
if (n && n.tagName && n.tagName.toLowerCase() === 'script') {
const src = n.src || (n.getAttribute && n.getAttribute('src')) || n.textContent;
if (looksLikeFingerprintScript(src) && !window.__spoofingInjected) {
injectSpoofing();
obs.disconnect();
return;
}
}
} catch (e) {}
}
}
});
obs.observe(document, { childList: true, subtree: true });
} catch (e) {}
// If the page already has script tags at start, scan them now
try {
const scripts = document.getElementsByTagName('script');
for (let i = 0; i < scripts.length; i++) {
const s = scripts[i];
const src = s.src || s.getAttribute && s.getAttribute('src') || s.textContent;
if (looksLikeFingerprintScript(src) && !window.__spoofingInjected) {
injectSpoofing();
break;
}
}
} catch (e) {}
})();
Además, los entornos WebGL de diferentes páginas no pueden verse entre sí. Puedes crear contextos aislados para evitar que los sitios web relacionen tus huellas digitales entre páginas.
WebGL vs Canvas
La huella digital WebGL y la huella digital Canvas suelen usarse indistintamente, y es cierto que están estrechamente relacionadas. Sin embargo, no son 100% lo mismo.
La huella digital Canvas analiza cómo los navegadores renderizan gráficos 2D mediante HTML5 Canvas. Los resultados de renderizado dependen principalmente de la pila gráfica del navegador y del motor de renderizado. Como resultado, es más fácil de falsificar.
La huella digital WebGL analiza cómo un navegador renderiza gráficos tanto 2D como 3D. Los resultados de visualización dependen de las características del hardware, lo que hace que este método sea más informativo y difícil de eludir.
Resumen
Ahora que conoces los desafíos de falsificar la huella digital WebGL, quizás pienses que estabas mejor hace diez minutos, cuando todavía no sabías nada. Sin embargo, tu objetivo no es ser invisible: solo debes dar la impresión de ser un “usuario normal”. Para eso, tu huella digital debe verse realista, ser consistente dentro de una sesión y cambiar de una sesión a la siguiente. Y eso es completamente alcanzable. Por otro lado, el web scraping exitoso solo es posible cuando preservas la confidencialidad en todos los niveles y empleas navegadores multi-login, soluciones de falsificación TLS, proxies, etc. Todas esas herramientas y enfoques se potencian entre sí, lo que te permite mantenerte fuera del radar. DataImpulse tiene justo lo que necesitas para tu privacidad y anonimato: proxies obtenidos legalmente y en lista blanca para necesidades universales de scraping, junto con un servicio de soporte humano 24/7 para que puedas recolectar datos sin interrupciones. Haz clic en “Prueba ahora” o contáctanos en [email protected] para comenzar.