Skip to main content

qualia_mobile_harness/
companion_device.rs

1//! Persistent companion device identity + Ed25519 challenge signing.
2
3use ed25519_dalek::{Signer, SigningKey};
4use wellfare_core::companion_pairing::{
5    CompanionChallenge, CompanionPairingResponse, COMPANION_PAIRING_CONTEXT,
6};
7
8const DEVICE_ID_KEY: &str = "qualia-companion-device-id";
9const DEVICE_SEED_KEY: &str = "qualia-companion-device-seed";
10
11#[wasm_bindgen::prelude::wasm_bindgen(inline_js = r#"
12    export function persistCompanionValue(key, value) {
13        localStorage.setItem(key, value);
14    }
15    export function loadCompanionValue(key) {
16        return localStorage.getItem(key) || "";
17    }
18"#)]
19extern "C" {
20    fn persistCompanionValue(key: &str, value: &str);
21    fn loadCompanionValue(key: &str) -> String;
22}
23
24/// `device` ID.
25pub fn device_id() -> String {
26    let stored = loadCompanionValue(DEVICE_ID_KEY);
27    if !stored.is_empty() {
28        return stored;
29    }
30    let id = format!("phone-{}", js_sys::Math::random());
31    persistCompanionValue(DEVICE_ID_KEY, &id);
32    id
33}
34
35fn signing_key() -> SigningKey {
36    let stored = loadCompanionValue(DEVICE_SEED_KEY);
37    if stored.len() == 64 {
38        if let Ok(bytes) = hex::decode(&stored) {
39            if bytes.len() == 32 {
40                let mut seed = [0u8; 32];
41                seed.copy_from_slice(&bytes);
42                return SigningKey::from_bytes(&seed);
43            }
44        }
45    }
46
47    let mut seed = [0u8; 32];
48    getrandom::fill(&mut seed).expect("OS random for companion device seed");
49    persistCompanionValue(DEVICE_SEED_KEY, &hex::encode(seed));
50    SigningKey::from_bytes(&seed)
51}
52
53/// Builds pairing-response.
54pub fn build_pairing_response(challenge_json: &str) -> Result<String, String> {
55    let challenge: CompanionChallenge =
56        serde_json::from_str(challenge_json).map_err(|e| format!("invalid challenge: {e}"))?;
57    if challenge.context != COMPANION_PAIRING_CONTEXT {
58        return Err("unexpected pairing context".into());
59    }
60    let nonce = hex::decode(&challenge.nonce_hex).map_err(|e| format!("bad nonce: {e}"))?;
61    if nonce.len() != 32 {
62        return Err("challenge nonce must be 32 bytes".into());
63    }
64
65    let key = signing_key();
66    let mut payload = Vec::with_capacity(challenge.context.len() + 1 + nonce.len());
67    payload.extend_from_slice(challenge.context.as_bytes());
68    payload.push(0);
69    payload.extend_from_slice(&nonce);
70    let signature = key.sign(&payload);
71
72    let response = CompanionPairingResponse::new(
73        device_id(),
74        hex::encode(key.verifying_key().to_bytes()),
75        hex::encode(signature.to_bytes()),
76    );
77    serde_json::to_string(&response).map_err(|e| e.to_string())
78}