<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Umbera</title>
    <description>The latest articles on DEV Community by Umbera (@umberaapp).</description>
    <link>https://dev.to/umberaapp</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4162191%2F77cd85cb-770a-4252-b3bf-fee0597d067f.png</url>
      <title>DEV Community: Umbera</title>
      <link>https://dev.to/umberaapp</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/umberaapp"/>
    <language>en</language>
    <item>
      <title>Hybrid post-quantum E2EE in a messenger: what is hybrid, and how to check it yourself</title>
      <dc:creator>Umbera</dc:creator>
      <pubDate>Mon, 16 Nov 2026 18:14:18 +0000</pubDate>
      <link>https://dev.to/umberaapp/hybrid-post-quantum-e2ee-in-a-messenger-what-is-hybrid-and-how-to-check-it-yourself-36m0</link>
      <guid>https://dev.to/umberaapp/hybrid-post-quantum-e2ee-in-a-messenger-what-is-hybrid-and-how-to-check-it-yourself-36m0</guid>
      <description>&lt;p&gt;&lt;em&gt;Hybrid X25519 + ML-KEM-1024 and ML-DSA-65, layer by layer, with tests you can run.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Umbera is an end-to-end encrypted messenger. This post walks through every place where it uses post-quantum cryptography, points to the file and the test behind each one, and ends with an equally explicit list of what you &lt;strong&gt;can't&lt;/strong&gt; verify yet. All code excerpts come from the public repository and are Apache-2.0.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftqiju3b11ihji8xb2vgp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftqiju3b11ihji8xb2vgp.png" alt="Where the hybrid sits: mechanism, classical half, post-quantum half" width="800" height="527"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;A 90-second look at the app before the details:&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/8xxGMZktlic" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  What is open, and what isn't
&lt;/h2&gt;

&lt;p&gt;Open, in &lt;a href="https://github.com/UmberaAPP/UMBERA" rel="noopener noreferrer"&gt;UmberaAPP/UMBERA&lt;/a&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;core/&lt;/code&gt;: the Rust crypto core (ML-KEM-1024, ML-DSA-65, X25519, Ed25519, secp256k1, AES-GCM, key derivation, MLS groups with X-Wing, call frame keys, QR device linking, message franking), plus tests, vectors and fuzz targets. The same code is published on crates.io as &lt;code&gt;umbera-core&lt;/code&gt; 1.1.0.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;kotlin/&lt;/code&gt;: the protocol layer of the apps (envelopes, Double Ratchet, mailbox addresses, group signatures, safety number, the second call layer, meetings by link).&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;communities/&lt;/code&gt;: Communities cryptography, with an independent Go reference implementation.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;docs/&lt;/code&gt;: &lt;code&gt;PROTOCOL.md&lt;/code&gt;, &lt;code&gt;PROOF.md&lt;/code&gt;, and &lt;code&gt;PQ_STATUS.md&lt;/code&gt;, which lists every post-quantum mechanism with its file, line and test.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Not open: the server, the app UI, the network and storage layers. The full code will go to trusted independent auditors when the project is audited, and we'll publish the report afterwards. Builds aren't reproducible yet.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why hybrid, and why now
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Harvest now, decrypt later.&lt;/strong&gt; Anyone can record ciphertext today, whether from the wire, the server or a database backup. If the session keys were agreed with elliptic curves only, a large enough quantum computer could later recover them with Shor's algorithm and read the archive. For messages that should stay private for years, the timeline of that computer barely matters, because the recording already exists.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why not pure post-quantum?&lt;/strong&gt; ML-KEM (FIPS 203) and ML-DSA (FIPS 204) were standardised in 2024. The math has been studied for a long time, but the implementations are young, and timing leaks have already turned up in Kyber implementations (KyberSlash). X25519 is the opposite: very well understood, and broken by a quantum adversary. A hybrid feeds both secrets into one key derivation, so an attacker has to break &lt;strong&gt;both&lt;/strong&gt;. Signal's PQXDH, Apple's PQ3 and the X25519MLKEM768 key exchange in browsers' TLS make the same choice.&lt;/p&gt;

&lt;p&gt;From &lt;code&gt;docs/PROTOCOL.md&lt;/code&gt;, section 4:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ss_classical = X25519(ephemeral_private, recipient_x25519_public)
(ct, ss_pq)  = ML-KEM-1024.Encapsulate(recipient_kyber_public)
okm = HKDF-SHA256(ikm = ss_classical || ss_pq, salt = HYBRID_LABEL, info = "key-derivation", L = 64)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  What exactly is hybrid
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1:1 messages: envelope v3 and sealed sender
&lt;/h3&gt;

&lt;p&gt;A message is encrypted by the Double Ratchet, packed together with the sender's identity, and sealed to the recipient. Because the sender is inside the ciphertext, the server never learns who sent it (sealed sender). In 2.1 the seal is &lt;strong&gt;envelope v3&lt;/strong&gt;: an ephemeral X25519 key plus an ML-KEM-1024 encapsulation, HKDF-SHA256 salted with a hash of the transcript (ephemeral key, KEM ciphertext, both recipient public keys), then AES-256-GCM and padding to a size class. Each transcript part is length-prefixed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// core/src/sealv3.rs, lines 8–20 · Apache-2.0&lt;/span&gt;
&lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;part&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="kd"&gt;mut&lt;/span&gt; &lt;span class="nc"&gt;Sha256&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;u8&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;update&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="kt"&gt;u32&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;to_be_bytes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;update&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;th&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;parts&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;u8&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Vec&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;u8&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="kd"&gt;mut&lt;/span&gt; &lt;span class="n"&gt;h&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Sha256&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;new&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nf"&gt;part&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="kd"&gt;mut&lt;/span&gt; &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;as_bytes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;parts&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nf"&gt;part&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="kd"&gt;mut&lt;/span&gt; &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;finalize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;to_vec&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;An ML-KEM-1024 ciphertext is 1,568 bytes, so not every message carries one. A full v3 envelope has a fresh capsule. Up to 49 short &lt;strong&gt;v3s&lt;/strong&gt; envelopes (24 hours at most) then use a fresh ephemeral X25519 key plus a one-way chain from the hybrid pair secret of the last &lt;em&gt;confirmed&lt;/em&gt; full envelope. Measured sizes: 21,682 bytes for the previous v2 format, 5,038 for full v3, 3,078 for short v3s, and 3,117 on average over 50.&lt;/p&gt;

&lt;p&gt;The ratchet itself runs on X25519, and a fresh ML-KEM-1024 secret is mixed into the root key at session start and then every 20 new chains or every 24 hours. File keys are wrapped with X25519 + ML-KEM-1024 and bound to the transcript (file wrap v2).&lt;/p&gt;

&lt;h3&gt;
  
  
  Mailboxes: where an envelope goes
&lt;/h3&gt;

&lt;p&gt;The server has no "from" or "to" fields. An envelope goes to a mailbox address that only the two people in the conversation can compute, with one address per direction. Between two 2.1 apps, the address mixes the X25519 pair secret with a &lt;strong&gt;direction secret&lt;/strong&gt; derived from the hybrid v3 exchange, so someone who later breaks X25519 still can't compute it. The address also rotates weekly, at the same second for everyone:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight kotlin"&gt;&lt;code&gt;&lt;span class="c1"&gt;// kotlin/src/commonMain/kotlin/app/umbera/core/crypto/RendezvousV2.kt, lines 39–40 · Apache-2.0&lt;/span&gt;
    &lt;span class="k"&gt;fun&lt;/span&gt; &lt;span class="nf"&gt;ridEpoch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ssX25519&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ByteArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dir&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ByteArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;fromId&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;toId&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;epoch&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Long&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="nf"&gt;hex&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;RustCore&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;hkdfSha256&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ssX25519&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;dir&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;SALT&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"rdv-e|$fromId|$toId|$epoch"&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;encodeToByteArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;32u&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If either side still runs 2.0.x, the pair keeps its previous, fixed address.&lt;/p&gt;

&lt;h3&gt;
  
  
  Groups: MLS with X-Wing, plus ML-DSA-65 on top
&lt;/h3&gt;

&lt;p&gt;Groups use MLS (RFC 9420) through OpenMLS 0.9.2. New groups are created on &lt;code&gt;MLS_256_XWING_CHACHA20POLY1305_SHA256_Ed25519&lt;/code&gt; (0x004D), where the KEM is X-Wing (X25519 + ML-KEM-768). An existing group moves to X-Wing by itself once every member supports it, and keeps its members and history. A group with a 2.0.x member stays on suite 0x0001.&lt;/p&gt;

&lt;p&gt;MLS member signatures are still Ed25519, as the standard defines today. On top of them, every Commit, Proposal and Welcome carries an ML-DSA-65 signature. Ordinary messages form a per-sender hash chain that is 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. The cost is +4,429 bytes per signed Commit and about +275 bytes per message on average.&lt;/p&gt;

&lt;h3&gt;
  
  
  Calls: a second post-quantum layer over DTLS-SRTP
&lt;/h3&gt;

&lt;p&gt;DTLS-SRTP agrees its key classically, so a call recorded today could be decrypted later. That's why every audio, video and screen-sharing frame is encrypted a second time, with keys from a fresh X25519 + ML-KEM-1024 exchange per call. The exchange is carried inside the encrypted, caller-signed call setup, the keys are bound to a hash of the whole exchange, and each direction gets its own key:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// core/src/callkey.rs, lines 74–86 (excerpt) · Apache-2.0&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;th&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;transcript&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;public&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;answer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;ikm&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Zeroizing&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;new&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;ss_x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ss_k&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;concat&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;prk&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Zeroizing&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;new&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;hkdf&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="nc"&gt;Hkdf&lt;/span&gt;&lt;span class="o"&gt;::&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;Sha256&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;::&lt;/span&gt;&lt;span class="nf"&gt;extract&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kc"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;th&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;ikm&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;to_vec&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;exp&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="n"&gt;info&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;u32&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;hkdf_sha256_expand&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;prk&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;to_vec&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;info&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;as_bytes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;to_vec&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;i2r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;exp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"umbera-call-v1/frames/initiator-&amp;gt;responder"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;32&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;r2i&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;exp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"umbera-call-v1/frames/responder-&amp;gt;initiator"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;32&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Frames use AES-128-GCM in WebRTC's frame-encryptor format. The key is PBKDF2-HMAC-SHA256 (100,000 rounds) of the 256-bit hybrid output. If AES-128 here bothers you, that's a fair thing to push on. In group calls, every &lt;strong&gt;pair&lt;/strong&gt; of participants runs its own exchange, and no server mixes media. In meetings by link, a 256-bit room key lives only in the URL fragment after &lt;code&gt;#&lt;/code&gt;, so the server sees only a random room number.&lt;/p&gt;

&lt;h3&gt;
  
  
  Stopping key substitution
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Safety number v2&lt;/strong&gt; hashes all four identity keys (secp256k1, X25519, ML-DSA-65, ML-KEM-1024), each one length-prefixed. v1 covered only the first two, which meant a server could have swapped the post-quantum keys without changing the number.
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight kotlin"&gt;&lt;code&gt;&lt;span class="c1"&gt;// kotlin/src/commonMain/kotlin/app/umbera/core/crypto/SafetyNumber.kt, lines 51–55 · Apache-2.0&lt;/span&gt;
    &lt;span class="k"&gt;fun&lt;/span&gt; &lt;span class="nf"&gt;identityV2&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;secp256k1&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ByteArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x25519&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ByteArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;mlDsaPk&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ByteArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;mlKemPk&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ByteArray&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="n"&gt;buf&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;V2_LABEL&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="nf"&gt;listOf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;secp256k1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x25519&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;mlDsaPk&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;mlKemPk&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;buf&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="nf"&gt;lenBE&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;k&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;HashUtils&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;sha256&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;buf&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;toHexLower&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The key transparency log&lt;/strong&gt; is an append-only Merkle tree. Since 16 November 2026, the server signs each tree head with Ed25519 &lt;em&gt;and&lt;/em&gt; ML-DSA-65; the ML-DSA message includes the Ed25519 key. The client side is open (&lt;code&gt;KeyTransparencyVerifier.sthAuthentic&lt;/code&gt;): once the log's ML-DSA-65 key is pinned, a tree head without a valid PQ co-signature is rejected. Pinning happens on first use, so the very first contact with the log is the weak point.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No silent downgrade.&lt;/strong&gt; A new format is sent only after the contact has announced support inside an end-to-end encrypted message. If that announcement later disappears, the app shows "key changed" instead of quietly falling back.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Linking a computer by QR follows the same pattern: X25519 + ML-KEM-1024, transcript-salted HKDF, key confirmation in both directions, a 6-digit code on both screens, and a device certificate signed with both secp256k1 and ML-DSA-65.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it yourself
&lt;/h2&gt;

&lt;p&gt;You need Rust 1.91 or newer.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/UmberaAPP/UMBERA
&lt;span class="nb"&gt;cd&lt;/span&gt; UMBERA/core
cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release
&lt;span class="c"&gt;# 8 test binaries, 114 passed, 0 failed&lt;/span&gt;

cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release --test proof          &lt;span class="c"&gt;# 1:1 seal: 7 tests&lt;/span&gt;
cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release --test proof_groups   &lt;span class="c"&gt;# MLS groups: 6 tests&lt;/span&gt;
cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release --test compat_v06     &lt;span class="c"&gt;# new core vs. the previous core (OpenMLS 0.6)&lt;/span&gt;
cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release --lib sealv3::        &lt;span class="c"&gt;# envelope v3 vectors, shared with Kotlin&lt;/span&gt;
cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release --lib callkey::       &lt;span class="c"&gt;# call frame keys&lt;/span&gt;
cargo &lt;span class="nb"&gt;test&lt;/span&gt; --release --lib xwing_hundred_leaves_and_sizes -- --nocapture

&lt;span class="nb"&gt;cd&lt;/span&gt; ../communities/pqc &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; go &lt;span class="nb"&gt;test&lt;/span&gt; -v ./...  &lt;span class="c"&gt;# independent Go check of the Communities vectors&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;tests/proof.rs&lt;/code&gt; models the hybrid seal and checks each property directly. Here's the one that matters for post-quantum:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// core/tests/proof.rs, lines 87–94 · Apache-2.0&lt;/span&gt;
&lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;breaking_only_x25519_is_not_enough&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// An attacker who somehow learned Bob's X25519 key (for example with a future&lt;/span&gt;
    &lt;span class="c1"&gt;// quantum computer) still cannot open the message without his Kyber key.&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;bob&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;new_recipient&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;eve&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;new_recipient&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;sealed&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;seal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;bob&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;MESSAGE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nf"&gt;assert_eq!&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;bob&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x25519_private&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;eve&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;kyber_private&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;sealed&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The mirror test, &lt;code&gt;breaking_only_kyber_is_not_enough&lt;/code&gt;, is right below it. &lt;code&gt;tests/proof_groups.rs&lt;/code&gt; checks that every member can read a message, that an outsider can't even with a group under the same ID, that a removed member can't read new epochs, and that a new member can't read old ones. One caveat: these tests prove properties of the scheme on the core's primitives. They don't prove what a store build runs.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Known-answer vectors&lt;/strong&gt; pin each formula byte for byte. &lt;code&gt;core/tests/vectors/seal-v3-vectors.txt&lt;/code&gt; covers the v3/v3s envelope, the file key, mailbox addresses and their weekly epochs. It's computed in Rust with &lt;code&gt;sha2&lt;/code&gt; + &lt;code&gt;hkdf&lt;/code&gt; directly and checked by the Kotlin tests too. &lt;code&gt;primitives-golden.json&lt;/code&gt; pins SHA-256, HKDF, AES-GCM, X25519, Ed25519, ML-KEM-1024, ML-DSA-65 and more. The strongest review is to implement a formula from &lt;code&gt;PROTOCOL.md&lt;/code&gt; yourself and diff it against these files.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Capture your own traffic.&lt;/strong&gt; On a network you control, use Wireshark with the filter &lt;code&gt;dtls || rtp || srtp&lt;/code&gt; during a call. You should see a DTLS handshake followed only by SRTP, with no plain RTP. Send a one-letter message and then a long paragraph, and the upload sizes fall into the same few fixed classes. Turn on Tor and repeat: nothing goes to the server directly any more.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F387bg92pcezof5nms6rt.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F387bg92pcezof5nms6rt.png" alt="What the server sees" width="800" height="942"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Since the server code is closed, that table describes what reaches the server according to the open client code. In short, the server sees mailbox addresses and when they're used, public keys, the number of linked computers and your IP address (unless Tor is on). It doesn't see content, the sender, the recipient account, group membership, exact sizes or meeting keys.&lt;/p&gt;

&lt;h2&gt;
  
  
  What we don't claim
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdb7w91forxzecdj15a9h.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdb7w91forxzecdj15a9h.png" alt="What we don't claim" width="800" height="611"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;No independent audit yet.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No reproducible builds yet.&lt;/strong&gt; Until they exist, "the app runs this code" rests on our word and on what you can observe.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The server and the apps aren't open.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Without Tor, the server sees your IP address.&lt;/strong&gt; Tor is off by default, and Tor itself has no post-quantum handshake yet.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Older apps (2.0.x) use older schemes&lt;/strong&gt;: no second call layer, the previous MLS suite, safety number v1, and a fixed mailbox address. Everything is still end-to-end encrypted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A key change warns, it doesn't block&lt;/strong&gt;, and a missing transparency log entry doesn't raise a warning yet.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mailbox reads are authorised with Ed25519&lt;/strong&gt;, so that part is classical today. &lt;code&gt;PQ_STATUS.md&lt;/code&gt; covers end-to-end encryption, not the transport to the server.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;A compromised device is out of scope.&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Break it
&lt;/h2&gt;

&lt;p&gt;If the code does less than &lt;code&gt;PQ_STATUS.md&lt;/code&gt; says, that's a security report. Email the address in &lt;a href="https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md" rel="noopener noreferrer"&gt;SECURITY.md&lt;/a&gt; with the subject &lt;code&gt;SECURITY&lt;/code&gt; (acknowledgement within 72 hours), and use GitHub Discussions for questions. There's no paid bounty yet, but confirmed findings are credited. Good places to start: the v3s inheritance window, trust-on-first-use pinning of the log's ML-DSA key, and the call frame format.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Links:&lt;/strong&gt; &lt;a href="https://github.com/UmberaAPP/UMBERA" rel="noopener noreferrer"&gt;repository&lt;/a&gt; · &lt;a href="https://github.com/UmberaAPP/UMBERA/blob/main/docs/PQ_STATUS.md" rel="noopener noreferrer"&gt;PQ_STATUS.md&lt;/a&gt; · &lt;a href="https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md" rel="noopener noreferrer"&gt;PROTOCOL.md&lt;/a&gt; · &lt;a href="https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROOF.md" rel="noopener noreferrer"&gt;PROOF.md&lt;/a&gt; · &lt;a href="https://crates.io/crates/umbera-core" rel="noopener noreferrer"&gt;crates.io/umbera-core&lt;/a&gt; · &lt;a href="https://umbera.app/verify" rel="noopener noreferrer"&gt;umbera.app/verify&lt;/a&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>cryptography</category>
      <category>rust</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Your messenger is end-to-end encrypted. Its server still knows who you talk to. I tried to fix that.</title>
      <dc:creator>Umbera</dc:creator>
      <pubDate>Sun, 08 Nov 2026 09:36:27 +0000</pubDate>
      <link>https://dev.to/umberaapp/your-messenger-is-end-to-end-encrypted-its-server-still-knows-who-you-talk-to-i-tried-to-fix-that-1p9b</link>
      <guid>https://dev.to/umberaapp/your-messenger-is-end-to-end-encrypted-its-server-still-knows-who-you-talk-to-i-tried-to-fix-that-1p9b</guid>
      <description>&lt;p&gt;"End-to-end encrypted" has become a checkbox. WhatsApp has it. Signal has it. Telegram has it (sometimes).&lt;/p&gt;

&lt;p&gt;But encryption hides &lt;strong&gt;what&lt;/strong&gt; you say. It does not automatically hide &lt;strong&gt;who&lt;/strong&gt; you are, &lt;strong&gt;who&lt;/strong&gt; you talk to, or &lt;strong&gt;how much&lt;/strong&gt; you say. That part is called metadata, and for many people it is the more dangerous part.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"We kill people based on metadata." — Michael Hayden, former director of the NSA and CIA&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;So when I started building &lt;strong&gt;Umbera&lt;/strong&gt;, a messenger for Android and iOS, I set myself one rule: design the server as if it will one day be hacked, subpoenaed, or run by someone I don't trust. What can it learn?&lt;/p&gt;

&lt;p&gt;Here is what I ended up with, including the parts that are still not solved.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. No phone number. No email. Nothing.
&lt;/h2&gt;

&lt;p&gt;Most messengers start by asking for your phone number. That number is tied to your real name, your SIM card and your contacts.&lt;/p&gt;

&lt;p&gt;In Umbera you pick a username and a password. That's it. Your account recovery is a 12-word phrase (like a crypto wallet) that lives only on your side. The server has nothing to send a password reset to, because it does not know who you are.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. The server does not see the sender
&lt;/h2&gt;

&lt;p&gt;Normally a message arrives at the server with a "from" field. Even if the content is encrypted, the server writes down: &lt;em&gt;Alice → Bob, 14:02&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;Umbera uses &lt;strong&gt;sealed sender&lt;/strong&gt;: the sender's identity is put &lt;em&gt;inside&lt;/em&gt; the encrypted envelope. The server sees a blob that it has to deliver, not who sent it.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. The server does not see the recipient either
&lt;/h2&gt;

&lt;p&gt;This is the part I'm most proud of. Messages are not sent "to Bob". They are dropped into a &lt;strong&gt;mailbox address&lt;/strong&gt; that only the two people in the chat can compute, and that address changes every week.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;shared = X25519(my_private, peer_public)
epoch  = floor(unix_time / 604800)          // one week

mailbox = HKDF-SHA256(ikm  = shared,
                      salt = RENDEZVOUS_LABEL,
                      info = "rdv|e{epoch}|{from}|{to}")
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each direction gets its own address. To read a mailbox, the phone proves it owns the key behind it with a signature, without showing any account ID.&lt;/p&gt;

&lt;p&gt;From the server's point of view, it's a rotating random string receiving random-looking blobs. It cannot link two mailboxes to the same person, or tell which two people share one.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Message length is hidden in buckets
&lt;/h2&gt;

&lt;p&gt;If "ok" is 2 bytes and a long confession is 900, size alone tells a story. Umbera pads every message up to a size bucket (1, 2, 4, 8, 16 KiB, then steps of 4 KiB), so "ok" and a whole paragraph look exactly the same on the wire.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Post-quantum, because recordings last forever
&lt;/h2&gt;

&lt;p&gt;Someone can record your encrypted traffic today and decrypt it in 10–15 years when quantum computers are good enough. This is called &lt;em&gt;harvest now, decrypt later&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;Umbera's session setup is &lt;strong&gt;hybrid&lt;/strong&gt;: classic X25519 &lt;strong&gt;plus&lt;/strong&gt; ML-KEM-1024 (the NIST post-quantum standard). An attacker has to break both.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Your IP address
&lt;/h2&gt;

&lt;p&gt;Encryption doesn't hide your IP. Umbera has &lt;strong&gt;built-in Tor&lt;/strong&gt; on Android and iOS: one switch and all app traffic goes through Tor. Calls can go through a relay so the other person doesn't see your IP.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it does NOT do (yet)
&lt;/h2&gt;

&lt;p&gt;I think a privacy post without this section is marketing. So:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Status&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1:1 message encryption post-quantum&lt;/td&gt;
&lt;td&gt;Yes (hybrid handshake)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ratchet after the handshake post-quantum&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt;, classic Double Ratchet for now&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Group chats post-quantum&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt;, groups use MLS with X25519&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Calls post-quantum&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt;, DTLS-SRTP (WebRTC)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Server sees delivery time&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Yes&lt;/strong&gt;, it has to deliver the message&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;App and server source open&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt;, only the crypto core is open&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Several devices on one account&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt;, one device per account&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  "Don't trust us. Verify."
&lt;/h2&gt;

&lt;p&gt;Every messenger says "we can't read your messages". I didn't want you to take my word for it.&lt;/p&gt;

&lt;p&gt;The cryptographic core is open source under Apache-2.0, written in Rust: &lt;strong&gt;umbera-core&lt;/strong&gt;. It ships with proof tests you can run in one command. They play the role of a malicious server and check that it cannot read, link or forge messages, and that a removed group member cannot read new messages.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/UmberaAPP/UMBERA
&lt;span class="nb"&gt;cd &lt;/span&gt;UMBERA/core
cargo &lt;span class="nb"&gt;test&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight tap"&gt;&lt;code&gt;test the_ciphertext_does_not_contain_the_message ... ok
test anyone_with_other_keys_cannot_read_it ... ok
test breaking_only_x25519_is_not_enough ... ok
test breaking_only_kyber_is_not_enough ... ok
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;Code: &lt;a href="https://github.com/UmberaAPP/UMBERA" rel="noopener noreferrer"&gt;https://github.com/UmberaAPP/UMBERA&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Crate: &lt;a href="https://crates.io/crates/umbera-core" rel="noopener noreferrer"&gt;https://crates.io/crates/umbera-core&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;How the protocol works: &lt;a href="https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md" rel="noopener noreferrer"&gt;https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you are a cryptographer and you find a hole, I really want to hear about it. Open an issue or write to &lt;a href="mailto:info@umbera.app"&gt;info@umbera.app&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;Umbera is live on both stores. No phone number, no email: just a username and a password.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Android:&lt;/strong&gt; &lt;a href="https://play.google.com/store/apps/details?id=cc.umbera.app" rel="noopener noreferrer"&gt;https://play.google.com/store/apps/details?id=cc.umbera.app&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;iPhone:&lt;/strong&gt; &lt;a href="https://apps.apple.com/app/id6805525799" rel="noopener noreferrer"&gt;https://apps.apple.com/app/id6805525799&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Website:&lt;/strong&gt; &lt;a href="https://umbera.app" rel="noopener noreferrer"&gt;https://umbera.app&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Install it, look at what the app shows you about your own privacy, and tell me in the comments what you would try to break first. I'll answer every comment.&lt;/p&gt;

</description>
      <category>privacy</category>
      <category>security</category>
      <category>showdev</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Don't trust your messenger: post-quantum sealing you can verify with 7 tests</title>
      <dc:creator>Umbera</dc:creator>
      <pubDate>Sun, 04 Oct 2026 18:03:47 +0000</pubDate>
      <link>https://dev.to/umberaapp/dont-trust-your-messenger-post-quantum-sealing-you-can-verify-with-7-tests-1acf</link>
      <guid>https://dev.to/umberaapp/dont-trust-your-messenger-post-quantum-sealing-you-can-verify-with-7-tests-1acf</guid>
      <description>&lt;p&gt;Almost every messenger says "we can't read your messages." Almost none of them let you check.&lt;/p&gt;

&lt;p&gt;While building Umbera, a messenger for Android and iOS, I decided to do the opposite: publish the cryptographic core — the code that decides what our server can learn — and write tests that rebuild the scheme and verify its properties with one command.&lt;/p&gt;

&lt;p&gt;This post walks through:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;how each message is sealed with a &lt;strong&gt;hybrid post-quantum&lt;/strong&gt; construction (X25519 + ML-KEM-1024),&lt;/li&gt;
&lt;li&gt;why breaking one of the two algorithms gets an attacker nothing,&lt;/li&gt;
&lt;li&gt;what metadata the server &lt;strong&gt;does&lt;/strong&gt; see (this matters),&lt;/li&gt;
&lt;li&gt;how calls are protected from DTLS fingerprint substitution,&lt;/li&gt;
&lt;li&gt;and how to verify every claim yourself.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The sealing key is derived from two shared secrets: a classical one (X25519) and a post-quantum one (ML-KEM-1024). An attacker has to break both.&lt;/li&gt;
&lt;li&gt;The relay stores only a mailbox ID and an opaque blob. There is no sender or recipient field.&lt;/li&gt;
&lt;li&gt;Call media uses DTLS-SRTP end to end; a TURN relay only sees encrypted datagrams.&lt;/li&gt;
&lt;li&gt;Seven Rust tests check the properties; calls can be checked with a packet capture.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How a message is sealed
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F50z46jx0suem9czh6cd6.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F50z46jx0suem9czh6cd6.png" alt="Message sealing pipeline" width="800" height="317"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Double Ratchet.&lt;/strong&gt; The text is encrypted with the conversation's ratchet session, so every message gets a fresh key (forward secrecy and post-compromise recovery).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Inner package.&lt;/strong&gt; The ratchet ciphertext is wrapped together with the sender's identity, so the sender travels &lt;em&gt;inside&lt;/em&gt; the ciphertext (sealed sender), not in a header.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Seal to the recipient.&lt;/strong&gt; The sender generates an ephemeral X25519 key pair for this message only, computes DH with the recipient's long-term X25519 key, and in parallel runs ML-KEM-1024 &lt;code&gt;Encaps&lt;/code&gt; against the recipient's Kyber key. &lt;code&gt;ss1 || ss2&lt;/code&gt; goes into HKDF-SHA256 with a domain-separation label; the first 32 bytes are the AES-256-GCM key.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Padding.&lt;/strong&gt; The result is padded to a fixed size bucket so length leaks as little as possible.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Delivery.&lt;/strong&gt; The envelope is dropped into a mailbox whose address only the two peers can compute from their shared secret. Addresses rotate weekly.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Here is the sealing from the proof tests — the same construction the apps use:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;seal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;to&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;Recipient&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;plaintext&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nb"&gt;u8&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;Sealed&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;ephemeral_private&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nn"&gt;random&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="mi"&gt;32&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;ephemeral_public&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;x25519_public_key&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ephemeral_private&lt;/span&gt;&lt;span class="nf"&gt;.clone&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;&lt;span class="nf"&gt;.unwrap&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;ss1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;x25519_shared_secret&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ephemeral_private&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;to&lt;/span&gt;&lt;span class="py"&gt;.x25519_public&lt;/span&gt;&lt;span class="nf"&gt;.clone&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;&lt;span class="nf"&gt;.unwrap&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;enc&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;mlkem1024_encapsulate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;to&lt;/span&gt;&lt;span class="py"&gt;.kyber_public&lt;/span&gt;&lt;span class="nf"&gt;.clone&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;&lt;span class="nf"&gt;.unwrap&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;iv&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nn"&gt;random&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="mi"&gt;12&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;box_&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;aes256_gcm_encrypt&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;key&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ss1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;enc&lt;/span&gt;&lt;span class="py"&gt;.shared_secret&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;iv&lt;/span&gt;&lt;span class="nf"&gt;.clone&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="n"&gt;plaintext&lt;/span&gt;&lt;span class="nf"&gt;.to_vec&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="nd"&gt;vec!&lt;/span&gt;&lt;span class="p"&gt;[])&lt;/span&gt;&lt;span class="nf"&gt;.unwrap&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="n"&gt;Sealed&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;ephemeral_public&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;kyber_ciphertext&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;enc&lt;/span&gt;&lt;span class="py"&gt;.ciphertext&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;iv&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;box_&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Why hybrid and not Kyber alone?&lt;/strong&gt; ML-KEM was standardised recently (FIPS 203). Classical X25519 hedges against a flaw in the new scheme; Kyber hedges X25519 against a quantum computer. Because the key comes from both secrets, the seal holds as long as either algorithm does.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the server sees
&lt;/h2&gt;

&lt;p&gt;A proof that hides the inconvenient parts is just marketing, so here is the full picture:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Data&lt;/th&gt;
&lt;th&gt;Visible to the server?&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Content (text, media, voice)&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt; — AEAD ciphertext&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sender&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt; — identity is inside the seal&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Recipient&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;No&lt;/strong&gt; — only a rendezvous ID derived from the pair's shared secret, rotated weekly&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Length&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Partly&lt;/strong&gt; — only the size bucket&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Timing&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Yes&lt;/strong&gt; — when an envelope is written and fetched&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Client network address&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Yes&lt;/strong&gt; on a direct connection; with Tor enabled, only the exit node&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A stored message is a mailbox ID, an opaque ciphertext, a type and timestamps. There is no sender, recipient or account field.&lt;/p&gt;

&lt;h2&gt;
  
  
  Seven proof tests
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;core/tests/proof.rs&lt;/code&gt; rebuilds the seal and checks one property per test. The key one is the post-quantum guarantee:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="nd"&gt;#[test]&lt;/span&gt;
&lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;breaking_only_x25519_is_not_enough&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;bob&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;new_recipient&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;eve&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;new_recipient&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;sealed&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;seal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;bob&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;MESSAGE&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nd"&gt;assert_eq!&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;bob&lt;/span&gt;&lt;span class="py"&gt;.x25519_private&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;eve&lt;/span&gt;&lt;span class="py"&gt;.kyber_private&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;sealed&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nb"&gt;None&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The attacker here holds the recipient's X25519 private key (say, after a quantum break) but not the Kyber key, and the message does not open. The other tests check that the recipient can read it, that the ciphertext doesn't contain the plaintext, that foreign keys fail, that breaking only Kyber fails too, that flipping a single bit is rejected, and that the same text sent twice yields unrelated ciphertexts.&lt;/p&gt;

&lt;p&gt;All you need is Rust:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/UmberaAPP/UMBERA
&lt;span class="nb"&gt;cd &lt;/span&gt;UMBERA/core
cargo &lt;span class="nb"&gt;test&lt;/span&gt; &lt;span class="nt"&gt;--test&lt;/span&gt; proof
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;running 7 tests
test the_recipient_can_read_the_message ... ok
test the_ciphertext_does_not_contain_the_message ... ok
test anyone_with_other_keys_cannot_read_it ... ok
test breaking_only_x25519_is_not_enough ... ok
test breaking_only_kyber_is_not_enough ... ok
test a_tampered_message_is_rejected ... ok
test every_message_is_sealed_with_fresh_keys ... ok

test result: ok. 7 passed; 0 failed
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On top of these, the core has 23 tests with known-answer vectors for every primitive and end-to-end checks of ML-KEM-1024 and ML-DSA-65. We don't roll our own ciphers: primitives come from RustCrypto, dalek-cryptography and OpenMLS.&lt;/p&gt;

&lt;h2&gt;
  
  
  Calls: protecting DTLS fingerprints
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8tqgn7uioc2t9bdgvcw2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8tqgn7uioc2t9bdgvcw2.png" alt="Call encryption" width="800" height="375"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Media goes over WebRTC: SRTP keys come from a DTLS handshake between the two endpoints. Behind symmetric NAT, a TURN relay forwards the traffic, but it works at the transport layer and never takes part in DTLS, so it never has the SRTP master secret.&lt;/p&gt;

&lt;p&gt;The one weak spot of this setup is fingerprint substitution during call setup — a classic man-in-the-middle. A signalling server could swap in its own DTLS fingerprints and sit between the callers. So the call description (SDP with the fingerprints) is encrypted with the same scheme as messages and signed by the caller:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight kotlin"&gt;&lt;code&gt;&lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="py"&gt;result&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;messageEncryption&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;encryptMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;content&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;recipientId&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;peerUserId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;recipientPublicKey&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;peerKeys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;first&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;recipientX25519PublicKey&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;peerKeys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;second&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;type&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;"signaling"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;sequenceNumber&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On the receiving side, a foreign or altered signature aborts call setup:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight kotlin"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(!&lt;/span&gt;&lt;span class="nc"&gt;Secp256k1&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;verify&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ciphertext&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sig&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;senderPublicKey&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;throw&lt;/span&gt; &lt;span class="nc"&gt;SecurityException&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"Invalid message signature"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Group calls are a full mesh: each participant has a separate DTLS-SRTP session with every other one. There is no SFU or MCU that could decode a stream.&lt;/p&gt;

&lt;h3&gt;
  
  
  Check it with Wireshark
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;Share your laptop's connection and capture the phone's traffic on that interface.&lt;/li&gt;
&lt;li&gt;Make a call.&lt;/li&gt;
&lt;li&gt;Filter the capture with &lt;code&gt;dtls || rtp || srtp&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Expect a DTLS ClientHello/ServerHello followed only by SRTP. Wireshark can't decode the payload, and there is no plain RTP.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Assumptions
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Trusted endpoints.&lt;/strong&gt; A compromised OS (malware, screen access) is outside what any E2E scheme can solve.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;An honest peer.&lt;/strong&gt; Cryptography can't stop a recipient from forwarding the decrypted text.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sound primitives.&lt;/strong&gt; We rely on NIST and IETF standards: FIPS 203, RFC 7748, RFC 5869, AES-GCM, RFC 5764.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verified keys for important contacts.&lt;/strong&gt; Key transparency (Merkle inclusion proofs) and key pinning warn you if a contact's keys change.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What is published
&lt;/h2&gt;

&lt;p&gt;The repository holds the Rust crate with the primitives and the MLS engine (exported to the mobile apps via UniFFI), the Kotlin Multiplatform protocol code shared by Android and iOS, and the wire-format specification. The server and the UI are not included: the server only ever receives what this code has already encrypted, so it isn't needed to check the claims.&lt;/p&gt;

&lt;p&gt;The license is PolyForm Strict 1.0.0 — you can read, build, run the tests and audit, but it's source-available, not open source.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try to break it
&lt;/h2&gt;

&lt;p&gt;If you can disprove either claim, I want to be the first to know — see SECURITY.md in the repo. I'd especially love feedback on how the two secrets are combined in HKDF and on the call-signalling protection.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Code, tests and protocol spec: &lt;a href="https://github.com/UmberaAPP/UMBERA" rel="noopener noreferrer"&gt;https://github.com/UmberaAPP/UMBERA&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Full proof with diagrams: &lt;a href="https://umbera.app/proof" rel="noopener noreferrer"&gt;https://umbera.app/proof&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;The app: &lt;a href="https://apps.apple.com/app/id6805525799" rel="noopener noreferrer"&gt;App Store&lt;/a&gt; · &lt;a href="https://play.google.com/store/apps/details?id=cc.umbera.app" rel="noopener noreferrer"&gt;Google Play&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>showdev</category>
      <category>security</category>
      <category>rust</category>
      <category>cryptography</category>
    </item>
  </channel>
</rss>
