@thumbmarkjs/thumbmarkjs 0.19.0 → 0.20.0

package/src/fingerprint/functions.ts

@@ -0,0 +1,118 @@
+import {componentInterface, getComponentPromises, timeoutInstance} from '../factory'
+import {hash} from '../utils/hash'
+import {raceAll, raceAllPerformance} from '../utils/raceAll'
+import {options} from './options'
+import * as packageJson from '../../package.json'
+
+export function getVersion(): string {
+    return packageJson.version
+}
+
+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 validValues: componentInterface[] = resolvedValues.filter((value): value is componentInterface => value !== undefined);
+        const resolvedComponents: Record<string, componentInterface> = {};
+        validValues.forEach((value, index) => {
+            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(includeData?: false): Promise<string>
+export async function getFingerprint(includeData: true): Promise<{ hash: string, data: componentInterface }>
+export async function getFingerprint(includeData?: boolean): Promise<string | { hash: string, data: componentInterface }> {
+    try {
+        const fingerprintData = await getFingerprintData()
+        const thisHash = hash(JSON.stringify(fingerprintData))
+        if (Math.random() < 0.001 && options.logging) logFingerprintData(thisHash, fingerprintData)
+        if (includeData) {
+            return { hash: thisHash.toString(), data: fingerprintData}
+        } else {
+            return thisHash.toString()
+        }
+    } catch (error) {
+        throw error
+    }
+}
+
+export async function getFingerprintPerformance() {
+    try {
+        const promiseMap = getComponentPromises()
+        const keys = Object.keys(promiseMap)
+        const promises = Object.values(promiseMap)
+        const resolvedValues = await raceAllPerformance(promises, options?.timeout || 1000, timeoutInstance )
+        const resolvedComponents: { [key: string]: any } = {
+            elapsed: {}
+        }
+        resolvedValues.forEach((value, index) => {
+            resolvedComponents[keys[index]] = value.value
+            resolvedComponents["elapsed"][keys[index]] = value.elapsed
+        });
+        return resolvedComponents
+    }
+    catch (error) {
+        throw error
+    }
+}
+
+// Function to log the fingerprint data
+async function logFingerprintData(thisHash: string, fingerprintData: componentInterface) {
+    const url = 'https://logging.thumbmarkjs.com/v1/log'
+    const payload = {
+        thumbmark: thisHash,
+        components: fingerprintData,
+        version: getVersion()
+    };
+    if (!sessionStorage.getItem("_tmjs_l")) {
+        sessionStorage.setItem("_tmjs_l", "1")
+        try {
+            await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(payload)
+            });
+        } catch { } // do nothing
+    }
+}

package/src/fingerprint/options.ts

@@ -0,0 +1,26 @@
+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,
+}
+
+export function setOption<K extends keyof optionsInterface>(key: K, value: optionsInterface[K]) {
+    if (!['include', 'exclude', 'permissions_to_check', 'retries', 'timeout', 'logging'].includes(key))
+        throw new Error('Unknown option ' + key)
+    if (['include', 'exclude', 'permissions_to_check'].includes(key) && !(Array.isArray(value) && value.every(item => typeof item === 'string')) )
+        throw new Error('The value of the include, exclude and permissions_to_check must be an array of strings');
+    if ([ 'retries', 'timeout'].includes(key) && typeof value !== 'number')
+        throw new Error('The value of retries must be a number');
+    options[key] = value;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import { getFingerprint, getFingerprintData, getFingerprintPerformance, getVersion } from './fingerprint/functions'
+import { setOption } from './fingerprint/options'
+import { includeComponent } from './factory'
+import './components'
+
+export { setOption, getVersion, getFingerprint, getFingerprintData, getFingerprintPerformance, includeComponent }

package/src/utils/commonPixels.ts

@@ -0,0 +1,38 @@
+export function getCommonPixels(images: ImageData[], width: number, height: number ): ImageData {
+    let finalData: number[] = [];
+    for (let i = 0; i < images[0].data.length; i++) {
+        let indice: number[] = [];
+        for (let u = 0; u < images.length; u++) {
+            indice.push(images[u].data[i]);
+        }
+        finalData.push(getMostFrequent(indice));
+    }
+
+    const pixelData = finalData;
+    const pixelArray = new Uint8ClampedArray(pixelData);
+    return new ImageData(pixelArray, width, height);
+}
+
+function getMostFrequent(arr: number[]): number {
+    if (arr.length === 0) {
+      return 0; // Handle empty array case
+    }
+  
+    const frequencyMap: { [key: number]: number } = {};
+    
+    // Count occurrences of each number in the array
+    for (const num of arr) {
+      frequencyMap[num] = (frequencyMap[num] || 0) + 1;
+    }
+  
+    let mostFrequent: number = arr[0];
+    
+    // Find the number with the highest frequency
+    for (const num in frequencyMap) {
+      if (frequencyMap[num] > frequencyMap[mostFrequent]) {
+        mostFrequent = parseInt(num, 10);
+      }
+    }
+  
+    return mostFrequent;
+  }

package/src/utils/ephemeralIFrame.ts

@@ -0,0 +1,35 @@
+export async function ephemeralIFrame(callback: ({ iframe }: { iframe: Document }) => void): Promise<any> {
+
+    while (!document.body) {
+      await wait(50)
+    }
+    const iframe = document.createElement('iframe')
+    iframe.setAttribute('frameBorder', '0')
+
+    const style = iframe.style
+    style.setProperty('position','fixed');
+    style.setProperty('display', 'block', 'important')
+    style.setProperty('visibility', 'visible')
+    style.setProperty('border', '0');
+    style.setProperty('opacity','0');
+    
+    iframe.src = 'about:blank'
+    document.body.appendChild(iframe)
+  
+    const iframeDocument = iframe.contentDocument || iframe.contentWindow?.document;
+    if (!iframeDocument) {
+      throw new Error('Iframe document is not accessible');
+    }
+  
+    // Execute the callback function with access to the iframe's document
+    callback({ iframe: iframeDocument });
+  
+    // Clean up after running the callback
+    setTimeout(() => {
+      document.body.removeChild(iframe);
+    }, 0);
+  }
+
+  export function wait<T = void>(durationMs: number, resolveWith?: T): Promise<T> {
+    return new Promise((resolve) => setTimeout(resolve, durationMs, resolveWith))
+  }

package/src/utils/getMostFrequent.ts

@@ -0,0 +1,39 @@
+function mostFrequentValue(arr: any[]): any | null {
+    if (arr.length === 0) {
+      return null; // Return null for an empty array
+    }
+  
+    const frequencyMap: { [key: string]: number } = {};
+  
+    // Count occurrences of each element in the array
+    arr.forEach((element) => {
+      const key = String(element);
+      frequencyMap[key] = (frequencyMap[key] || 0) + 1;
+    });
+  
+    let mostFrequent: any = arr[0]; // Assume the first element is the most frequent
+    let highestFrequency = 1; // Frequency of the assumed most frequent element
+  
+    // Find the element with the highest frequency
+    Object.keys(frequencyMap).forEach((key) => {
+      if (frequencyMap[key] > highestFrequency) {
+        mostFrequent = key;
+        highestFrequency = frequencyMap[key];
+      }
+    });
+  
+    return mostFrequent;
+  }
+
+export function mostFrequentValuesInArrayOfDictionaries(arr: { [key: string]: any }[], keys: string[]): { [key: string]: any } {
+    const result: { [key: string]: any } = {};
+  
+    keys.forEach((key) => {
+      const valuesForKey = arr.map((obj) => (key in obj ? obj[key] : undefined)).filter((val) => val !== undefined);
+      const mostFrequentValueForKey = mostFrequentValue(valuesForKey);
+      if (mostFrequentValueForKey)
+        result[key] = mostFrequentValueForKey;
+    });
+  
+    return result;
+  }

package/src/utils/hash.ts

@@ -0,0 +1,198 @@
+/**
+ * This code is taken from https://github.com/LinusU/murmur-128/blob/master/index.js
+ * But instead of dependencies to encode-utf8 and fmix, I've implemented them here.
+ */
+
+function encodeUtf8(text: string): ArrayBuffer {
+  const encoder = new TextEncoder();
+  return encoder.encode(text).buffer;
+}
+
+function fmix (input : number) : number {
+  input ^= (input >>> 16)
+  input = Math.imul(input, 0x85ebca6b)
+  input ^= (input >>> 13)
+  input = Math.imul(input, 0xc2b2ae35)
+  input ^= (input >>> 16)
+
+  return (input >>> 0)
+}
+
+const C = new Uint32Array([
+  0x239b961b,
+  0xab0e9789,
+  0x38b34ae5,
+  0xa1e38b93
+])
+
+function rotl (m : number, n : number) : number {
+  return (m << n) | (m >>> (32 - n))
+}
+
+function body (key : ArrayBuffer, hash : Uint32Array) {
+  const blocks = (key.byteLength / 16) | 0
+  const view32 = new Uint32Array(key, 0, blocks * 4)
+
+  for (let i = 0; i < blocks; i++) {
+    const k = view32.subarray(i * 4, (i + 1) * 4)
+
+    k[0] = Math.imul(k[0], C[0])
+    k[0] = rotl(k[0], 15)
+    k[0] = Math.imul(k[0], C[1])
+
+    hash[0] = (hash[0] ^ k[0])
+    hash[0] = rotl(hash[0], 19)
+    hash[0] = (hash[0] + hash[1])
+    hash[0] = Math.imul(hash[0], 5) + 0x561ccd1b
+
+    k[1] = Math.imul(k[1], C[1])
+    k[1] = rotl(k[1], 16)
+    k[1] = Math.imul(k[1], C[2])
+
+    hash[1] = (hash[1] ^ k[1])
+    hash[1] = rotl(hash[1], 17)
+    hash[1] = (hash[1] + hash[2])
+    hash[1] = Math.imul(hash[1], 5) + 0x0bcaa747
+
+    k[2] = Math.imul(k[2], C[2])
+    k[2] = rotl(k[2], 17)
+    k[2] = Math.imul(k[2], C[3])
+
+    hash[2] = (hash[2] ^ k[2])
+    hash[2] = rotl(hash[2], 15)
+    hash[2] = (hash[2] + hash[3])
+    hash[2] = Math.imul(hash[2], 5) + 0x96cd1c35
+
+    k[3] = Math.imul(k[3], C[3])
+    k[3] = rotl(k[3], 18)
+    k[3] = Math.imul(k[3], C[0])
+
+    hash[3] = (hash[3] ^ k[3])
+    hash[3] = rotl(hash[3], 13)
+    hash[3] = (hash[3] + hash[0])
+    hash[3] = Math.imul(hash[3], 5) + 0x32ac3b17
+  }
+}
+
+function tail (key : ArrayBuffer, hash : Uint32Array) {
+  const blocks = (key.byteLength / 16) | 0
+  const reminder = (key.byteLength % 16)
+
+  const k = new Uint32Array(4)
+  const tail = new Uint8Array(key, blocks * 16, reminder)
+
+  switch (reminder) {
+    case 15:
+      k[3] = (k[3] ^ (tail[14] << 16))
+      // fallthrough
+    case 14:
+      k[3] = (k[3] ^ (tail[13] << 8))
+      // fallthrough
+    case 13:
+      k[3] = (k[3] ^ (tail[12] << 0))
+
+      k[3] = Math.imul(k[3], C[3])
+      k[3] = rotl(k[3], 18)
+      k[3] = Math.imul(k[3], C[0])
+      hash[3] = (hash[3] ^ k[3])
+      // fallthrough
+    case 12:
+      k[2] = (k[2] ^ (tail[11] << 24))
+      // fallthrough
+    case 11:
+      k[2] = (k[2] ^ (tail[10] << 16))
+      // fallthrough
+    case 10:
+      k[2] = (k[2] ^ (tail[9] << 8))
+      // fallthrough
+    case 9:
+      k[2] = (k[2] ^ (tail[8] << 0))
+
+      k[2] = Math.imul(k[2], C[2])
+      k[2] = rotl(k[2], 17)
+      k[2] = Math.imul(k[2], C[3])
+      hash[2] = (hash[2] ^ k[2])
+      // fallthrough
+    case 8:
+      k[1] = (k[1] ^ (tail[7] << 24))
+      // fallthrough
+    case 7:
+      k[1] = (k[1] ^ (tail[6] << 16))
+      // fallthrough
+    case 6:
+      k[1] = (k[1] ^ (tail[5] << 8))
+      // fallthrough
+    case 5:
+      k[1] = (k[1] ^ (tail[4] << 0))
+
+      k[1] = Math.imul(k[1], C[1])
+      k[1] = rotl(k[1], 16)
+      k[1] = Math.imul(k[1], C[2])
+      hash[1] = (hash[1] ^ k[1])
+      // fallthrough
+    case 4:
+      k[0] = (k[0] ^ (tail[3] << 24))
+      // fallthrough
+    case 3:
+      k[0] = (k[0] ^ (tail[2] << 16))
+      // fallthrough
+    case 2:
+      k[0] = (k[0] ^ (tail[1] << 8))
+      // fallthrough
+    case 1:
+      k[0] = (k[0] ^ (tail[0] << 0))
+
+      k[0] = Math.imul(k[0], C[0])
+      k[0] = rotl(k[0], 15)
+      k[0] = Math.imul(k[0], C[1])
+      hash[0] = (hash[0] ^ k[0])
+  }
+}
+
+function finalize (key : ArrayBuffer, hash : Uint32Array) {
+  hash[0] = (hash[0] ^ key.byteLength)
+  hash[1] = (hash[1] ^ key.byteLength)
+  hash[2] = (hash[2] ^ key.byteLength)
+  hash[3] = (hash[3] ^ key.byteLength)
+
+  hash[0] = (hash[0] + hash[1]) | 0
+  hash[0] = (hash[0] + hash[2]) | 0
+  hash[0] = (hash[0] + hash[3]) | 0
+
+  hash[1] = (hash[1] + hash[0]) | 0
+  hash[2] = (hash[2] + hash[0]) | 0
+  hash[3] = (hash[3] + hash[0]) | 0
+
+  hash[0] = fmix(hash[0])
+  hash[1] = fmix(hash[1])
+  hash[2] = fmix(hash[2])
+  hash[3] = fmix(hash[3])
+
+  hash[0] = (hash[0] + hash[1]) | 0
+  hash[0] = (hash[0] + hash[2]) | 0
+  hash[0] = (hash[0] + hash[3]) | 0
+
+  hash[1] = (hash[1] + hash[0]) | 0
+  hash[2] = (hash[2] + hash[0]) | 0
+  hash[3] = (hash[3] + hash[0]) | 0
+}
+
+export function hash (key : ArrayBuffer | string, seed = 0) : string {
+  seed = (seed ? (seed | 0) : 0)
+
+  if (typeof key === 'string') {
+    key = encodeUtf8(key)
+  }
+
+  if (!(key instanceof ArrayBuffer)) {
+    throw new TypeError('Expected key to be ArrayBuffer or string')
+  }
+
+  const hash = new Uint32Array([seed, seed, seed, seed])
+
+  body(key, hash)
+  tail(key, hash)
+  finalize(key, hash)
+  const byteArray = new Uint8Array(hash.buffer);
+  return Array.from(byteArray).map(byte => byte.toString(16).padStart(2, '0')).join('');
+}

package/src/utils/imageDataToDataURL.ts

@@ -0,0 +1,15 @@
+export function imageDataToDataURL(imageData: ImageData): string {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+
+    if (!context) {
+        throw new Error('Canvas context not supported');
+    }
+
+    canvas.width = imageData.width;
+    canvas.height = imageData.height;
+
+    context.putImageData(imageData, 0, 0);
+
+    return canvas.toDataURL();
+}

package/src/utils/raceAll.ts

@@ -0,0 +1,45 @@
+import { componentInterface } from '../factory'
+
+type DelayedPromise<T> = Promise<T>;
+
+export function delay<T>(t: number, val: T): DelayedPromise<T> {
+  return new Promise<T>((resolve) => {
+    setTimeout(() => resolve(val), t);
+  });
+}
+
+
+export interface RaceResult<T> {
+  value: T;
+  elapsed?: number;
+}
+
+export function raceAllPerformance<T>(
+  promises: Promise<T>[],
+  timeoutTime: number,
+  timeoutVal: T
+): Promise<RaceResult<T>[]> {
+  return Promise.all(
+    promises.map((p) => {
+      const startTime = performance.now();
+      return Promise.race([
+        p.then((value) => ({
+          value,
+          elapsed: performance.now() - startTime,
+        })),
+        delay(timeoutTime, timeoutVal).then((value) => ({
+          value,
+          elapsed: performance.now() - startTime,
+        })),
+      ]);
+    })
+  );
+}
+
+
+
+export function raceAll<T>(promises: Promise<T>[], timeoutTime: number, timeoutVal: T): Promise<(T | undefined)[]> {
+  return Promise.all(promises.map((p) => {
+    return Promise.race([p, delay(timeoutTime, timeoutVal)]);
+  }));
+}