← Articles
Airlock: air-gapped signing and clear signing on Solana logo
solana

Airlock: air-gapped signing and clear signing on Solana

· NOV 21, 2026 ·
Read
Share

Airlock keeps preparing a transaction apart from signing it. An online device builds, simulates and submits; a second device that may never touch a network reads the same transaction with its own IDLs and signs. Transactions and signatures move between them as QR codes. It's an unaudited prototype, so try it on devnet, not with real funds.

devrels.xyz/a/399

Read this first: Airlock is a prototype and has not been formally audited. In the README's words, it "handles private keys and signs transactions", and you should not "use it to hold or move real funds." Everything below is for learning and for devnet testing. Vulnerability reports go through the repo's private advisory form (see SECURITY.md).

Airlock is an open-source Solana wallet by Tiago Carvalho (@qtmoses on X, tiago18c on GitHub, LinkedIn), who works in engineering at the Solana Foundation. Its idea is simple: keep preparing a transaction apart from signing it. An online device builds, reviews, simulates and submits. A second device, which may never connect to a network, reviews the same transaction on its own and signs it. The two pass transactions and signatures back and forth as QR codes or pasted text.

It's written in Rust with the Dioxus UI framework, so one codebase runs on the desktop, in a browser and on Android 14+. It's MIT licensed (the bundled IDL files keep their own sources' licences). The repo was created in October 2026, and 0.4.0, the latest release, came out on 20 November. This piece walks through how it works, from the README, docs/signing.md, docs/android.md, the other files in docs/ and the release notes, as of 21 November 2026.

Why air-gapped signing matters on Solana

A normal software wallet keeps the key and the network on one machine. Whatever compromises that machine, or the browser on it, sits right next to the key. A hardware wallet moves the key off the machine, but you still have to trust what its small screen tells you, and some transactions can only be approved blind, as a hash.

Airlock's answer is to give the signing side its own full decoder. The offline device doesn't take the online device's word for what a transaction does. It decodes the transaction itself, explains every instruction with IDLs stored on that device, and only then signs. The docs' "who decides" table puts it plainly:

  • The site, the extension and the browser decide nothing. They propose transactions and report the origin.
  • The online app decides for its own keys. For a key on another device, its reading is advisory only.
  • The RPC node decides nothing. It's trusted for what the chain holds, never for what gets signed, and the docs admit the online device can't tell when a node lies.
  • The offline app decides for its keys, from its own decoding and its own IDLs.

The threat model in docs/browser-bridge.md spells out the reason. A compromised online app "can produce a malicious rebuild", and the defence is that the offline device reads the transaction on its own. A malicious extension update or hijacked store account can inject requests and lie about origins, but it can't sign without approval in the desktop app and, for an offline key, approval on the offline device too.

The online/offline split

The repo ships five pieces:

AppRunsDoes
airlockDesktop or browser, onlineHolds a vault; builds, reviews, rebuilds and submits; answers the browser extension (desktop only)
airlock-offlineDesktop, offlineHolds its own vault, reviews and signs. Opens no connection of its own, so it can't simulate or submit
airlock-mobileAndroid 14+, online or offlineThe online app's screens on a phone, a vault per mode, the camera for QR codes, the Seed Vault, and Mobile Wallet Adapter when online
Airlock ExtensionChromium browsersShows sites a Wallet Standard wallet and forwards requests. Holds no keys and approves nothing
bridge-hostStarted by the browserRelays between the extension and the running desktop app

The offline build is offline by construction rather than by a setting: airlock-offline doesn't link the app-online or wallet-rpc crates, so it has no code path to a node. The README is careful about the limits of that. Its window is a WebView, and the UI library brings network code along. On Windows it starts the WebView with background traffic off and every non-loopback request sent to a proxy that isn't there. Still, keeping it on a device with no network is what actually keeps it offline. On Android, offline mode is "a promise the app keeps, not something Android enforces", since the APK still has the INTERNET permission.

Keys sit in a password-sealed vault. The wallet-vault crate uses Argon2id (256 MiB, three passes) and then XChaCha20-Poly1305, and wipes secrets from memory. An offline wallet on the online device holds only the public key. The secret lives in the offline device's vault as a hot wallet there.

A round trip

  1. On the online app, build a transaction for the offline wallet (the docs recommend a durable nonce). It fetches a blockhash or nonce and simulates.
  2. Optionally, a hot wallet on the online device signs as fee payer. Signatures can go in any order.
  3. The online app shows the transaction as QR codes, optionally with a context note listing the IDLs it was read with.
  4. The offline app scans them, decodes and explains the transaction, compares IDL checksums, and you sign.
  5. The offline app shows the signature as a QR code. The online app scans it, verifies it against the transaction on screen, inserts it, and submits.

Mind the clock. A transaction on a recent blockhash is accepted for roughly 30 to 45 seconds, and a trip to another device often takes longer. For anything slower, use a durable nonce. An offline wallet's Settings can create a nonce account with the offline key as its authority, after which transactions from that key are compiled on the nonce and don't expire. The other non-expiring path is a programmatic signer, covered below.

QRS1: the QR handoff format

What moves between devices is a QRS1 payload, implemented in the qr-protocol crate, which "knows bytes, not Solana". A payload carries one to 64 typed objects, written with wincode, as one QR code or a numbered set of same-size codes:

KindObjectCarries
1TransactionThe full v1 wire, with every signature so far
2SignatureWhat it signs (the transaction, a programmatic Submit authorization or a Vector authorization), the signer and the signature
3Context noteThe message hash, a checksum per IDL used to read it, and Vector account state. Never signed
4Public keyThe next Winternitz key for a Vector account
5Wallet keys1 to 32 addresses, for adding wallets whose keys stay elsewhere
6, 7Key rotation, account stateVector XMSS/Winternitz key management

The framing details from the docs:

  • A payload is at most 32 KiB, which is 43 codes. Every frame carries the same 768-byte chunk (the last padded with zeros), so every code is QR version 23 whatever it carries.
  • Each frame names its transfer by the first 8 bytes of the payload's SHA-256, checked once every frame is in, beside a CRC32. That catches a misread code or one from another transfer. It isn't meant to stop a forged payload: the signing device decides from its own reading.
  • IDL bytes never travel in a QR code. A zipped Token-2022 IDL alone is about 34 KiB, over the payload cap. The context note carries at most a 32-byte SHA-256 pin per program, and IDLs move between devices by file import.

As text, a payload is JSON, one object or an array, each with a "type". Addresses and Ed25519 signatures are base58, digests and nonces hex, other bytes base64. A transaction signature coming back looks like this:

json
{
  "type": "signature",
  "signs": "transaction",
  "pubkey": "<base58>",
  "signature": "<base58>"
}

Both devices of a pair must run the same build.

v1 transactions (SIMD-0385)

Airlock is built around Solana's new v1 transaction format (our v1 explainer). The rules, from the README and signing docs:

  • Browser requests and paste on the Sign screen accept legacy, v0 and v1.
  • A request that only needs hot keys on this device is signed as is. Anything else is converted to v1, wire prefix 0x81.
  • The QR handoff stays v1 only. Scanning a non-v1 QR is refused.
  • A v0 transaction is signed without its lookup tables, because signing reads only the message bytes. Showing it needs them, so they're read over RPC.

There's a trade-off to know about. A v1 transaction reads no lookup tables, so a Squads proposal naming more accounts than one v1 transaction can list ("somewhat more than a hundred") can't be executed from Airlock, though it can still be read and approved. Hardware support also depends on v1: Ledger's Solana app reads it from 1.18 and Trezor from its next firmware, both pre-release builds so far.

Wallet kinds

A wallet record says where the key is, or whether there is one at all. When a wallet has no key, another wallet signs for it, and the app follows that chain to the key at the end and picks a fee payer. The longest chain is Squads, then a programmatic signer or Vector wallet, then a key.

KindWhere the key isWhat signs
Hot (keypair or seed)This device's vaultThe key, over the transaction
OfflineAnother deviceThat device, over the transaction it's shown
Ed25519 programmatic signerNowhere: the address is derived from an authority keyThe authority, over an authorization message inside the transaction
Vector walletIn the record, a hot wallet, or elsewhereThe authority, over a digest of the relay instructions
Squads multisig (v4 and smart account)Nowhere: the vault is a PDAA member, by creating, approving and executing a proposal
Hardware (Ledger, Trezor, Keystone)On the deviceThe device, once you confirm on it
Seed Vault (Saga, Seeker)The phone's secure hardwareThe Seed Vault, after its own confirmation screen
  • Ed25519 programmatic signer. The wallet's address is a PDA derived from an authority key. Transactions targeting it are rebuilt into an authorization the key signs, ordered by the signer's executor nonce account. That authorization has no blockhash, which is why it's the second path for slow offline round trips. A hot wallet pays and relays.
  • Vector wallet (turned on in Settings). Built on a fork of blueshift-gg/vector deployed on devnet only, with its own program ID. Authorities can use Ed25519, secp256k1 and post-quantum schemes: ML-DSA-44 (the default), Falcon-512, XMSS and Winternitz. Falcon-512, XMSS and Winternitz are desktop and airgap only, and one ML-DSA signature is 2,420 of a v1 transaction's 4,096 bytes. The docs warn that a Winternitz key whose transaction failed on chain signs nothing else, so the account can get stuck.
  • Squads. Both Squads v4 multisigs and smart accounts. 0.4.0 added a lot here: members and threshold follow the chain, proposals show who voted, reject and vote-to-cancel, proposals that change the multisig itself, simulating a proposal, and closing finished proposals to reclaim rent. A multisig can't be a member of another multisig. (Background: how Squads works on-chain.)
  • Hardware wallets appear only once Pre-release hardware wallets is on in Settings. Ledger and Trezor connect over USB (HID/USB on desktop, WebHID and WebUSB in Chromium on the web build). A Keystone works through the camera with BC-UR QR codes. The signing docs say Keystone support "has not been checked on a device yet", hardware wallets in general "are not checked on devices yet", and a Trezor Safe 7 is refused. Every device signature is checked against the key and message before it goes in.
  • Seed Vault. On a Saga or Seeker, Airlock treats a Seed Vault account as a hardware wallet whose device is the phone, using Solana Mobile's seedvault-wallet-sdk. Add wallet → Seed Vault offers Choose seed, Import phrase and Create seed. Airlock never sees the seed; the Seed Vault signs after the owner confirms with fingerprint or PIN.

The desktop browser extension bridge

On desktop, a site sees Airlock as a normal Wallet Standard wallet, but the keys never enter the browser. The path is: site → content script (registers the wallet) → service worker (stamps the origin from the browser) → bridge-host over native messaging → a per-user local socket → the running Airlock app, which queues the request and asks you.

The bridge answers these methods:

  • connect, disconnect (and an internal status)
  • signTransaction, signAndSendTransaction, signAndSendAllTransactions, with one to 16 transactions per request, legacy, v0 or v1
  • signMessage and signIn

Everything else returns not_implemented. A few behaviours worth knowing if you build a dapp:

  • @solana/wallet-adapter prefers signAndSendTransaction for sendTransaction, so on those sites transactions go out through Airlock's node, not yours. skipPreflight, maxRetries, preflightCommitment and minContextSlot aren't passed on.
  • If Airlock rebuilt or converted your transaction (for a Squads vault, a programmatic signer, or to v1), the signature you get back is of what actually went out, which may not be what you were watching for.
  • When a send times out, the site gets send_unknown, never send_failed, so it doesn't resend something that may still land.
  • signMessage refuses bytes that parse as a transaction, anything starting with vector:, and Solana offchain messages. signIn refuses a domain that isn't the browser's host for the origin. Ledger and Trezor can't do signIn.
  • Limits: 256 KiB of JSON per request, 30 requests per origin every 10 seconds, 8 waiting per origin and 32 in all. Unanswered requests expire after ten minutes.

Why native messaging rather than a localhost server? A localhost HTTP or WebSocket server is reachable by every website and needs pairing tokens, origin checks and DNS-rebinding defences. Native messaging leaves that boundary to the browser: only the pinned extension can start the host. It also keeps the bridge off offline machines, since Airlock Offline doesn't link it.

Mobile Wallet Adapter on Android

On Android, online, other apps and sites in Chrome reach Airlock through Mobile Wallet Adapter: a solana-wallet: link opens it and they talk over an encrypted local WebSocket, using Solana Mobile's walletlib 2.1.1. Each MWA request is read into the same frame the browser extension would send, and goes through the same checks, queue and modals:

MWAAirlock
authorizeAlways asks in the connect modal, even for a site with a grant, since any app can claim that site's address
sign_transactionssignTransaction, at most 16
sign_and_send_transactionssignAndSendAllTransactions
sign_messagessignMessage, one at a time
deauthorizeEnds the site's connection

Offline, Airlock is never listed as a wallet. The docs also note that Android doesn't vouch for who an app says it is, so the modal says the app "only says" it is that site. Remote sessions through a reflector server aren't offered.

Clear signing: 90+ IDLs and templates

Every review row and every Build form in Airlock comes from an IDL. The README says the IDLs of over 90 programs ship with the app, in two sets:

  • The core, compiled into the binary: System, Stake, Token, Token-2022, compute budget, the Ed25519 programmatic signer, the two Squads programs, the Squads clear signing program and Vector.
  • The IDL pack for third-party programs, such as Jupiter v6, Orca Whirlpool, Raydium CLMM and CP swap, Meteora DLMM and DAMM v2, Pump.fun and PumpSwap, DFlow, Phoenix Perpetuals, Realms and the upgradeable loader. The pack's SHA-256 is pinned in the build, and a pack that doesn't match is refused whole.

The rules that tie what you read to what you sign:

  • IDLs are kept per network, since a program can differ between mainnet and devnet. The offline app has no node, so you choose the network in Settings → Read transactions for.
  • IDLs are read from the chain only (the program-metadata account, then the legacy Anchor IDL account), never over HTTP, and a check never overwrites the stored file.
  • An on-chain IDL is written by whoever controls the program, so it can explain an instruction but never makes Sign the primary button. Unless every instruction was read with a built-in or imported IDL, Sign is amber and the modal says what it couldn't read.
  • A hostile IDL can leave an instruction unread, "and nothing worse". Depth and expansion limits make it fall back to raw.

Templates on the Build screen are short TOML files that ask a few questions and write IDL blocks, which are then compiled and reviewed exactly like hand-built ones. A template can't emit raw bytes, its labels never appear on Review and Sign, and templates are never fetched. Shipped ones include Create a token, Create a Token-2022 token, Mint tokens, Create an NFT, Metaplex Core and compressed NFTs, a Streamflow vesting stream, Marinade staking and unstaking, a devnet Raydium pool, and Upgrade a program.

Trying it

Grab a build from the latest release (0.4.0 at the time of writing). There are installers and portable builds for Windows x64, DMGs for Apple Silicon Macs (no Intel builds), .deb and AppImage for x86-64 Linux, an arm64 APK for Android 14+, and the extension zip, each in an online and an offline variant where that applies. None is signed by a publisher the OS knows, so expect SmartScreen, Gatekeeper and Android's unknown-apps prompts. Check what you downloaded:

bash
# compare with SHA256SUMS.txt from the release
sha256sum airlock-0.4.0-linux-amd64.deb

# check the build provenance attestation (built by the repo's workflow from the tag)
gh attestation verify airlock-0.4.0-linux-amd64.deb --repo tiago18c/airlock

For the browser extension: install the online Airlock, press Install the browser bridge on its Extension chip (the Windows installer does this for you), unzip airlock-extension-0.4.0.zip into a folder you'll keep, enable Developer mode on chrome://extensions (or Edge or Brave), choose Load unpacked, restart the browser, then unlock Airlock and set it to Online. Firefox isn't supported yet.

To build from source you need Rust via rustup and the Dioxus CLI 0.7.10. Run the apps through dx, not plain cargo run:

bash
cargo binstall [email protected]

dx serve -p airlock --desktop                 # online app, desktop
dx serve -p airlock --web --addr 0.0.0.0      # online app, web (http://127.0.0.1:8080)
dx serve -p airlock-offline --desktop         # offline app

# extension + native messaging host (Node 22)
cd extension && npm install && npm run build && cd ..
cargo run -p bridge-host -- install

Both desktop apps can run on one machine with separate vaults, which is a handy way to learn the QR flow before you put the offline app on a second device. Keep it on devnet.

Known gaps

The docs list their own gaps. The ones most likely to bite:

  • A site's blockhash won't survive a QR round trip unless the offline key has a durable nonce and is the only signer missing.
  • Transactions prepared on one durable nonce aren't tracked. Only the first to land is valid, and nothing warns before a second is made.
  • Hardware wallets aren't checked on devices yet.
  • An approval of a Squads proposal on an offline device is taken on trust: it signs a proposal's address, and what the proposal holds is what the other device says.
  • Vector is devnet only.
  • Code that got into the app's WebView could still get data out through the default browser or WebRTC.

The takeaway

Airlock is worth reading even if you never run it. It's a concrete, well-documented answer to "what you see is what you sign" on Solana: an independent decoder on the signing device, IDL pins instead of trusting the online side, v1 as the handoff format, and one review path for Squads, programmatic signers, hardware and Seed Vault keys. Just treat it as what the README says it is: an unaudited prototype.

Links

Keep reading

Get new articles in your inbox

Technical deep-dives on Solana tooling, infrastructure, and ecosystem. No noise.

solanawalletsecurityair-gappedclear-signingrustv1-transactions

DevRels · November 21, 2026

Airlock: air-gapped signing and clear signing on Solana | devrels.xyz