Skip to content

Integrity and backups

This page explains, in plain language first and then in technical detail, how BreachSpider protects the files you keep in the documents vault, how anyone can check later that a stored file is exactly what was stored, how a device's current configuration is compared with a backup, and how backups of BreachSpider itself are made. For the screens, see Backups & integrity.

The short version

Question Answer
Who can read my vault files? Only people who have your vault passphrase or recovery key. Files are encrypted in your browser before upload. BreachSpider never has the key and cannot read the files, their names, types, notes or original fingerprints
Where are they kept? As encrypted bytes in a private Backblaze B2 storage bucket that BreachSpider controls. So BreachSpider does store your vault files, but only in a form it cannot read
Where are my workspace backups kept? On your own computer. The backup file is encrypted in your browser and downloaded to you; BreachSpider does not keep a copy
How do I know a stored file was not changed? Every version is sealed when stored: a separate signing service measures the stored bytes and signs that record with two signatures. Verify re-measures the bytes and checks both signatures
What makes the seal post-quantum? One of the two signatures is ML-DSA-65, a signature scheme designed to resist attacks by quantum computers. See Post-quantum signatures
Can I tell whether a device's configuration changed since its backup? Yes, with Check current file. Your browser compares the current file with the sealed fingerprint; the file never leaves your browser
Are BreachSpider's own databases backed up? Yes, nightly, encrypted, to Backblaze B2. These are BreachSpider's operational backups, encrypted with keys BreachSpider holds

Part 1: what happens when you store a file

In your browser

  1. Keys. When an owner or admin sets up the vault, the browser makes a random 256-bit vault key for the organization. It is stored on the server only in two wrapped (encrypted) forms: once under a key derived from your vault passphrase, and once under a key derived from the printed recovery key. The derivation uses Argon2id (64 MiB of memory, 3 passes), which makes guessing a passphrase slow and expensive.
  2. A fresh key per file. Each version gets its own random 256-bit data key, stored only wrapped by the vault key.
  3. Fingerprint of your file. The browser computes the SHA-256 digest of the original file (its fingerprint).
  4. Encryption. The file is encrypted with AES-256-GCM in 4 MiB chunks. Each chunk is bound to the organization, the device, the version, the kind of file, its position and whether it is the last chunk, so chunks cannot be reordered, moved to another version, or cut short without the decryption failing.
  5. Metadata. The file name, type, notes, size and original fingerprint are encrypted with the file's data key.
  6. Upload. The encrypted bytes go from your browser directly to the storage bucket, through a one-time upload address valid for 15 minutes, for one object name that is never reused. BreachSpider's application server never sees the file.

On the server: the seal

  1. Size check. The API checks that the stored object has exactly the size announced.
  2. Sealing. A separate signing service, running as its own operating system user with its own signing keys, its own read-only storage key and its own ledger, reads the stored bytes itself and measures their SHA-256 digest and length. It never signs a digest it is told.
  3. It writes a manifest: the organization, device, version id, kind, object name, the measured digest and length of the encrypted bytes, the algorithms, who uploaded it, when, the sequence number and the hash of the previous seal for this organization. Each seal links to the one before it, forming a hash chain per organization.
  4. It signs the manifest twice: with Ed25519 and with ML-DSA-65. Both signatures cover exactly the same bytes (a canonical JSON encoding of the manifest).
  5. It records the seal in its append-only ledger: a database the application cannot write to, which refuses any update or deletion of a seal.
  6. The first verification runs at once. You see "Version N stored, sealed and verified".

Every day: the anchor

Once a day the signing service signs the latest seal of every organization (the chain heads) with both signatures and writes this anchor to a separate storage bucket under Object Lock retention (governance mode, 400 days). An anchor fixes the state of every chain on that day, so a seal cannot later be inserted into the past without the chain and the anchors disagreeing.

Part 2: what BreachSpider can and cannot see

BreachSpider can see BreachSpider cannot see
That a version exists, for which device, its kind (configuration or document), its version number The file's contents
The encrypted size, who uploaded it and when The file name, type and notes
The digest of the encrypted bytes (in the seal) The digest of the original file
Verification results and comparison outcomes (unchanged or changed), with who and when The passphrase, the recovery key, the vault key or any data key

If BreachSpider's database, application server and storage were all exposed together, an attacker would learn sizes, counts, device links and times only.

Part 3: verification, step by step

Verify integrity (one version), Verify all, the automatic re-check of versions not checked for 30 days, and the check before every download all ask the signing service the same question. It answers from its own ledger and the stored bytes, never from the application's records:

  1. Find the seal for this version in the signing service's own ledger, and check it belongs to this organization.
  2. Check the Ed25519 signature over the manifest with the public key named in it. Keys retired after a rotation are kept, so older seals still verify.
  3. Check the ML-DSA-65 signature over the same manifest. For a post-quantum (hybrid) seal, both must be valid.
  4. Check the chain: every seal of the organization links to the one before it and hashes to its recorded value.
  5. Read the stored bytes again from storage and measure their SHA-256 digest and length.
  6. Compare with the sealed digest and length.
Result When
Verified Every step passed: the stored bytes are exactly the bytes that were sealed
Mismatch The signatures and chain check, but the stored bytes differ from the sealed baseline (digest or size)
Unable to verify A step could not be completed or did not check: storage or the signing service unreachable, no trusted seal, a signature or the chain does not check, or the signing key is not available

Every check is recorded with what triggered it, its result, the reason and who asked.

After download: the recovered-file check

A download is allowed only after the version verifies. Your browser then decrypts it (any change to an encrypted chunk makes decryption fail) and compares the SHA-256 of the recovered file with the original fingerprint stored, encrypted, at upload. "Recovered-file integrity: Verified" means you hold exactly the bytes you stored.

What a detected problem means, and what to do

  • Mismatch means the bytes in storage are not the bytes that were sealed. Causes include storage corruption or someone with access to the storage replacing or altering the object. The file is not handed out for routine use. A vault admin can download the encrypted file for investigation with a written reason, which is logged. Use another verified version, and contact us.
  • Unable to verify does not say the file changed, and it does not say it is unchanged. Most often storage or the signing service was briefly unreachable: try again later. If it persists with a signature, chain or key reason, contact us.
  • Recovered-file mismatch after a download: do not use the file; contact your vault admin.

Verification checks that the stored bytes match the baseline sealed at upload. It is not a malware scan: a match does not show that a file was harmless when it was sealed, or that the device's running logic is unchanged.

Part 4: has the device's configuration changed since this backup?

Check current file compares the configuration on the device now with a sealed version:

  1. You export the current file from the device and choose it in the browser.
  2. The browser decrypts the version's metadata with your vault key and reads the original fingerprint sealed at upload.
  3. It computes the SHA-256 of the current file locally and compares fingerprint and size.
  4. Unchanged: the current file is byte-for-byte identical to that version. Changed: it differs.
  5. At the same moment the server verifies the stored backup through the signing service, and records the outcome: who, when, which version, unchanged or changed, the backup's integrity state and its seal scheme. Never the file, its name or a digest. The record appears in the device's history.

If the backup itself did not verify at that moment, the comparison says so and cannot be relied on: an altered or unverifiable backup never yields a plain "Unchanged".

A match shows identical bytes to that backup only. A difference can be an intended change, an unauthorized change, or an export format that writes a timestamp or session data into every file. Review it, and store the current file as a new version if the change is intended.

Part 5: workspace backups

Download encrypted backup on Backups & integrity exports your devices, sites, tags, identifiers and maintenance records as one JSON document, then encrypts it in your browser: a key derived from your passphrase with PBKDF2-SHA-256 (600,000 iterations, random salt) and AES-256-GCM. The file also carries the SHA-256 of the plain backup, checked after decryption, so a damaged or altered file is reported as such.

The encrypted file is downloaded to your computer. BreachSpider never sees the passphrase or the encrypted file and does not keep a copy. If the passphrase is lost, no one can open the backup.

Restore decrypts the file in your browser, sends only the records that are missing now, previews what would come back, never overwrites anything that exists, restores only into the organization the backup came from, and one Undo reverses it. Engine results are not in a backup: restored devices are checked again.

Part 6: backups of BreachSpider itself

Separately from your own backups, BreachSpider backs up its service:

  • Nightly database backup. A consistent dump of the database is encrypted with AES-256 as it is written (it never touches the disk unencrypted), together with encrypted archives of the code and configuration, and uploaded to a Backblaze B2 bucket.
  • Nightly whole-server backup. An encrypted, deduplicated, incremental backup of the server's files (restic) to Backblaze B2, kept as 7 daily, 4 weekly and 6 monthly snapshots.

These backups contain what the database contains, including organizations' inventory data, encrypted with keys that BreachSpider holds, so that the service can be restored. Vault files are not in them in readable form: the vault holds only ciphertext, and its keys are never on BreachSpider's servers.

Not available yet

A downloadable verification receipt (a record of a seal or a comparison that can be checked offline) is not available yet. This page will describe it when it is released.

Technical summary

Item Value
Vault file encryption AES-256-GCM, 4 MiB chunks, per-chunk associated data (organization, device, version, kind, index, last), in the browser
Key hierarchy Passphrase or recovery key, Argon2id (m = 64 MiB, t = 3, p = 1), wraps a 256-bit vault key, which wraps a 256-bit data key per version
Recovery key 30 characters in 6 groups (Crockford base32, 150 bits), shown once
Upload Browser to storage directly, presigned for 15 minutes, exact size, one immutable object per version, up to 100 MB
Seal manifest bs-seal/2 (hybrid) or bs-seal/1 (classical, before 2026-11-07), canonical JSON
Seal signatures Ed25519 and ML-DSA-65 (FIPS 204) over the same manifest bytes; both required for bs-seal/2
Digest SHA-256 of the stored ciphertext (signed), and of the original file (inside the encrypted metadata)
Chain Per organization: sequence number and previous seal hash in every manifest
Ledger Append-only, owned by the signing service; updates and deletes refused
Anchor Daily, both signatures, separate bucket with 400-day governance retention
Scheduled verification Every sealed version at least every 30 days
Signing key ids (2026-11-08) Ed25519 f5d5b03ec4359653, ML-DSA-65 39b2f241c9eef5e0
Workspace backup PBKDF2-SHA-256 (600,000 iterations), AES-256-GCM, in the browser, downloaded only