@arsedizioni/ars-utils 20.4.9 → 20.4.11

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<"selection" | "none" | "bag">;
+    readonly selectionSource: _angular_core.InputSignal<"none" | "selection" | "bag">;
     protected selection: () => ClipperDocumentInfo[];
     readonly parent: _angular_core.InputSignal<ClipperSearchResultManager>;
     readonly item: _angular_core.InputSignal<ClipperDocumentInfo>;

package/core/index.d.ts

@@ -409,64 +409,36 @@ declare class SystemUtils {
      */
     static isColorLight(color: string, minimumLuminance?: number): boolean;
     /**
-   * 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;
-    /**
-     * 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
+     * Get a unique machine id
+     * @returns : the machine id
      */
-    private static formatAsGuid;
+    static getMachineId(): string;
     /**
-     * Collects browser fingerprint
-     * Focus on hardware characteristics + elements that vary between PCs
+     * Browser fingerprint
      */
     private static collectFingerprint;
     /**
-     * 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
+     * Canvas fingerprinting
      */
-    private static getCanvasHash;
+    private static getCanvasFingerprint;
     /**
      * WebGL fingerprinting
      */
     private static getWebGLFingerprint;
     /**
-     * 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
+     * Audio context fingerprinting
      */
+    private static getAudioFingerprint;
     /**
-     * Detects available fonts
+     * Rileva font disponibili
      */
     private static detectFonts;
     /**
-     * Plugins - REMOVED
-     * Plugin list deprecated and different between browsers
+     * Ottiene lista plugins
      */
+    private static getPlugins;
     /**
-     * Generates 128-bit hash (32 hex characters) from string
+     * Genera hash SHA-256-like da stringa (semplificato)
      */
     private static generateHash;
 }

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

@@ -1071,180 +1071,46 @@ class SystemUtils {
         return luminance > minimumLuminance;
     }
     /**
-   * Generates a unique Machine ID based on browser fingerprinting
-   * Purely deterministic - same device = same ID
-   * GUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-   */
+     * Get a unique machine id
+     * @returns : the machine id
+     */
     static getMachineId() {
         const fingerprint = this.collectFingerprint();
-        const salt = this.generateSalt();
-        const combined = JSON.stringify(fingerprint) + salt;
-        const hash = this.generateHash(combined);
-        return this.formatAsGuid(hash);
-    }
-    /**
-     * 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;
+        const hash = this.generateHash(JSON.stringify(fingerprint));
+        return hash;
     }
     /**
-     * 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)}`;
-    }
-    /**
-     * Collects browser fingerprint
-     * Focus on hardware characteristics + elements that vary between PCs
+     * Browser fingerprint
      */
     static collectFingerprint() {
         const nav = navigator;
         return {
-            // HARDWARE characteristics
+            userAgent: nav.userAgent || '',
+            language: nav.language || '',
+            languages: nav.languages ? nav.languages.join(',') : '',
+            platform: nav.platform || '',
             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)
+            canvas: this.getCanvasFingerprint(),
             webgl: this.getWebGLFingerprint(),
-            webglParams: this.getWebGLParameters(),
-            // Normalized platform
-            platform: this.normalizePlatform(nav.platform || ''),
-            // Fonts (installed on system - often vary between PCs)
+            audio: this.getAudioFingerprint(),
             fonts: this.detectFonts(),
-            // Lightweight canvas fingerprint (varies by GPU/specific drivers)
-            canvasHash: this.getCanvasHash(),
-            // Additional entropy from performance
-            performanceEntropy: this.getPerformanceEntropy()
+            plugins: this.getPlugins(),
+            cookieEnabled: nav.cookieEnabled,
+            doNotTrack: nav.doNotTrack || 'unknown'
         };
     }
     /**
-     * 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
+     * Canvas fingerprinting
      */
-    static getCanvasHash() {
+    static getCanvasFingerprint() {
         try {
             const canvas = document.createElement('canvas');
             canvas.width = 200;
@@ -1257,15 +1123,11 @@ class SystemUtils {
             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);
+            ctx.fillText('MachineID 🔒', 2, 15);
+            ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
+            ctx.font = 'bold 18pt Times';
+            ctx.fillText('Fingerprint', 4, 45);
+            return canvas.toDataURL();
         }
         catch (e) {
             return '';
@@ -1293,58 +1155,36 @@ class SystemUtils {
         }
     }
     /**
-     * Additional WebGL parameters for greater entropy
+     * Audio context fingerprinting
      */
-    static getWebGLParameters() {
+    static getAudioFingerprint() {
         try {
-            const canvas = document.createElement('canvas');
-            const gl = canvas.getContext('webgl') ||
-                canvas.getContext('experimental-webgl');
-            if (!gl)
+            const AudioContext = window.AudioContext ||
+                window.webkitAudioContext;
+            if (!AudioContext)
                 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('|');
+            const context = new AudioContext();
+            const oscillator = context.createOscillator();
+            const analyser = context.createAnalyser();
+            const gainNode = context.createGain();
+            const scriptProcessor = context.createScriptProcessor(4096, 1, 1);
+            gainNode.gain.value = 0;
+            oscillator.connect(analyser);
+            analyser.connect(scriptProcessor);
+            scriptProcessor.connect(gainNode);
+            gainNode.connect(context.destination);
+            oscillator.start(0);
+            const fingerprint = `${context.sampleRate}-${analyser.fftSize}`;
+            oscillator.stop();
+            context.close();
+            return fingerprint;
         }
         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
+     * Rileva font disponibili
      */
     static detectFonts() {
         const baseFonts = ['monospace', 'sans-serif', 'serif'];
@@ -1381,34 +1221,30 @@ class SystemUtils {
         return detectedFonts.join(',');
     }
     /**
-     * Plugins - REMOVED
-     * Plugin list deprecated and different between browsers
+     * Ottiene lista plugins
      */
+    static getPlugins() {
+        const plugins = [];
+        for (let i = 0; i < navigator.plugins.length; i++) {
+            plugins.push(navigator.plugins[i].name);
+        }
+        return plugins.join(',');
+    }
     /**
-     * Generates 128-bit hash (32 hex characters) from string
+     * Genera hash SHA-256-like da stringa (semplificato)
      */
     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;
-        let h4 = 0x9abcdef0;
         for (let i = 0; i < str.length; i++) {
             const ch = str.charCodeAt(i);
             h1 = Math.imul(h1 ^ ch, 2654435761);
             h2 = Math.imul(h2 ^ ch, 1597334677);
-            h3 = Math.imul(h3 ^ ch, 2246822507);
-            h4 = Math.imul(h4 ^ ch, 3266489909);
         }
         h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
         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') +
-            (h4 >>> 0).toString(16).padStart(8, '0');
+        const hash = 4294967296 * (2097151 & h2) + (h1 >>> 0);
+        return hash.toString(16).padStart(16, '0');
     }
 }