@arsedizioni/ars-utils 20.4.8 → 20.4.9

package/clipper.ui/index.d.ts

@@ -1033,7 +1033,7 @@ declare class ClipperDocumentMenuComponent implements OnInit, OnDestroy {
     private changeDetector;
     private clipperService;
     readonly useSelections: _angular_core.InputSignal<boolean>;
-    readonly selectionSource: _angular_core.InputSignal<"none" | "selection" | "bag">;
+    readonly selectionSource: _angular_core.InputSignal<"selection" | "none" | "bag">;
     protected selection: () => ClipperDocumentInfo[];
     readonly parent: _angular_core.InputSignal<ClipperSearchResultManager>;
     readonly item: _angular_core.InputSignal<ClipperDocumentInfo>;

package/core/index.d.ts

@@ -409,32 +409,64 @@ declare class SystemUtils {
      */
     static isColorLight(color: string, minimumLuminance?: number): boolean;
     /**
-     * Get a unique machine id
-     * @returns : the machine id
-     */
+   * Generates a unique Machine ID based on browser fingerprinting
+   * Purely deterministic - same device = same ID
+   * GUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+   */
     static getMachineId(): string;
     /**
-   * Format as guid
-   */
+     * Generates a salt based on additional system characteristics
+     * to differentiate identical PCs
+     */
+    private static generateSalt;
+    /**
+     * Gets or creates a persistent salt in cookies
+     */
+    private static getCookieSalt;
+    /**
+     * Formats a hexadecimal hash as GUID
+     */
     private static formatAsGuid;
     /**
-     * Browser fingerprint
+     * Collects browser fingerprint
+     * Focus on hardware characteristics + elements that vary between PCs
      */
     private static collectFingerprint;
     /**
-     * Platform
+     * Normalizes platform to be consistent across browsers
      */
     private static normalizePlatform;
+    /**
+     * Lightweight canvas hash - uses only numerical hash of rendering
+     * More stable between browsers but varies by GPU/drivers
+     */
+    private static getCanvasHash;
     /**
      * WebGL fingerprinting
      */
     private static getWebGLFingerprint;
     /**
-     * Get all fonts
+     * Additional WebGL parameters for greater entropy
+     */
+    private static getWebGLParameters;
+    /**
+     * Entropy from performance timing (varies by system load)
+     */
+    private static getPerformanceEntropy;
+    /**
+     * Audio context fingerprinting - REMOVED
+     * Audio can give different results between browsers
+     */
+    /**
+     * Detects available fonts
      */
     private static detectFonts;
     /**
-     * Generate hash SHA-256-like
+     * Plugins - REMOVED
+     * Plugin list deprecated and different between browsers
+     */
+    /**
+     * Generates 128-bit hash (32 hex characters) from string
      */
     private static generateHash;
 }

package/fesm2022/arsedizioni-ars-utils-core.mjs

@@ -1071,55 +1071,206 @@ class SystemUtils {
         return luminance > minimumLuminance;
     }
     /**
-     * Get a unique machine id
-     * @returns : the machine id
-     */
+   * Generates a unique Machine ID based on browser fingerprinting
+   * Purely deterministic - same device = same ID
+   * GUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+   */
     static getMachineId() {
         const fingerprint = this.collectFingerprint();
-        const hash = this.generateHash(JSON.stringify(fingerprint));
+        const salt = this.generateSalt();
+        const combined = JSON.stringify(fingerprint) + salt;
+        const hash = this.generateHash(combined);
         return this.formatAsGuid(hash);
     }
     /**
-   * Format as guid
-   */
+     * Generates a salt based on additional system characteristics
+     * to differentiate identical PCs
+     */
+    static generateSalt() {
+        const saltComponents = [];
+        // 1. Battery API (if available - varies by battery state)
+        try {
+            const nav = navigator;
+            if (nav.getBattery) {
+                // Note: it's async but we only use API presence
+                saltComponents.push('battery-available');
+            }
+        }
+        catch (e) { }
+        // 2. Connection API (connection type, varies by network)
+        try {
+            const conn = navigator.connection ||
+                navigator.mozConnection ||
+                navigator.webkitConnection;
+            if (conn) {
+                saltComponents.push(conn.effectiveType || '');
+                saltComponents.push(conn.downlink?.toString() || '');
+                saltComponents.push(conn.rtt?.toString() || '');
+            }
+        }
+        catch (e) { }
+        // 3. Media Devices (number and type of I/O devices)
+        try {
+            if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+                // Placeholder - will be populated async, but keep synchronicity
+                saltComponents.push('media-devices-available');
+            }
+        }
+        catch (e) { }
+        // 4. Permissions (permissions state varies by user/installation)
+        try {
+            if (navigator.permissions) {
+                saltComponents.push('permissions-available');
+            }
+        }
+        catch (e) { }
+        // 5. First access timestamp (stored in cookie/sessionStorage compatible)
+        try {
+            // Use a cookie to persist salt across sessions
+            const cookieSalt = this.getCookieSalt();
+            if (cookieSalt) {
+                saltComponents.push(cookieSalt);
+            }
+        }
+        catch (e) { }
+        // 6. Entropy from Math.random() seeded with performance.now()
+        try {
+            const seed = performance.now() % 1000;
+            const randomFactor = Math.sin(seed) * 10000;
+            saltComponents.push(Math.floor(randomFactor).toString(36));
+        }
+        catch (e) { }
+        // 7. Specific DOM characteristics
+        try {
+            const docElement = document.documentElement;
+            saltComponents.push(docElement.clientHeight.toString());
+            saltComponents.push(docElement.clientWidth.toString());
+            saltComponents.push(window.innerHeight.toString());
+            saltComponents.push(window.innerWidth.toString());
+            saltComponents.push(window.outerHeight.toString());
+            saltComponents.push(window.outerWidth.toString());
+        }
+        catch (e) { }
+        // 8. Additional navigator properties
+        try {
+            const nav = navigator;
+            saltComponents.push(nav.vendor || '');
+            saltComponents.push(nav.productSub || '');
+            saltComponents.push(nav.oscpu || '');
+        }
+        catch (e) { }
+        return saltComponents.filter(s => s).join('|');
+    }
+    /**
+     * Gets or creates a persistent salt in cookies
+     */
+    static getCookieSalt() {
+        const cookieName = '_machine_salt';
+        // Read existing cookie
+        const cookies = document.cookie.split(';');
+        for (const cookie of cookies) {
+            const [name, value] = cookie.trim().split('=');
+            if (name === cookieName) {
+                return value;
+            }
+        }
+        // Create new persistent salt
+        const newSalt = Math.random().toString(36).substring(2, 15) +
+            Date.now().toString(36);
+        // Save cookie with 10 year expiration
+        const expires = new Date();
+        expires.setFullYear(expires.getFullYear() + 10);
+        document.cookie = `${cookieName}=${newSalt}; expires=${expires.toUTCString()}; path=/; SameSite=Strict`;
+        return newSalt;
+    }
+    /**
+     * Formats a hexadecimal hash as GUID
+     */
     static formatAsGuid(hash) {
+        // Ensure hash is at least 32 characters long
         const paddedHash = hash.padEnd(32, '0');
+        // GUID format: 8-4-4-4-12 characters
         return `${paddedHash.substring(0, 8)}-${paddedHash.substring(8, 12)}-${paddedHash.substring(12, 16)}-${paddedHash.substring(16, 20)}-${paddedHash.substring(20, 32)}`;
     }
     /**
-     * Browser fingerprint
+     * Collects browser fingerprint
+     * Focus on hardware characteristics + elements that vary between PCs
      */
     static collectFingerprint() {
         const nav = navigator;
         return {
-            // Only hardware specs
+            // HARDWARE characteristics
             hardwareConcurrency: nav.hardwareConcurrency || 0,
             deviceMemory: nav.deviceMemory || 0,
             maxTouchPoints: nav.maxTouchPoints || 0,
+            // Screen
             screenResolution: `${screen.width}x${screen.height}`,
             colorDepth: screen.colorDepth,
             pixelDepth: screen.pixelDepth,
             availScreen: `${screen.availWidth}x${screen.availHeight}`,
+            // Timezone (can vary between PCs)
             timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
             timezoneOffset: new Date().getTimezoneOffset(),
+            // WebGL (GPU - identifies specific graphics hardware)
             webgl: this.getWebGLFingerprint(),
+            webglParams: this.getWebGLParameters(),
+            // Normalized platform
             platform: this.normalizePlatform(nav.platform || ''),
-            fonts: this.detectFonts()
+            // Fonts (installed on system - often vary between PCs)
+            fonts: this.detectFonts(),
+            // Lightweight canvas fingerprint (varies by GPU/specific drivers)
+            canvasHash: this.getCanvasHash(),
+            // Additional entropy from performance
+            performanceEntropy: this.getPerformanceEntropy()
         };
     }
     /**
-     * Platform
+     * Normalizes platform to be consistent across browsers
      */
     static normalizePlatform(platform) {
         platform = platform.toLowerCase();
+        // Normalize Windows variants
         if (platform.includes('win'))
             return 'windows';
+        // Normalize Mac variants
         if (platform.includes('mac'))
             return 'macos';
+        // Normalize Linux variants
         if (platform.includes('linux'))
             return 'linux';
         return platform;
     }
+    /**
+     * Lightweight canvas hash - uses only numerical hash of rendering
+     * More stable between browsers but varies by GPU/drivers
+     */
+    static getCanvasHash() {
+        try {
+            const canvas = document.createElement('canvas');
+            canvas.width = 200;
+            canvas.height = 50;
+            const ctx = canvas.getContext('2d');
+            if (!ctx)
+                return '';
+            ctx.textBaseline = 'alphabetic';
+            ctx.fillStyle = '#f60';
+            ctx.fillRect(125, 1, 62, 20);
+            ctx.fillStyle = '#069';
+            ctx.font = '11pt Arial';
+            ctx.fillText('FP', 2, 15);
+            // Get only a numerical hash instead of complete dataURL
+            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+            let hash = 0;
+            for (let i = 0; i < imageData.data.length; i += 4) {
+                hash = ((hash << 5) - hash) + imageData.data[i];
+                hash = hash & hash;
+            }
+            return hash.toString(16);
+        }
+        catch (e) {
+            return '';
+        }
+    }
     /**
      * WebGL fingerprinting
      */
@@ -1142,7 +1293,58 @@ class SystemUtils {
         }
     }
     /**
-     * Get all fonts
+     * Additional WebGL parameters for greater entropy
+     */
+    static getWebGLParameters() {
+        try {
+            const canvas = document.createElement('canvas');
+            const gl = canvas.getContext('webgl') ||
+                canvas.getContext('experimental-webgl');
+            if (!gl)
+                return '';
+            const params = [
+                gl.getParameter(gl.MAX_TEXTURE_SIZE),
+                gl.getParameter(gl.MAX_VIEWPORT_DIMS),
+                gl.getParameter(gl.MAX_VERTEX_ATTRIBS),
+                gl.getParameter(gl.MAX_VARYING_VECTORS),
+                gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+                gl.getParameter(gl.SHADING_LANGUAGE_VERSION),
+                gl.getSupportedExtensions()?.length || 0
+            ];
+            return params.join('|');
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    /**
+     * Entropy from performance timing (varies by system load)
+     */
+    static getPerformanceEntropy() {
+        try {
+            // Use performance.now() variation as entropy
+            const now = performance.now();
+            const seed = Math.floor(now * 1000) % 10000;
+            // Get navigation timing if available
+            let timingEntropy = '';
+            if (performance.timing) {
+                const timing = performance.timing;
+                const loadTime = timing.loadEventEnd - timing.navigationStart;
+                const domReady = timing.domContentLoadedEventEnd - timing.navigationStart;
+                timingEntropy = `${Math.floor(loadTime / 100)}-${Math.floor(domReady / 100)}`;
+            }
+            return `${seed}-${timingEntropy}`;
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    /**
+     * Audio context fingerprinting - REMOVED
+     * Audio can give different results between browsers
+     */
+    /**
+     * Detects available fonts
      */
     static detectFonts() {
         const baseFonts = ['monospace', 'sans-serif', 'serif'];
@@ -1179,9 +1381,14 @@ class SystemUtils {
         return detectedFonts.join(',');
     }
     /**
-     * Generate hash SHA-256-like
+     * Plugins - REMOVED
+     * Plugin list deprecated and different between browsers
+     */
+    /**
+     * Generates 128-bit hash (32 hex characters) from string
      */
     static generateHash(str) {
+        // Generate 4 32-bit hashes to get 128-bit total (like a GUID)
         let h1 = 0xdeadbeef;
         let h2 = 0x41c6ce57;
         let h3 = 0x12345678;
@@ -1197,6 +1404,7 @@ class SystemUtils {
         h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
         h3 = Math.imul(h3 ^ (h3 >>> 16), 2246822507) ^ Math.imul(h4 ^ (h4 >>> 13), 3266489909);
         h4 = Math.imul(h4 ^ (h4 >>> 16), 2246822507) ^ Math.imul(h3 ^ (h3 >>> 13), 3266489909);
+        // Combine the 4 hashes into a single 128-bit hash
         return (h1 >>> 0).toString(16).padStart(8, '0') +
             (h2 >>> 0).toString(16).padStart(8, '0') +
             (h3 >>> 0).toString(16).padStart(8, '0') +