In short
- The cryptographic core in Rust and the Kotlin protocol layer are open source under Apache-2.0. The Rust core in the repository is the code the apps are built from.
- One command builds the core and runs 114 tests. Known-answer vectors pin the output of every formula byte for byte.
- Every statement below points to a file, a test or something you can see in your own traffic.
- What we can’t prove yet, and what we don’t publish yet, is listed at the end of the page.
The other pages explain the same thing at different depths: Proof walks through the main claims, Security lists the layers in plain words, and the Specification gives the formulas. This page shows where to look and what to run.
What is open
Everything below is in the public repository UmberaAPP/UMBERA on GitHub, in the main branch.
On crates.io, umbera-core 1.1.0 (November 16, 2026) matches the core on GitHub: X-Wing groups, call frame keys and linking a computer by QR code. The 1.0.0 API is unchanged.
Is it the same code the apps run? We compared the repository with our build tree file by file: the Rust files of the core match line for line, apart from translated comments and test messages. The Kotlin files of the 2.1 mechanisms (SealV3, GroupPqSig, RendezvousV2, CallFrameE2ee, DoubleRatchet and others) match too. You can’t yet check this against an installed app yourself — see “What we don’t claim”.
Build and run the tests
You need Rust 1.91 or newer (rustup.rs). It builds and runs on Linux, macOS and Windows. On a clean clone, we get the result below — yours should match.
The Communities formats have an independent Go reference implementation (Go 1.27) that checks the same vectors the Kotlin client uses:
The parsers that read data from other people — MLS Welcome and incoming messages, device linking, call keys, abuse reports, PDF metadata removal — have fuzz targets:
The Kotlin tests (SealV3Test, PqRatchetTest, GroupPqSigTest, SafetyNumberV2Test, DesktopCallPqLoopbackTest and others) are published for review. They need the platform bindings of our app build, so they can be read but not run from the repository.
Test vectors
A known-answer vector fixes the exact output of a formula for fixed inputs. If an implementation — ours or yours — differs by a single bit, the test fails. The strongest check is to implement a formula from docs/PROTOCOL.md yourself and compare with these files.
Messages: the envelope
A 1:1 message is first encrypted by the conversation’s Double Ratchet session, then packed together with the sender’s identity and sealed to the recipient: a fresh one-time X25519 key and an ML-KEM-1024 encapsulation. Both secrets go into one HKDF-SHA256, and the result is closed with AES-256-GCM and padded to a size class.
In 2.1, the key derivation is also salted with a hash of the transcript — the one-time key, the ML-KEM ciphertext and both of the recipient’s public keys — so a key can’t be reused in a different context. Each part of the hash carries its length, so the end of one part can’t pass for the start of the next:
A full envelope carries a fresh ML-KEM capsule. Between full envelopes, up to 49 short ones take their keys from the pair secret of the last confirmed full envelope, moved forward through a one-way chain, so the 1.5 KB capsule doesn’t travel in every message. In our tests, a full envelope is 5,038 bytes, a short one 3,078, and the previous format 21,682.
tests/proof.rs models the seal and checks each property directly. The key test is the post-quantum one: an attacker with the recipient’s X25519 key but without the ML-KEM key can’t open the message.
Code: kotlin/…/crypto/SealV3.kt and HybridKeyExchange.kt. Tests: Rust sealv3::kat_matches_kotlin (Rust and Kotlin give identical bytes), Kotlin SealV3Test. Older apps (2.0.x) keep the previous envelope, which also combines X25519 and ML-KEM-1024 in every message.
Mailboxes: where an envelope goes
The server has no “from” and “to” fields. An envelope goes to a mailbox address that only the two people in the conversation can compute, and the address isn’t tied to either account.
When both of you have 2.1, the address comes from two inputs: the X25519 secret of the pair and a direction secret derived from the hybrid v3 envelope — that is, from X25519 and ML-KEM-1024 together. Someone who later breaks X25519 still can’t compute your addresses.
The address also changes every week. The boundary is the same second for everyone, so a change doesn’t single out a conversation, and addresses of different weeks can’t be linked to each other without the direction secret. The app keeps listening to the neighbouring weeks, so nothing is lost at the boundary or while a device is offline.
Honestly, about what is still visible:
- With a contact who still runs 2.0.x, the pair keeps its previous address and it doesn’t change until both of you update.
- The server sees which addresses are written to and read, when, and the size class of each envelope.
- Without Tor, your app checks all its mailboxes over one connection, so the server can see that a set of addresses belongs to one device — though not whose device it is. With Tor turned on, the app spreads its mailboxes over separate Tor circuits.
Code: kotlin/…/crypto/RendezvousV2.kt, devices/DeviceRidEpochs.kt (the same weekly schedule for addresses between your linked devices). Tests: Rust sealv3:: (address vectors), Kotlin SealV3Test.rendezvousV2Handshake, DeviceRidEpochTest.
How keys change
In 1:1 chats
Double Ratchet: every message has its own key, and a used key is deleted. A fresh ML-KEM-1024 secret is mixed into the root key at the start of a session and again every 20 new chains or every 24 hours, so the session also recovers after a key compromise against a quantum attacker. Code: DoubleRatchet.kt. Test: PqRatchetTest, including x25519_secrets_alone_do_not_open_a_pq_session.
In groups
Every change of members moves the MLS group to a new epoch with new keys. On top of that, each device refreshes its own leaf every 7 days (±12 hours), after 100 of its own packets or after a long idle period — so the group heals even when nobody joins or leaves. Code: GroupRekeyPolicy.kt. Tests: pcs_rekey (9), MlsRekeyTest.
In calls
Every call, every transfer to another device and every pair in a group call gets a new X25519 + ML-KEM-1024 exchange. Nothing is reused from one call to the next.
No silent downgrade
A new format is sent to a contact only after they have announced support inside an end-to-end encrypted message. Once announced, the capability is pinned: if it later disappears, the app shows “key changed” instead of quietly falling back. Test: PeerCryptoCapsPinTest (15).
Safety number and a contact’s key change
The app remembers a contact’s keys the first time it sees them. If the server later serves different keys, the app doesn’t accept them silently: it shows a security warning in the chat, and you can verify the person and then accept the new key. Messages and calls keep working while the warning is shown — the decision is yours.
To check that nobody is in the middle, compare the safety number with the other person, in person or by scanning each other’s QR codes. The number is the same on both sides. Version 2 covers all four identity keys — secp256k1, X25519, ML-DSA-65 and ML-KEM-1024 — and each key carries its length, so the keys can’t be shifted against each other:
Version 2 is used when both of you have announced it inside your encrypted messages; the verification screen then says “Version 2”. With a contact on an older app, it is version 1, which covers the secp256k1 and X25519 keys.
Public keys are also written to an append-only transparency log, and the app checks a contact’s keys against it and shows the result in the contact’s card and in the Verification log. Each tree head of the log is signed with both Ed25519 and ML-DSA-65. A missing log entry doesn’t raise the warning yet — the safety number is the check that settles it.
Code: kotlin/…/crypto/SafetyNumber.kt, KeyTransparencyVerifier.kt. Tests: SafetyNumberV2Test (6), SafetyNumberNegotiationTest (10).
Groups: proofs for MLS
Groups use MLS (RFC 9420) through OpenMLS 0.9.2. New groups are created on the X-Wing suite (X25519 + ML-KEM-768). An existing group moves to X-Wing by itself once every member supports it, with the same members and history. A group that still includes a 2.0.x member stays on the previous suite, and each group packet still travels inside that member’s hybrid envelope.
tests/proof_groups.rs checks the group claims one by one: every member can read a message, the server sees only ciphertext, an outsider can’t read it — even with her own group under the same group ID — a removed member can’t read new messages, a new member can’t read older ones, and a key update moves the group to a new epoch.
Who changed the group: MLS member signatures are Ed25519, as the standard defines today. On top of them, every Commit, Proposal and Welcome carries an ML-DSA-65 signature, and each sender’s ordinary messages form a hash chain closed by an ML-DSA-65 checkpoint every 20 messages or after 30 seconds of silence. Once a member has announced these signatures, an unsigned change in their name is refused.
Code: core/src/lib.rs, provider.rs; kotlin/…/crypto/GroupPqSig.kt. Tests: Rust xwing_*, suites_do_not_mix, compat_v06, xwing_short_key; Kotlin GroupPqSigTest (29), MlsXwingRegroupTest. Cost: +4,429 bytes per signed Commit, about +275 bytes per message on average.
One-to-one calls
A call has two layers of encryption. The first is WebRTC’s DTLS-SRTP: the handshake runs directly between the two devices, and the relay server, when one is needed, forwards packets it can’t open. DTLS agrees on its key classically, so a recording made today could be opened by a quantum computer later.
That is why every audio, video and screen-sharing frame is encrypted a second time. The devices run a fresh X25519 + ML-KEM-1024 exchange for each call, carried in the call setup, which itself travels inside the end-to-end encrypted 1:1 envelope. The keys are bound to a hash of the whole exchange, and each direction has its own key:
The call setup — including the DTLS fingerprints — is encrypted and signed by the caller, so the server can neither read nor swap them. A signature that doesn’t match the caller’s key means the call isn’t established.
Code: core/src/callkey.rs, kotlin/…/webrtc/CallFrameE2ee.kt, desktopMain/…/PcFrameCryptor.kt. Tests: Rust callkey:: (both sides get the same keys; any tampering changes the keys or fails), Kotlin DesktopCallPqLoopbackTest on a real WebRTC connection: a wrong key drops every frame. With a 2.0.x contact the call runs on DTLS-SRTP alone.
Group calls and meetings by link
There is no server that mixes or decodes media. In a group call, participants connect to each other in pairs — directly or through the relay server — and every pair of participants runs its own X25519 + ML-KEM-1024 exchange with its own frame keys. A pair that includes someone on 2.0.x runs on DTLS-SRTP alone.
A meeting by link has a 256-bit room key that lives only in the link, after the “#”. That part of a link is never sent in a web request, so the server receives only a random room number. From the key, the app derives one key for the room description and one for the signalling inside the room; the server stores both only as ciphertext. Media between each pair is protected exactly as in a group call.
Code: kotlin/…/meet/MeetCrypto.kt, MeetLink.kt, webrtc/CallFrameE2ee.kt. Tests: MeetLinkCryptoTest (7), DesktopCallPqLoopbackTest.conferenceLegUsesItsOwnExchange.
What the server sees
Not only what it can’t see — also what it can. The server code isn’t public, so this table describes what reaches the server from the open client code:
Check the traffic yourself
You don’t need our code for this — only a network you control. Share a laptop’s connection with your phone, or run Umbera for computers on your own machine, and record the traffic with Wireshark.
- Write down every host the app connects to and compare it with this page.
- Send a one-letter message, then a long paragraph. The upload size doesn’t follow the length of the text: it falls into a few fixed sizes.
- Turn on Tor in Settings and repeat: messages no longer go to the server directly, only into the Tor network.
- Make a call and filter the recording as shown below. You’ll see a DTLS handshake followed only by SRTP packets — no plain RTP, nothing Wireshark can decode into sound or picture.
What a capture can’t show: the second call layer and the contents of envelopes are inside the encryption, so they look like noise. That’s expected — use the tests and vectors above to check those.
What we don’t claim
No independent audit yet
The code is open and covered by tests, but no outside firm has audited it yet.
Builds aren’t reproducible yet
You can build the core from source, but you can’t yet rebuild an app from the stores bit for bit and compare. Until then, “the app runs this code” rests on our word and on what you can observe.
The server and the apps aren’t open
The repository holds the code that decides what the server can learn. The server, the app interface and the network layer aren’t published.
Without Tor, the server sees your IP address
Tor is off until you turn it on. Tor itself has no post-quantum handshake yet; what Umbera sends inside it is post-quantum encrypted.
Older apps use older schemes
With a contact on 2.0.x, calls run without the second layer, groups stay on the previous suite, the safety number is version 1 and the mailbox address doesn’t change. Everything stays end-to-end encrypted.
A key change warns, it doesn’t block
Messages and calls continue after a contact’s key changes; you decide whether to trust it. A missing transparency log entry doesn’t raise the warning yet.
The tree head’s ML-DSA signature is server-side
Since November 16 the server signs each log tree head with Ed25519 and ML-DSA-65, and the app pins both keys on first use. The signing code is on the server, which isn’t public.
A hacked device is out of scope
Encryption protects data on the way and on the server, not on a device someone else controls.
Not published yet
Some implementation details — for example, the server code, the delivery and anti-abuse mechanisms, and the app’s network and storage layers — aren’t published yet. The full code and documentation will be handed over to trusted independent auditors when the project is audited, and we will publish the audit report afterwards.
Found a problem?
If the code does less than this page says, we want to be the first to know. Report security issues privately as described in SECURITY.md; questions and ideas go to Discussions on GitHub. We answer every report, fix what’s wrong and say what it was.