Разбираем, где в мессенджере Umbera стоит постквантовая криптография: конверты сообщений, файлы, группы MLS, звонки, журнал ключей, код безопасности и адреса ящиков. Для каждого механизма — формула, файл в открытом репозитории и тест, который можно запустить одной командой. В конце — честный список того, что проверить пока нельзя.
Где стоит гибрид: механизм, классическая и постквантовая половины
Как это выглядит в приложении — полторы минуты, перед подробностями:
Вместо вступления: что открыто, а что нет
Недавно, после статьи про «Тайник», в комментариях справедливо спросили: «а софт-то закрытый?». Отвечу сразу, чтобы дальше не было недомолвок.
Открыто под Apache-2.0 (репозиторий UmberaAPP/UMBERA на GitHub):
-
core/— криптоядро на Rust: ML-KEM-1024, ML-DSA-65, X25519, Ed25519, secp256k1, AES-GCM, выработка ключей, группы MLS с набором X-Wing, ключи кадров звонка, привязка компьютера по QR-коду, подтверждение отправителя для жалоб (message franking), тесты, векторы и цели фаззинга. Это же ядро опубликовано на crates.io какumbera-core1.1.0; -
kotlin/— протокольный слой приложений: конверты, Double Ratchet, адреса ящиков, подписи в группах, код безопасности, второй слой звонков, конференции по ссылке; -
communities/— криптография Сообществ и независимая эталонная реализация форматов на Go; -
docs/—PROTOCOL.md(форматы и метки),PROOF.md(утверждения и проверки),PQ_STATUS.md(каждый постквантовый механизм с файлом, строкой и тестом).
Закрыто: код сервера, интерфейс приложений, сетевой слой и хранилища, механизмы доставки и защиты от злоупотреблений. Полный код и документация будут переданы доверенным независимым аудиторам при аудите, отчёт мы опубликуем после него. Воспроизводимых сборок пока нет. Поэтому дальше всё, что я утверждаю, опирается либо на открытый код, либо на то, что вы можете увидеть в собственном трафике, а про остальное прямо сказано «проверить нельзя».
Зачем вообще постквантовое шифрование в мессенджере
Угроза называется «собери сейчас — расшифруй потом» (harvest now, decrypt later). Трафик мессенджера можно записать сегодня: с канала связи, с сервера, из резервной копии базы. Если ключи согласовывались только на эллиптических кривых, то противник с достаточно большим квантовым компьютером в будущем восстановит общие секреты алгоритмом Шора и прочитает архив. Для переписки, которая должна оставаться тайной годами, срок появления такого компьютера не так важен: запись уже лежит.
Для подписей угроза другая. Подделать подпись «задним числом» бессмысленно, если её проверили сегодня. Но если долгоживущий ключ (ключ личности, ключ журнала, ключ участника группы) однажды можно будет подделать, противник сможет выдавать себя за собеседника в будущих сессиях. Поэтому подписи тоже стоит переводить заранее — особенно там, где они защищают от подмены ключей.
Почему гибрид, а не «чистый» постквантовый алгоритм
ML-KEM (FIPS 203) и ML-DSA (FIPS 204) стандартизированы в 2024 году. Математику изучают давно, но реализации молоды: в реализациях Kyber уже находили утечки по времени выполнения (история KyberSlash). X25519 и Ed25519, наоборот, изучены вдоль и поперёк, но беззащитны перед квантовым противником.
Гибрид снимает выбор «что из двух сломается первым»: оба секрета идут в одну выработку ключа, и, чтобы прочитать сообщение, надо сломать оба. Этот же подход сейчас используют Signal (PQXDH), Apple (PQ3 в iMessage) и TLS в браузерах (X25519MLKEM768). Формулировка в docs/PROTOCOL.md, раздел 4:
Every key agreement combines a classical and a post-quantum secret. The derived key is secure as long as either X25519 or ML-KEM-1024 remains unbroken.
Базовая формула выглядит так (там же):
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)
Дальше — по механизмам: что именно сведено и где это в коде.
Ключи личности
У каждого аккаунта на устройстве создаются ключи (PROTOCOL.md, раздел 3):
Ключ
Алгоритм
Назначение
Ключ обмена
X25519
классическая половина каждого согласования ключей
Ключ KEM
ML-KEM-1024
постквантовая половина каждого согласования
Ключ подписи
secp256k1 ECDSA
классическая половина подписей личности
Постквантовая подпись
ML-DSA-65
постквантовая половина подписей личности
Учётные данные MLS
Ed25519
членство в группах
Ключ франкинга
Ristretto255
жалобы (message franking)
Все ключи, включая ML-KEM-1024 и ML-DSA-65, детерминированно выводятся из фразы восстановления из 12 слов (HKDF-SHA256, отдельный контекст на каждый ключ; kotlin/.../crypto/RecoverySeed.kt:89-107). Отдельного теста на это в открытом репозитории нет — это сказано прямо в PQ_STATUS.md.
Реализации: RustCrypto ml-kem 0.3 и ml-dsa 0.1; X-Wing — из openmls_libcrux_crypto 0.4 внутри OpenMLS 0.9.2. Одно и то же ядро на Rust собирается для Android, iOS, Windows, macOS и Linux.
Сообщения 1:1: конверт v3 и скрытый отправитель
Сообщение 1:1 сначала шифруется сессией Double Ratchet, затем вместе с данными отправителя упаковывается во внутренний пакет и запечатывается получателю. Отправитель находится внутри шифра — это и есть скрытый отправитель (sealed sender): сервер видит одноразовый открытый ключ и шифротекст, но не видит, от кого конверт.
Запечатывание в версии 2.1 (конверт v3):
-
новый одноразовый ключ X25519 и инкапсуляция ML-KEM-1024 к ключу получателя;
-
оба секрета идут в одну HKDF-SHA256;
-
солью служит хеш транскрипта — одноразового ключа, шифротекста ML-KEM и обоих открытых ключей получателя, поэтому выведенный ключ нельзя переиспользовать в другом контексте;
-
результат закрывается AES-256-GCM и дополняется до класса размера.
Хеш транскрипта в эталонной реализации на Rust. Каждая часть идёт со своей длиной, чтобы конец одной части нельзя было выдать за начало следующей:
// core/src/sealv3.rs, строки 8–20 и 36–38 · Apache-2.0fn part(h: &mut Sha256, x: &[u8]) { h.update((x.len() as u32).to_be_bytes()); h.update(x);}fn th(label: &str, parts: &[&[u8]]) -> Vec { let mut h = Sha256::new(); part(&mut h, label.as_bytes()); for p in parts { part(&mut h, p); } h.finalize().to_vec()}… let ikm = [ss_x.as_slice(), ss_k.as_slice()].concat(); let t = th("umbera-seal-v3/transcript", &[&eph, &ct, &rx, &rek]);
Цена капсулы и короткие конверты
Шифротекст ML-KEM-1024 занимает 1568 байт, и возить его в каждом сообщении дорого. Поэтому конверты бывают двух видов. Полный (v3) несёт свежую капсулу. Между полными до 49 коротких (v3s, не дольше 24 часов) используют новый одноразовый X25519 и ключи из односторонней хеш-цепочки от гибридного секрета пары, установленного последним подтверждённым полным конвертом. То есть постквантовая часть в коротком конверте не исчезает — она унаследована от последнего полного и продвигается по цепочке.
Размеры из тестов (PQ_STATUS.md, «Size cost»):
Что
Байт
Прежний конверт v2 (текст 40 символов, JSON)
21 682
Полный конверт v3
5 038
Короткий конверт v3s
3 078
В среднем на 50 конвертов (1 полный + 49 коротких)
3 117
Старые приложения (2.0.x) остаются на прежнем конверте v2, который тоже сводит X25519 и ML-KEM-1024 — но в каждом сообщении и без привязки к транскрипту.
Double Ratchet с постквантовым корнем
Сам Double Ratchet работает на X25519. Чтобы восстановление после компрометации (post-compromise security) работало и против квантового противника, в корневой ключ подмешивается свежий секрет ML-KEM-1024 — в начале сессии и затем каждые 20 новых цепочек или каждые 24 часа (версия храповика root+mlkem1024; kotlin/.../crypto/DoubleRatchet.kt:461, :495, :576). Тест на Kotlin PqRatchetTest включает случай x25519_secrets_alone_do_not_open_a_pq_session.
Файлы
Для каждого файла — свой одноразовый X25519; ключ файла дополнительно обёрнут X25519 + ML-KEM-1024 с привязкой к транскрипту (обёртка v2, SealV3.kt:129-135). Файл режется на куски по 256 КиБ, у каждого свой выведенный ключ и случайный nonce, AES-256-GCM, дополнение. Имя, тип и размер шифруются отдельно как метаданные. У исходящих PDF вычищаются автор, программа-производитель и другие идентифицирующие поля (core/src/pdf.rs).
Ящики: куда уходит конверт
У сервера нет полей «от кого» и «кому». Конверт уходит на адрес ящика, который могут вычислить только двое участников переписки. Отдельный адрес на каждое направление.
Если у обоих версия 2.1, адрес собирается из секрета пары X25519 и секрета направления, выведенного из гибридного конверта v3, — то есть из X25519 и ML-KEM-1024 вместе. Тот, кто в будущем сломает X25519, адреса не вычислит.
// core/src/sealv3.rs, строки 49–51 · Apache-2.0 // Direction secret and v2 mailbox address. let dir = hkdf(&ikm, &t, "umbera-rendezvous-v2/dir", 32); let rid2 = hkdf(&[ss_x.as_slice(), dir.as_slice()].concat(), b"umbera-rendezvous-v2", "rdv|alice|bob", 32);
Кроме того, адрес меняется раз в неделю. Граница эпохи — одна и та же секунда для всех, поэтому смена адреса не выделяет отдельную переписку; адреса разных недель связать между собой без секрета направления нельзя (разные метки HKDF). Приложение слушает и соседние недели, поэтому на границе и после того, как устройство было не в сети, ничего не теряется.
// kotlin/src/commonMain/kotlin/app/umbera/core/crypto/RendezvousV2.kt, строки 35–40 · Apache-2.0 fun rid(ssX25519: ByteArray, dir: ByteArray, fromId: String, toId: String): String = hex(RustCore.hkdfSha256(ssX25519 + dir, SALT, "rdv|$fromId|$toId".encodeToByteArray(), 32u)) /** Address for epoch [epoch]: same input as [rid], different label (addresses of different epochs are unlinkable without D — HKDF). */ fun ridEpoch(ssX25519: ByteArray, dir: ByteArray, fromId: String, toId: String, epoch: Long): String = hex(RustCore.hkdfSha256(ssX25519 + dir, SALT, "rdv-e|$fromId|$toId|$epoch".encodeToByteArray(), 32u))
Что при этом остаётся видно:
-
с собеседником на 2.0.x у пары остаётся прежний адрес, и он не меняется, пока не обновятся оба;
-
сервер видит, в какие адреса пишут и из каких читают, когда, и класс размера каждого конверта;
-
без Tor приложение проверяет все свои ящики по одному соединению, поэтому сервер может понять, что набор адресов принадлежит одному устройству (но не чьё оно); с включённым Tor ящики разносятся по разным цепочкам Tor;
-
право чтения ящика подтверждается подписью Ed25519 от ключа, выведенного из X25519 (PROTOCOL.md, раздел 8), — эта часть сейчас классическая.
Поскольку ящики анонимны и ограничивать запись по аккаунту нельзя, для записи нужно небольшое доказательство работы (по умолчанию 15 нулевых бит SHA-256; раздел 10). Размеры конвертов дополняются до классов 1, 2, 4, 8, 16 КиБ (раздел 9).
Группы: MLS, X-Wing и подписи ML-DSA-65 поверх
Группы работают на MLS (RFC 9420) через OpenMLS 0.9.2. Новые группы создаются на наборе MLS_256_XWING_CHACHA20POLY1305_SHA256_Ed25519 (код 0x004D из черновика IETF): KEM X-Wing — это X25519 + ML-KEM-768. Существующая группа сама переходит на X-Wing, как только его поддерживают все участники, — с тем же составом, историей и ключами подписи листьев. Поддержку определяет метка 0xF0D2 в возможностях листа, а не список наборов: старое ядро перечисляет 0x004D, не поддерживая его. Группа, где есть участник на 2.0.x, остаётся на MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519 (0x0001), и каждый групповой пакет к нему по-прежнему едет внутри его гибридного конверта 1:1.
Подписи участников MLS — Ed25519, как сегодня определяет стандарт. Поверх них приложение подписывает каждый Commit, Proposal и Welcome подписью ML-DSA-65. Обычные сообщения каждого отправителя складываются в хеш-цепочку (32 байта на сообщение), которую закрывает контрольная подпись ML-DSA-65 каждые 20 сообщений или после 30 секунд тишины (kotlin/.../crypto/GroupPqSig.kt:57-60, :131). Если участник однажды объявил такие подписи, неподписанное изменение от его имени отвергается. В тестах GroupPqSigTest (29) есть forkIsViolated и substitutedMiddleFrameIsViolated.
Ещё один механизм — регулярное обновление ключей: каждое устройство само обновляет свой лист раз в 7 дней (±12 часов), после 100 своих пакетов или после долгого простоя, поэтому группа восстанавливается даже без входов и выходов (GroupRekeyPolicy.kt, тесты pcs_rekey — 9 штук).
Цена (PQ_STATUS.md):
Что
Байт
Подпись ML-DSA-65 на Commit / Proposal
+4 429
Обычное сообщение (хеш-цепочка + контрольная подпись раз в 20)
около +275 в среднем
KeyPackage X-Wing
2 650
Welcome X-Wing на 100 листьев
268 368
Commit с путём обновления, 100 листьев
126 054
Ограничение состава (20 человек, до 100 листьев с компьютерами) проверяет каждый клиент, а не сервер: у сервера нет понятия группы, групповые сообщения расходятся по парным адресам ящиков.
Совместимость нового ядра со старым проверяется по-настоящему: tests/compat_v06.rs прогоняет смешанные группы против прежнего ядра на OpenMLS 0.6, а core/tests/vectors/openmls-0.6-state.json — сохранённое прежним ядром состояние, которое новое обязано открыть.
Звонки: второй постквантовый слой поверх DTLS-SRTP
У звонка два слоя шифрования. Первый — DTLS-SRTP из WebRTC: рукопожатие идёт напрямую между устройствами, сервер-ретранслятор (TURN) пересылает пакеты, которые не может открыть. Проблема в том, что DTLS согласует ключ классически, и записанный сегодня разговор квантовый компьютер мог бы открыть потом.
Поэтому каждый кадр звука, видео и показа экрана шифруется второй раз. На каждый звонок устройства делают свежий обмен X25519 + ML-KEM-1024. Открытые части обмена едут в настройке звонка (атрибут a=x-umbera-pq в SDP), а сама настройка — внутри гибридного конверта 1:1. Ключи привязаны к хешу всего обмена, у каждого направления свой ключ:
// core/src/callkey.rs, строки 74–86 · Apache-2.0fn derive(call_id: &str, public: &[u8], answer: &[u8], ss_x: &[u8], ss_k: &[u8], initiator: bool) -> Result { if ss_x.iter().all(|b| *b == 0) { return Err(bad("x25519 low-order point")); } let th = transcript(call_id, public, answer); let ikm = Zeroizing::new([ss_x, ss_k].concat()); let prk = Zeroizing::new(hkdf::Hkdf::::extract(Some(&th), &ikm).0.to_vec()); let exp = |info: &str, n: u32| p::hkdf_sha256_expand(prk.to_vec(), info.as_bytes().to_vec(), n); let i2r = exp("umbera-call-v1/frames/initiator->responder", 32)?; let r2i = exp("umbera-call-v1/frames/responder->initiator", 32)?; let check = exp("umbera-call-v1/check", 4)?; Ok(if initiator { CallFrameKeys { send: i2r, recv: r2i, check } } else { CallFrameKeys { send: r2i, recv: i2r, check } })}
Обратите внимание на проверку точки малого порядка: нулевой общий секрет X25519 — отказ, а не тихое продолжение.
Сам кадр шифруется AES-128-GCM в формате стандартного frame encryptor WebRTC; ключ — PBKDF2-HMAC-SHA256 (100 000 раундов) от 256-битного выхода гибридного обмена, отдельный для каждого направления (PQ_STATUS.md, строка 8 таблицы механизмов). Если вас смущает AES-128 в этом месте — это как раз то, на что стоит посмотреть критически, и мы будем рады разбору. Цена: 1601 байт обмена на каждое направление за звонок и около 0,46 мс на кадр (шифрование + расшифровка) на компьютере в тесте с петлёй.
Настройка звонка вместе с отпечатками DTLS зашифрована и подписана звонящим, поэтому сервер не может ни прочитать, ни подменить их — классическая атака «человек посередине» на WebRTC через подмену отпечатка не проходит. Тест DesktopCallPqLoopbackTest на настоящем WebRTC-соединении проверяет, что с чужим ключом отбрасывается каждый кадр, а старый собеседник по-прежнему подключается.
С собеседником на 2.0.x звонок идёт только на DTLS-SRTP.
Конференции и встречи по ссылке
Сервера, который смешивает или декодирует медиа, нет. В конференции участники соединяются попарно — напрямую или через ретранслятор, — и каждая пара делает свой обмен X25519 + ML-KEM-1024 со своими ключами кадров.
У встречи по ссылке есть 256-битный ключ комнаты, который живёт только во фрагменте ссылки после #. Фрагмент не уходит в веб-запросе, поэтому сервер получает лишь случайный номер комнаты. Из ключа выводятся отдельный ключ для описания комнаты и отдельный для сигналов внутри неё; сервер хранит то и другое только шифротекстом:
// kotlin/src/commonMain/kotlin/app/umbera/core/meet/MeetCrypto.kt, строки 28–34 · Apache-2.0 fun keys(roomKey: ByteArray): Keys { require(roomKey.size == MeetLinks.KEY_BYTES) return Keys( meta = RustCore.hkdfSha256(roomKey, SALT, "meta".encodeToByteArray(), 32u), sig = RustCore.hkdfSha256(roomKey, SALT, "sig".encodeToByteArray(), 32u), ) }
Медиа между каждой парой участников встречи защищено так же, как в конференции.
Как не дать серверу подменить ключ
Всё вышеописанное бессмысленно, если сервер отдаст вам вместо ключей собеседника свои. Здесь три линии защиты.
Код безопасности v2
Код безопасности сверяют лично или сканированием QR-кодов друг друга. Версия 1 покрывала только secp256k1 и X25519 — то есть сервер мог подменить постквантовые ключи, и сверка кодов этого бы не показала. Версия 2 покрывает все четыре ключа личности, каждый с длиной:
// kotlin/src/commonMain/kotlin/app/umbera/core/crypto/SafetyNumber.kt, строки 49–55 · Apache-2.0 private val V2_LABEL = "umbera-safety-number-v2".encodeToByteArray() fun identityV2(secp256k1: ByteArray, x25519: ByteArray, mlDsaPk: ByteArray, mlKemPk: ByteArray): String { var buf = V2_LABEL for (k in listOf(secp256k1, x25519, mlDsaPk, mlKemPk)) buf += lenBE(k.size) + k return HashUtils.sha256(buf).toHexLower() }
Версия 2 используется, когда оба собеседника объявили её внутри зашифрованных сообщений; на экране сверки тогда написано «Версия 2». Код должен совпасть с обеих сторон, поэтому со старым приложением остаётся версия 1.
Журнал ключей
Открытые ключи записываются в журнал прозрачности — дерево Меркла, куда можно только дописывать (PROTOCOL.md, раздел 14). Клиент проверяет доказательство включения относительно подписанной вершины дерева. Вершина подписывается Ed25519 и, с 16 ноября 2026 года на сервере, ещё и ML-DSA-65 по сообщению, которое включает и ключ Ed25519:
sth_message = "KT-STH-v1|" tree_size "|" root_hash "|" timestamp // Ed25519sth_pq_message = "KT-STH-PQ-v1|" tree_size "|" root_hash "|" timestamp "|" ed25519_pub // ML-DSA-65
Клиентская логика — в KeyTransparencyVerifier.kt (функция sthAuthentic, строки 67–77): если подпись ML-DSA-65 есть, она проверяется; когда ключ ML-DSA-65 журнала закреплён, вершина без действительной постквантовой подписи этого ключа отвергается. Без закреплённого ключа вершина только с Ed25519 принимается — это защита от отката «по первому использованию», и её слабое место очевидно: первое знакомство с журналом. Серверная половина закрыта, так что факт подписи на сервере вы проверяете по ответам сервера, а не по коду.
Важное ограничение: отсутствие записи в журнале пока не поднимает предупреждение — решающая проверка здесь код безопасности.
Без незаметного отката
Новый формат (конверт v3, храповик, слой кадров, X-Wing, подписи в группах, код безопасности v2) уходит собеседнику только после того, как он объявил поддержку внутри сообщения со сквозным шифрованием. Объявленная возможность закрепляется: если она потом пропадёт, приложение покажет «ключ изменился», а не откатится молча (PeerCryptoCapsPinTest, 15 тестов). Если сервер отдаёт другие ключи собеседника, в чате появляется предупреждение безопасности; сообщения и звонки продолжают работать, решение — за пользователем.
Привязка компьютера по QR-коду
С версией для компьютера появился ещё один канал, который надо было сделать постквантовым. QR-код несёт ключ X25519 компьютера и хеш SHA-256 его ключа ML-KEM-1024 (полный ключ передаётся отдельно и сверяется с хешем). Ключи сессии — HKDF по X25519 ‖ ML-KEM-1024 с солью из хеша всего транскрипта; обе стороны подтверждают ключ HMAC до любого обмена данными; на обоих экранах показывается 6-значный код из того же ключа. QR действует 60 секунд, подтверждение — 180 секунд. Телефон удостоверяет ключи компьютера ключом secp256k1 и ключом ML-DSA-65 аккаунта, а приложения принимают связанное устройство, только если проверяются обе подписи. Ключи аккаунта телефон не покидают.
Тесты: 26 штук в devlink::tests, среди них mitm_with_substituted_desktop_keys_shows_different_codes — подменённый ключ даёт разные коды на экранах.
Как проверить самому
Сборка и тесты
Нужен Rust 1.91 или новее. Собирается на Linux, macOS и Windows.
git clone https://github.com/UmberaAPP/UMBERAcd UMBERA/corecargo test --release# test result: ok. 63 passed (юнит-тесты)# test result: ok. 21 passed (compat_v06)# … всего 114 passed, 0 failed
По одному механизму:
cargo test --release --test proof # 1:1 печать: 7 тестовcargo test --release --test proof_groups # группы MLS: 6 тестовcargo test --release --lib xwing_ # группы X-Wingcargo test --release --test pcs_rekey # восстановление после компрометацииcargo test --release --test compat_v06 # новое ядро против прежнегоcargo test --release --lib sealv3:: # векторы конверта v3, общие с Kotlincargo test --release --lib callkey:: # ключи кадров звонкаcargo test --release --lib devlink:: # привязка компьютера по QRcargo test --release --lib pq_tests # эталонные ответы ML-KEM-1024 и ML-DSA-65cargo test --release --lib xwing_hundred_leaves_and_sizes -- --nocapture # печатает размеры X-Wing на 100 листьев
Форматы Сообществ проверяются независимой реализацией на Go — она читает те же векторы, что и клиент на Kotlin:
cd ../communities/pqcgo test -v ./...# PASS: TestVectorsFile, TestHybridNegatives
Для разборщиков чужих данных (Welcome и входящие MLS, привязка устройства, ключи звонка, жалобы, удаление метаданных PDF) есть цели фаззинга:
cargo install cargo-fuzzcd core/fuzzcargo +nightly fuzz run mls_welcome# другие цели: mls_incoming, devlink, callkey, amf_parse, pdf_strip
Тесты на Kotlin (SealV3Test, PqRatchetTest, GroupPqSigTest, SafetyNumberV2Test, DesktopCallPqLoopbackTest и другие) опубликованы исходниками, но запустить их из репозитория нельзя: им нужны платформенные привязки сборки приложения.
Что доказывают proof и proof_groups
tests/proof.rs воспроизводит гибридную печать на примитивах ядра и проверяет каждое свойство напрямую: получатель читает; шифротекст не содержит сообщения; чужие ключи не открывают; подделанное сообщение отвергается; каждое сообщение запечатано свежими ключами. Два главных теста — про гибрид:
// core/tests/proof.rs, строки 87–94 · Apache-2.0fn breaking_only_x25519_is_not_enough() { // An attacker who somehow learned Bob's X25519 key (for example with a future // quantum computer) still cannot open the message without his Kyber key. let bob = new_recipient(); let eve = new_recipient(); let sealed = seal(&bob, MESSAGE); assert_eq!(open(&bob.x25519_private, &eve.kyber_private, &sealed), None);}
и симметричный breaking_only_kyber_is_not_enough — с настоящим ключом ML-KEM, но чужим X25519 сообщение тоже не открывается.
tests/proof_groups.rs проверяет утверждения о группах: каждый участник читает сообщение; сервер видит только шифротекст; посторонний не читает — даже создав свою группу с тем же идентификатором; удалённый участник не читает новые сообщения; новый не читает старые; обновление ключа переводит группу в новую эпоху. Фрагмент про удалённого участника:
// core/tests/proof_groups.rs, строки 74–81 · Apache-2.0 let commit = alice.remove_members(gid.clone(), vec![carol_leaf]).unwrap(); assert!(matches!(bob.process_incoming(gid.clone(), commit.clone()).unwrap(), Incoming::CommitApplied)); // Carol even receives and processes the removal Commit herself. let _ = carol.process_incoming(gid.clone(), commit); let ct = alice.encrypt(gid.clone(), b"after carol left".to_vec()).unwrap(); assert_eq!(readable(bob.process_incoming(gid.clone(), ct.clone())), Some(b"after carol left".to_vec())); assert_eq!(readable(carol.process_incoming(gid.clone(), ct)), None, "a removed member must not read new epochs");
Важно понимать границы: proof.rs моделирует печать на примитивах ядра, а не запускает код приложения целиком. Он доказывает свойство схемы, а не то, что приложение из магазина делает именно это.
Эталонные векторы
Эталонный вектор фиксирует точный результат формулы на заданных входных данных: расхождение в один бит — тест падает. Самая сильная проверка — реализовать формулу по docs/PROTOCOL.md самостоятельно и сравнить с этими файлами.
Файл
Что закрепляет
Кто проверяет
core/tests/vectors/primitives-golden.json
SHA-256, HKDF, HMAC, PBKDF2, Argon2id, AES-GCM, X25519, Ed25519, secp256k1, ML-KEM-1024, ML-DSA-65
Rust
core/tests/vectors/seal-v3-vectors.txt
конверт v3 и короткий v3s, ключ файла, адрес ящика и его недельные эпохи
Rust, Kotlin
core/tests/vectors/link-vectors.json
привязка компьютера: рукопожатие, сертификат устройства, пакет переноса
Rust, Kotlin
core/tests/vectors/openmls-0.6-state.json
группа, сохранённая прежним ядром
Rust
communities/pqc/testdata/pq-vectors.json
Сообщества: гибридные подписи, ключи, посты приватных каналов
Kotlin, Go
Начало файла векторов конверта:
# core/tests/vectors/seal-v3-vectors.txt, строки 1–5 · Apache-2.0# Known-answer vectors for the 1:1 v3 / v3s envelope and the v2 file key.# Inputs: eph[i]=i+1 (32), ct[i]=i*7+3 (1568), rcpt_x[i]=0x40+i (32), rcpt_ek[i]=i*13+5 (1568),# ss_X25519[i]=0x80+i (32), ss_ML-KEM[i]=0xC0+i (32); bytes modulo 256.# Source of truth — Rust core/src/sealv3.rs (sha2 + hkdf); Kotlin SealV3Test.katMatchesRust — the same lines.KAT_TH = "3a83de5db60910cb810c32de542789131ee091507625fd39d8ff830fff6f0fa9"
Rust-тест sealv3::kat_matches_kotlin вычисляет эти значения на sha2 и hkdf напрямую, независимо от Kotlin, а Kotlin-тест SealV3Test.katMatchesRust сверяется с теми же строками.
Wireshark: свой трафик
Для этого не нужен наш код — нужна сеть, которую вы контролируете: раздайте интернет с ноутбука на телефон или запустите версию для компьютера и пишите трафик Wireshark.
-
Выпишите все адреса, к которым подключается приложение.
-
Отправьте сообщение из одной буквы, затем длинный абзац: размер отправки не следует за длиной текста, а попадает в несколько фиксированных классов.
-
Включите Tor в настройках и повторите: сообщения больше не идут на сервер напрямую — только в сеть Tor.
-
Позвоните и поставьте фильтр
dtls || rtp || srtp: будет рукопожатие DTLS и дальше только SRTP — ни открытого RTP, ни того, что Wireshark превратит в звук или картинку.
Чего запись трафика не покажет: второй слой звонка и содержимое конвертов находятся внутри шифра и выглядят как шум. Это проверяют тесты и векторы.
Что видит сервер
Не только чего он не видит, но и что видит. Код сервера закрыт, поэтому таблица описывает, что доходит до сервера по открытому коду клиента.
Таблица «Что видит сервер» со страницы umbera.app/verify
Данные
Сервер видит?
Почему
Текст, фото, файлы, голосовые, медиа звонков
нет
шифруется на устройстве, до сервера доходит только шифротекст
Кто отправил конверт
нет
отправитель запечатан внутри шифра
Для какого аккаунта конверт
нет
только адрес ящика, который вычисляют лишь двое
Кто в группе
нет
каждому участнику — отдельный конверт, в случайном порядке и с небольшой случайной задержкой
Точный размер
нет
только класс размера
Ключ встречи
нет
остаётся после # в ссылке; сервер видит случайный номер комнаты
Адреса ящиков и когда в них пишут и читают
да
без этого ничего не доставить
Открытые ключи и сколько компьютеров привязано к аккаунту
да
нужны отправителю, чтобы зашифровать для каждого устройства
Какие ящики принадлежат одному устройству
частично
без Tor все проверяются по одному соединению, с Tor — по разным цепочкам
IP-адрес
да / с Tor — нет
как любой сайт
Чего мы не утверждаем
Раздел «Чего мы не утверждаем» со страницы umbera.app/verify
-
Независимого аудита пока нет. Код открыт и покрыт тестами, но внешняя фирма его ещё не проверяла.
-
Сборки не воспроизводимы. Ядро собирается из исходников, но пересобрать приложение из магазина бит в бит и сравнить пока нельзя. До тех пор «приложение работает на этом коде» держится на нашем слове и на том, что вы наблюдаете сами. Мы сверили репозиторий с деревом сборки пофайлово — файлы ядра на Rust совпадают строка в строку, кроме переведённых комментариев, — но это наше утверждение, не ваша проверка.
-
Сервер и приложения закрыты. В репозитории лежит код, который решает, что может узнать сервер. Сервер, интерфейс и сетевой слой не опубликованы.
-
Без Tor сервер видит ваш IP-адрес. Tor выключен, пока его не включить. У самого Tor постквантового рукопожатия пока нет; то, что идёт внутри, зашифровано постквантово.
-
Со старыми приложениями — прежние схемы. С собеседником на 2.0.x звонки идут без второго слоя, группы — на прежнем наборе MLS, код безопасности — версии 1, адрес ящика не меняется. Сквозное шифрование при этом сохраняется.
-
Смена ключа предупреждает, но не блокирует. Отсутствие записи в журнале ключей пока не вызывает предупреждения.
-
Транспорт к серверу.
PQ_STATUS.mdописывает сквозное шифрование между устройствами, а не соединение с сервером. -
Взломанное устройство — вне модели. Шифрование защищает данные в пути и на сервере, но не на устройстве, которым управляет кто-то другой.
Сломайте это
Если код делает меньше, чем написано в PQ_STATUS.md, — это отчёт об уязвимости, а не «особенность». Об уязвимостях — закрыто, письмом на адрес из SECURITY.md с темой SECURITY; публичные вопросы и идеи — в Discussions на GitHub. В SECURITY.md указаны сроки: подтверждение получения — до 72 часов, первичная оценка — до 7 дней. Платной программы вознаграждений пока нет; каждая подтверждённая находка указывается в списке благодарностей и в заметках к выпуску.
С чего интересно начать, по мнению самого SECURITY.md: гибридное согласование X25519 + ML-KEM-1024, конверт v3, группы X-Wing, ключи кадров звонка, привязка компьютера по QR, скрытый отправитель, смена адресов ящиков и message franking. От себя добавлю: короткие конверты v3s (окно наследования постквантового секрета), закрепление ключа ML-DSA-65 журнала по первому использованию и выбор AES-128-GCM для кадров звонка.
Ссылки
-
Репозиторий: https://github.com/UmberaAPP/UMBERA
-
Постквантовый статус по механизмам: https://github.com/UmberaAPP/UMBERA/blob/main/docs/PQ_STATUS.md
-
Протокол: https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROTOCOL.md
-
Доказательства и проверки: https://github.com/UmberaAPP/UMBERA/blob/main/docs/PROOF.md
-
Политика безопасности: https://github.com/UmberaAPP/UMBERA/blob/main/SECURITY.md
-
Крейт: https://crates.io/crates/umbera-core
-
Страница «Проверьте каждое утверждение сами»: https://umbera.app/ru/verify
-
MLS: RFC 9420; ML-KEM: FIPS 203; ML-DSA: FIPS 204; X-Wing: draft-connolly-cfrg-xwing-kem; наборы MLS с постквантовыми KEM: draft-ietf-mls-pq-ciphersuites
Источник: habr.com