@telepapo/sdk 0.0.0-stage → 0.2.0

package/signal/fonte/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "telepapo-signal"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+libsignal-protocol = { git = "https://github.com/signalapp/libsignal", tag = "v0.105.4" }
+wasm-bindgen = "0.2"
+getrandom = { version = "0.3", features = ["wasm_js"] }
+getrandom02 = { package = "getrandom", version = "0.2", features = ["js"] }
+getrandom04 = { package = "getrandom", version = "0.4", features = ["wasm_js"] }
+rand = "0.9"
+futures = { version = "0.3", default-features = false, features = ["executor"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+base64 = "0.22"
+async-trait = "0.1"
+uuid = "1"
+
+[profile.release]
+opt-level = "s"
+lto = true

package/signal/fonte/LEIAME.md

@@ -0,0 +1,14 @@
+# Código-fonte do `telepapo_signal_bg.wasm`
+
+O WebAssembly em `../` é compilado deste crate Rust, que usa o
+[libsignal](https://github.com/signalapp/libsignal) v0.105.4 (AGPL-3.0).
+Distribuído aqui como a fonte correspondente exigida pela AGPL-3.0.
+
+Para compilar (Rust com o alvo `wasm32-unknown-unknown`, `wasm-pack` e `protoc`):
+
+```bash
+RUSTFLAGS='--cfg getrandom_backend="wasm_js"' wasm-pack build --target nodejs --release
+```
+
+O binário publicado foi compilado com `--remap-path-prefix` (os caminhos de
+origem viram `/cargo`, `/rustup` e `/signal-wasm`), o que não muda o código gerado.

package/signal/fonte/src/lib.rs

@@ -0,0 +1,510 @@
+//! Signal (libsignal 0.105) para o navegador: o mesmo protocolo do app Android,
+//! compilado para WebAssembly.
+//!
+//! O estado inteiro (identidade, pré-chaves, sessões) vive num `Estado`
+//! serializável: o JavaScript chama `exportar()` depois de cada operação que
+//! muda alguma coisa e guarda o JSON no IndexedDB. As lojas do libsignal são
+//! `async`, mas aqui nada espera de verdade — `block_on` resolve na hora.
+
+use std::collections::BTreeMap;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use async_trait::async_trait;
+use base64::{Engine, engine::general_purpose::STANDARD as B64};
+use futures::executor::block_on;
+use libsignal_protocol::{
+    CiphertextMessage, DeviceId, Direction, GenericSignedPreKey, IdentityChange, IdentityKey, IdentityKeyPair,
+    IdentityKeyStore, KeyPair, KyberPreKeyId, KyberPreKeyRecord, KyberPreKeyStore, PreKeyBundle, PreKeyId,
+    PreKeyRecord, PreKeySignalMessage, PreKeyStore, ProtocolAddress, PublicKey, SessionRecord, SessionStore,
+    SignalMessage, SignalProtocolError, SignedPreKeyId, SignedPreKeyRecord, SignedPreKeyStore, Timestamp, kem,
+    message_decrypt_prekey, message_decrypt_signal, message_encrypt, process_prekey_bundle,
+};
+use rand::{Rng, TryRngCore, rngs::OsRng};
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+
+type Res<T> = Result<T, SignalProtocolError>;
+
+fn erro(e: impl std::fmt::Display) -> JsError {
+    JsError::new(&e.to_string())
+}
+
+fn b64(b: &[u8]) -> String {
+    B64.encode(b)
+}
+
+fn de_b64(s: &str) -> Result<Vec<u8>, JsError> {
+    B64.decode(s).map_err(erro)
+}
+
+/// O relógio vem do JavaScript: `SystemTime::now()` não existe no wasm32.
+fn agora(ms: f64) -> SystemTime {
+    UNIX_EPOCH + Duration::from_millis(ms as u64)
+}
+
+fn chave_endereco(a: &ProtocolAddress) -> String {
+    format!("{}.{}", a.name(), u32::from(a.device_id()))
+}
+
+fn endereco(usuario: &str, dispositivo: u32) -> Result<ProtocolAddress, JsError> {
+    let d = DeviceId::try_from(dispositivo).map_err(|_| JsError::new("dispositivo inválido"))?;
+    Ok(ProtocolAddress::new(usuario.to_owned(), d))
+}
+
+#[derive(Serialize, Deserialize, Default, Clone)]
+struct Kyber {
+    registro: String,
+    ultimo_recurso: bool,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone)]
+struct Estado {
+    identidade: String,
+    registration_id: u32,
+    /// Endereço deste navegador (conta + número do aparelho), definido no vínculo.
+    usuario: String,
+    dispositivo: u32,
+    identidades: BTreeMap<String, String>,
+    prekeys: BTreeMap<u32, String>,
+    signed: BTreeMap<u32, String>,
+    kyber: BTreeMap<u32, Kyber>,
+    /// Chaves base já vistas com cada Kyber de último recurso (anti-replay).
+    kyber_vistos: BTreeMap<String, Vec<String>>,
+    sessoes: BTreeMap<String, String>,
+    proximo_prekey: u32,
+    proximo_signed: u32,
+    proximo_kyber: u32,
+    /// Contatos que trocaram de identidade (app reinstalado): o JS lê e avisa.
+    #[serde(default)]
+    trocas: Vec<String>,
+}
+
+fn corrompido(o_que: &str) -> SignalProtocolError {
+    SignalProtocolError::InvalidState("estado", format!("{o_que} corrompido"))
+}
+
+#[async_trait(?Send)]
+impl IdentityKeyStore for Estado {
+    async fn get_identity_key_pair(&self) -> Res<IdentityKeyPair> {
+        let b = B64.decode(&self.identidade).map_err(|_| corrompido("identidade"))?;
+        IdentityKeyPair::try_from(b.as_slice())
+    }
+
+    async fn get_local_registration_id(&self) -> Res<u32> {
+        Ok(self.registration_id)
+    }
+
+    async fn save_identity(&mut self, a: &ProtocolAddress, id: &IdentityKey) -> Res<IdentityChange> {
+        let nova = b64(&id.serialize());
+        let antiga = self.identidades.insert(chave_endereco(a), nova.clone());
+        Ok(match antiga {
+            Some(v) if v != nova => {
+                self.trocas.push(a.name().to_owned());
+                IdentityChange::ReplacedExisting
+            }
+            _ => IdentityChange::NewOrUnchanged,
+        })
+    }
+
+    /// Como no app: confia sempre (a troca de identidade vira aviso na conversa).
+    async fn is_trusted_identity(&self, _: &ProtocolAddress, _: &IdentityKey, _: Direction) -> Res<bool> {
+        Ok(true)
+    }
+
+    async fn get_identity(&self, a: &ProtocolAddress) -> Res<Option<IdentityKey>> {
+        match self.identidades.get(&chave_endereco(a)) {
+            None => Ok(None),
+            Some(v) => {
+                let b = B64.decode(v).map_err(|_| corrompido("identidade remota"))?;
+                Ok(Some(IdentityKey::decode(&b)?))
+            }
+        }
+    }
+}
+
+#[async_trait(?Send)]
+impl PreKeyStore for Estado {
+    async fn get_pre_key(&self, id: PreKeyId) -> Res<PreKeyRecord> {
+        let v = self.prekeys.get(&u32::from(id)).ok_or(SignalProtocolError::InvalidPreKeyId)?;
+        PreKeyRecord::deserialize(&B64.decode(v).map_err(|_| corrompido("prekey"))?)
+    }
+
+    async fn save_pre_key(&mut self, id: PreKeyId, r: &PreKeyRecord) -> Res<()> {
+        self.prekeys.insert(u32::from(id), b64(&r.serialize()?));
+        Ok(())
+    }
+
+    /// Uso único: usada, apagada (sigilo futuro).
+    async fn remove_pre_key(&mut self, id: PreKeyId) -> Res<()> {
+        self.prekeys.remove(&u32::from(id));
+        Ok(())
+    }
+}
+
+#[async_trait(?Send)]
+impl SignedPreKeyStore for Estado {
+    async fn get_signed_pre_key(&self, id: SignedPreKeyId) -> Res<SignedPreKeyRecord> {
+        let v = self.signed.get(&u32::from(id)).ok_or(SignalProtocolError::InvalidSignedPreKeyId)?;
+        SignedPreKeyRecord::deserialize(&B64.decode(v).map_err(|_| corrompido("signed"))?)
+    }
+
+    async fn save_signed_pre_key(&mut self, id: SignedPreKeyId, r: &SignedPreKeyRecord) -> Res<()> {
+        self.signed.insert(u32::from(id), b64(&r.serialize()?));
+        Ok(())
+    }
+}
+
+#[async_trait(?Send)]
+impl KyberPreKeyStore for Estado {
+    async fn get_kyber_pre_key(&self, id: KyberPreKeyId) -> Res<KyberPreKeyRecord> {
+        let v = self.kyber.get(&u32::from(id)).ok_or(SignalProtocolError::InvalidKyberPreKeyId)?;
+        KyberPreKeyRecord::deserialize(&B64.decode(&v.registro).map_err(|_| corrompido("kyber"))?)
+    }
+
+    async fn save_kyber_pre_key(&mut self, id: KyberPreKeyId, r: &KyberPreKeyRecord) -> Res<()> {
+        self.kyber.insert(u32::from(id), Kyber { registro: b64(&r.serialize()?), ultimo_recurso: false });
+        Ok(())
+    }
+
+    /// De uso único: apaga. De último recurso: fica, mas a mesma chave base não
+    /// pode voltar (seria a mesma mensagem inicial reapresentada).
+    async fn mark_kyber_pre_key_used(&mut self, id: KyberPreKeyId, ec: SignedPreKeyId, base: &PublicKey) -> Res<()> {
+        let n = u32::from(id);
+        let Some(k) = self.kyber.get(&n) else { return Ok(()) };
+        if !k.ultimo_recurso {
+            self.kyber.remove(&n);
+            return Ok(());
+        }
+        let vistos = self.kyber_vistos.entry(format!("{n}.{}", u32::from(ec))).or_default();
+        let base = b64(&base.serialize());
+        if vistos.contains(&base) {
+            return Err(SignalProtocolError::InvalidMessage(
+                libsignal_protocol::CiphertextMessageType::PreKey,
+                "reused base key".to_owned(),
+            ));
+        }
+        vistos.push(base);
+        Ok(())
+    }
+}
+
+#[async_trait(?Send)]
+impl SessionStore for Estado {
+    async fn load_session(&self, a: &ProtocolAddress) -> Res<Option<SessionRecord>> {
+        match self.sessoes.get(&chave_endereco(a)) {
+            None => Ok(None),
+            Some(v) => Ok(Some(SessionRecord::deserialize(&B64.decode(v).map_err(|_| corrompido("sessão"))?)?)),
+        }
+    }
+
+    async fn store_session(&mut self, a: &ProtocolAddress, r: &SessionRecord) -> Res<()> {
+        self.sessoes.insert(chave_endereco(a), b64(&r.serialize()?));
+        Ok(())
+    }
+}
+
+// ------------------------------------------------------------ formatos do servidor
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PreKeyDto {
+    key_id: u32,
+    public_key: String,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AssinadaDto {
+    key_id: u32,
+    public_key: String,
+    assinatura: String,
+}
+
+/// O `ChavesDoDispositivoDto` da API.
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ChavesDto {
+    registration_id: u32,
+    identity_key: String,
+    signed_pre_key: AssinadaDto,
+    kyber_ultimo_recurso: AssinadaDto,
+    pre_keys: Vec<PreKeyDto>,
+    kyber_pre_keys: Vec<AssinadaDto>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ReposicaoDto {
+    pre_keys: Vec<PreKeyDto>,
+    kyber_pre_keys: Vec<AssinadaDto>,
+}
+
+/// Um pacote de `GET /v1/chaves/:usuarioId`.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PacoteDto {
+    dispositivo: u32,
+    registration_id: u32,
+    identity_key: String,
+    signed_pre_key: AssinadaDto,
+    pre_key: Option<PreKeyDto>,
+    kyber_pre_key: AssinadaDto,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct Cifrado {
+    tipo: &'static str,
+    conteudo: String,
+    registration_id: u32,
+}
+
+const LOTE: usize = 50;
+const LOTE_KYBER: usize = 20;
+/// Ids de pré-chave cabem em 24 bits (limite do DTO do servidor).
+const MAX_ID: u32 = 0xff_fff0;
+
+fn proximo(contador: &mut u32) -> u32 {
+    if *contador == 0 || *contador >= MAX_ID {
+        *contador = 1 + rand::rng().random_range(0..0x7f_ffff);
+    }
+    let id = *contador;
+    *contador += 1;
+    id
+}
+
+#[wasm_bindgen]
+pub struct Signal {
+    e: Estado,
+}
+
+impl Signal {
+    fn par(&self) -> Result<IdentityKeyPair, JsError> {
+        block_on(self.e.get_identity_key_pair()).map_err(erro)
+    }
+
+    fn local(&self) -> Result<ProtocolAddress, JsError> {
+        if self.e.usuario.is_empty() {
+            return Err(JsError::new("navegador ainda não vinculado"));
+        }
+        endereco(&self.e.usuario, self.e.dispositivo)
+    }
+
+    fn nova_signed(&mut self, ms: f64) -> Result<AssinadaDto, JsError> {
+        let par = self.par()?;
+        let id = proximo(&mut self.e.proximo_signed);
+        let mut rng = OsRng.unwrap_err();
+        let chaves = KeyPair::generate(&mut rng);
+        let assinatura = par.private_key().calculate_signature(&chaves.public_key.serialize(), &mut rng).map_err(erro)?;
+        let r = SignedPreKeyRecord::new(id.into(), Timestamp::from_epoch_millis(ms as u64), &chaves, &assinatura);
+        self.e.signed.insert(id, b64(&r.serialize().map_err(erro)?));
+        Ok(AssinadaDto { key_id: id, public_key: b64(&chaves.public_key.serialize()), assinatura: b64(&assinatura) })
+    }
+
+    fn nova_kyber(&mut self, ms: f64, ultimo_recurso: bool) -> Result<AssinadaDto, JsError> {
+        let par = self.par()?;
+        let id = proximo(&mut self.e.proximo_kyber);
+        let mut rng = OsRng.unwrap_err();
+        let chaves = kem::KeyPair::generate(kem::KeyType::Kyber1024, &mut rng);
+        let publica = chaves.public_key.serialize();
+        let assinatura = par.private_key().calculate_signature(&publica, &mut rng).map_err(erro)?;
+        let r = KyberPreKeyRecord::new(id.into(), Timestamp::from_epoch_millis(ms as u64), &chaves, &assinatura);
+        self.e.kyber.insert(id, Kyber { registro: b64(&r.serialize().map_err(erro)?), ultimo_recurso });
+        Ok(AssinadaDto { key_id: id, public_key: b64(&publica), assinatura: b64(&assinatura) })
+    }
+
+    fn novas_prekeys(&mut self, quantas: usize) -> Result<Vec<PreKeyDto>, JsError> {
+        let mut rng = OsRng.unwrap_err();
+        (0..quantas)
+            .map(|_| {
+                let id = proximo(&mut self.e.proximo_prekey);
+                let chaves = KeyPair::generate(&mut rng);
+                let r = PreKeyRecord::new(id.into(), &chaves);
+                self.e.prekeys.insert(id, b64(&r.serialize().map_err(erro)?));
+                Ok(PreKeyDto { key_id: id, public_key: b64(&chaves.public_key.serialize()) })
+            })
+            .collect()
+    }
+}
+
+#[wasm_bindgen]
+impl Signal {
+    /// Identidade nova (navegador nunca vinculado).
+    #[wasm_bindgen(js_name = novo)]
+    pub fn novo() -> Signal {
+        let mut rng = OsRng.unwrap_err();
+        let par = IdentityKeyPair::generate(&mut rng);
+        let e = Estado {
+            identidade: b64(&par.serialize()),
+            // 14 bits, nunca zero (igual ao app).
+            registration_id: 1 + rng.random_range(0..16380),
+            ..Default::default()
+        };
+        Signal { e }
+    }
+
+    #[wasm_bindgen(js_name = carregar)]
+    pub fn carregar(json: &str) -> Result<Signal, JsError> {
+        Ok(Signal { e: serde_json::from_str(json).map_err(erro)? })
+    }
+
+    pub fn exportar(&self) -> Result<String, JsError> {
+        serde_json::to_string(&self.e).map_err(erro)
+    }
+
+    /// Pacote inicial (o `chaves` do pedido de vínculo), no formato da API.
+    #[wasm_bindgen(js_name = chavesIniciais)]
+    pub fn chaves_iniciais(&mut self, ms: f64) -> Result<String, JsError> {
+        let signed = self.nova_signed(ms)?;
+        let ultimo = self.nova_kyber(ms, true)?;
+        let pre_keys = self.novas_prekeys(LOTE)?;
+        let kyber_pre_keys = (0..LOTE_KYBER).map(|_| self.nova_kyber(ms, false)).collect::<Result<Vec<_>, _>>()?;
+        let par = self.par()?;
+        serde_json::to_string(&ChavesDto {
+            registration_id: self.e.registration_id,
+            identity_key: b64(&par.identity_key().serialize()),
+            signed_pre_key: signed,
+            kyber_ultimo_recurso: ultimo,
+            pre_keys,
+            kyber_pre_keys,
+        })
+        .map_err(erro)
+    }
+
+    /// Reposição de pré-chaves (`PUT /v1/chaves`).
+    #[wasm_bindgen(js_name = reposicao)]
+    pub fn reposicao(&mut self, ms: f64, pre_keys: usize, kyber: usize) -> Result<String, JsError> {
+        let pre_keys = self.novas_prekeys(pre_keys.min(100))?;
+        let kyber_pre_keys = (0..kyber.min(100)).map(|_| self.nova_kyber(ms, false)).collect::<Result<Vec<_>, _>>()?;
+        serde_json::to_string(&ReposicaoDto { pre_keys, kyber_pre_keys }).map_err(erro)
+    }
+
+    /// Chave pública de identidade (base64): vai no QR para o celular conferir.
+    #[wasm_bindgen(js_name = identidadePublica)]
+    pub fn identidade_publica(&self) -> Result<String, JsError> {
+        Ok(b64(&self.par()?.identity_key().serialize()))
+    }
+
+    #[wasm_bindgen(js_name = registrationId)]
+    pub fn registration_id(&self) -> u32 {
+        self.e.registration_id
+    }
+
+    /// Depois do vínculo: o endereço deste navegador.
+    #[wasm_bindgen(js_name = definirEndereco)]
+    pub fn definir_endereco(&mut self, usuario: &str, dispositivo: u32) -> Result<(), JsError> {
+        endereco(usuario, dispositivo)?;
+        self.e.usuario = usuario.to_owned();
+        self.e.dispositivo = dispositivo;
+        Ok(())
+    }
+
+    /// X3DH + Kyber (PQXDH): o libsignal confere as assinaturas e recusa pacote forjado.
+    #[wasm_bindgen(js_name = abrirSessao)]
+    pub fn abrir_sessao(&mut self, usuario: &str, pacote_json: &str, ms: f64) -> Result<(), JsError> {
+        let p: PacoteDto = serde_json::from_str(pacote_json).map_err(erro)?;
+        let device = DeviceId::try_from(p.dispositivo).map_err(|_| JsError::new("dispositivo inválido"))?;
+        let pre_key = match &p.pre_key {
+            None => None,
+            Some(k) => Some((PreKeyId::from(k.key_id), PublicKey::deserialize(&de_b64(&k.public_key)?).map_err(erro)?)),
+        };
+        let pacote = PreKeyBundle::new(
+            p.registration_id,
+            device,
+            pre_key,
+            p.signed_pre_key.key_id.into(),
+            PublicKey::deserialize(&de_b64(&p.signed_pre_key.public_key)?).map_err(erro)?,
+            de_b64(&p.signed_pre_key.assinatura)?,
+            p.kyber_pre_key.key_id.into(),
+            kem::PublicKey::deserialize(&de_b64(&p.kyber_pre_key.public_key)?).map_err(erro)?,
+            de_b64(&p.kyber_pre_key.assinatura)?,
+            IdentityKey::decode(&de_b64(&p.identity_key)?).map_err(erro)?,
+        )
+        .map_err(erro)?;
+        let remoto = endereco(usuario, p.dispositivo)?;
+        let local = self.local()?;
+        let mut rng = OsRng.unwrap_err();
+        // A mesma loja faz papel de sessões e identidades: cópia para o segundo `&mut`.
+        let mut ids = self.e.clone();
+        block_on(process_prekey_bundle(&remoto, &local, &mut self.e, &mut ids, &pacote, agora(ms), &mut rng)).map_err(erro)?;
+        self.e.identidades = ids.identidades;
+        self.e.trocas = ids.trocas;
+        Ok(())
+    }
+
+    /// Números dos aparelhos de alguém com quem há sessão.
+    #[wasm_bindgen(js_name = dispositivosComSessao)]
+    pub fn dispositivos_com_sessao(&self, usuario: &str) -> Vec<u32> {
+        let prefixo = format!("{usuario}.");
+        self.e
+            .sessoes
+            .keys()
+            .filter_map(|k| k.strip_prefix(&prefixo).and_then(|n| n.parse().ok()))
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = apagarSessao)]
+    pub fn apagar_sessao(&mut self, usuario: &str, dispositivo: u32) {
+        self.e.sessoes.remove(&format!("{usuario}.{dispositivo}"));
+    }
+
+    /// Cifra para um aparelho: `{tipo: PREKEY|WHISPER, conteudo, registrationId}`.
+    pub fn cifrar(&mut self, usuario: &str, dispositivo: u32, claro: &[u8], ms: f64) -> Result<String, JsError> {
+        let remoto = endereco(usuario, dispositivo)?;
+        let local = self.local()?;
+        let mut rng = OsRng.unwrap_err();
+        let mut ids = self.e.clone();
+        let msg = block_on(message_encrypt(claro, &remoto, &local, &mut self.e, &mut ids, agora(ms), &mut rng)).map_err(erro)?;
+        self.e.identidades = ids.identidades;
+        self.e.trocas = ids.trocas;
+        let registro = block_on(self.e.load_session(&remoto)).map_err(erro)?.ok_or_else(|| JsError::new("sem sessão"))?;
+        let tipo = match msg {
+            CiphertextMessage::PreKeySignalMessage(_) => "PREKEY",
+            _ => "WHISPER",
+        };
+        serde_json::to_string(&Cifrado {
+            tipo,
+            conteudo: b64(msg.serialize()),
+            registration_id: registro.remote_registration_id().map_err(erro)?,
+        })
+        .map_err(erro)
+    }
+
+    /// Decifra um envelope. Erro com "duplicate" no texto = mensagem repetida.
+    pub fn decifrar(&mut self, usuario: &str, dispositivo: u32, tipo: &str, conteudo_b64: &str) -> Result<Vec<u8>, JsError> {
+        let remoto = endereco(usuario, dispositivo)?;
+        let local = self.local()?;
+        let bytes = de_b64(conteudo_b64)?;
+        let mut rng = OsRng.unwrap_err();
+        // Loja de trabalho: só vale se a decifragem der certo (falha não estraga a sessão).
+        let mut trabalho = self.e.clone();
+        let mut ids = self.e.clone();
+        let claro = if tipo == "PREKEY" {
+            let m = PreKeySignalMessage::try_from(bytes.as_slice()).map_err(erro)?;
+            let mut pre = self.e.clone();
+            let mut kyber = self.e.clone();
+            let signed = self.e.clone();
+            let r = block_on(message_decrypt_prekey(
+                &m, &remoto, &local, &mut trabalho, &mut ids, &mut pre, &signed, &mut kyber, &mut rng,
+            ))
+            .map_err(erro)?;
+            trabalho.prekeys = pre.prekeys;
+            trabalho.kyber = kyber.kyber;
+            trabalho.kyber_vistos = kyber.kyber_vistos;
+            r
+        } else {
+            let m = SignalMessage::try_from(bytes.as_slice()).map_err(erro)?;
+            block_on(message_decrypt_signal(&m, &remoto, &local, &mut trabalho, &mut ids, &mut rng)).map_err(erro)?
+        };
+        trabalho.identidades = ids.identidades;
+        trabalho.trocas = ids.trocas;
+        self.e = trabalho;
+        Ok(claro)
+    }
+
+    /// Contatos que trocaram de identidade desde a última leitura.
+    #[wasm_bindgen(js_name = lerTrocas)]
+    pub fn ler_trocas(&mut self) -> Vec<String> {
+        std::mem::take(&mut self.e.trocas)
+    }
+}

package/signal/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/signal/telepapo_signal.d.ts

@@ -0,0 +1,52 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Signal {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * X3DH + Kyber (PQXDH): o libsignal confere as assinaturas e recusa pacote forjado.
+     */
+    abrirSessao(usuario: string, pacote_json: string, ms: number): void;
+    apagarSessao(usuario: string, dispositivo: number): void;
+    static carregar(json: string): Signal;
+    /**
+     * Pacote inicial (o `chaves` do pedido de vínculo), no formato da API.
+     */
+    chavesIniciais(ms: number): string;
+    /**
+     * Cifra para um aparelho: `{tipo: PREKEY|WHISPER, conteudo, registrationId}`.
+     */
+    cifrar(usuario: string, dispositivo: number, claro: Uint8Array, ms: number): string;
+    /**
+     * Decifra um envelope. Erro com "duplicate" no texto = mensagem repetida.
+     */
+    decifrar(usuario: string, dispositivo: number, tipo: string, conteudo_b64: string): Uint8Array;
+    /**
+     * Depois do vínculo: o endereço deste navegador.
+     */
+    definirEndereco(usuario: string, dispositivo: number): void;
+    /**
+     * Números dos aparelhos de alguém com quem há sessão.
+     */
+    dispositivosComSessao(usuario: string): Uint32Array;
+    exportar(): string;
+    /**
+     * Chave pública de identidade (base64): vai no QR para o celular conferir.
+     */
+    identidadePublica(): string;
+    /**
+     * Contatos que trocaram de identidade desde a última leitura.
+     */
+    lerTrocas(): string[];
+    /**
+     * Identidade nova (navegador nunca vinculado).
+     */
+    static novo(): Signal;
+    registrationId(): number;
+    /**
+     * Reposição de pré-chaves (`PUT /v1/chaves`).
+     */
+    reposicao(ms: number, pre_keys: number, kyber: number): string;
+}