How To Use ZevSafe

1. Key Derivation Pipeline (PBKDF2-SHA256)

Raw passwords are never used directly as keys. To prevent dictionary attacks and brute-forcing, ZevSafe employs a secure key stretching pipeline:

• Salt Generation (16 Bytes): A unique, random 128-bit salt is generated for each operation using the browser's cryptographically secure pseudo-random number generator (CSPRNG), window.crypto.getRandomValues(). This makes rainbow tables and pre-computed attacks completely useless.
• PBKDF2 Stretching: The password and salt are processed through the Password-Based Key Derivation Function 2 (PBKDF2) using SHA-256 as the underlying hash function.
• 100,000 Iterations: The key derivation runs for exactly 100,000 iterations. This heavy stretching introduces a significant computational delay for attackers, making brute-force cracking mathematically infeasible.
• Key Derivation: The stretched result is derived as a 256-bit symmetric cryptographic key ready for AES encryption.

2. Step-by-Step Encryption Flow

When you drop a folder and click "Encrypt & Download", the browser executes the following sequence:

• Step 2.1: Folder Compression (JSZip): The selected folder structure is compressed in-memory into a single ZIP binary stream using the DEFLATE algorithm (compression level 6). This hides original filenames and directory layout structure inside the compressed payload.
• Step 2.2: Header Variables: The CSPRNG generates a random 16-byte Salt and a 12-byte Initialization Vector (IV/Nonce).
• Step 2.3: Key Stretching: The browser derives a 256-bit key from the password and Salt using PBKDF2-SHA256 (100k iterations) via crypto.subtle.deriveKey().
• Step 2.4: AES-256-GCM ciphering: The ZIP binary stream is encrypted using AES-GCM-256 with the derived key and the 12-byte IV. During this operation, a 16-byte (128-bit) GCM authentication tag is generated to ensure integrity.
• Step 2.5: Packaging: The outputs are packed into a single binary array using a specific layout:
  [ Salt (16 Bytes) ]  +  [ IV (12 Bytes) ]  +  [ Ciphertext (Variable) ]  +  [ GCM Tag (16 Bytes) ]
• Step 2.6: Disk Write: The packed array is downloaded as a single .enc file directly via browser local memory.

3. Step-by-Step Decryption Flow

When you upload a .enc file and click "Decrypt & Download", the reverse sequence takes place:

• Step 3.1: Parsing Headers: The browser reads the raw binary array of the .enc file. It extracts the first 16 bytes as the Salt, the next 12 bytes (bytes 16–27) as the IV, and the rest as the ciphertext payload (which implicitly contains the 16-byte GCM tag appended at the end).
• Step 3.2: Re-deriving the Key: The user-provided password and the extracted 16-byte Salt are passed to crypto.subtle.deriveKey() to re-derive the 256-bit AES-GCM key using the exact same PBKDF2 parameters (100k iterations, SHA-256).
• Step 3.3: Cryptographic Decryption & Integrity Check: The browser calls crypto.subtle.decrypt() using the re-derived key and the extracted 12-byte IV. The Web Crypto engine automatically calculates the authentication tag and compares it to the GCM tag appended to the ciphertext.
  Note: If even a single byte has been modified, or if the password is incorrect, the tags will not match. The operation throws an OperationError and immediately aborts, preventing tampered data or wrong passwords from corrupting memory.
• Step 3.4: ZIP Extraction: Upon successful decryption, the resulting clean binary ZIP payload is read by JSZip, which extracts the original folder layout, subfolders, and files exactly as they were.
• Step 3.5: Delivery: The files are packed as a zip archive and downloaded as *_decrypted.zip.