diff --git a/veilid-wasm/src/lib.rs b/veilid-wasm/src/lib.rs index b949f527..fa87391c 100644 --- a/veilid-wasm/src/lib.rs +++ b/veilid-wasm/src/lib.rs @@ -66,10 +66,15 @@ fn take_veilid_api() -> Result Vec { +pub fn unmarshall(b64: String) -> APIResult> { data_encoding::BASE64URL_NOPAD .decode(b64.as_bytes()) - .unwrap() + .map_err(|e| { + VeilidAPIError::generic(format!( + "error decoding base64url string '{}' into bytes: {}", + b64, e + )) + }) } pub fn marshall(data: &Vec) -> String { diff --git a/veilid-wasm/src/veilid_crypto_js.rs b/veilid-wasm/src/veilid_crypto_js.rs index ada65c4b..e12a1978 100644 --- a/veilid-wasm/src/veilid_crypto_js.rs +++ b/veilid-wasm/src/veilid_crypto_js.rs @@ -93,12 +93,8 @@ impl VeilidCrypto { pub fn hashPassword(kind: String, password: String, salt: String) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let password: Vec = data_encoding::BASE64URL_NOPAD - .decode(password.as_bytes()) - .unwrap(); - let salt: Vec = data_encoding::BASE64URL_NOPAD - .decode(salt.as_bytes()) - .unwrap(); + let password = unmarshall(password)?; + let salt = unmarshall(salt)?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -119,9 +115,7 @@ impl VeilidCrypto { password_hash: String, ) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let password: Vec = data_encoding::BASE64URL_NOPAD - .decode(password.as_bytes()) - .unwrap(); + let password = unmarshall(password)?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -138,12 +132,8 @@ impl VeilidCrypto { pub fn deriveSharedSecret(kind: String, password: String, salt: String) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let password: Vec = data_encoding::BASE64URL_NOPAD - .decode(password.as_bytes()) - .unwrap(); - let salt: Vec = data_encoding::BASE64URL_NOPAD - .decode(salt.as_bytes()) - .unwrap(); + let password = unmarshall(password)?; + let salt = unmarshall(salt)?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -196,20 +186,34 @@ impl VeilidCrypto { signatures: StringArray, ) -> VeilidAPIResult { let node_ids = into_unchecked_string_vec(node_ids); - let node_ids: Vec = node_ids + let node_ids: Vec = node_ids .iter() - .map(|k| veilid_core::TypedKey::from_str(k).unwrap()) - .collect(); + .map(|k| { + veilid_core::TypedKey::from_str(k).map_err(|e| { + VeilidAPIError::invalid_argument( + "verifySignatures()", + format!("error decoding nodeid in node_ids[]: {}", e), + k, + ) + }) + }) + .collect::>>()?; - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(data.as_bytes()) - .unwrap(); + let data: Vec = unmarshall(data)?; let typed_signatures = into_unchecked_string_vec(signatures); - let typed_signatures: Vec = typed_signatures + let typed_signatures: Vec = typed_signatures .iter() - .map(|k| veilid_core::TypedSignature::from_str(k).unwrap()) - .collect(); + .map(|k| { + TypedSignature::from_str(k).map_err(|e| { + VeilidAPIError::invalid_argument( + "verifySignatures()", + format!("error decoding keypair in key_pairs[]: {}", e), + k, + ) + }) + }) + .collect::>>()?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -223,15 +227,21 @@ impl VeilidCrypto { } pub fn generateSignatures(data: String, key_pairs: StringArray) -> APIResult { - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(data.as_bytes()) - .unwrap(); + let data = unmarshall(data)?; let key_pairs = into_unchecked_string_vec(key_pairs); - let key_pairs: Vec = key_pairs + let key_pairs: Vec = key_pairs .iter() - .map(|k| veilid_core::TypedKeyPair::from_str(k).unwrap()) - .collect(); + .map(|k| { + veilid_core::TypedKeyPair::from_str(k).map_err(|e| { + VeilidAPIError::invalid_argument( + "generateSignatures()", + format!("error decoding keypair in key_pairs[]: {}", e), + k, + ) + }) + }) + .collect::>>()?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -262,9 +272,7 @@ impl VeilidCrypto { pub fn generateHash(kind: String, data: String) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(data.as_bytes()) - .unwrap(); + let data = unmarshall(data)?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -301,9 +309,7 @@ impl VeilidCrypto { pub fn validateHash(kind: String, data: String, hash: String) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(data.as_bytes()) - .unwrap(); + let data = unmarshall(data)?; let hash: veilid_core::HashDigest = veilid_core::HashDigest::from_str(&hash)?; @@ -345,9 +351,7 @@ impl VeilidCrypto { let key: veilid_core::PublicKey = veilid_core::PublicKey::from_str(&key)?; let secret: veilid_core::SecretKey = veilid_core::SecretKey::from_str(&secret)?; - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(data.as_bytes()) - .unwrap(); + let data = unmarshall(data)?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -362,9 +366,7 @@ impl VeilidCrypto { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; let key: veilid_core::PublicKey = veilid_core::PublicKey::from_str(&key)?; - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(data.as_bytes()) - .unwrap(); + let data = unmarshall(data)?; let signature: veilid_core::Signature = veilid_core::Signature::from_str(&signature)?; let veilid_api = get_veilid_api()?; @@ -401,20 +403,16 @@ impl VeilidCrypto { ) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let body: Vec = data_encoding::BASE64URL_NOPAD - .decode(body.as_bytes()) - .unwrap(); + let body = unmarshall(body)?; let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce)?; let shared_secret: veilid_core::SharedSecret = veilid_core::SharedSecret::from_str(&shared_secret)?; - let associated_data: Option> = associated_data.map(|ad| { - data_encoding::BASE64URL_NOPAD - .decode(ad.as_bytes()) - .unwrap() - }); + let associated_data = associated_data + .map(|ad| unmarshall(ad)) + .map_or(APIResult::Ok(None), |r| r.map(Some))?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -447,20 +445,16 @@ impl VeilidCrypto { ) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let body: Vec = data_encoding::BASE64URL_NOPAD - .decode(body.as_bytes()) - .unwrap(); + let body = unmarshall(body)?; - let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce).unwrap(); + let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce)?; let shared_secret: veilid_core::SharedSecret = - veilid_core::SharedSecret::from_str(&shared_secret).unwrap(); + veilid_core::SharedSecret::from_str(&shared_secret)?; - let associated_data: Option> = associated_data.map(|ad| { - data_encoding::BASE64URL_NOPAD - .decode(ad.as_bytes()) - .unwrap() - }); + let associated_data: Option> = associated_data + .map(|ad| unmarshall(ad)) + .map_or(APIResult::Ok(None), |r| r.map(Some))?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; @@ -492,14 +486,12 @@ impl VeilidCrypto { ) -> APIResult { let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?; - let mut body: Vec = data_encoding::BASE64URL_NOPAD - .decode(body.as_bytes()) - .unwrap(); + let mut body = unmarshall(body)?; - let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce).unwrap(); + let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce)?; let shared_secret: veilid_core::SharedSecret = - veilid_core::SharedSecret::from_str(&shared_secret).unwrap(); + veilid_core::SharedSecret::from_str(&shared_secret)?; let veilid_api = get_veilid_api()?; let crypto = veilid_api.crypto()?; diff --git a/veilid-wasm/src/veilid_routing_context_js.rs b/veilid-wasm/src/veilid_routing_context_js.rs index 45183655..9707c0be 100644 --- a/veilid-wasm/src/veilid_routing_context_js.rs +++ b/veilid-wasm/src/veilid_routing_context_js.rs @@ -44,9 +44,7 @@ impl VeilidRoutingContext { /// /// Returns a route id that can be used to send private messages to the node creating this route. pub fn importRemotePrivateRoute(&self, blob: String) -> APIResult { - let blob: Vec = data_encoding::BASE64URL_NOPAD - .decode(blob.as_bytes()) - .unwrap(); + let blob = unmarshall(blob)?; let veilid_api = get_veilid_api()?; let route_id = veilid_api.import_remote_private_route(blob)?; APIResult::Ok(route_id) @@ -86,7 +84,7 @@ impl VeilidRoutingContext { /// * `call_id` - specifies which call to reply to, and it comes from a VeilidUpdate::AppCall, specifically the VeilidAppCall::id() value. /// * `message` - is an answer blob to be returned by the remote node's RoutingContext::app_call() function, and may be up to 32768 bytes pub async fn appCallReply(call_id: String, message: String) -> APIResult<()> { - let message = unmarshall(message); + let message = unmarshall(message)?; let call_id = match call_id.parse() { Ok(v) => v, Err(e) => { @@ -152,7 +150,7 @@ impl VeilidRoutingContext { #[wasm_bindgen(skip_jsdoc)] pub async fn appMessage(&self, target_string: String, message: String) -> APIResult<()> { let routing_context = self.getRoutingContext()?; - let message = unmarshall(message); + let message = unmarshall(message)?; let veilid_api = get_veilid_api()?; let target = veilid_api.parse_as_target(target_string).await?; @@ -169,7 +167,7 @@ impl VeilidRoutingContext { /// @returns an answer blob of up to `32768` bytes, base64Url encoded. #[wasm_bindgen(skip_jsdoc)] pub async fn appCall(&self, target_string: String, request: String) -> APIResult { - let request: Vec = unmarshall(request); + let request: Vec = unmarshall(request)?; let routing_context = self.getRoutingContext()?; let veilid_api = get_veilid_api()?; @@ -215,11 +213,10 @@ impl VeilidRoutingContext { key: String, writer: Option, ) -> APIResult { - let key = TypedKey::from_str(&key).unwrap(); - let writer = match writer { - Some(writer) => Some(KeyPair::from_str(&writer).unwrap()), - _ => None, - }; + let key = TypedKey::from_str(&key)?; + let writer = writer + .map(|writer| KeyPair::from_str(&writer)) + .map_or(APIResult::Ok(None), |r| r.map(Some))?; let routing_context = self.getRoutingContext()?; let dht_record_descriptor = routing_context.open_dht_record(key, writer).await?; @@ -230,7 +227,7 @@ impl VeilidRoutingContext { /// /// Closing a record allows you to re-open it with a different routing context pub async fn closeDhtRecord(&self, key: String) -> APIResult<()> { - let key = TypedKey::from_str(&key).unwrap(); + let key = TypedKey::from_str(&key)?; let routing_context = self.getRoutingContext()?; routing_context.close_dht_record(key).await?; APIRESULT_UNDEFINED @@ -242,7 +239,7 @@ impl VeilidRoutingContext { /// Deleting a record does not delete it from the network, but will remove the storage of the record locally, /// and will prevent its value from being refreshed on the network by this node. pub async fn deleteDhtRecord(&self, key: String) -> APIResult<()> { - let key = TypedKey::from_str(&key).unwrap(); + let key = TypedKey::from_str(&key)?; let routing_context = self.getRoutingContext()?; routing_context.delete_dht_record(key).await?; APIRESULT_UNDEFINED @@ -260,7 +257,7 @@ impl VeilidRoutingContext { subKey: u32, forceRefresh: bool, ) -> APIResult> { - let key = TypedKey::from_str(&key).unwrap(); + let key = TypedKey::from_str(&key)?; let routing_context = self.getRoutingContext()?; let res = routing_context .get_dht_value(key, subKey, forceRefresh) @@ -278,10 +275,8 @@ impl VeilidRoutingContext { subKey: u32, data: String, ) -> APIResult> { - let key = TypedKey::from_str(&key).unwrap(); - let data: Vec = data_encoding::BASE64URL_NOPAD - .decode(&data.as_bytes()) - .unwrap(); + let key = TypedKey::from_str(&key)?; + let data = unmarshall(data)?; let routing_context = self.getRoutingContext()?; let res = routing_context.set_dht_value(key, subKey, data).await?; diff --git a/veilid-wasm/src/veilid_table_db_js.rs b/veilid-wasm/src/veilid_table_db_js.rs index 2a8c235a..f1fb86c3 100644 --- a/veilid-wasm/src/veilid_table_db_js.rs +++ b/veilid-wasm/src/veilid_table_db_js.rs @@ -63,11 +63,11 @@ impl VeilidTableDB { /// Read a key from a column in the TableDB immediately. pub async fn load(&mut self, columnId: u32, key: String) -> APIResult> { self.ensureOpen().await; - let key = unmarshall(key); + let key = unmarshall(key)?; let table_db = self.getTableDB()?; - let out = table_db.load(columnId, &key).await?.unwrap(); - let out = Some(marshall(&out)); + let out = table_db.load(columnId, &key).await?; + let out = out.map(|out| marshall(&out)); APIResult::Ok(out) } @@ -75,8 +75,8 @@ impl VeilidTableDB { /// Performs a single transaction immediately. pub async fn store(&mut self, columnId: u32, key: String, value: String) -> APIResult<()> { self.ensureOpen().await; - let key = unmarshall(key); - let value = unmarshall(value); + let key = unmarshall(key)?; + let value = unmarshall(value)?; let table_db = self.getTableDB()?; table_db.store(columnId, &key, &value).await?; @@ -86,11 +86,11 @@ impl VeilidTableDB { /// Delete key with from a column in the TableDB. pub async fn delete(&mut self, columnId: u32, key: String) -> APIResult> { self.ensureOpen().await; - let key = unmarshall(key); + let key = unmarshall(key)?; let table_db = self.getTableDB()?; - let out = table_db.delete(columnId, &key).await?.unwrap(); - let out = Some(marshall(&out)); + let out = table_db.delete(columnId, &key).await?; + let out = out.map(|out| marshall(&out)); APIResult::Ok(out) } @@ -161,15 +161,15 @@ impl VeilidTableDBTransaction { /// Store a key with a value in a column in the TableDB. /// Does not modify TableDB until `.commit()` is called. pub fn store(&self, col: u32, key: String, value: String) -> APIResult<()> { - let key = unmarshall(key); - let value = unmarshall(value); + let key = unmarshall(key)?; + let value = unmarshall(value)?; let transaction = self.getTransaction()?; transaction.store(col, &key, &value) } /// Delete key with from a column in the TableDB pub fn deleteKey(&self, col: u32, key: String) -> APIResult<()> { - let key = unmarshall(key); + let key = unmarshall(key)?; let transaction = self.getTransaction()?; transaction.delete(col, &key) }