# Show HN: Umbera-core – hybrid X25519 and ML-KEM sealed sender in Rust

> Source: <https://github.com/UmberaAPP/UMBERA>
> Published: 2026-11-22 14:00:58+00:00

**Key takeaway:** Umbera's umbera-core crate mixes an ML-KEM-1024 secret into the Double Ratchet root key at session start and every 20 new chains or 24 hours, so recorded conversations stay closed if X25519 is later broken.

**Umbera** is a private communication platform built on one rule: *the server should never know who talks to whom.*
This repository contains the code that enforces that rule — the cryptographic core that runs on every
Umbera device. It is open source under the Apache License 2.0, so that anyone can read it, run its tests, check our
claims and reuse it.

No phone number. No email. Post-quantum end-to-end encryption. Sealed sender. A relay that moves padded ciphertext between rotating mailbox addresses and learns nothing else.

```
cargo add umbera-core
```

API docs are on [docs.rs/umbera-core](https://docs.rs/umbera-core). To check our claims instead of trusting them, clone the repo and run the proof tests:

```
git clone https://github.com/UmberaAPP/UMBERA && cd UMBERA/core
cargo test --release --test proof
```

Questions or a review? Open a [discussion](https://github.com/UmberaAPP/UMBERA/discussions) or join our [Discord](https://discord.gg/P4VbVDYPm6). If this is useful to you, a star helps other people find it.

An app that promises privacy should not ask to be trusted blindly. Everything that decides what the server can or cannot learn lives on the device, and that code is here:

| **Key agreement** | Hybrid X25519 + ML-KEM-1024 (CRYSTALS-Kyber). An attacker must break both to read a message. | 
| **Signatures** | Hybrid classical + ML-DSA-65 (CRYSTALS-Dilithium) identity keys. | 
| **1:1 sessions** | Double Ratchet with a post-quantum step: an ML-KEM-1024 secret is mixed into the root key at session start and again every 20 new chains or 24 h (PQ3-style), so a recorded conversation stays closed even if X25519 is broken later. Forward secrecy and break-in recovery for every conversation. Source: [`DoubleRatchet.kt`](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin/src/commonMain/kotlin/app/umbera/core/crypto/DoubleRatchet.kt) , tests:[`PqRatchetTest.kt`](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin/src/commonTest/kotlin/app/umbera/core/crypto/PqRatchetTest.kt) . | 
| **Sealed sender** | The sender's identity is encrypted inside the message, never visible to the relay. | 
| **Rendezvous** | Mailbox addresses derived by both peers from a shared secret, rotated weekly. | 
| **Groups** | MLS (RFC 9420) with the X-Wing cipher suite (X25519 + ML-KEM-768), ML-DSA-65 signed commits and a cryptographically enforced member cap. | 
| **Calls** | A second layer on every call frame with keys from an X25519 + ML-KEM-1024 exchange per call, in addition to WebRTC's DTLS-SRTP. | 
| **Linked devices** | A computer is linked to the phone by QR code with X25519 + ML-KEM-1024 session keys and a certificate signed with secp256k1 and ML-DSA-65. | 
| **Abuse reports** | Asymmetric message franking: a recipient can prove to a moderator who sent an abusive message, while the relay never reads traffic. | 
| **Attachments** | A fresh key per file, a derived key per 256 KiB chunk, encrypted metadata. | 
| **Key transparency** | Merkle inclusion proofs that let clients detect a server substituting someone's keys. | 

The server, billing and application UI are not part of this repository. None of them can change the guarantees above, because the relay only ever handles data that this code has already encrypted.

Umbera 2.1.0 (Android, iOS) and Umbera Desktop 1.0.0 (Windows, macOS, Linux) combine a classical algorithm
with a NIST post-quantum algorithm in every end-to-end layer: 1:1 envelopes and file keys
(X25519 + ML-KEM-1024), group key schedule (MLS with X-Wing, X25519 + ML-KEM-768), group commits
(ML-DSA-65), a second encryption layer on call frames (X25519 + ML-KEM-1024 per call), linking a computer
by QR code, messages between linked devices, and Communities. Each mechanism, its code (file and line)
and the test that checks it are listed in [**docs/PQ_STATUS.md**](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PQ_STATUS.md); the changes of this
release are in [CHANGELOG.md](https://github.com/UmberaAPP/UMBERA/blob/main/CHANGELOG.md).

Check it yourself:

```
cd core
cargo test --release                                  # whole Rust suite
cargo test --release --lib xwing_                     # X-Wing groups
cargo test --release --test compat_v06                # new core against the previous core (OpenMLS 0.6)
cargo test --release --lib callkey::                  # call frame keys
cargo test --release --lib devlink::                  # QR linking, device certificates
cargo test --release --lib sealv3::                   # envelope v3 vectors shared with Kotlin

cd ../communities/pqc
go test -v ./...                                      # Communities vectors (Go reference)
```

The Rust crate in [`core/`](https://github.com/UmberaAPP/UMBERA/blob/main/core) is compiled once and shared by Android, iOS and the desktop app
through [UniFFI](https://github.com/mozilla/uniffi-rs). The protocol layer in [`kotlin/`](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin) is Kotlin
Multiplatform code built on top of it.

1. The message is encrypted with the conversation's **Double Ratchet** session, whose root key also mixes in a
fresh ML-KEM-1024 secret every 20 chains or 24 h ([details](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md#5-one-to-one-sessions-double-ratchet) ).
2. It is wrapped together with the sender's identity into an **inner package** .
3. The inner package is **sealed** to the recipient with a fresh ephemeral X25519 key and an ML-KEM-1024
encapsulation; both secrets feed one HKDF, so the seal holds if either primitive survives.
4. The result is **padded** to a fixed size bucket so length reveals little.
5. It is delivered to a **rendezvous address** that only the two peers can compute:

The full specification, including every wire format and domain-separation label, is in
[**docs/PROTOCOL.md**](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md).

**Don't trust, verify.** [docs/PROOF.md](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROOF.md) shows, with code references, runnable tests
and a packet-capture procedure, that nobody but the recipient can read a message, nobody but the
members can read a group chat and nobody but the participants can listen to a call.

ML-KEM and ML-DSA are the NIST-standardised versions of CRYSTALS-Kyber (FIPS 203) and CRYSTALS-Dilithium
(FIPS 204). All primitives come from established open-source Rust implementations
([RustCrypto](https://github.com/RustCrypto), [dalek-cryptography](https://github.com/dalek-cryptography),
[OpenMLS](https://github.com/openmls/openmls)). Umbera does not implement its own ciphers.

```
umbera-core/
├── core/                      Rust crate: primitives, MLS engine, device linking, call keys, franking
│   ├── src/
│   │   ├── primitives.rs      ML-KEM, ML-DSA, X25519, Ed25519, secp256k1, AES-GCM, KDFs
│   │   ├── lib.rs             MLS group engine exposed over UniFFI (X-Wing and the previous suite)
│   │   ├── provider.rs        OpenMLS crypto provider with the X-Wing KEM
│   │   ├── callkey.rs         X25519 + ML-KEM-1024 call frame keys
│   │   ├── sealv3.rs          envelope v3 known-answer vectors (test only)
│   │   ├── devlink/           linking a computer by QR code, device certificates, transfer package
│   │   ├── amf.rs             asymmetric message franking
│   │   └── pdf.rs             metadata removal for outgoing PDF files
│   ├── tests/                 proofs, compatibility with the previous core, vectors
│   └── fuzz/                  cargo-fuzz targets
├── kotlin/                    protocol layer (Kotlin Multiplatform)
│   └── src/
│       ├── commonMain/kotlin/app/umbera/core/
│       │   ├── crypto/        envelopes, ratchet, files, rendezvous, groups, safety number
│       │   ├── devices/       envelopes and addresses between linked devices
│       │   ├── meet/          meetings by link
│       │   ├── webrtc/        call frame encryption
│       │   └── util/          small helpers used by the protocol code
│       ├── desktopMain/       desktop call frame encryptor
│       └── commonTest/, desktopTest/   tests, published for review
├── communities/               Communities cryptography
│   ├── src/                   Kotlin client code
│   └── pqc/                   Go reference with known-answer vectors
└── docs/
    ├── PROTOCOL.md            protocol specification
    ├── PROOF.md               claims and how to check them
    ├── PQ_STATUS.md           post-quantum status, code and tests
    └── assets/                diagrams
```

The Rust core builds and tests on any platform with a stable toolchain (Rust 1.91 or newer):

```
cd core
cargo test --release
test result: ok. 63 passed; 0 failed     (unit tests: primitives, MLS, X-Wing, call keys, device linking, envelope v3)
test result: ok. 21 passed; 0 failed     (tests/compat_v06.rs: new core against the previous core)
test result: ok. 1 passed; 0 failed      (tests/golden_primitives.rs)
test result: ok. 9 passed; 0 failed      (tests/pcs_rekey.rs)
test result: ok. 4 passed; 0 failed      (tests/pq_small_stack.rs)
test result: ok. 7 passed; 0 failed      (tests/proof.rs)
test result: ok. 6 passed; 0 failed      (tests/proof_groups.rs)
test result: ok. 3 passed; 0 failed      (tests/xwing_short_key.rs)
```

The tests include known-answer vectors for every primitive and end-to-end checks of ML-KEM-1024 and ML-DSA-65 key generation, encapsulation, signing and verification. The Communities vectors are checked by the Go reference (Go 1.27):

```
cd communities/pqc
go test ./...
```

To fuzz the parsers (franking, MLS Welcome and incoming messages, device linking, call keys, PDF):

```
cargo install cargo-fuzz
cd core/fuzz && cargo +nightly fuzz run amf_parse      # or mls_welcome, mls_incoming, devlink, callkey, pdf_strip
```

The Kotlin sources in [`kotlin/`](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin) are the protocol layer exactly as it ships in the apps and are
published for review. See [kotlin/README.md](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin/README.md).

Found a vulnerability? Please report it privately — see [SECURITY.md](https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md). We answer every report.

**What is verified and what is not.** Every primitive has known-answer tests and the end-to-end tests above
pass on every change. The protocol has **not yet had an independent third-party audit.** Until it has, treat
it as reviewed by its authors and by whoever reads this code — and we would very much like that to be you.

- **Cryptographers:** read[docs/PROTOCOL.md](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md) and try to break it. Private reports go to[SECURITY.md](https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md) ; everyone who finds a real issue is credited there.
- **Questions and ideas:** use[Discussions](https://github.com/UmberaAPP/UMBERA/discussions) .
- **Small, well-defined tasks:** see issues labelled[good first issue](https://github.com/UmberaAPP/UMBERA/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) .
Pull requests are welcome — see[CONTRIBUTING.md](https://github.com/UmberaAPP/UMBERA/blob/main/CONTRIBUTING.md) .

| Questions, partnerships, licensing | [info@umbera.app](mailto:info@umbera.app) | 
| Abuse reports | [abuse@umbera.app](mailto:abuse@umbera.app) | 
| Security issues | see [SECURITY.md](https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md) | 

**Open source.** The cryptographic core in this repository is licensed under the
[Apache License 2.0](https://github.com/UmberaAPP/UMBERA/blob/main/LICENSE): you may use, modify and redistribute it, including in commercial products,
as long as you keep the copyright and license notices. The Umbera apps, server and billing are separate
and are not part of this repository.

"Umbera" and the eclipse logo are trademarks of Umbera and are not covered by the license.
See [NOTICE.md](https://github.com/UmberaAPP/UMBERA/blob/main/NOTICE.md).

<sub>© 2026 Umbera · [umbera.app](https://umbera.app)</sub>
