@ginger-ai/ginger-js 0.0.1

package/src/device/components/fonts/fonts.ts

@@ -0,0 +1,143 @@
+import { componentInterface, includeComponent } from '../../factory'
+import { ephemeralIFrame } from '../../utils/ephemeralIFrame'
+import { getBrowserName } from '../system/browser'
+
+
+
+const availableFonts = [
+    'Arial',
+    'Arial Black',
+    'Arial Narrow',
+    'Arial Rounded MT',
+    'Arimo',
+    'Archivo',
+    'Barlow',
+    'Bebas Neue',
+    'Bitter',
+    'Bookman',
+    'Calibri',
+    'Cabin',
+    'Candara',
+    'Century',
+    'Century Gothic',
+    'Comic Sans MS',
+    'Constantia',
+    'Courier',
+    'Courier New',
+    'Crimson Text',
+    'DM Mono',
+    'DM Sans',
+    'DM Serif Display',
+    'DM Serif Text',
+    'Dosis',
+    'Droid Sans',
+    'Exo',
+    'Fira Code',
+    'Fira Sans',
+    'Franklin Gothic Medium',
+    'Garamond',
+    'Geneva',
+    'Georgia',
+    'Gill Sans',
+    'Helvetica',
+    'Impact',
+    'Inconsolata',
+    'Indie Flower',
+    'Inter',
+    'Josefin Sans',
+    'Karla',
+    'Lato',
+    'Lexend',
+    'Lucida Bright',
+    'Lucida Console',
+    'Lucida Sans Unicode',
+    'Manrope',
+    'Merriweather',
+    'Merriweather Sans',
+    'Montserrat',
+    'Myriad',
+    'Noto Sans',
+    'Nunito',
+    'Nunito Sans',
+    'Open Sans',
+    'Optima',
+    'Orbitron',
+    'Oswald',
+    'Pacifico',
+    'Palatino',
+    'Perpetua',
+    'PT Sans',
+    'PT Serif',
+    'Poppins',
+    'Prompt',
+    'Public Sans',
+    'Quicksand',
+    'Rajdhani',
+    'Recursive',
+    'Roboto',
+    'Roboto Condensed',
+    'Rockwell',
+    'Rubik',
+    'Segoe Print',
+    'Segoe Script',
+    'Segoe UI',
+    'Sora',
+    'Source Sans Pro',
+    'Space Mono',
+    'Tahoma',
+    'Taviraj',
+    'Times',
+    'Times New Roman',
+    'Titillium Web',
+    'Trebuchet MS',
+    'Ubuntu',
+    'Varela Round',
+    'Verdana',
+    'Work Sans',
+  ];
+
+  const baseFonts = ['monospace', 'sans-serif', 'serif'];
+
+export default function getFontMetrics(): Promise<componentInterface> {
+    
+    return new Promise((resolve, reject) => {
+        try {
+
+            ephemeralIFrame(async ({ iframe }) => {
+
+                const canvas = iframe.createElement('canvas');
+                const ctx = canvas.getContext('2d');
+
+                const defaultWidths: number[] = baseFonts.map((font) => {
+                    return measureSingleFont(ctx, font)
+                })
+
+                let results: {[k: string]: any} = {};
+                availableFonts.forEach((font) => {
+                    const fontWidth = measureSingleFont(ctx, font);
+                    if (!defaultWidths.includes(fontWidth))
+                        results[font] = fontWidth;
+                });
+    
+                resolve(results);
+            })
+
+
+        } catch (error) {
+            reject({'error': 'unsupported'})
+        }
+    });
+};
+
+
+function measureSingleFont(ctx: CanvasRenderingContext2D | null, font: string): number {
+    if (!ctx) {
+        throw new Error('Canvas context not supported');
+    }
+    const text: string = "WwMmLli0Oo";
+    ctx.font = `72px ${font}`; // Set a default font size
+    return ctx.measureText(text).width;
+}
+
+if (getBrowserName() != 'Firefox')
+    includeComponent('fonts', getFontMetrics);

package/src/device/components/hardware/hardware.ts

@@ -0,0 +1,66 @@
+import { componentInterface, includeComponent } from '../../factory'
+
+function getHardwareInfo(): Promise<componentInterface> {
+  return new Promise((resolve) => {
+    const memoryInfo = (window.performance && (window.performance as any).memory ) ? (window.performance as any).memory : 0
+    resolve(
+      {
+        'videocard': getVideoCard(),
+        'architecture': getArchitecture(),
+        'jsHeapSizeLimit': memoryInfo.jsHeapSizeLimit || 0
+      }
+    )
+  });
+}
+
+function getVideoCard(): componentInterface | string {
+    const canvas = document.createElement('canvas');
+    const gl = canvas.getContext('webgl') ?? canvas.getContext('experimental-webgl');
+    
+    if (gl && 'getParameter' in gl) {
+        try {
+            // Try standard parameters first
+            const vendor = (gl.getParameter(gl.VENDOR) || '').toString();
+            const renderer = (gl.getParameter(gl.RENDERER) || '').toString();
+            
+            let result: componentInterface = {
+              vendor: vendor,
+              renderer: renderer,
+              version: (gl.getParameter(gl.VERSION) || '').toString(),
+              shadingLanguageVersion: (gl.getParameter(gl.SHADING_LANGUAGE_VERSION) || '').toString(),
+            };
+            
+            // Only try debug info if needed and available
+            
+            const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+            if (debugInfo) {
+                const vendorUnmasked = (gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || '').toString();
+                const rendererUnmasked = (gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || '').toString();
+                
+                // Only add unmasked values if they exist
+                if (vendorUnmasked) {
+                    result.vendorUnmasked = vendorUnmasked;
+                }
+                if (rendererUnmasked) {
+                    result.rendererUnmasked = rendererUnmasked;
+                }
+            }
+            
+            return result;
+        } catch (error) {
+            // fail silently
+        }
+    }
+    return "undefined";
+}
+
+function getArchitecture(): number {
+  const f = new Float32Array(1);
+  const u8 = new Uint8Array(f.buffer);
+  f[0] = Infinity;
+  f[0] = f[0] - f[0];
+
+  return u8[3];
+}
+
+includeComponent('hardware', getHardwareInfo);

package/src/device/components/index.ts

@@ -0,0 +1,14 @@
+import './audio/audio'
+import './canvas/canvas'
+import './fonts/fonts'
+import './hardware/hardware'
+import './locales/locales'
+import './permissions/permissions'
+import './screen/screen'
+import './screen/screenResolution'
+import './webgl/webgl'
+import './plugins/plugins'
+import './system/system'
+import './system/emoji'
+import './math/math'
+import './extra/extra'

package/src/device/components/locales/locales.ts

@@ -0,0 +1,21 @@
+import { componentInterface, includeComponent } from '../../factory'
+
+function getLocales(): Promise<componentInterface> {
+  return new Promise((resolve) => {
+    resolve(
+      {
+        'languages': getUserLanguage(),
+        'timezone': getUserTimezone()
+      });
+    });
+}
+
+function getUserLanguage(): string {
+    return navigator.language;
+}
+
+function getUserTimezone(): string {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+
+includeComponent('locales', getLocales);

package/src/device/components/math/math.ts

@@ -0,0 +1,39 @@
+import { componentInterface, includeComponent } from '../../factory'
+
+const getMathInfo = async (): Promise<componentInterface> => {
+    return {
+        acos: Math.acos(0.5),
+        asin: integrate(Math.asin, -1, 1, 97),
+        atan: integrate(Math.atan, -1, 1, 97),
+        cos: integrate(Math.cos, 0, Math.PI, 97),
+        cosh: Math.cosh(9/7),
+        e: Math.E,
+        largeCos: Math.cos(1e20),
+        largeSin: Math.sin(1e20),
+        largeTan: Math.tan(1e20),
+        log: Math.log(1000),
+        pi: Math.PI,
+        sin: integrate(Math.sin, -Math.PI, Math.PI, 97),
+        sinh: integrate(Math.sinh, -9/7, 7/9, 97),
+        sqrt: Math.sqrt(2),
+        tan: integrate(Math.tan, 0, 2 * Math.PI, 97),
+        tanh: integrate(Math.tanh, -9/7, 7/9, 97),
+    }
+}
+
+/** This might be a little excessive, but I wasn't sure what number to pick for some of the
+ * trigonometric functions. Using an integral here, so a few numbers are calculated. However,
+ * I do this mainly for those integrals that sum up to a small value, otherwise there's no point.
+*/ 
+
+const integrate = (f: (x: number) => number, a: number, b: number, n: number): number => {
+    const h = (b - a) / n;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        const x = a + (i + 0.5) * h;
+        sum += f(x);
+    }
+    return sum * h;
+};
+
+includeComponent('math', getMathInfo);

package/src/device/components/permissions/permissions.ts

@@ -0,0 +1,60 @@
+import { componentInterface, includeComponent } from '../../factory';
+import { mostFrequentValuesInArrayOfDictionaries } from '../../utils/getMostFrequent';
+import { options } from '../../modules/options';
+
+let permission_keys: PermissionName[];
+function initializePermissionKeys() {
+    permission_keys = options?.permissions_to_check || [
+        'accelerometer',
+        'accessibility', 'accessibility-events',
+        'ambient-light-sensor',
+        'background-fetch', 
+        'background-sync', 
+        'bluetooth',
+        'clipboard-read',
+        'clipboard-write',
+        'device-info', 
+        'display-capture',
+        'gyroscope', 
+        'local-fonts',
+        'magnetometer', 
+        'midi',
+        'nfc', 'notifications',
+        'payment-handler',
+        'persistent-storage',
+        'speaker', 'storage-access',
+        'top-level-storage-access',
+        'window-management',
+        'query',
+    ] as PermissionName[];
+}
+
+export default async function getBrowserPermissions(): Promise<componentInterface> {
+    initializePermissionKeys();
+    const permissionPromises: Promise<componentInterface>[] = Array.from({length: options?.retries || 3}, () => getBrowserPermissionsOnce() );
+    return Promise.all(permissionPromises).then((resolvedPermissions) => {
+        const permission = mostFrequentValuesInArrayOfDictionaries(resolvedPermissions, permission_keys);
+        return permission;
+    });
+}
+
+async function getBrowserPermissionsOnce(): Promise<componentInterface> {
+
+    const permissionStatus: { [key: string]: string } = {};
+
+    for (const feature of permission_keys) {
+        try {
+            // Request permission status for each feature
+            const status = await navigator.permissions.query({ name: feature });
+
+            // Assign permission status to the object
+            permissionStatus[feature] = status.state.toString();
+        } catch (error) {
+            // In case of errors (unsupported features, etc.), do nothing. Not listing them is the same as not supported
+        }
+    }
+
+    return permissionStatus;
+}
+
+includeComponent("permissions", getBrowserPermissions);

package/src/device/components/plugins/plugins.ts

@@ -0,0 +1,22 @@
+import { componentInterface, includeComponent } from '../../factory'
+
+export default function getInstalledPlugins(): Promise<componentInterface> {
+    const plugins: string[] = [];
+  
+    if (navigator.plugins) {
+      for (let i = 0; i < navigator.plugins.length; i++) {
+        const plugin = navigator.plugins[i];
+        plugins.push([plugin.name, plugin.filename, plugin.description ].join("|"));
+      }
+    }
+  
+    return new Promise((resolve) => {
+      resolve(
+        {
+          'plugins': plugins
+        }
+      );
+  });
+  }
+  
+  includeComponent('plugins', getInstalledPlugins);

package/src/device/components/screen/screen.ts

@@ -0,0 +1,13 @@
+import { componentInterface, includeComponent } from '../../factory';
+
+function screenDetails(): Promise<componentInterface> {
+    return new Promise((resolve) => {
+        resolve(
+            {
+                'colorDepth': screen.colorDepth,
+            }
+        );
+    });
+}
+
+includeComponent('screen', screenDetails);

package/src/device/components/screen/screenResolution.ts

@@ -0,0 +1,45 @@
+import { includeComponent } from "../../factory";
+import {
+  isSafariWebKit,
+  isWebKit,
+  isWebKit616OrNewer,
+} from "../../utils/browser_";
+import { replaceNaN, toInt } from "../../utils/data";
+
+type ScreenResolution = [number | null, number | null];
+
+/**
+ * A version of the entropy source with stabilization to make it suitable for static fingerprinting.
+ * The window resolution is always the document size in private mode of Safari 17,
+ * so the window resolution is not used in Safari 17.
+ */
+export default async function getScreenResolution(): Promise<any> {
+  if (isWebKit() && isWebKit616OrNewer() && isSafariWebKit()) {
+    return [];
+  }
+
+  return getUnstableScreenResolution();
+}
+
+/**
+ * A version of the entropy source without stabilization.
+ *
+ * Warning for package users:
+ * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.
+ */
+export function getUnstableScreenResolution(): ScreenResolution {
+  const s = screen;
+
+  // Some browsers return screen resolution as strings, e.g. "1200", instead of a number, e.g. 1200.
+  // I suspect it's done by certain plugins that randomize browser properties to prevent fingerprinting.
+  // Some browsers even return  screen resolution as not numbers.
+  const parseDimension = (value: unknown) => replaceNaN(toInt(value), null);
+  const dimensions = [
+    parseDimension(s.width),
+    parseDimension(s.height),
+  ] as ScreenResolution;
+  dimensions.sort().reverse();
+  return dimensions;
+}
+
+includeComponent("screenResolution", getScreenResolution);