Your keys

When you create a vault, your browser makes a random 256-bit vault key. It is never sent anywhere in readable form. Instead, it is locked (wrapped) once for each way you can sign in:

  • Passkey. Sigil asks your passkey for its PRF output, a secret that the passkey derives on your device and gives only to this site. That secret unlocks your copy of the vault key. Passkeys without PRF support cannot hold a vault key; Sigil tells you when that happens.
  • Wallet. Your wallet signs one fixed message. The signature stays in your browser and is turned into a key. Sigil checks at sign-up that your wallet signs the same way every time, because a wallet that does not could never open the vault again.
  • Recovery phrase. 24 words (256 bits) shown to you once at sign-up. They unlock a third copy of the vault key. You can replace the phrase in Settings; the old one stops working.

Signing in also proves to the server who you are, without giving it anything that unlocks the vault: passkeys use standard WebAuthn signatures, and wallets and phrases send a separate token derived from the same secret, of which the server stores only a SHA-256 hash.

Encryption

Every folder has its own random key, wrapped by your vault key. Every memory is encrypted with its folder's key using AES-256-GCM with a fresh random nonce, through the WebCrypto built into your browser. Keys are derived with HKDF-SHA256, with a separate label for every purpose.

Each piece of ciphertext is bound to the exact record it belongs to. A memory copied into another record, another folder or another account fails to decrypt instead of showing the wrong content. The full format is in the docs.

The site is served with a content security policy that only lets the page talk to Sigil's own server, and there are no analytics, advertising or third-party scripts on it.

What the server can and cannot see

It cannot see the title, body or tags of any memory, the names of your folders, the names of your connected apps, your search words, any of your keys, your model key, your AI self's rules, or the questions and answers of your ask links.

It can see that your account exists; your passkey's public key or your wallet address (needed to find your vault when you sign in); how many folders and memories you have, their sizes and when they changed; which app is allowed to read which folder; the read log: which app read which memory, and when; that an ask link exists, how often it is used and when your AI self last checked in; and, for a memory you gave an expiry, the time it is to be deleted. This metadata is needed to run the service, and it is covered by the privacy notice.

Connected apps

Each connected app gets its own secret, made in your browser and shown to you once as the app key. From it come two things: a token the connector uses to talk to the server (the server keeps only its hash) and a key that unwraps the folder keys you granted to that app. Folders you did not grant are never wrapped for the app, so its key cannot open them.

The connector runs on your computer and decrypts there. It keeps nothing between requests, so revoking an app takes effect on its next request. On revoke the server also deletes that app's wrapped folder keys.

Connected apps cannot change or delete memories. An app you allow may suggest one: the connector, the extension or the web app seals it to your vault's public key on the user's side, and it becomes a memory only when you approve it in your inbox. The public key comes with a tag your vault made with that app's own secret, so a server that swapped in a key of its own would be caught before anything is sealed.

Sharing a folder with another vault seals the folder key to that vault's public key, taken from the code its owner gave you, never from the server. Stopping a share gives the folder a new key on your device and encrypts the folder again, so the removed vault holds only a key that opens nothing stored now. Search by meaning runs on your device; its vectors never reach the server and are kept in your browser only encrypted.

Your AI self

Your AI self runs where your keys are: in your open vault, or in the connector on your machine for an app you allow. It calls your own model provider with your own key, straight from there. The key and the rules are saved only as envelopes under your vault key; for an app you allow they are wrapped again under a key derived from that app's secret, which never reaches the server. Only the folders your rules allow are given to the model, and the rules are checked on the device before and after the model answers.

An ask link carries the link's public key after the #, which browsers never send to a server. The asker's browser checks the key the server holds against it and refuses a different one, makes a fresh X25519 key pair for the conversation, and seals each question with a key derived from both sides (HKDF-SHA256, then XChaCha20-Poly1305 bound to the link, the conversation, the message and its direction). The server stores and forwards these boxes and cannot open them. Each question and answer is also sealed to your vault's public key for your read log, where the entry is part of the hourly seal.

The model provider you choose does see the question and the memories given to it for that answer: that is how a model answers. Its own terms apply to what it receives. Imports from GitHub are asked from your browser in the same way, with a token that is never saved.

Deleting means deleted

Deleting a memory, a folder or your account removes the rows from the database, and the database is set to overwrite deleted content on disk rather than just unlinking it. Deleting your account removes your sign-in methods, sessions, folders, memories, apps and read log in one step. A memory you gave an expiry is deleted by the server when its grace period is over, whether or not your vault is open. Export everything first if you want to keep a copy: the export is decrypted on your device.

Hourly seals

Every read by a connected app is written to your read log with a random 32-byte salt. The log entry and its salt are hashed into a leaf. When an hour is over, all leaves from that hour (from every vault) are combined into one Merkle root: the seal for that hour. A seal is never changed after it is made.

In your vault, Verify on any log entry recomputes its leaf from the entry itself, fetches the proof, and checks in your browser that it leads to the published root. Because every leaf is salted and the salt is only shown to the vault's owner, the roots reveal nothing about who read what. When you delete your account, your salts are deleted with it, so the leaves left in old seals point to nothing.

Today seals are kept by Sigil and marked Local. The contract that will publish them on chain, so that not even Sigil could change one later, is written and tested but not yet deployed. When that is switched on, seals will be marked On chain.

Latest seals

Loading seals

Legacy, devices and agents

  • Legacy. The legacy key is made and split in your browser with Shamir's secret sharing (the independently audited shamir-secret-sharing library). Each share and each bundle is sealed to one trusted person's vault public key; a bundle is also encrypted under a key from the legacy key, so it takes the shares and that person's vault to open. Shares are passed between trusted people sealed to the keys you named, which they take from their own copy of the plan. Every change makes a new key.
  • Devices. A new device makes a one-time X25519 key pair. Its pairing code is a hash of the public key, so the vault that sends the keys can tell a key the server swapped in. The vault key and a fresh device secret travel sealed to that one-time key; the device keeps its secret as a non-extractable WebCrypto key. A captured note or photo is sealed on the phone to your vault's public key, checked against the key the device saw when the vault was last open.
  • Agents and spaces. An agent's X25519 key pair is derived from its secret on your device and in the connector. Team space keys are sealed to every member; member tags are MACs under the space key, checked before anything is sealed. Removing a member encrypts the space again under a new key.
  • Presence. A signing key (Ed25519) is derived from your vault key. One statement per hour you have the vault open is signed in your browser and sealed with that hour, which is what a life certificate is built from.

Sync, protection, public and meeting selves

  • Live sync. OAuth 2.0 with PKCE (S256) from your browser as a public client; no client secret is sent from a browser or kept on the server. The tokens and the cursor are one document encrypted with your vault key, and, for a connector you let sync in the background, under a key derived from that app's secret. Fetching and encrypting happen on the device. The content security policy allows exactly the Google and Slack addresses live sync calls.
  • Protected folders. The server holds a protected folder's ciphertext back from apps, agents and links until you approve that read; an approval is single use and lasts ten minutes. Protected reads and your answers have their own kinds in the log, and the kind is part of each sealed leaf. Redaction runs on the device before text leaves the vault.
  • The public AI self. Its X25519 key pair is made on your device; the private half and its rules are encrypted with your vault key. Visitors' questions use the same relay as ask links, and it answers only from the public copy you publish.
  • Selves meet. The invite and the answer are sealed boxes to the other vault. Turns are XChaCha20-Poly1305 under a key from X25519 between the two vaults' own keys, bound to the meet, the turn and the sender, so only those two vaults can write a turn that opens.
  • The open standard. All of this is written down in the open standard, with test vectors the code is checked against on every test run.

Identity, work, proofs, emergency, agreements and packs

  • The self key. A secp256k1 key derived with HKDF from your vault key on your device, never stored and never sent; the server keeps its address only. The identity statement is signed by both your vault's Ed25519 key and the self key, and the server checks both signatures before it serves one. The wallet rules are an encrypted setting.
  • The contracts. SigilSelfRegistry registers a self key only with an EIP-712 signature by that key naming its owner, and refuses high-s signatures; a revoked key stays revoked. SigilSelfWallet checks, for every call by the self key, freeze, expiry, the allowed target, the allowed function, token caps with allowed recipients, and native caps per call and per UTC day; it refuses token moves it cannot cap. The owner can always freeze, change the rules and withdraw. Both are tested with Foundry, with fuzzing of the caps and the freeze, and are not deployed.
  • Drafts. Each draft of your AI self is an envelope under your vault key; the server knows its kind and state. Nothing is sent on its own: held answers go out only when you approve them, through their own encrypted channel.
  • Proofs of a fact. Each field of a memory is committed with its own 32 random bytes of salt, so the commitment says nothing without them. Only the hash of the signed statement reaches the server before you share a proof; it is sealed with the hour.
  • The emergency card. AES-256-GCM under a fresh key that is only in the link after the #, bound to the card's id. The server stores ciphertext it cannot open and records each opening with a time, a device class and a language only.
  • Agreements. The text goes to the other vault as a sealed box; each side keeps its copy under its own vault key. Both sign one SHA-256 fingerprint with Ed25519; the server checks each signature against the key that vault registered, and the receiving vault checks that the document names it with its own keys before it signs.
  • Knowledge packs. Public by design and signed by the publisher's vault key. A follower pins that key and checks every version, in order, against it and the hash of the version before.

Bundles, nodes, voice, capture, sessions and shared memory

  • The bundle. Every part of the vault as the node holds it (envelopes, sealed boxes, wrapped keys, hashes and public keys), with a SHA-256 hash over all of it and an Ed25519 signature by your vault's key, made on your device. A restore unwraps the vault key from the bundle's own key slot on your device and opens every folder, memory and setting under the record it claims before the node is asked to take it in, with a statement your key signed for that node and that is at most ten minutes old.
  • Storage tokens. The vault's backup setting, an envelope under your vault key; for a connector you allow, an envelope under a key from that app's secret. S3 requests are signed with AWS Signature Version 4 on the device; an Arweave upload is a data item signed with your key file on the device, whose id the device checks. Where each copy went is sealed to your vault's key. The content security policy lists the storage addresses the page may upload to.
  • Moving. A move statement and an arrival, both Ed25519 by your vault's key; the new node fetches the bundle only with a 32-byte secret from the code you carry, of which the old node keeps the hash. Node to node requests use HTTPS only, follow no redirect, are limited in time and size, and refuse addresses written as private unless the operator allows them.
  • Capture keys. 32 random bytes per key; the node keeps the SHA-256 of the derived token. Captures are sealed boxes to the vault public key, checked against a tag only the key and your vault can make, and bound to the key's id. Plain text is taken only for a key you allowed, and sealed at once.
  • Voice. The speech model runs in a worker of the page with the same WebAssembly runtime as search by meaning; it is fetched from this site, only when someone turns voice on. The microphone is allowed for this site only.
  • Sessions. A session link's 32-byte secret gives the bearer token (the node keeps its hash) and the visitor's X25519 key for the relay. The intake is a sealed box to the public self's key; each turn's transcript a sealed box to your vault's key.
  • Shared memory. The space key, roles and member tags of team spaces. The node keeps who wrote each entry and enforces that writers change only their own. Heirs are sealed and tagged by an admin's device and sealed again with every new key.

Limits, plainly

  • Lost keys are lost. If you lose every passkey, every wallet and your recovery phrase, the vault cannot be opened by anyone, including Sigil.
  • What an AI has read, it has. Once an AI app reads a memory, that text is in the app's hands and its own policies apply. Revoking stops future reads, not past ones.
  • Your device is part of the system. Encryption protects your vault on the server and on the network. It cannot protect it from malware on the device where you unlock it, or from someone using your unlocked computer.
  • Metadata is visible to the server, as listed above.
  • Your model provider sees what it answers from. Each answer of your AI self, each brief written by your model and each pair it checks sends that text to the provider you chose, under your key and its terms.
  • The ask page is served by the server. Like any web page with end to end encryption, it is only as honest as the code the server sends. The code is open source, so it can be checked.
  • The server keeps the legacy clock. It cannot open a share, but it decides when a plan may be released. A server working with enough of your trusted people could release early.
  • A revoked device keeps what it showed. Revoking ends its access from then on; it cannot reach into the device.
  • A proof of a field or an age is your own word. It is signed and sealed, not checked by anyone else: Sigil does not read a passport. Only sealed history and team spaces are checked in full.
  • An emergency card is for anyone who sees the code. That is its purpose. A phone that opened it may keep its ciphertext, and the key is in that phone's history; issuing a new code makes both useless.
  • Early software. The code is open source and has not had an independent audit yet.

Reporting a problem

Please report a security issue privately through the Sigil repository on GitHub (Security, Report a vulnerability), not in a public issue. Say what you found, how to reproduce it and what someone could do with it. Do not test against vaults that are not yours. We will tell you when it is fixed and, if you want, credit you. There is no bounty at present.

The review before launch

Before Sigil opened to people, every part was reviewed: the cryptography, every permission check of the API, the connector, the extension and the contracts, with fuzz tests for every parser of outside input and every route. Each finding, its fix and the test that shows it are written down in docs/SECURITY-REVIEW.md, together with what is known and not fixed yet and what still needs an outside audit. That review was made by the project itself; it is not an audit.

Hidden instructions in memories

Mail, chats and imports can carry text written to steer an AI. Sigil checks every memory from outside on your device, holds what looks like that in your inbox until you let it through, quotes every memory it hands to a model as data, and puts every catch in your read log. A public test attacks these defences every hour and publishes its sealed record at /immune.