Eve library

Phase 150 implementation evidence

Tracker

Revision 1

On this page

Historical task source. The Eve task board holds current task state.

This ledger records direct implementation evidence for checked Phase 150 requirements. Unchecked requirements remain open. Types, adapter seams, and cataloged dependencies are not treated as completion without executable behavior and focused validation.

150.1 Zero-knowledge crypto core#

Implementation root: libs/neith/vault-crypto/.

Requirements Direct evidence
150.1.1 calibrateArgon2id measures a one-iteration Argon2id probe, chooses bounded iterations for the requested device target, remeasures the selected parameters, and enforces a memory floor.
150.1.2 deriveAccountKey derives a raw Argon2id password key and combines it with the independent account Secret Key through domain-separated HKDF-SHA256; temporary password and derived buffers are zeroed.
150.1.3–.4 Authenticated XChaCha20-Poly1305 and AES-256-GCM paths enforce key/nonce sizes, bind associated data, keep the authentication tag with the ciphertext, and reject tampering.
150.1.5–.6 sealItem generates a random per-item key, encrypts payload and wrapped key under separate associated-data domains, and rotateItemEnvelope rewraps only the item key under a monotonically newer per-vault HKDF generation. Tests prove the payload ciphertext does not change and the old vault key no longer opens the rotated envelope.
150.1.7 The SRP-6a implementation uses a 2048-bit safe-prime group, padded SHA-256 transcript values, verifier-only server state, public-value validation, mutual M1/M2 proofs, and constant-time proof comparison. Correct peers derive the same session key; a wrong password does not authenticate.
150.1.8 Asynchronous recipient sharing implements the RFC 9180 labeled extract/expand construction with DHKEM(X25519, HKDF-SHA256), base-mode key schedule, and AES-256-GCM. Only the matching recipient private key opens the context-bound share.
150.1.9 Byte-wise GF(2^8) Shamir splitting supports 2–255 shares and arbitrary thresholds, validates set consistency and duplicate indices, and reconstructs from an out-of-order threshold subset.
150.1.10 Ed25519 envelopes sign a domain-separated context, fixed-width payload length, and the complete payload; verification optionally pins the expected context and rejects mutation.
150.1.11 The hybrid KEM uses the runtime cryptographic provider's ML-KEM-768 and X25519 encapsulations, concatenates both 256-bit component secrets, and derives the final 256-bit secret with HKDF-SHA256. The salt commits to a versioned domain, both public keys, both ciphertexts, and caller context. Keys/ciphertexts are strict DER/length/version validated and temporary component secrets, input key material, and salt are zeroed.
150.1.12 Secret/proof comparisons use timingSafeEqual; unequal lengths still perform a padded equal-length comparison before returning false.
150.1.13 NativeMemoryLockAdapter invokes a host-built Rust N-API module that applies mlock/munlock on Unix and VirtualLock/VirtualUnlock on Windows to the exact Node buffer backing SecureBytes. Construction zeroes the copied allocation if locking fails; disposal zeroes it before unlocking. Linux verification observes VmLck increase for the live pages, then return to baseline after their contents are verified zero.
150.1.14 The Lean 4.32 proof gate contains no sorry/admit and proves symbolic invariants for five production operation boundaries: generation-separated vault-key derivation, AEAD round-trip plus wrong-AAD rejection for either cipher, item seal/open round-trip, rotation payload/generation preservation, and both hybrid-KEM component bindings. The model explicitly scopes standardized primitives as ideal constructors rather than claiming primitive-level cryptanalysis.
150.1.15 Every AEAD/item envelope pins a crypto version. CryptoMigrationRatchet requires a complete, strictly one-version-at-a-time forward chain and rejects future-version input.

Verification log#

  • tsc --noEmit -p libs/neith/vault-crypto/tsconfig.json passes.
  • The focused Vitest suite passes 15 tests covering KDF/2SKD, both AEADs, tamper rejection, item rotation, HPKE, Shamir recovery, signatures, SRP-6a, constant-time comparison, memory lifecycle, migration ratcheting, native ML-KEM-768/X25519 hybrid round-trip, provider interop, and malformed-input rejection.
  • Rust release compilation of the native memory module passes; the Linux test independently validates live VmLck accounting and zero-before-unlock.
  • Lean 4.32.0 accepts formal/VaultCrypto.lean; the gate rejects any future sorry or admit before invoking the pinned compiler.
  • V8 reports 89.17% statements, 74.07% branches, 98.52% functions, and 95.07% lines across the complete package.
  • Prettier and git diff --check pass for the implementation and lockfile.

150.2 Item model and types#

Implementation root: libs/neith/vault-item/.

Requirements Direct evidence
150.2.1–.15 A discriminated VaultPayload defines all fifteen named categories. Runtime validation enforces each category's required fields and invariants, including web URL schemes, Luhn-valid PANs and card dates, computed OpenSSH SHA-256 fingerprints, rotation timestamps/policies, ciphertext blob digests/versions, positive seat counts, wallet key material, OTP backup-code usage timestamps, paired barcode/QR values, and custom-template membership. The category matrix creates every type.
150.2.16 Item sensitivity is a validated path map with concealed, visible, and monitored states. Secret-bearing fields receive concealed defaults; changes and granular reverts are historied.
150.2.17 Immutable updates store only changed prior values with actor/time metadata. revertVaultItemFields restores an explicit subset, validates the resulting payload, and histories the revert so it can itself be reversed.
150.2.18 linkVaultItems creates validated, deduplicated, bidirectional same-vault relationships, applies inverse credential/recovery semantics, and histories both sides.
150.2.19 Normalized tags, favourites, and validated custom sections/fields are first-class item state and participate in immutable history.
150.2.20 Strict ISO expiration timestamps drive idempotent auto-archive; only expired active items change and the system lifecycle actor is recorded in history.

150.2 verification log#

  • tsc --noEmit -p libs/neith/vault-item/tsconfig.json passes.
  • The focused Vitest suite passes nine tests covering the full type matrix, sensitivity update/revert, encrypted blob references, SSH fingerprints, custom templates, granular history, relationships, organization, and expiry.

150.3 TOTP, OTP, and passkeys#

Implementation root: libs/neith/vault-totp/.

Requirements Direct evidence
150.3.1–.2 SHA-1/SHA-256/SHA-512 HOTP uses an unsigned 64-bit counter, RFC dynamic truncation, and 6–8 digits; TOTP derives the counter from a validated period/time. Tests match all ten RFC 4226 examples and three RFC 6238 SHA-1 examples.
150.3.3 Steam Guard generation uses the 30-second HMAC-SHA1 counter and five selections from Steam's custom alphabet; deterministic and next-window behavior is tested.
150.3.4 parseOtpAuthUri validates and imports TOTP/HOTP URIs, including algorithm, digits, period, and counter. parseOtpAuthQr limits input size, uses the bundled ZXing WebAssembly reader in QR-only mode, requires exactly one valid symbol, and feeds its decoded text through the same strict URI parser. The test generates PNG pixels from a real otpauth URI and decodes them offline; a non-OTP QR is rejected.
150.3.5 Hardware OTP entries validate UUID-form AAGUIDs, named YubiKey/sovereign/other vendors, and non-empty authenticator transports.
150.3.6–.8 Passkey records include credential/user/RP keys, sign count, backup flags, AAGUID, format, transports, attestation object and certificate chain. sealPasskey encrypts the complete credential as a versioned per-item envelope; openPasskey authenticates it and validates metadata. Tests prove the correct vault key opens it while a different key or ciphertext mutation fails.
150.3.9 Backup-code consumption immutably timestamps exactly one matching unused code and rejects replay or unknown codes.
150.3.10 SMS/email OTP archival validates the source record and retains only a final-two-digit redaction, never the full code.

150.3 verification log#

  • tsc --noEmit -p libs/neith/vault-totp/tsconfig.json passes.
  • The focused Vitest suite passes nine protocol and lifecycle tests, including an actual generated PNG QR decode through ZXing WebAssembly.

150.4 Password and secret generator#

Implementation root: libs/neith/vault-gen/.

Requirements Direct evidence
150.4.1 generatePassword enforces a 4–4096 length, independently selectable/required lower/upper/digit/symbol sets, arbitrary exclusions, and a similar-character deny set. All selections and the Fisher-Yates shuffle use 32-bit rejection sampling rather than modulo-biased bytes.
150.4.2, .6 Canonical EFF long and short-list-2 assets are pinned with source URL, entry count, and SHA-256. Diceware supports 3–32 words and explicit list/separator/capitalization/number choices; memorable mode composes those controls. Tests prove every selected word belongs to the requested EFF list.
150.4.3 PIN generation supports exactly 4/6/8 digits and rejects repeated, sequential, year, keypad-common, and repeated-half patterns. Sixty generated PINs are checked by the weak-pattern classifier.
150.4.4, .9 DomainPolicyDatabase normalizes URL/host input, inherits parent-domain policies, clamps requested lengths, enforces required classes and exact allowed characters, and removes forbidden characters. The test policy simultaneously requires four classes, caps length, and forbids dollar.
150.4.5 Pronounceable generation alternates consonants/vowels, capitalizes the first character, and optionally replaces a noninitial position with a digit while maintaining exact length.
150.4.7–.8 The package uses zxcvbn 4.4.2 directly and exposes its score, guess count, entropy bits, warning/suggestions, and four online/offline crack-time scenarios. An explicit arbitrary-rate half-search estimator is included.
150.4.10 RecipeStore saves, clones, retrieves, deletes, and directly generates from validated named password recipes without leaking mutable configuration references.
150.4.11 UUIDv4 plus entropy-sized hex, base58, base64, and base64url generators are backed by the OS CSPRNG. Base58 preserves leading zero bytes and excludes ambiguous alphabet characters.
150.4.12 Ed25519, RSA-3072, and ECDSA-P256 generation emits PKCS#8 private PEM, SPKI public PEM, native authorized_keys public records, and SHA-256 fingerprints over the SSH wire blob. Every record is independently accepted by ssh-keygen -lf -.
150.4.13 BIP39 generation accepts all five standard entropy sizes, appends the SHA-256 checksum bits, and maps 11-bit indices through the pinned canonical 2,048-word English list. Tests match the canonical all-zero 128-bit vector and validate generated 12/15/18/21/24-word phrases.
150.4.14 The PKCS#10 helper DER-encodes subject names and public keys and signs requests with RSA-SHA256, ECDSA-SHA256, or Ed25519. OpenSSL independently verifies the signature and requested subject.
150.4.15 WireGuard output is exactly 32 random bytes in base64; Tailscale-style output is a 256-bit base64url secret with the expected auth-key prefix.

150.4 verification log#

  • tsc --noEmit -p libs/neith/vault-gen/tsconfig.json passes.
  • The focused Vitest suite passes twelve tests, including independent ssh-keygen and OpenSSL subprocess verification.
  • Runtime wordlist loaders enforce 7,776 EFF-long, 1,296 EFF-short, and 2,048 BIP39 entries; the asset README pins all three SHA-256 digests.

150.5 Autofill security and behavior core#

Implementation roots: libs/neith/vault-autofill/, apps/neith-vault/extension/, apps/neith-vault/android/, and libs/neith/vault-secret-service/.

Requirements Direct evidence
150.5.1 The build emits a Chromium Manifest V3 package for Chrome, Edge, and the Chromium-based sovereign browser. It grants only nativeMessaging plus HTTPS origins, runs only in the top frame, and routes opaque field metadata through the com.oshun.neith.vault native-messaging boundary. The background worker independently binds every request and response to the sender's HTTPS origin before any candidate or secret reaches the isolated content script.
150.5.2 The same audited source emits a Firefox Manifest V2 package with a pinned Gecko extension ID and Firefox 128 minimum, non-persistent background script, nativeMessaging, HTTPS-only matches, and top-frame-only content execution. Chromium and Firefox Playwright projects exercise the browser content behavior against the same secure-fill and insecure-origin rejection contract.
150.5.6, .9 The Android application declares a platform-bound AutofillService and an independently opt-in AccessibilityService. Autofill walks the current AssistStructure, classifies only username/password fields, excludes Neith itself, scopes candidates to normalized web domains, and emits datasets only while the Android-Keystore-backed vault session is unlocked. The old-OEM fallback never reads node text, accepts only editable password nodes outside Neith, displays a TYPE_ACCESSIBILITY_OVERLAY, and performs ACTION_SET_TEXT only after an explicit user tap. Both services require their respective system-only bind permissions. JVM tests exercise field classification/domain normalization; a compiled instrumentation suite checks manifest permissions, screenshot blocking, accessibility, phone layout, and fallback eligibility. Native execution remains open because this host exposes neither a device nor KVM: both installed x86_64 API 34/35 images fail to reach a usable package/activity service under bounded software-emulation attempts.
150.5.8 The Linux Rust bridge owns org.freedesktop.secrets on the user session bus and exposes spec-shaped Service, Collection, Item, and Session objects backed by a narrow async VaultBackend trait. Searches return stable opaque object paths, reads require a session actually opened by this process, locked vaults fail closed, unsafe IDs/attributes are rejected, secrets are copied through zeroizing buffers, and unlock is delegated to the trusted Neith UI rather than accepted over D-Bus.
150.5.10 detectField first honors standardized autocomplete semantics, then applies a deterministic local linear classifier to type/name/id/label/placeholder features for incomplete and unusual forms. It distinguishes username, current/new password, email, and OTP while refusing hidden, disabled, readonly, or low-confidence fields. Fixtures exercise incomplete metadata for every supported purpose.
150.5.11 matchUrl requires credential-free HTTPS URLs, distinguishes exact hosts from opted-in subdomains, supports segment-bounded path prefixes, and permits only anchored, length-bounded regexes after rejecting backreferences, lookaround, stacked quantifiers, and nested quantified groups. Tests cover sibling-host deception, HTTP, embedded credentials, exact path matching, and a ReDoS-shaped pattern.
150.5.12 assessPhishing permits only the trusted host or its descendants, converts IDNs to Unicode, normalizes compatibility/combining characters, maps common Cyrillic/Greek confusables, and blocks equal or one-edit visual skeletons. Tests block both an ASCII one-edit lookalike and a punycode homograph while allowing a legitimate account subdomain.
150.5.13 InlineMenuController is a secret-free isolated-world state machine rather than an iframe. It bounds and validates opaque IDs/display metadata, rejects duplicates and control characters, exposes clone-only state, provides wraparound keyboard navigation plus Home/End/Escape/Enter, and closes/clears metadata immediately after selection.
150.5.14 IsolatedAutofillBridge uses one-use random request IDs and opaque field tokens, denies non-top/cross-origin frames, requires exact page/top/grant origin binding, applies values only through an injected native-setter callback (no script/eval/style injection), accepts canonical UTF-8 without NUL, zeroes the secret buffer on every path, and rejects replay.
150.5.15 LocalAutofillTelemetry has no network or storage callback and accepts only four aggregate event enums. It retains daily counters for at most 30 days and never accepts URLs, origins, items, users, fields, or secret values; snapshots are cloned and the complete state can be cleared.

Safari, iOS/macOS, and Windows packaging/integration targets (150.5.3–.5 and 150.5.7) remain open pending their native application/extension hosts. The Android targets (150.5.6 and 150.5.9) now have buildable implementation and compiled automation, but remain unchecked pending execution on a usable Android runtime. The browser extension deliberately transports requests across a named native-host boundary; it does not embed vault state or plaintext persistence in the browser.

150.5 verification log#

  • Prettier, ESLint with zero warnings, and tsc --noEmit -p libs/neith/vault-autofill/tsconfig.json pass.
  • The focused Vitest suite passes fourteen URL, phishing, field-classification, iframe isolation, CSP-safe fill, keyboard-menu, replay, zeroization, and local telemetry tests.
  • Seven extension-focused Vitest checks validate both emitted manifests plus top-frame, HTTPS, request-origin, and native-response-origin enforcement; the build produces separate Chromium MV3 and Firefox MV2 directories from one audited source tree.
  • Four Playwright checks pass across real Chromium and Firefox engines: secure candidate presentation/fill and rejection on an insecure page in each engine. An axe WCAG 2 A/AA scan runs after every browser check and reports no serious or critical violations.
  • Linux cargo check, rustfmt, and Clippy with warnings denied pass. Two Rust tests run under dbus-run-session; the integration case connects a second client to the real ephemeral bus, opens/closes a session, searches the collection, reads an item and secret, observes locked-state denial, and rejects a fabricated session path.
  • Android API 36 debug/release phone APK, debug instrumentation APK, JVM contract tests, and debug/release Android lint with warnings promoted to errors pass. The device runner is bounded and supports unaccelerated emulation, but API 35 ATD reached ADB without starting system_server and the API 34 Pixel image timed out before ADB connectivity because the host exposes no KVM/VMX/SVM; no device-test pass is claimed.
  • V8 coverage is 88.70% statements, 83.95% branches, 96.96% functions, and 92.54% lines across the complete package.

150.6 Sharing, collections, family, and team#

Implementation root: libs/neith/vault-share/.

Requirements Direct evidence
150.6.1 One-time links encrypt with a fresh 256-bit XChaCha20-Poly1305 key, bind share/item/expiry as AAD, retain the key only in the URL fragment, require HTTPS, and reject expiry, revocation, wrong origin, and second consumption. The serialized service store is proven not to contain plaintext.
150.6.2 Direct recipient shares use the crypto core's RFC 9180 HPKE implementation, bind sender/recipient/item/expiry metadata, pin recipient identity, and reject the wrong private key.
150.6.3–.4 Shared collections deduplicate item membership and principal grants. Managed-directory-derived authorization implements exact view/edit/admin/reveal-disabled capabilities; callers cannot self-assert group IDs.
150.6.5 FamilyAccount counts the owner toward an enforced five-member maximum, prevents a second owner, and manages explicit recovery delegates.
150.6.6–.7 TeamDirectory maintains deduplicated members and arbitrary organisation/department/team nesting, prevents hierarchy cycles, resolves descendants for membership reports, and resolves ancestors for inherited ACLs.
150.6.8 Emergency access models a trustee request, owner rejection/revocation, an automatic dead-man waiting period, bounded active access window, and expiry. Access requires both the named trustee and current active state.
150.6.9 Reveal/copy/autofill and lifecycle actions append to a SHA-256 hash chain authenticated with HMAC-SHA256. Sequence, linkage, content, and signatures are verified; mutation is detected.
150.6.10 Ghost links inherit one-time consumption and synchronously invoke item rotation after reveal, recording both reveal and rotation audit events.

150.6 verification log#

  • tsc --noEmit -p libs/neith/vault-share/tsconfig.json passes.
  • The focused Vitest suite passes nine encryption, authorization, membership, emergency-access, and audit tests.

150.7 Recovery and account lifecycle#

Implementation root: libs/neith/vault-recovery/.

Requirements Direct evidence
150.7.1 generateEmergencyKitPdf emits a self-contained one-page PDF with account identity, HTTPS sign-in origin, Secret Key, timestamp, offline-storage warning, and optional instructions. The Master Password value is never accepted by the API. pdfinfo independently parses the generated artifact in the test suite.
150.7.2 Recovery data is XChaCha20-Poly1305 sealed under an Argon2id-derived account key that mixes both the Master Password and Secret Key. Version and AAD are fixed, derived key material is zeroed, and either wrong factor fails authentication.
150.7.3 Social recovery wraps the crypto core's byte-preserving Shamir M-of-N implementation with unique named contacts, issuance identifiers/timestamps, and duplicate-contact rejection during creation and recovery. A non-adjacent 3-of-5 subset reconstructs the exact secret.
150.7.4 ConsentResetService requires a reason, binds one random 256-bit challenge to the member, compares it through fixed-size SHA-256 digests, requires consent before completion, pins the initiating administrator, prevents repeat transitions, clears the used challenge, and records each actor in an audit trail.
150.7.5 HardwareTokenRecoveryService enrolls a YubiKey/sovereign-HSM recovery slot through the provider-neutral KMS boundary, keeps only the provider key ID, wrapped 256-bit recovery key, and an account/token/algorithm/ciphertext-binding HMAC, and destroys custody on revoke. Recovery requires a digest-only random challenge valid for 30 seconds to five minutes; issuing a new challenge invalidates the old one, every attempted use consumes it, exact expiry and cross-account use fail, and unwrap/binding failures are indistinguishable. The sovereign-HSM integration executes enrollment, PIN-gated recovery, non-extractability inspection, replay denial, and token-object destruction against a real isolated SoftHSM PKCS #11 token. A physical YubiKey run is not claimed.
150.7.7–.8 Device enrollment uses a short-lived random challenge and Ed25519 proof of private-key possession bound to account and device IDs. Challenges are one-use and expiry-bounded; the registry exposes last-seen updates, account-scoped listing, revocation, and post-revocation denial.
150.7.9 Secret Key rotation derives old and new account/vault keys, decrypts and reseals every item envelope without changing its identity or generation, preserves its selected AEAD algorithm, zeroes temporary plaintext and keys, and returns a timestamped replacement ceremony result. Tests prove the new key opens the item and the old key does not.
150.7.10 Cryptographic erasure fingerprints the doomed account key, zeroes it in place, and signs the account ID, destroyed-record count, fingerprint, and deletion time with an Ed25519 attestation key. Verification validates both signature and payload schema and rejects mutation.

The Android implementation now uses the framework BiometricPrompt with strong biometric or device-credential authentication and binds its AES-256-GCM vault key to Android Keystore user authentication, invalidating it on biometric enrollment changes. Its compile/lint gates pass, but 150.7.6 remains open until that path runs on biometric hardware and until the named Apple/Windows paths exist. Hardware recovery is exercised through the sovereign-HSM alternative against a real PKCS #11 token; a physical YubiKey run is not represented.

150.7 verification log#

  • tsc --noEmit -p libs/neith/vault-recovery/tsconfig.json passes.
  • The focused Vitest suite passes eleven recovery, consent, hardware-token, device, rotation, erasure, and composed device-loss drill tests. The PDF test invokes the independent system pdfinfo parser.
  • Package-local V8 coverage is 84.98% statements, 76.55% branches, 97.77% functions, and 92.03% lines.

150.8 Breach and weakness monitoring#

Implementation root: libs/neith/vault-watchtower/.

Requirements Direct evidence
150.8.1 lookupPwnedPassword SHA-1 hashes locally and sends only the first five uppercase hexadecimal characters to the fixed HTTPS Pwned Passwords range origin. It requests response padding, identifies itself, accepts cancellation, bounds the response size, strictly validates every suffix/count row, and returns only the local full-suffix match. Tests inspect the request and prove the plaintext is absent.
150.8.2 SovereignBreachFeed implements a commutative private-set-intersection protocol over Ristretto255: the client hashes and independently blinds each identifier, the server evaluates blinded points under a private scalar, and the client unblinds locally before comparing against server-keyed public feed tokens. The protocol bounds batches and validates point encodings. Tests recover exactly a non-contiguous intersection and prove repeated queries are unlinkable at the blinded-element layer.
150.8.3 Weak-password analysis combines a configurable minimum length with the real zxcvbn 4.4.2 assessment exported by @neith/vault-gen; the full strength result remains available for explanation.
150.8.4 Reuse clustering hashes passwords only in transient local memory, returns sorted item-ID clusters, excludes singleton groups, and never places a password or fingerprint in the report.
150.8.5–.7 Item analysis independently flags advertised-but-disabled 2FA, expired/soon-expiring cards and identity documents against a caller-controlled clock, and login entries whose parsed URL uses cleartext HTTP. Invalid URLs and timestamps fail closed.
150.8.8 detectCredentialStuffing consumes the exact flattened Phase 151 authentication event fields, validates bounded batches/events and per-host monotonic sequence, ignores successes, aggregates failures by principal and distinct source, requires a configurable minimum threshold, maps only through an explicit principal-to-vault-item table, and emits deterministic @neith/edr-agent warnings. A schema-shaped multi-source event fixture flows through detection into watchtower scoring.
150.8.9 Each item receives a bounded 0–100 additive score with explicit reasons. Each vault receives a bounded maximum/mean composite plus item and high-risk counts, avoiding dilution of a single critical credential in a large vault.
150.8.10 Password-bearing findings form a deterministic descending rotation queue, with item ID as the stable tie-breaker. Known breaches, weakness, reuse, missing MFA, HTTP, and validated stuffing signals all affect priority.

150.8 verification log#

  • tsc --noEmit -p libs/neith/vault-watchtower/tsconfig.json passes.
  • The focused Vitest suite passes eleven privacy, protocol, EDR-schema, sequence, parsing, weakness, aggregation, and input-validation tests.
  • Package-local V8 coverage is 89.74% statements, 83.60% branches, 95.00% functions, and 94.11% lines; the transitive generator package retains its separate focused suite.

150.9 Developer CLI core#

Implementation root: libs/neith/vault-cli/.

Requirements Direct evidence
150.9.1 The buildable neithvault executable implements list, raw get, JSON-fed create, and run. Its production backend requires an HTTPS URL without embedded credentials, uses bearer authorization, rejects redirects, bounds JSON responses, uses canonical base64 for secret bytes, and encodes every path segment. Create accepts fields via stdin or a mode-controlled file rather than exposing secret values in the process list. Tests execute list/get/create/run dispatch, and the built ESM executable independently prints all four commands.
150.9.2 runWithSecrets parses strict references, validates and deduplicates environment names, rejects NUL and invalid UTF-8, fetches into temporary byte buffers, directly spawns an executable with shell: false, propagates its status, and removes injected environment entries on error or exit. The subprocess test exits successfully only when it observes the injected secret and verifies the source buffer was zeroed.
150.9.3 parseSecretReference and formatSecretReference round-trip exactly three encoded vault/item/field segments under the nv: scheme while rejecting credentials, ports, queries, fragments, traversal, separators, NUL, missing, and extra segments.
150.9.5 SecretSessionCache defaults to exactly 15 minutes, enforces a bounded TTL, clones values at both boundaries, deterministically expires entries, and zeroes stored bytes on replacement, deletion, expiry, lock, or clear. CachedVaultBackend zeroes freshly retrieved backend buffers after caching them.
150.9.6 The built neithvault ssh-agent command reads public-key/reference bindings from bounded JSON, creates a mode-0600 Unix agent socket, prints a shell-safe SSH_AUTH_SOCK export, and shuts down cleanly on SIGINT/SIGTERM. It implements bounded SSH-agent framing, identity listing, constant-time key-blob selection, and Ed25519/RSA/ECDSA signing. Native unencrypted openssh-key-v1 Ed25519 seeds are strictly decoded in memory and converted to PKCS#8 with decoded buffers zeroed. neithvault git-credential implements the Git helper get/store/erase protocol, restricts retrieval to exactly matched HTTPS host/path rules, rejects malformed/ambiguous inputs, and zeroes fetched username/password buffers.
150.9.7 VaultSshAgentServer is a standard SSH agent socket suitable for OpenSSH forwarding: it retains only public bindings and fetches the private-key field from the vault for an individual sign request. A real ssh-add -L process lists the identity without retrieving the private key, and real ssh-keygen -Y sign processes sign with Ed25519, RSA-SHA2, and ECDSA keys through the socket; each backend-returned private buffer is zero afterward.
150.9.8 gitSshSigningConfig pins Git's SSH signature mode and the configured public key while signing stays in the vault agent. The integration test initializes a real repository, removes the generated private-key file, creates a signed commit through SSH_AUTH_SOCK, inspects the commit's SSH signature armor, and proves a single on-demand key fetch was zeroed.
150.9.9 The GPG adapter forces batch/loopback mode and passes the vault passphrase only on inherited fd 3; a real GPG AES-256 symmetric encrypt/decrypt round-trip passes. The age adapter forces --identity -, streams the identity on stdin, and rejects caller identity overrides; a real generated age identity encrypts a file and the adapter decrypts it. Neither secret enters argv, environment variables, or a temporary adapter file, and source/payload buffers are zeroed.
150.9.10 sdks/neith-vault supplies list-vaults, list-items, get-secret, and create-item clients for Node, Python, Go, Rust, and Swift against one versioned API contract. Each implementation requires HTTPS without URL credentials, carries the token only as bearer authorization, refuses redirects in its production transport, encodes path segments independently, bounds responses to 10 MiB, and rejects malformed/noncanonical base64. Python is dependency-free; Go uses an injectable HTTPDoer; Rust ships a real rustls transport behind a tested transport seam; Swift uses an ephemeral no-cookie URLSession with redirect cancellation; Node uses the existing HttpVaultBackend. The checked-in matrix runner compiles and tests every language, including Swift 6 in a pinned Linux container.
150.9.11 neithvault kubernetes-sidecar runs an abortable refresh loop over reference-only bindings and writes changed values through exclusive owner-only temporary files, fsync, atomic rename, and mode 0600. It rejects absolute/traversing/duplicate paths, symlink parents, non-regular targets, empty/oversized values, and unsafe intervals; unchanged content is not rewritten. The deployment example uses a memory-backed shared volume, read-only application mount, non-root UID/GID, RuntimeDefault seccomp, no capabilities/privilege escalation, and a read-only sidecar root filesystem. Kubeconform strictly validates both resources.
150.9.12 neithvault ci-export emits either GitHub command-file heredocs (including multiline values and runner mask commands) or owner-only dotenv files from bounded reference bindings, while validating/deduplicating variable names and zeroing retrieved buffers. The composite action passes all untrusted inputs through environment variables rather than interpolating them into shell code, resolves directly into GITHUB_ENV, and is accepted by the action-metadata schema validator.
150.9.13 neithvault buildx maps each validated secret ID to a deterministic collision-checked process-local environment slot and supplies only --secret id=...,env=... arguments to docker buildx build; fetched buffers and the child environment copy are cleared after exit. A command-capture test proves the value is absent from argv/files. The opt-in real BuildKit test mounts a random value at /run/secrets/npm-token, verifies its digest in the designated step, proves the mount is absent from the next layer and a running image, and proves the random value is absent from image history.
150.9.14 The Terraform module invokes the built CLI through HashiCorp external v2.4.0, validates named nv:// references, keeps URL/token out of module inputs, and marks the complete result sensitive; its documentation explicitly warns that external-data values remain in Terraform state. A real terraform apply calls the built CLI against a locally trusted TLS vault endpoint and resolves the sensitive output. The Pulumi dynamic resource reads URL/token only from deployment environment, enforces strict HTTPS/bearer/canonical-base64 transport, refreshes on create/read/update, replaces on reference change, and marks value both with pulumi.secret and additionalSecretOutputs; provider transport and secret propagation tests pass with Pulumi 3.253.0 and the production dependency audit reports no vulnerabilities.
150.9.15 The dotenv/direnv bridge refuses to write without explicit opt-in, validates names and values, records a machine-checkable expiry, writes through an exclusive random temporary file plus sync/atomic rename, and forces owner-only mode 0600. The reader rejects malformed or expired caches. Filesystem tests verify permission bits and the exact expiry boundary.

Native biometric CLI unlock remains open pending per-OS secure-hardware integration and target-device validation.

150.9 verification log#

  • ESLint passes with zero warnings and tsc --noEmit -p libs/neith/vault-cli/tsconfig.json passes.
  • The focused Vitest suite passes fourteen URI, session, HTTPS-backend, command, subprocess-injection, zeroization, filesystem, real OpenSSH/Git signing, credential-helper, real GPG, and real age tests.
  • tsup builds dist/cli.js; invoking the artifact with node prints all four supported subcommands without requiring vault credentials for help.
  • sdks/neith-vault/verify-matrix.sh passes the Node Vitest/typecheck gate, Python unittest/compile gate, Go vet/race gate, locked Rust test gate, and Swift 6 Linux-container build/test gate.
  • The provider suite has nineteen default cases plus opt-in real BuildKit and Terraform/TLS cases; all twenty-one pass. Kubeconform validates the sidecar resources, the GitHub action metadata validator accepts the composite action, Terraform validates after locked provider initialization, Pulumi's two tests pass, and npm audit --omit=dev reports zero vulnerabilities.

150.10 Secrets engine core#

Implementation root: libs/neith/vault-engine/.

Requirements Direct evidence
150.10.1 VersionedKvEngine provides immutable numbered versions, optimistic check-and-set, version-specific read, soft delete/undelete, irreversible value destruction, cloned values, metadata, and namespace-scoped listing. Tests cover the entire lifecycle and prove tenant isolation.
150.10.2 DynamicDatabaseCredentials registers tenant-scoped roles for Postgres, MySQL, MongoDB, and Redis drivers, generates independent high-entropy usernames/passwords, awaits the driver create operation before disclosure, binds each principal to a renewable capped lease, invokes the same driver on explicit/expiry revocation, and compensates by revoking if lease creation fails. Tests execute all four driver paths and denial boundaries.
150.10.3 DynamicCloudCredentials registers tenant-isolated AWS/GCP/Azure roles, requests provider-bounded lifetimes, wraps results in nonrenewable leases, rejects overlong/provider-mismatched credentials, and invokes provider revocation where supported. AwsStsProvider sends a bounded HTTPS AssumeRole request with SigV4, optional source-session-token signing, strict XML extraction, and zeroed source/signing keys; its captured signature is independently recomputed in the test. GcpStsProvider implements RFC 8693 workload token exchange, and AzureStsProvider implements OAuth 2 client credentials; both require HTTPS, reject redirects/bad token types/lifetimes, and zero subject/client-secret buffers.
150.10.4 SshOtpEngine issues CSPRNG passwords valid for at most five minutes, stores only SHA-256 digests, binds verification to namespace/host/principal, compares digests in constant time, consumes an OTP exactly once, rejects exact-boundary expiry, and zeroes digest buffers during purge. Tests prove context mismatch, replay, expiry, and invalid host rejection.
150.10.5 X509PkiEngine generates P-256 PKCS#8 keys and bounded random serials, creates a self-signed root constrained to path length 1, creates a root-signed intermediate constrained to path length 0, and issues CA-false leaves with strict DNS/IP SAN and server/client EKU validation. Temporary key files are owner-only and recursively removed in finally. The test independently runs openssl verify with hostname and SSL-server purpose across the full root/intermediate/leaf chain.
150.10.6 TransitEngine keeps non-exportable AES-256-GCM key versions, authenticates namespace/key/version as AAD, rotates and rewraps ciphertext, enforces a minimum decryptable version, supports context-derived keys, rejects tampering, and zeroes derived plaintext/key buffers where ownership permits.
150.10.7 KmsTransitEngine exposes a provider-neutral KMS boundary and uses per-operation AES-256-GCM data keys wrapped by versioned key-encryption keys; namespace, key, version, opaque provider key ID, and wrapped key are authenticated as AAD, plaintext data keys are zeroed, rotation/minimum-version/destruction are enforced, and provider failures disclose no secret. Pkcs11KmsBackend generates 3072-bit RSA keys inside a real SoftHSM token, requests sensitive non-extractable private objects, keeps the PIN out of argv through an environment reference, streams unwrap input/output without plaintext key files, and destroys both token objects. The integration test verifies always sensitive/never extractable attributes, refused private-key export, real wrap/unwrap, isolation, tamper rejection, rotation, version retirement, and erasure.
150.10.8 LeaseManager issues bounded renewable leases, caps renewal at maximum TTL, validates parent leases, rejects expired/revoked credentials, runs provider revocation callbacks, and revokes descendant credentials before their parent.
150.10.9 The bounded policy compiler accepts only the documented path/capability grammar, implements exact, single-segment, and prefix matching, treats deny as authoritative across policies, and fails closed on unsupported syntax or capabilities.
150.10.10 A shared namespace/path normalizer rejects traversal, empty/control-character segments, backslashes, and oversized identifiers. Every KV, transit, lease, wrapping, policy, and audit lookup binds its data or authorization to the normalized tenant namespace.
150.10.11 AuthBackendRegistry implements AppRole with random role/secret identifiers, digest-only secret storage, constant-time verification, and tenant/role binding. JWT, OIDC, Kubernetes, AWS, GCP, and Azure assertions dispatch only to an exact registered verifier; missing or denying verifiers fail closed. Focused table tests execute every backend.
150.10.12 ResponseWrapper stores only a SHA-256 token digest, gives callers a 256-bit random one-time handoff token, clones payloads, bounds TTL to one day, consumes tokens on every unwrap attempt, and enforces tenant plus exact expiry.
150.10.13 ShamirUnseal uses the audited vault-crypto M-of-N implementation, rejects duplicate/incompatible/wrong-set shares, authenticates the reconstructed 256-bit key, exposes only an operation-scoped zeroed copy, and zeroes pending shares and live key material when resealed. The auto-unseal envelope binds provider, key ID, and cluster context; a provider implementation seals the master key with authenticated encryption, and a restart-style test proves correct-context recovery plus wrong-context rejection without persisting plaintext.
150.10.14 SignedAuditLog creates an ordered SHA-256 content chain authenticated by HMAC-SHA256, includes actor/operation/path/outcome and optional request metadata, provides independent exported-chain verification, uses constant-time signature/hash comparison, and detects content mutation.
150.10.15 HaClusterController coordinates an odd voting quorum plus non-voting DR replicas across a partitionable transport boundary. Active writes require a live fenced lease and a quorum of caught-up voters; HMAC-authenticated, SHA-256-chained records bind cluster/term/index/prior hash/payload; monotonic snapshots are bounded and independently reverify every record. Standbys catch up from authenticated snapshots, exact-expiry promotion issues a higher fencing term, an isolated old leader cannot write, DR replicas cannot serve before an explicit two-operator force promotion, and DR mode can continue after primary loss. Tests exercise lag, heal/catch-up, minority-write denial, stale leader fencing, normal failover, tamper/cross-cluster/wrong-key rejection, and isolated DR continuation.

Database, cloud-KMS, external-auth, replication-transport, and linearizable leader-lease integrations use explicit production driver/verifier boundaries; the focused suite verifies orchestration and security invariants without claiming a live cloud-provider or multi-host deployment. PKCS #11 custody is additionally exercised against a real isolated SoftHSM token.

150.10 verification log#

  • ESLint passes with zero warnings and tsc --noEmit -p libs/neith/vault-engine/tsconfig.json passes.
  • The focused Vitest suite passes forty lifecycle, isolation, multi-process HA, cryptographic, authorization, dynamic-driver, authentication-backend, PKI-chain, expiry, replay, tamper, and validation tests.
  • V8 reports 84.31% statement, 76.31% branch, 93.28% function, and 88.61% line coverage for vault-engine/src; transitive vault-crypto files are excluded from the package-specific percentage because they have their own focused suite.

150.11 Privileged access management core#

Implementation root: libs/neith/vault-pam/.

Requirements Direct evidence
150.11.1, .9 SessionRecorder accepts SSH, RDP, database, and Kubernetes sessions and records ordered input/output/command/resize/metadata frames. Every frame binds session identity, actor, target, protocol, start time, sequence, prior hash, payload, and encoding into a SHA-256 chain authenticated with HMAC-SHA256. Independent verification succeeds for all four protocols, including a recorded kubectl exec, and detects payload mutation.
150.11.2–.3 JustInTimeAccessService validates resource/capability/duration requests, limits eligible approvers, prevents self-approval and replay, activates only at the configured quorum, authorizes only the exact requester/resource/capability tuple, expires at the exact boundary, supports explicit revocation, and records every transition with actor and time.
150.11.4 Emergency requests require at least a two-person quorum, follow the same unique-approver and exact-scope rules, and remain bounded to a maximum 24-hour elevation. A test proves one-person break-glass is rejected and quorum access can be immediately revoked.
150.11.5, .7 SecretlessProxy accepts only vault-reference-shaped identifiers, retrieves the credential directly from its provider, copies it into the trusted connector only, never includes it in the caller-visible request or result, and zeroes both provider-owned and connector-owned buffers on success or error.
150.11.6 CommandPolicy normalizes a single command, supports bounded allow/deny globs, gives every matching deny precedence, defaults to deny, and rejects multiline/NUL command smuggling. Tests cover allowed maintenance, an overlapping explicit deny, unmatched input, and newline injection.
150.11.8 RemoteAccessBroker restricts targets to an explicit SSH/RDP/database/Kubernetes allowlist, delegates cryptographic MFA proof validation to a verifier, requires a fresh actor-bound assertion plus active JIT authorization, caps the session by both MFA and requested expiry, stores only a SHA-256 token digest, and supports immediate revocation.
150.11.10 CloudConsoleBroker registers tenant-scoped cloud roles, requires an injected exact actor/role authorizer, bounds sessions to 15 minutes–12 hours, and retains provider URLs only behind random digest-indexed one-use handoff tokens bound to tenant/actor with exact-expiry and consume-on-mismatch behavior. AwsConsoleProvider requests short-lived credentials through a production boundary, performs the documented fixed-origin getSigninToken exchange with redirect denial and bounded strict response parsing, constructs the HTTPS federation login URL, and zeroes source secret/session-token buffers on success and error. Captured-protocol tests inspect the full AWS session request, prove authorization/isolation/replay/expiry behavior, and reject a redirected federation response.

The PAM package exposes production credential, authorization, federation, and connector boundaries; tests validate the AWS federation protocol and security behavior without claiming live cloud credentials or that an in-memory connector is a deployed SSH/RDP/Kubernetes gateway. GCP/Azure adapters can implement the same provider boundary but are not claimed by the AWS-SSO-class requirement.

150.11 verification log#

  • ESLint passes with zero warnings and tsc --noEmit -p libs/neith/vault-pam/tsconfig.json passes.
  • The focused Vitest suite passes thirteen approval, expiry, quorum, federation, protocol, tamper, command-policy, zeroization, MFA, target, and revocation tests.
  • V8 reports 82.14% statement, 77.57% branch, 91.52% function, and 85.56% line coverage for the complete package.

150.12 Desktop, web, Android, and Wear OS vault UI#

Implementation roots: apps/neith-vault/web/, apps/neith-vault/desktop/, and apps/neith-vault/android/.

Requirements Direct evidence
150.12.1 The Tauri 2 host loads the same production-built vault surface under a stable application identity, a bounded resizable window, a strict content-security policy, and local frontend distribution. Its Rust library and binary compile on Linux against a committed 471-package Cargo lock, and its bundle metadata plus RGBA icon are present for downstream signed packaging.
150.12.2 The Android half is a native API 28–36 application with a secure-window biometric gate, Android-Keystore AES-256-GCM ciphertext persistence, validated login creation, bounded/versioned binary records, search, reveal, sensitive clipboard copy, Autofill settings, and a calm phone layout with explicit content descriptions and ≥44 dp actions. No demo credential ships in the initial encrypted vault. JVM tests cover record round-trip plus truncation/trailing-data rejection; its build, instrumentation compilation, and warnings-as-errors lint pass. The combined row remains open because iOS is absent and the Android instrumentation APK cannot run without a usable device/KVM runtime on this host.
150.12.3 The responsive React/Vite vault app gates its workspace behind navigator.credentials.get with a random 32-byte WebAuthn challenge, relying-party binding, required user verification, a secure-context check, cancellation/error reporting, and no password fallback.
150.12.4 The Wear OS half builds as a non-standalone watch companion under the phone application's identity. It publishes a watch-generated 3072-bit Android-Keystore RSA public key over the app-private Data Layer; phone quick-copy creates a one-minute envelope with a random AES-256-GCM content key wrapped by RSA-OAEP, and sends it as an ephemeral connected-node message. The watch persists ciphertext only, requires strong biometric/device credential before private-key use, marks clipboard content sensitive, and deletes decrypted/pending material after copy or expiry. JVM tests prove round-trip, exact expiry, wrong-watch denial, and ciphertext-tamper denial. The combined row remains open pending paired-watch runtime automation and the Apple Watch half.
150.12.5 The native tray exposes only Open, Lock, Hide, and Quit actions plus left-click visibility toggling. Lock emits a narrow vault-lock-requested event; the frontend clears revealed state and returns to the passkey gate, which Playwright verifies. Closing the desktop window prevents process exit and hides it back to the tray.
150.12.6 Tauri's OS global-shortcut plugin registers parsed CommandOrControl+Shift+Space. A press only shows, centers, and focuses the vault window; it never carries a secret or bypasses the passkey gate. Rust tests verify shortcut parsing and prove the closed tray-action allowlist rejects unknown IDs.
150.12.7 The selected-item inspector accepts drag/drop files, rejects files over 25 MiB before state admission, reports accepted name and size, and exposes a keyboard-focusable labelled drop target with a polite attachment-count update.
150.12.8 Dark, light, and true OLED-black token sets are cycled from an accessible control, applied at the document root, persisted locally, and exercised through every state in Playwright. No font or other presentation asset is fetched from a third party.
150.12.9 The app supplies skip navigation, labelled navigation/main/complementary landmarks, a single workspace h1, structured details, option selection state, strong visible focus, a keyboard search shortcut, responsive phone magnification/reflow, and a no-animation reduced-motion mode. The shared Playwright fixture runs WCAG 2 A/AA axe analysis after every desktop and phone flow, while a dedicated audit requires zero violations of any impact.
150.12.10 The production service worker discovers and pre-caches the hashed Vite shell during installation, serves exact cached resources first, limits the shell fallback to navigations, and retains changes locally when connectivity events report offline. A production-preview Playwright test installs the worker, verifies JS/CSS cache entries, forces the browser fully offline, reloads the shell, and completes passkey unlock. mergeVaultRecord resolves every field by Lamport clock and stable device-ID tie-break, and its unit test proves bidirectional merge convergence.

150.12 verification log#

  • ESLint and tsc --noEmit pass with zero errors or warnings.
  • Vitest passes the deterministic offline merge unit test.
  • Vite's production build passes and emits the hashed app shell.
  • Six Chromium Playwright flows pass for WebAuthn unlock, search/selection/reveal, all three themes, keyboard focus, bounded attachment drop, online/offline state, phone reflow, native tray lock handling, and automatic WCAG 2 A/AA axe checks.
  • A separate production-preview Playwright gate passes a real service-worker install, full offline reload, and offline passkey unlock.
  • Cargo formatting, locked checking, warning-denying Clippy, and locked native tests pass; the two Rust tests cover the tray allowlist and global shortcut contract. Frozen pnpm install passes for both Neith application packages.
  • The finished 1440×900 workspace was visually inspected after automation.
  • Android phone and Wear OS debug/release APKs, both JVM suites, debug/release lint with warnings promoted to errors, and phone instrumentation APK assembly pass. Native phone/watch and paired Data Layer execution remain unclaimed because the host has no device and cannot boot its x86_64 emulators without KVM.

150.13 Encrypted sync, import, backup, and storage integrity#

Implementation root: libs/neith/vault-sync/.

Requirements Direct evidence
150.13.1 sealSyncItem encrypts each JSON item with XChaCha20-Poly1305 under a client vault key and authenticates vault/item/device/revision/time metadata. EncryptedSyncStore rejects extra plaintext-shaped fields, stores only a fixed ciphertext schema, requires monotonic revisions, and returns cloned ciphertext changes/snapshots. Tests prove a wrong key and metadata mutation fail authentication and serialized server state omits the secret.
150.13.2 The per-item CRDT tracks a Lamport clock per field plus a device vector, applies only advancing device counters, retains deletion tombstones, and resolves equal-counter conflicts by stable device ID. Bidirectional merge-order tests converge byte-for-byte while preserving independent edits and deletions.
150.13.3 SyncDeviceRegistry issues bounded one-use challenges, requires Ed25519 proof of possession over the complete account/device/challenge/expiry tuple, maintains enrollment and last-seen time, lists cloned account devices, supports revocation, and rejects challenge replay, foreign signatures, and revoked devices.
150.13.4 LanDiscoveryService exchanges bounded real UDP announcements, signs a canonical short-lived transcript with each enrolled device's Ed25519 key, accepts only configured trusted peers, rejects public cleartext endpoints and replayed nonces, and advertises domain-separated SHA-256 vault hints instead of vault IDs. pullLanChanges authenticates with a separately paired token, sends only the hint/cursor, bounds and validates every ciphertext record and monotonic cursor, and rejects cross-vault injection. Loopback tests exercise both actual UDP discovery and direct HTTP ciphertext pull.
150.13.5 @neith/vault-selfhost is a dependency-free Go HTTP server that stores only bounded opaque ciphertext blobs behind constant-time bearer authentication. It requires canonical SHA-256 upload checksums, validates keys against traversal, writes via owner-only synchronized temporary files plus atomic rename, lists deterministically, applies no-store/security headers, bounds headers/timeouts, and shuts down gracefully. CGO_ENABLED=0 produces a stripped static ELF; a multi-stage Dockerfile copies it into a non-root scratch image with an owned data volume. Go race tests, a Docker build, and a live container put/get/list flow pass.
150.13.6 S3BlobBackend stores only bounded opaque bytes, sends a SHA-256 checksum, supports scoped prefixes, paginated deterministic listing, get/delete/not-found semantics, strict bucket/key validation, and traversal rejection through the AWS S3 protocol. Its integration test starts an isolated real MinIO container and executes binary put/get/list/delete end to end.
150.13.7, .11 Snapshot and cursor-based incremental exports contain only already-encrypted sync records. The backup layer validates the cursor range, compresses the export, encrypts it again with XChaCha20-Poly1305 under an independent 256-bit backup key, binds vault/time as AAD, bounds decompression, zeroes transient buffers, and rejects a wrong key.
150.13.8 The 1PIF importer accepts JSON-lines or array exports and preserves login designation, concealed/custom fields, URLs, notes, folders, and favorite state. The 1PUX importer parses bounded ZIP central/local records, rejects encryption and ZIP bombs, extracts only export.data, walks accounts/vaults/items, and maps overview/details data. A constructed ZIP fixture exercises the archive path.
150.13.9 The Bitwarden importer preserves folders, favorites, notes, login/TOTP/URI data, custom concealed fields, cards, and identities. Password-protected exports support the documented PBKDF2-SHA256 and Argon2id KDF variants, Bitwarden HKDF-expand key separation, HMAC-SHA256 validation, AES-256-CBC data decryption, strict encoding/parameter bounds, constant-time MAC comparison, wrong-password rejection, and temporary key/plaintext zeroing. Both KDF paths execute in the test suite.
150.13.10 A quote-aware RFC-style CSV parser and explicit header mappings import LastPass, Dashlane, Chrome, Safari, and KeePass login exports, including commas inside quoted notes, folder/group, favorite, URL, username, password, note, and OTP fields. All five named formats have focused fixtures.
150.13.12 WebDavBlobBackend requires HTTPS except for explicit loopback air-gap use, keeps credentials out of URLs, applies Basic authorization, emits SHA-256 Digest metadata, bounds response bodies, encodes every path segment, rejects traversal, and implements PUT/GET/DELETE/PROPFIND listing. A real local HTTP/WebDAV harness verifies the complete authenticated method flow and missing-object behavior.
150.13.13 VaultChangePushService registers account/device destinations for APNs, FCM, or Web Push transports, replaces/revokes registrations with buffer zeroization, isolates account fan-out, and emits only a silent vault-sync message containing a keyed vault hint, monotonic revision, stable keyed collapse identifier, and content-available flag—never account/vault/item identifiers or secret data. Each transport receives an operation-scoped destination copy that is zeroed after success or failure, and per-device results tolerate partial provider outage. PushGatewayTransport requires HTTPS outside an explicit loopback test path, sends credentials only in authorization, denies redirects, and checks the response. A real HTTP gateway test executes success/failure fan-out and proves opaque payloads, account isolation, cancellation, and destination-copy zeroization.
150.13.14 Every store instance owns one validated region; each vault must be explicitly pinned before writes. Cross-region writes fail, and a non-empty vault cannot silently change region without a migration workflow.
150.13.15 The retrievability audit builds a domain-separated SHA-256 Merkle tree over bounded chunks, derives deterministic unique challenge indices from a random seed, returns only challenged chunks and sibling paths, checks final-chunk length, and verifies roots with constant-time comparison. A modified proof is rejected.

150.13 verification log#

  • ESLint passes with zero warnings and tsc --noEmit -p libs/neith/vault-sync/tsconfig.json passes.
  • The focused Vitest suite passes twenty-three encryption, metadata, CRDT, device, push-gateway, backup, import-format, KDF, region, Merkle-proof, MinIO, WebDAV, and real UDP LAN direct-sync tests.
  • V8 reports 81.03% statement, 71.85% branch, 98.39% function, and 87.81% line coverage for vault-sync/src; transitive vault-crypto files retain their separate focused suite.
  • The self-host server passes go vet, go test -race, static stripped binary inspection, scratch-image Docker build, and a live non-root container health/put/get/list integration flow.

150.14 Enterprise identity, policy, lifecycle, and DLP#

Implementation root: libs/neith/vault-enterprise/.

Requirements Direct evidence
150.14.1 VaultEnterpriseDirectory.federatedLogin delegates provider lookup, tenant isolation, enabled state, assertion age, verified-email policy, claim mapping, and JIT provisioning to the Phase 146 FederationBroker, then creates the vault member from its verified federated user result. Both enterprise OIDC and SAML providers execute in focused integration tests.
150.14.2 The directory consumes Phase 146 SCIM User and Group resources by their standard schemas, upserts users, preserves external identity and primary email, validates active same-tenant group members, replaces group membership deterministically, and removes all membership when a user is deactivated. Cross-tenant lookup is denied.
150.14.3–.4 EnterprisePolicyEngine enforces bounded authentication age, multi-factor or phishing-resistant passkey/WebAuthn/hardware authentication, and independently configurable managed, compliant, disk-encrypted, and healthy-EDR device signals. It fails closed when policy or required posture is absent and returns explicit denial reasons.
150.14.5 OffboardingService idempotently revokes every session and device through injected production adapters, transfers all owned vaults to a distinct successor, deactivates the member, returns exact counts/IDs, and appends member plus per-vault audit events. The test asserts operation order and proves a repeated workflow makes no second mutation.
150.14.6 EnterpriseRecoveryEscrow creates a dedicated provider-opaque KMS key per tenant/member and persists only the wrapped 256-bit recovery key plus a metadata-binding HMAC. Recovery requires an authorized initiating administrator, a bounded reason/expiry, and two distinct authorized approvers who are neither requester nor recovering member; release is fail-closed and single-use, exact expiry is denied, tenant isolation is enforced, and revoke destroys the KMS key and zeroes stored ciphertext/binding buffers. Every transition enters the signed admin audit chain without key material. A live isolated SoftHSM integration proves the RSA-3072 private key is always sensitive, never extractable, completes the ceremony through PKCS #11, and confirms both token objects disappear on revocation.
150.14.7 TravelModeService selects only sensitive locally available vaults for the member, awaits a cryptographic-purge adapter before marking each unavailable, records the exact purged set, refuses duplicate entry, restores ciphertext only on explicit exit, and audits both transitions without secret data.
150.14.8 AdminAuditTrail constrains administrative action names and uses the vault-engine signed audit chain: ordered sequence and previous hash, SHA-256 content digest, HMAC-SHA256 authentication, constant-time verification, cloned reads, tenant filtering, and actor/resource/outcome/metadata capture.
150.14.9 generateEnterpriseRiskReport validates only aggregate counts, bounds the score to 0–100, reports distinct members/vaults, high-risk/weak/reused/missing-MFA totals, unmanaged and dormant members, and a deterministic top-20 vault queue without accepting item or secret contents.
150.14.10 VaultDlp applies normalized blocked tags with default denial for unconfigured tenants, supports explicit HTTPS-origin exceptions and policy-controlled privileged override, blocks copy attempts before any secret value enters the API, and writes a denied audit event containing only actor/item/field/tag metadata.

150.14 verification log#

  • ESLint passes with zero warnings and tsc --noEmit -p libs/neith/vault-enterprise/tsconfig.json passes.
  • The focused Vitest suite passes ten federation-protocol, SCIM lifecycle, policy/posture, offboarding, recovery-ceremony, live-HSM, audit, travel, DLP, and reporting tests.
  • V8 reports 82.66% statement, 72.22% branch, 88.09% function, and 87.02% line coverage for vault-enterprise/src; the imported Phase 146 and vault-engine packages retain their own focused suites.

150.15 Release validation and assurance#

Requirements Direct evidence
150.15.1 The encrypted-sync test serializes the complete server store and proves an inserted plaintext secret is absent; wrong client keys and authenticated-metadata mutation fail. Backup exports contain only encrypted records and are independently AEAD-wrapped. Share tests similarly prove service state lacks shared plaintext. These executable invariants exercise the actual store/export implementations rather than a documentation assertion.
150.15.4 Focused import fixtures execute 1Password 1PIF and constructed 1PUX ZIP, Bitwarden plain JSON plus PBKDF2 and Argon2id encrypted JSON, and quote-sensitive LastPass, Dashlane, Chrome, Safari, and KeePass CSV mappings. Tests assert preserved URLs, usernames, passwords, TOTP/custom fields, notes, folders, favorites, cards, and identities, plus wrong-password/archive-boundary rejection.
150.15.5 LoginBackoff scopes state by tenant and normalized subject, uses exponentially increasing delay with bounded arithmetic and a configurable cap, denies before but allows at the exact boundary, isolates tenants, and clears state after success. The soak performs 10,000 consecutive failures/boundary checks, reaches the capped 53-attempt counter without overflow, and verifies reset.
150.15.6 The composed recovery drill enrolls a device with Ed25519 possession proof, marks the lost device revoked, reconstructs the old Secret Key from a non-adjacent 3-of-5 social-recovery quorum, decrypts/reseals the vault under a replacement Secret Key, proves the recovered item opens under the replacement, and proves the old vault key cannot open the rotated envelope. All transient keys are zeroed in cleanup.
150.15.8 The interop test decapsulates the emitted ML-KEM-768 and X25519 ciphertexts independently through the native provider using exported PKCS#8 keys, independently reconstructs the domain-separated transcript salt and HKDF input, and proves that result equals the package's hybrid secret. The focused suite also checks the standardized 1,088-byte ML-KEM-768 and 32-byte X25519 ciphertext sizes.
150.15.9 The HA chaos gate launches four independent Node processes as three voting replicas plus a non-voting DR replica over serialized IPC. It commits with a two-of-three quorum while withholding traffic to partition C/DR, kills the sole caught-up standby, proves the minority path rejects a write before proposal, restarts with a wrong membership key and verifies snapshot rejection, then restarts with the provisioned key and authenticates catch-up. Exact-expiry promotion advances the fencing term; the prior leader remains denied even with a skewed old timestamp, is killed, and rejoins from a signed snapshot after the new quorum commits. All four processes must converge on the same three-record hash chain, and DR remains unable to serve before promotion.
150.15.10 TODOS/phase-150-compliance-matrix.md maps implemented cryptography, access control, authentication/posture, audit, lifecycle, resilience, monitoring, DLP, minimization, and travel controls to SOC 2 TSC, HIPAA Security Rule, ISO/IEC 27001:2022 Annex A, and GDPR articles. It explicitly distinguishes engineering evidence from certification/legal assurance and lists deployment/organisational gaps.

KDF timing on a named mid-tier phone (150.15.2), live top-1000-site browser conformance (150.15.3), and an independent sovereign red-team engagement (150.15.7) remain open because their required hardware, external corpus/team, or browser fleet does not exist locally. They are not replaced with synthetic pass claims.

Remaining non-local gates audit — 2026-07-15#

All Phase 150 implementation work executable without the unavailable target runtimes is complete. Thirteen rows remain deliberately unchecked because their full acceptance condition requires a native target, physical hardware, live external fleet/corpus, or organisational independence unavailable in this checkout. The Linux x86-64 host now has Android platforms 34–36, build tools, platform tools, emulator 36.5.11, and API 34/35 x86_64 images, but no attached device and no KVM/VMX/SVM. A bounded -no-accel API 35 ATD boot reached ADB without system_server; the standard API 34 image timed out before ADB. Apple, Windows, physical biometric, paired-watch, and native mobile runtimes remain absent.

Open requirements Non-local acceptance boundary
150.5.3–.5 Safari Web Extension, iOS AutoFill Provider, and macOS Password AutoFill require Xcode, Apple signing/entitlements, and an Apple runtime. None exists on this Linux host.
150.5.6, 150.5.9, 150.12.2 Android implementation, debug/instrumentation APK assembly, JVM tests, and warnings-as-errors lint now pass. Native instrumentation remains required on a device or KVM-capable host; the installed x86_64 images cannot boot a usable Android framework under this VM. The iOS half of 150.12.2 additionally requires the Apple stack.
150.5.7 A Windows Credential Provider requires the Windows SDK, registration in a Windows logon runtime, and Windows integration validation; no Windows runtime/toolchain exists here.
150.7.6, 150.9.4 Android framework/Keystore biometric implementation compiles and lints, but its hardware-backed behavior still requires target biometric execution. Face ID, Touch ID, Windows Hello, and per-OS CLI biometric unlock require their named target hardware/APIs. Software mocks cannot prove key protection or user verification.
150.12.4 The encrypted Wear OS companion builds and its crypto protocol tests pass, but paired Data Layer, watch Keystore/biometric, and quick-copy clipboard behavior require a runnable Wear device/emulator. The Apple Watch half still requires Apple's watch SDK/runtime.
150.15.2 The requirement explicitly measures KDF duration on a named mid-tier phone; no phone is attached, so a desktop CPU benchmark would be a false substitute.
150.15.3 Conformance requires a live top-1000 corpus and a production extension/native-host browser fleet. The focused Chromium/Firefox tests prove the local contract but are not relabeled as that external campaign.
150.15.7 An independent red-team engagement cannot be performed or self-attested by the implementation agent; it requires a separate authorised team and sovereign pentest corpus.

This audit is a scope boundary, not a completion waiver: each row stays open until its stated external evidence is produced.