Struct BackendReport

Source

pub struct BackendReport {Show 15 fields
    pub active: Backend,
    pub accelerated_backend_active: bool,
    pub security_posture: SecurityPosture,
    pub encode_backend: OperationBackendReport,
    pub strict_decode_backend: OperationBackendReport,
    pub secret_decode_backend: OperationBackendReport,
    pub candidate: Backend,
    pub candidate_detection_mode: CandidateDetectionMode,
    pub simd_feature_enabled: bool,
    pub ordinary_acceleration_active: bool,
    pub unsafe_boundary_enforced: bool,
    pub wasm_artifact_posture: WasmArtifactPosture,
    pub wasm_runtime_posture: WasmRuntimePosture,
    pub wipe_posture: WipePosture,
    pub ct_gate_posture: CtGatePosture,
}

Expand description

Backend report for the current build and target.

Fields§

§active: Backend

Compatibility alias for ordinary encode. New code should use Self::encode_backend and inspect the separate decode reports.

§accelerated_backend_active: bool

Whether ordinary encode is accelerated; this does not describe strict decode. New code should inspect the operation-specific reports.

§security_posture: SecurityPosture

Compatibility posture for ordinary encode and its candidate. New code should use the operation-specific security postures.

§encode_backend: OperationBackendReport

Strongest healthy ordinary encode backend for qualifying inputs.

Per-call length and alphabet policy can select a narrower backend or scalar fallback without changing this capability-oriented report.

§strict_decode_backend: OperationBackendReport

Selected ordinary strict-decode backend.

§secret_decode_backend: OperationBackendReport

Secret decode backend, independently fixed to the scalar constant-time-oriented boundary.

§candidate: Backend

Strongest backend candidate visible to the current build.

§candidate_detection_mode: CandidateDetectionMode

Whether candidate visibility came from runtime CPU probing, compile-time target features, or a disabled SIMD feature.

§simd_feature_enabled: bool

Whether the simd feature is enabled in this build.

§ordinary_acceleration_active: bool

Whether either ordinary operation selects acceleration.

§unsafe_boundary_enforced: bool

Whether this build keeps the high-assurance scalar unsafe boundary.

This is a conservative compile-time posture signal. It is true only when the reserved simd feature is disabled; simd builds expose additional private prototype boundaries and must use the release evidence scripts for boundary validation.

§wasm_artifact_posture: WasmArtifactPosture

Wasm artifact selection, distinct from native runtime CPU dispatch.

§wasm_runtime_posture: WasmRuntimePosture

Wasm host-runtime identification posture.

§wipe_posture: WipePosture

Current wipe-barrier posture.

§ct_gate_posture: CtGatePosture

Current constant-time result-gate barrier posture.

Implementations§

Source §

impl BackendReport

Source

pub const fn satisfies(self, policy: BackendPolicy) -> bool

Returns whether this report satisfies policy.

let report = base64_ng::runtime::backend_report();

let scalar_only =
    report.satisfies(base64_ng::runtime::BackendPolicy::ScalarExecutionOnly);
assert!(!scalar_only || !report.ordinary_acceleration_active);

Source

pub const fn candidate_required_cpu_features(self) -> &'static [&'static str]

Returns the CPU features required by the detected candidate.

let report = base64_ng::runtime::backend_report();

assert_eq!(
    report.candidate_required_cpu_features(),
    report.candidate.required_cpu_features(),
);

Source

pub fn active_decode_backend(self) -> Backend

Returns the typed backend selected by ordinary strict decode.

Prefer Self::strict_decode_backend for stable logging.

Source

pub const fn memory_lock_posture(self) -> MemoryLockPosture

Returns whether base64-ng itself locks secret buffers into physical memory.

This crate intentionally has no OS-specific mlock/VirtualLock integration. High-assurance deployments should pair secret buffers with their own platform-approved memory-locking, swap, hibernation, and crash-dump controls.

Source

pub const fn snapshot(self) -> BackendSnapshot

Returns a compact structured snapshot with stable string values.

let snapshot = base64_ng::runtime::backend_report().snapshot();

assert_eq!(
    snapshot.ordinary_acceleration_active,
    snapshot.encode_backend.backend != "scalar"
        || snapshot.strict_decode_backend.backend != "scalar",
);