{"id":938,"date":"2016-02-06T20:11:48","date_gmt":"2016-02-06T12:11:48","guid":{"rendered":"http:\/\/qing.su\/?p=938"},"modified":"2016-02-06T20:27:01","modified_gmt":"2016-02-06T12:27:01","slug":"119","status":"publish","type":"post","link":"https:\/\/qing.su\/article\/119.html","title":{"rendered":"\u79d1\u666e\u5411\u2014\u2014\u4f7f\u7528BrainFuck\u8bed\u8a00\u7f16\u5199\u7b80\u5355\u7f51\u9875"},"content":{"rendered":"

\u4eca\u5929\u82b1\u4e86\u534a\u4e2a\u5c0f\u65f6\u7528BrainFuck\u8bed\u8a00\u7f16\u5199\u4e86\u4e00\u4e2a\u53ea\u6709\u4e00\u884c\u5b57\u7684\u7f51\u9875\uff08\u540c\u6837\u7684\u4e8b\u60c5\u5982\u679c\u7528C\u8bed\u8a00\u5927\u6982\u9700\u8981\u82b15\u5206\u949f\uff0c\u7528PHP\u53ea\u9700\u898120\u79d2\u949f\uff09\uff0c\u5927\u6982\u6ca1\u4eba\u6bd4\u6211\u66f4\u65e0\u804a\u4e86\u5427\u3002\u5730\u5740\u662fhttp:\/\/qing.su\/cgi-bin\/brainfuck.cgi<\/a><\/p>\n

BrainFuck\u662f\u4e16\u754c\u4e0a\u6700\u7cbe\u81f4\u7684\u56fe\u7075\u5b8c\u5907\u7684\u8ba1\u7b97\u673a\u8bed\u8a00\uff08\u5176\u7f16\u8bd1\u5668\u4ec5\u6709240bytes\uff09\u3002\u5b83\u7531\u516b\u4e2a\u5b57\u7b26\u6784\u6210\uff1a<>+-.,[]\u5206\u522b\u4ee3\u8868\u4e86\u5de6\u53f3\u4f4d\u79fb\u3001\u589e\u51cf\u53d8\u91cf\u3001\u8f93\u51fa\u8f93\u5165\u4ee5\u53ca\u5faa\u73af\u5f00\u95ed\u3002\u5982\u6b64\u6709\u9650\u7684\u5b57\u7b26\u5e93\u51b3\u5b9a\u4e86\u5176\u7f16\u5199\u8fc7\u7a0b\u7684\u7e41\u7410\u548c\u5197\u957f\u3001\u6613\u8bfb\u6027\u6781\u5dee\uff0c\u51e0\u4e4e\u65e0\u6cd5\u6210\u4e3a\u771f\u6b63\u751f\u4ea7\u4f7f\u7528\u7684\u8ba1\u7b97\u673a\u8bed\u8a00\u3002\u6216\u8bb8\uff0c\u5076\u5c14\u7f16\u5199\u4e00\u4e2aBrainFuck\u7a0b\u5e8f\u70e7\u4e00\u70e7\u8111\u5b50\u662f\u4e0d\u9519\u7684\u9009\u62e9\u3002\u4e0b\u9762\u4ecb\u7ecd\u4e00\u4e0b\u7528BrainFuck\u8bed\u8a00\u7f16\u5199\u7f51\u9875\u7684\u65b9\u5f0f\u3002<\/p>\n

\u5f00\u59cb\u7f16\u5199\u7f51\u9875\u4e4b\u524d\uff0c\u9700\u8981\u4e86\u89e3\u4e00\u4e0bCGI\u7f16\u7a0b\u89c4\u8303\u3002\u4efb\u4f55\u4e00\u79cd\u8bed\u8a00\u7f16\u5199\u7684\u7a0b\u5e8f\u90fd\u53ef\u4ee5\u6210\u4e3a\u7f51\u9875\u3002\u5982PHP, JSP\u4e4b\u7c7b\u7684\u7a0b\u5e8f\u53ef\u4ee5\u901a\u8fc7\u5bf9\u5e94\u7684\u811a\u672c\u89e3\u91ca\u5668\u8f6c\u6362\u4e3aHTML\u6807\u7b7e\u683c\u5f0f\uff0c\u76f4\u63a5\u5448\u73b0\u5728\u6d4f\u89c8\u5668\u4e0a\u4f9b\u4eba\u4eec\u8bbf\u95ee\u3002\u800c\u5982\u679c\u4f7f\u7528\u5176\u4ed6\u975e\u4e3b\u6d41\u8bed\u8a00\uff0c\u6bd4\u5982\u4e4b\u524d\u63d0\u5230\u7684C\u8bed\u8a00\uff08\u53c2\u8003 http:\/\/qing.su\/article\/93.html<\/a>\uff09\u6216\u8005\u6b63\u5728\u4f7f\u7528\u7684BrainFuck\u8bed\u8a00\uff0c\u5219\u53ef\u4ee5\u901a\u8fc7CGI\u7684\u65b9\u5f0f\u8bbf\u95ee\uff0c\u8ba9\u670d\u52a1\u5668\u5c06\u7a0b\u5e8f\u8f6c\u5316\u4e3aHTML\u6807\u7b7e\u63d0\u4f9b\u7ed9\u5ba2\u6237\u7aef\u6d4f\u89c8\u5668\u8bc6\u522b\u3002\u6309\u7167CGI\u7684\u8981\u6c42\uff0c\u8f93\u51fa\u5230\u6d4f\u89c8\u5668\u4e0a\u7684\u7a0b\u5e8f\u9700\u8981\u9996\u5148\u63d0\u4ea4\u5934\u4fe1\u606f\uff0c\u6bd4\u5982\uff0cContent-type: text\/html, \u5e76\u4e14\u5728\u5934\u4fe1\u606f\u4e0b\u90e8\u6709\u4e00\u7a7a\u884c\u3002\u56e0\u6b64\uff0c\u53ea\u8981\u9075\u5faa\u8fd9\u4e00\u89c4\u8303\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u7528\u4efb\u4f55\u8bed\u8a00\u7684\u7a0b\u5e8f\u7f16\u5199\u7f51\u9875\u3002<\/p>\n

\u9996\u5148\uff0c\u7f16\u5199\u4e00\u4e2aBrainFuck\u8bed\u8a00\u7a0b\u5e8f\uff0c\u5982\u4e0b\u3002<\/p>\n

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<\/div><\/td>
++++++++++   * \u53d8\u91cf\u7b2c\u96f6\u4f4d+10, \u50a8\u5b58\u5faa\u73af\u6b21\u6570
\n[>+++++++++++   * \u53d8\u91cf\u7b2c\u4e00\u4f4d+11, 10*11=110 == asc('n')
\n>++++++++++++>+++>++++++>+++++++>++++++++>+>++++   * \u7c7b\u4f3c\u4e0a\u4e00\u6b65\uff0c\u8bbe\u7f6e8\u4e2a\u53d8\u91cf\u65b9\u4fbf\u8f93\u51fa\u5b57\u7b26
\n<<<<<<<<-]   * \u5faa\u73af\uff0c\u6bcf\u6b21\u5faa\u73af\u7b2c\u4e00\u4f4d\u53d8\u91cf-1, \u76f4\u81f30
\n>>>>>---.   * \u7b2c\u4e94\u4f4d\u53d8\u91cf-3, \u8f93\u51fa10*7-3=67 == asc('C')
\n<<<<+.   * \u7b2c\u4e00\u4f4d\u53d8\u91cf+1, \u8f93\u51fa10*11+1=111 == asc('o')
\n-.   * \u7b2c\u4e00\u4f4d\u53d8\u91cf-1, 110 'n'
\n>----.   * \u7b2c\u4e8c\u4f4d\u53d8\u91cf-4, 10*12-4=116 == asc('t')
\n<---------.   * \u7b2c\u4e00\u4f4d\u53d8\u91cf-9, 101 'e'
\n+++++++++.>.>>>>>>+++++.
\n<<<<<<.+++++.<++.-----------.
\n>>>--.<++.<-----.<.>++++.----.
\n>>>>>>++.<<<<<<<+++.>.<+++++.-.
\n>>>>>>..<<+++++.--<+++++++.>>..
\n+++++++++.<<<.>>++++++++.--<++++.++++++++++++++++++.
\n------------------>>--<<<.
\n>>>++.<<.----.>++++++.<<+.    * \u7ee7\u7eed\u4e4b\u524d\u7684\u8f93\u51fa<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

\u8fd9\u4e2a\u7a0b\u5e8f\u505a\u4e86\u4e24\u4ef6\u4e8b\uff1a1\uff0c\u5411\u670d\u52a1\u5668\u8f93\u51faContent-type: text\/html\\n\\n. 2\uff0c\u5411\u670d\u52a1\u5668\u8f93\u51fa\u9700\u8981\u663e\u793a\u5728\u5c4f\u5e55\u4e0a\u7684\u53e5\u5b50\uff0cHAPPY NEW YEAR! <\/p>\n

\u7f16\u5199\u5b8c\u6bd5\u540e\uff0c\u6211\u4eec\u5728\u670d\u52a1\u5668\u4e0a\u5c06\u5176\u7f16\u8bd1\u4e3a\u53ef\u6267\u884c\u7a0b\u5e8f\u3002\u7f16\u8bd1\u5668\u4e3a\u6c47\u7f16\u6e90\u7801\uff08\u94fe\u63a5\u4e3a\uff1ahttp:\/\/www.muppetlabs.com\/~breadbox\/software\/tiny\/bf.asm.txt\uff09\uff0c\u53ef\u4ee5\u7528nasm\u7a0b\u5e8f\u5c06\u5176\u7f16\u8bd1\u6210\u53ef\u6267\u884c\u7a0b\u5e8f\u3002\u65b0\u5efa\u6587\u4ef6bf.asm\u5c06\u6e90\u7801\u4fdd\u5b58\u5728\u5176\u4e2d\uff1a<\/p>\n

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
<\/div><\/td>
;; bf.asm: Copyright (C) 1999 Brian Raiter <breadbox@muppetlabs.com><\/span>
\n;; Licensed under the terms of the GNU General Public License, either<\/span>
\n;; version 2 or (at your option) any later version.<\/span>
\n;;<\/span>
\n;; To build:<\/span>
\n;;  nasm -f bin -o bf bf.asm && chmod +x bf<\/span>
\n;; To use:<\/span>
\n;;  bf < foo.b > foo && chmod +x foo<\/span>
\n
\nBITS<\/span> 32<\/span>
\n
\n;; This is the size of the data area supplied to compiled programs.<\/span>
\n
\n%define<\/span> arraysize   30000<\/span>
\n
\n;; For the compiler, the text segment is also the data segment. The<\/span>
\n;; memory image of the compiler is inside the code buffer, and is<\/span>
\n;; modified in place to become the memory image of the compiled<\/span>
\n;; program. The area of memory that is the data segment for compiled<\/span>
\n;; programs is not used by the compiler. The text and data segments of<\/span>
\n;; compiled programs are really only different areas in a single<\/span>
\n;; segment, from the system's point of view. Both the compiler and<\/span>
\n;; compiled programs load the entire file contents into a single<\/span>
\n;; memory segment which is both writeable and executable.<\/span>
\n
\n%define<\/span> TEXTORG     0x45E9B000<\/span>
\n%define<\/span> DATAOFFSET  0x2000<\/span>
\n%define<\/span> DATAORG     (<\/span>TEXTORG +<\/span> DATAOFFSET)<\/span>
\n
\n;; Here begins the file image.<\/span>
\n
\n        org TEXTORG
\n
\n;; At the beginning of the text segment is the ELF header and the<\/span>
\n;; program header table, the latter consisting of a single entry. The<\/span>
\n;; two structures overlap for a space of eight bytes. Nearly all<\/span>
\n;; unused fields in the structures are used to hold bits of code.<\/span>
\n
\n;; The beginning of the ELF header.<\/span>
\n
\n        db<\/span>  0x7F<\/span>,<\/span> "ELF"<\/span>     ; ehdr.e_ident<\/span>
\n
\n;; The top(s) of the main compiling loop. The loop jumps back to<\/span>
\n;; different positions, depending on how many bytes to copy into the<\/span>
\n;; code buffer. After doing that, esi is initialized to point to the<\/span>
\n;; epilog code chunk, a copy of edi (the pointer to the end of the<\/span>
\n;; code buffer) is saved in ebp, the high bytes of eax are reset to<\/span>
\n;; zero (via the exchange with ebx), and then the next character of<\/span>
\n;; input is retrieved.<\/span>
\n
\nemitputchar:<\/span>    add<\/span> esi<\/span>,<\/span> byte<\/span> (<\/span>putchar -<\/span> decchar)<\/span> -<\/span> 4<\/span>
\nemitgetchar:<\/span>    lodsd<\/span>
\nemit6bytes:<\/span> movsd<\/span>
\nemit2bytes:<\/span> movsb<\/span>
\nemit1byte:<\/span>  movsb<\/span>
\ncompile:<\/span>    lea<\/span> esi<\/span>,<\/span> [<\/span>byte<\/span> ecx<\/span> +<\/span> epilog -<\/span> filesize]<\/span>
\n        xchg<\/span>    eax<\/span>,<\/span> ebx<\/span>
\n        cmp<\/span> eax<\/span>,<\/span> 0x00030002<\/span>     ; ehdr.e_type    (0x0002)<\/span>
\n                        ; ehdr.e_machine (0x0003)<\/span>
\n        mov<\/span> ebp<\/span>,<\/span> edi<\/span>        ; ehdr.e_version<\/span>
\n        jmp<\/span> short getchar
\n
\n;; The entry point for the compiler (and compiled programs), and the<\/span>
\n;; location of the program header table.<\/span>
\n
\n        dd<\/span>  _start          ; ehdr.e_entry<\/span>
\n        dd<\/span>  proghdr -<\/span> $$<\/span>        ; ehdr.e_phoff<\/span>
\n
\n;; The last routine of the compiler, called when there is no more<\/span>
\n;; input. The epilog code chunk is copied into the code buffer. The<\/span>
\n;; text origin is popped off the stack into ecx, and subtracted from<\/span>
\n;; edi to determine the size of the compiled program. This value is<\/span>
\n;; stored in the program header table, and then is moved into edx.<\/span>
\n;; The program then jumps to the putchar routine, which sends the<\/span>
\n;; compiled program to stdout before falling through to the epilog<\/span>
\n;; routine and exiting.<\/span>
\n
\neof:<\/span>        movsd<\/span>               ; ehdr.e_shoff<\/span>
\n        xchg<\/span>    eax<\/span>,<\/span> ecx<\/span>
\n        pop<\/span> ecx<\/span>
\n        sub<\/span> edi<\/span>,<\/span> ecx<\/span>        ; ehdr.e_flags<\/span>
\n        xchg<\/span>    eax<\/span>,<\/span> edi<\/span>
\n        stosd<\/span>
\n        xchg<\/span>    eax<\/span>,<\/span> edx<\/span>
\n        jmp<\/span> short putchar       ; ehdr.e_ehsize<\/span>
\n
\n;; 0x20 == the size of one program header table entry.<\/span>
\n
\n        dw<\/span>  0x20<\/span>            ; ehdr.e_phentsize<\/span>
\n
\n;; The beginning of the program header table. 1 == PT_LOAD, indicating<\/span>
\n;; that the segment is to be loaded into memory.<\/span>
\n
\nproghdr:<\/span>    dd<\/span>  1<\/span>           ; ehdr.e_phnum & phdr.p_type<\/span>
\n                        ; ehdr.e_shentsize<\/span>
\n        dd<\/span>  0<\/span>           ; ehdr.e_shnum & phdr.p_offset<\/span>
\n                        ; ehdr.e_shstrndx<\/span>
\n
\n;; (Note that the next four bytes, in addition to containing the first<\/span>
\n;; two instructions of the bracket routine, also comprise the memory<\/span>
\n;; address of the text origin.)<\/span>
\n
\n        db<\/span>  0<\/span>           ; phdr.p_vaddr<\/span>
\n
\n;; The bracket routine emits code for the "[" instruction. This<\/span>
\n;; instruction translates to a simple "jmp near", but the target of<\/span>
\n;; the jump will not be known until the matching "]" is seen. The<\/span>
\n;; routine thus outputs a random target, and pushes the location of<\/span>
\n;; the target in the code buffer onto the stack.<\/span>
\n
\nbracket:<\/span>    mov<\/span> al<\/span>,<\/span> 0xE9<\/span>
\n        inc<\/span> ebp<\/span>
\n        push<\/span>    ebp<\/span>         ; phdr.p_paddr<\/span>
\n        stosd<\/span>
\n        jmp<\/span> short emit1byte
\n
\n;; This is where the size of the executable file is stored in the<\/span>
\n;; program header table. The compiler updates this value just before<\/span>
\n;; it outputs the compiled program. This is the only field in the two<\/span>
\n;; headers that differs between the compiler and its compiled<\/span>
\n;; programs. (While the compiler is reading input, the first byte of<\/span>
\n;; this field is also used as an input buffer.)<\/span>
\n
\nfilesize:<\/span>   dd<\/span>  compilersize        ; phdr.p_filesz<\/span>
\n
\n;; The size of the program in memory. This entry creates an area of<\/span>
\n;; bytes, arraysize in size, all initialized to zero, starting at<\/span>
\n;; DATAORG.<\/span>
\n
\n        dd<\/span>  DATAOFFSET +<\/span> arraysize  ; phdr.p_memsz<\/span>
\n
\n;; The code chunk for the "." instruction. eax is set to 4 to invoke<\/span>
\n;; the write system call. ebx, the file handle to write to, is set to<\/span>
\n;; 1 for stdout. ecx points to the buffer containing the bytes to<\/span>
\n;; output, and edx equals the number of bytes to output. (Note that<\/span>
\n;; the first byte of the first instruction, which is also the least<\/span>
\n;; significant byte of the p_flags field, encodes to 0xB3. Having the<\/span>
\n;; 2-bit set marks the memory containing the compiler, and its<\/span>
\n;; compiled programs, as writeable.)<\/span>
\n
\nputchar:<\/span>    mov<\/span> bl<\/span>,<\/span> 1<\/span>           ; phdr.p_flags<\/span>
\n        mov<\/span> al<\/span>,<\/span> 4<\/span>
\n        int<\/span> 0x80<\/span>            ; phdr.p_align<\/span>
\n
\n;; The epilog code chunk. After restoring the initialized registers,<\/span>
\n;; eax and ebx are both zero. eax is incremented to 1, so as to invoke<\/span>
\n;; the exit system call. ebx specifies the process's return value.<\/span>
\n
\nepilog:<\/span>     popa<\/span>
\n        inc<\/span> eax<\/span>
\n        int<\/span> 0x80<\/span>
\n
\n;; The code chunks for the ">", "<", "+", and "-" instructions.<\/span>
\n
\nincptr:<\/span>     inc<\/span> ecx<\/span>
\ndecptr:<\/span>     dec<\/span> ecx<\/span>
\nincchar:<\/span>    inc<\/span> byte<\/span> [<\/span>ecx<\/span>]<\/span>
\ndecc<\/span>har:<\/span>    dec<\/span> byte<\/span> [<\/span>ecx<\/span>]<\/span>
\n
\n;; The main loop of the compiler continues here, by obtaining the next<\/span>
\n;; character of input. This is also the code chunk for the ","<\/span>
\n;; instruction. eax is set to 3 to invoke the read system call. ebx,<\/span>
\n;; the file handle to read from, is set to 0 for stdin. ecx points to<\/span>
\n;; a buffer to receive the bytes that are read, and edx equals the<\/span>
\n;; number of bytes to read.<\/span>
\n
\ngetchar:<\/span>    mov<\/span> al<\/span>,<\/span> 3<\/span>
\n        xor<\/span> ebx<\/span>,<\/span> ebx<\/span>
\n        int<\/span> 0x80<\/span>
\n
\n;; If eax is zero or negative, then there is no more input, and the<\/span>
\n;; compiler proceeds to the eof routine.<\/span>
\n
\n        or<\/span>  eax<\/span>,<\/span> eax<\/span>
\n        jle<\/span> eof
\n
\n;; Otherwise, esi is advanced four bytes (from the epilog code chunk<\/span>
\n;; to the incptr code chunk), and the character read from the input is<\/span>
\n;; stored in al, with the high bytes of eax reset to zero.<\/span>
\n
\n        lodsd<\/span>
\n        mov<\/span> eax<\/span>,<\/span> [<\/span>ecx<\/span>]<\/span>
\n
\n;; The compiler compares the input character with ">" and "<". esi is<\/span>
\n;; advanced to the next code chunk with each failed test.<\/span>
\n
\n        cmp<\/span> al<\/span>,<\/span> '>'<\/span>
\n        jz<\/span>  emit1byte
\n        inc<\/span> esi<\/span>
\n        cmp<\/span> al<\/span>,<\/span> '<'<\/span>
\n        jz<\/span>  emit1byte
\n        inc<\/span> esi<\/span>
\n
\n;; The next four tests check for the characters "+", ",", "-", and<\/span>
\n;; ".", respectively. These four characters are contiguous in ASCII,<\/span>
\n;; and so are tested for by doing successive decrements of eax.<\/span>
\n
\n        sub<\/span> al<\/span>,<\/span> '+'<\/span>
\n        jz<\/span>  emit2bytes
\n        dec<\/span> eax<\/span>
\n        jz<\/span>  emitgetchar
\n        inc<\/span> esi<\/span>
\n        inc<\/span> esi<\/span>
\n        dec<\/span> eax<\/span>
\n        jz<\/span>  emit2bytes
\n        dec<\/span> eax<\/span>
\n        jz<\/span>  emitputchar
\n
\n;; The remaining instructions, "[" and "]", have special routines for<\/span>
\n;; emitting the proper code. (Note that the jump back to the main loop<\/span>
\n;; is at the edge of the short-jump range. Routines below here<\/span>
\n;; therefore use this jump as a relay to return to the main loop;<\/span>
\n;; however, in order to use it correctly, the routines must be sure<\/span>
\n;; that the zero flag is cleared at the time.)<\/span>
\n
\n        cmp<\/span> al<\/span>,<\/span> '['<\/span> -<\/span> '.'<\/span>
\n        jz<\/span>  bracket
\n        cmp<\/span> al<\/span>,<\/span> ']'<\/span> -<\/span> '.'<\/span>
\nrelay:<\/span>      jnz<\/span> compile
\n
\n;; The endbracket routine emits code for the "]" instruction, as well<\/span>
\n;; as completing the code for the matching "[". The compiler first<\/span>
\n;; emits "cmp dh, [ecx]" and the first two bytes of a "jnz near". The<\/span>
\n;; location of the missing target in the code for the "[" instruction<\/span>
\n;; is then retrieved from the stack, the correct target value is<\/span>
\n;; computed and stored, and then the current instruction's jmp target<\/span>
\n;; is computed and emitted.<\/span>
\n
\nendbracket:<\/span> mov<\/span> eax<\/span>,<\/span> 0x850F313A<\/span>
\n        stosd<\/span>
\n        lea<\/span> esi<\/span>,<\/span> [<\/span>byte<\/span> edi<\/span> -<\/span> 8<\/span>]<\/span>
\n        pop<\/span> eax<\/span>
\n        sub<\/span> esi<\/span>,<\/span> eax<\/span>
\n        mov<\/span> [<\/span>eax<\/span>]<\/span>,<\/span> esi<\/span>
\n        sub<\/span> eax<\/span>,<\/span> edi<\/span>
\n        stosd<\/span>
\n        jmp<\/span> short relay
\n
\n;; This is the entry point, for both the compiler and its compiled<\/span>
\n;; programs. The shared initialization code sets ecx to the beginning<\/span>
\n;; of the array that is the compiled program's data area, and edx to<\/span>
\n;; one. (This also clears the zero flag for the relay jump below.) The<\/span>
\n;; registers are then saved on the stack, to be restored at the end.<\/span>
\n
\n_start:<\/span>
\n        mov<\/span> ecx<\/span>,<\/span> DATAORG
\n        inc<\/span> edx<\/span>
\n        pusha<\/span>
\n
\n;; At this point, the compiler and its compiled programs diverge.<\/span>
\n;; Although every compiled program includes all the code in this file<\/span>
\n;; above this point, only the three instructions directly above are<\/span>
\n;; actually used by both. This point is where the compiler begins<\/span>
\n;; storing the generated code, so only the compiler sees the<\/span>
\n;; instructions below. This routine first modifies ecx to contain<\/span>
\n;; TEXTORG, which is stored on the stack, and then offsets it to point<\/span>
\n;; to filesize. edi is set equal to codebuf, and then the compiler<\/span>
\n;; enters the main loop.<\/span>
\n
\ncodebuf:<\/span>
\n        mov<\/span> ch<\/span>,<\/span> (<\/span>TEXTORG >> 8<\/span>)<\/span> & 0xFF<\/span>
\n        push<\/span>    ecx<\/span>
\n        mov<\/span> cl<\/span>,<\/span> filesize -<\/span> $$<\/span>
\n        lea<\/span> edi<\/span>,<\/span> [<\/span>byte<\/span> ecx<\/span> +<\/span> codebuf -<\/span> filesize]<\/span>
\n        jmp<\/span> short relay
\n
\n;; Here ends the file image.<\/span>
\n
\ncompilersize    equ<\/span> $<\/span> -<\/span> $$<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

\u6267\u884c\uff1a<\/p>\n

1
2
3
<\/div><\/td>
yum install<\/span> nasm<\/span> -y<\/span>
\nnasm<\/span> -f<\/span> bin -o<\/span> bf_compiler bf.asm
\nchmod<\/span> +x .\/<\/span>bf_compiler<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

\u5c06\u4e0a\u9762\u7684BrainFuck\u7a0b\u5e8f\u4fdd\u5b58\u5728brainfuck.bf\u6587\u4ef6\uff0c\u5728SSH\u4e2d\u6267\u884c\uff1a<\/p>\n

1
2
3
<\/div><\/td>
.\/<\/span>bf_compiler <<\/span> brainfuck.bf ><\/span> brainfuck.cgi
\nchmod<\/span> +x .\/<\/span>brainfuck.cgi
\n.\/<\/span>brainfuck.cgi<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n

\u5982\u679c\u8fd9\u65f6\u80fd\u591f\u770b\u5230\u6211\u4eec\u4e4b\u524d\u8bf4\u7684\u90a3\u4e24\u884c\u8f93\u51fa\uff0c\u8bf4\u660e\u7f51\u9875\u7f16\u5199\u6210\u529f\u3002\u7136\u540e\uff0c\u5c06\u8fd9\u4e2a\u6587\u4ef6\u590d\u5236\u5230cgi-bin\u4e0b\u9762\uff0c\u901a\u8fc7\u6d4f\u89c8\u5668\u5c31\u53ef\u4ee5\u8bbf\u95ee\u4e86\u3002\u5982\u679c\u51fa\u73b0HTTP 500\u9519\u8bef\uff0c\u8bf7\u67e5\u770bApache\u65e5\u5fd7\u3002<\/p>\n

\u6bd5\u7adf\u662f\u4e00\u4e2a\u6bd4\u8f83\u9ebb\u70e6\u7684\u4e8b\u60c5\uff0c\u6211\u5c31\u4e0d\u518d\u7ee7\u7eed\u7528BrainFuck\u505a\u66f4\u591a\u529f\u80fd\u7684\u7f51\u9875\u4e86\u3002\u5927\u5bb6\u6709\u4ec0\u4e48\u95ee\u9898\u53ef\u4ee5\u5728\u4e0b\u9762\u7559\u8a00\u95ee\u6211\u3002<\/p>\n

\u672c\u6587\u4f5c\u8005\u4e3a\u9999\u83c7\u80a5\u725b\uff08http:\/\/qing.su\/article\/119.html<\/a>\uff09\uff0c\u8f6c\u8f7d\u8bf7\u6ce8\u660e\u539f\u6587\u94fe\u63a5\uff0c\u8c22\u8c22\u3002<\/p>\n","protected":false},"excerpt":{"rendered":"

\u4eca\u5929\u82b1\u4e86\u534a\u4e2a\u5c0f\u65f6\u7528BrainFuck\u8bed\u8a00\u7f16\u5199\u4e86\u4e00\u4e2a\u53ea\u6709\u4e00\u884c\u5b57\u7684\u7f51\u9875\uff08\u540c\u6837\u7684\u4e8b\u60c5\u5982\u679c\u7528C\u8bed\u8a00\u5927\u6982\u9700\u8981\u82b15\u5206\u949f\uff0c\u7528PHP\u53ea\u9700\u898120\u79d2\u949f\uff09\uff0c\u5927\u6982\u6ca1\u4eba\u6bd4\u6211\u66f4\u65e0\u804a\u4e86\u5427\u3002\u5730\u5740\u662fhttp:\/\/qing.su\/cgi-bin\/brainfuck.cgi BrainFuck\u662f\u4e16\u754c\u4e0a\u6700\u7cbe\u81f4\u7684\u56fe\u7075\u5b8c\u5907\u7684\u8ba1\u7b97\u673a\u8bed\u8a00\uff08\u5176\u7f16\u8bd1\u5668\u4ec5\u6709240bytes\uff09\u3002\u5b83\u7531\u516b\u4e2a\u5b57\u7b26\u6784\u6210\uff1a+-.,[]\u5206\u522b\u4ee3\u8868\u4e86\u5de6\u53f3\u4f4d\u79fb\u3001\u589e\u51cf\u53d8\u91cf\u3001\u8f93\u51fa\u8f93\u5165\u4ee5\u53ca\u5faa\u73af\u5f00\u95ed\u3002\u5982\u6b64\u6709\u9650\u7684\u5b57\u7b26\u5e93\u51b3\u5b9a\u4e86\u5176\u7f16\u5199\u8fc7\u7a0b\u7684\u7e41\u7410\u548c\u5197\u957f\u3001\u6613\u8bfb\u6027\u6781\u5dee\uff0c\u51e0\u4e4e\u65e0\u6cd5\u6210\u4e3a\u771f\u6b63\u751f\u4ea7\u4f7f\u7528\u7684\u8ba1\u7b97\u673a\u8bed\u8a00\u3002\u6216\u8bb8\uff0c\u5076\u5c14\u7f16\u5199\u4e00\u4e2aBrainFuck\u7a0b\u5e8f\u70e7\u4e00\u70e7\u8111\u5b50\u662f\u4e0d\u9519\u7684\u9009\u62e9\u3002\u4e0b\u9762\u4ecb\u7ecd\u4e00\u4e0b\u7528BrainFuck\u8bed\u8a00\u7f16\u5199\u7f51\u9875\u7684\u65b9\u5f0f\u3002<\/p>\n","protected":false},"author":1,"featured_media":941,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_seopress_robots_primary_cat":"","_seopress_titles_title":"","_seopress_titles_desc":"","_seopress_robots_index":"","footnotes":""},"categories":[9],"tags":[152,107],"class_list":["post-938","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripts","tag-brainfuck","tag-cgi_program","no-featured-image-padding"],"_links":{"self":[{"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/posts\/938","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/comments?post=938"}],"version-history":[{"count":0,"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/posts\/938\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/media\/941"}],"wp:attachment":[{"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/media?parent=938"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/categories?post=938"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/qing.su\/wp-json\/wp\/v2\/tags?post=938"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}