@ginger-ai/ginger-js 0.0.1

package/src/device/modules/fp.ts

@@ -0,0 +1,138 @@
+import {
+  FingerprintComponentValue,
+  GingerJsFp,
+} from "../../core";
+import {
+  componentInterface,
+  getComponentPromises,
+  timeoutInstance,
+} from "../factory";
+import { hash } from "../utils/hash";
+import { raceAll } from "../utils/raceAll";
+import { options } from "./options";
+
+export async function getFingerprintData(): Promise<componentInterface> {
+  try {
+    const promiseMap: Record<
+      string,
+      Promise<componentInterface>
+    > = getComponentPromises();
+
+    const keys: string[] = Object.keys(promiseMap);
+    const promises: Promise<componentInterface>[] = Object.values(promiseMap);
+    const resolvedValues: (componentInterface | undefined)[] = await raceAll(
+      promises,
+      options?.timeout || 1000,
+      timeoutInstance
+    );
+
+    const resolvedComponents: Record<string, componentInterface> = {};
+    
+    resolvedValues.forEach((value, index) => {
+      if (value !== undefined) {
+        resolvedComponents[keys[index]] = value;
+      }
+    });
+
+    return filterFingerprintData(
+      resolvedComponents,
+      options.exclude || [],
+      options.include || [],
+      ""
+    );
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * This function filters the fingerprint data based on the exclude and include list
+ * @param {componentInterface} obj - components objects from main componentInterface
+ * @param {string[]} excludeList - elements to exclude from components objects (e.g : 'canvas', 'system.browser')
+ * @param {string[]} includeList - elements to only include from components objects (e.g : 'canvas', 'system.browser')
+ * @param {string} path - auto-increment path iterating on key objects from components objects
+ * @returns {componentInterface} result - returns the final object before hashing in order to get fingerprint
+ */
+export function filterFingerprintData(
+  obj: componentInterface,
+  excludeList: string[],
+  includeList: string[],
+  path: string = ""
+): componentInterface {
+  const result: componentInterface = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const currentPath = path + key + ".";
+
+    if (typeof value === "object" && !Array.isArray(value)) {
+      const filtered = filterFingerprintData(
+        value,
+        excludeList,
+        includeList,
+        currentPath
+      );
+      if (Object.keys(filtered).length > 0) {
+        result[key] = filtered;
+      }
+    } else {
+      const isExcluded = excludeList.some((exclusion) =>
+        currentPath.startsWith(exclusion)
+      );
+      const isIncluded = includeList.some((inclusion) =>
+        currentPath.startsWith(inclusion)
+      );
+
+      if (!isExcluded || isIncluded) {
+        result[key] = value;
+      }
+    }
+  }
+
+  return result;
+}
+
+export async function getFingerprint(): Promise<GingerJsFp> {
+  try {
+    const fingerprintData = await getFingerprintData();
+
+    const serializedFingerprint = getSerializedFingerprintObj(fingerprintData);
+    const thisHash = hash(JSON.stringify(serializedFingerprint));
+    const componentsUsedForHash = getHashRelevantKeys(serializedFingerprint as componentInterface);
+    return {
+      hash: thisHash.toString(),
+      data: fingerprintData,
+      componentsUsedForHash: componentsUsedForHash,
+    };
+  } catch (error) {
+    throw error;
+  }
+}
+
+function serializedObject(data: componentInterface): FingerprintComponentValue {
+  return {
+    audio: data.audio,
+    fonts: data.fonts,
+    hardware: data.hardware,
+    math: data.math,
+    permissions: data.permissions,
+    screen: data.screen,
+    system: data.system,
+    emojiFingerprint: data.emojiFingerprint,
+    vendorFlavour: data.vendorFlavour,
+    colorGamut: data.colorGamut,
+    canvas: data.canvas,
+    webglBasics: data.webGlBasics,
+  };
+}
+
+function getSerializedFingerprintObj(
+  data: componentInterface
+): FingerprintComponentValue {
+  return serializedObject(data);
+}
+
+function getHashRelevantKeys(
+  data: componentInterface
+): Array<keyof FingerprintComponentValue> {
+  const fpdata = serializedObject(data);
+  return Object.keys(fpdata) as Array<keyof FingerprintComponentValue>;
+}

package/src/device/modules/incognito.ts

@@ -0,0 +1,253 @@
+type IncognitoDetectionResult = {
+    status: boolean;
+    browser_name: string;
+};
+
+async function detectIncognito(): Promise<IncognitoDetectionResult> {
+    return new Promise(function (resolve, reject) {
+        let browser_name = 'unknown';
+
+        function __callback (status: boolean): void {
+            resolve({
+              status,
+              browser_name
+            })
+          }
+      
+          function identifyChromium (): string {
+            const ua = navigator.userAgent
+            if (ua.match(/Chrome/)) {
+              if ((navigator as any).brave !== undefined) {
+                return 'Brave'
+              } else if (ua.match(/Edg/)) {
+                return 'Edge'
+              } else if (ua.match(/OPR/)) {
+                return 'Opera'
+              }
+              return 'Chrome'
+            } else {
+              return 'Chromium'
+            }
+          }
+      
+          function assertEvalToString (value: number): boolean {
+            return value === eval.toString().length
+          }
+      
+          function feid (): number {
+            let toFixedEngineID = 0
+            let neg = parseInt("-1")
+            try {
+               neg.toFixed(neg)
+            } catch (e) {
+              toFixedEngineID = (e as Error).message.length 
+            }
+            return toFixedEngineID
+          }
+      
+          function isSafari (): boolean {
+            return feid() === 44
+          }
+      
+          function isChrome (): boolean {
+            return feid() === 51
+          }
+      
+          function isFirefox (): boolean {
+            return feid() === 25
+          }
+      
+          function isMSIE (): boolean {
+            return (
+              (navigator as any).msSaveBlob !== undefined && assertEvalToString(39)
+            )
+          }
+      
+          /**
+           * Safari (Safari for iOS & macOS)
+           **/
+      
+          function newSafariTestByStorageFallback (): void {
+            if (!navigator.storage?.estimate) {
+              __callback(false);
+              return;
+            }
+      
+            navigator.storage
+              .estimate()
+              .then(({ quota }) => {
+                // iOS 18.x/macOS Safari 18.x (normal): ~41GB
+                // iOS 18.x/macOS Safari 18.x (private): ~1GB
+                // If reported quota < 2 GB => likely private
+                if (quota && quota < 2_000_000_000) {
+                  __callback(true);
+                } else {
+                  __callback(false);
+                }
+              })
+              .catch(() => {
+                __callback(false);
+              });
+          }
+      
+          function newSafariTest (): void {
+            const tmp_name = String(Math.random())
+      
+            try {
+              const db = window.indexedDB.open(tmp_name, 1)
+      
+              db.onupgradeneeded = function (i: any) {
+                const res = i.target?.result
+      
+                try {
+                  res.createObjectStore('test', {
+                    autoIncrement: true
+                  }).put(new Blob())
+                } catch (e) {
+                  let message = e
+      
+                  if (e instanceof Error) {
+                    message = e.message ?? e
+                  }
+      
+                  if (typeof message !== 'string') {
+                    __callback(false); return
+                  }
+      
+                  const matchesExpectedError = message.includes('BlobURLs are not yet supported')
+                  if (matchesExpectedError) {
+                    __callback(true)
+                  }
+                } finally {
+                  res.close()
+                  window.indexedDB.deleteDatabase(tmp_name)
+      
+                  // indexdb works on newer versions of safari so we need to check via storage fallback
+                  newSafariTestByStorageFallback();
+                }
+              }
+            } catch (e) {
+              __callback(false)
+            }
+          }
+      
+          function oldSafariTest (): void {
+            const openDB = (window as any).openDatabase
+            const storage = window.localStorage
+            try {
+              openDB(null, null, null, null)
+            } catch (e) {
+              __callback(true); return
+            }
+            try {
+              storage.setItem('test', '1')
+              storage.removeItem('test')
+            } catch (e) {
+              __callback(true); return
+            }
+            __callback(false)
+          }
+      
+          function safariPrivateTest (): void {
+            if (navigator.maxTouchPoints !== undefined) {
+              newSafariTest()
+            } else {
+              oldSafariTest()
+            }
+          }
+      
+          /**
+           * Chrome
+           **/
+      
+          function getQuotaLimit (): number {
+            const w = window as any
+            if (
+              w.performance !== undefined &&
+              w.performance.memory !== undefined &&
+              w.performance.memory.jsHeapSizeLimit !== undefined
+            ) {
+              return (performance as any).memory.jsHeapSizeLimit
+            }
+            return 1073741824
+          }
+      
+          // >= 76
+          function storageQuotaChromePrivateTest (): void {
+            (navigator as any).webkitTemporaryStorage.queryUsageAndQuota(
+              function (_: number, quota: number) {
+                const quotaInMib = Math.round(quota / (1024 * 1024))
+                const quotaLimitInMib = Math.round(getQuotaLimit() / (1024 * 1024)) * 2
+      
+                __callback(quotaInMib < quotaLimitInMib)
+              },
+              function (e: any) {
+                reject(
+                  new Error(
+                    'detectIncognito somehow failed to query storage quota: ' +
+                      e.message
+                  )
+                )
+              }
+            )
+          }
+      
+          // 50 to 75
+          function oldChromePrivateTest (): void {
+            const fs = (window as any).webkitRequestFileSystem
+            const success = function () {
+              __callback(false)
+            }
+            const error = function () {
+              __callback(true)
+            }
+            fs(0, 1, success, error)
+          }
+      
+          function chromePrivateTest (): void {
+            if (self.Promise !== undefined && (self.Promise as any).allSettled !== undefined) {
+              storageQuotaChromePrivateTest()
+            } else {
+              oldChromePrivateTest()
+            }
+          }
+      
+          /**
+           * Firefox
+           **/
+      
+          function firefoxPrivateTest (): void {
+            __callback(navigator.serviceWorker === undefined)
+          }
+      
+          /**
+           * MSIE
+           **/
+      
+          function msiePrivateTest (): void {
+            __callback(window.indexedDB === undefined)
+          }
+      
+          function main (): void {
+            if (isSafari()) {
+              browser_name = 'Safari'
+              safariPrivateTest()
+            } else if (isChrome()) {
+              browser_name = identifyChromium()
+              chromePrivateTest()
+            } else if (isFirefox()) {
+              browser_name = 'Firefox'
+              firefoxPrivateTest()
+            } else if (isMSIE()) {
+              browser_name = 'Internet Explorer'
+              msiePrivateTest()
+            } else {
+              reject(new Error('detectIncognito cannot determine the browser'))
+            }
+          }
+      
+          main()
+        })
+      }
+
+export {detectIncognito}

package/src/device/modules/options.ts

@@ -0,0 +1,17 @@
+export interface optionsInterface {
+    exclude: string[],
+    include: string[],
+    webgl_runs?: number,
+    canvas_runs?: number,
+    permissions_to_check?: PermissionName[], // new option
+    retries?: number, // new option
+    timeout?: number, // new option
+    logging: boolean
+}
+
+export let options: optionsInterface = {
+    exclude: [],
+    include: [],
+    logging: true,
+}
+

package/src/device/modules/os.ts

@@ -0,0 +1,15 @@
+import { UAParser } from "ua-parser-js";
+import { DeviceOs } from "../../core";
+
+export const getOs = async (): Promise<DeviceOs> => {
+  const parser = new UAParser(navigator.userAgent);
+  const result = parser.getResult();
+  return { ...result.os, device_type: getDeviceType() };
+};
+
+const getDeviceType = () => {
+  const w = window.innerWidth;
+  if (w <= 767) return 'mobile';
+  if (w <= 1024) return 'tablet';
+  return 'desktop';
+};

package/src/device/modules/tor.ts

@@ -0,0 +1,41 @@
+import { TorDetectionResult } from "../../core";
+
+async function detectTorBrowser(): Promise<TorDetectionResult> {
+  const totalChecks = 7;
+  let score = 0;
+
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  if (tz === "Atlantic/Reykjavik") score++;
+  const webGLInfo = getWebGLInfo();
+  if (["Mozilla", "unknown"].includes(webGLInfo.vendor)) score++;
+  if (!window.RTCPeerConnection) score++;
+  if (!(navigator as any).deviceMemory) score++;
+  if (navigator.hardwareConcurrency === 2) score++;
+  if (!navigator.credentials) score++;
+  if (!navigator.geolocation) score++;
+
+  return {
+    status: score >= 6,
+    confidence: `${((score / totalChecks)).toFixed(2)}`,
+  };
+}
+
+const getWebGLInfo = (): { vendor: string; renderer: string } => {
+  try {
+    const canvas = document.createElement("canvas");
+    const gl: any =
+      canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl) return { vendor: "unsupported", renderer: "unsupported" };
+    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+    return debugInfo
+      ? {
+          vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL),
+          renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL),
+        }
+      : { vendor: "unknown", renderer: "unknown" };
+  } catch {
+    return { vendor: "error", renderer: "error" };
+  }
+};
+
+export { detectTorBrowser };

package/src/device/utils/async.ts

@@ -0,0 +1,106 @@
+export type MaybePromise<T> = Promise<T> | T
+
+export function wait<T = void>(durationMs: number, resolveWith?: T): Promise<T> {
+  return new Promise((resolve) => setTimeout(resolve, durationMs, resolveWith))
+}
+
+/**
+ * Allows asynchronous actions and microtasks to happen.
+ */
+function releaseEventLoop(): Promise<void> {
+  // Don't use setTimeout because Chrome throttles it in some cases causing very long agent execution:
+  // https://stackoverflow.com/a/6032591/1118709
+  // https://github.com/chromium/chromium/commit/0295dd09496330f3a9103ef7e543fa9b6050409b
+  // Reusing a MessageChannel object gives no noticeable benefits
+  return new Promise((resolve) => {
+    const channel = new MessageChannel()
+    channel.port1.onmessage = () => resolve()
+    channel.port2.postMessage(null)
+  })
+}
+
+export function requestIdleCallbackIfAvailable(fallbackTimeout: number, deadlineTimeout = Infinity): Promise<void> {
+  const { requestIdleCallback } = window
+  if (requestIdleCallback) {
+    // The function `requestIdleCallback` loses the binding to `window` here.
+    // `globalThis` isn't always equal `window` (see https://github.com/fingerprintjs/fingerprintjs/issues/683).
+    // Therefore, an error can occur. `call(window,` prevents the error.
+    return new Promise((resolve) => requestIdleCallback.call(window, () => resolve(), { timeout: deadlineTimeout }))
+  } else {
+    return wait(Math.min(fallbackTimeout, deadlineTimeout))
+  }
+}
+
+export function isPromise<T>(value: PromiseLike<T> | unknown): value is PromiseLike<T> {
+  return !!value && typeof (value as PromiseLike<T>).then === 'function'
+}
+
+/**
+ * Calls a maybe asynchronous function without creating microtasks when the function is synchronous.
+ * Catches errors in both cases.
+ *
+ * If just you run a code like this:
+ * ```
+ * console.time('Action duration')
+ * await action()
+ * console.timeEnd('Action duration')
+ * ```
+ * The synchronous function time can be measured incorrectly because another microtask may run before the `await`
+ * returns the control back to the code.
+ */
+export function awaitIfAsync<TResult, TError = unknown>(
+  action: () => MaybePromise<TResult>,
+  callback: (...args: [success: true, result: TResult] | [success: false, error: TError]) => unknown,
+): void {
+  try {
+    const returnedValue = action()
+    if (isPromise(returnedValue)) {
+      returnedValue.then(
+        (result) => callback(true, result),
+        (error: TError) => callback(false, error),
+      )
+    } else {
+      callback(true, returnedValue)
+    }
+  } catch (error) {
+    callback(false, error as TError)
+  }
+}
+
+/**
+ * If you run many synchronous tasks without using this function, the JS main loop will be busy and asynchronous tasks
+ * (e.g. completing a network request, rendering the page) won't be able to happen.
+ * This function allows running many synchronous tasks such way that asynchronous tasks can run too in background.
+ */
+export async function mapWithBreaks<T, U>(
+  items: readonly T[],
+  callback: (item: T, index: number) => U,
+  loopReleaseInterval = 16,
+): Promise<U[]> {
+  const results = Array<U>(items.length)
+  let lastLoopReleaseTime = Date.now()
+
+  for (let i = 0; i < items.length; ++i) {
+    results[i] = callback(items[i], i)
+
+    const now = Date.now()
+    if (now >= lastLoopReleaseTime + loopReleaseInterval) {
+      lastLoopReleaseTime = now
+      await releaseEventLoop()
+    }
+  }
+
+  return results
+}
+
+/**
+ * Makes the given promise never emit an unhandled promise rejection console warning.
+ * The promise will still pass errors to the next promises.
+ * Returns the input promise for convenience.
+ *
+ * Otherwise, promise emits a console warning unless it has a `catch` listener.
+ */
+export function suppressUnhandledRejectionWarning<T extends PromiseLike<unknown>>(promise: T): T {
+  promise.then(undefined, () => undefined)
+  return promise
+}