GIBLEX Phantom Suite
Credibility

How the model holds up

Everything Phantom does rests on three commitments: keep workflows local, make possession part of access, and be clear about the limits. This page sets out the principles, the architecture, and the threat model in one place.

01 — Security principles

Most software assumes remote infrastructure should sit in the middle of access, storage, and recovery. Giblex starts from the opposite assumption: sensitive workflows belong on the system the owner controls, and the fewer external parties an operation depends on, the smaller its attack surface.

Local-first by default

Sensitive data stays on systems the user controls whenever possible, rather than depending on cloud accounts or sync layers. Offline is the normal state, not a degraded one.

Possession as part of access

Protected workflows require something physical — a USB keyfile present on the machine — so access depends on a condition an attacker cannot satisfy remotely. In Phantom Obscura this is not a setting: the vault refuses to create, unlock, or mount without its keyfile.

Transparent access logic

Security decisions should be legible. A person should be able to understand what their access depends on, rather than trusting an opaque service to decide for them.

Zero-knowledge architecture

Giblex never sees your vault data, your master password, your keys, or your entries. Encryption and decryption happen entirely on your device. There is nothing for us to hand over, because we do not hold it.

Composability without shared blast radius

Each Phantom tool is independent. They interoperate under one trust model, but a failure or compromise in one is contained rather than cascading across the suite.

02 — Encryption

Every Phantom product that stores sensitive data uses authenticated encryption throughout. The encryption is not bolted on — it is the storage layer.

PASSWORD SALT Argon2id AES-256-GCM 10 01 11 00 10 01 11 00 10 CIPHERTEXT Memory-hard key derivation → authenticated encryption → locked ciphertext

AES-256-GCM

Vault data is encrypted using AES-256-GCM (Galois/Counter Mode). GCM provides both confidentiality (data cannot be read without the key) and integrity (any tampering with the ciphertext is detected at decryption time). A single modified byte causes decryption to fail with an authentication error, not silently corrupt data.

Post-quantum hybrid encryption

Where a long confidentiality horizon matters, Phantom Obscura runs a hybrid scheme: ML-KEM-768 (CRYSTALS-Kyber) encapsulates a 32-byte shared secret, and that secret keys AES-256-GCM. An adversary has to break both the post-quantum KEM and the symmetric layer, so a "harvest now, decrypt later" capture is not obviously worth keeping.

Per-entry encryption

Rather than encrypting the vault as a single block, Phantom Obscura encrypts each entry independently with its own IV (initialisation vector). This limits the blast radius of any cryptographic weakness — a flaw in one entry's nonce does not expose others. It also allows selective export and sharing without decrypting the entire vault.

Memory-only decryption

Decrypted data is held only in process memory for the duration of the session. It is never written to disk in plaintext — not to swap, not to temp files, not to crash dumps. When the session ends, the decrypted data is scrubbed from memory before the process releases it. No plaintext ever touches persistent storage after the initial entry creation.

Encrypted metadata

Entry names, categories, tags, URLs, and timestamps are encrypted inside the vault blob, not stored in a plaintext header or index. A forensic examination of the vault file reveals nothing about its contents — not even the number of entries, because the file is padded to reduce inference from file size.

03 — Architecture

Phantom products share a layered structure. Each layer has a narrow responsibility, and trust flows upward only when the layer beneath it is satisfied.

Root trust

The unlock path can combine a hardware root (TPM), a USB-held secret, and a user PIN. No single factor on its own grants access; possession and knowledge are both required where it matters.

Vault containers

Data is held in encrypted containers, encrypted at rest and decrypted only into working memory under satisfied access conditions. The container is the unit of storage, isolation, and recovery. Each vault is fully self-contained — there is no dependency on an external key server or sync service to open it.

Split-key access (Phantom Key)

Phantom Key implements split-key access control: the secret required to unlock a vault or a protected resource is split between two or more devices. Neither device alone is sufficient. This enables scenarios like requiring both a laptop and a USB token to be present, or requiring two people to co-authorise access to a sensitive resource.

Controlled recovery (Phantom Recovery)

Recovery is a separate, controlled process — not an emergency email link. Phantom Recovery allows you to define how access can be recovered in advance: who has the recovery fragment, what conditions must be met, and what evidence is produced. Recovery is auditable rather than silent.

04 — Key management

The security of a vault depends entirely on how its encryption key is derived and stored. Phantom Obscura uses a two-stage key derivation process designed to resist brute-force and offline dictionary attacks.

Key derivation: Argon2id

The master vault key is derived from the USB keyfile, a DPAPI-protected pepper, and — optionally — your master password, using Argon2id, the winner of the Password Hashing Competition (PHC). Argon2id is memory-hard, meaning it requires a large amount of RAM to compute, making parallel GPU brute-force attacks significantly more expensive than password hashing schemes like bcrypt or PBKDF2.

  • Memory cost: 64 MB minimum (configurable higher in Pro)
  • Time cost: tuned to take ≥ 500 ms on the local machine
  • Salt: 256-bit random salt, unique per vault, stored in the vault header

Verified before decrypted

A candidate master key is checked against a stored HMAC verifier before any payload is decrypted. A wrong key is rejected outright rather than producing garbage that has to be interpreted — and the key itself is never stored, only the verifier. When the vault locks, key material is zeroed from memory explicitly.

PBKDF2 for the PIN

The optional PIN lock uses PBKDF2 at 150,000 iterations, held in the vault manifest with a settings fallback and protected by unlock throttling. The PIN is a convenience gate on an already-unlocked session — it is not an alternative path to the master key.

Keys never leave the device

The derived encryption key exists only in process memory. It is never persisted, never synced, and never transmitted. If you lose your keyfile and have no recovery codes or recovery fragments configured, access to the vault is lost — because there is nothing on our side to recover it from. Phantom Obscura issues ten single-use recovery codes at 128 bits each, Argon2-hashed and validated in constant time, exportable as a locally rendered PDF recovery kit.

The USB keyfile

Key material stored on the USB device is combined with the derived key to produce the final vault key. This is mandatory, not opt-in: a copy of the vault file without the keyfile is useless. If a password has also been set, a copy of the keyfile without that password is equally useless.

05 — Hardware binding

Phantom products can bind access to hardware you physically control, adding a "something you have" factor that cannot be satisfied remotely.

USB DEVICE TPM CHIP ● ● ● ● PIN 🔑 VAULT REMOTE ATTACKER no USB → no access USB + TPM + PIN converge — remote access blocked without physical possession

USB device binding

A vault or protected resource can be bound to a specific USB device identified by a stable hardware identifier combined with a secret written to the device at setup. The binding survives reboots and reconnections but is invalidated if the USB device is absent, cloned without the secret, or removed before the session is established.

TPM integration

On machines with a Trusted Platform Module, Phantom can seal a key fragment to the TPM, optionally requiring a specific PCR (Platform Configuration Register) state. This means the vault can only be opened on the specific machine for which it was configured, and only when the boot configuration matches — preventing offline extraction of the TPM-sealed secret.

Multi-factor access

Hardware binding, master password, and optional PIN can be combined in any combination. The access policy for a vault is defined at creation time and stored in the vault header (in plaintext — the policy itself is not secret, only the satisfaction of it matters).

06 — Session security

An unlocked vault is a session, not a persistent state. Session security limits the window in which a compromised machine can be used to exfiltrate data.

Idle auto-lock

Vaults auto-lock after a configurable idle period (default: 5 minutes). Locking clears the decryption key from memory, returning the vault to its encrypted-at-rest state without requiring the app to close.

USB removal lock

If USB binding is active, removing the bound USB device immediately locks the vault. The session cannot continue without the device, preventing a scenario where an attacker gains access to an unattended unlocked machine.

Screen lock integration

Phantom Obscura can optionally integrate with the operating system's screen lock event — when the screen locks, the vault locks. The two events are decoupled by default so you can control them independently.

Clipboard hygiene

Copied secrets are automatically cleared from the clipboard after a configurable timeout (default 15 seconds). The app does not maintain a clipboard history. Fields containing passwords and secrets are masked by default and must be explicitly revealed.

Privacy shield

When the Phantom Obscura window loses focus, sensitive field contents are automatically masked. Screenshots taken of the app while it is in focus capture masked values rather than plaintext where field protection is enabled.

07 — Integrity and audit

Security tools need to be verifiable. Phantom products include mechanisms for detecting and evidencing tampering.

Vault integrity verification

AES-GCM authentication tags detect any modification of the ciphertext. Any change to the vault file — even a single byte — causes decryption to fail with an explicit integrity error rather than silently returning corrupted data. The vault cannot be partially tampered with without detection.

Phantom Attestor

Phantom Attestor extends integrity checking to the broader system. It generates signed attestation manifests — cryptographically bound records of the state of files, configurations, and access conditions at a point in time. These manifests can be used to verify that a system has not changed since it was last inspected, to audit access events, or to produce evidence of state for compliance purposes.

Audit trail

Session open and close events, failed unlock attempts, and access policy changes are logged locally. The log is not transmitted anywhere — it remains on the device and under the vault owner's control. Phantom Obscura also keeps a bounded in-app record of the last 50 warnings and errors, reviewable from Settings, so a security-relevant failure never passes silently.

08 — Network isolation

The attack surface of offline software is fundamentally different from networked software. Phantom products are designed to work fully offline and make no network calls at runtime.

DEVICE analytics telemetry crash reports cloud sync 0 outbound connections All outbound connection attempts are blocked — zero network calls at runtime

Zero runtime network calls

Phantom apps do not make HTTP requests during normal operation. They do not contact update servers, sync data, send crash reports, check licence validity against a remote endpoint, or open any sockets. A network firewall that blocks all outbound traffic from the process does not degrade functionality in any way.

No third-party SDKs

Phantom products do not include analytics SDKs, crash reporters, advertising libraries, or any third-party component that phones home. The network-aware paths that do exist — breach checking, icon downloads, and update checks — are all gated behind a single master Go Offline switch that also revokes active consent grants. Breach checking is k-anonymous: only the first five characters of a password hash leave the device. Automatic update checking is off by default, and updates are verified by an Ed25519 manifest signature, a SHA-256 asset hash, and an Authenticode check before installing.

Air-gap capable

For environments where network access must be eliminated entirely, Phantom products can be installed and operated on air-gapped machines. Licence verification, vault operations, and all Phantom functionality work without any network connection.

09 — Threat model

A security tool is only useful if it is honest about what it does and does not defend against. Phantom products are designed around a specific set of threats.

In scope

  • Remote access to data that should never leave the device
  • Compromise of cloud accounts or sync infrastructure — because that infrastructure is not in the path
  • Access attempts without the required physical device present
  • Brute-force of master passwords — resisted by Argon2id key derivation
  • Silent tampering with stored data — detected by AES-GCM authentication
  • Clipboard-based secret exfiltration — limited by auto-clear and masking
  • Shoulder surfing and screenshot capture — mitigated by privacy shield
  • Offline vault cracking on an exfiltrated vault file — resisted by memory-hard KDF

Out of scope

  • An attacker with full, persistent control of the host operating system while the vault is unlocked
  • Hardware implants or supply-chain compromise of the device itself
  • Coercion of the legitimate owner to unlock the system
  • Side-channel attacks against the CPU (Spectre, Meltdown variants) — mitigated only to the extent that the host OS mitigates them
  • Malware with kernel-level access present at time of vault unlock

Naming the limits is part of the model. A tool that claims to defend against everything defends against nothing in particular.

Early access

Follow the build

Join the waitlist to follow architecture progress and get early-access releases first.