Show HN: Umbera-core – hybrid X25519 and ML-KEM sealed sender in Rust Umbera released umbera-core, an Apache 2.0-licensed Rust cryptographic core for its private messaging platform, combining X25519 with NIST post-quantum algorithms in every end-to-end layer. The core pairs X25519 + ML-KEM-1024 for 1:1 key agreement and file keys, ML-DSA-65 for signatures, MLS (RFC 9420) with the X-Wing suite (X25519 + ML-KEM-768) for groups, and a PQ3-style Double Ratchet that mixes a fresh ML-KEM-1024 secret into the root key every 20 new chains or 24 hours. Umbera 2.1.0 (Android, iOS) and Umbera Desktop 1.0.0 (Windows, macOS, Linux) ship the code, which the company says can be verified by running `cargo test --release --test proof` in the repository. 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 .