nx_pe_compile_win_index.nx source
↩ module page · 267 lines · 15223 B
1// nx_pe_compile_win_index.nx -- keystone-linker for a MEDIUM organ (the sovereign inverted INDEX) -> native Windows PE.
2// Extends nx_pe_compile_win_organ (0x400 .text, mmap+write+exit HAL) to a 0x2000 (8KB) .text so a real index organ's
3// code fits; .idata shifts RVA 0x2000->0x3000 accordingly (all import RVAs +0x1000). Same 5 kernel32 imports
4// (GetProcessHeap/HeapAlloc/GetStdHandle/WriteFile/ExitProcess). Emits _offc/nx_win_search_index.exe. This is the
5// multi-target / platform-independence step: the SAME index .nx that runs on Linux ELF now compiles + runs as a native
6// Windows PE (and the bounded footprint -- nx_inv_new_bounded -- means HeapAlloc suffices). PIPELINE: index_src.nx ->
7// nx_compile_x86_native > /tmp/nxwin.s -> this -> _offc/nx_win_search_index.exe -> run native. license_tier: ORIGINAL
8
9import "nx_syscalls.nx"
10import "nxasm_x86.nx"
11import "nx_pe_writer.nx"
12
13const NXORG_CODE_CAP: i64 = 1048576
14const NXORG_FILE_SIZE: i64 = 0x2400 // headers(0x200) + .text(0x2000) + .idata(0x200)
15const NXORG_STUB_LEN: i64 = 18
16const NXORG_HLEN: i64 = 29 // halloc thunk
17const NXORG_WLEN: i64 = 66 // write thunk
18const NXORG_ELEN: i64 = 13 // exit thunk
19const NXORG_TEXT_CAP: i64 = 0x2000 // .text raw region (file 0x200..0x2200) -- 8KB for a real index organ
20const NXORG_RVA_TEXT: i64 = 0x1000
21const NXORG_RVA_IDATA: i64 = 0x3000 // .text raw 0x2000 -> virtual 0x2000 -> idata at 0x3000
22const NXORG_FOFF_TEXT: i64 = 0x200
23const NXORG_FOFF_IDATA:i64 = 0x2200
24const NXORG_IAT_GPH: i64 = 0x3058
25const NXORG_IAT_HA: i64 = 0x3060
26const NXORG_IAT_GSH: i64 = 0x3068
27const NXORG_IAT_WF: i64 = 0x3070
28const NXORG_IAT_EXIT: i64 = 0x3078
29
30func nxorg_assemble(src: *u8, n: i64, out: *u8, out_cap: i64, p_main: *i64, p_mm: *i64, p_sw: *i64, p_se: *i64) -> i64 {
31 let lab_off: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
32 let lab_len: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
33 let lab_addr: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
34 let lab_sec: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
35 let op0: *i64 = sys_mmap(72) as *i64 // 9 slots for SIB (matches nxasm_x86)
36 let op1: *i64 = sys_mmap(72) as *i64
37 let op2: *i64 = sys_mmap(72) as *i64 // API DRIFT FIX: axc_pass gained op2
38 let scratch: *u8 = sys_mmap(64)
39 let posbox: *i64 = sys_mmap(16) as *i64
40 let n_lab_box: *i64 = sys_mmap(16) as *i64
41 n_lab_box[0] = 0
42 let lh: *i64 = sys_mmap(ASM_LH_SIZE * 8) as *i64
43
44 let text_size: i64 = axc_pass(src, n, out, 0, 0, lab_off, lab_len, lab_addr, lab_sec, n_lab_box, lh, op0, op1, op2, scratch, posbox)
45 if text_size < 0 { return text_size }
46 let n_lab: i64 = n_lab_box[0]
47
48 var main_a: i64 = 0 - 1
49 var mm_a: i64 = 0 - 1
50 var sw_a: i64 = 0 - 1
51 var se_a: i64 = 0 - 1
52 var k: i64 = 0
53 while k < n_lab {
54 if lab_sec[k] == 1 { lab_addr[k] = lab_addr[k] + text_size }
55 if axc_tok_is(src, lab_off[k], lab_len[k], "main") == 1 { main_a = lab_addr[k] }
56 if axc_tok_is(src, lab_off[k], lab_len[k], "sys_mmap") == 1 { mm_a = lab_addr[k] }
57 if axc_tok_is(src, lab_off[k], lab_len[k], "sys_write") == 1 { sw_a = lab_addr[k] }
58 if axc_tok_is(src, lab_off[k], lab_len[k], "sys_exit") == 1 { se_a = lab_addr[k] }
59 k = k + 1
60 }
61 axc_lh_build(src, lab_off, lab_len, n_lab, lh)
62
63 let total: i64 = axc_pass(src, n, out, text_size, 1, lab_off, lab_len, lab_addr, lab_sec, n_lab_box, lh, op0, op1, op2, scratch, posbox)
64 if total < 0 { return total }
65 if total > out_cap { return 0 - 200 }
66 p_main[0] = main_a
67 p_mm[0] = mm_a
68 p_sw[0] = sw_a
69 p_se[0] = se_a
70 return total
71}
72
73func nxorg_emit_pe(buf: *u8, code: *u8, code_len: i64, main_off: i64, mm_off: i64, sw_off: i64, se_off: i64) -> i64 {
74 if (buf as i64) == 0 { return 0 - NX_PE_BAD_INPUT }
75 if mm_off < 0 { return 0 - NX_PE_BAD_INPUT }
76 if sw_off < 0 { return 0 - NX_PE_BAD_INPUT }
77 if se_off < 0 { return 0 - NX_PE_BAD_INPUT }
78 let hoff: i64 = NXORG_STUB_LEN + code_len
79 let woff: i64 = hoff + NXORG_HLEN
80 let eoff: i64 = woff + NXORG_WLEN
81 let text_vsize: i64 = eoff + NXORG_ELEN
82 if text_vsize > NXORG_TEXT_CAP { return 0 - NX_PE_BAD_INPUT }
83
84 _w16(buf, 0, 0x5A4D)
85 _w32(buf, 0x3C, FOFF_PE_SIG)
86 _w32(buf, FOFF_PE_SIG, 0x00004550)
87 _w16(buf, FOFF_COFF + 0, PE_MACHINE_AMD64)
88 _w16(buf, FOFF_COFF + 2, 2)
89 _w16(buf, FOFF_COFF + 16, 0xF0)
90 _w16(buf, FOFF_COFF + 18, PE_CHAR_EXEC | PE_CHAR_LARGE_ADDR)
91 _w16(buf, FOFF_OPT + 0, PE_OH_MAGIC_PEPLUS)
92 _w8(buf, FOFF_OPT + 2, 1)
93 _w32(buf, FOFF_OPT + 4, 0x2000) // SizeOfCode (.text raw 0x2000)
94 _w32(buf, FOFF_OPT + 8, 0x200) // SizeOfInitializedData
95 _w32(buf, FOFF_OPT + 16, NXORG_RVA_TEXT)
96 _w32(buf, FOFF_OPT + 20, NXORG_RVA_TEXT)
97 _w64(buf, FOFF_OPT + 24, IMG_BASE_LO, IMG_BASE_HI)
98 _w32(buf, FOFF_OPT + 32, 0x1000)
99 _w32(buf, FOFF_OPT + 36, 0x200)
100 _w16(buf, FOFF_OPT + 40, 6)
101 _w16(buf, FOFF_OPT + 48, 6)
102 _w32(buf, FOFF_OPT + 56, 0x4000) // SizeOfImage (headers 0x1000 + .text 0x2000 + .idata 0x1000)
103 _w32(buf, FOFF_OPT + 60, 0x200)
104 _w16(buf, FOFF_OPT + 68, PE_SUBSYSTEM_CONSOLE)
105 _w64(buf, FOFF_OPT + 72, 0x100000, 0)
106 _w64(buf, FOFF_OPT + 80, 0x1000, 0)
107 _w64(buf, FOFF_OPT + 88, 0x100000, 0)
108 _w64(buf, FOFF_OPT + 96, 0x1000, 0)
109 _w32(buf, FOFF_OPT + 108, 16)
110 _w32(buf, FOFF_OPT + 112 + 8, NXORG_RVA_IDATA)
111 _w32(buf, FOFF_OPT + 112 + 12, 0x28)
112 // .text raw size 0x2000 (8KB) so a real index organ fits
113 _emit_section_header(buf, FOFF_SECT_TBL, 46, 116, 101, 120, 116, 0, 0, 0, text_vsize, NXORG_RVA_TEXT, 0x2000, NXORG_FOFF_TEXT, PE_SECT_CODE_X_R)
114 _emit_section_header(buf, FOFF_SECT_TBL + 40, 46, 105, 100, 97, 116, 97, 0, 0, 0xDD, NXORG_RVA_IDATA, 0x200, NXORG_FOFF_IDATA, PE_SECT_DATA_R)
115
116 // ===== .text: entry stub (call main; exit with its return) =====
117 let t: i64 = NXORG_FOFF_TEXT
118 _w8(buf, t+0, 0x48); _w8(buf, t+1, 0x83); _w8(buf, t+2, 0xEC); _w8(buf, t+3, 0x28)
119 _w8(buf, t+4, 0xE8); _w32(buf, t+5, 0x9 + main_off)
120 _w8(buf, t+9, 0x89); _w8(buf, t+10, 0xC1)
121 _w8(buf, t+11, 0xFF); _w8(buf, t+12, 0x15); _w32(buf, t+13, NXORG_IAT_EXIT - (NXORG_RVA_TEXT + 17))
122 _w8(buf, t+17, 0xCC)
123 var i: i64 = 0
124 while i < code_len { buf[t + NXORG_STUB_LEN + i] = code[i]; i = i + 1 }
125
126 // ===== HALLOC thunk (sys_mmap -> GetProcessHeap+HeapAlloc) =====
127 let hrva: i64 = NXORG_RVA_TEXT + hoff
128 let h: i64 = NXORG_FOFF_TEXT + hoff
129 _w8(buf, h+0, 0x48); _w8(buf, h+1, 0x83); _w8(buf, h+2, 0xEC); _w8(buf, h+3, 0x28) // sub rsp,0x28
130 _w8(buf, h+4, 0xFF); _w8(buf, h+5, 0x15); _w32(buf, h+6, NXORG_IAT_GPH - (hrva + 10)) // call GetProcessHeap
131 _w8(buf, h+10, 0x48); _w8(buf, h+11, 0x89); _w8(buf, h+12, 0xC1) // mov rcx,rax
132 _w8(buf, h+13, 0x31); _w8(buf, h+14, 0xD2) // xor edx,edx
133 _w8(buf, h+15, 0x49); _w8(buf, h+16, 0x89); _w8(buf, h+17, 0xF8) // mov r8,rdi
134 _w8(buf, h+18, 0xFF); _w8(buf, h+19, 0x15); _w32(buf, h+20, NXORG_IAT_HA - (hrva + 24)) // call HeapAlloc
135 _w8(buf, h+24, 0x48); _w8(buf, h+25, 0x83); _w8(buf, h+26, 0xC4); _w8(buf, h+27, 0x28) // add rsp,0x28
136 _w8(buf, h+28, 0xC3) // ret
137
138 // ===== WRITE thunk (sys_write -> fd-routed GetStdHandle+WriteFile, returns) =====
139 let wrva: i64 = NXORG_RVA_TEXT + woff
140 let w: i64 = NXORG_FOFF_TEXT + woff
141 _w8(buf, w+0, 0x48); _w8(buf, w+1, 0x83); _w8(buf, w+2, 0xEC); _w8(buf, w+3, 0x38) // sub rsp,0x38
142 _w8(buf, w+4, 0x48); _w8(buf, w+5, 0x89); _w8(buf, w+6, 0x54); _w8(buf, w+7, 0x24); _w8(buf, w+8, 0x30) // mov [rsp+0x30],rdx
143 _w8(buf, w+9, 0xB9); _w8(buf, w+10, 0xF5); _w8(buf, w+11, 0xFF); _w8(buf, w+12, 0xFF); _w8(buf, w+13, 0xFF) // mov ecx,-11
144 _w8(buf, w+14, 0x83); _w8(buf, w+15, 0xFF); _w8(buf, w+16, 0x02) // cmp edi,2
145 _w8(buf, w+17, 0x75); _w8(buf, w+18, 0x05) // jne +5
146 _w8(buf, w+19, 0xB9); _w8(buf, w+20, 0xF4); _w8(buf, w+21, 0xFF); _w8(buf, w+22, 0xFF); _w8(buf, w+23, 0xFF) // mov ecx,-12
147 _w8(buf, w+24, 0xFF); _w8(buf, w+25, 0x15); _w32(buf, w+26, NXORG_IAT_GSH - (wrva + 30)) // call GetStdHandle
148 _w8(buf, w+30, 0x48); _w8(buf, w+31, 0x89); _w8(buf, w+32, 0xC1) // mov rcx,rax
149 _w8(buf, w+33, 0x48); _w8(buf, w+34, 0x89); _w8(buf, w+35, 0xF2) // mov rdx,rsi
150 _w8(buf, w+36, 0x4C); _w8(buf, w+37, 0x8B); _w8(buf, w+38, 0x44); _w8(buf, w+39, 0x24); _w8(buf, w+40, 0x30) // mov r8,[rsp+0x30]
151 _w8(buf, w+41, 0x4C); _w8(buf, w+42, 0x8D); _w8(buf, w+43, 0x4C); _w8(buf, w+44, 0x24); _w8(buf, w+45, 0x28) // lea r9,[rsp+0x28]
152 _w8(buf, w+46, 0x48); _w8(buf, w+47, 0xC7); _w8(buf, w+48, 0x44); _w8(buf, w+49, 0x24); _w8(buf, w+50, 0x20); _w32(buf, w+51, 0) // mov qword[rsp+0x20],0
153 _w8(buf, w+55, 0xFF); _w8(buf, w+56, 0x15); _w32(buf, w+57, NXORG_IAT_WF - (wrva + 61)) // call WriteFile
154 _w8(buf, w+61, 0x48); _w8(buf, w+62, 0x83); _w8(buf, w+63, 0xC4); _w8(buf, w+64, 0x38) // add rsp,0x38
155 _w8(buf, w+65, 0xC3) // ret
156
157 // ===== EXIT thunk (sys_exit -> ExitProcess) =====
158 let erva: i64 = NXORG_RVA_TEXT + eoff
159 let e: i64 = NXORG_FOFF_TEXT + eoff
160 _w8(buf, e+0, 0x89); _w8(buf, e+1, 0xF9) // mov ecx,edi
161 _w8(buf, e+2, 0x48); _w8(buf, e+3, 0x83); _w8(buf, e+4, 0xEC); _w8(buf, e+5, 0x28) // sub rsp,0x28
162 _w8(buf, e+6, 0xFF); _w8(buf, e+7, 0x15); _w32(buf, e+8, NXORG_IAT_EXIT - (erva + 12)) // call ExitProcess
163 _w8(buf, e+12, 0xCC) // int3
164
165 // ===== OVERWRITE the three shims with jmp rel32 -> their thunks =====
166 let mm_rva: i64 = NXORG_RVA_TEXT + NXORG_STUB_LEN + mm_off
167 let mm: i64 = NXORG_FOFF_TEXT + NXORG_STUB_LEN + mm_off
168 _w8(buf, mm+0, 0xE9); _w32(buf, mm+1, hrva - (mm_rva + 5))
169 let sw_rva: i64 = NXORG_RVA_TEXT + NXORG_STUB_LEN + sw_off
170 let sw: i64 = NXORG_FOFF_TEXT + NXORG_STUB_LEN + sw_off
171 _w8(buf, sw+0, 0xE9); _w32(buf, sw+1, wrva - (sw_rva + 5))
172 let se_rva: i64 = NXORG_RVA_TEXT + NXORG_STUB_LEN + se_off
173 let se: i64 = NXORG_FOFF_TEXT + NXORG_STUB_LEN + se_off
174 _w8(buf, se+0, 0xE9); _w32(buf, se+1, erva - (se_rva + 5))
175
176 // ===== .idata: 5 kernel32 imports (RVA base 0x3000) =====
177 let d: i64 = NXORG_FOFF_IDATA
178 _w32(buf, d + 0, 0x3028) // OriginalFirstThunk = INT RVA
179 _w32(buf, d + 12, 0x30D0) // Name = "kernel32.dll" RVA
180 _w32(buf, d + 16, 0x3058) // FirstThunk = IAT RVA
181 // INT (RVA 0x3028) -> name RVAs
182 _w64(buf, d + 0x28, 0x3088, 0) // GetProcessHeap
183 _w64(buf, d + 0x30, 0x309A, 0) // HeapAlloc
184 _w64(buf, d + 0x38, 0x30A6, 0) // GetStdHandle
185 _w64(buf, d + 0x40, 0x30B6, 0) // WriteFile
186 _w64(buf, d + 0x48, 0x30C2, 0) // ExitProcess
187 _w64(buf, d + 0x50, 0, 0) // null
188 // IAT (RVA 0x3058) -- same, loader overwrites
189 _w64(buf, d + 0x58, 0x3088, 0)
190 _w64(buf, d + 0x60, 0x309A, 0)
191 _w64(buf, d + 0x68, 0x30A6, 0)
192 _w64(buf, d + 0x70, 0x30B6, 0)
193 _w64(buf, d + 0x78, 0x30C2, 0)
194 _w64(buf, d + 0x80, 0, 0)
195 // IMAGE_IMPORT_BY_NAME GetProcessHeap (RVA 0x3088)
196 _w16(buf, d + 0x88, 0)
197 _w8(buf,d+0x8A,71);_w8(buf,d+0x8B,101);_w8(buf,d+0x8C,116);_w8(buf,d+0x8D,80) // GetP
198 _w8(buf,d+0x8E,114);_w8(buf,d+0x8F,111);_w8(buf,d+0x90,99);_w8(buf,d+0x91,101) // roce
199 _w8(buf,d+0x92,115);_w8(buf,d+0x93,115);_w8(buf,d+0x94,72);_w8(buf,d+0x95,101) // ssHe
200 _w8(buf,d+0x96,97);_w8(buf,d+0x97,112);_w8(buf,d+0x98,0);_w8(buf,d+0x99,0) // ap\0 pad
201 // HeapAlloc (RVA 0x309A)
202 _w16(buf, d + 0x9A, 0)
203 _w8(buf,d+0x9C,72);_w8(buf,d+0x9D,101);_w8(buf,d+0x9E,97);_w8(buf,d+0x9F,112) // Heap
204 _w8(buf,d+0xA0,65);_w8(buf,d+0xA1,108);_w8(buf,d+0xA2,108);_w8(buf,d+0xA3,111) // Allo
205 _w8(buf,d+0xA4,99);_w8(buf,d+0xA5,0) // c\0
206 // GetStdHandle (RVA 0x30A6)
207 _w16(buf, d + 0xA6, 0)
208 _w8(buf,d+0xA8,71);_w8(buf,d+0xA9,101);_w8(buf,d+0xAA,116);_w8(buf,d+0xAB,83) // GetS
209 _w8(buf,d+0xAC,116);_w8(buf,d+0xAD,100);_w8(buf,d+0xAE,72);_w8(buf,d+0xAF,97) // tdHa
210 _w8(buf,d+0xB0,110);_w8(buf,d+0xB1,100);_w8(buf,d+0xB2,108);_w8(buf,d+0xB3,101) // ndle
211 _w8(buf,d+0xB4,0);_w8(buf,d+0xB5,0) // \0 pad
212 // WriteFile (RVA 0x30B6)
213 _w16(buf, d + 0xB6, 0)
214 _w8(buf,d+0xB8,87);_w8(buf,d+0xB9,114);_w8(buf,d+0xBA,105);_w8(buf,d+0xBB,116) // Writ
215 _w8(buf,d+0xBC,101);_w8(buf,d+0xBD,70);_w8(buf,d+0xBE,105);_w8(buf,d+0xBF,108) // eFil
216 _w8(buf,d+0xC0,101);_w8(buf,d+0xC1,0) // e\0
217 // ExitProcess (RVA 0x30C2)
218 _w16(buf, d + 0xC2, 0)
219 _w8(buf,d+0xC4,69);_w8(buf,d+0xC5,120);_w8(buf,d+0xC6,105);_w8(buf,d+0xC7,116) // Exit
220 _w8(buf,d+0xC8,80);_w8(buf,d+0xC9,114);_w8(buf,d+0xCA,111);_w8(buf,d+0xCB,99) // Proc
221 _w8(buf,d+0xCC,101);_w8(buf,d+0xCD,115);_w8(buf,d+0xCE,115);_w8(buf,d+0xCF,0) // ess\0
222 // "kernel32.dll\0" (RVA 0x30D0)
223 _w8(buf,d+0xD0,107);_w8(buf,d+0xD1,101);_w8(buf,d+0xD2,114);_w8(buf,d+0xD3,110) // kern
224 _w8(buf,d+0xD4,101);_w8(buf,d+0xD5,108);_w8(buf,d+0xD6,51);_w8(buf,d+0xD7,50) // el32
225 _w8(buf,d+0xD8,46);_w8(buf,d+0xD9,100);_w8(buf,d+0xDA,108);_w8(buf,d+0xDB,108);_w8(buf,d+0xDC,0) // .dll\0
226
227 return NX_PE_OK
228}
229
230func main() -> i64 {
231 let lenbox: *i64 = sys_mmap(16) as *i64
232 let src: *u8 = sys_read_file("/tmp/nxwin.s" as *u8, lenbox)
233 if (src as i64) == 0 { return 1 }
234 let n: i64 = lenbox[0]
235 if n <= 0 { return 2 }
236
237 let code: *u8 = sys_mmap(NXORG_CODE_CAP)
238 let mainbox: *i64 = sys_mmap(16) as *i64
239 let mmbox: *i64 = sys_mmap(16) as *i64
240 let swbox: *i64 = sys_mmap(16) as *i64
241 let sebox: *i64 = sys_mmap(16) as *i64
242 mainbox[0] = 0 - 1
243 mmbox[0] = 0 - 1
244 swbox[0] = 0 - 1
245 sebox[0] = 0 - 1
246 let code_len: i64 = nxorg_assemble(src, n, code, NXORG_CODE_CAP, mainbox, mmbox, swbox, sebox)
247 if code_len < 0 { return 3 }
248 let main_off: i64 = mainbox[0]
249 if main_off < 0 { return 4 }
250 let mm_off: i64 = mmbox[0]
251 if mm_off < 0 { return 6 }
252 let sw_off: i64 = swbox[0]
253 if sw_off < 0 { return 7 }
254 let se_off: i64 = sebox[0]
255 if se_off < 0 { return 8 }
256
257 let buf: *u8 = sys_mmap(NXORG_FILE_SIZE)
258 let rc: i64 = nxorg_emit_pe(buf, code, code_len, main_off, mm_off, sw_off, se_off)
259 if rc != NX_PE_OK { return 5 }
260
261 let outp: *u8 = "/mnt/c/Users/elder/nishi-core/nxc2/_offc/nx_win_search_index.exe" as *u8
262 if nx_pe_write_to_file(outp, buf, NXORG_FILE_SIZE) != NX_PE_OK { return 70 }
263
264 let msg: *u8 = "[substrate] nxc2-compiled native INDEX organ PE written: nx_win_search_index.exe\n" as *u8
265 sys_write(1, msg, 81)
266 return 0
267}