Whiphash

Whiplash is a next-generation password generation and management system designed to produce secure, verifiable, and tamper-resistant passwords. Unlike conventional password managers that rely solely on local device randomness or centralized servers, Whiplash combines multiple layers of cryptographic security and on-chain verifiable randomness to ensure that every password is unique, unpredictable, and resilient against both offline and online attacks.

Key Features and Encryption Layers:

Local Key Generation: A device-specific secret (LocalKey) is generated using Argon2id, a memory-hard password-hashing algorithm. This step protects against brute-force attacks and ensures that even if local data is exposed, attackers cannot easily reconstruct passwords.

On-Chain Randomness Integration: We leverage Pyth Entropy contracts deployed on Base L2 to fetch verifiable random values (R1 and R2). These values are public but auditable, ensuring that the randomness source is unbiased and tamper-resistant.

Key Derivation: The local key is combined with the on-chain random values using HKDF (HMAC-based Key Derivation Function). HKDF securely derives a strong, uniform cryptographic seed from multiple entropy sources.

Password Hardening: The derived seed is further processed using Argon2id to generate the final password. This additional layer ensures computational hardness, protecting against offline brute-force attacks even if the encrypted password is exposed.

Secure Storage: The final passwords are stored in NilionDB’s SecretVault, which splits and encrypts data across multiple nodes. This prevents any single server from holding the complete password, making storage highly resilient against server compromise.

Workflow Summary:

Fetch R1 from Pyth Entropy on Base L2.

Generate LocalKey via Argon2id from device entropy + optional user secret.

Combine LocalKey + R2 using HKDF → produce cryptographic seed.

Harden seed with Argon2id → final password.

Store password securely in NilionDB SecretVault (encrypted + split across nodes).

Security Advantages:

Resistance to biased RNGs: Mixing device entropy with verifiable on-chain randomness prevents single-source manipulation.

Memory-hard hardening: Argon2id prevents fast GPU or ASIC-based brute-force attacks.

Distributed storage: NilionDB ensures no single point of compromise for stored passwords.

Auditable randomness: Users can verify the on-chain entropy used to generate each password.

In essence, Whiplash combines the best of client-side security, on-chain verifiable randomness, and distributed secret storage to produce passwords that are unpredictable, secure, and fully under user control.

1. Architecture Overview

Whiplash is built as a browser extension with a separation of UI, background processing, cryptography, and secure storage. The architecture consists of:

Extension UI / popup – built with React + TypeScript for fast, responsive interactions.

Background service worker – handles orchestration, interacts with the blockchain oracle, triggers cryptographic operations, and manages communication between the UI and worker.

Crypto Worker (WASM) – runs heavy computations like Argon2id and HKDF off the main thread to avoid UI blocking.

On-chain entropy integration – fetches verifiable randomness from Pyth Entropy contracts deployed on Base L2, ensuring unbiased, auditable randomness for password generation.

Secure storage layer – uses NilionDB SecretVault to encrypt, split, and store passwords across nodes, so no single server ever holds the plaintext.

1. Key Technologies and Libraries

Frontend / Extension

React + TypeScript – UI components for password generation, settings, and user interactions.

Tailwind-style CSS utilities – minimal styling without large frameworks.

Cryptography

Argon2id (argon2-browser / argon2-node) – memory-hard hashing for local key and final password hardening.

HKDF (futoin-hkdf / WebCrypto) – key derivation from combined entropy sources (LocalKey + on-chain randomness).

libsodium-wrappers – AEAD encryption for pre-encrypting passwords before storing in NilionDB.

Base64URL / Uint8Arrays – helper libraries for encoding and decoding cryptographic blobs.

Blockchain / Oracle

ethers.js – interacts with Base L2, reads Pyth Entropy contract values, verifies proofs.

Pyth Entropy contracts (Base L2) – provide verifiable, public randomness used in password derivation.

Storage

NilionDB SecretVault – encrypts and shards passwords across nodes, providing distributed, tamper-resistant storage.

chrome.storage.local – stores non-sensitive metadata (e.g., transaction IDs, KDF parameters).

1. How Components Work Together

Password Request: User requests a new password via the extension popup.

On-chain Randomness Fetch: Background service worker requests R1 from Pyth Entropy contracts (with optional helper backend for proof verification).

Local Key Generation: Crypto worker generates or retrieves the device-local secret (LocalKey).

Seed Derivation: LocalKey + R1 are combined via HKDF → produces a strong, uniform seed.

Password Hardening: Seed is further processed with Argon2id → final password.

Secure Storage: Final password is encrypted using libsodium (AEAD) and stored in NilionDB SecretVault, which splits ciphertext across nodes.

Optional R2 Mixing: A second on-chain random value R2 can be incorporated for additional entropy if needed.

1. Partner Technologies and Benefits

Pyth Entropy (Base L2): Provides verifiable randomness that is public, unbiased, and tamper-resistant, adding trustworthiness to generated passwords.

NilionDB SecretVault: Adds distributed, encrypted storage that reduces single-point-of-failure risk and enhances security compared to centralized vaults.

Argon2id + HKDF: Strong cryptographic primitives ensure high computational cost for attackers attempting offline brute-force.

1. Notable / Hacky Engineering

Crypto Worker in WASM: Offloads heavy KDFs (Argon2id) and HKDF derivation off the main thread, keeping UI responsive even with high memory-hard parameters.

Pre-encryption before NilionDB storage: Encrypting passwords client-side before sharding ensures NilionDB nodes never see plaintext, giving end-to-end confidentiality.

Proof Verification in Extension: Verifies Pyth randomness proofs entirely on the client without trusting external servers, providing auditable entropy.

Layered Randomness: Mixing on-chain randomness with device-local entropy gives resilience against single-source RNG compromise, a step beyond traditional password managers.