大家好，我是極客君，去年鵝廠內部極客圈舉辦了第二次極客大賽，題目如下：

"實現一個世界上最小的程序來輸出自身的MD5"

作為極客圈一員的我也參加了比賽，比賽競爭很激烈，為了爭奪一個字節的優勢，大家都拿出自己的絕活，比賽重新刷新了我對匯編的認知和對程序運行原理理解，昨天分享一個典型的樸素解法：

最小MD5挑戰賽，你敢來戰嗎？

但這篇"菜鳥"樸素解法,已經讓有些人看得不知所云，其實要完全理解其中一些技巧，可能需要實際操作一下，計算機實踐很重要，看不懂也可以做個吃瓜群眾，長長見識也可以。

上篇文章說過點贊在看超過20，今天就放出大神解法，我相信此法一出，評論區會一片驚呼：

A：天啊，這個男人不得了，他做到了最短！

B：神仙打架

C :??膜拜第一名大佬，各種技巧溜得飛起，學習了

? ? ?

D :? 跪著看完了，厲害！

E? :??降維打擊

...

文章稍微有點長，不想慢慢看完，可以直接拉到底，接下來該你上場表演了。

開闊眼界的大神解法

299字節打印自身的MD5，NO.1（冠軍）

用 nasm 寫匯編，手動構造 ELF 格式文件。ELF 文件分為三部分：

[A] [B] [C]

其中 A 的長度為 64 的倍數，B+C 的長度 <= 55。

A+B 包括：ELF 文件頭、計算 MD5 一個 block 的代碼、輸出 16 進制的代碼。盡可能壓縮這部分代碼的大小。

C 是對 A 計算 MD5（不加 padding）的中間結果，13 字節。（為什么是 13 不是 16？因為撞了 3 個字節，詳見下文。）

思路

大的方向無非就這些：

撞：理想情況下，我們的程序就簡單執行一條輸出指令，撞出一個滿足?MD5(print(md5_string)) == md5_string?的?md5_string。

利用外部能力：調用外部程序，或者利用 Linux 內核中的 MD5 實現。

算：程序讀取自身，計算 MD5 并輸出。

如果考慮撞，MD5 有 128 位，2 的 128 次方據說已經超過了宇宙中基本粒子的數量，窮舉顯然是不行的，只能用密碼學的方法構造。鑒于本文作者的密碼學知識接近于 0，就不賣弄了，不過據群里的同學說這樣構造出來的文件會很大，并不適合本次比賽。

而利用外部能力的路已經被堵死，不允許 fork，也不允許使用 socket，此路不通。

看來可行的方法就是算，成了一個純工程優化問題。這一塊正好本文作者有點經驗，研究生方向是編譯器，做的題目是 code size reduction。

MD5 算法

第一想法是去抄開源代碼，我一開始抄了 Linux kernel 里的 MD5 實現，但后來發現并不適合本次比賽。開源的 MD5 實現為了性能大都做了人工循環展開和常量預計算，會把代碼撐得很大。不如直接照著 MD5 算法的偽碼來寫，維基百科上面的偽代碼寫得夠清晰，就它了。

簡單描述：

需要先對原始數據做 padding，將它的長度變成 64 字節的整數倍，MD5 算法在 64 字節長的 block 上進行。

具體 padding 方法：在原始數據后增加一字節 0x80，然后再增加若干個 0，直到總長度為 64 的倍數，并且最后至少留出 8 個字節的位置，用于填寫 little endian 編碼的原始數據總長度（按位計，即字節數乘以 8）。

Padding 完成后，對每個 64 字節 block 進行計算，block 的計算方法參考下一節的代碼。每一輪計算結束后更新 16 字節的 MD5 狀態，最后一輪計算完成后，將狀態用 16 進制打印出來。

C++ 實現

以下是一個 C++ 寫的完整實現，在不太損失可讀性的前提下用較簡短的寫法，不考慮性能：

#include <cmath> #include <cstdio> #include <cstring> #include <memory>using namespace std;static const uint8_t SHIFT[] = {7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21};// 注：為了省事，下面代碼假設了 CPU 是 little endian static void compute_md5(void* result, const void* orig_data, size_t orig_size) {uint32_t* hash = reinterpret_cast<uint32_t*>(result);hash[0] = 0x67452301;hash[1] = 0xefcdab89;hash[2] = 0x98badcfe;hash[3] = 0x10325476;// 計算padding后的總長度size_t padded_size;if (orig_size % 64 > 55) {padded_size = orig_size / 64 * 64 + 128;} else {padded_size = orig_size / 64 * 64 + 64;}// 增加paddingstd::unique_ptr<char[]> padded_data(new char[padded_size]);memset(padded_data.get(), 0, padded_size);memcpy(padded_data.get(), orig_data, orig_size);padded_data[orig_size] = 0x80;*(uint64_t*)(padded_data.get() + padded_size - 8) = orig_size * 8;// 開始計算for (const uint32_t* data = (const uint32_t*)padded_data.get();padded_size >= 64; data += 16, padded_size -= 64) {uint32_t a = hash[0];uint32_t b = hash[1];uint32_t c = hash[2];uint32_t d = hash[3];for (int i = 0; i < 64; ++i) {uint32_t f, g;if (i < 16) {f = ((c ^ d) & b) ^ d; // 等價于 (b & c) | ((~b) & d);g = i;} else if (i < 32) {f = ((b ^ c) & d) ^ c; // (d & b) | ((~d) & c);g = 5*i + 1;} else if (i < 48) {f = b ^ c ^ d;g = 3*i + 5;} else {f = c ^ (b | (~d));g = 7*i;}uint32_t K = static_cast<uint32_t>(fabs(sin(i + 1)) * 4294967296.0);f += a + K + data[g % 16];int shift_val = SHIFT[(i / 16) * 4 + (i % 4)];f = (f << shift_val) | (f >> (32 - shift_val));a = d;d = c;c = b;b += f;}hash[0] += a;hash[1] += b;hash[2] += c;hash[3] += d;} }int main(int argc, char** argv) {FILE* fp = fopen(argv[0], "rb");if (fp == nullptr) {perror("Failed to open file");return 1;}char buffer[65536];size_t len = fread(buffer, 1, sizeof(buffer), fp);fclose(fp);unsigned char result[16];compute_md5(result, buffer, len);for (int i = 0; i < 16; ++i) {printf("%02x", result[i]);}putchar('\n');return 0; }

這個版本用?g++ -Os?編譯出來，strip 一下，不做其他處理，大約 14 KB。

用匯編改寫

接下來的任務就是想辦法用匯編重寫這個 14 KB 的程序，將代碼壓縮到最小。

手動構造 ELF

手動構造 ELF 網上能找到不少例子，例如：Smallest executable program (x86-64)。它使用 nasm 構造了一個最小的 64 位 ELF，先照著它搭個架子。

這個例子提供了兩個思路：(1) ELF 頭部有很多不重要的字段，可以用來放代碼或數據 (2) ehdr 的最后 8 個字節和 phdr 的最前面 8 個字節可以重合。

借助 nasm 可以很容易地將 file size 硬編碼到代碼里。還有?%define、%if?等也可以幫助我們省很多事。

手動構造 ELF 以后，也不再需要再去讀文件，加載到內存里的地址完全受我們控制了，直接去讀。

系統調用

沒有 C 庫以后，系統調用需要自己寫。x86-64 有 syscall 指令，發起系統調用很方便。

• 入參：

• • eax = 系統調用號，可以在?/usr/include/asm/unistd_64.h?文件中找到

  • rdi, rsi, rdx, r10, r8, r9 分別為第 1 至 6 個參數

• 出參：

• • rax = 返回值（如果失敗，返回 -errno）

  • rcx, r11 被破壞（它們分別被 syscall 指令用來保存返回地址和 rflags）

  • 其他寄存器的值保留

假設棧頂 32 字節是計算好的 MD5 字符串，輸出的系統調用：

0: b8 01 00 00 00 mov eax,0x1 ; write 系統調用5: bf 01 00 00 00 mov edi,0x1 ; 標準輸出a: 48 89 e6 mov rsi,rsp ; 指針d: ba 20 00 00 00 mov edx,0x20 ; 長度 32 字節12: 0f 05 syscall

匯編代碼優化

預先計算 MD5 中間狀態

將 ELF 文件分為三部分：[A] [B] [C]

其中 A 的長度為 64 的倍數，B+C 的長度 <= 55。

A+B 包括：ELF 文件頭、計算 MD5 一個 block 的代碼、輸出 16 進制的代碼。

C 是對 A 計算 MD5（不加 padding）的中間結果，16 字節，由輔助腳本計算并填入。（后面會把 C 變成 13 字節，見下文。）

這樣可以省掉外層循環，匯編只用計算最后 64 位字節。

避免 copy

默認 text 段是不可寫的，可以修改 p_flags，從 5 (可讀可執行) 寫為 7 (可讀寫可執行)，同時把 p_memsz 改大一些。這樣 padding 就可以直接加在后面，不需要再拷貝到棧上。

分支之間共用指令

注意最內層的那一串 if-else：有兩個分支都用到?b^c，還有兩個分支計算?f?的最后一步是?^c，還兩個分支計算?f?的最后一步是?^d。這里代碼都可以共用，不僅可以省掉幾個字節，更重要的是，分支代碼碼變得更短以后，更容易塞到文件頭里面。

指令選擇

盡量選用早期 x86 就有的指令，一般編碼會比較短。很多不常用的指令，只因為生得早，占了好坑，都只要一兩個字節。

例如：lodsb?只要一個字節，而?mov al,[rsi]; inc rsi?要好幾個。

又如，loop addr?指令大致相當于?dec ecx; jnz addr，也少了好幾個字節。沒有哪個現代編譯器會主動生成這個指令，實際上 Intel 也不建議用，較新的 CPU 里沒有為這個指令做優化，性能偏低。但對本題卻相當合適。

拿不準的時候多試幾次，用 objdump 看哪個短。

寄存器的選擇

優先使用從 32 位時代沿襲下來的 8 個寄存器 (rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp)，避免使用 r8-r15。對于很多指令，使用 r8-r15 會多占一個字節。例如：

0: 41 83 e0 01 and r8d,0x14: 83 e0 01 and eax,0x1

用最短的代碼賦值小常量給寄存器

對 0 值，對寄存器異或自身：xor eax, eax。這個很常見，減少代碼體積，也不損失性能，Intel 也推薦這樣寫。

對于非 0 值，下面的寫法就損失性能了，但對本題有用。

將常量 1 賦給 ebx，最自然的寫法 5 個字節：

0: bb 01 00 00 00 mov ebx,0x1

這樣寫只要 4 個字節（如果知道 ebx 的高位已經是 0，則只需后一指令，2 個字節）：

0: 31 db xor ebx,ebx 2: b3 01 mov bl,0x1

這樣寫只要 3 個字節：

0: 6a 01 push 0x1 2: 5b pop rbx

32 位 or 64 位寄存器

x86-64 有一個特性，目標操作數是 32 位寄存器時，會同時清空對應 64 位寄存器的高 32 位。所以?xor eax, eax?與?xor rax, rax?等價；mov eax, 1?也與?mov rax, 1?等價。使用 32 位寄存器常常可以省一個字節（r8-r15 除外）：

0: 31 c0 xor eax,eax 2: 48 31 c0 xor rax,rax

但注意，在作為地址時，情況相反，64 位少一個字節：

0: 67 8d 43 08 lea eax,[ebx+0x8] 4: 8d 43 08 lea eax,[rbx+0x8]

進程初始狀態

網上說 Linux 進程啟動時，除了 RCX 以外，其他寄存器的值都不確定。但實測拿到的都是 0，所以省略對寄存器清 0 的操作。

（有的資料說其他寄存器會繼承?execve?之前的值，懶得去驗證，不過對此存疑。如果操作系統不清 0，這會是一個安全漏洞，父進程可能無意中漏泄信息給子進程。）

使用 16 位地址

ELF 的常見初始虛擬地址是諸如 0x8048000 這樣的值，把它改成 0x1000，這樣兩個字節可以放下地址。

不能比 0x1000 更小了，因為 0x1000 == 4096 是一個頁面的大小，在最前面至少要留一個頁面，否則 NULL 會成為有效指針。

棧優化

棧涉及到內存操作，比用寄存器慢。然而 push、pop 作為元老級的 8086 指令，編碼超級短，前 8 個寄存器的 push、pop 只要一個字節。

0: 50 push rax 1: 5b pop rbx 2: 48 89 c3 mov rbx,rax

在這個例子里，出棧再入棧竟然比 mov 少一個字節！

浮點運算

現在 Intel 推薦用 SSE/AVX 來做浮點運算，但對本題還是 x87 香，計算 sin、取絕對值都是一條指令的事情（兩個字節）。

x87 寄存器是棧式的，寫復雜的算式比較麻煩。好在本題的式子并不復雜，下面幾行代碼就可以計算出?(fabs(sin(i + 1)) * 4294967296.0)，其中?[rbx-0x14]?指向一個預存了?4294967296.0?的地址。

10d4: 50 push rax ; i+1 入棧10d5: db 04 24 fild DWORD PTR [rsp] ; 轉成浮點數，放到st010d8: d9 fe fsin ; sin10da: d9 e1 fabs ; abs10dc: d8 4b ec fmul DWORD PTR [rbx-0x14] ; 乘以 429496729610df: dd 0c 24 fisttp QWORD PTR [rsp] ; 轉成整數，寫到棧頂10e2: 5a pop rdx ; 出棧，讀到結果

pext 指令

C++ 代碼里有一處?(i / 16) * 4 + (i % 4)，很適合用 pext 指令來實現。pext 是一條 BMI 2 指令，可以簡便地從源操作數里抽一些不連續的位出來。

假設?i?放在 eax，那么用?pext ecx, eax, bit_mask?(bit_mask = 0b00110011) 就可以從?i?里面提取出第 0、1、4、5 位，正好就是?(i / 16) * 4 + (i % 4)?的值。

使用 near 跳轉

jmp、jcc 都有 8 位偏移和 32 位偏移兩個版本。32 位太浪費，盡量調整代碼塊的位置，讓所有跳轉都變成 8 位（跳轉范圍在 -128 至 127 字節之間）。實在避免不了的，用兩條短 jmp 中轉一下都能節省一個字節。

尋址優化

x86-64 提供了相對 rip 的尋址，為位置無關代碼（PIC）提供了很大便利。又由于它比絕對尋址短，所以編譯器通常在非 PIC 代碼中也會使用它。

但遺憾的是，它始終使用 32 位偏移量，太浪費。可以考慮固定使用一個寄存器保存一個地址，后面的尋址都相對它進行，并設法將偏移保持在 8 位的范圍內（-128 至 127）。

對比以下三條指令的長度：

0: 8b 43 02 mov eax,DWORD PTR [rbx+0x2] 3: 8b 05 02 00 00 00 mov eax,DWORD PTR [rip+0x2] 9: 8b 04 25 02 00 00 00 mov eax,DWORD PTR [0x2]

調用函數

call 指令沒有 8 位偏移的版本，32 位偏移很浪費。先將函數地址裝到一個寄存器，再 call 這個寄存器，只要兩個字節：

0: ff d3 call rbx

最后撞三個字節

寫完代碼以后，發現 ELF 頭部還剩兩個可以自由修改的字節。代碼里還有一些等效的指令，例如，當已知 eax 和 ecx 的值相等時，下面四條指令等價：

lea ecx, [rax+rax*4+1] lea ecx, [rax+rcx*4+1] lea ecx, [rcx+rax*4+1] lea ecx, [rcx+rcx*4+1]

又如，在判斷循環條件時，下面代碼里的?jb?可以替換為?jne：

inc eax cmp al, 64 jb _loop_md5

于是，通過給 nasm 增加參數?-Dalternative=...，并在代碼里使用?%if alternative = ...?來選擇使用哪一種等價的寫法。

再寫一個額外的程序來遍歷頭部兩個字節的值，以及代碼中這些有?alternative?的地方的指令選擇，使得計算出的 MD5 的中間結果的最后三個字節是?0x80 0x00 0x00，即與 MD5 padding 的前三個字節相同，這樣就可以從文件內容中省去這三個字節。

代碼

完整代碼：

bits 64; 定義“變量”對應的寄存器; R_ 表示 64 位，r_ 表示對應的 32 位，_w 表示低 16 位， _l 表示低 8 位%define r_base ebx ; 始終指向$$+offs%define R_base rbx%define r_base_w bx;%define r_a r8d ; a,b,c,d 在內層循環中保存MD5狀態;%define R_a r8 ; r_a 現在不占用寄存器了，移到棧頂 [rsp]%define r_b edi%define R_b rdi%define r_c ebp%define R_c rbp%define r_d edx%define R_d rdx%define r_i eax ; 內層循環下標%define R_i rax%define r_i_l al%define r_f esi ; 內層循環中的變量 F; ecx用作臨時變量; 一般是使用 0x8048000，故意改成一個很小的數，以便兩個字節可以放下地址 %define base 0x1000org base ehdr: ; Elf64_Ehdrdb 0x7F, "ELF", 2, 1, 1, 0 ; e_ident; times 8 db 0; 這個代碼塊正好8字節，放這里 _16_to_32:; if (16 <= i && i < 32) {; g = 5*i + 1;; f = ((b ^ c) & d) ^ c; // (d & b) | ((~d) & c);; }%if alternative = 1 ; alternative用于控制生成多種等效的代碼，fill.py會對它們進行遍歷，; 找到使MD5中間結果最后幾個字節恰好等于 0x80 0x00 0x00 的組合lea ecx, [R_i+R_i*4+1]%elif alternative = 2lea ecx, [R_i+rcx*4+1]%elif alternative = 3lea ecx, [rcx+R_i*4+1]%elselea ecx, [rcx+rcx*4+1]%endifand r_f, r_djmp _reuse_code ; _16_to_32 與 _32_to_48 最后一條指令相同，jmp過去省兩個字節 times 8 - ($ - _16_to_32) db 0; enddw 2 ; e_typedw 62 ; e_machine;dd 1 ; e_version (modifiable) _0x1p32 dd 4294967296.0 ; pow(2.0, 32)dq _start ; e_entrydq phdr - $$ ; e_phoff;dq 0 ; e_shoff (modifiable);dd 0 ; e_flags (modifiable);dw ehdrsize ; e_ehsize (modifiable); 14個可以修改的字節，放一個函數在此(13字節); 將al低4位轉為1位16進制 _make_hex:and eax, 15cmp al, 10jb .lt10add al, 'a' - '0' - 10 .lt10:add al, '0'stosbret; 剩一個字節，放pext的mask%if alternative = 1 _pext_mask db 0b00110011%elif alternative = 2 _pext_mask db 0b01110011%elif alternative = 3 _pext_mask db 0b10110011%else _pext_mask db 0b11110011%endif times 14-($-_make_hex) db 0dw phdrsize ; e_phentsize;; overlap the last 8 bytes of ehdr with phdr phdr: ; Elf64_Phdrdd 1 ; p_type = 1; e_phnum (word, 1); e_shentsize (word, modifiable)db 7 ; p_flags=7 (readable, writable, executable)db 0 ; 這個字節留給fill.py修改 (p_flags只要最低1字節對即可，高位隨便改) _context_ptr dw base + (_context - $$) ; e_shnum (word, modifiable); e_shstrndx (word, modifiable)ehdrsize equ $ - ehdrdq 0 ; p_offsetdq $$ ; p_vaddr;;dq $$ ; p_paddr (modifiable) _0_to_16: ; 這個代碼塊正好8字節，放這里; if (i < 16) {; g = i;; f = ((c ^ d) & b) ^ d; // (b & c) | ((~b) & d);; }mov r_f, r_cxor r_f, r_dand r_f, r_bjmp _reuse_code_2 ; _0_to_16 與 _48_to_64 最后一條指令相同，jmp過去省兩個字節 times 8-($-_0_to_16) db 0dq filesize ; p_filesz;dq filesize+512 ; p_memsz; 挪用p_memsz用于存一些其他數據，只要這里填的值至少比filesize大一些，但又不要過于; 巨大以免運行錯誤 _16_to_32_relay: jmp short _16_to_32 ; 中轉向_16_to_32的跳轉，便得兩處跳轉都使用8位偏移量 _compute_start_ptr dd ($$ + filesize - filesize % 64) times (8 - ($ - _16_to_32_relay)) db 0;dq 0x1000 ; p_align;; p_align是phdr的最后8個字節，對靜態鏈接的代碼沒什么用，省去 phdrsize equ $ + 8 - phdr_shift db 7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21%assign start_of_code base + ($ - $$) %warning code: start_of_code_48_to_64:; if (i >= 48) {; g = 7*i;; f = c ^ (b | (~d));; }%if alternative = 1imul ecx, r_i, 7%elseimul ecx, 7%endifmov r_f, r_dnot r_for r_f, r_b _reuse_code:xor r_f, r_cjmp _join; R_base 偏移 offs 字節，指向 _make_hex offs equ _make_hex - $$; 程序入口 _start:mov r_base_w, base + offs ; mov r_base, $$ + offs; 文檔說進程啟動時rdi的值未定，但實測至少tlinux2; 保證了它是0mov esi, [R_base - offs - $$ + _context_ptr]; 本來這里應該用movzx讀2個字節的，但正好后面2個字節也是0，就用mov省一個字節push rsi; MD5 paddingmov byte [rsi + _end - _context], 0x80mov word [rsi + _end - _context + paddingsize - 8], filesize*8; uint32_t a = hash[0];; uint32_t b = hash[1];; uint32_t c = hash[2];; uint32_t d = hash[3];push qword [rsi]mov r_b, [rsi + 4]mov r_c, [rsi + 8]mov r_d, [rsi + 12]; for (int i = 0; i < 64; ++i) {; xor r_i, r_i ; 文檔說啟動時rax的值未定，實測至少tlinux2上進程啟動時eax=0 _loop_md5:; 有兩個分支用到 b^c，在分支前先算出來放到f，省兩個字節mov r_f, r_b ; f = b ^ cxor r_f, r_cmov ecx, r_i ; g = icmp r_i_l, 16jb _0_to_16cmp r_i_l, 32jb _16_to_32_relaycmp r_i_l, 48jae _48_to_64_32_to_48:; if (32 <= i && i < 48) {; g = 3*i + 5;; f = b ^ c ^ d;; }%if alternative = 1lea ecx, [R_i+R_i*2+5]%elif alternative = 2lea ecx, [R_i+rcx*2+5]%elif alternative = 3lea ecx, [rcx+R_i*2+5]%elselea ecx, [rcx+rcx*2+5]%endif _reuse_code_2:xor r_f, r_d_join:; f += a; a = d;; (d := garbage)xchg r_d, [rsp]add r_f, r_d; f += in[g % 16];and ecx, 15mov r_d, [R_base - offs - $$ + _compute_start_ptr]add r_f, [R_d + rcx*4]; int shift_val = _shift[(i / 16) * 4 + (i % 4)];pext ecx, r_i, [R_base-offs-$$+_pext_mask] ; _pext_mask的高24位不是0，不過不影響，因為r_i高位全是0mov cl, [R_base-offs-$$+_shift+rcx] ; [_shift + rcx]; K[i] := floor(2^32 × abs (sin(i + 1)))inc r_ipush R_ifild dword [rsp]fsinfabsfmul dword [R_base-offs-$$+_0x1p32] ; * 2^32fisttp qword [rsp]; f += K[i]pop R_d ; 把r_d當作臨時寄存器用一下，pop出來的是剛才fisttp寫入[rsp]的值，即K[i]add r_f, r_d; f = (f << shift_val) | (f >> (32 - shift_val));rol r_f, cl; d = c;; c = b;; b += f;mov r_d, r_cmov r_c, r_badd r_b, r_f; }cmp r_i_l, 64%if alternative = 1jb _loop_md5%elsejne _loop_md5%endif; hash[0] += a;; hash[1] += b;; hash[2] += c;; hash[3] += d;pop rax ; Apop rsi ; _contextadd [rsi], eaxadd [rsi+4], r_badd [rsi+8], r_cadd [rsi+12], r_d; PRINT HEX;xor ecx, ecx ; 從前面循環里出來，ecx高位還是0mov cl, 16 ; mov ecx, 16lea edi, [rsi+16].loop_print_hex:mov al, [rsi]shr eax, 4call R_base ; call _make_hexlodsbcall R_base ; call _make_hexloop .loop_print_hex;rsi is already buffer of hex stringmov al, 1 ; mov eax, 1 (write) (eax高位已經是0)mov edi, eax ; mov edi, 1 (1 = stdout)%if alternative = 1lea edx, [rax+31] ; mov edx, 32; 用lea比mov短一點%elselea edx, [rdi+31]%endifsyscall; 返回后eax=32; EXIT%if alternative = 1mov al, 231 ; exit_group (eax高位已經是0)%elif alternative = 2add al, 231-32 ; 同上%elif alternative = 3sub al, 32-231 ; 同上%elif alternative = 4mov al, 60 ; exit (eax高位已經是0)%elif alternative = 5add al, 60-32 ; 同上%elsesub al, 32-60 ; 同上%endifxor edi, edisyscall%if ($ - $$) % 64 > 64 - 13 - 9 %assign wasted_padding 64 - ($ - $$) % 64 %warning Wasted padding bytes: wasted_paddingalign 64 %endif; _context 的初始內容由 fill.py 填入 _context: times 13 db 0 ; 最后三個字節由fill.py保證正好是0x80 0x00 0x00 (和MD5的padding一致)_end:filesize equ $ - $$ main_loops equ (filesize + 9 + 63) / 64 ; MD5算法循環次數 paddingsize equ 64 * main_loops - filesize ; 原始數據后需要附加的字節數%assign filesize filesize %warning File size: filesize

光憑這個 asm 還不夠，還要配合碰撞的腳本才能編譯出來正確的二進制：

• README.md：解題描述

• build.ninja：編譯腳本

• main.asm: 主程序

• fill.py: 用于碰撞 3 個字節的腳本

• fill_helper.cpp: fill.py 的輔助代碼（用 C++ 加速）

• md5.out: 最終的 299 字節可執行文件

• cpp_reference.cpp：C++ 參考實現

最終文件?md5.out?。從源碼編譯需要先安裝 Python 3、ninja、nasm，然后運行 ninja 命令，等 10~20 分鐘（取決于機器性能），就能得到 md5.out。

感興趣的小伙伴，可以在公眾號回復“md5”獲取完整實現。

---

大神解法，我是跪著看完了，歡迎小伙伴在留言區打上666，膜拜一下大佬，

如果文章給你長見識了，那就一鍵三連繼續支持，點贊和在看超過30，我就放另辟蹊徑的野路子解法：

絕對讓你感嘆腦洞如此之大，讓人望其項背。

推薦閱讀

最小MD5挑戰賽，你敢來戰嗎？

頂級C程序員之路

一個奇葩的網絡問題

C++模版的本質

超強干貨來襲 云風專訪：近40年碼齡，通宵達旦的技術人生

總結

以上是生活随笔為你收集整理的顶级极客技术挑战赛，你敢来挑战吗？| 大神登峰造极的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。