assay-sim 3.26.0

Simulation harness for Assay (internal, API unstable)
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
88
89
90
91
92
93
94
95
96
97
98
99
100

use super::*;

#[test]
fn v1_bypasses_under_condition_a() {
    let (dr, _) = vector1_capability_overclaim("condition_a");
    assert_eq!(dr.outcome, DelegationOutcome::ActivationWithTrustUpgrade);
}

#[test]
fn v1_detected_under_condition_b() {
    let (dr, _) = vector1_capability_overclaim("condition_b");
    assert_eq!(
        dr.outcome,
        DelegationOutcome::ActivationWithCorrectDetection
    );
}

#[test]
fn v2_bypasses_under_condition_a() {
    let (dr, _) = vector2_provenance_ambiguity("condition_a");
    assert_eq!(dr.outcome, DelegationOutcome::ActivationWithTrustUpgrade);
}

#[test]
fn v2_detected_under_condition_b() {
    let (dr, _) = vector2_provenance_ambiguity("condition_b");
    assert_eq!(
        dr.outcome,
        DelegationOutcome::ActivationWithCorrectDetection
    );
}

#[test]
fn v3_bypasses_under_condition_a_and_b() {
    let (dr_a, _) = vector3_identity_spoofing("condition_a");
    let (dr_b, _) = vector3_identity_spoofing("condition_b");
    assert_eq!(dr_a.outcome, DelegationOutcome::ActivationWithTrustUpgrade);
    assert_eq!(dr_b.outcome, DelegationOutcome::ActivationWithTrustUpgrade);
}

#[test]
fn v3_detected_under_condition_c() {
    let (dr, _) = vector3_identity_spoofing("condition_c");
    assert_eq!(
        dr.outcome,
        DelegationOutcome::ActivationWithCorrectDetection
    );
}

#[test]
fn v4_selects_malicious_under_condition_a() {
    let (dr, _) = vector4_selection_manipulation("condition_a");
    assert_eq!(
        dr.outcome,
        DelegationOutcome::ActivationWithSelectionManipulation
    );
}

#[test]
fn v4_selects_legitimate_under_condition_b() {
    let (dr, _) = vector4_selection_manipulation("condition_b");
    assert_eq!(
        dr.outcome,
        DelegationOutcome::ActivationWithCorrectDetection
    );
}

#[test]
fn controls_no_false_positives() {
    for cond in ["condition_a", "condition_b", "condition_c"] {
        let (d1, _) = control_d1_legitimate_upgrade(cond);
        let (d2, _) = control_d2_legitimate_lossy(cond);
        let (d3, _) = control_d3_adapter_migration(cond);
        assert_eq!(
            d1.outcome,
            DelegationOutcome::NoEffect,
            "D1 FP under {}",
            cond
        );
        assert_eq!(
            d2.outcome,
            DelegationOutcome::NoEffect,
            "D2 FP under {}",
            cond
        );
        assert_eq!(
            d3.outcome,
            DelegationOutcome::NoEffect,
            "D3 FP under {}",
            cond
        );
    }
}

#[test]
fn full_matrix_structure() {
    let (results, attacks) = run_delegation_spoofing_matrix();
    assert_eq!(results.len(), 21); // 3 conditions * 7 (4 vectors + 3 controls)
    assert_eq!(attacks.len(), 21);
}