nx_pe_compile_win_httpd.nx source
↩ module page · 292 lines · 17945 B
1// nx_pe_compile_win_httpd.nx -- W-NET-1/2/3: a sovereign Nishi-native Windows HTTP server.
2// nxc2-compiled NishiLang -> native PE that listens on a TCP port via raw Winsock and serves HTTP.
3// No Docker, no VM, no WSL, no libc: kernel32 { ExitProcess } + ws2_32 { WSAStartup, socket, bind,
4// listen, accept, send, closesocket }. The keystone-linker resolves each socket shim to a Winsock
5// thunk (SysV->MS-x64 + sockaddr/htons built in-thunk). The 1:1 Elder-UI-on-:5173 migration vehicle.
6// Tolerant: only redirects shims that the source actually defines (so a socket+bind+listen probe and
7// the full serve loop both build from the same organ). lineage_id: substrate_pe_compile_win_httpd_v1
8import "nx_syscalls.nx"
9import "nxasm_x86.nx"
10import "nx_pe_writer.nx"
11
12const HD_CODE_CAP: i64 = 1048576
13const HD_FILE_SIZE: i64 = 0x1400 // headers(0x200)+.text(0x1000)+.idata(0x200)
14const HD_STUB_LEN: i64 = 18
15const HD_TEXT_CAP: i64 = 0x1000
16const HD_RVA_TEXT: i64 = 0x1000
17const HD_RVA_IDATA: i64 = 0x2000
18const HD_FOFF_TEXT: i64 = 0x200
19const HD_FOFF_IDATA:i64 = 0x1200
20// IAT RVAs (laid out below): kernel32 ExitProcess; ws2_32 funcs.
21const HD_IAT_EXIT: i64 = 0x2094
22const HD_IAT_WSA: i64 = 0x20A4
23const HD_IAT_SOCK: i64 = 0x20AC
24const HD_IAT_BIND: i64 = 0x20B4
25const HD_IAT_LISTEN:i64 = 0x20BC
26const HD_IAT_ACCEPT:i64 = 0x20C4
27const HD_IAT_SEND: i64 = 0x20CC
28const HD_IAT_CLOSE: i64 = 0x20D4
29const HD_IAT_RECV: i64 = 0x20DC
30
31// thunk lengths
32const HD_L_WSA: i64 = 31
33const HD_L_SOCK: i64 = 28
34const HD_L_BIND: i64 = 65
35const HD_L_LISTEN: i64 = 23
36const HD_L_ACCEPT: i64 = 23
37const HD_L_SEND: i64 = 27
38const HD_L_CLOSE: i64 = 18
39const HD_L_RECV: i64 = 38
40
41func hd_lbloff(src: *u8, n: i64, out: *u8, lab_off: *i64, lab_len: *i64, lab_addr: *i64, lab_sec: *i64, n_lab: i64, nm: *u8) -> i64 {
42 var k: i64 = 0
43 while k < n_lab {
44 if axc_tok_is(src, lab_off[k], lab_len[k], nm) == 1 { return lab_addr[k] }
45 k = k + 1
46 }
47 return 0 - 1
48}
49
50// assemble + resolve main and all socket shim labels (only those present resolve; absent = -1).
51func hd_assemble(src: *u8, n: i64, out: *u8, out_cap: i64, off: *i64) -> i64 {
52 let lab_off: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
53 let lab_len: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
54 let lab_addr: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
55 let lab_sec: *i64 = sys_mmap(ASM_MAX_LABELS * 8) as *i64
56 let op0: *i64 = sys_mmap(72) as *i64 // 9 slots for SIB (matches nxasm_x86)
57 let op1: *i64 = sys_mmap(72) as *i64
58 let op2: *i64 = sys_mmap(72) as *i64 // API DRIFT FIX: axc_pass gained op2
59 let scratch: *u8 = sys_mmap(64)
60 let posbox: *i64 = sys_mmap(16) as *i64
61 let n_lab_box: *i64 = sys_mmap(16) as *i64
62 n_lab_box[0] = 0
63 let lh: *i64 = sys_mmap(ASM_LH_SIZE * 8) as *i64
64
65 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)
66 if text_size < 0 { return text_size }
67 let n_lab: i64 = n_lab_box[0]
68 var k: i64 = 0
69 while k < n_lab { if lab_sec[k] == 1 { lab_addr[k] = lab_addr[k] + text_size } k = k + 1 }
70 axc_lh_build(src, lab_off, lab_len, n_lab, lh)
71 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)
72 if total < 0 { return total }
73 if total > out_cap { return 0 - 200 }
74 // off[0]=main off[1..7]=wsa,sock,bind,listen,accept,send,close
75 off[0] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "main")
76 off[1] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_wsa")
77 off[2] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_sock")
78 off[3] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_bind")
79 off[4] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_listen")
80 off[5] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_accept")
81 off[6] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_send")
82 off[7] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_close")
83 off[8] = hd_lbloff(src, n, out, lab_off, lab_len, lab_addr, lab_sec, n_lab, "nx_recv")
84 return total
85}
86
87// overwrite a shim's first 5 bytes (at text off shim_off) with jmp rel32 -> thunk at text off thunk_off
88func hd_redirect(buf: *u8, shim_off: i64, thunk_off: i64) -> i64 {
89 if shim_off < 0 { return 0 }
90 let shim_rva: i64 = HD_RVA_TEXT + HD_STUB_LEN + shim_off
91 let thunk_rva: i64 = HD_RVA_TEXT + thunk_off
92 let s: i64 = HD_FOFF_TEXT + HD_STUB_LEN + shim_off
93 _w8(buf, s+0, 0xE9); _w32(buf, s+1, thunk_rva - (shim_rva + 5))
94 return 0
95}
96
97func hd_emit_pe(buf: *u8, code: *u8, code_len: i64, off: *i64) -> i64 {
98 if (buf as i64) == 0 { return 0 - NX_PE_BAD_INPUT }
99 if off[0] < 0 { return 0 - NX_PE_BAD_INPUT }
100 // thunk region after [stub][code]
101 let twsa: i64 = HD_STUB_LEN + code_len
102 let tsock: i64 = twsa + HD_L_WSA
103 let tbind: i64 = tsock + HD_L_SOCK
104 let tlisten: i64 = tbind + HD_L_BIND
105 let taccept: i64 = tlisten + HD_L_LISTEN
106 let tsend: i64 = taccept + HD_L_ACCEPT
107 let tclose: i64 = tsend + HD_L_SEND
108 let trecv: i64 = tclose + HD_L_CLOSE
109 let tend: i64 = trecv + HD_L_RECV
110 if tend > HD_TEXT_CAP { return 0 - NX_PE_BAD_INPUT }
111
112 _w16(buf, 0, 0x5A4D); _w32(buf, 0x3C, FOFF_PE_SIG); _w32(buf, FOFF_PE_SIG, 0x00004550)
113 _w16(buf, FOFF_COFF + 0, PE_MACHINE_AMD64); _w16(buf, FOFF_COFF + 2, 2)
114 _w16(buf, FOFF_COFF + 16, 0xF0); _w16(buf, FOFF_COFF + 18, PE_CHAR_EXEC | PE_CHAR_LARGE_ADDR)
115 _w16(buf, FOFF_OPT + 0, PE_OH_MAGIC_PEPLUS); _w8(buf, FOFF_OPT + 2, 1)
116 _w32(buf, FOFF_OPT + 4, 0x1000); _w32(buf, FOFF_OPT + 8, 0x200)
117 _w32(buf, FOFF_OPT + 16, HD_RVA_TEXT); _w32(buf, FOFF_OPT + 20, HD_RVA_TEXT)
118 _w64(buf, FOFF_OPT + 24, IMG_BASE_LO, IMG_BASE_HI)
119 _w32(buf, FOFF_OPT + 32, 0x1000); _w32(buf, FOFF_OPT + 36, 0x200)
120 _w16(buf, FOFF_OPT + 40, 6); _w16(buf, FOFF_OPT + 48, 6)
121 _w32(buf, FOFF_OPT + 56, 0x3000); _w32(buf, FOFF_OPT + 60, 0x200)
122 _w16(buf, FOFF_OPT + 68, PE_SUBSYSTEM_CONSOLE)
123 _w64(buf, FOFF_OPT + 72, 0x100000, 0); _w64(buf, FOFF_OPT + 80, 0x1000, 0)
124 _w64(buf, FOFF_OPT + 88, 0x100000, 0); _w64(buf, FOFF_OPT + 96, 0x1000, 0)
125 _w32(buf, FOFF_OPT + 108, 16)
126 _w32(buf, FOFF_OPT + 112 + 8, HD_RVA_IDATA); _w32(buf, FOFF_OPT + 112 + 12, 0x3C)
127 _emit_section_header(buf, FOFF_SECT_TBL, 46, 116, 101, 120, 116, 0, 0, 0, tend, HD_RVA_TEXT, 0x1000, HD_FOFF_TEXT, PE_SECT_CODE_X_R)
128 _emit_section_header(buf, FOFF_SECT_TBL + 40, 46, 105, 100, 97, 116, 97, 0, 0, 0x164, HD_RVA_IDATA, 0x200, HD_FOFF_IDATA, PE_SECT_DATA_R)
129
130 // ===== entry stub (call main; exit with its return) =====
131 let t: i64 = HD_FOFF_TEXT
132 _w8(buf, t+0, 0x48); _w8(buf, t+1, 0x83); _w8(buf, t+2, 0xEC); _w8(buf, t+3, 0x28)
133 _w8(buf, t+4, 0xE8); _w32(buf, t+5, 0x9 + off[0])
134 _w8(buf, t+9, 0x89); _w8(buf, t+10, 0xC1)
135 _w8(buf, t+11, 0xFF); _w8(buf, t+12, 0x15); _w32(buf, t+13, HD_IAT_EXIT - (HD_RVA_TEXT + 17))
136 _w8(buf, t+17, 0xCC)
137 var i: i64 = 0
138 while i < code_len { buf[t + HD_STUB_LEN + i] = code[i]; i = i + 1 }
139
140 // ===== thunks =====
141 // -- WSA (nx_wsa -> WSAStartup, own-stack WSADATA) --
142 var rva: i64 = HD_RVA_TEXT + twsa
143 var a: i64 = HD_FOFF_TEXT + twsa
144 _w8(buf,a+0,0x48);_w8(buf,a+1,0x81);_w8(buf,a+2,0xEC);_w32(buf,a+3,0x228)
145 _w8(buf,a+7,0xB9);_w32(buf,a+8,0x0202)
146 _w8(buf,a+12,0x48);_w8(buf,a+13,0x8D);_w8(buf,a+14,0x54);_w8(buf,a+15,0x24);_w8(buf,a+16,0x28)
147 _w8(buf,a+17,0xFF);_w8(buf,a+18,0x15);_w32(buf,a+19,HD_IAT_WSA-(rva+23))
148 _w8(buf,a+23,0x48);_w8(buf,a+24,0x81);_w8(buf,a+25,0xC4);_w32(buf,a+26,0x228)
149 _w8(buf,a+30,0xC3)
150 // -- SOCK (nx_sock -> socket(2,1,0)) --
151 rva = HD_RVA_TEXT + tsock; a = HD_FOFF_TEXT + tsock
152 _w8(buf,a+0,0x48);_w8(buf,a+1,0x83);_w8(buf,a+2,0xEC);_w8(buf,a+3,0x28)
153 _w8(buf,a+4,0xB9);_w32(buf,a+5,2)
154 _w8(buf,a+9,0xBA);_w32(buf,a+10,1)
155 _w8(buf,a+14,0x45);_w8(buf,a+15,0x31);_w8(buf,a+16,0xC0)
156 _w8(buf,a+17,0xFF);_w8(buf,a+18,0x15);_w32(buf,a+19,HD_IAT_SOCK-(rva+23))
157 _w8(buf,a+23,0x48);_w8(buf,a+24,0x83);_w8(buf,a+25,0xC4);_w8(buf,a+26,0x28)
158 _w8(buf,a+27,0xC3)
159 // -- BIND (nx_bind(s,port) -> sockaddr_in + bind) --
160 rva = HD_RVA_TEXT + tbind; a = HD_FOFF_TEXT + tbind
161 _w8(buf,a+0,0x48);_w8(buf,a+1,0x83);_w8(buf,a+2,0xEC);_w8(buf,a+3,0x38) // sub rsp,0x38
162 _w8(buf,a+4,0x66);_w8(buf,a+5,0xC7);_w8(buf,a+6,0x44);_w8(buf,a+7,0x24);_w8(buf,a+8,0x20);_w16(buf,a+9,2) // mov word[rsp+0x20],2
163 _w8(buf,a+11,0x66);_w8(buf,a+12,0x89);_w8(buf,a+13,0xF0) // mov ax,si
164 _w8(buf,a+14,0x66);_w8(buf,a+15,0xC1);_w8(buf,a+16,0xC0);_w8(buf,a+17,0x08) // rol ax,8 (htons)
165 _w8(buf,a+18,0x66);_w8(buf,a+19,0x89);_w8(buf,a+20,0x44);_w8(buf,a+21,0x24);_w8(buf,a+22,0x22) // mov word[rsp+0x22],ax
166 _w8(buf,a+23,0xC7);_w8(buf,a+24,0x44);_w8(buf,a+25,0x24);_w8(buf,a+26,0x24);_w32(buf,a+27,0) // mov dword[rsp+0x24],0
167 _w8(buf,a+31,0x48);_w8(buf,a+32,0xC7);_w8(buf,a+33,0x44);_w8(buf,a+34,0x24);_w8(buf,a+35,0x28);_w32(buf,a+36,0) // mov qword[rsp+0x28],0
168 _w8(buf,a+40,0x48);_w8(buf,a+41,0x89);_w8(buf,a+42,0xF9) // mov rcx,rdi
169 _w8(buf,a+43,0x48);_w8(buf,a+44,0x8D);_w8(buf,a+45,0x54);_w8(buf,a+46,0x24);_w8(buf,a+47,0x20) // lea rdx,[rsp+0x20]
170 _w8(buf,a+48,0x41);_w8(buf,a+49,0xB8);_w32(buf,a+50,16) // mov r8d,16
171 _w8(buf,a+54,0xFF);_w8(buf,a+55,0x15);_w32(buf,a+56,HD_IAT_BIND-(rva+60)) // call [bind]
172 _w8(buf,a+60,0x48);_w8(buf,a+61,0x83);_w8(buf,a+62,0xC4);_w8(buf,a+63,0x38) // add rsp,0x38
173 _w8(buf,a+64,0xC3)
174 // -- LISTEN (nx_listen(s) -> listen(s,16)) --
175 rva = HD_RVA_TEXT + tlisten; a = HD_FOFF_TEXT + tlisten
176 _w8(buf,a+0,0x48);_w8(buf,a+1,0x83);_w8(buf,a+2,0xEC);_w8(buf,a+3,0x28)
177 _w8(buf,a+4,0x48);_w8(buf,a+5,0x89);_w8(buf,a+6,0xF9)
178 _w8(buf,a+7,0xBA);_w32(buf,a+8,16)
179 _w8(buf,a+12,0xFF);_w8(buf,a+13,0x15);_w32(buf,a+14,HD_IAT_LISTEN-(rva+18))
180 _w8(buf,a+18,0x48);_w8(buf,a+19,0x83);_w8(buf,a+20,0xC4);_w8(buf,a+21,0x28)
181 _w8(buf,a+22,0xC3)
182 // -- ACCEPT (nx_accept(s) -> accept(s,0,0)) --
183 rva = HD_RVA_TEXT + taccept; a = HD_FOFF_TEXT + taccept
184 _w8(buf,a+0,0x48);_w8(buf,a+1,0x83);_w8(buf,a+2,0xEC);_w8(buf,a+3,0x28)
185 _w8(buf,a+4,0x48);_w8(buf,a+5,0x89);_w8(buf,a+6,0xF9)
186 _w8(buf,a+7,0x31);_w8(buf,a+8,0xD2)
187 _w8(buf,a+9,0x45);_w8(buf,a+10,0x31);_w8(buf,a+11,0xC0)
188 _w8(buf,a+12,0xFF);_w8(buf,a+13,0x15);_w32(buf,a+14,HD_IAT_ACCEPT-(rva+18))
189 _w8(buf,a+18,0x48);_w8(buf,a+19,0x83);_w8(buf,a+20,0xC4);_w8(buf,a+21,0x28)
190 _w8(buf,a+22,0xC3)
191 // -- SEND (nx_send(c,buf,n) -> send(c,buf,n,0)) --
192 rva = HD_RVA_TEXT + tsend; a = HD_FOFF_TEXT + tsend
193 _w8(buf,a+0,0x48);_w8(buf,a+1,0x83);_w8(buf,a+2,0xEC);_w8(buf,a+3,0x28)
194 _w8(buf,a+4,0x48);_w8(buf,a+5,0x89);_w8(buf,a+6,0xF9) // mov rcx,rdi (c)
195 _w8(buf,a+7,0x49);_w8(buf,a+8,0x89);_w8(buf,a+9,0xD0) // mov r8,rdx (n)
196 _w8(buf,a+10,0x48);_w8(buf,a+11,0x89);_w8(buf,a+12,0xF2) // mov rdx,rsi (buf)
197 _w8(buf,a+13,0x45);_w8(buf,a+14,0x31);_w8(buf,a+15,0xC9) // xor r9d,r9d
198 _w8(buf,a+16,0xFF);_w8(buf,a+17,0x15);_w32(buf,a+18,HD_IAT_SEND-(rva+22))
199 _w8(buf,a+22,0x48);_w8(buf,a+23,0x83);_w8(buf,a+24,0xC4);_w8(buf,a+25,0x28)
200 _w8(buf,a+26,0xC3)
201 // -- CLOSE (nx_close(c) -> closesocket(c)) --
202 rva = HD_RVA_TEXT + tclose; a = HD_FOFF_TEXT + tclose
203 _w8(buf,a+0,0x48);_w8(buf,a+1,0x83);_w8(buf,a+2,0xEC);_w8(buf,a+3,0x28)
204 _w8(buf,a+4,0x48);_w8(buf,a+5,0x89);_w8(buf,a+6,0xF9)
205 _w8(buf,a+7,0xFF);_w8(buf,a+8,0x15);_w32(buf,a+9,HD_IAT_CLOSE-(rva+13))
206 _w8(buf,a+13,0x48);_w8(buf,a+14,0x83);_w8(buf,a+15,0xC4);_w8(buf,a+16,0x28)
207 _w8(buf,a+17,0xC3)
208 // -- RECV (nx_recv(c) -> recv(c, own-stack buf, 0x400, 0); drains request for graceful close) --
209 rva = HD_RVA_TEXT + trecv; a = HD_FOFF_TEXT + trecv
210 _w8(buf,a+0,0x48);_w8(buf,a+1,0x81);_w8(buf,a+2,0xEC);_w32(buf,a+3,0x428) // sub rsp,0x428
211 _w8(buf,a+7,0x48);_w8(buf,a+8,0x89);_w8(buf,a+9,0xF9) // mov rcx,rdi (c)
212 _w8(buf,a+10,0x48);_w8(buf,a+11,0x8D);_w8(buf,a+12,0x54);_w8(buf,a+13,0x24);_w8(buf,a+14,0x28) // lea rdx,[rsp+0x28]
213 _w8(buf,a+15,0x41);_w8(buf,a+16,0xB8);_w32(buf,a+17,0x400) // mov r8d,0x400
214 _w8(buf,a+21,0x45);_w8(buf,a+22,0x31);_w8(buf,a+23,0xC9) // xor r9d,r9d
215 _w8(buf,a+24,0xFF);_w8(buf,a+25,0x15);_w32(buf,a+26,HD_IAT_RECV-(rva+30)) // call [recv]
216 _w8(buf,a+30,0x48);_w8(buf,a+31,0x81);_w8(buf,a+32,0xC4);_w32(buf,a+33,0x428) // add rsp,0x428
217 _w8(buf,a+37,0xC3) // ret
218
219 // ===== redirect shims that exist =====
220 hd_redirect(buf, off[1], twsa)
221 hd_redirect(buf, off[2], tsock)
222 hd_redirect(buf, off[3], tbind)
223 hd_redirect(buf, off[4], tlisten)
224 hd_redirect(buf, off[5], taccept)
225 hd_redirect(buf, off[6], tsend)
226 hd_redirect(buf, off[7], tclose)
227 hd_redirect(buf, off[8], trecv)
228
229 // ===== .idata: kernel32{ExitProcess} + ws2_32{WSAStartup,socket,bind,listen,accept,send,closesocket,recv} =====
230 let d: i64 = HD_FOFF_IDATA
231 // descriptors
232 _w32(buf,d+0x00,0x203C); _w32(buf,d+0x0C,0x214C); _w32(buf,d+0x10,0x2094) // kernel32: OFT,Name,FT
233 _w32(buf,d+0x14,0x204C); _w32(buf,d+0x20,0x2159); _w32(buf,d+0x24,0x20A4) // ws2_32: OFT,Name,FT
234 // INT_k @0x3C
235 _w64(buf,d+0x3C,0x20EC,0); _w64(buf,d+0x44,0,0)
236 // INT_w @0x4C (8 funcs + null)
237 _w64(buf,d+0x4C,0x20FA,0); _w64(buf,d+0x54,0x2108,0); _w64(buf,d+0x5C,0x2112,0); _w64(buf,d+0x64,0x211A,0)
238 _w64(buf,d+0x6C,0x2124,0); _w64(buf,d+0x74,0x212E,0); _w64(buf,d+0x7C,0x2136,0); _w64(buf,d+0x84,0x2144,0); _w64(buf,d+0x8C,0,0)
239 // IAT_k @0x94
240 _w64(buf,d+0x94,0x20EC,0); _w64(buf,d+0x9C,0,0)
241 // IAT_w @0xA4 (8 funcs + null)
242 _w64(buf,d+0xA4,0x20FA,0); _w64(buf,d+0xAC,0x2108,0); _w64(buf,d+0xB4,0x2112,0); _w64(buf,d+0xBC,0x211A,0)
243 _w64(buf,d+0xC4,0x2124,0); _w64(buf,d+0xCC,0x212E,0); _w64(buf,d+0xD4,0x2136,0); _w64(buf,d+0xDC,0x2144,0); _w64(buf,d+0xE4,0,0)
244 // names (IMAGE_IMPORT_BY_NAME: hint16 + asciiz, even-aligned)
245 // ExitProcess @0xEC
246 _w16(buf,d+0xEC,0);_w8(buf,d+0xEE,69);_w8(buf,d+0xEF,120);_w8(buf,d+0xF0,105);_w8(buf,d+0xF1,116);_w8(buf,d+0xF2,80);_w8(buf,d+0xF3,114);_w8(buf,d+0xF4,111);_w8(buf,d+0xF5,99);_w8(buf,d+0xF6,101);_w8(buf,d+0xF7,115);_w8(buf,d+0xF8,115);_w8(buf,d+0xF9,0)
247 // WSAStartup @0xFA
248 _w16(buf,d+0xFA,0);_w8(buf,d+0xFC,87);_w8(buf,d+0xFD,83);_w8(buf,d+0xFE,65);_w8(buf,d+0xFF,83);_w8(buf,d+0x100,116);_w8(buf,d+0x101,97);_w8(buf,d+0x102,114);_w8(buf,d+0x103,116);_w8(buf,d+0x104,117);_w8(buf,d+0x105,112);_w8(buf,d+0x106,0);_w8(buf,d+0x107,0)
249 // socket @0x108
250 _w16(buf,d+0x108,0);_w8(buf,d+0x10A,115);_w8(buf,d+0x10B,111);_w8(buf,d+0x10C,99);_w8(buf,d+0x10D,107);_w8(buf,d+0x10E,101);_w8(buf,d+0x10F,116);_w8(buf,d+0x110,0);_w8(buf,d+0x111,0)
251 // bind @0x112
252 _w16(buf,d+0x112,0);_w8(buf,d+0x114,98);_w8(buf,d+0x115,105);_w8(buf,d+0x116,110);_w8(buf,d+0x117,100);_w8(buf,d+0x118,0);_w8(buf,d+0x119,0)
253 // listen @0x11A
254 _w16(buf,d+0x11A,0);_w8(buf,d+0x11C,108);_w8(buf,d+0x11D,105);_w8(buf,d+0x11E,115);_w8(buf,d+0x11F,116);_w8(buf,d+0x120,101);_w8(buf,d+0x121,110);_w8(buf,d+0x122,0);_w8(buf,d+0x123,0)
255 // accept @0x124
256 _w16(buf,d+0x124,0);_w8(buf,d+0x126,97);_w8(buf,d+0x127,99);_w8(buf,d+0x128,99);_w8(buf,d+0x129,101);_w8(buf,d+0x12A,112);_w8(buf,d+0x12B,116);_w8(buf,d+0x12C,0);_w8(buf,d+0x12D,0)
257 // send @0x12E
258 _w16(buf,d+0x12E,0);_w8(buf,d+0x130,115);_w8(buf,d+0x131,101);_w8(buf,d+0x132,110);_w8(buf,d+0x133,100);_w8(buf,d+0x134,0);_w8(buf,d+0x135,0)
259 // closesocket @0x136
260 _w16(buf,d+0x136,0);_w8(buf,d+0x138,99);_w8(buf,d+0x139,108);_w8(buf,d+0x13A,111);_w8(buf,d+0x13B,115);_w8(buf,d+0x13C,101);_w8(buf,d+0x13D,115);_w8(buf,d+0x13E,111);_w8(buf,d+0x13F,99);_w8(buf,d+0x140,107);_w8(buf,d+0x141,101);_w8(buf,d+0x142,116);_w8(buf,d+0x143,0)
261 // recv @0x144
262 _w16(buf,d+0x144,0);_w8(buf,d+0x146,114);_w8(buf,d+0x147,101);_w8(buf,d+0x148,99);_w8(buf,d+0x149,118);_w8(buf,d+0x14A,0);_w8(buf,d+0x14B,0)
263 // "kernel32.dll" @0x14C
264 _w8(buf,d+0x14C,107);_w8(buf,d+0x14D,101);_w8(buf,d+0x14E,114);_w8(buf,d+0x14F,110);_w8(buf,d+0x150,101);_w8(buf,d+0x151,108);_w8(buf,d+0x152,51);_w8(buf,d+0x153,50);_w8(buf,d+0x154,46);_w8(buf,d+0x155,100);_w8(buf,d+0x156,108);_w8(buf,d+0x157,108);_w8(buf,d+0x158,0)
265 // "ws2_32.dll" @0x159
266 _w8(buf,d+0x159,119);_w8(buf,d+0x15A,115);_w8(buf,d+0x15B,50);_w8(buf,d+0x15C,95);_w8(buf,d+0x15D,51);_w8(buf,d+0x15E,50);_w8(buf,d+0x15F,46);_w8(buf,d+0x160,100);_w8(buf,d+0x161,108);_w8(buf,d+0x162,108);_w8(buf,d+0x163,0)
267
268 return NX_PE_OK
269}
270
271func main() -> i64 {
272 let lenbox: *i64 = sys_mmap(16) as *i64
273 let src: *u8 = sys_read_file("/tmp/nxwin.s" as *u8, lenbox)
274 if (src as i64) == 0 { return 1 }
275 let n: i64 = lenbox[0]
276 if n <= 0 { return 2 }
277 let code: *u8 = sys_mmap(HD_CODE_CAP)
278 let off: *i64 = sys_mmap(16 * 8) as *i64
279 var z: i64 = 0
280 while z < 9 { off[z] = 0 - 1; z = z + 1 }
281 let code_len: i64 = hd_assemble(src, n, code, HD_CODE_CAP, off)
282 if code_len < 0 { return 3 }
283 if off[0] < 0 { return 4 }
284 let buf: *u8 = sys_mmap(HD_FILE_SIZE)
285 let rc: i64 = hd_emit_pe(buf, code, code_len, off)
286 if rc != NX_PE_OK { return 5 }
287 let outp: *u8 = "/mnt/c/Users/elder/nishi-core/nxc2/_offc/nx_win_httpd.exe" as *u8
288 if nx_pe_write_to_file(outp, buf, HD_FILE_SIZE) != NX_PE_OK { return 70 }
289 let msg: *u8 = "[substrate] nxc2-compiled native Winsock HTTP server PE written: nx_win_httpd.exe\n" as *u8
290 sys_write(1, msg, 82)
291 return 0
292}