@futdevpro/fsm-dynamo 1.10.37 → 1.10.39

package/src/_modules/crypto/_collections/crypto.util.spec.ts

@@ -44,6 +44,39 @@ describe('| DyFM_Crypto', () => {
       expect(decrypted).toEqual(complexData);
     });
 
+    it('| should get the same result with the same input', () => {
+      const complexData = {
+        id: 2,
+        name: 'test',
+        nested: {
+          value: 'nested-value',
+          array: [1, 2, 3]
+        }
+      };
+      const expectedResult = JSON.stringify(complexData);
+
+      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      const result = JSON.stringify(decrypted);
+      expect(result).toBe(expectedResult);
+    });
+
+    it('| should not effect the original object', () => {
+      const complexData = {
+        id: 1,
+        name: 'test',
+        nested: { value: 'nested-value', array: [1, 2, 3] }
+      };
+      const originalData = JSON.stringify(complexData);
+
+      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      const result = JSON.stringify(decrypted);
+      expect(result).toBe(originalData);
+    });
+
     it('| should handle arrays', () => {
       const arrayData = [1, 'test', { nested: true }];
       const encrypted = DyFM_Crypto.encrypt(arrayData, testKey);
@@ -191,5 +224,400 @@ describe('| DyFM_Crypto', () => {
         expect(() => DyFM_Crypto.decrypt(modified, testKey)).toThrow();
       });
     });
+
+    describe('| JSON handling edge cases', () => {
+      it('| should handle double-stringified JSON data correctly', () => {
+        const testData = {
+          username: 'Itharen',
+          password: 'asdasd',
+          roles: [],
+          permissions: [],
+          activeSubscriptions: [],
+          clientUserIds: {},
+          oauth2Data: {}
+        };
+
+        // Simulate double stringification
+        const doubleStringified = JSON.stringify(JSON.stringify(testData));
+        
+        const encrypted = DyFM_Crypto.encrypt(doubleStringified, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+        // Should be able to parse the decrypted data back to the original object
+        const parsed = JSON.parse(decrypted as string);
+        expect(parsed).toEqual(testData);
+      });
+
+      it('| should handle character-by-character JSON data correctly', () => {
+        // Create a character-by-character object like in the example
+        const charByCharData = {
+          '0': '{',
+          '1': '"',
+          '2': '_',
+          '3': '_',
+          '4': 'c',
+          '5': 'r',
+          '6': 'e',
+          '7': 'a',
+          '8': 't',
+          '9': 'e',
+          '10': 'd',
+          '11': '"',
+          '12': ':',
+          '13': '"',
+          '14': '2',
+          '15': '0',
+          '16': '2',
+          '17': '5',
+          '18': '-',
+          '19': '0',
+          '20': '5',
+          '21': '-',
+          '22': '1',
+          '23': '3',
+          '24': 'T',
+          '25': '1',
+          '26': '0',
+          '27': ':',
+          '28': '4',
+          '29': '0',
+          '30': ':',
+          '31': '4',
+          '32': '4',
+          '33': '.',
+          '34': '7',
+          '35': '6',
+          '36': '0',
+          '37': 'Z',
+          '38': '"',
+          '39': ',',
+          '40': '"',
+          '41': '_',
+          '42': '_',
+          '43': 'l',
+          '44': 'a',
+          '45': 's',
+          '46': 't',
+          '47': 'M',
+          '48': 'o',
+          '49': 'd',
+          '50': 'i',
+          '51': 'f',
+          '52': 'i',
+          '53': 'e',
+          '54': 'd',
+          '55': '"',
+          '56': ':',
+          '57': '"',
+          '58': '2',
+          '59': '0',
+          '60': '2',
+          '61': '5',
+          '62': '-',
+          '63': '0',
+          '64': '5',
+          '65': '-',
+          '66': '1',
+          '67': '3',
+          '68': 'T',
+          '69': '1',
+          '70': '0',
+          '71': ':',
+          '72': '4',
+          '73': '0',
+          '74': ':',
+          '75': '4',
+          '76': '4',
+          '77': '.',
+          '78': '7',
+          '79': '6',
+          '80': '0',
+          '81': 'Z',
+          '82': '"',
+          '83': ',',
+          '84': '"',
+          '85': '_',
+          '86': '_',
+          '87': 'v',
+          '88': '"',
+          '89': ':',
+          '90': '0',
+          '91': ',',
+          '92': '"',
+          '93': 'u',
+          '94': 's',
+          '95': 'e',
+          '96': 'r',
+          '97': 'n',
+          '98': 'a',
+          '99': 'm',
+          '100': 'e',
+          '101': '"',
+          '102': ':',
+          '103': '"',
+          '104': 'I',
+          '105': 't',
+          '106': 'h',
+          '107': 'a',
+          '108': 'r',
+          '109': 'e',
+          '110': 'n',
+          '111': '"',
+          '112': ',',
+          '113': '"',
+          '114': 'p',
+          '115': 'r',
+          '116': 'e',
+          '117': 'v',
+          '118': 'i',
+          '119': 'o',
+          '120': 'u',
+          '121': 's',
+          '122': 'E',
+          '123': 'm',
+          '124': 'a',
+          '125': 'i',
+          '126': 'l',
+          '127': 's',
+          '128': '"',
+          '129': ':',
+          '130': '[',
+          '131': ']',
+          '132': ',',
+          '133': '"',
+          '134': 'p',
+          '135': 'a',
+          '136': 's',
+          '137': 's',
+          '138': 'w',
+          '139': 'o',
+          '140': 'r',
+          '141': 'd',
+          '142': '"',
+          '143': ':',
+          '144': '"',
+          '145': 'a',
+          '146': 's',
+          '147': 'd',
+          '148': 'a',
+          '149': 's',
+          '150': 'd',
+          '151': '"',
+          '152': ',',
+          '153': '"',
+          '154': 'r',
+          '155': 'o',
+          '156': 'l',
+          '157': 'e',
+          '158': 's',
+          '159': '"',
+          '160': ':',
+          '161': '[',
+          '162': ']',
+          '163': ',',
+          '164': '"',
+          '165': 'p',
+          '166': 'e',
+          '167': 'r',
+          '168': 'm',
+          '169': 'i',
+          '170': 's',
+          '171': 's',
+          '172': 'i',
+          '173': 'o',
+          '174': 'n',
+          '175': 's',
+          '176': '"',
+          '177': ':',
+          '178': '[',
+          '179': ']',
+          '180': ',',
+          '181': '"',
+          '182': 'a',
+          '183': 'c',
+          '184': 't',
+          '185': 'i',
+          '186': 'v',
+          '187': 'e',
+          '188': 'S',
+          '189': 'u',
+          '190': 'b',
+          '191': 's',
+          '192': 'c',
+          '193': 'r',
+          '194': 'i',
+          '195': 'p',
+          '196': 't',
+          '197': 'i',
+          '198': 'o',
+          '199': 'n',
+          '200': 's',
+          '201': '"',
+          '202': ':',
+          '203': '[',
+          '204': ']',
+          '205': ',',
+          '206': '"',
+          '207': 'c',
+          '208': 'l',
+          '209': 'i',
+          '210': 'e',
+          '211': 'n',
+          '212': 't',
+          '213': 'U',
+          '214': 's',
+          '215': 'e',
+          '216': 'r',
+          '217': 'I',
+          '218': 'd',
+          '219': 's',
+          '220': '"',
+          '221': ':',
+          '222': '{',
+          '223': '}',
+          '224': ',',
+          '225': '"',
+          '226': 'o',
+          '227': 'a',
+          '228': 'u',
+          '229': 't',
+          '230': 'h',
+          '231': '2',
+          '232': 'D',
+          '233': 'a',
+          '234': 't',
+          '235': 'a',
+          '236': '"',
+          '237': ':',
+          '238': '{',
+          '239': '}',
+          '240': '}'
+        };
+
+        const encrypted = DyFM_Crypto.encrypt(charByCharData, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+        // Should be able to parse the decrypted data back to the original object
+        expect(decrypted).toEqual(charByCharData);
+      });
+    });
+
+    describe('| cross-environment consistency', () => {
+      it('| should produce same encrypted output for same input across different environments', () => {
+        const testData = {
+          id: 1,
+          name: 'test',
+          timestamp: '2024-03-20T10:00:00Z'
+        };
+        const key = 'test-secret-key-123';
+
+        // Simulate different environments by creating new instances
+        const encrypted1 = DyFM_Crypto.encrypt(testData, key);
+        const encrypted2 = DyFM_Crypto.encrypt(testData, key);
+
+        expect(encrypted1).toBe(encrypted2);
+        expect(DyFM_Crypto.decrypt(encrypted1, key)).toEqual(testData);
+        expect(DyFM_Crypto.decrypt(encrypted2, key)).toEqual(testData);
+      });
+
+      it('| should maintain encryption consistency with different data types', () => {
+        const testCases = [
+          { data: { id: 1 }, key: 'key1' },
+          { data: 'string data', key: 'key2' },
+          { data: [1, 2, 3], key: 'key3' },
+          { data: { nested: { value: true } }, key: 'key4' }
+        ];
+
+        testCases.forEach(({ data, key }) => {
+          const encrypted1 = DyFM_Crypto.encrypt(data, key);
+          const encrypted2 = DyFM_Crypto.encrypt(data, key);
+          expect(encrypted1).toBe(encrypted2);
+        });
+      });
+    });
+
+    describe('| database persistence', () => {
+      interface UserData {
+        id: number;
+        name: string;
+        lastLogin: string;
+        preferences: {
+          language: string;
+          timezone: string;
+        };
+      }
+
+      it('| should successfully encrypt and decrypt data after database storage simulation', () => {
+        const originalData = {
+          id: 1,
+          name: 'test user',
+          email: 'test@example.com',
+          settings: {
+            theme: 'dark',
+            notifications: true
+          }
+        };
+        const key = 'db-storage-key';
+
+        // Simulate database storage and retrieval
+        const encrypted = DyFM_Crypto.encrypt(originalData, key);
+        const storedData = encrypted; // Simulating database storage
+        const retrievedData = storedData; // Simulating database retrieval
+        const decrypted = DyFM_Crypto.decrypt(retrievedData, key);
+
+        expect(decrypted).toEqual(originalData);
+      });
+
+      it('| should handle multiple encryption/decryption cycles for database operations', () => {
+        const userData: UserData = {
+          id: 1,
+          name: 'test user',
+          lastLogin: new Date().toISOString(),
+          preferences: {
+            language: 'en',
+            timezone: 'UTC'
+          }
+        };
+        const key = 'persistent-key';
+
+        // Simulate multiple database operations
+        const encrypted1 = DyFM_Crypto.encrypt(userData, key);
+        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key) as UserData;
+        
+        // Simulate data update
+        const updatedData: UserData = { 
+          ...decrypted1, 
+          lastLogin: new Date().toISOString() 
+        };
+        const encrypted2 = DyFM_Crypto.encrypt(updatedData, key);
+        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key) as UserData;
+
+        expect(decrypted1).toEqual(userData);
+        expect(decrypted2).toEqual(updatedData);
+        expect(decrypted2.lastLogin).not.toBe(userData.lastLogin);
+      });
+
+      it('| should maintain data integrity through multiple database operations', () => {
+        const sensitiveData = {
+          id: 1,
+          password: 'hashed-password-123',
+          securityQuestions: [
+            { question: 'What is your pet name?', answer: 'Fluffy' },
+            { question: 'Where were you born?', answer: 'New York' }
+          ]
+        };
+        const key = 'sensitive-data-key';
+
+        // Simulate multiple database operations with the same data
+        const encrypted1 = DyFM_Crypto.encrypt(sensitiveData, key);
+        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key);
+        const encrypted2 = DyFM_Crypto.encrypt(decrypted1, key);
+        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key);
+
+        expect(decrypted1).toEqual(sensitiveData);
+        expect(decrypted2).toEqual(sensitiveData);
+        expect(encrypted1).toBe(encrypted2); // Different encryption instances
+      });
+    });
   });
 }); 

package/src/_modules/crypto/_collections/crypto.util.ts

@@ -1,17 +1,20 @@
 import * as CryptoJS from 'crypto-js';
+import { 
+  DyFM_Error, 
+  DyFM_Error_Settings 
+} from '../../../_models/control-models/error.control-model';
 
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
 
 /**
  * Error codes for crypto operations
  */
-export enum CryptoErrorCode {
+/* export enum CryptoErrorCode {
   INVALID_INPUT = 'DyFM-CRY-EA0',
-  DECRYPTION_FAILED = 'DyFM-CRY-DRY',
+  DECRYPTION_FAILED = '',
   ENCRYPTION_FAILED = 'DyFM-CRY-ENF',
   INVALID_KEY = 'DyFM-CRY-IKY',
   INVALID_DATA = 'DyFM-CRY-IDT'
-}
+} */
 
 /**
  * Configuration options for encryption/decryption
@@ -29,11 +32,14 @@ export interface CryptoConfig {
  */
 export class DyFM_Crypto {
   private static readonly DEFAULT_CONFIG: Required<CryptoConfig> = {
-    ivLength: 16,
-    saltLength: 16,
+    ivLength: 16, // 128 bits
+    saltLength: 16, // 128 bits
     keyIterations: 10000,
-    keySize: 256 / 32
+    keySize: 8 // 256 bits (8 * 32)
   };
+  private static readonly defaultErrorUserMsg = 
+    `We encountered an unhandled Authentication Error, ` +
+    `\nplease contact the responsible development team.`;
 
   // Tömör: kb. 60–80 karakteres token, nem 200+
   // Nem szabványos: nehéz visszafejteni
@@ -43,37 +49,42 @@ export class DyFM_Crypto {
    * Validates the input data and key
    * @throws {DyFM_Error} if validation fails
    */
-  private static validateInput<T>(data: T, key: string): void {
-    if (data === undefined || data === null) {
+  private static validateInput(data: any, key: string): void {
+    if (!key || typeof key !== 'string' || key.trim().length === 0) {
       throw new DyFM_Error({
-        message: 'Data is required',
-        error: new Error('Data is required'),
-        errorCode: CryptoErrorCode.INVALID_DATA
+        ...this.getDefaultErrorSettings('validateInput'),
+        errorCode: 'DyFM-CRY-IKY',
+        message: 'Invalid encryption key'
       });
     }
 
-    if (!key || typeof key !== 'string' || key.trim().length === 0) {
+    if (data === undefined || data === null) {
       throw new DyFM_Error({
-        message: 'Valid key is required',
-        error: new Error('Key must be a non-empty string'),
-        errorCode: CryptoErrorCode.INVALID_KEY
+        ...this.getDefaultErrorSettings('validateInput'),
+        errorCode: 'DyFM-CRY-IDT',
+        message: 'Invalid data to encrypt/decrypt'
       });
     }
   }
 
   /**
-   * Generates a secure random padding
-   * @param length Length of the padding in bytes
+   * Generates a deterministic IV based on the input data and key
    */
-  private static generatePadding(length: number): string {
-    return CryptoJS.lib.WordArray.random(length).toString();
+  private static generateIV(data: string, key: string, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
+    const hash = CryptoJS.SHA256(data + key);
+    return CryptoJS.lib.WordArray.create(hash.words.slice(0, config.ivLength / 4));
+  }
+
+  /**
+   * Generates a deterministic salt based on the input data and key
+   */
+  private static generateSalt(data: string, key: string, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
+    const hash = CryptoJS.SHA256(key + data);
+    return CryptoJS.lib.WordArray.create(hash.words.slice(0, config.saltLength / 4));
   }
 
   /**
    * Derives a key using PBKDF2
-   * @param key The input key
-   * @param salt The salt to use
-   * @param config Configuration options
    */
   private static deriveKey(key: string, salt: CryptoJS.lib.WordArray, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
     return CryptoJS.PBKDF2(key, salt, {
@@ -84,38 +95,62 @@ export class DyFM_Crypto {
 
   /**
    * Safely serializes data to JSON
-   * @param data The data to serialize
-   * @returns Serialized data as string
    */
   private static safeSerialize<T>(data: T): string {
     try {
       return JSON.stringify(data);
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Failed to serialize data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.INVALID_DATA
+        ...this.getDefaultErrorSettings('safeSerialize', error),
+        errorCode: 'DyFM-CRY-SER',
+        message: 'Failed to serialize data'
       });
     }
   }
 
   /**
    * Safely deserializes JSON data
-   * @param data The JSON string to deserialize
-   * @returns Deserialized data
    */
   private static safeDeserialize<T>(data: string): T {
     try {
-      return JSON.parse(data);
+      let parsed = JSON.parse(data);
+      
+      // Handle double-stringified JSON
+      if (typeof parsed === 'string') {
+        try {
+          parsed = JSON.parse(parsed);
+        } catch {
+          // If second parse fails, return the string as is
+          return parsed as T;
+        }
+      }
+
+      // Handle primitive values
+      if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean') {
+        return parsed as T;
+      }
+
+      return parsed as T;
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Failed to deserialize data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.DECRYPTION_FAILED
+        ...this.getDefaultErrorSettings('safeDeserialize', error),
+        errorCode: 'DyFM-CRY-DES',
+        message: 'Failed to deserialize data'
       });
     }
   }
 
+  /**
+   * Gets default error settings
+   */
+  private static getDefaultErrorSettings(operation: string, error?: any): DyFM_Error_Settings {
+    return {
+      message: `Crypto operation '${operation}' failed`,
+      error: error instanceof Error ? error : new Error(String(error)),
+      errorCode: 'DyFM-CRY-ERR'
+    };
+  }
+
   /**
    * Encrypts data using AES-256-CBC
    * @param data The data to encrypt
@@ -129,20 +164,18 @@ export class DyFM_Crypto {
       this.validateInput(data, key);
       const finalConfig = { ...this.DEFAULT_CONFIG, ...config };
 
-      // Generate random IV and salt
-      const iv = CryptoJS.lib.WordArray.random(finalConfig.ivLength);
-      const salt = CryptoJS.lib.WordArray.random(finalConfig.saltLength);
+      // Convert data to string
+      const dataStr = this.safeSerialize(data);
+
+      // Generate deterministic IV and salt based on data and key
+      const iv = this.generateIV(dataStr, key, finalConfig);
+      const salt = this.generateSalt(dataStr, key, finalConfig);
 
       // Derive key using PBKDF2
       const derivedKey = this.deriveKey(key, salt, finalConfig);
 
-      // Convert data to string and add random padding
-      const dataStr = this.safeSerialize(data);
-      const padding = this.generatePadding(16);
-      const paddedData = padding + dataStr;
-
       // Encrypt the data
-      const encrypted = CryptoJS.AES.encrypt(paddedData, derivedKey, {
+      const encrypted = CryptoJS.AES.encrypt(dataStr, derivedKey, {
         iv: iv,
         mode: CryptoJS.mode.CBC,
         padding: CryptoJS.pad.Pkcs7
@@ -158,9 +191,8 @@ export class DyFM_Crypto {
         .replace(/=+$/, '');
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Error encrypting data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.ENCRYPTION_FAILED
+        ...this.getDefaultErrorSettings('encrypt', error),
+        errorCode: 'DyFM-CRY-ENC',
       });
     }
   }
@@ -186,6 +218,12 @@ export class DyFM_Crypto {
       // Parse the combined data
       const combined = CryptoJS.enc.Base64.parse(base64);
 
+      // Validate minimum length (IV + Salt + minimum ciphertext)
+      const minLength = (finalConfig.ivLength + finalConfig.saltLength + 16) / 4; // 16 bytes minimum for ciphertext
+      if (combined.words.length < minLength) {
+        throw new Error('Invalid encrypted data length');
+      }
+
       // Extract IV, salt, and ciphertext
       const iv = CryptoJS.lib.WordArray.create(combined.words.slice(0, finalConfig.ivLength / 4));
       const salt = CryptoJS.lib.WordArray.create(
@@ -212,15 +250,13 @@ export class DyFM_Crypto {
         }
       );
 
-      // Remove padding and parse JSON
+      // Parse JSON
       const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
-      const jsonStr = decryptedStr.slice(32); // Remove 16-byte padding
-      return this.safeDeserialize<T>(jsonStr);
+      return this.safeDeserialize<T>(decryptedStr);
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Error decrypting data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.DECRYPTION_FAILED
+        ...this.getDefaultErrorSettings('decrypt', error),
+        errorCode: 'DyFM-CRY-DRY',
       });
     }
   }