chio-kernel 0.1.2

Chio runtime kernel: capability validation, guard evaluation, receipt signing
Documentation 
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

use chio_kernel::weights_binding::{
    evaluate_weights_binding_with_loaded_hash, WeightsBindingError,
};
use chio_weights::card::{ModelCard, StringSet};
use chio_weights::error::WeightsError;
use chrono::{TimeZone, Utc};

fn issued_at() -> chrono::DateTime<Utc> {
    match Utc.with_ymd_and_hms(2026, 5, 2, 9, 0, 0) {
        chrono::LocalResult::Single(value) => value,
        _ => panic!("fixed timestamp fixture must construct"),
    }
}

fn model_card(weights_hash: &str) -> ModelCard {
    let issued = issued_at();
    match ModelCard::new(
        weights_hash,
        StringSet::new(["tool:read"]),
        StringSet::new(["tool:exec"]),
        "local-fixture",
        "https://issuer.example",
        issued,
        issued + chrono::Duration::days(30),
    ) {
        Ok(card) => card,
        Err(error) => panic!("model card fixture must construct: {error}"),
    }
}

fn binding_sets() -> (StringSet, StringSet) {
    (StringSet::new(["tool:read"]), StringSet::new(["tool:read"]))
}

#[test]
fn recomputed_loaded_hash_allows_matching_card() {
    let card = model_card("0000000000000000000000000000000000000000000000000000000000000001");
    let (scopes, tools) = binding_sets();
    let result = evaluate_weights_binding_with_loaded_hash(
        &card,
        Ok::<_, WeightsBindingError>(
            "0000000000000000000000000000000000000000000000000000000000000001",
        ),
        &scopes,
        &tools,
    );
    assert!(result.is_ok());
}

#[test]
fn recomputed_loaded_hash_rejects_spoofed_digest() {
    let card = model_card("0000000000000000000000000000000000000000000000000000000000000001");
    let (scopes, tools) = binding_sets();
    let err = match evaluate_weights_binding_with_loaded_hash(
        &card,
        Ok::<_, WeightsBindingError>(
            "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        ),
        &scopes,
        &tools,
    ) {
        Ok(()) => panic!("spoofed digest must reject"),
        Err(err) => err,
    };
    assert!(matches!(err, WeightsError::CardMismatch { .. }));
}

#[test]
fn unavailable_loaded_weights_reject_fail_closed() {
    let card = model_card("0000000000000000000000000000000000000000000000000000000000000001");
    let (scopes, tools) = binding_sets();
    let err = match evaluate_weights_binding_with_loaded_hash(
        &card,
        Err::<String, _>("hosted provider did not expose loaded weights"),
        &scopes,
        &tools,
    ) {
        Ok(()) => panic!("unavailable loaded weights must reject"),
        Err(err) => err,
    };
    match err {
        WeightsError::SchemaRejected(message) => {
            assert!(message.contains("loaded weights unavailable"));
        }
        other => panic!("unexpected error: {other:?}"),
    }
}