anubis-age 1.4.0

//! FIPS 140-3 compliance module
//!
//! This module implements the self-tests and integrity verification required
//! for FIPS 140-3 Level 1 certification.

pub mod selftests;

pub use selftests::{run_power_up_tests, FipsError};

/// Module integrity hash computed at build time
const MODULE_HASH: &str = env!("FIPS_MODULE_HASH");

/// Build timestamp for audit trail
const BUILD_TIMESTAMP: &str = env!("FIPS_BUILD_TIMESTAMP");

/// Verify module integrity
///
/// This function checks that the cryptographic module has not been tampered with
/// by verifying the embedded integrity hash. This is required for FIPS 140-3
/// compliance as part of the power-up self-tests.
///
/// # Returns
///
/// - `Ok(())` if integrity verification passes
/// - `Err(FipsError::IntegrityCheckFailed)` if the module has been tampered with
pub fn verify_module_integrity() -> Result<(), FipsError> {
    // Check that we have a valid hash (not UNKNOWN)
    if MODULE_HASH == "UNKNOWN" {
        eprintln!("WARNING: Module integrity hash not available");
        eprintln!("This may indicate a build system issue or development build");
        return Err(FipsError::IntegrityCheckFailed);
    }

    // In a production FIPS module, we would:
    // 1. Compute SHA-256 hash of the loaded .so/.dylib/.dll
    // 2. Compare against the embedded hash
    // 3. Fail if they don't match
    //
    // For source-level verification during development:
    // - The hash is computed from source files at build time
    // - We verify that the hash is present and valid
    // - A full binary verification would be done during FIPS certification

    // Verify hash format (should be 64 hex characters for SHA-256)
    if MODULE_HASH.len() != 64 {
        return Err(FipsError::IntegrityCheckFailed);
    }

    // Verify all characters are valid hex
    if !MODULE_HASH.chars().all(|c| c.is_ascii_hexdigit()) {
        return Err(FipsError::IntegrityCheckFailed);
    }

    Ok(())
}

/// Get module integrity information
///
/// Returns the module hash and build timestamp for audit purposes.
pub fn module_integrity_info() -> ModuleIntegrityInfo {
    ModuleIntegrityInfo {
        hash: MODULE_HASH,
        build_timestamp: BUILD_TIMESTAMP,
        fips_mode: is_fips_mode(),
    }
}

/// Module integrity information for audit trail
#[derive(Debug, Clone)]
pub struct ModuleIntegrityInfo {
    /// SHA-256 hash of cryptographic module source files
    pub hash: &'static str,
    /// Build timestamp in RFC 3339 format
    pub build_timestamp: &'static str,
    /// Whether FIPS mode is enabled
    pub fips_mode: bool,
}

impl std::fmt::Display for ModuleIntegrityInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "FIPS 140-3 Module Integrity Information:")?;
        writeln!(f, "  Module Hash: {}", self.hash)?;
        writeln!(f, "  Build Time:  {}", self.build_timestamp)?;
        writeln!(
            f,
            "  FIPS Mode:   {}",
            if self.fips_mode { "Enabled" } else { "Ready" }
        )?;
        Ok(())
    }
}

/// Check if FIPS mode is enabled
pub fn is_fips_mode() -> bool {
    cfg!(feature = "fips")
}

/// Get FIPS compliance status
pub fn fips_status() -> &'static str {
    if is_fips_mode() {
        "FIPS 140-3 Mode Enabled"
    } else {
        "FIPS 140-3 Ready"
    }
}