Hugging Face's logo

Datasets:
Sahek
/
ubda-engine

Modalities:
Text
Formats:
json
Size:
< 1K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
ubda-engine
File size: 4,503 Bytes
b90fa8e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
# UBDA — Unified Behavioral Data Access (V1.2-alpha)

[![CI](https://github.com/kaymyg/ubda-engine/actions/workflows/ci.yml/badge.svg)](https://github.com/kaymyg/ubda-engine/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Rust 2021](https://img.shields.io/badge/rust-2021_edition-orange.svg)](Cargo.toml)

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](https://huggingface.co/spaces/sahek/ubda-engine)
— 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`](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

```bash

# 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`](LICENSE).

## Contributing

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

## Security

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

## Changelog

See [`CHANGELOG.md`](CHANGELOG.md).