Sahek/ubda-engine

UBDA — Unified Behavioral Data Access (V1.2-alpha)

UBDA is a prototype capability-based data access architecture written in Rust. It models a system where a software behavioral-trust engine can influence trust levels, but only a separate hardware/TEE-style authority can ever mint the signed, short-lived capabilities that unlock encryption keys. The goal is to explore the design pattern — not to ship a production security product.

⚠️ Prototype / educational status. This is a self-teaching / architecture exploration project. MockHardwareAuthorizer uses an in-memory Ed25519 keypair and a hard-coded demo secret in place of a real HSM/TEE, and Ed25519 is used as a placeholder for a future post-quantum signature scheme. Do not use this as-is to protect real secrets.

Try it live: UBDA Engine Demo on Hugging Face Spaces — click "Run protocol walkthrough" to execute the real compiled engine in your browser.

Concept

• Trust states (T-1…T4) describe how strongly the system currently trusts the requester, moving from a cold, unauthenticated boot through device authentication, behavioral continuity, step-up (biometric/PIN), and finally hardware-backed critical elevation.
• Data classifications (D0…D3) describe how sensitive a resource is, from public system files up to root/master key material.
• Every classification has a minimum required trust state. The KeyAuthority refuses to issue a capability if the caller's asserted trust state doesn't meet it.
• A Data Access Capability (DAC) is a signed, time-boxed, single-use, resource-scoped grant. The KeyBroker independently re-verifies the DAC's signature, expiry, trust-state requirement, operation, and session binding, and rejects replay via nonce/cap-id tracking, before asking the authority to derive an ephemeral session key (HKDF-SHA256).
• A hard anomaly signal (or an intrusion interrupt) forces the whole system into a Compromised (T-1) state where all key material is invalidated until an explicit hardware recovery reset.

See docs/ARCHITECTURE.md for the full state-transition diagram, component-isolation diagram, and the trust/classification matrix.

Project layout

src/
  types.rs               Core enums/structs: TrustState, DataClassification,
                          DataAccessCapability, telemetry & assertion types
  state_machine.rs        SystemStateMachine — enforces valid trust transitions
  bte_interface.rs         BehavioralTrustEngine — turns telemetry into a PolicyAssertion
  hardware_authorizer.rs   KeyAuthority trait + MockHardwareAuthorizer (Ed25519 + HKDF)
  key_broker.rs            KeyBroker — verifies & consumes DACs, derives session keys
  replay_store.rs          Nonce / capability-id replay protection
  main.rs                  End-to-end walkthrough exercising the full protocol

Running it

# Run the end-to-end protocol walkthrough
cargo run

# Run the unit test suite (17 tests across state machine, authorizer, broker)
cargo test

Expected cargo run output walks through: reaching T2 via behavioral continuity, a rejected over-privileged request, a full issue → verify → derive-key cycle, a blocked replay attempt, a blocked signature-tampering attempt, full elevation through T3/T4 with real D2/D3 capability issuance, and a compromise lockout + recovery reset.

Requirements

• Rust 2021 edition. Dependency versions in Cargo.toml are pinned to remain buildable on older stable toolchains (tested on rustc 1.75); newer toolchains work too.

License

MIT — see LICENSE.

Contributing

Bug reports, feature ideas, and PRs are welcome — see CONTRIBUTING.md for setup and the checks CI runs.

Security

Found a design or implementation flaw? Please see SECURITY.md for how to report it responsibly rather than opening a public issue.

Changelog

See CHANGELOG.md.