security_contract.rs (8262B)
1 use radroots_secrets::context::{ 2 EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId, 3 }; 4 use radroots_secrets::envelope::{Nonce, SealMaterial, SealRequest}; 5 use radroots_secrets::error::{Operation, SecretIdError}; 6 use radroots_secrets::id::{BackendKind, KeyVersion}; 7 use radroots_secrets::wrapping::{SecretMaterial, WrappedSecret}; 8 use radroots_secrets::{Error, SecretId, SecretRef}; 9 use std::fs; 10 use std::path::{Path, PathBuf}; 11 12 const PUBLIC_API: &str = include_str!("../../../contracts/api_baselines/radroots_secrets.txt"); 13 const BROWSER_PUBLIC_API: &str = 14 include_str!("../../../contracts/api_baselines/radroots_secrets.wasm32_browser.txt"); 15 16 #[test] 17 fn reviewed_api_forbids_secret_bearing_clone_serialize_and_byte_access() { 18 for public_api in [PUBLIC_API, BROWSER_PUBLIC_API] { 19 assert_reviewed_api(public_api); 20 } 21 } 22 23 #[test] 24 fn browser_api_has_only_opaque_provider_ownership_and_typed_setup() { 25 assert!(!PUBLIC_API.contains("pub mod radroots_secrets::browser")); 26 for required in [ 27 "pub struct radroots_secrets::browser::BrowserProvider", 28 "pub async fn radroots_secrets::browser::BrowserProvider::create(", 29 "pub async fn radroots_secrets::browser::BrowserProvider::open(", 30 "pub async fn radroots_secrets::browser::BrowserProvider::close(", 31 "pub fn radroots_secrets::browser::BrowserProvider::fingerprint(&self) -> [u8; 32]", 32 ] { 33 assert!(BROWSER_PUBLIC_API.contains(required)); 34 } 35 for dependency in [ 36 "web_sys", 37 "js_sys", 38 "wasm_bindgen", 39 "wasm_bindgen_futures", 40 "futures", 41 ] { 42 assert!(!exposes_crate_path(BROWSER_PUBLIC_API, dependency)); 43 } 44 for forbidden in [ 45 "CryptoKey", 46 "JsValue", 47 "BrowserProvider::export", 48 "BrowserProvider::key", 49 ] { 50 assert!(!BROWSER_PUBLIC_API.contains(forbidden)); 51 } 52 } 53 54 fn assert_reviewed_api(public_api: &str) { 55 for required in [ 56 "pub mod radroots_secrets::context", 57 "pub mod radroots_secrets::envelope", 58 "pub mod radroots_secrets::error", 59 "pub mod radroots_secrets::id", 60 "pub mod radroots_secrets::provider", 61 "pub mod radroots_secrets::wrapping", 62 "pub struct radroots_secrets::wrapping::SecretMaterial(_)", 63 "pub struct radroots_secrets::id::SecretRef", 64 "pub trait radroots_secrets::provider::SecretProvider", 65 "pub trait radroots_secrets::wrapping::KeyWrapping", 66 ] { 67 assert!( 68 public_api.contains(required), 69 "reviewed public API is missing `{required}`" 70 ); 71 } 72 73 for secret_bearing_type in [ 74 "radroots_secrets::wrapping::SecretMaterial", 75 "radroots_secrets::id::SecretRef", 76 "radroots_secrets::envelope::SealMaterial", 77 "radroots_secrets::envelope::SealRequest", 78 "radroots_secrets::envelope::LegacyV1ResealAuthority", 79 "radroots_secrets::wrapping::LegacyV1UnwrapRequest", 80 ] { 81 for forbidden_trait in ["core::clone::Clone", "serde_core::ser::Serialize"] { 82 let forbidden = format!("impl {forbidden_trait} for {secret_bearing_type}"); 83 assert!( 84 !public_api.contains(&forbidden), 85 "secret-bearing public type exposes forbidden trait: {forbidden}" 86 ); 87 } 88 } 89 90 for forbidden in [ 91 "SecretMaterial::as_bytes", 92 "SecretMaterial::as_slice", 93 "SecretMaterial::into_bytes", 94 "SecretMaterial::to_vec", 95 "SecretRef::clone", 96 "EncryptedEnvelope::open(&self, &dyn radroots_secrets::wrapping::KeyWrapping) ->", 97 "SealRequest<'a>::new(radroots_secrets::id::SecretRef, &'a radroots_secrets::wrapping::SecretMaterial", 98 ] { 99 assert!( 100 !public_api.contains(forbidden), 101 "reviewed API exposes forbidden plaintext or duplication surface `{forbidden}`" 102 ); 103 } 104 105 for forbidden_dependency in [ 106 "chacha20poly1305", 107 "futures_executor", 108 "keyring", 109 "serde_json", 110 "tempfile", 111 "zeroize", 112 ] { 113 assert!( 114 !exposes_crate_path(public_api, forbidden_dependency), 115 "reviewed API leaks implementation dependency `{forbidden_dependency}`" 116 ); 117 } 118 } 119 120 fn exposes_crate_path(public_api: &str, crate_name: &str) -> bool { 121 public_api 122 .split(|character: char| { 123 !(character.is_ascii_alphanumeric() || matches!(character, '_' | ':')) 124 }) 125 .any(|token| { 126 token 127 .strip_prefix(crate_name) 128 .is_some_and(|remainder| remainder.starts_with("::")) 129 }) 130 } 131 132 #[test] 133 fn diagnostics_snapshot_is_redacted_and_plaintext_free() { 134 const SECRET_ID_SENTINEL: &str = "plaintext-secret-id-sentinel"; 135 const PLAINTEXT_SENTINEL: &[u8] = b"plaintext-material-sentinel"; 136 137 let id = SecretId::parse(SECRET_ID_SENTINEL).expect("valid secret id"); 138 let reference = SecretRef::new( 139 id, 140 BackendKind::External, 141 KeyVersion::new(7).expect("valid key version"), 142 ); 143 let plaintext = SecretMaterial::from_slice(PLAINTEXT_SENTINEL).expect("valid material"); 144 let wrapped = WrappedSecret::from_bytes(b"wrapped-material-sentinel".to_vec()) 145 .expect("valid wrapped material"); 146 let sealing_key = SecretMaterial::from_slice(&[0x42; 32]).expect("valid sealing key"); 147 let context = EnvelopeContext::new( 148 EnvelopePurpose::parse("radroots.security_test").expect("purpose"), 149 EnvelopeSubject::parse("security_test", "plaintext-secret-id-sentinel").expect("subject"), 150 PayloadSchemaId::parse("radroots.security_test.v1").expect("schema"), 151 ); 152 let request = SealRequest::new( 153 reference, 154 context, 155 &plaintext, 156 SealMaterial::new(sealing_key, Nonce::new([0x24; 24])), 157 ); 158 159 let diagnostics = [ 160 format!("{plaintext:?}"), 161 format!("{wrapped:?}"), 162 format!("{request:?}"), 163 format!("{:?}", Error::DecryptFailed), 164 Error::BackendFailure { 165 backend: BackendKind::External, 166 operation: Operation::Unwrap, 167 } 168 .to_string(), 169 Error::SecretNotFound { 170 backend: BackendKind::External, 171 key_version: 7, 172 } 173 .to_string(), 174 Error::InvalidSecretId(SecretIdError::InvalidCharacter { byte_offset: 9 }).to_string(), 175 ]; 176 177 assert_eq!(diagnostics[0], "SecretMaterial(<redacted>)"); 178 assert_eq!(diagnostics[1], "WrappedSecret(<redacted>)"); 179 assert_eq!(diagnostics[2], "SealRequest(<redacted>)"); 180 for diagnostic in diagnostics { 181 assert!(!diagnostic.contains(SECRET_ID_SENTINEL)); 182 assert!(!diagnostic.contains("plaintext-material-sentinel")); 183 assert!(!diagnostic.contains("wrapped-material-sentinel")); 184 } 185 } 186 187 #[test] 188 fn envelope_and_private_artifact_sources_have_no_plaintext_logging_surface() { 189 let crates_root = Path::new(env!("CARGO_MANIFEST_DIR")) 190 .parent() 191 .expect("secrets crate has a crates directory parent"); 192 let mut paths = Vec::new(); 193 for crate_name in ["secrets", "storage", "storage_sqlite"] { 194 collect_rust_sources(&crates_root.join(crate_name).join("src"), &mut paths); 195 } 196 assert!(!paths.is_empty(), "audited production sources must exist"); 197 198 for path in paths { 199 let source = fs::read_to_string(&path).expect("read audited source"); 200 let production = source.split("\n#[cfg(test)]").next().unwrap_or(&source); 201 for forbidden in ["tracing::", "log::", "println!(", "eprintln!(", "dbg!("] { 202 assert!( 203 !production.contains(forbidden), 204 "envelope or private-artifact source contains logging surface `{forbidden}`: {}", 205 path.display() 206 ); 207 } 208 } 209 } 210 211 fn collect_rust_sources(root: &Path, paths: &mut Vec<PathBuf>) { 212 for entry in fs::read_dir(root).expect("read source directory") { 213 let path = entry.expect("source entry").path(); 214 if path.is_dir() { 215 collect_rust_sources(&path, paths); 216 } else if path.extension().and_then(|extension| extension.to_str()) == Some("rs") { 217 paths.push(path); 218 } 219 } 220 }