nx_failover_compose_test.nx source
↩ module page · 149 lines · 6500 B
1// nx_failover_compose_test.nx -- ransomware-judo failover end-to-end.
2//
3// Per [[feedback-cell-immune-system-ransomware-judo-ddos-by-bit]]
4// scenario: "if website a got hit with ransomware we laugh and delete
5// and shift to website b and load up c as the new backup defying
6// ddos and all other systems of attack by judo by bit."
7//
8// The compose demo lifecycle:
9// 1. Build cell A (primary) + cell B (chromatin backup) + cell C
10// (newer chromatin backup waiting in the wings)
11// 2. Build a dyad: A and B run side-by-side serving same input;
12// observatory watches both outputs from outside
13// 3. Provenance chain logs the input ingest + each cell's output
14// production
15// 4. Ransomware sig detected on cell A -- nx_promote swaps A to B
16// using the latest chromatin
17// 5. C's chromatin replaces the now-stale B-as-backup (C is fresher)
18// 6. Provenance chain shows the failover as a transform link
19// (NX_TX_NONE caller-defined kind for now)
20// 7. Observatory now watches NEW dyad (B-as-primary + C-as-backup)
21//
22// This proves the judo: vendor's attack on A becomes our forensic
23// record of attack + sub-second swap + audit-trail through provenance.
24
25import "nx_syscalls.nx"
26import "nx_tier.nx"
27import "nx_attention_class.nx"
28import "nx_evict_journal.nx"
29import "nx_methyl.nx"
30import "nx_chromatin.nx"
31import "nx_promote.nx"
32import "nx_dyad.nx"
33import "nx_observatory.nx"
34import "nx_provenance_chain.nx"
35
36func main() -> i64 {
37 let sig: *u8 = (sys_mmap(96)) as *u8
38 sig[0] = 42 as u8
39
40 // ===== Step 1: build A's + B's + C's state buffers =============
41 let a_state: *u8 = (sys_mmap(64)) as *u8
42 let b_state: *u8 = (sys_mmap(64)) as *u8
43 let c_state: *u8 = (sys_mmap(64)) as *u8
44 var i: nx_size = 0
45 while i < 32 {
46 a_state[i] = (65 + i) as u8
47 b_state[i] = (65 + i) as u8
48 c_state[i] = (65 + i) as u8
49 i = i + 1
50 }
51
52 // Each cell has its own methyl mark for self-validation
53 let mark_a: *NxMethylMark = nx_methyl_new(10, 0xaaaa, 1000, sig, 96)
54 let mark_b: *NxMethylMark = nx_methyl_new(20, 0xbbbb, 1000, sig, 96)
55 let mark_c: *NxMethylMark = nx_methyl_new(30, 0xcccc, 1000, sig, 96)
56 if nx_methyl_is_self(mark_a, 2000, 10000, 10) != 1 { return 1 }
57
58 // ===== Step 2: capture chromatins for B (replica of A) and C ===
59 let ch_b: *NxChromatin = nx_chromatin_capture(20, 0xb001, 1500,
60 a_state, 32, mark_b, 1)
61 let ch_c: *NxChromatin = nx_chromatin_capture(30, 0xc001, 1600,
62 a_state, 32, mark_c, 2)
63 if (ch_b as i64) == 0 { return 2 }
64 if (ch_c as i64) == 0 { return 3 }
65 if nx_chromatin_is_fresher(ch_c, ch_b) != 1 { return 4 }
66
67 // ===== Step 3: build failover contract A -> B ==================
68 let journal: *NxEvictJournal = nx_evict_journal_new(16)
69 let contract: *NxFailoverContract = nx_failover_contract_new(
70 500, 10, 20, ch_b)
71 if nx_promote_is_primary(contract, 10) != 1 { return 5 }
72
73 // ===== Step 4: dyad runs A and B side by side ==================
74 let a_in: *u8 = (sys_mmap(32)) as *u8
75 let a_out: *u8 = (sys_mmap(32)) as *u8
76 let b_in: *u8 = (sys_mmap(32)) as *u8
77 let b_out: *u8 = (sys_mmap(32)) as *u8
78 let dyad: *NxDyad = nx_dyad_new(
79 10, NX_AC_INTERACTIVE_FOREGROUND_GAME, a_in, 32, a_out, 32,
80 20, NX_AC_INTERACTIVE_FOREGROUND_GAME, b_in, 32, b_out, 32)
81 if (dyad as i64) == 0 { return 6 }
82 if nx_dyad_buffers_isolated(dyad) != 1 { return 7 }
83
84 // Feed both A and B the same input
85 let request: *u8 = (sys_mmap(16)) as *u8
86 request[0] = 71 as u8 // 'G'
87 request[1] = 69 as u8 // 'E'
88 request[2] = 84 as u8 // 'T'
89 nx_dyad_feed_same_input(dyad, request, 16)
90 if nx_dyad_inputs_match(dyad, 16) != 1 { return 8 }
91
92 // ===== Step 5: cells produce outputs (simulate) ================
93 var j: nx_size = 0
94 while j < 16 {
95 a_out[j] = (50 + j) as u8
96 b_out[j] = (50 + j) as u8 // identical responses
97 j = j + 1
98 }
99
100 // ===== Step 6: observatory watches dyad ========================
101 let obs: *NxObservatory = nx_observatory_new(dyad, 16)
102 nx_observatory_sample(obs, 16, 2000)
103 nx_observatory_sample(obs, 16, 2100)
104 nx_observatory_sample(obs, 16, 2200)
105 if nx_observatory_agreement_q10(obs) != 1024 { return 9 }
106 if nx_observatory_is_divergent(obs, 256) != 0 { return 10 }
107
108 // ===== Step 7: provenance chain logs the request lineage =======
109 let prov: *NxProvenanceChain = nx_provenance_chain_new(32)
110 nx_provenance_append(prov, NX_TX_CAPTURE, 0x100, 0xae0001, 2000, 10, mark_a)
111 nx_provenance_append(prov, NX_TX_PREPROCESS, 0x200, 0xae0002, 2050, 10, mark_a)
112 nx_provenance_append(prov, NX_TX_ENCODE, 0x300, 0xae0003, 2100, 10, mark_a)
113 if prov.count != 3 { return 11 }
114 if nx_provenance_verify_continuity(prov) != NX_PV_OK { return 12 }
115 if nx_provenance_last_hash(prov) != 0xae0003 { return 13 }
116
117 // ===== Step 8: ransomware detected on cell A -> promote to B ===
118 let dst_b: *u8 = (sys_mmap(64)) as *u8
119 let rc: nx_int = nx_promote_execute(contract,
120 NX_PR_TRG_RANSOMWARE, dst_b, 64, 3000, 10000, journal)
121 if rc != NX_PROMOTE_OK { return 14 }
122 if contract.primary_cell_id != 20 { return 15 }
123 if contract.backup_cell_id != 10 { return 16 }
124 if contract.last_trigger != NX_PR_TRG_RANSOMWARE { return 17 }
125 if journal.count != 1 { return 18 }
126
127 // ===== Step 9: provenance logs the failover as a transform =====
128 nx_provenance_append(prov, NX_TX_NONE, 0xfa110ade, 0xfa110bbb,
129 3100, 20, mark_b)
130 if prov.count != 4 { return 19 }
131 if nx_provenance_verify_continuity(prov) != NX_PV_OK { return 20 }
132
133 // ===== Step 10: load C's chromatin as the new backup ===========
134 let rc_update: nx_int = nx_promote_update_chromatin(contract, ch_c)
135 if rc_update != NX_PROMOTE_OK { return 21 }
136
137 // ===== Step 11: observatory still sees agreement after swap ====
138 nx_observatory_sample(obs, 16, 4000)
139 if nx_observatory_agreement_q10(obs) != 1024 { return 22 }
140
141 // ===== Step 12: forensic asserts ===============================
142 if nx_promote_flap_count(contract) != 1 { return 23 }
143 if nx_provenance_count_by_transform(prov, NX_TX_CAPTURE) != 1 { return 24 }
144 if nx_provenance_count_by_transform(prov, NX_TX_ENCODE) != 1 { return 25 }
145 // Chain still continuous after failover transform appended
146 if nx_provenance_verify_continuity(prov) != NX_PV_OK { return 26 }
147
148 return 0
149}