lox/crates/lox-wasm/src/lib.rs

use lox::cred::Lox;
use lox::bridge_table::BridgeLine;
use lox::proto::{open_invite, trust_promotion};
use lox::{IssuerPubKey, OPENINV_LENGTH};
use serde::{Deserialize, Serialize};
use serde_json;
//use serde_wasm_bindgen;
use std::array::TryFromSliceError;
use std::panic;
use wasm_bindgen::prelude::*;

#[derive(Deserialize, Serialize)]
struct OpenReqState {
    request: open_invite::Request,
    state: open_invite::State,
}

#[derive(Deserialize, Serialize)]
struct TrustReqState {
    request: trust_promotion::Request,
    state: trust_promotion::State,
}

#[derive(Debug, Deserialize, Serialize)]
struct PubKeys {
    lox_pub: IssuerPubKey,
    migration_pub: IssuerPubKey,
    migrationkey_pub: IssuerPubKey,
    reachability_pub: IssuerPubKey,
    invitation_pub: IssuerPubKey,
}

#[derive(Debug, Deserialize, Serialize)]
struct Credential {
    lox_credential: Lox,
    bridgeline: BridgeLine,
}

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_namespace = console)]
    pub fn log(s: &str);
}

#[wasm_bindgen]
pub fn set_panic_hook() {
    panic::set_hook(Box::new(console_error_panic_hook::hook));
}

#[wasm_bindgen]
pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
    unsafe {
        log(&format!("Using invite: {:?}", invite));
    }
    let token = match validate(invite) {
        Ok(token) => token,
        Err(e) => return Err(JsValue::from(e.to_string())),
    };
    let (request, state) = open_invite::request(&token);
    let req_state = OpenReqState {
        request: request,
        state: state,
    };
    unsafe {
        log(&format!(
            "Formatted open invite request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    Ok(serde_json::to_string(&req_state).unwrap())
}

#[wasm_bindgen]
pub fn handle_new_lox_credential(
    open_lox_result: String,
    open_lox_response: String,
    lox_pub: String,
) -> Result<String, JsValue> {
    let req_state: OpenReqState = serde_json::from_str(&open_lox_result).unwrap();
    let deserialized_state = req_state.state;
    let deserialized_response = serde_json::from_str(&open_lox_response).unwrap();
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    let lox_cred = match open_invite::handle_response(
        deserialized_state,
        deserialized_response,
        &pubkeys.lox_pub,
    ) {
        Ok(lox_cred) => lox_cred,
        Err(e) => {
            log(&format!("Error: {:?}", e.to_string()));
            return Err(JsValue::from(e.to_string()));
        }
    };
    let lox_cred = Credential {
        lox_credential: lox_cred.0,
        bridgeline: lox_cred.1,
    };
    unsafe {
        log(&format!(
            "Got new Lox Credential: {}",
            serde_json::to_string(&lox_cred.lox_credential).unwrap()
        ));
        log(&format!("Got new bridgeline: {}", serde_json::to_string(&lox_cred.bridgeline).unwrap()));
    }
    Ok(serde_json::to_string(&lox_cred).unwrap())
}


#[wasm_bindgen]
pub fn trust_promotion(open_lox_cred: String, lox_pub: String) -> String {
    let lox_cred: Credential = serde_json::from_str(&open_lox_cred).unwrap();
    let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
    let (request, state) = trust_promotion::request(&lox_cred.lox_credential, &pubkeys.lox_pub, today()).unwrap();
    let req_state = TrustReqState {
        request: request,
        state: state,
    };
    unsafe {
        log(&format!(
            "Formatted open invite request: {}",
            serde_json::to_string(&req_state).unwrap()
        ));
    }
    serde_json::to_string(&req_state).unwrap()
}


#[wasm_bindgen]
pub fn handle_trust_promotion(
    trust_promo_request: String,
    trust_promo_response: String,
) -> Result<String, JsValue> {
    let req_state: TrustReqState = serde_json::from_str(&trust_promo_request).unwrap();
    let deserialized_state = req_state.state;
    let deserialized_response = serde_json::from_str(&trust_promo_response).unwrap();
    let migration_cred = match trust_promotion::handle_response(
        deserialized_state,
        deserialized_response,
    ) {
        Ok(migration_cred) => migration_cred,
        Err(e) => {
            log(&format!("Error: {:?}", e.to_string()));
            return Err(JsValue::from(e.to_string()));
        }
    };
    unsafe {
        log(&format!(
            "Got new Migration Credential: {}",
            serde_json::to_string(&migration_cred).unwrap()
        ));
    }
    Ok(serde_json::to_string(&migration_cred).unwrap())
}



// This should also check the pubkey
fn validate(invite: &[u8]) -> Result<[u8; OPENINV_LENGTH], TryFromSliceError> {
    invite.try_into()
}

/// Get today's (real or simulated) date
fn today() -> u32 {
    // We will not encounter negative Julian dates (~6700 years ago)
    // or ones larger than 32 bits
        (time::OffsetDateTime::now_utc().date())
            .julian_day()
            .try_into()
            .unwrap()
    }