nx_bed_mesh_adversarial_test.nx source
↩ module page · 77 lines · 3136 B
1// nx_bed_mesh_adversarial_test.nx -- Phase A6 of S-class hardening.
2//
3// Adversarial fuzz of nx_bed_mesh: corrupted probe data must not
4// crash queries or generate i64 overflow in the bilinear math.
5//
6// Operator workflow: bed mesh data comes from a Klipper BED_MESH_
7// CALIBRATE probe. If the probe data file is corrupted or
8// adversarial (wrong values from a bad sensor), the substrate's
9// query primitives MUST stay safe.
10//
11// expect_exit: 0
12// license_tier: ORIGINAL
13
14import "nx_syscalls.nx"
15import "nx_bed_mesh.nx"
16
17const Q14: i64 = 16384
18
19func main() -> i64 {
20 // ===== (a) Null mesh -> z_offset returns 0 (graceful) =====
21 let z_null: i64 = nx_bed_mesh_z_offset(0 as *NxBedMesh, 100 * Q14, 100 * Q14)
22 if z_null != 0 { return 10 }
23
24 let z_null_layer: i64 = nx_bed_mesh_z_at_layer(0 as *NxBedMesh, 100 * Q14, 100 * Q14, 0)
25 if z_null_layer != 0 { return 11 }
26
27 // ===== (b) Minimum-size mesh (2x2) -> sane =====
28 let bed_max: i64 = 200 * Q14
29 let m: *NxBedMesh = nx_bed_mesh_new(2, 2, 0, bed_max, 0, bed_max, 10)
30 if (m as i64) == 0 { return 20 }
31
32 // ===== (c) Query at hugely-out-of-range positive coord -> clamps =====
33 let z_huge_pos: i64 = nx_bed_mesh_z_offset(m, 9999999 * Q14, 9999999 * Q14)
34 if z_huge_pos != 0 { return 30 } // clamped to corner (which is 0)
35
36 // ===== (d) Query at hugely-negative coord -> clamps =====
37 let z_huge_neg: i64 = nx_bed_mesh_z_offset(m, 0 - 9999999 * Q14, 0 - 9999999 * Q14)
38 if z_huge_neg != 0 { return 40 }
39
40 // ===== (e) set_point with negative indices -> error =====
41 let bad_neg_x: i64 = nx_bed_mesh_set_point(m, -1, 0, Q14)
42 if bad_neg_x == NX_BED_MESH_OK { return 50 }
43
44 let bad_neg_y: i64 = nx_bed_mesh_set_point(m, 0, -100, Q14)
45 if bad_neg_y == NX_BED_MESH_OK { return 51 }
46
47 // ===== (f) set_point with out-of-range indices -> error =====
48 let bad_high_x: i64 = nx_bed_mesh_set_point(m, 99, 0, Q14)
49 if bad_high_x == NX_BED_MESH_OK { return 60 }
50
51 let bad_high_y: i64 = nx_bed_mesh_set_point(m, 0, 99, Q14)
52 if bad_high_y == NX_BED_MESH_OK { return 61 }
53
54 // ===== (g) Set extreme +/- dz values -> no overflow on query =====
55 //
56 // Set corner to massive +dz (~150mm) and another to massive -dz.
57 // Bilinear at midpoint should be well-defined (not overflow).
58 let big_pos: i64 = 150 * Q14 // 150 mm (absurd but bounded)
59 let big_neg: i64 = 0 - big_pos
60 nx_bed_mesh_set_point(m, 0, 0, big_pos)
61 nx_bed_mesh_set_point(m, 1, 1, big_neg)
62 // Query at midpoint (100, 100) -- should be finite + within
63 // [-150mm, +150mm] in Q14.
64 let z_mid: i64 = nx_bed_mesh_z_offset(m, 100 * Q14, 100 * Q14)
65 if z_mid > big_pos { return 70 }
66 if z_mid < big_neg { return 71 }
67
68 // ===== (h) layer_idx > taper_layers -> 0 (queued -- no oscillation) =====
69 let z_past_taper: i64 = nx_bed_mesh_z_at_layer(m, 100 * Q14, 100 * Q14, 100)
70 if z_past_taper != 0 { return 80 }
71
72 // ===== (i) layer_idx negative -> 0 (graceful) =====
73 let z_neg_layer: i64 = nx_bed_mesh_z_at_layer(m, 100 * Q14, 100 * Q14, -5)
74 if z_neg_layer != 0 { return 90 }
75
76 return 0
77}