rullst-security 12.3.0

Runtime application security, RASP, OWASP headers, Login Jail, and WAF middleware for Rullst.
Documentation
use super::*;

const KEY: &[u8; KEY_LENGTH] = b"0123456789abcdef0123456789abcdef";
const OTHER_KEY: &[u8; KEY_LENGTH] = b"abcdef0123456789abcdef0123456789";
const AAD: &[u8] = b"tenant-7:users:ssn:42";

#[test]
fn test_vault_secret_redaction() {
    let secret = VaultSecret::new("super_secret_password".to_string());
    assert_eq!(format!("{:?}", secret), "VaultSecret(***REDACTED***)");
    assert_eq!(format!("{}", secret), "***REDACTED***");
    assert_eq!(secret.expose_secret(), "super_secret_password");
}

#[test]
fn field_encryptor_round_trips_and_uses_random_nonces() {
    let first = FieldEncryptor::encrypt_with_key_id("secret_data", KEY, "primary", AAD)
        .expect("encryption should succeed");
    let second = FieldEncryptor::encrypt_with_key_id("secret_data", KEY, "primary", AAD)
        .expect("encryption should succeed");

    assert!(first.starts_with("RULLST:v2:primary:"));
    assert!(!first.contains("secret_data"));
    assert_ne!(first, second, "a fresh nonce must produce a new envelope");
    assert_eq!(
        FieldEncryptor::decrypt_with_aad(&first, KEY, AAD).expect("decryption should succeed"),
        "secret_data"
    );
    assert_eq!(
        FieldEncryptor::envelope_key_id(&first).expect("envelope should be valid"),
        "primary"
    );
}

#[test]
fn convenience_api_round_trips_empty_and_unicode_fields() {
    for plaintext in ["", "dados confidenciais 🔐"] {
        let encrypted = FieldEncryptor::encrypt(plaintext, KEY).expect("encryption should succeed");
        assert_eq!(
            FieldEncryptor::decrypt(&encrypted, KEY).expect("decryption should succeed"),
            plaintext
        );
    }
}

#[test]
fn reads_pre_v12_enc_prefix_for_migration() {
    let current =
        FieldEncryptor::encrypt("legacy data", KEY).expect("current encryption should succeed");
    let legacy = current.replacen("RULLST:", "ENC:", 1);

    assert_eq!(
        FieldEncryptor::decrypt(&legacy, KEY).expect("legacy prefix should remain readable"),
        "legacy data"
    );
}

#[test]
fn rejects_invalid_keys_wrong_keys_and_mismatched_aad() {
    assert_eq!(
        FieldEncryptor::encrypt("secret", b"too-short"),
        Err(VaultError::InvalidKeyLength {
            expected: KEY_LENGTH,
            actual: 9,
        })
    );

    let encrypted =
        FieldEncryptor::encrypt_with_aad("secret", KEY, AAD).expect("encryption should succeed");
    assert_eq!(
        FieldEncryptor::decrypt_with_aad(&encrypted, OTHER_KEY, AAD),
        Err(VaultError::AuthenticationFailed)
    );
    assert_eq!(
        FieldEncryptor::decrypt_with_aad(&encrypted, KEY, b"tenant-8:users:ssn:42"),
        Err(VaultError::AuthenticationFailed)
    );
    assert_eq!(
        FieldEncryptor::decrypt_with_aad(&encrypted, b"too-short", AAD),
        Err(VaultError::InvalidKeyLength {
            expected: KEY_LENGTH,
            actual: 9,
        })
    );
}

#[test]
fn rejects_tampered_ciphertext_and_authenticated_key_id() {
    let encrypted = FieldEncryptor::encrypt_with_key_id("secret", KEY, "primary", AAD)
        .expect("encryption should succeed");
    let mut fields: Vec<String> = encrypted.split(':').map(str::to_string).collect();
    let mut ciphertext = URL_SAFE_NO_PAD
        .decode(&fields[4])
        .expect("test envelope should contain base64 ciphertext");
    ciphertext[0] ^= 1;
    fields[4] = URL_SAFE_NO_PAD.encode(ciphertext);
    let tampered_ciphertext = fields.join(":");

    assert_eq!(
        FieldEncryptor::decrypt_with_aad(&tampered_ciphertext, KEY, AAD),
        Err(VaultError::AuthenticationFailed)
    );

    let tampered_key_id = encrypted.replacen(":primary:", ":secondary:", 1);
    assert_eq!(
        FieldEncryptor::decrypt_with_aad(&tampered_key_id, KEY, AAD),
        Err(VaultError::AuthenticationFailed)
    );
}

#[test]
fn rejects_legacy_unknown_and_malformed_envelopes() {
    assert_eq!(
        FieldEncryptor::decrypt("RULLST:v1:irreversible-hash", KEY),
        Err(VaultError::LegacyIrreversibleEnvelope {
            version: "v1".to_string(),
        })
    );
    assert_eq!(
        FieldEncryptor::decrypt("RULLST:v99:default:nonce:ciphertext", KEY),
        Err(VaultError::UnsupportedEnvelopeVersion {
            version: "v99".to_string(),
        })
    );
    assert_eq!(
        FieldEncryptor::decrypt("not-an-envelope", KEY),
        Err(VaultError::InvalidEnvelope)
    );

    let short_nonce = URL_SAFE_NO_PAD.encode([0_u8; NONCE_LENGTH - 1]);
    let tag = URL_SAFE_NO_PAD.encode([0_u8; TAG_LENGTH]);
    assert_eq!(
        FieldEncryptor::decrypt(&format!("RULLST:v2:default:{short_nonce}:{tag}"), KEY),
        Err(VaultError::InvalidNonceLength {
            expected: NONCE_LENGTH,
            actual: NONCE_LENGTH - 1,
        })
    );
}

#[test]
fn supports_key_rotation_with_envelope_key_ids() {
    let old_envelope = FieldEncryptor::encrypt_with_key_id("old data", KEY, "key-2025", AAD)
        .expect("encryption should succeed");
    let new_envelope = FieldEncryptor::encrypt_with_key_id("new data", OTHER_KEY, "key-2026", AAD)
        .expect("encryption should succeed");
    let keyring: [(&str, &[u8]); 2] = [
        ("key-2026", OTHER_KEY.as_slice()),
        ("key-2025", KEY.as_slice()),
    ];

    assert_eq!(
        FieldEncryptor::decrypt_with_keyring(&old_envelope, &keyring, AAD)
            .expect("old key should remain readable"),
        "old data"
    );
    assert_eq!(
        FieldEncryptor::decrypt_with_keyring(&new_envelope, &keyring, AAD)
            .expect("current key should be readable"),
        "new data"
    );
    assert_eq!(
        FieldEncryptor::decrypt_with_keyring(&new_envelope, &keyring[1..], AAD),
        Err(VaultError::KeyNotFound {
            key_id: "key-2026".to_string(),
        })
    );
}

#[test]
fn validates_rotation_key_identifiers() {
    assert_eq!(
        FieldEncryptor::encrypt_with_key_id("secret", KEY, "", AAD),
        Err(VaultError::EmptyKeyId)
    );
    assert_eq!(
        FieldEncryptor::encrypt_with_key_id("secret", KEY, "key:invalid", AAD),
        Err(VaultError::InvalidKeyId)
    );
    assert_eq!(
        FieldEncryptor::encrypt_with_key_id("secret", KEY, "k".repeat(MAX_KEY_ID_LENGTH + 1), AAD),
        Err(VaultError::KeyIdTooLong {
            maximum: MAX_KEY_ID_LENGTH,
            actual: MAX_KEY_ID_LENGTH + 1
        })
    );
}

#[test]
fn rejects_invalid_envelope_encodings_and_short_ciphertexts() {
    let valid_nonce = URL_SAFE_NO_PAD.encode([0_u8; NONCE_LENGTH]);

    assert_eq!(
        FieldEncryptor::decrypt("RULLST:v2:default:!not-base64!:AAAA", KEY),
        Err(VaultError::InvalidEnvelopeEncoding { component: "nonce" })
    );
    assert_eq!(
        FieldEncryptor::decrypt(
            &format!("RULLST:v2:default:{valid_nonce}:!not-base64!"),
            KEY
        ),
        Err(VaultError::InvalidEnvelopeEncoding {
            component: "ciphertext"
        })
    );

    let short_ciphertext = URL_SAFE_NO_PAD.encode([0_u8; TAG_LENGTH - 1]);
    assert_eq!(
        FieldEncryptor::decrypt(
            &format!("RULLST:v2:default:{valid_nonce}:{short_ciphertext}"),
            KEY
        ),
        Err(VaultError::CiphertextTooShort {
            minimum: TAG_LENGTH,
            actual: TAG_LENGTH - 1
        })
    );
    assert_eq!(
        FieldEncryptor::decrypt(
            &format!("RULLST:v2:default:{valid_nonce}:{short_ciphertext}:extra"),
            KEY
        ),
        Err(VaultError::InvalidEnvelope)
    );
}

#[test]
fn authenticated_non_utf8_plaintext_is_rejected() {
    let nonce_bytes = [7_u8; NONCE_LENGTH];
    let nonce = Nonce::<Aes256Gcm>::from(nonce_bytes);
    let authenticated_data = build_authenticated_data(DEFAULT_KEY_ID, b"");
    let ciphertext = create_cipher(KEY)
        .expect("test key should initialize AES-GCM")
        .encrypt(
            &nonce,
            Payload {
                msg: &[0xff, 0xfe],
                aad: &authenticated_data,
            },
        )
        .expect("non-UTF-8 bytes are valid authenticated plaintext");
    let envelope = format!(
        "RULLST:v2:{DEFAULT_KEY_ID}:{}:{}",
        URL_SAFE_NO_PAD.encode(nonce_bytes),
        URL_SAFE_NO_PAD.encode(ciphertext)
    );

    assert_eq!(
        FieldEncryptor::decrypt(&envelope, KEY),
        Err(VaultError::InvalidPlaintextUtf8)
    );
}