GIBLEX Phantom Suite
PH-01 · Vault core · Deep dive

Phantom Obscura — Features

A portable, hardware-bound security vault built for hostile environments — a Windows desktop app, an Android app, and a browser extension over one shared vault engine. This page covers every layer: lifecycle, architecture, cryptography, authentication, defence, autofill, recovery, and threat model.

Vault lifecycle

The vault is not "opened." It is provisioned, verified, and mounted. Phantom Obscura follows a strict lifecycle designed to reduce exposure time and prevent silent failure states. Passwords are an optional extra factor in that lifecycle — the USB keyfile is not.

PROVISION VERIFY MOUNT ACTIVE SEAL Provision → verify → mount → auto-lock → seal

Lifecycle flow

  1. USB keyfile required — KeyfileGuard refuses every create, unlock, and mount path without it
  2. Device identity evaluated — serial / VID / PID, plus an optional per-machine device salt
  3. Environment checks — the signed policy engine decides whether access is allowed
  4. Key derivation — Argon2id, a DPAPI-protected pepper, and the keyfile produce the master key
  5. Verifier check — the master key is validated against a stored HMAC verifier before anything decrypts
  6. Vault unlock — the container header hash and HMAC are checked before the payload is touched
  7. Session active — UI reveals only what is required, when required
  8. Auto-lock triggers — idle timeout, focus loss, USB removal, manual lock
  9. Memory wipe — key material zeroed with CryptographicOperations.ZeroMemory
  10. Vault unmounted — the system returns to a sealed state

This design makes "walk away and forget" a non-event.

Core architecture

Separation is a security feature. Phantom Obscura is split into distinct layers so that a compromise in one area does not cascade.

PhantomVault.Core · vault engine PhantomVault.UI · interface Platform · privileged broker Isolated layers — a breach in one does not cascade

Crypto (GiblexVault.Security.ZK)

The primitives layer, and nothing else: Argon2id, AES-GCM, HKDF, key wrapping, the zero-knowledge vault format, and recovery material. It has no idea what a credential is.

PhantomVault.Core (vault engine)

The heart of the system. It owns:

  • Vault file structure and lifecycle
  • The v4 container format — static bootstrap header, Argon2id KDF material, and an encrypted private header carrying the payload hash and HMAC (still reads v2 and v3)
  • Encryption and decryption orchestration, including the post-quantum hybrid pipeline
  • Key derivation and the zero-knowledge verifier
  • Integrity and tamper validation, and update signature verification
  • Policy enforcement and the security defence engine
  • Passkeys, TOTP, import/export, USB binding, and the secure rubbish bin

The core treats the UI as an untrusted consumer. It multi-targets desktop and Android, substituting mobile implementations for the desktop-only services.

Platform & Autofill

Platform-specific work sits behind interfaces in its own project, and autofill is separated again: the native messaging host, the Windows and Android autofill backends, and form field detection. The local IPC pipe is restricted with PipeOptions.CurrentUserOnly.

PhantomVault.UI (interface layer)

Deliberately isolated from cryptographic decisions. Built on Avalonia, with a Windows desktop head and an Android head that share the same resource URIs. It handles:

  • User interaction and presentation
  • Security-aware UI controls
  • Privacy shielding and masking
  • Workflow surfaces (import/export, passkeys, autofill, setup, recovery)

The UI does not own secrets. It requests them under policy.

Cryptography stack

PLAINTEXT Argon2id AES-256-GCM 10 01 11 00 10 01 11 00 10 CIPHERTEXT Memory-hard key derivation + authenticated encryption

Modern primitives. Multiple libraries. Specific roles. Phantom Obscura uses multiple crypto libraries by design — no single library is best at everything.

Key derivation

  • Argon2id (memory-hard) to resist GPU and ASIC cracking
  • A DPAPI-protected pepper held outside the vault file
  • The USB keyfile as a required input, not an optional one
  • HKDF for subkey separation, and secure array handling to reduce memory exposure

Encryption & integrity

  • AES-256-GCM authenticated encryption for all vault data — tampering fails the tag, it does not return garbage
  • Key wrapping so the master key never sits in the file in the clear
  • Payload hash plus HMAC inside the encrypted private header

Post-quantum hybrid encryption

For the paths that need it, Phantom Obscura runs a hybrid scheme: ML-KEM-768 (CRYSTALS-Kyber, via BouncyCastle) encapsulates a 32-byte shared secret, and that secret keys AES-256-GCM. Classical security is unchanged; a future quantum adversary has to break the KEM as well. It is exposed as the KyberAesHybrid algorithm in the hybrid encryption service.

Libraries in use

  • Isopoh.Cryptography.Argon2 — Argon2id master key derivation
  • NSec.Cryptography — libsodium-backed primitives with safer high-level APIs
  • BouncyCastle — ML-KEM (Kyber), ASN.1, and broader algorithm coverage
  • KeePassLib — reading proven credential vault structures on import
  • System.Security.Cryptography.ProtectedData — DPAPI pepper protection on Windows

Crypto is implemented as services so algorithms can evolve without redesigning the entire app.

Zero-knowledge security

PROVER · holds secret VERIFIER challenge → ← proof (no secret) Access is proven without the secret ever leaving the device

Validate without exposing. The zero-knowledge vault service verifies a candidate master key against a stored HMAC verifier before access is granted — the key itself is never stored, and a wrong key is rejected without any payload being decrypted.

  • Vault integrity verification without revealing secrets
  • Master key checked against a verifier, not against decrypted output
  • Policy checks without plaintext inspection, where applicable
  • Key material zeroed from memory on lock

This makes it harder to trick the vault into opening, and easier to detect tampering.

USB-bound protection

A vault that refuses to unlock when copied. The USB keyfile is mandatory — KeyfileGuard.Require is called at every create, unlock, and mount entry point, so there is no configuration in which a password alone opens the vault. On top of that, access can be bound to physical hardware identity:

VAULT DATA BINDS TO DEVICE IDENTITY
  • USB serial identity
  • Vendor / Product fingerprints
  • Optional entropy-based device checks

If the vault file is copied to another machine or another USB context, access can be blocked by policy. Stolen files stay useless.

Hardware keys (YubiKey)

  • Device enumeration and info
  • OATH TOTP credential listing and code generation
  • Hardware-backed key storage paths

YubiKey support is desktop-only. USB binding also happens only on the desktop: the Android app can read a binding token from an already-bound USB vault, but it cannot create or rebind one.

Authentication factors

The keyfile is the floor, not the ceiling. Everything below stacks on top of it.

  • USB keyfile — required, always
  • Password — optional additional factor
  • Device binding — optional per-machine salt, so a vault copied to another machine will not derive
  • Windows Hello — biometric or PIN unlock
  • Passkeys — FIDO2, platform-backed (Windows Hello only; macOS and Linux platform passkeys are surfaced as unsupported)
  • YubiKey — hardware token, desktop only
  • TOTP — with a built-in QR scanner
  • PIN lock — PBKDF2 at 150,000 iterations, stored in the vault manifest, with unlock throttling

Security-aware UI

SecureTextBox Masked entry · virtual keyboard · privacy shield

The interface is part of the threat model. A normal UI assumes the system is safe. Phantom Obscura's UI assumes the opposite.

SecureTextBox

  • Prevents accidental leakage patterns
  • Designed to reduce clipboard and preview exposure

Virtual keyboard

  • Optional input path to reduce risk from keylogging

Privacy shield

  • Auto-masks sensitive content on focus loss
  • Privacy blur and field masking modes
  • Safer "glance" behaviour in public spaces

Copy controls

  • Time-limited clipboard exposure with a clipboard guard
  • Auto-clear mechanics, plus exclusion from OS clipboard history
  • "Copy with intent" instead of "copy forever"

Screen & process protection

  • Window protection and screenshot protection services
  • Crash dump suppression, so a crash cannot spill vault memory to disk
  • Memory protection for sensitive buffers
  • Anti-keylogging heuristics alongside the virtual keyboard

Recent Issues panel

A bounded in-memory log of the last 50 warnings and errors, reviewable from Settings after a toast has faded. Security-relevant silent failures — settings persistence, PIN setup, auto-lock-on-threat, autofill init, TOTP sync — are recorded deliberately, so nothing fails invisibly.

Policy engine & security defence

device identity environment checks session policy UNLOCK Every rule must pass before the vault unlocks

Rules that govern access and behaviour. The policy engine enforces security posture:

  • Lock conditions (idle timeout, minimise, screen lock, USB state)
  • Feature gating (export/import limits, clipboard rules)
  • Environment gating (restrict access based on context)
  • Recovery and deletion rules

The baseline policy ships pre-signed. Custom overrides have to be re-signed with the project's key utility before the runtime will accept them, so a policy cannot be quietly weakened by editing a file on disk. Policies exist so the vault does not silently become "conveniently insecure."

Intrusion defence

  • Rule engine driven by the signed policy
  • Tamper detection and advanced debugger detection
  • Virtual machine detection (desktop only)
  • Build integrity verifier — the embedded git commit hash and UTC build timestamp are checked at startup

Decoy vault

A decoy vault and decoy credential generator, for the situation where refusing to open is not a safe answer.

Secure deletion & secure rubbish bin

  • Secure Rubbish Bin — retention-based, policy-governed recovery window
  • Secure deletion for entries leaving the vault for good
  • USB artifact protection and binding

Recovery can be allowed, restricted, or disabled based on policy.

Privacy shield & Go Offline

A single master switch gates every outbound HTTP client in the app — breach checking, icon downloads, update checks — and revokes any active consent grants when you flip it. Breach checking itself uses k-anonymity: only the first five characters of a password hash ever leave the device. There are no telemetry or analytics SDKs in the build, and automatic update checking is off by default.

Autofill & the browser extension

Autofill is the part of a vault most likely to leak, so it is the part kept furthest from the network.

  • A native messaging host (com.phantomvault.autofill) — the desktop app running with a dedicated flag, not a separate service
  • A local IPC pipe restricted to the current user
  • A Manifest V3 extension for Chrome, Edge, and Firefox that detects login, registration, and TOTP forms and injects an inline fill chip
  • Native Windows and Android autofill service backends

The extension never talks to a server. It talks to the vault on the same machine, through the browser's native messaging channel, and only while the vault is unlocked.

Experience layer

DEFAULT + ICON MANAGER Theme studio — six palettes, instant switch · icon manager

The customisation and productivity layer — the things that make a locked-down vault something you will actually keep using, without diluting policy controls.

Entry types

Nine of them: passwords, API keys, bank accounts, cards, contacts, identities, PINs, Wi-Fi, and secure notes. Each with categories, tags, and icons, and full create/read/update/delete.

Password health

A duplicate scan with merge, a password health checker backed by k-anonymous breach lookups, and a password generator.

Theme studio

Switch colour palettes with live preview. The free edition ships the default dark theme; Pro unlocks the rest.

Icon manager

Assign custom icons to entries, with an icon downloader for fetching site icons — gated behind the same Go Offline switch as everything else that touches the network.

Category manager

Add, rename, and remove categories. Changes apply to the vault immediately.

Desktop conveniences

  • Start with Windows — per-user launch registration, off by default, toggled from Settings
  • Global hotkey — an optional system-wide chord (default Ctrl+Alt+P) that brings the vault forward, served by a dedicated message-only window so it never subclasses the app's window proc

Concurrent multi-session vault access is intentionally not implemented. The settings toggle is shown for roadmap visibility only.

Import, export & recovery

VAULT ENCRYPTED COPY Portable, always-encrypted exports — never plaintext at rest

Backups should not create a second breach.

  • Encrypt before export
  • Validate integrity before restore
  • Control what metadata leaves the vault
  • Reduce accidental leakage through format conversions

Import

KeePass .kdbx import via KeePassLib, alongside CSV and JSON, with import history and template support.

Recovery codes

Ten codes, 128 bits of entropy each, formatted XXXX-XXXX-XXXX-XXXX. They are Argon2-hashed at rest, single-use, and validated in constant time. You can export them as a printable PDF recovery kit, rendered locally — the kit never leaves the machine to be generated.

Phantom Recovery hand-off

An integrated recovery panel detects a recovery vault and launches Phantom Recovery as a separate process. Recovery deliberately does not run inside the unlocked vault — the isolation is the point.

Sharing

Share payloads are encrypted to an RSA public key, so a shared entry is readable only by the intended recipient.

Compatibility & runtime

Built on .NET 10 and Avalonia 11.3. Deterministic builds are enabled on the Core and Crypto libraries, so a build can be reproduced from its source revision.

SurfaceRequirement
Windows desktopWindows 10 build 19041 or newer, 64-bit
AndroidAndroid 8.0 (API 26) or newer
Browser extensionChrome, Edge, or Firefox 128+ (Manifest V3)

Current limits, stated plainly

  • The desktop app is Windows-only. There is no macOS or Linux build.
  • Platform passkeys are wired for Windows Hello only; macOS and Linux platform passkeys are surfaced as unsupported.
  • YubiKey, VM detection, and USB binding are desktop-only. Android can read an existing binding token but cannot create or rebind one.
  • The Android app ships a subset of the desktop windows — welcome, unlock, dashboard, credential list, add/edit, category landing, security dashboard, import/export, icon downloader, settings, and themes. The remaining desktop windows are tracked for future ports.
  • Concurrent multi-session vault access is not implemented.

Threat model

Threats stop at the boundary — the vault never decrypts

Security only makes sense when you are clear about what you are defending against. Phantom Obscura assumes three uncomfortable truths: devices get compromised, people make mistakes, and attackers don't play fair.

1. Lost or stolen device

Full access to files at rest, unlimited offline time, ability to brute-force passwords.

Mitigations: AES-256-GCM at rest, Argon2id key derivation with a DPAPI-protected pepper, a required USB keyfile, optional device binding and hardware key requirements, no plaintext secrets on disk.

2. Malware-infected system

Keylogging, clipboard monitoring, screen capture, process inspection.

Mitigations: minimal exposure time, auto-lock on idle / minimise / screen lock, optional virtual keyboard and anti-keylogging heuristics, privacy masking, clipboard guard with auto-clear, screenshot and window protection, crash dump suppression, and key material zeroed on lock.

3. Curious or opportunistic insider

Physical access, visual observation, opportunistic browsing.

Mitigations: mandatory authentication, privacy shielding, manual reveal controls, fast lock/exit flows, clear session boundaries.

4. Cloud or service breach

Server-side compromise, credential database access, metadata harvesting.

Mitigations: no cloud sync, local vaults, no centralised database, no telemetry or analytics SDKs at all. Breach checking is k-anonymous, and the master Go Offline switch can cut every outbound client at once. There is no central service to compromise.

5. Forensic / offline analysis

Advanced tooling, time and compute resources, static and dynamic analysis.

Mitigations: encrypted vault files, no plaintext secrets at rest, secure memory handling, AES-GCM integrity validation, and a signed update pipeline (Ed25519 manifest signature, SHA-256 asset hash, Authenticode check) so a tampered update cannot install.

Out of scope

  • Nation-state attackers with physical access and unlimited resources
  • Compromised operating systems that actively alter application behaviour in real time
  • Users who willingly disclose their credentials
  • Hardware-level compromises of the host machine itself
  • An attacker who holds both the vault file and its USB keyfile, plus any password set on it

Being honest about limits is part of security.

FAQ

Is Phantom Obscura a password manager?

It can store credentials, but it is closer to a portable security environment: vault engine + policy + hardware binding + privacy-first UI.

What happens if someone steals the vault file?

The file alone is not enough. Derivation requires the USB keyfile, and the master key is checked against a stored verifier before anything decrypts. Without the keyfile — and any password or binding you have added on top — the file stays encrypted and effectively useless.

Does the UI ever store secrets?

The UI requests secrets under policy and displays them briefly. The core owns cryptographic state and lifecycle rules.

Why not just use one crypto library?

Different libraries excel at different things. Phantom Obscura uses multiple libraries intentionally, with clear responsibility boundaries: Argon2 for derivation, an NSec/libsodium core for everyday primitives, BouncyCastle where post-quantum and ASN.1 work is needed.

Do I have to carry a USB stick?

Yes. The keyfile is required to create, unlock, or mount a vault — that is the trade the design makes, and it is not configurable away. A password is something you can add on top of it, not instead of it.

Is it quantum-resistant?

Partly, and honestly so. The hybrid pipeline uses ML-KEM-768 to encapsulate a secret that keys AES-256-GCM, which means a future quantum adversary has to break the KEM as well as the symmetric layer. The classical Argon2id + AES-GCM path is unchanged.

Does it run on macOS or Linux?

Not today. The desktop app targets Windows 10 build 19041 and up. There is an Android app and a browser extension; a macOS or Linux desktop build is not currently shipped.

Ready?

Try the live demo or compare plans

Use the interactive vault demo, then see what the free and pro editions include.