Delete storage.js

storage.js

@@ -1,599 +0,0 @@
-// ============================================================================
-// File: storage.js
-// ============================================================================
-
-(global => {
-    'use strict';
-
-    const DB_NAME = "FritreeEnterpriseDB";
-    const DB_VERSION = 3; 
-    
-    const STORES = {
-        MEDIA: "media_assets",       
-        HISTORY: "campaign_history",  
-        SYSTEM: "system_metadata"     
-    };
-
-    // Keys monitored under the Double-Anchor Signature Integrity Verification (SIS)
-    // Enforces strict anti-tampering verification for level metrics, cards, and USD balances
-    const SECURE_SIS_KEYS = new Set([
-        "acc_userLevel", 
-        "acc_userXP", 
-        "acc_lifetimeFb",
-        "acc_lifetimeWa",
-        "acc_lifetimeTasks",
-        "local_previous_posts",
-        "wa_connected",
-        "wa_sent_today",
-        "acc_fbShares",
-        "acc_waShares",
-        "userPoints" // Represents USD balance
-    ]);
-
-    // Constant validation salt tied to SHA-256 integrity seal
-    const INTEGRITY_SEAL_SALT = "FritreeSymmetricIntegritySeal_WebCrypto_Strict_SHA256_Production_Salt_2026";
-
-    // Configuration keys stored via standard WebCrypto GCM encryption envelopes
-    const LIGHTWEIGHT_CONFIG_KEYS = new Set([
-        "userPoints",
-        "userPointsSig",
-        "fritree_account_id",
-        "acc_fbShares",
-        "acc_fbShares_sig",
-        "acc_waShares",
-        "acc_waShares_sig",
-        "acc_userLevel",
-        "acc_userXP",
-        "acc_lifetimeFb",
-        "acc_lifetimeWa",
-        "acc_lifetimeTasks",
-        "acc_activeSub",
-        "acc_subExpiry",
-        "local_sleep_intervals",
-        "local_protection_settings",
-        "local_shield_config_matrix",
-        "wa_connected",
-        "wa_phone_number",
-        "wa_profile_name",
-        "wa_sent_today"
-    ]);
-
-    let dbInstance = null;
-    let isDbInitializing = false;
-    const dbInitPromiseResolvers = [];
-
-    // ============================================================================
-    // Asynchronous Execution Queue to Mitigate Database Write Collisions
-    // ============================================================================
-    class AsyncWriteQueue {
-        constructor() {
-            this.queue = [];
-            this.isProcessing = false;
-        }
-
-        enqueue(task) {
-            return new Promise((resolve, reject) => {
-                this.queue.push({ task, resolve, reject });
-                this.processNext();
-            });
-        }
-
-        async processNext() {
-            if (this.isProcessing || this.queue.length === 0) return;
-            this.isProcessing = true;
-
-            const { task, resolve, reject } = this.queue.shift();
-            try {
-                const result = await task();
-                resolve(result);
-            } catch (err) {
-                reject(err);
-            } finally {
-                this.isProcessing = false;
-                this.processNext();
-            }
-        }
-    }
-
-    const storageWriteQueue = new AsyncWriteQueue();
-
-    // ============================================================================
-    // IndexedDB Connection Lifecycles
-    // ============================================================================
-    function initIndexedDB() {
-        if (dbInstance) return Promise.resolve(dbInstance);
-        if (isDbInitializing) {
-            return new Promise((resolve, reject) => {
-                dbInitPromiseResolvers.push({ resolve, reject });
-            });
-        }
-
-        isDbInitializing = true;
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(DB_NAME, DB_VERSION);
-
-            request.onupgradeneeded = event => {
-                const db = event.target.result;
-                Object.values(STORES).forEach(storeName => {
-                    if (!db.objectStoreNames.contains(storeName)) {
-                        db.createObjectStore(storeName, { keyPath: "id" });
-                    }
-                });
-            };
-
-            request.onsuccess = event => {
-                dbInstance = event.target.result;
-                isDbInitializing = false;
-                resolve(dbInstance);
-
-                dbInitPromiseResolvers.forEach(r => r.resolve(dbInstance));
-                dbInitPromiseResolvers.length = 0;
-            };
-
-            request.onerror = event => {
-                isDbInitializing = false;
-                reject(event.target.error);
-
-                dbInitPromiseResolvers.forEach(r => r.reject(event.target.error));
-                dbInitPromiseResolvers.length = 0;
-            };
-        });
-    }
-
-    function base64ToBlob(base64Data, mimeType) {
-        const byteCharacters = atob(base64Data.split(",")[1] || base64Data);
-        const byteArrays = [];
-
-        for (let offset = 0; offset < byteCharacters.length; offset += 512) {
-            const slice = byteCharacters.slice(offset, offset + 512);
-            const byteNumbers = new Array(slice.length);
-            for (let i = 0; i < slice.length; i++) {
-                byteNumbers[i] = slice.charCodeAt(i);
-            }
-            const byteArray = new Uint8Array(byteNumbers);
-            byteArrays.push(byteArray);
-        }
-
-        return new Blob(byteArrays, { type: mimeType });
-    }
-
-    function blobToBase64(blob) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onloadend = () => resolve(reader.result);
-            reader.onerror = reject;
-            reader.readAsDataURL(blob);
-        });
-    }
-
-    async function writeIndexedDBEntry(storeName, key, encryptedValue) {
-        const db = await initIndexedDB();
-        return new Promise((resolve, reject) => {
-            const transaction = db.transaction([storeName], "readwrite");
-            const store = transaction.objectStore(storeName);
-            
-            const putRequest = store.put({ id: key, payload: encryptedValue, updated_at: Date.now() });
-
-            putRequest.onsuccess = () => resolve(true);
-            putRequest.onerror = e => reject(e.target.error);
-        });
-    }
-
-    async function readIndexedDBEntry(storeName, key) {
-        const db = await initIndexedDB();
-        return new Promise(resolve => {
-            const transaction = db.transaction([storeName], "readonly");
-            const store = transaction.objectStore(storeName);
-            const getRequest = store.get(key);
-
-            getRequest.onsuccess = e => {
-                const record = e.target.result;
-                resolve(record ? record.payload : null);
-            };
-
-            getRequest.onerror = () => {
-                resolve(null);
-            };
-        });
-    }
-
-    async function deleteIndexedDBEntry(storeName, key) {
-        const db = await initIndexedDB();
-        return new Promise((resolve, reject) => {
-            const transaction = db.transaction([storeName], "readwrite");
-            const store = transaction.objectStore(storeName);
-            const deleteRequest = store.delete(key);
-
-            deleteRequest.onsuccess = () => resolve(true);
-            deleteRequest.onerror = e => reject(e.target.error);
-        });
-    }
-
-    function routeIndexedDBStore(key) {
-        if (key === "campaignHistoryData") {
-            return STORES.HISTORY;
-        } else if (key === "local_previous_posts") {
-            return STORES.MEDIA;
-        }
-        return STORES.SYSTEM;
-    }
-
-    // ============================================================================
-    // Double-Anchor Secondary Verification Anchors
-    // ============================================================================
-    async function computeSecureSymmetricChecksum(key, data) {
-        let stringData = "";
-        if (typeof data === 'number') {
-            // Precise floating-point serialization lock for USD to avoid numeric evaluation rounding errors
-            stringData = key === 'userPoints' ? data.toFixed(2) : String(data);
-        } else if (typeof data === 'object') {
-            stringData = JSON.stringify(data);
-        } else {
-            stringData = String(data);
-        }
-
-        const payloadString = `${key}:${stringData}:${INTEGRITY_SEAL_SALT}`;
-        if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.sha256 === 'function') {
-            return await FritreeCrypto.sha256(payloadString);
-        }
-        
-        let hash = 0;
-        const inputStr = payloadString;
-        for (let i = 0; i < inputStr.length; i++) {
-            const char = inputStr.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash |= 0;
-        }
-        return "fallback_sha256_" + Math.abs(hash).toString(16);
-    }
-
-    async function writeSecondarySignatureAnchor(key, signature) {
-        const obfuscatedSigKey = await asyncHashKey(`sis_anchor_sig_${key}`);
-        if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-            const payload = {};
-            payload[obfuscatedSigKey] = signature;
-            return new Promise(res => chrome.storage.local.set(payload, () => res(true)));
-        } else {
-            localStorage.setItem(syncHashKey(`sis_anchor_sig_${key}`), signature);
-            return true;
-        }
-    }
-
-    async function readSecondarySignatureAnchor(key) {
-        const obfuscatedSigKey = await asyncHashKey(`sis_anchor_sig_${key}`);
-        if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-            return new Promise(res => {
-                chrome.storage.local.get(obfuscatedSigKey, payload => {
-                    res(payload[obfuscatedSigKey] || null);
-                });
-            });
-        } else {
-            return localStorage.getItem(syncHashKey(`sis_anchor_sig_${key}`)) || null;
-        }
-    }
-
-    async function deleteSecondarySignatureAnchor(key) {
-        const obfuscatedSigKey = await asyncHashKey(`sis_anchor_sig_${key}`);
-        if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-            return new Promise(res => chrome.storage.local.remove(obfuscatedSigKey, () => res(true)));
-        } else {
-            localStorage.removeItem(syncHashKey(`sis_anchor_sig_${key}`));
-            return true;
-        }
-    }
-
-    // ============================================================================
-    // Storage Interface Operations
-    // ============================================================================
-    const UnifiedStorageManager = {
-        set: function(key, value) {
-            return storageWriteQueue.enqueue(async () => {
-                if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.validateData === 'function') {
-                    if (!FritreeCrypto.validateData(value, key)) {
-                        return false;
-                    }
-                }
-
-                // Compile and seal state signatures across local stores
-                if (SECURE_SIS_KEYS.has(key)) {
-                    const dynamicSig = await computeSecureSymmetricChecksum(key, value);
-                    await writeIndexedDBEntry(STORES.SYSTEM, `local_sis_sig_${key}`, dynamicSig);
-                    await writeSecondarySignatureAnchor(key, dynamicSig);
-                    
-                    // Secure dual backup points to facilitate self-healing recovery
-                    await writeIndexedDBEntry(STORES.SYSTEM, `local_sis_backup_${key}`, value);
-                    if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.setStorage === 'function') {
-                        await FritreeCrypto.setStorage(`sis_backup_${key}`, value);
-                    }
-                }
-
-                // Directly route raw Blob files to the IndexedDB media store
-                if (value instanceof Blob) {
-                    try {
-                        const targetStore = STORES.MEDIA; 
-                        await writeIndexedDBEntry(targetStore, key, value);
-                        return true;
-                    } catch (dbErr) {
-                        console.error("[Fritree Storage] Binary media write failure:", dbErr);
-                        return false;
-                    }
-                }
-
-                // Handle standard extension configurations via Chrome Local Storage
-                if (LIGHTWEIGHT_CONFIG_KEYS.has(key)) {
-                    if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.setStorage === 'function') {
-                        return await FritreeCrypto.setStorage(key, value);
-                    }
-                    
-                    const localBackupKey = syncHashKey(key);
-                    const plainSerialized = JSON.stringify(value);
-                    const localMockCipher = btoa(unescape(encodeURIComponent(plainSerialized)));
-                    localStorage.setItem(localBackupKey, `fte_fallback_enc:${localMockCipher}`);
-                    return true;
-                }
-
-                // Process high-capacity campaign histories and template registries
-                const targetStore = routeIndexedDBStore(key);
-                try {
-                    if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.setStorage === 'function') {
-                        await FritreeCrypto.setStorage(key, value);
-                    } else {
-                        throw new Error("Cryptographic module is offline.");
-                    }
-                    
-                    const obfuscatedKey = await asyncHashKey(key);
-                    const freshCipher = await new Promise(res => {
-                        if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-                            chrome.storage.local.get(obfuscatedKey, payload => res(payload[obfuscatedKey]));
-                        } else {
-                            res(localStorage.getItem(obfuscatedKey));
-                        }
-                    });
-
-                    if (freshCipher) {
-                        await writeIndexedDBEntry(targetStore, key, freshCipher);
-                        
-                        if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-                            chrome.storage.local.remove(obfuscatedKey);
-                        } else {
-                            localStorage.removeItem(obfuscatedKey);
-                        }
-                        return true;
-                    }
-                } catch (dbErr) {
-                    console.warn("[Fritree Storage] IndexedDB route missed. Fallback to LocalStorage:", dbErr);
-                    if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.setStorage === 'function') {
-                        return await FritreeCrypto.setStorage(key, value);
-                    }
-                }
-                return false;
-            });
-        },
-
-        get: function(key, defaultValue = null) {
-            return new Promise(async resolve => {
-                try {
-                    let decryptedValue = null;
-
-                    if (LIGHTWEIGHT_CONFIG_KEYS.has(key)) {
-                        if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.getStorage === 'function') {
-                            decryptedValue = await FritreeCrypto.getStorage(key, defaultValue);
-                        } else {
-                            const raw = localStorage.getItem(syncHashKey(key));
-                            if (raw) {
-                                if (raw.startsWith("fte_fallback_enc:")) {
-                                    const cipherPart = raw.slice("fte_fallback_enc:".length);
-                                    const plain = decodeURIComponent(escape(atob(cipherPart)));
-                                    decryptedValue = JSON.parse(plain);
-                                } else {
-                                    decryptedValue = JSON.parse(raw);
-                                }
-                            } else {
-                                decryptedValue = defaultValue;
-                            }
-                        }
-                    } else {
-                        const isMediaKey = key.startsWith("media_blob_") || key.startsWith("media_thumb_") || key.startsWith("media_") || key.startsWith("rot_media_") || key.startsWith("wa_composer_");
-                        const targetStore = isMediaKey ? STORES.MEDIA : routeIndexedDBStore(key);
-                        const cipherPacket = await readIndexedDBEntry(targetStore, key);
-
-                        if (cipherPacket === null) {
-                            if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.getStorage === 'function') {
-                                decryptedValue = await FritreeCrypto.getStorage(key, defaultValue);
-                            } else {
-                                decryptedValue = defaultValue;
-                            }
-                        } else {
-                            if (cipherPacket instanceof Blob) {
-                                resolve(cipherPacket);
-                                return;
-                            }
-
-                            const obfuscatedKey = await asyncHashKey(key);
-                            const tempPayload = {};
-                            tempPayload[obfuscatedKey] = cipherPacket;
-                            
-                            if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-                                await new Promise(r => chrome.storage.local.set(tempPayload, r));
-                                decryptedValue = await FritreeCrypto.getStorage(key, defaultValue);
-                                chrome.storage.local.remove(obfuscatedKey); 
-                            } else {
-                                localStorage.setItem(obfuscatedKey, cipherPacket);
-                                decryptedValue = await FritreeCrypto.getStorage(key, defaultValue);
-                                localStorage.removeItem(obfuscatedKey);
-                            }
-                        }
-                    }
-
-                    // Run the Double-Anchor verification and reject external settings tampering
-                    if (SECURE_SIS_KEYS.has(key) && decryptedValue !== null && decryptedValue !== defaultValue) {
-                        const actualComputedSig = await computeSecureSymmetricChecksum(key, decryptedValue);
-                        
-                        const savedAnchorASig = await readIndexedDBEntry(STORES.SYSTEM, `local_sis_sig_${key}`);
-                        const savedAnchorBSig = await readSecondarySignatureAnchor(key);
-
-                        const isAnchorAValid = savedAnchorASig === actualComputedSig;
-                        const isAnchorBValid = savedAnchorBSig === actualComputedSig;
-
-                        if (!isAnchorAValid || !isAnchorBValid) {
-                            console.warn(`[Fritree Storage] Security Guard: Tampering detected for key: "${key}"! Attempting secure recovery...`);
-                            
-                            let recoveredValue = null;
-                            
-                            // Try to recover from IndexedDB Backup (Anchor A)
-                            const backupA = await readIndexedDBEntry(STORES.SYSTEM, `local_sis_backup_${key}`);
-                            if (backupA !== null) {
-                                const sigA = await computeSecureSymmetricChecksum(key, backupA);
-                                if (sigA === savedAnchorASig) {
-                                    recoveredValue = backupA;
-                                    console.log(`[Fritree Storage] Restored tampered "${key}" from secure IndexedDB backup.`);
-                                }
-                            }
-                            
-                            // Try to recover from LocalStorage Backup (Anchor B) if Anchor A was altered
-                            if (recoveredValue === null) {
-                                if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.getStorage === 'function') {
-                                    const backupB = await FritreeCrypto.getStorage(`sis_backup_${key}`, null);
-                                    if (backupB !== null) {
-                                        const sigB = await computeSecureSymmetricChecksum(key, backupB);
-                                        if (sigB === savedAnchorBSig) {
-                                            recoveredValue = backupB;
-                                            console.log(`[Fritree Storage] Restored tampered "${key}" from secure LocalStorage backup.`);
-                                        }
-                                    }
-                                }
-                            }
-                            
-                            if (recoveredValue !== null) {
-                                decryptedValue = recoveredValue;
-                                // Re-sync signatures
-                                const restoredSig = await computeSecureSymmetricChecksum(key, recoveredValue);
-                                await writeIndexedDBEntry(STORES.SYSTEM, `local_sis_sig_${key}`, restoredSig);
-                                await writeSecondarySignatureAnchor(key, restoredSig);
-                            } else {
-                                // If both backups are compromised, reject manipulation and revert to safe default state
-                                console.error(`[Fritree Storage] Critical Violation: Recovery failed for "${key}". Reverting to safe default.`);
-                                decryptedValue = defaultValue;
-                                
-                                const defaultSig = await computeSecureSymmetricChecksum(key, defaultValue);
-                                await writeIndexedDBEntry(STORES.SYSTEM, `local_sis_sig_${key}`, defaultSig);
-                                await writeSecondarySignatureAnchor(key, defaultSig);
-                                await writeIndexedDBEntry(STORES.SYSTEM, `local_sis_backup_${key}`, defaultValue);
-                                if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.setStorage === 'function') {
-                                    await FritreeCrypto.setStorage(`sis_backup_${key}`, defaultValue);
-                                }
-                            }
-                        }
-                    }
-
-                    resolve(decryptedValue !== null ? decryptedValue : defaultValue);
-
-                } catch (e) {
-                    console.error(`[Fritree Storage] Key retrieval failure for "${key}":`, e);
-                    resolve(defaultValue);
-                }
-            });
-        },
-
-        remove: function(key) {
-            return storageWriteQueue.enqueue(async () => {
-                const obfuscatedKey = await asyncHashKey(key);
-                
-                localStorage.removeItem(syncHashKey(key));
-                localStorage.removeItem(obfuscatedKey);
-                if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-                    chrome.storage.local.remove(obfuscatedKey);
-                }
-
-                const isMediaKey = key.startsWith("media_blob_") || key.startsWith("media_thumb_") || key.startsWith("media_") || key.startsWith("rot_media_") || key.startsWith("wa_composer_");
-                const targetStore = isMediaKey ? STORES.MEDIA : routeIndexedDBStore(key);
-                try {
-                    await deleteIndexedDBEntry(targetStore, key);
-                } catch (e) {
-                    console.error("[Fritree Storage] Store deletion error:", e);
-                }
-
-                if (SECURE_SIS_KEYS.has(key)) {
-                    try {
-                        await deleteIndexedDBEntry(STORES.SYSTEM, `local_sis_sig_${key}`);
-                        await deleteSecondarySignatureAnchor(key);
-                        await deleteIndexedDBEntry(STORES.SYSTEM, `local_sis_backup_${key}`);
-                        if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-                            const obfuscatedBackupKey = await asyncHashKey(`sis_backup_${key}`);
-                            chrome.storage.local.remove(obfuscatedBackupKey);
-                        }
-                    } catch (e) {
-                        console.error("[Fritree Storage] Anchor removal error:", e);
-                    }
-                }
-
-                if (!isMediaKey) {
-                    try {
-                        await deleteIndexedDBEntry(STORES.MEDIA, key);
-                    } catch (e) {
-                        console.error("[Fritree Storage] Fallback store removal error:", e);
-                    }
-                }
-                return true;
-            });
-        },
-
-        clear: function() {
-            return storageWriteQueue.enqueue(async () => {
-                localStorage.clear();
-                
-                if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
-                    await new Promise(r => chrome.storage.local.clear(r));
-                }
-
-                if (dbInstance) {
-                    dbInstance.close();
-                    dbInstance = null;
-                }
-                
-                return new Promise(resolve => {
-                    const deleteReq = indexedDB.deleteDatabase(DB_NAME);
-                    deleteReq.onsuccess = () => resolve(true);
-                    deleteReq.onerror = () => resolve(false);
-                });
-            });
-        },
-
-        b64ToBlob: base64ToBlob,
-        blobToB64: blobToBase64
-    };
-
-    async function asyncHashKey(key) {
-        if (typeof FritreeCrypto !== 'undefined' && typeof FritreeCrypto.sha256 === 'function') {
-            return "" + await FritreeCrypto.sha256(key + "FritreeKeySalt_2026_StrictSHA256_Hashed_Production_WebCrypto_Salt");
-        }
-        const input = key + "FritreeKeySalt_2026_StrictSHA256_Hashed_Production_WebCrypto_Salt";
-        let hash = 0;
-        for (let i = 0; i < input.length; i++) {
-            const char = input.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash |= 0;
-        }
-        return "fte_sh_sha256_" + Math.abs(hash).toString(16);
-    }
-
-    function syncHashKey(key) {
-        const input = key + "FritreeKeySalt_2026_StrictSHA256_Hashed_Production_WebCrypto_Salt";
-        let hash = 0;
-        for (let i = 0; i < input.length; i++) {
-            const char = input.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash |= 0;
-        }
-        return "fte_sh_sha256_" + Math.abs(hash).toString(16);
-    }
-
-    global.FritreeStorage = UnifiedStorageManager;
-
-    initIndexedDB().then(() => {
-        console.log("[Fritree Storage] Unified IndexedDB system online.");
-    }).catch(err => {
-        console.error("[Fritree Storage] Database upgrade/initialization failed:", err);
-    });
-
-})(typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : this);