crypto.rs (7912B)
1 use super::BrowserError; 2 use crate::{ 3 SecretId, SecretRef, 4 context::EnvelopeContext, 5 wrapping::{SecretMaterial, WrappedSecret}, 6 }; 7 use js_sys::{Array, ArrayBuffer, Reflect, Uint8Array}; 8 use sha2::{Digest, Sha256}; 9 use wasm_bindgen::{JsCast, JsValue}; 10 use wasm_bindgen_futures::JsFuture; 11 use web_sys::{AesKeyGenParams, Crypto, CryptoKey, HkdfParams, SubtleCrypto}; 12 13 const HEADER: &[u8; 5] = b"RRBW\x01"; 14 const ENCODED_BYTES: usize = 45; 15 16 struct PlainBytes(Uint8Array); 17 impl Drop for PlainBytes { 18 fn drop(&mut self) { 19 self.0.fill(0, 0, self.0.length()); 20 } 21 } 22 fn usages(names: &[&str]) -> Array { 23 names.iter().map(|name| JsValue::from_str(name)).collect() 24 } 25 pub(super) fn host() -> Result<(Crypto, SubtleCrypto), BrowserError> { 26 let crypto = Reflect::get(&js_sys::global(), &JsValue::from_str("crypto")) 27 .map_err(|_| BrowserError::Unavailable)? 28 .dyn_into::<Crypto>() 29 .map_err(|_| BrowserError::Unavailable)?; 30 let subtle = Reflect::get(crypto.as_ref(), &JsValue::from_str("subtle")) 31 .map_err(|_| BrowserError::Unavailable)? 32 .dyn_into::<SubtleCrypto>() 33 .map_err(|_| BrowserError::Unavailable)?; 34 Ok((crypto, subtle)) 35 } 36 pub(super) async fn generate( 37 crypto: &Crypto, 38 subtle: &SubtleCrypto, 39 ) -> Result<CryptoKey, BrowserError> { 40 let seed = PlainBytes(Uint8Array::new_with_length(32)); 41 crypto 42 .get_random_values_with_js_u8_array(&seed.0) 43 .map_err(|_| BrowserError::Unavailable)?; 44 let promise = subtle 45 .import_key_with_str("raw", &seed.0, "HKDF", false, &usages(&["deriveKey"])) 46 .map_err(|_| BrowserError::Unavailable)?; 47 let key = JsFuture::from(promise) 48 .await 49 .map_err(|_| BrowserError::Unavailable)? 50 .dyn_into::<CryptoKey>() 51 .map_err(|_| BrowserError::KeyMismatch)?; 52 validate(&key)?; 53 Ok(key) 54 } 55 pub(super) fn validate(key: &CryptoKey) -> Result<(), BrowserError> { 56 let algorithm = key.algorithm().map_err(|_| BrowserError::KeyMismatch)?; 57 if key.type_() != "secret" 58 || key.extractable() 59 || key.usages().length() != 1 60 || key.usages().get(0).as_string().as_deref() != Some("deriveKey") 61 || Reflect::get(&algorithm, &JsValue::from_str("name")) 62 .ok() 63 .and_then(|v| v.as_string()) 64 .as_deref() 65 != Some("HKDF") 66 { 67 return Err(BrowserError::KeyMismatch); 68 } 69 Ok(()) 70 } 71 fn scope(namespace: &SecretId, reference: &SecretRef) -> [u8; 32] { 72 let mut hash = Sha256::new(); 73 hash.update(b"radroots.browser.key_scope.v1\0"); 74 for value in [namespace.as_str(), reference.id().as_str()] { 75 hash.update((value.len() as u16).to_be_bytes()); 76 hash.update(value.as_bytes()); 77 } 78 hash.update(reference.key_version().get().to_be_bytes()); 79 hash.finalize().into() 80 } 81 async fn derive( 82 subtle: &SubtleCrypto, 83 key: &CryptoKey, 84 namespace: &SecretId, 85 reference: &SecretRef, 86 context: Option<&EnvelopeContext>, 87 ) -> Result<CryptoKey, BrowserError> { 88 validate(key)?; 89 let salt = Uint8Array::from(scope(namespace, reference).as_slice()); 90 let mut info = Vec::from(if context.is_some() { 91 b"radroots.browser.key_wrap.v1\0".as_slice() 92 } else { 93 b"radroots.browser.key_probe.v1\0".as_slice() 94 }); 95 if let Some(context) = context { 96 info.extend_from_slice(&context.authentication_digest()); 97 } 98 let params = 99 HkdfParams::new_with_str("HKDF", "SHA-256", &Uint8Array::from(info.as_slice()), &salt); 100 let algorithm = AesKeyGenParams::new("AES-KW", 256); 101 let promise = subtle 102 .derive_key_with_object_and_object( 103 ¶ms, 104 key, 105 &algorithm, 106 false, 107 &usages(&["wrapKey", "unwrapKey"]), 108 ) 109 .map_err(|_| BrowserError::Unavailable)?; 110 JsFuture::from(promise) 111 .await 112 .map_err(|_| BrowserError::Unavailable)? 113 .dyn_into::<CryptoKey>() 114 .map_err(|_| BrowserError::KeyMismatch) 115 } 116 async fn encode( 117 subtle: &SubtleCrypto, 118 wrapping: &CryptoKey, 119 bytes: &[u8], 120 ) -> Result<Vec<u8>, BrowserError> { 121 if bytes.len() != 32 { 122 return Err(BrowserError::Provider(crate::Error::InvalidDataKeyLength { 123 actual_bytes: bytes.len(), 124 })); 125 } 126 let raw = PlainBytes(Uint8Array::from(bytes)); 127 let promise = subtle 128 .import_key_with_str("raw", &raw.0, "AES-GCM", true, &usages(&["encrypt"])) 129 .map_err(|_| BrowserError::Unavailable)?; 130 let data_key = JsFuture::from(promise) 131 .await 132 .map_err(|_| BrowserError::Unavailable)? 133 .dyn_into::<CryptoKey>() 134 .map_err(|_| BrowserError::KeyMismatch)?; 135 let promise = subtle 136 .wrap_key_with_str("raw", &data_key, wrapping, "AES-KW") 137 .map_err(|_| BrowserError::Unavailable)?; 138 let buffer = JsFuture::from(promise) 139 .await 140 .map_err(|_| BrowserError::Unavailable)? 141 .dyn_into::<ArrayBuffer>() 142 .map_err(|_| BrowserError::KeyMismatch)?; 143 if buffer.byte_length() != 40 { 144 return Err(BrowserError::KeyMismatch); 145 } 146 Ok(Uint8Array::new(&buffer).to_vec()) 147 } 148 pub(super) async fn fingerprint( 149 subtle: &SubtleCrypto, 150 key: &CryptoKey, 151 namespace: &SecretId, 152 reference: &SecretRef, 153 ) -> Result<[u8; 32], BrowserError> { 154 let derived = derive(subtle, key, namespace, reference, None).await?; 155 // Public fixed probe in its own KDF domain; no payload or provider key is exposed. 156 Ok(Sha256::digest(encode(subtle, &derived, &[0xa5; 32]).await?).into()) 157 } 158 pub(super) async fn wrap( 159 subtle: &SubtleCrypto, 160 key: &CryptoKey, 161 namespace: &SecretId, 162 reference: &SecretRef, 163 context: &EnvelopeContext, 164 plaintext: &SecretMaterial, 165 ) -> Result<WrappedSecret, BrowserError> { 166 let derived = derive(subtle, key, namespace, reference, Some(context)).await?; 167 let raw = plaintext.expose_secret(|bytes| zeroize::Zeroizing::new(bytes.to_vec())); 168 let mut encoded = Vec::from(HEADER.as_slice()); 169 encoded.extend_from_slice(&encode(subtle, &derived, raw.as_slice()).await?); 170 WrappedSecret::from_bytes(encoded).map_err(BrowserError::Provider) 171 } 172 pub(super) fn validate_wrapped(wrapped: &WrappedSecret) -> Result<(), BrowserError> { 173 if wrapped.as_bytes().len() != ENCODED_BYTES || !wrapped.as_bytes().starts_with(HEADER) { 174 return Err(BrowserError::KeyMismatch); 175 } 176 Ok(()) 177 } 178 pub(super) async fn unwrap( 179 subtle: &SubtleCrypto, 180 key: &CryptoKey, 181 namespace: &SecretId, 182 reference: &SecretRef, 183 context: &EnvelopeContext, 184 wrapped: &WrappedSecret, 185 ) -> Result<SecretMaterial, BrowserError> { 186 validate_wrapped(wrapped)?; 187 let derived = derive(subtle, key, namespace, reference, Some(context)).await?; 188 let ciphertext = Uint8Array::from(&wrapped.as_bytes()[HEADER.len()..]); 189 let promise = subtle 190 .unwrap_key_with_buffer_source_and_str_and_str( 191 "raw", 192 &ciphertext, 193 &derived, 194 "AES-KW", 195 "AES-GCM", 196 true, 197 &usages(&["encrypt"]), 198 ) 199 .map_err(|_| BrowserError::KeyMismatch)?; 200 let data_key = JsFuture::from(promise) 201 .await 202 .map_err(|_| BrowserError::KeyMismatch)? 203 .dyn_into::<CryptoKey>() 204 .map_err(|_| BrowserError::KeyMismatch)?; 205 let promise = subtle 206 .export_key("raw", &data_key) 207 .map_err(|_| BrowserError::KeyMismatch)?; 208 let buffer = JsFuture::from(promise) 209 .await 210 .map_err(|_| BrowserError::KeyMismatch)? 211 .dyn_into::<ArrayBuffer>() 212 .map_err(|_| BrowserError::KeyMismatch)?; 213 let plaintext = PlainBytes(Uint8Array::new(&buffer)); 214 if plaintext.0.length() != 32 { 215 return Err(BrowserError::KeyMismatch); 216 } 217 SecretMaterial::from_owned(plaintext.0.to_vec()).map_err(BrowserError::Provider) 218 }