canvasframework 0.5.18 → 0.5.20

package/utils/CryptoManager.js

@@ -0,0 +1,303 @@
+/**
+ * Gestionnaire de cryptographie pour le Canvas Framework
+ * Utilise l'API Web Crypto (SubtleCrypto) pour un chiffrement sécurisé
+ * @class
+ */
+class CryptoManager {
+  constructor() {
+    // Vérifier la disponibilité de l'API Crypto
+    if (!window.crypto || !window.crypto.subtle) {
+      throw new Error('Web Crypto API is not available in this browser');
+    }
+    
+    this.crypto = window.crypto.subtle;
+    
+    // Algorithme par défaut
+    this.algorithm = {
+      name: 'AES-GCM',
+      length: 256
+    };
+    
+    // Stockage des clés en mémoire (pas dans localStorage !)
+    this._keys = new Map();
+  }
+
+  /**
+   * Génère une clé de chiffrement aléatoire
+   * @param {string} keyName - Nom de la clé pour référence ultérieure
+   * @returns {Promise<CryptoKey>}
+   */
+  async generateKey(keyName = 'default') {
+    const key = await this.crypto.generateKey(
+      {
+        name: this.algorithm.name,
+        length: this.algorithm.length
+      },
+      true, // extractable
+      ['encrypt', 'decrypt']
+    );
+    
+    this._keys.set(keyName, key);
+    return key;
+  }
+
+  /**
+   * Importe une clé depuis une chaîne (base64)
+   * @param {string} keyString - Clé au format base64
+   * @param {string} keyName - Nom de la clé
+   * @returns {Promise<CryptoKey>}
+   */
+  async importKey(keyString, keyName = 'default') {
+    const keyBuffer = this._base64ToBuffer(keyString);
+    
+    const key = await this.crypto.importKey(
+      'raw',
+      keyBuffer,
+      { name: this.algorithm.name },
+      true,
+      ['encrypt', 'decrypt']
+    );
+    
+    this._keys.set(keyName, key);
+    return key;
+  }
+
+  /**
+   * Exporte une clé au format base64
+   * @param {string} keyName - Nom de la clé
+   * @returns {Promise<string>}
+   */
+  async exportKey(keyName = 'default') {
+    const key = this._keys.get(keyName);
+    if (!key) {
+      throw new Error(`Key "${keyName}" not found`);
+    }
+    
+    const exported = await this.crypto.exportKey('raw', key);
+    return this._bufferToBase64(exported);
+  }
+
+  /**
+   * Dérive une clé depuis un mot de passe
+   * @param {string} password - Mot de passe
+   * @param {string} keyName - Nom de la clé
+   * @param {string} salt - Salt (optionnel, généré automatiquement)
+   * @returns {Promise<{key: CryptoKey, salt: string}>}
+   */
+  async deriveKeyFromPassword(password, keyName = 'default', salt = null) {
+    // Générer ou utiliser le salt fourni
+    const saltBuffer = salt 
+      ? this._base64ToBuffer(salt)
+      : window.crypto.getRandomValues(new Uint8Array(16));
+    
+    // Encoder le mot de passe
+    const encoder = new TextEncoder();
+    const passwordBuffer = encoder.encode(password);
+    
+    // Importer le mot de passe comme clé
+    const keyMaterial = await this.crypto.importKey(
+      'raw',
+      passwordBuffer,
+      { name: 'PBKDF2' },
+      false,
+      ['deriveBits', 'deriveKey']
+    );
+    
+    // Dériver la clé
+    const key = await this.crypto.deriveKey(
+      {
+        name: 'PBKDF2',
+        salt: saltBuffer,
+        iterations: 100000,
+        hash: 'SHA-256'
+      },
+      keyMaterial,
+      { name: this.algorithm.name, length: this.algorithm.length },
+      true,
+      ['encrypt', 'decrypt']
+    );
+    
+    this._keys.set(keyName, key);
+    
+    return {
+      key,
+      salt: this._bufferToBase64(saltBuffer)
+    };
+  }
+
+  /**
+   * Chiffre des données
+   * @param {any} data - Données à chiffrer (sera converti en JSON)
+   * @param {string} keyName - Nom de la clé à utiliser
+   * @returns {Promise<{encrypted: string, iv: string}>}
+   */
+  async encrypt(data, keyName = 'default') {
+    const key = this._keys.get(keyName);
+    if (!key) {
+      throw new Error(`Key "${keyName}" not found. Generate or import a key first.`);
+    }
+    
+    // Convertir les données en JSON puis en buffer
+    const dataString = typeof data === 'string' ? data : JSON.stringify(data);
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(dataString);
+    
+    // Générer un IV (Initialization Vector) aléatoire
+    const iv = window.crypto.getRandomValues(new Uint8Array(12));
+    
+    // Chiffrer
+    const encryptedBuffer = await this.crypto.encrypt(
+      {
+        name: this.algorithm.name,
+        iv: iv
+      },
+      key,
+      dataBuffer
+    );
+    
+    return {
+      encrypted: this._bufferToBase64(encryptedBuffer),
+      iv: this._bufferToBase64(iv)
+    };
+  }
+
+  /**
+   * Déchiffre des données
+   * @param {string} encryptedData - Données chiffrées (base64)
+   * @param {string} iv - IV utilisé lors du chiffrement (base64)
+   * @param {string} keyName - Nom de la clé à utiliser
+   * @param {boolean} parseJson - Parser le résultat en JSON (true par défaut)
+   * @returns {Promise<any>}
+   */
+  async decrypt(encryptedData, iv, keyName = 'default', parseJson = true) {
+    const key = this._keys.get(keyName);
+    if (!key) {
+      throw new Error(`Key "${keyName}" not found. Generate or import a key first.`);
+    }
+    
+    // Convertir les chaînes base64 en buffers
+    const encryptedBuffer = this._base64ToBuffer(encryptedData);
+    const ivBuffer = this._base64ToBuffer(iv);
+    
+    // Déchiffrer
+    const decryptedBuffer = await this.crypto.decrypt(
+      {
+        name: this.algorithm.name,
+        iv: ivBuffer
+      },
+      key,
+      encryptedBuffer
+    );
+    
+    // Convertir le buffer en string
+    const decoder = new TextDecoder();
+    const decryptedString = decoder.decode(decryptedBuffer);
+    
+    // Parser en JSON si demandé
+    if (parseJson) {
+      try {
+        return JSON.parse(decryptedString);
+      } catch (e) {
+        // Si le parsing échoue, retourner la chaîne brute
+        return decryptedString;
+      }
+    }
+    
+    return decryptedString;
+  }
+
+  /**
+   * Chiffre et encode en une seule chaîne (pratique pour stockage)
+   * @param {any} data - Données à chiffrer
+   * @param {string} keyName - Nom de la clé
+   * @returns {Promise<string>} - Chaîne contenant données chiffrées + IV
+   */
+  async encryptToString(data, keyName = 'default') {
+    const { encrypted, iv } = await this.encrypt(data, keyName);
+    return `${encrypted}.${iv}`;
+  }
+
+  /**
+   * Déchiffre depuis une chaîne créée par encryptToString
+   * @param {string} encryptedString - Chaîne chiffrée
+   * @param {string} keyName - Nom de la clé
+   * @param {boolean} parseJson - Parser en JSON
+   * @returns {Promise<any>}
+   */
+  async decryptFromString(encryptedString, keyName = 'default', parseJson = true) {
+    const [encrypted, iv] = encryptedString.split('.');
+    if (!encrypted || !iv) {
+      throw new Error('Invalid encrypted string format');
+    }
+    return this.decrypt(encrypted, iv, keyName, parseJson);
+  }
+
+  /**
+   * Hash une chaîne (non réversible)
+   * @param {string} data - Données à hasher
+   * @param {string} algorithm - Algorithme (SHA-256, SHA-384, SHA-512)
+   * @returns {Promise<string>} - Hash en base64
+   */
+  async hash(data, algorithm = 'SHA-256') {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    
+    const hashBuffer = await this.crypto.digest(algorithm, dataBuffer);
+    return this._bufferToBase64(hashBuffer);
+  }
+
+  /**
+   * Génère un token aléatoire sécurisé
+   * @param {number} length - Longueur en octets (32 par défaut)
+   * @returns {string} - Token en base64
+   */
+  generateToken(length = 32) {
+    const buffer = window.crypto.getRandomValues(new Uint8Array(length));
+    return this._bufferToBase64(buffer);
+  }
+
+  /**
+   * Supprime une clé de la mémoire
+   * @param {string} keyName - Nom de la clé
+   */
+  deleteKey(keyName) {
+    this._keys.delete(keyName);
+  }
+
+  /**
+   * Supprime toutes les clés
+   */
+  deleteAllKeys() {
+    this._keys.clear();
+  }
+
+  /**
+   * Liste les clés disponibles
+   * @returns {string[]}
+   */
+  listKeys() {
+    return Array.from(this._keys.keys());
+  }
+
+  // ===== Méthodes utilitaires =====
+
+  _bufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+
+  _base64ToBuffer(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+}
+
+export default CryptoManager;

package/utils/DataStore.js

@@ -0,0 +1,403 @@
+/**
+ * Cache local avec TTL (Time To Live) et gestion avancée
+ * @class
+ * @property {Map} store - Stockage interne
+ * @property {number} defaultTTL - TTL par défaut en ms
+ * @property {number} maxSize - Taille max du cache
+ * @property {Object} stats - Statistiques du cache
+ */
+class DataStore {
+  /**
+   * Crée une instance de DataStore
+   * @param {Object} [options={}] - Options
+   * @param {number} [options.defaultTTL=3600000] - TTL par défaut (1h)
+   * @param {number} [options.maxSize=100] - Taille max du cache
+   * @param {boolean} [options.enableStats=true] - Activer les stats
+   */
+  constructor(options = {}) {
+    this.store = new Map();
+    this.defaultTTL = options.defaultTTL || 3600000; // 1 heure par défaut
+    this.maxSize = options.maxSize || 100;
+    this.enableStats = options.enableStats !== false;
+    
+    // Statistiques
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      deletes: 0,
+      evictions: 0
+    };
+    
+    // Nettoyage périodique
+    this.startCleanupInterval();
+  }
+
+  /**
+   * Stocke une valeur avec TTL
+   * @param {string} key - Clé
+   * @param {*} value - Valeur
+   * @param {number} [ttl] - TTL en ms (optionnel)
+   * @returns {DataStore} Instance pour chaînage
+   */
+  set(key, value, ttl) {
+    const expiresAt = Date.now() + (ttl || this.defaultTTL);
+    
+    // Si le cache est plein, supprimer l'élément le plus ancien
+    if (this.store.size >= this.maxSize && !this.store.has(key)) {
+      this.evictOldest();
+    }
+    
+    this.store.set(key, {
+      value,
+      expiresAt,
+      createdAt: Date.now(),
+      accessCount: 0
+    });
+    
+    if (this.enableStats) this.stats.sets++;
+    
+    return this;
+  }
+
+  /**
+   * Récupère une valeur
+   * @param {string} key - Clé
+   * @param {*} [defaultValue=null] - Valeur par défaut
+   * @returns {*} Valeur ou null
+   */
+  get(key, defaultValue = null) {
+    const item = this.store.get(key);
+    
+    if (!item) {
+      if (this.enableStats) this.stats.misses++;
+      return defaultValue;
+    }
+    
+    // Vérifier l'expiration
+    if (Date.now() > item.expiresAt) {
+      this.delete(key);
+      if (this.enableStats) this.stats.misses++;
+      return defaultValue;
+    }
+    
+    // Mettre à jour les stats d'accès
+    item.accessCount++;
+    
+    if (this.enableStats) this.stats.hits++;
+    
+    return item.value;
+  }
+
+  /**
+   * Vérifie si une clé existe et n'est pas expirée
+   * @param {string} key - Clé
+   * @returns {boolean} True si existe et valide
+   */
+  has(key) {
+    const item = this.store.get(key);
+    
+    if (!item) return false;
+    
+    if (Date.now() > item.expiresAt) {
+      this.delete(key);
+      return false;
+    }
+    
+    return true;
+  }
+
+  /**
+   * Supprime une entrée
+   * @param {string} key - Clé
+   * @returns {boolean} True si supprimé
+   */
+  delete(key) {
+    const deleted = this.store.delete(key);
+    if (deleted && this.enableStats) this.stats.deletes++;
+    return deleted;
+  }
+
+  /**
+   * Vide tout le cache
+   */
+  clear() {
+    this.store.clear();
+    if (this.enableStats) {
+      this.stats = {
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        evictions: 0
+      };
+    }
+  }
+
+  /**
+   * Récupère ou calcule une valeur (memoization)
+   * @param {string} key - Clé
+   * @param {Function} factory - Fonction qui retourne la valeur
+   * @param {number} [ttl] - TTL optionnel
+   * @returns {Promise<*>} Valeur
+   */
+  async getOrSet(key, factory, ttl) {
+    if (this.has(key)) {
+      return this.get(key);
+    }
+    
+    const value = await factory();
+    this.set(key, value, ttl);
+    return value;
+  }
+
+  /**
+   * Récupère plusieurs valeurs
+   * @param {Array<string>} keys - Clés
+   * @returns {Object} Objet clé-valeur
+   */
+  getMany(keys) {
+    const result = {};
+    
+    for (let key of keys) {
+      const value = this.get(key);
+      if (value !== null) {
+        result[key] = value;
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Stocke plusieurs valeurs
+   * @param {Object} items - Objet clé-valeur
+   * @param {number} [ttl] - TTL optionnel
+   * @returns {DataStore} Instance pour chaînage
+   */
+  setMany(items, ttl) {
+    for (let key in items) {
+      this.set(key, items[key], ttl);
+    }
+    return this;
+  }
+
+  /**
+   * Supprime plusieurs entrées
+   * @param {Array<string>} keys - Clés
+   * @returns {number} Nombre de suppressions
+   */
+  deleteMany(keys) {
+    let count = 0;
+    for (let key of keys) {
+      if (this.delete(key)) count++;
+    }
+    return count;
+  }
+
+  /**
+   * Met à jour le TTL d'une entrée
+   * @param {string} key - Clé
+   * @param {number} ttl - Nouveau TTL en ms
+   * @returns {boolean} True si mis à jour
+   */
+  touch(key, ttl) {
+    const item = this.store.get(key);
+    
+    if (!item) return false;
+    
+    item.expiresAt = Date.now() + (ttl || this.defaultTTL);
+    return true;
+  }
+
+  /**
+   * Obtient le TTL restant
+   * @param {string} key - Clé
+   * @returns {number} TTL en ms, ou -1 si n'existe pas
+   */
+  ttl(key) {
+    const item = this.store.get(key);
+    
+    if (!item) return -1;
+    
+    const remaining = item.expiresAt - Date.now();
+    return remaining > 0 ? remaining : -1;
+  }
+
+  /**
+   * Évince l'élément le plus ancien (LRU)
+   * @private
+   */
+  evictOldest() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    
+    for (let [key, item] of this.store.entries()) {
+      // Utiliser l'accès le moins récent comme critère
+      const priority = item.createdAt - (item.accessCount * 1000);
+      
+      if (priority < oldestTime) {
+        oldestTime = priority;
+        oldestKey = key;
+      }
+    }
+    
+    if (oldestKey) {
+      this.store.delete(oldestKey);
+      if (this.enableStats) this.stats.evictions++;
+    }
+  }
+
+  /**
+   * Nettoie les entrées expirées
+   * @returns {number} Nombre d'entrées nettoyées
+   */
+  cleanup() {
+    const now = Date.now();
+    let cleaned = 0;
+    
+    for (let [key, item] of this.store.entries()) {
+      if (now > item.expiresAt) {
+        this.store.delete(key);
+        cleaned++;
+      }
+    }
+    
+    return cleaned;
+  }
+
+  /**
+   * Démarre le nettoyage automatique
+   * @param {number} [interval=60000] - Intervalle en ms (1 minute)
+   * @private
+   */
+  startCleanupInterval(interval = 60000) {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, interval);
+  }
+
+  /**
+   * Arrête le nettoyage automatique
+   */
+  stopCleanupInterval() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  /**
+   * Obtient toutes les clés
+   * @param {boolean} [includeExpired=false] - Inclure les expirées
+   * @returns {Array<string>} Liste des clés
+   */
+  keys(includeExpired = false) {
+    const keys = [];
+    const now = Date.now();
+    
+    for (let [key, item] of this.store.entries()) {
+      if (includeExpired || now <= item.expiresAt) {
+        keys.push(key);
+      }
+    }
+    
+    return keys;
+  }
+
+  /**
+   * Obtient la taille du cache
+   * @returns {number} Nombre d'entrées
+   */
+  size() {
+    return this.store.size;
+  }
+
+  /**
+   * Obtient les statistiques
+   * @returns {Object} Statistiques
+   */
+  getStats() {
+    const hitRate = this.stats.hits + this.stats.misses > 0 
+      ? (this.stats.hits / (this.stats.hits + this.stats.misses) * 100).toFixed(2)
+      : 0;
+    
+    return {
+      ...this.stats,
+      size: this.store.size,
+      hitRate: `${hitRate}%`,
+      maxSize: this.maxSize
+    };
+  }
+
+  /**
+   * Réinitialise les statistiques
+   */
+  resetStats() {
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      deletes: 0,
+      evictions: 0
+    };
+  }
+
+  /**
+   * Exporte le cache en JSON
+   * @returns {string} JSON
+   */
+  export() {
+    const data = {};
+    
+    for (let [key, item] of this.store.entries()) {
+      data[key] = {
+        value: item.value,
+        expiresAt: item.expiresAt,
+        createdAt: item.createdAt
+      };
+    }
+    
+    return JSON.stringify(data);
+  }
+
+  /**
+   * Importe un cache depuis JSON
+   * @param {string} json - JSON
+   */
+  import(json) {
+    const data = JSON.parse(json);
+    const now = Date.now();
+    
+    for (let key in data) {
+      const item = data[key];
+      
+      // Ne pas importer les entrées expirées
+      if (item.expiresAt > now) {
+        this.store.set(key, {
+          value: item.value,
+          expiresAt: item.expiresAt,
+          createdAt: item.createdAt,
+          accessCount: 0
+        });
+      }
+    }
+  }
+
+  /**
+   * Détruit le store
+   */
+  destroy() {
+    this.stopCleanupInterval();
+    this.clear();
+  }
+}
+
+// Instance globale par défaut
+DataStore.global = new DataStore();
+
+export default DataStore;