vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix serialization of request/state

This commit is contained in:
onyinyang 2023-01-30 16:03:12 -05:00
parent d0388c841a
commit efbc822be6
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
1 changed files with 22 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
crates/lox-wasm/src/lib.rs
View File

@ -8,10 +8,16 @@ use std::array::TryFromSliceError;
use std::panic;
use wasm_bindgen::prelude::*;
#[derive(Debug,Deserialize, Serialize)]
#[derive(Deserialize, Serialize)]
struct ReqState {
request: String,
state: String,
request: lox::proto::open_invite::Request,
state: lox::proto::open_invite::State,
}
#[derive(Debug,Deserialize, Serialize)]
struct Credential {
lox_credential: String,
bridgeline: String,
}
#[wasm_bindgen]
@ -36,9 +42,9 @@ pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
};
let (request, state) = open_invite::request(&token);
let req_state = ReqState {
request: serde_json::to_string(&request).unwrap(),
state: serde_json::to_string(&state).unwrap(),
};
request: request,
state: state,
};
unsafe {
log(&format!(
"Formatted open invite request: {}",
@ -48,59 +54,31 @@ pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
Ok(serde_json::to_string(&req_state).unwrap())
}
fn concat_string(request: String, state: String) -> String {
let mut new_string: String = "Request:".to_owned();
new_string.push_str(&request);
new_string.push_str(", State:");
new_string.push_str(&state);
return new_string;
}
fn deconcat_string(concatString: String) -> (String, String) {
("hello".to_owned(), "world".to_owned())
}
#[wasm_bindgen]
pub fn handle_new_lox_credential(open_lox_result: String, open_lox_response: String, lox_pub: String) -> Result<String, JsValue> {
unsafe {
log(&format!("Using server response: {:?}", open_lox_result));
}
let (state, response) = deconcat_string(open_lox_result);
let deserialized_state = serde_json::from_str(&state).unwrap();
let deserialized_response = serde_json::from_str(&response).unwrap();
let req_state: ReqState = 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 deserialized_pubkey = serde_json::from_str(&lox_pub).unwrap();
let lox_cred = match open_invite::handle_response(deserialized_state, deserialized_response, &deserialized_pubkey) {
Ok(lox_cred) => lox_cred,
Err(e) => return Err(JsValue::from(e.to_string())),
};
let serialized_credential = serde_json::to_string(&lox_cred.0).unwrap();
let serialized_bridgeline= serde_json::to_string(&lox_cred.1).unwrap();
let lox_cred = Credential {
lox_credential: serde_json::to_string(&lox_cred.0).unwrap(),
bridgeline: serde_json::to_string(&lox_cred.1).unwrap(),
};
unsafe {
log(&format!("Got new Lox Credential: {}", serialized_credential));
log(&format!("Got new bridgeline: {}", serialized_bridgeline));
log(&format!("Got new Lox Credential: {}", lox_cred.lox_credential));
log(&format!("Got new bridgeline: {}", lox_cred.bridgeline));
}
let open_lox_response = concat_string(serialized_credential, serialized_bridgeline);
Ok(open_lox_response)
Ok(serde_json::to_string(&lox_cred).unwrap())
}
/* Somehow get pubkeys and return to function
#[wasm_bindgen]
pub async fn get_pubkey(key_type: String) -> Result<JsValue, JsValue> {
let mut url = "http://localhost:8001/".to_owned() + &key_type;
let res = reqwest::Client::new()
.get(url)
.send()
.await?;
let text = res.text().await?;
let pub_key: IssuerPubKey = serde_json::from_str(&text).unwrap();
Ok(pub_key)
} */
// This should also check the pubkey
fn validate(invite: &[u8]) -> Result<[u8; OPENINV_LENGTH], TryFromSliceError> {
invite.try_into()