PansLabyrinth 记录软件开发和生活中的日常

IOLI-crackme0x06-0x09 writeup

2018-03-10
Pan

Radare2

前几天写了使用Radare2并用3中方法来解决crackme0x00, 然后紧接着第二天 就写了另外5个writeup, 如果认真看会发现那几个crackme的分析也是一开始 走了很多弯路, 但玩多了也就熟悉了. 趁热打铁, 把最后几关也过一过.

本文所使用的crackmes都来自IOLI-crackme.

crackme0x06

虽然隔了几天, 但r2打开反汇编时还是发现结构和crackme0x05差不多, 先看main函数:

[0x08048607]> pdf @ sym.main
            ;-- main:
/ (fcn) sym.main 99
|   sym.main (int arg_10h);
|           ; var int local_78h @ ebp-0x78
|           ; arg int arg_10h @ ebp+0x10
|           ; var int local_4h @ esp+0x4
|              ; DATA XREF from 0x08048417 (entry0)
|           0x08048607      55             push ebp
|           0x08048608      89e5           mov ebp, esp
|           0x0804860a      81ec88000000   sub esp, 0x88
|           0x08048610      83e4f0         and esp, 0xfffffff0
|           0x08048613      b800000000     mov eax, 0
|           0x08048618      83c00f         add eax, 0xf
|           0x0804861b      83c00f         add eax, 0xf
|           0x0804861e      c1e804         shr eax, 4
|           0x08048621      c1e004         shl eax, 4
|           0x08048624      29c4           sub esp, eax
|           0x08048626      c70424638704.  mov dword [esp], str.IOLI_Crackme_Level_0x06 ; [0x8048763:4]=0x494c4f49 ; "IOLI Crackme Level 0x06\n"
|           0x0804862d      e886fdffff     call sym.imp.printf         ; int printf(const char *format)
|           0x08048632      c704247c8704.  mov dword [esp], str.Password: ; [0x804877c:4]=0x73736150 ; "Password: "
|           0x08048639      e87afdffff     call sym.imp.printf         ; int printf(const char *format)
|           0x0804863e      8d4588         lea eax, [local_78h]
|           0x08048641      89442404       mov dword [local_4h], eax
|           0x08048645      c70424878704.  mov dword [esp], 0x8048787  ; [0x8048787:4]=0x7325
|           0x0804864c      e847fdffff     call sym.imp.scanf          ; int scanf(const char *format)
|           0x08048651      8b4510         mov eax, dword [arg_10h]    ; [0x10:4]=-1 ; 16
|           0x08048654      89442404       mov dword [local_4h], eax
|           0x08048658      8d4588         lea eax, [local_78h]
|           0x0804865b      890424         mov dword [esp], eax
|           0x0804865e      e825ffffff     call sym.check
|           0x08048663      b800000000     mov eax, 0
|           0x08048668      c9             leave
\           0x08048669      c3             ret
:> ps @ 0x8048787
%s

local_4h还是scanf输入的用户密码, 但这里值得一提的是arg_10h这个地址(ebp+0x10), 我们知道main函数接受2个参数int main(int argc, char *argv[]), 其中argc对应ebp+8, argv对于ebp+12, 而返回地址在ebp+4, 那么ebp+16又是啥? 第三个参数? 其实这是GCC编译器的一个 特性, 第三个参数envp也是一个字符串指针, 表示的是环境变量的值, 所以这里main函数相当于 int main(int argc, char *argv[], char *envp[]), 只不过前两个参数并未用到.

接下来分析check函数. 对于流程比较复杂的程序, 我们可以在视图模式中按p键切换到极简试图, 然后按TAB,Shift+TAB键切换不同的代码块(Basic Block), 如下所示:

r2-view

check接受两个参数, 第一个为输入字符串, 第二个为字符串指针. 伪代码如下:

void check(char *input, char *envp[]) {
    int i;
    char local_dh[2];
    int local_8h = 0;
    for(i = 0; i < strlen(input); i++) {
        local_dh[0] = input[i];
        local_dh[1] = 0;
        sscanf(local_dh, "%d", local_4h);
        local_8h += local_4h;
        if (local_8h == 0x10) {
            parell(input, envp);
        }
    }
    printf("Password Incorrect!\n");
    return;
}

根据循环的跳转情况可知ebp-0xc为循环变量, 因此重命名为i, 其他尚未知具体作用的变量保留. 该函数的作用是将输入的每一字节都转成数字并累加, 当累加和为0x10时调用parell:

[0x08048588]> pdf @ sym.parell 
/ (fcn) sym.parell 110
|   sym.parell (int arg_8h, int arg_ch);
|           ; var int local_8h_2 @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_8h @ ebp+0x8
|           ; arg int arg_ch @ ebp+0xc
|           ; var int local_4h_2 @ esp+0x4
|           ; var int local_8h @ esp+0x8
|              ; CALL XREF from 0x080485ed (sym.check)
|           0x0804851a      55             push ebp
|           0x0804851b      89e5           mov ebp, esp
|           0x0804851d      83ec18         sub esp, 0x18
|           0x08048520      8d45fc         lea eax, [local_4h]
|           0x08048523      89442408       mov dword [local_8h], eax
|           0x08048527      c74424043d87.  mov dword [local_4h_2], 0x804873d ; [0x804873d:4]=0x50006425
|           0x0804852f      8b4508         mov eax, dword [arg_8h]     ; [0x8:4]=-1 ; 8
|           0x08048532      890424         mov dword [esp], eax
|           0x08048535      e88efeffff     call sym.imp.sscanf         ; int sscanf(const char *s, const char *format,   ...)
|           0x0804853a      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|           0x0804853d      89442404       mov dword [local_4h_2], eax
|           0x08048541      8b45fc         mov eax, dword [local_4h]
|           0x08048544      890424         mov dword [esp], eax
|           0x08048547      e868ffffff     call sym.dummy
|           0x0804854c      85c0           test eax, eax
|       ,=< 0x0804854e      7436           je 0x8048586
|       |   0x08048550      c745f8000000.  mov dword [local_8h_2], 0
|       |      ; JMP XREF from 0x08048584 (sym.parell)
|      .--> 0x08048557      837df809       cmp dword [local_8h_2], 9   ; [0x9:4]=-1 ; 9
|     ,===< 0x0804855b      7f29           jg 0x8048586
|     |:|   0x0804855d      8b45fc         mov eax, dword [local_4h]
|     |:|   0x08048560      83e001         and eax, 1
|     |:|   0x08048563      85c0           test eax, eax
|    ,====< 0x08048565      7518           jne 0x804857f
|    ||:|   0x08048567      c70424408704.  mov dword [esp], str.Password_OK ; [0x8048740:4]=0x73736150 ; "Password OK!\n"
|    ||:|   0x0804856e      e845feffff     call sym.imp.printf         ; int printf(const char *format)
|    ||:|   0x08048573      c70424000000.  mov dword [esp], 0
|    ||:|   0x0804857a      e869feffff     call sym.imp.exit           ; void exit(int status)
|    `----> 0x0804857f      8d45f8         lea eax, [local_8h_2]
|     |:|   0x08048582      ff00           inc dword [eax]
|     |`==< 0x08048584      ebd1           jmp 0x8048557
|     `-`-> 0x08048586      c9             leave
\           0x08048587      c3             ret

parell接受2个参数, 伪代码如下:

void parell(char *input, char *envp[]) {
    sscanf(input, "%d", local_4h);
    if (dummy(local_4h, envp) == 0) {
        return;
    }
    for (int i = 0; i <= 9; i++) {
        if (local_4h & 1 == 0) {
            printf("Password OK!\n");
            exit(0);
        }
    }
    return;
}

作用就是判断输入数字的奇偶性, 不过增加了dummy函数返回不为0的限制. 而且这里的循环居然是个障眼法= =.

好吧, 再看看dummy函数:

[0x08048607]> pdf @ sym.dummy
/ (fcn) sym.dummy 102
|   sym.dummy (int arg_ch);
|           ; var int local_8h_2 @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_ch @ ebp+0xc
|              ; CALL XREF from 0x08048547 (sym.parell)
|           0x080484b4      55             push ebp
|           0x080484b5      89e5           mov ebp, esp
|           0x080484b7      83ec18         sub esp, 0x18
|           0x080484ba      c745fc000000.  mov dword [local_4h], 0
|       .-> 0x080484c1      8b45fc         mov eax, dword [local_4h]
|       :   0x080484c4      8d1485000000.  lea edx, [eax*4]
|       :   0x080484cb      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|       :   0x080484ce      833c0200       cmp dword [edx + eax], 0
|      ,==< 0x080484d2      743a           je 0x804850e
|      |:   0x080484d4      8b45fc         mov eax, dword [local_4h]
|      |:   0x080484d7      8d0c85000000.  lea ecx, [eax*4]
|      |:   0x080484de      8b550c         mov edx, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|      |:   0x080484e1      8d45fc         lea eax, [local_4h]
|      |:   0x080484e4      ff00           inc dword [eax]
|      |:   0x080484e6      c74424080300.  mov dword [esp + 8], 3
|      |:   0x080484ee      c74424043887.  mov dword [esp + 4], str.LOLO ; [0x8048738:4]=0x4f4c4f4c ; "LOLO"
|      |:   0x080484f6      8b0411         mov eax, dword [ecx + edx]
|      |:   0x080484f9      890424         mov dword [esp], eax
|      |:   0x080484fc      e8d7feffff     call sym.imp.strncmp        ; int strncmp(const char *s1, const char *s2, size_t n)
|      |:   0x08048501      85c0           test eax, eax
|      |`=< 0x08048503      75bc           jne 0x80484c1
|      |    0x08048505      c745f8010000.  mov dword [local_8h_2], 1
|      |,=< 0x0804850c      eb07           jmp 0x8048515
|      `--> 0x0804850e      c745f8000000.  mov dword [local_8h_2], 0
|       |      ; JMP XREF from 0x0804850c (sym.dummy)
|       `-> 0x08048515      8b45f8         mov eax, dword [local_8h_2]
|           0x08048518      c9             leave
\           0x08048519      c3             ret

从汇编可以发现, dummy函数虽然传入了2个参数, 但只用到了第二个, 先写个粗略的伪代码:

int dummy(char *input, char *envp[]) {
    local_4h = 0;
    while(1) {
        if (envp[local_4h] == 0) {
            return 0;
        }
        char *s = envp[local_4h];
        local_4h++;
        if (strncmp(s, "LOLO", 3) != 0) {
            continue;
        } else {
            return 1;
        }
    }
}

作用就很明显了, 判断输入的环境变量前3字节是否为LOL, 若是则返回1. 所以我们只需要 传入环境变量, 并且输入一个前X为和为0x10的偶数即可:

$ env LOL=1 ./crackme0x06
IOLI Crackme Level 0x06
Password: 886
Password OK!

crackme0x07

先看主函数:

[0x0804867d]> pdf @ main
/ (fcn) main 99
|   main (int arg_10h);
|           ; var int local_78h @ ebp-0x78
|           ; arg int arg_10h @ ebp+0x10
|           ; var int local_4h @ esp+0x4
|              ; DATA XREF from 0x08048417 (entry0)
|           0x0804867d      55             push ebp
|           0x0804867e      89e5           mov ebp, esp
|           0x08048680      81ec88000000   sub esp, 0x88
|           0x08048686      83e4f0         and esp, 0xfffffff0
|           0x08048689      b800000000     mov eax, 0
|           0x0804868e      83c00f         add eax, 0xf
|           0x08048691      83c00f         add eax, 0xf
|           0x08048694      c1e804         shr eax, 4
|           0x08048697      c1e004         shl eax, 4
|           0x0804869a      29c4           sub esp, eax
|           0x0804869c      c70424d98704.  mov dword [esp], str.IOLI_Crackme_Level_0x07 ; [0x80487d9:4]=0x494c4f49 ; "IOLI Crackme Level 0x07\n"
|           0x080486a3      e810fdffff     call sym.imp.printf         ; int printf(const char *format)
|           0x080486a8      c70424f28704.  mov dword [esp], str.Password: ; [0x80487f2:4]=0x73736150 ; "Password: "
|           0x080486af      e804fdffff     call sym.imp.printf         ; int printf(const char *format)
|           0x080486b4      8d4588         lea eax, [local_78h]
|           0x080486b7      89442404       mov dword [local_4h], eax
|           0x080486bb      c70424fd8704.  mov dword [esp], 0x80487fd  ; [0x80487fd:4]=0x7325
|           0x080486c2      e8d1fcffff     call sym.imp.scanf          ; int scanf(const char *format)
|           0x080486c7      8b4510         mov eax, dword [arg_10h]    ; [0x10:4]=-1 ; 16
|           0x080486ca      89442404       mov dword [local_4h], eax
|           0x080486ce      8d4588         lea eax, [local_78h]
|           0x080486d1      890424         mov dword [esp], eax
|           0x080486d4      e8e0feffff     call fcn.080485b9
|           0x080486d9      b800000000     mov eax, 0
|           0x080486de      c9             leave
\           0x080486df      c3             ret
[0x0804867d]> ps @ 0x80487fd
%s

大意就是用户输入密码,然后调用fcn.080485b9函数,其中第一个参数为输入字符串,第二个参数为arg_10h, 即上节说过的envp. 再看看fcn.080485b9这个函数:

[0x080485b9]> pdf @ fcn.080485b9
/ (fcn) fcn.080485b9 196
|   fcn.080485b9 (int arg_8h, int arg_ch);
|           ; var int local_dh @ ebp-0xd
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_8h @ ebp+0x8
|           ; arg int arg_ch @ ebp+0xc
|           ; var int local_4h_2 @ esp+0x4
|           ; var int local_8h_2 @ esp+0x8
|              ; CALL XREF from 0x080486d4 (main)
|           0x080485b9      55             push ebp
|           0x080485ba      89e5           mov ebp, esp
|           0x080485bc      83ec28         sub esp, 0x28               ; '('
|           0x080485bf      c745f8000000.  mov dword [local_8h], 0
|           0x080485c6      c745f4000000.  mov dword [local_ch], 0
|              ; JMP XREF from 0x08048628 (fcn.080485b9)
|       .-> 0x080485cd      8b4508         mov eax, dword [arg_8h]     ; [0x8:4]=-1 ; 8
|       :   0x080485d0      890424         mov dword [esp], eax
|       :   0x080485d3      e8d0fdffff     call sym.imp.strlen         ; size_t strlen(const char *s)
|       :   0x080485d8      3945f4         cmp dword [local_ch], eax   ; [0x13:4]=-1 ; 19
|      ,==< 0x080485db      734d           jae 0x804862a
|      |:   0x080485dd      8b45f4         mov eax, dword [local_ch]
|      |:   0x080485e0      034508         add eax, dword [arg_8h]
|      |:   0x080485e3      0fb600         movzx eax, byte [eax]
|      |:   0x080485e6      8845f3         mov byte [local_dh], al
|      |:   0x080485e9      8d45fc         lea eax, [local_4h]
|      |:   0x080485ec      89442408       mov dword [local_8h_2], eax
|      |:   0x080485f0      c7442404c287.  mov dword [local_4h_2], 0x80487c2 ; [0x80487c2:4]=0x50006425
|      |:   0x080485f8      8d45f3         lea eax, [local_dh]
|      |:   0x080485fb      890424         mov dword [esp], eax
|      |:   0x080485fe      e8c5fdffff     call sym.imp.sscanf         ; int sscanf(const char *s, const char *format,   ...)
|      |:   0x08048603      8b55fc         mov edx, dword [local_4h]
|      |:   0x08048606      8d45f8         lea eax, [local_8h]
|      |:   0x08048609      0110           add dword [eax], edx
|      |:   0x0804860b      837df810       cmp dword [local_8h], 0x10  ; [0x10:4]=-1 ; 16
|     ,===< 0x0804860f      7512           jne 0x8048623
|     ||:   0x08048611      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|     ||:   0x08048614      89442404       mov dword [local_4h_2], eax
|     ||:   0x08048618      8b4508         mov eax, dword [arg_8h]     ; [0x8:4]=-1 ; 8
|     ||:   0x0804861b      890424         mov dword [esp], eax
|     ||:   0x0804861e      e81fffffff     call 0x8048542
|     `---> 0x08048623      8d45f4         lea eax, [local_ch]
|      |:   0x08048626      ff00           inc dword [eax]
|      |`=< 0x08048628      eba3           jmp 0x80485cd
|      `--> 0x0804862a      e8f5feffff     call 0x8048524
|           0x0804862f      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|           0x08048632      89442404       mov dword [local_4h_2], eax
|           0x08048636      8b45fc         mov eax, dword [local_4h]
|           0x08048639      890424         mov dword [esp], eax
|           0x0804863c      e873feffff     call 0x80484b4
|           0x08048641      85c0           test eax, eax
|       ,=< 0x08048643      7436           je 0x804867b
|       |   0x08048645      c745f4000000.  mov dword [local_ch], 0
|       |      ; JMP XREF from 0x08048679 (fcn.080485b9)
|      .--> 0x0804864c      837df409       cmp dword [local_ch], 9     ; [0x9:4]=-1 ; 9
|     ,===< 0x08048650      7f29           jg 0x804867b
|     |:|   0x08048652      8b45fc         mov eax, dword [local_4h]
|     |:|   0x08048655      83e001         and eax, 1
|     |:|   0x08048658      85c0           test eax, eax
|    ,====< 0x0804865a      7518           jne 0x8048674
|    ||:|   0x0804865c      c70424d38704.  mov dword [esp], str.wtf    ; [0x80487d3:4]=0x3f667477 ; "wtf?\n"
|    ||:|   0x08048663      e850fdffff     call sym.imp.printf         ; int printf(const char *format)
|    ||:|   0x08048668      c70424000000.  mov dword [esp], 0
|    ||:|   0x0804866f      e874fdffff     call sym.imp.exit           ; void exit(int status)
|    `----> 0x08048674      8d45f4         lea eax, [local_ch]
|     |:|   0x08048677      ff00           inc dword [eax]
|     |`==< 0x08048679      ebd1           jmp 0x804864c
|     `-`-> 0x0804867b      c9             leave
\           0x0804867c      c3             ret

有点小长,可以用视图模式去看有个比较直观的印象,这个函数也没个名字,就还是称之为check吧, 重命名一下函数:

[0x080485b9]> afn check fcn.080485b9

写个粗糙的伪代码:

void check(char *input, char *envp[]) {
    int i,j = 0;
    while(1) {
        if (i >= strlen(input)) {
            fcn.08048524();
        }
        local_dh = input[i];
        sscanf(local_dh, "%d", &local_4h);
        j += local_4h;
        if (j == 0x10) {
            fcn.8048542(input ,envp);
        }
        i++;
        continue;
    }
}

有几个无名的函数, 先看fcn.08048524:

[0x08048542]> pdf @ 0x08048524
/ (fcn) fail 30
|   fail (int arg_8h);
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; arg int arg_8h @ ebp+0x8
|              ; CALL XREF from 0x0804862a (check)
|           0x08048524      55             push ebp
|           0x08048525      89e5           mov ebp, esp
|           0x08048527      83ec08         sub esp, 8
|           0x0804852a      c70424ad8704.  mov dword [esp], str.Password_Incorrect ; [0x80487ad:4]=0x73736150 ; "Password Incorrect!\n"
|           0x08048531      e882feffff     call sym.imp.printf         ; int printf(const char *format)
|           0x08048536      c70424000000.  mov dword [esp], 0
\           0x0804853d      e8a6feffff     call sym.imp.exit           ; void exit(int status)

作用是打印密码出错信息然后退出, 所以我们将其重命名为fail了. 其实fail函数之后还有很多逻辑, 但我们都可以不用分析, 因为那部分逻辑是不会进入的. 再看函数fcn.8048542:

[0x08048542]> pdf @ 0x8048542
/ (fcn) fcn.08048542 119
|   fcn.08048542 (int arg_8h, int arg_9h, int arg_ch);
|           ; var int local_dh @ ebp-0xd
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_8h @ ebp+0x8
|           ; arg int arg_9h @ ebp+0x9
|           ; arg int arg_ch @ ebp+0xc
|           ; var int local_4h_2 @ esp+0x4
|           ; var int local_8h_2 @ esp+0x8
|              ; CALL XREF from 0x0804861e (check)
|           0x08048542      55             push ebp
|           0x08048543      89e5           mov ebp, esp
|           0x08048545      83ec18         sub esp, 0x18
|           0x08048548      8d45fc         lea eax, [local_4h]
|           0x0804854b      89442408       mov dword [local_8h_2], eax
|           0x0804854f      c7442404c287.  mov dword [local_4h_2], 0x80487c2 ; [0x80487c2:4]=0x50006425
|           0x08048557      8b4508         mov eax, dword [arg_8h]     ; [0x8:4]=-1 ; 8
|           0x0804855a      890424         mov dword [esp], eax
|           0x0804855d      e866feffff     call sym.imp.sscanf         ; int sscanf(const char *s, const char *format,   ...)
|           0x08048562      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|           0x08048565      89442404       mov dword [local_4h_2], eax
|           0x08048569      8b45fc         mov eax, dword [local_4h]
|           0x0804856c      890424         mov dword [esp], eax
|           0x0804856f      e840ffffff     call fcn.080484b4
|           0x08048574      85c0           test eax, eax
|       ,=< 0x08048576      743f           je 0x80485b7
|       |   0x08048578      c745f8000000.  mov dword [local_8h], 0
|       |      ; JMP XREF from 0x080485b5 (fcn.08048542)
|      .--> 0x0804857f      837df809       cmp dword [local_8h], 9     ; [0x9:4]=-1 ; 9
|     ,===< 0x08048583      7f32           jg 0x80485b7
|     |:|   0x08048585      8b45fc         mov eax, dword [local_4h]
|     |:|   0x08048588      83e001         and eax, 1
|     |:|   0x0804858b      85c0           test eax, eax
|    ,====< 0x0804858d      7521           jne 0x80485b0
|    ||:|   0x0804858f      833d2ca00408.  cmp dword [0x804a02c], 1    ; [0x1:4]=-1 ; 1
|   ,=====< 0x08048596      750c           jne 0x80485a4
|   |||:|   0x08048598      c70424c58704.  mov dword [esp], str.Password_OK ; [0x80487c5:4]=0x73736150 ; "Password OK!\n"
|   |||:|   0x0804859f      e814feffff     call sym.imp.printf         ; int printf(const char *format)
|   `-----> 0x080485a4      c70424000000.  mov dword [esp], 0
|    ||:|   0x080485ab      e838feffff     call sym.imp.exit           ; void exit(int status)
|    `----> 0x080485b0      8d45f8         lea eax, [local_8h]
|     |:|   0x080485b3      ff00           inc dword [eax]
|     |`==< 0x080485b5      ebc8           jmp 0x804857f
|     `-`-> 0x080485b7      c9             leave
\           0x080485b8      c3             ret

看来是做进一步的校验, 姑且命名为double_check吧, 不知道是不是r2的bug, 居然显示这个函数有3个参数, 但我们前面知道其实它只有两个, 所以不管什么原因, 先把arg_9h去掉再说, 然后两个参数改个像样的名字:

[0x08048542]> afv-arg_9h
[0x08048542]> afvn arg_8h input
[0x08048542]> afvn arg_ch envp

again, 写一下它的伪代码:

void double_check(char *input, char *envp[])
{
    int local_4h;
    int i;
    sscanf(input, "%d", &local_4h);
    if (0 == fcn.080484b4(local_4h, envp)) {
        return;
    }
    for (i = 0; i <= 9; i++) {
        if(local_4h & 1 != 0) {
            continue;
        }
        if ((int)*0x804a02c == 1) {
            printf("Password OK!\n");
        }
        exit(0);
    }
}

由代码可以得知要想进入正确分支, 必须要满足函数fcn.080484b4返回不为0, 而且输入的数字要是个偶数. 有意思的是还要额外判断一个硬编码的地址(0x804a02c) 里的值是否为1, 若为1才打印密码正确. dump这个地址出来看看:

:> px @ 0x804a02c
- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF
0x0804a02c  0000 0000 ffff ffff ffff ffff ffff ffff  ................
0x0804a03c  ffff ffff ffff ffff ffff ffff ffff ffff  ................

发现其默认值是0, 所以必然是运行时修改了这个地址, 那么在哪儿呢? 猜测是fcn.080484b4 这函数, 因为只有它没被分析过了, 当然r2也提供了查看引用的功能:

:> axt @ 0x804a02c 
fcn.080484b4 0x8048505 [data] mov dword [0x804a02c], 1

果然是你, 那就来看看这个检查环境变量和输入的函数吧:

[0x0804851f]> pdf @ fcn.080484b4
/ (fcn) fcn.080484b4 112
|   fcn.080484b4 (int arg_ch);
|           ; var int local_8h @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_ch @ ebp+0xc
|              ; CALL XREF from 0x0804863c (check)
|              ; CALL XREF from 0x0804856f (double_check)
|           0x080484b4      55             push ebp
|           0x080484b5      89e5           mov ebp, esp
|           0x080484b7      83ec18         sub esp, 0x18
|           0x080484ba      c745fc000000.  mov dword [local_4h], 0
|       .-> 0x080484c1      8b45fc         mov eax, dword [local_4h]
|       :   0x080484c4      8d1485000000.  lea edx, [eax*4]
|       :   0x080484cb      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|       :   0x080484ce      833c0200       cmp dword [edx + eax], 0
|      ,==< 0x080484d2      7444           je 0x8048518
|      |:   0x080484d4      8b45fc         mov eax, dword [local_4h]
|      |:   0x080484d7      8d0c85000000.  lea ecx, [eax*4]
|      |:   0x080484de      8b550c         mov edx, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|      |:   0x080484e1      8d45fc         lea eax, [local_4h]
|      |:   0x080484e4      ff00           inc dword [eax]
|      |:   0x080484e6      c74424080300.  mov dword [esp + 8], 3
|      |:   0x080484ee      c7442404a887.  mov dword [esp + 4], str.LOLO ; [0x80487a8:4]=0x4f4c4f4c ; "LOLO"
|      |:   0x080484f6      8b0411         mov eax, dword [ecx + edx]
|      |:   0x080484f9      890424         mov dword [esp], eax
|      |:   0x080484fc      e8d7feffff     call sym.imp.strncmp        ; int strncmp(const char *s1, const char *s2, size_t n)
|      |:   0x08048501      85c0           test eax, eax
|      |`=< 0x08048503      75bc           jne 0x80484c1
|      |    0x08048505      c7052ca00408.  mov dword [0x804a02c], 1    ; [0x804a02c:4]=0
|      |    0x0804850f      c745f8010000.  mov dword [local_8h], 1
|      |,=< 0x08048516      eb07           jmp 0x804851f
|      `--> 0x08048518      c745f8000000.  mov dword [local_8h], 0
|       |      ; JMP XREF from 0x08048516 (fcn.080484b4)
|       `-> 0x0804851f      8b45f8         mov eax, dword [local_8h]
|           0x08048522      c9             leave
\           0x08048523      c3             ret

虽然调用时传了两个参数, 但实际上只用到了第二个即环境变量char *envp[]. 伪代码如下:

int check_env(char *input, char *envp[]) {
    int local_4h = 0;
    while(1) {
        if (0 == envp[local_4h * 4]) {
            local_8h = 0;
            break;
        }
        local_4h++;
        if (0 != strncmp(envp[local_4h * 4], "LOLO", 3))
            continue;
        *0x804a02c = 1;
        local_8h = 1;
        break;
    }
    return local_8h;
}

所以结果还是查看环境变量里的key前3位是不是LOL, 然后要求输入是个偶数, 并且前n位相加为16就行了, 所以基本上和上题一样, 只不过加了一大堆障眼法而已罢了. 验证结果:

$ LOL= ./crackme0x07 
IOLI Crackme Level 0x07
Password: 88
Password OK!

$ LOLO=1 ./crackme0x07 
IOLI Crackme Level 0x07
Password: 196110
Password OK!

crackme0x08

还是老样子, 从main开始分析:

[0x08048400]> pdf @ main
            ;-- main:
/ (fcn) sym.main 99
|   sym.main (int arg_10h);
|           ; var int local_78h @ ebp-0x78
|           ; arg int arg_10h @ ebp+0x10
|           ; var int local_4h @ esp+0x4
|              ; DATA XREF from 0x08048417 (entry0)
|           0x0804867d      55             push ebp
|           0x0804867e      89e5           mov ebp, esp
|           0x08048680      81ec88000000   sub esp, 0x88
|           0x08048686      83e4f0         and esp, 0xfffffff0
|           0x08048689      b800000000     mov eax, 0
|           0x0804868e      83c00f         add eax, 0xf
|           0x08048691      83c00f         add eax, 0xf
|           0x08048694      c1e804         shr eax, 4
|           0x08048697      c1e004         shl eax, 4
|           0x0804869a      29c4           sub esp, eax
|           0x0804869c      c70424d98704.  mov dword [esp], str.IOLI_Crackme_Level_0x08 ; [0x80487d9:4]=0x494c4f49 ; "IOLI Crackme Level 0x08\n"
|           0x080486a3      e810fdffff     call sym.imp.printf         ; int printf(const char *format)
|           0x080486a8      c70424f28704.  mov dword [esp], str.Password: ; [0x80487f2:4]=0x73736150 ; "Password: "
|           0x080486af      e804fdffff     call sym.imp.printf         ; int printf(const char *format)
|           0x080486b4      8d4588         lea eax, [local_78h]
|           0x080486b7      89442404       mov dword [local_4h], eax
|           0x080486bb      c70424fd8704.  mov dword [esp], 0x80487fd  ; [0x80487fd:4]=0x7325
|           0x080486c2      e8d1fcffff     call sym.imp.scanf          ; int scanf(const char *format)
|           0x080486c7      8b4510         mov eax, dword [arg_10h]    ; [0x10:4]=-1 ; 16
|           0x080486ca      89442404       mov dword [local_4h], eax
|           0x080486ce      8d4588         lea eax, [local_78h]
|           0x080486d1      890424         mov dword [esp], eax
|           0x080486d4      e8e0feffff     call sym.check
|           0x080486d9      b800000000     mov eax, 0
|           0x080486de      c9             leave
\           0x080486df      c3             ret

似曾相识? 再看看sym.check:

[0x08048400]> pdf @ sym.check
/ (fcn) sym.check 196
|   sym.check (int arg_8h, int arg_ch);
|           ; var int local_dh @ ebp-0xd
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; var int local_4h @ ebp-0x4
|           ; arg int arg_8h @ ebp+0x8
|           ; arg int arg_ch @ ebp+0xc
|           ; var int local_4h_2 @ esp+0x4
|           ; var int local_8h_2 @ esp+0x8
|              ; CALL XREF from 0x080486d4 (sym.main)
|           0x080485b9      55             push ebp
|           0x080485ba      89e5           mov ebp, esp
|           0x080485bc      83ec28         sub esp, 0x28               ; '('
|           0x080485bf      c745f8000000.  mov dword [local_8h], 0
|           0x080485c6      c745f4000000.  mov dword [local_ch], 0
|              ; JMP XREF from 0x08048628 (sym.check)
|       .-> 0x080485cd      8b4508         mov eax, dword [arg_8h]     ; [0x8:4]=-1 ; 8
|       :   0x080485d0      890424         mov dword [esp], eax
|       :   0x080485d3      e8d0fdffff     call sym.imp.strlen         ; size_t strlen(const char *s)
|       :   0x080485d8      3945f4         cmp dword [local_ch], eax   ; [0x13:4]=-1 ; 19
|      ,==< 0x080485db      734d           jae 0x804862a
|      |:   0x080485dd      8b45f4         mov eax, dword [local_ch]
|      |:   0x080485e0      034508         add eax, dword [arg_8h]
|      |:   0x080485e3      0fb600         movzx eax, byte [eax]
|      |:   0x080485e6      8845f3         mov byte [local_dh], al
|      |:   0x080485e9      8d45fc         lea eax, [local_4h]
|      |:   0x080485ec      89442408       mov dword [local_8h_2], eax
|      |:   0x080485f0      c7442404c287.  mov dword [local_4h_2], 0x80487c2 ; [0x80487c2:4]=0x50006425
|      |:   0x080485f8      8d45f3         lea eax, [local_dh]
|      |:   0x080485fb      890424         mov dword [esp], eax
|      |:   0x080485fe      e8c5fdffff     call sym.imp.sscanf         ; int sscanf(const char *s, const char *format,   ...)
|      |:   0x08048603      8b55fc         mov edx, dword [local_4h]
|      |:   0x08048606      8d45f8         lea eax, [local_8h]
|      |:   0x08048609      0110           add dword [eax], edx
|      |:   0x0804860b      837df810       cmp dword [local_8h], 0x10  ; [0x10:4]=-1 ; 16
|     ,===< 0x0804860f      7512           jne 0x8048623
|     ||:   0x08048611      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|     ||:   0x08048614      89442404       mov dword [local_4h_2], eax
|     ||:   0x08048618      8b4508         mov eax, dword [arg_8h]     ; [0x8:4]=-1 ; 8
|     ||:   0x0804861b      890424         mov dword [esp], eax
|     ||:   0x0804861e      e81fffffff     call sym.parell
|     ||:      ; JMP XREF from 0x0804860f (sym.check)
|     `---> 0x08048623      8d45f4         lea eax, [local_ch]
|      |:   0x08048626      ff00           inc dword [eax]
|      |`=< 0x08048628      eba3           jmp 0x80485cd
|      |       ; JMP XREF from 0x080485db (sym.check)
|      `--> 0x0804862a      e8f5feffff     call sym.che
|           0x0804862f      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12
|           0x08048632      89442404       mov dword [local_4h_2], eax
|           0x08048636      8b45fc         mov eax, dword [local_4h]
|           0x08048639      890424         mov dword [esp], eax
|           0x0804863c      e873feffff     call sym.dummy
|           0x08048641      85c0           test eax, eax
|       ,=< 0x08048643      7436           je 0x804867b
|       |   0x08048645      c745f4000000.  mov dword [local_ch], 0
|       |      ; JMP XREF from 0x08048679 (sym.check)
|      .--> 0x0804864c      837df409       cmp dword [local_ch], 9     ; [0x9:4]=-1 ; 9
|     ,===< 0x08048650      7f29           jg 0x804867b
|     |:|   0x08048652      8b45fc         mov eax, dword [local_4h]
|     |:|   0x08048655      83e001         and eax, 1
|     |:|   0x08048658      85c0           test eax, eax
|    ,====< 0x0804865a      7518           jne 0x8048674
|    ||:|   0x0804865c      c70424d38704.  mov dword [esp], str.wtf    ; [0x80487d3:4]=0x3f667477 ; "wtf?\n"
|    ||:|   0x08048663      e850fdffff     call sym.imp.printf         ; int printf(const char *format)
|    ||:|   0x08048668      c70424000000.  mov dword [esp], 0
|    ||:|   0x0804866f      e874fdffff     call sym.imp.exit           ; void exit(int status)
|    ||:|      ; JMP XREF from 0x0804865a (sym.check)
|    `----> 0x08048674      8d45f4         lea eax, [local_ch]
|     |:|   0x08048677      ff00           inc dword [eax]
|     |`==< 0x08048679      ebd1           jmp 0x804864c
|     | |      ; JMP XREF from 0x08048643 (sym.check)
|     | |      ; JMP XREF from 0x08048650 (sym.check)
|     `-`-> 0x0804867b      c9             leave
\           0x0804867c      c3             ret

还是似层相识. 有了上一题的经历, 这次就不重新分析了, 直接用radiff2来看看和上一题的不同之处:

$ radiff2 -A -C ./crackme0x07 ./crackme0x08 
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze len bytes of instructions for references (aar)
[x] Analyze function calls (aac)
[x] Use -AA or aaaa to perform additional experimental analysis.
[x] Constructing a function name for fcn.* and sym.func.* functions (aan)
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze len bytes of instructions for references (aar)
[x] Analyze function calls (aac)
[x] Use -AA or aaaa to perform additional experimental analysis.
[x] Constructing a function name for fcn.* and sym.func.* functions (aan)
              fcn.08048360  23 0x8048360 |   MATCH  (1.000000) | 0x8048360   23 sym._init
 sym.imp.__libc_start_main   6 0x8048388 |   MATCH  (1.000000) | 0x8048388    6 sym.imp.__libc_start_main
             sym.imp.scanf   6 0x8048398 |   MATCH  (1.000000) | 0x8048398    6 sym.imp.scanf
            sym.imp.strlen   6 0x80483a8 |   MATCH  (1.000000) | 0x80483a8    6 sym.imp.strlen
            sym.imp.printf   6 0x80483b8 |   MATCH  (1.000000) | 0x80483b8    6 sym.imp.printf
            sym.imp.sscanf   6 0x80483c8 |   MATCH  (1.000000) | 0x80483c8    6 sym.imp.sscanf
           sym.imp.strncmp   6 0x80483d8 |   MATCH  (1.000000) | 0x80483d8    6 sym.imp.strncmp
              sym.imp.exit   6 0x80483e8 |   MATCH  (1.000000) | 0x80483e8    6 sym.imp.exit
                    entry0  33 0x8048400 |   MATCH  (1.000000) | 0x8048400   33 entry0
              fcn.08048424  33 0x8048424 |   MATCH  (1.000000) | 0x8048424   33 fcn.08048424
              fcn.08048450  47 0x8048450 |   MATCH  (1.000000) | 0x8048450   47 sym.__do_global_dtors_aux
              fcn.08048480  50 0x8048480 |   MATCH  (1.000000) | 0x8048480   50 sym.frame_dummy
              sub.LOLO_4b4 112 0x80484b4 |   MATCH  (1.000000) | 0x80484b4  112 sym.dummy
sub.Password_Incorrect_524  30 0x8048524 |   MATCH  (1.000000) | 0x8048524   30 sym.che
            sub.sscanf_542 119 0x8048542 |   MATCH  (1.000000) | 0x8048542  119 sym.parell
            sub.strlen_5b9 196 0x80485b9 |   MATCH  (1.000000) | 0x80485b9  196 sym.check
                      main  99 0x804867d |   MATCH  (1.000000) | 0x804867d   99 sym.main
              fcn.08048755   4 0x8048755 |   MATCH  (1.000000) | 0x8048755    4 sym.__i686.get_pc_thunk.bx
              fcn.08048760  35 0x8048760 |   MATCH  (1.000000) | 0x8048760   35 sym.__do_global_ctors_aux
              fcn.0804878d  17 0x804878d |     NEW  (0.000000)
       sym.__libc_csu_init  99 0x80486e0 |     NEW  (0.000000)
       sym.__libc_csu_fini   5 0x8048750 |     NEW  (0.000000)
                 sym._fini  26 0x8048784 |     NEW  (0.000000)

lucky! crackme0x08居然和crackme0x07几乎一样, 不同之处在于crackme0x08的符号没有去掉, 虽然crackme0x07有几个新的函数, 不过大多都在init, fini部分. 所以用上题的密码来验证下:

$ LOL= ./crackme0x08 
IOLI Crackme Level 0x08
Password: 88
Password OK!

$ LOLO=1 ./crackme0x08 
IOLI Crackme Level 0x08
Password: 196110
Password OK!

有同学就问了, 要是没有那么lucky怎么办? 那也没关系, 只要分析不同的函数, 也能达到事半功倍的效果, 或者重新分析, 那也比crackme0x07简单嘛, 至少不用重命名函数了.

crackme0x09

最后一关了, 还是从main开始:

[0x080486ee]> pdf @ main
/ (fcn) main 120
|   main (int arg_10h);
|           ; var int local_78h @ ebp-0x78
|           ; var int local_4h_2 @ ebp-0x4
|           ; arg int arg_10h @ ebp+0x10
|           ; var int local_4h @ esp+0x4
|              ; DATA XREF from 0x08048437 (entry0)
|           0x080486ee      55             push ebp
|           0x080486ef      89e5           mov ebp, esp
|           0x080486f1      53             push ebx
|           0x080486f2      81ec84000000   sub esp, 0x84
|           0x080486f8      e869000000     call fcn.08048766
|           0x080486fd      81c3f7180000   add ebx, 0x18f7
|           0x08048703      83e4f0         and esp, 0xfffffff0
|           0x08048706      b800000000     mov eax, 0
|           0x0804870b      83c00f         add eax, 0xf
|           0x0804870e      83c00f         add eax, 0xf
|           0x08048711      c1e804         shr eax, 4
|           0x08048714      c1e004         shl eax, 4
|           0x08048717      29c4           sub esp, eax
|           0x08048719      8d8375e8ffff   lea eax, [ebx - 0x178b]
|           0x0804871f      890424         mov dword [esp], eax
|           0x08048722      e8b9fcffff     call sym.imp.printf         ; int printf(const char *format)
|           0x08048727      8d838ee8ffff   lea eax, [ebx - 0x1772]
|           0x0804872d      890424         mov dword [esp], eax
|           0x08048730      e8abfcffff     call sym.imp.printf         ; int printf(const char *format)
|           0x08048735      8d4588         lea eax, [local_78h]
|           0x08048738      89442404       mov dword [local_4h], eax
|           0x0804873c      8d8399e8ffff   lea eax, [ebx - 0x1767]
|           0x08048742      890424         mov dword [esp], eax
|           0x08048745      e876fcffff     call sym.imp.scanf          ; int scanf(const char *format)
|           0x0804874a      8b4510         mov eax, dword [arg_10h]    ; [0x10:4]=-1 ; 16
|           0x0804874d      89442404       mov dword [local_4h], eax
|           0x08048751      8d4588         lea eax, [local_78h]
|           0x08048754      890424         mov dword [esp], eax
|           0x08048757      e8bafeffff     call sub.strlen_616         ; size_t strlen(const char *s)
|           0x0804875c      b800000000     mov eax, 0
|           0x08048761      8b5dfc         mov ebx, dword [local_4h_2]
|           0x08048764      c9             leave
\           0x08048765      c3             ret

上来就调用了函数fcn.08048766, 看看是干嘛用的呢:

[0x080486ee]> pdf @ fcn.08048766
/ (fcn) fcn.08048766 4
|   fcn.08048766 ();
|              ; XREFS: CALL 0x080486f8  CALL 0x0804861d  CALL 0x080484db  CALL 0x08048564  CALL 0x08048590  
|              ; XREFS: CALL 0x08048778  
|           0x08048766      8b1c24         mov ebx, dword [esp]
\           0x08048769      c3             ret

WOW, 好像引用的地方还不少, 作用似乎是把栈指针指向的值保存在ebx里然后返回, 值得一提的是, call xxx指令相当于:

push $EIP + sizof instruction
jmp xxx

所以该函数作用就是把下一条指令的地址保存在ebx中. 从main函数来看, 调用的一些函数传参似乎就用了ebx来做计算, 这是什么骚操作? 网上google了一下得知, 这种模式似乎是因为编译时指定了-fPIC参数, 即产生位置无关代码, 好处是这样程序可以加载到任意内存地址, 并且可以正常访问全局变量. 关于这种模式的介绍可以查看这个stackoverflow上的回答. 简而言之, 这样我们便将ebx作为PIC寄存器, 用以访问got.plt表. 以上面的main函数为例, 先把函数fcn.08048766改名为pic, 看到调用pic之后ebx应该等于0x080486fd, 然后加上0x18f7, 再减去0x178b, 最后的值作为第一个printf的参数:

[0x080486ee]> ps @ 0x080486fd+0x18f7-0x178b
IOLI Crackme Level 0x09

当然也可以通过r2分析的符号来计算:

[0x080486ee]> ps @ section_end..got - 0x178b
IOLI Crackme Level 0x09

虽然过程曲折了点, 但总算开了个头. 接下来就可以继续分析main函数了, 还是scanf输入一个 字符串, 然后调用sub.strlen_616, 接受2个参数, 分别是用户输入input和环境变量envp:

[0x080486ee]> pdf @ sub.strlen_616
/ (fcn) sub.strlen_616 216
|   sub.strlen_616 (int input, int envp);
|           ; var int local_11h @ ebp-0x11
|           ; var int local_10h @ ebp-0x10
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; arg int input @ ebp+0x8
|           ; arg int envp @ ebp+0xc
|           ; var int local_4h @ esp+0x4
|           ; var int local_8h_2 @ esp+0x8
|              ; CALL XREF from 0x08048757 (main)
|           0x08048616      55             push ebp
|           0x08048617      89e5           mov ebp, esp
|           0x08048619      53             push ebx
|           0x0804861a      83ec24         sub esp, 0x24               ; '$'
|           0x0804861d      e844010000     call pic
|           0x08048622      81c3d2190000   add ebx, 0x19d2
|           0x08048628      c745f4000000.  mov dword [local_ch], 0
|           0x0804862f      c745f0000000.  mov dword [local_10h], 0
|              ; JMP XREF from 0x08048693 (sub.strlen_616)
|       .-> 0x08048636      8b4508         mov eax, dword [input]      ; [0x8:4]=-1 ; 8
|       :   0x08048639      890424         mov dword [esp], eax
|       :   0x0804863c      e88ffdffff     call sym.imp.strlen         ; size_t strlen(const char *s)
|       :   0x08048641      3945f0         cmp dword [local_10h], eax  ; [0x13:4]=-1 ; 19
|      ,==< 0x08048644      734f           jae 0x8048695
|      |:   0x08048646      8b45f0         mov eax, dword [local_10h]
|      |:   0x08048649      034508         add eax, dword [input]
|      |:   0x0804864c      0fb600         movzx eax, byte [eax]
|      |:   0x0804864f      8845ef         mov byte [local_11h], al
|      |:   0x08048652      8d45f8         lea eax, [local_8h]
|      |:   0x08048655      89442408       mov dword [local_8h_2], eax
|      |:   0x08048659      8d835ee8ffff   lea eax, [ebx - 0x17a2]
|      |:   0x0804865f      89442404       mov dword [local_4h], eax
|      |:   0x08048663      8d45ef         lea eax, [local_11h]
|      |:   0x08048666      890424         mov dword [esp], eax
|      |:   0x08048669      e882fdffff     call sym.imp.sscanf         ; int sscanf(const char *s, const char *format,   ...)
|      |:   0x0804866e      8b55f8         mov edx, dword [local_8h]
|      |:   0x08048671      8d45f4         lea eax, [local_ch]
|      |:   0x08048674      0110           add dword [eax], edx
|      |:   0x08048676      837df410       cmp dword [local_ch], 0x10  ; [0x10:4]=-1 ; 16
|     ,===< 0x0804867a      7512           jne 0x804868e
|     ||:   0x0804867c      8b450c         mov eax, dword [envp]       ; [0xc:4]=-1 ; 12
|     ||:   0x0804867f      89442404       mov dword [local_4h], eax
|     ||:   0x08048683      8b4508         mov eax, dword [input]      ; [0x8:4]=-1 ; 8
|     ||:   0x08048686      890424         mov dword [esp], eax
|     ||:   0x08048689      e8fbfeffff     call sub.sscanf_589         ; int sscanf(const char *s, const char *format,   ...)
|     ||:      ; JMP XREF from 0x0804867a (sub.strlen_616)
|     `---> 0x0804868e      8d45f0         lea eax, [local_10h]
|      |:   0x08048691      ff00           inc dword [eax]
|      |`=< 0x08048693      eba1           jmp 0x8048636
|      |       ; JMP XREF from 0x08048644 (sub.strlen_616)
|      `--> 0x08048695      e8c3feffff     call sub.printf_55d         ; int printf(const char *format)
|           0x0804869a      8b450c         mov eax, dword [envp]       ; [0xc:4]=-1 ; 12
|           0x0804869d      89442404       mov dword [local_4h], eax
|           0x080486a1      8b45f8         mov eax, dword [local_8h]
|           0x080486a4      890424         mov dword [esp], eax
|           0x080486a7      e828feffff     call sub.strncmp_4d4        ; int strncmp(const char *s1, const char *s2, size_t n)
|           0x080486ac      85c0           test eax, eax
|       ,=< 0x080486ae      7438           je 0x80486e8
|       |   0x080486b0      c745f0000000.  mov dword [local_10h], 0
|       |      ; JMP XREF from 0x080486e6 (sub.strlen_616)
|      .--> 0x080486b7      837df009       cmp dword [local_10h], 9    ; [0x9:4]=-1 ; 9
|     ,===< 0x080486bb      7f2b           jg 0x80486e8
|     |:|   0x080486bd      8b45f8         mov eax, dword [local_8h]
|     |:|   0x080486c0      83e001         and eax, 1
|     |:|   0x080486c3      85c0           test eax, eax
|    ,====< 0x080486c5      751a           jne 0x80486e1
|    ||:|   0x080486c7      8d836fe8ffff   lea eax, [ebx - 0x1791]
|    ||:|   0x080486cd      890424         mov dword [esp], eax
|    ||:|   0x080486d0      e80bfdffff     call sym.imp.printf         ; int printf(const char *format)
|    ||:|   0x080486d5      c70424000000.  mov dword [esp], 0
|    ||:|   0x080486dc      e82ffdffff     call sym.imp.exit           ; void exit(int status)
|    ||:|      ; JMP XREF from 0x080486c5 (sub.strlen_616)
|    `----> 0x080486e1      8d45f0         lea eax, [local_10h]
|     |:|   0x080486e4      ff00           inc dword [eax]
|     |`==< 0x080486e6      ebcf           jmp 0x80486b7
|     | |      ; JMP XREF from 0x080486ae (sub.strlen_616)
|     | |      ; JMP XREF from 0x080486bb (sub.strlen_616)
|     `-`-> 0x080486e8      83c424         add esp, 0x24               ; '$'
|           0x080486eb      5b             pop ebx
|           0x080486ec      5d             pop ebp
\           0x080486ed      c3             ret

由于启用了位置无关代码, 一眼看不出来哪个分支是我们要去的, 所以还是按照顺序来, 首先计算出GOT(末尾)地址是0x08048622 + 0x19d2 = 0x8049ff4 (= section_end..got), 写伪代码:

void strlen_616(char *input, char *envp[]) {
    int local_ch = 0;
    int local_8h;
    char c[2];
    for(i=0; i<strlen(input); i++) {
        c[0] = input[i];
        c[1] = 0;
        sscanf(c, "%d", &local_8h);
        local_ch += local_8h;
        if (local_ch == 0x10) {
            sscanf_589(input, envp);
        }
    }
    printf_55d();
    // junk codes
}

printf_55d的代码如下, 作用是打印密码错误信息并且调用exit退出, 所以其后的代码基本上 都是垃圾代码, 就不分析了.

:> pdf @ sub.printf_55d
/ (fcn) sub.printf_55d 44
|   sub.printf_55d ();
|           0x0804855d      55             push ebp
|           0x0804855e      89e5           mov ebp, esp
|           0x08048560      53             push ebx
|           0x08048561      83ec04         sub esp, 4
|           0x08048564      e8fd010000     call pic
|           0x08048569      81c38b1a0000   add ebx, 0x1a8b
|           0x0804856f      8d8349e8ffff   lea eax, [ebx - 0x17b7]
|           0x08048575      890424         mov dword [esp], eax
|           0x08048578      e863feffff     call sym.imp.printf
|           0x0804857d      c70424000000.  mov dword [esp], 0
\           0x08048584      e887feffff     call sym.imp.exit
:> ps @ section_end..got - 0x17b7
Password Incorrect!

而循环里的逻辑和之前差不多, 也是检测每一位输入的累加和, 等于0x10时调用sscanf_589:

:> pdf @ sub.sscanf_589
/ (fcn) sub.sscanf_589 141
|   sub.sscanf_589 (int arg_8h, int arg_9h, int arg_ch);
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; arg int arg_8h @ ebp+0x8
|           ; arg int arg_9h @ ebp+0x9
|           ; arg int arg_ch @ ebp+0xc
|           0x08048589      55             push ebp
|           0x0804858a      89e5           mov ebp, esp
|           0x0804858c      53             push ebx
|           0x0804858d      83ec14         sub esp, 0x14
|           0x08048590      e8d1010000     call pic
|           0x08048595      81c35f1a0000   add ebx, 0x1a5f
|           0x0804859b      8d45f8         lea eax, [local_8h]
|           0x0804859e      89442408       mov dword [esp + 8], eax
|           0x080485a2      8d835ee8ffff   lea eax, [ebx - 0x17a2]
|           0x080485a8      89442404       mov dword [esp + 4], eax
|           0x080485ac      8b4508         mov eax, dword [arg_8h]
|           0x080485af      890424         mov dword [esp], eax
|           0x080485b2      e839feffff     call sym.imp.sscanf
|           0x080485b7      8b450c         mov eax, dword [arg_ch]
|           0x080485ba      89442404       mov dword [esp + 4], eax
|           0x080485be      8b45f8         mov eax, dword [local_8h]
|           0x080485c1      890424         mov dword [esp], eax
|           0x080485c4      e80bffffff     call sub.strncmp_4d4
|           0x080485c9      85c0           test eax, eax
|       ,=< 0x080485cb      7443           je 0x8048610
|       |   0x080485cd      c745f4000000.  mov dword [local_ch], 0
|      .--> 0x080485d4      837df409       cmp dword [local_ch], 9
|     ,===< 0x080485d8      7f36           jg 0x8048610
|     |:|   0x080485da      8b45f8         mov eax, dword [local_8h]
|     |:|   0x080485dd      83e001         and eax, 1
|     |:|   0x080485e0      85c0           test eax, eax
|    ,====< 0x080485e2      7525           jne 0x8048609
|    ||:|   0x080485e4      8b83fcffffff   mov eax, dword [ebx - 4]
|    ||:|   0x080485ea      833801         cmp dword [eax], 1
|   ,=====< 0x080485ed      750e           jne 0x80485fd
|   |||:|   0x080485ef      8d8361e8ffff   lea eax, [ebx - 0x179f]
|   |||:|   0x080485f5      890424         mov dword [esp], eax
|   |||:|   0x080485f8      e8e3fdffff     call sym.imp.printf
|   `-----> 0x080485fd      c70424000000.  mov dword [esp], 0
|    ||:|   0x08048604      e807feffff     call sym.imp.exit
|    `----> 0x08048609      8d45f4         lea eax, [local_ch]
|     |:|   0x0804860c      ff00           inc dword [eax]
|     |`==< 0x0804860e      ebc4           jmp 0x80485d4
|     `-`-> 0x08048610      83c414         add esp, 0x14
|           0x08048613      5b             pop ebx
|           0x08048614      5d             pop ebp
\           0x08048615      c3             ret

同样, arg_9h也是不存在的, 应该先去掉, 然后再写下伪代码:

void sscanf_589(char *input, char *envp[]) {
    int local_8h;
    int local_ch;
    sscanf(input, "%d", &local_8h);
    if (0 == strncmp_4d4(local_8h, envp)){
        return;
    }
    for (local_ch = 0; local_ch < 9; local_ch++) {
        if (local_8h & 1 == 0) {
            if((int)*0x08049ff0 == 1) {
                printf("Password OK!\n");
            }
            exit(0);
        }
    }
}

最后看下strncmp_4d4:

:> pdf @ sub.strncmp_4d4
/ (fcn) sub.strncmp_4d4 137
|   sub.strncmp_4d4 (int arg_ch);
|           ; var int local_ch @ ebp-0xc
|           ; var int local_8h @ ebp-0x8
|           ; arg int arg_ch @ ebp+0xc
|           0x080484d4      55             push ebp
|           0x080484d5      89e5           mov ebp, esp
|           0x080484d7      53             push ebx
|           0x080484d8      83ec14         sub esp, 0x14
|           0x080484db      e886020000     call pic
|           0x080484e0      81c3141b0000   add ebx, 0x1b14
|           0x080484e6      c745f8000000.  mov dword [local_8h], 0
|       .-> 0x080484ed      8b45f8         mov eax, dword [local_8h]
|       :   0x080484f0      8d1485000000.  lea edx, [eax*4]
|       :   0x080484f7      8b450c         mov eax, dword [arg_ch]
|       :   0x080484fa      833c0200       cmp dword [edx + eax], 0
|      ,==< 0x080484fe      7448           je 0x8048548
|      |:   0x08048500      8b45f8         mov eax, dword [local_8h]
|      |:   0x08048503      8d1485000000.  lea edx, [eax*4]
|      |:   0x0804850a      8b4d0c         mov ecx, dword [arg_ch]
|      |:   0x0804850d      8d45f8         lea eax, [local_8h]
|      |:   0x08048510      ff00           inc dword [eax]
|      |:   0x08048512      8d8344e8ffff   lea eax, [ebx - 0x17bc]
|      |:   0x08048518      c74424080300.  mov dword [esp + 8], 3
|      |:   0x08048520      89442404       mov dword [esp + 4], eax
|      |:   0x08048524      8b040a         mov eax, dword [edx + ecx]
|      |:   0x08048527      890424         mov dword [esp], eax
|      |:   0x0804852a      e8d1feffff     call sym.imp.strncmp
|      |:   0x0804852f      85c0           test eax, eax
|      |`=< 0x08048531      75ba           jne 0x80484ed
|      |    0x08048533      8b83fcffffff   mov eax, dword [ebx - 4]
|      |    0x08048539      c70001000000   mov dword [eax], 1
|      |    0x0804853f      c745f4010000.  mov dword [local_ch], 1
|      |,=< 0x08048546      eb0c           jmp 0x8048554
|      `--> 0x08048548      c70424ffffff.  mov dword [esp], 0xffffffff
|       |   0x0804854f      e8bcfeffff     call sym.imp.exit
|       `-> 0x08048554      8b45f4         mov eax, dword [local_ch]
|           0x08048557      83c414         add esp, 0x14
|           0x0804855a      5b             pop ebx
|           0x0804855b      5d             pop ebp
\           0x0804855c      c3             ret
:> ps @ section_end..got - 0x17bc
LOLO

伪代码:

int strncmp_4d4(char *input, char *envp[]) {
    int i; //local_8h
    int local_ch;
    for (i=0;;i++) {
        if (envp[i * 4] == 0) {
            exit(0);
        }
        if (0 == strncmp(3, "LOLO", envp[i * 4])) {
            *0x08049ff0 = 1;
            local_ch = 1;
            break;
        }
    }
    return local_ch;
}

还是检测和之前类似, 所以综上所述, 要想密码正确, 则需满足以下输入条件:

  1. 输入的前X位(数字)之和为16, X为任意值.
  2. 输入的环境变量中要有一个key的前3字节为LOL.
  3. 输入的必须是个合法的数字而且为偶数.

验证:

$ LOL= ./crackme0x09 
IOLI Crackme Level 0x09
Password: 88
Password OK!
$ LOLTHATSFUN=1 ./crackme0x09 
IOLI Crackme Level 0x09
Password: 19621234
Password OK!

大功告成! 其实这题除了PIC之外和前一题依旧是类似的.

后记

由于这篇writeup写的时间跨度比较长, 所以前面逆了一个到后面不知不觉又当成是新的程序来分析, 其实他们之间有很多相似的地方. 不过从练习的角度来说这也算好事, 汇编代码看多了之后发现一些 原来要花很多时间分析的地方再遇到类似的模式时就能很快反应过来, 也算是熟能生巧吧.

这两篇也算是我使用radare2做静态分析的一个笔记, 因为程序都比较简单所以就没有进行调试. 一般来说遇到现实生活中的样本(比如病毒或者木马), 进行分析时还需要进行动态调试分析才能对其 功能有个整体了解, 此外也衍生出了一些反分析(加花, 加壳)以及反调试手段. 所以做安全还是 要不断学习和挑战, 切忌在自己的舒适区里止步不前啊.



相似文章

上一篇(较旧) IOLI-crackme0x01-0x05 writeup

下一篇(较新) 栈溢出漏洞的利用和缓解

评论