lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }