{"slug": "show-hn-umbera-core-hybrid-x25519-and-ml-kem-sealed-sender-in-rust", "title": "Show HN: Umbera-core – hybrid X25519 and ML-KEM sealed sender in Rust", "summary": "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.", "body_md": "**Umbera** is a private communication platform built on one rule: *the server should never know who talks to whom.*\nThis repository contains the code that enforces that rule — the cryptographic core that runs on every\nUmbera device. It is open source under the Apache License 2.0, so that anyone can read it, run its tests, check our\nclaims and reuse it.\n\nNo 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.\n\n```\ncargo add umbera-core\n```\n\nAPI 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:\n\n```\ngit clone https://github.com/UmberaAPP/UMBERA && cd UMBERA/core\ncargo test --release --test proof\n```\n\nQuestions 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.\n\nAn 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:\n\n| **Key agreement** | Hybrid X25519 + ML-KEM-1024 (CRYSTALS-Kyber). An attacker must break both to read a message. | \n| **Signatures** | Hybrid classical + ML-DSA-65 (CRYSTALS-Dilithium) identity keys. | \n| **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) . | \n| **Sealed sender** | The sender's identity is encrypted inside the message, never visible to the relay. | \n| **Rendezvous** | Mailbox addresses derived by both peers from a shared secret, rotated weekly. | \n| **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. | \n| **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. | \n| **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. | \n| **Abuse reports** | Asymmetric message franking: a recipient can prove to a moderator who sent an abusive message, while the relay never reads traffic. | \n| **Attachments** | A fresh key per file, a derived key per 256 KiB chunk, encrypted metadata. | \n| **Key transparency** | Merkle inclusion proofs that let clients detect a server substituting someone's keys. | \n\nThe 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.\n\nUmbera 2.1.0 (Android, iOS) and Umbera Desktop 1.0.0 (Windows, macOS, Linux) combine a classical algorithm\nwith a NIST post-quantum algorithm in every end-to-end layer: 1:1 envelopes and file keys\n(X25519 + ML-KEM-1024), group key schedule (MLS with X-Wing, X25519 + ML-KEM-768), group commits\n(ML-DSA-65), a second encryption layer on call frames (X25519 + ML-KEM-1024 per call), linking a computer\nby QR code, messages between linked devices, and Communities. Each mechanism, its code (file and line)\nand 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\nrelease are in [CHANGELOG.md](https://github.com/UmberaAPP/UMBERA/blob/main/CHANGELOG.md).\n\nCheck it yourself:\n\n```\ncd core\ncargo test --release                                  # whole Rust suite\ncargo test --release --lib xwing_                     # X-Wing groups\ncargo test --release --test compat_v06                # new core against the previous core (OpenMLS 0.6)\ncargo test --release --lib callkey::                  # call frame keys\ncargo test --release --lib devlink::                  # QR linking, device certificates\ncargo test --release --lib sealv3::                   # envelope v3 vectors shared with Kotlin\n\ncd ../communities/pqc\ngo test -v ./...                                      # Communities vectors (Go reference)\n```\n\nThe Rust crate in [`core/`](https://github.com/UmberaAPP/UMBERA/blob/main/core) is compiled once and shared by Android, iOS and the desktop app\nthrough [UniFFI](https://github.com/mozilla/uniffi-rs). The protocol layer in [`kotlin/`](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin) is Kotlin\nMultiplatform code built on top of it.\n\n1. The message is encrypted with the conversation's **Double Ratchet** session, whose root key also mixes in a\nfresh 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) ).\n2. It is wrapped together with the sender's identity into an **inner package** .\n3. The inner package is **sealed** to the recipient with a fresh ephemeral X25519 key and an ML-KEM-1024\nencapsulation; both secrets feed one HKDF, so the seal holds if either primitive survives.\n4. The result is **padded** to a fixed size bucket so length reveals little.\n5. It is delivered to a **rendezvous address** that only the two peers can compute:\n\nThe full specification, including every wire format and domain-separation label, is in\n[**docs/PROTOCOL.md**](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md).\n\n**Don't trust, verify.** [docs/PROOF.md](https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROOF.md) shows, with code references, runnable tests\nand a packet-capture procedure, that nobody but the recipient can read a message, nobody but the\nmembers can read a group chat and nobody but the participants can listen to a call.\n\nML-KEM and ML-DSA are the NIST-standardised versions of CRYSTALS-Kyber (FIPS 203) and CRYSTALS-Dilithium\n(FIPS 204). All primitives come from established open-source Rust implementations\n([RustCrypto](https://github.com/RustCrypto), [dalek-cryptography](https://github.com/dalek-cryptography),\n[OpenMLS](https://github.com/openmls/openmls)). Umbera does not implement its own ciphers.\n\n```\numbera-core/\n├── core/                      Rust crate: primitives, MLS engine, device linking, call keys, franking\n│   ├── src/\n│   │   ├── primitives.rs      ML-KEM, ML-DSA, X25519, Ed25519, secp256k1, AES-GCM, KDFs\n│   │   ├── lib.rs             MLS group engine exposed over UniFFI (X-Wing and the previous suite)\n│   │   ├── provider.rs        OpenMLS crypto provider with the X-Wing KEM\n│   │   ├── callkey.rs         X25519 + ML-KEM-1024 call frame keys\n│   │   ├── sealv3.rs          envelope v3 known-answer vectors (test only)\n│   │   ├── devlink/           linking a computer by QR code, device certificates, transfer package\n│   │   ├── amf.rs             asymmetric message franking\n│   │   └── pdf.rs             metadata removal for outgoing PDF files\n│   ├── tests/                 proofs, compatibility with the previous core, vectors\n│   └── fuzz/                  cargo-fuzz targets\n├── kotlin/                    protocol layer (Kotlin Multiplatform)\n│   └── src/\n│       ├── commonMain/kotlin/app/umbera/core/\n│       │   ├── crypto/        envelopes, ratchet, files, rendezvous, groups, safety number\n│       │   ├── devices/       envelopes and addresses between linked devices\n│       │   ├── meet/          meetings by link\n│       │   ├── webrtc/        call frame encryption\n│       │   └── util/          small helpers used by the protocol code\n│       ├── desktopMain/       desktop call frame encryptor\n│       └── commonTest/, desktopTest/   tests, published for review\n├── communities/               Communities cryptography\n│   ├── src/                   Kotlin client code\n│   └── pqc/                   Go reference with known-answer vectors\n└── docs/\n    ├── PROTOCOL.md            protocol specification\n    ├── PROOF.md               claims and how to check them\n    ├── PQ_STATUS.md           post-quantum status, code and tests\n    └── assets/                diagrams\n```\n\nThe Rust core builds and tests on any platform with a stable toolchain (Rust 1.91 or newer):\n\n```\ncd core\ncargo test --release\ntest result: ok. 63 passed; 0 failed     (unit tests: primitives, MLS, X-Wing, call keys, device linking, envelope v3)\ntest result: ok. 21 passed; 0 failed     (tests/compat_v06.rs: new core against the previous core)\ntest result: ok. 1 passed; 0 failed      (tests/golden_primitives.rs)\ntest result: ok. 9 passed; 0 failed      (tests/pcs_rekey.rs)\ntest result: ok. 4 passed; 0 failed      (tests/pq_small_stack.rs)\ntest result: ok. 7 passed; 0 failed      (tests/proof.rs)\ntest result: ok. 6 passed; 0 failed      (tests/proof_groups.rs)\ntest result: ok. 3 passed; 0 failed      (tests/xwing_short_key.rs)\n```\n\nThe 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):\n\n```\ncd communities/pqc\ngo test ./...\n```\n\nTo fuzz the parsers (franking, MLS Welcome and incoming messages, device linking, call keys, PDF):\n\n```\ncargo install cargo-fuzz\ncd core/fuzz && cargo +nightly fuzz run amf_parse      # or mls_welcome, mls_incoming, devlink, callkey, pdf_strip\n```\n\nThe 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\npublished for review. See [kotlin/README.md](https://github.com/UmberaAPP/UMBERA/blob/main/kotlin/README.md).\n\nFound a vulnerability? Please report it privately — see [SECURITY.md](https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md). We answer every report.\n\n**What is verified and what is not.** Every primitive has known-answer tests and the end-to-end tests above\npass on every change. The protocol has **not yet had an independent third-party audit.** Until it has, treat\nit as reviewed by its authors and by whoever reads this code — and we would very much like that to be you.\n\n- **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.\n- **Questions and ideas:** use[Discussions](https://github.com/UmberaAPP/UMBERA/discussions) .\n- **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) .\nPull requests are welcome — see[CONTRIBUTING.md](https://github.com/UmberaAPP/UMBERA/blob/main/CONTRIBUTING.md) .\n\n| Questions, partnerships, licensing | [info@umbera.app](mailto:info@umbera.app) | \n| Abuse reports | [abuse@umbera.app](mailto:abuse@umbera.app) | \n| Security issues | see [SECURITY.md](https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md) | \n\n**Open source.** The cryptographic core in this repository is licensed under the\n[Apache License 2.0](https://github.com/UmberaAPP/UMBERA/blob/main/LICENSE): you may use, modify and redistribute it, including in commercial products,\nas long as you keep the copyright and license notices. The Umbera apps, server and billing are separate\nand are not part of this repository.\n\n\"Umbera\" and the eclipse logo are trademarks of Umbera and are not covered by the license.\nSee [NOTICE.md](https://github.com/UmberaAPP/UMBERA/blob/main/NOTICE.md).\n\n<sub>© 2026 Umbera · [umbera.app](https://umbera.app)</sub>", "url": "https://wpnews.pro/news/show-hn-umbera-core-hybrid-x25519-and-ml-kem-sealed-sender-in-rust", "canonical_source": "https://github.com/UmberaAPP/UMBERA", "published_at": "2026-11-22 14:00:58+00:00", "updated_at": "2026-11-22 14:12:01.929196+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-safety"], "entities": ["Umbera", "umbera-core", "X25519", "ML-KEM-1024", "ML-DSA-65", "MLS (RFC 9420)", "X-Wing", "Umbera Desktop 1.0.0"], "also_reported_by": [], "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.", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/show-hn-umbera-core-hybrid-x25519-and-ml-kem-sealed-sender-in-rust", "markdown": "https://wpnews.pro/news/show-hn-umbera-core-hybrid-x25519-and-ml-kem-sealed-sender-in-rust.md", "text": "https://wpnews.pro/news/show-hn-umbera-core-hybrid-x25519-and-ml-kem-sealed-sender-in-rust.txt", "jsonld": "https://wpnews.pro/news/show-hn-umbera-core-hybrid-x25519-and-ml-kem-sealed-sender-in-rust.jsonld"}}