CSAPP - 反编译 strings_not_equal

已于 2024-01-13 20:17:06 修改
阅读量818 收藏 22
点赞数 20
文章标签： 汇编
于 2024-01-13 11:03:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baiyu33/article/details/135567195
版权

CSAPP - 反编译 strings_not_equal

CSAPP bomlab1 中涉及到的 strings_not_equal 函数, 虽然可以从函数名字猜出函数含义，但我想根据汇编代码反推出对应的C代码，而不是根据函数名字猜测。

相比于专门学习 CTF 的选手， 本篇的废话很多，是完全不熟悉汇编的视角出发。

一点经验：

  • 逐句翻译汇编，写出对应的C代码
  • 写出C代码的时候，增加注释，把寄存器 和 变量名字 绑定起来， 好处是下次看到 callee-saved 寄存器时，直接对应到C代码

文章目录

概况 - 涉及的函数调用

int main()
{
    phase_1()
        - read_line()
        - strings_not_equal()
            - string_length()
}

完整的反汇编代码

前文已对 string_length() 做了反汇编（汇编代码到C代码的人工翻译和整理）， 本篇对 strings_not_equal() 做反汇编， 它的完整汇编代码是：

(gdb) disassemble strings_not_equal 
Dump of assembler code for function strings_not_equal:
   0x0000000000401338 <+0>:     push   r12
   0x000000000040133a <+2>:     push   rbp
   0x000000000040133b <+3>:     push   rbx
   0x000000000040133c <+4>:     mov    rbx,rdi
   0x000000000040133f <+7>:     mov    rbp,rsi
   0x0000000000401342 <+10>:    call   0x40131b <string_length>
   0x0000000000401347 <+15>:    mov    r12d,eax
   0x000000000040134a <+18>:    mov    rdi,rbp
   0x000000000040134d <+21>:    call   0x40131b <string_length>
   0x0000000000401352 <+26>:    mov    edx,0x1
   0x0000000000401357 <+31>:    cmp    r12d,eax
   0x000000000040135a <+34>:    jne    0x40139b <strings_not_equal+99>
   0x000000000040135c <+36>:    movzx  eax,BYTE PTR [rbx]
   0x000000000040135f <+39>:    test   al,al
   0x0000000000401361 <+41>:    je     0x401388 <strings_not_equal+80>
   0x0000000000401363 <+43>:    cmp    al,BYTE PTR [rbp+0x0]
   0x0000000000401366 <+46>:    je     0x401372 <strings_not_equal+58>
   0x0000000000401368 <+48>:    jmp    0x40138f <strings_not_equal+87>
   0x000000000040136a <+50>:    cmp    al,BYTE PTR [rbp+0x0]
   0x000000000040136d <+53>:    nop    DWORD PTR [rax]
   0x0000000000401370 <+56>:    jne    0x401396 <strings_not_equal+94>
   0x0000000000401372 <+58>:    add    rbx,0x1
   0x0000000000401376 <+62>:    add    rbp,0x1
   0x000000000040137a <+66>:    movzx  eax,BYTE PTR [rbx]
   0x000000000040137d <+69>:    test   al,al
   0x000000000040137f <+71>:    jne    0x40136a <strings_not_equal+50>
   0x0000000000401381 <+73>:    mov    edx,0x0
   0x0000000000401386 <+78>:    jmp    0x40139b <strings_not_equal+99>
   0x0000000000401388 <+80>:    mov    edx,0x0
   0x000000000040138d <+85>:    jmp    0x40139b <strings_not_equal+99>
   0x000000000040138f <+87>:    mov    edx,0x1
   0x0000000000401394 <+92>:    jmp    0x40139b <strings_not_equal+99>
   0x0000000000401396 <+94>:    mov    edx,0x1
   0x000000000040139b <+99>:    mov    eax,edx
   0x000000000040139d <+101>:   pop    rbx
   0x000000000040139e <+102>:   pop    rbp
   0x000000000040139f <+103>:   pop    r12
   0x00000000004013a1 <+105>:   ret    
End of assembler dump.

由于汇编较长，并且在执行时跳来跳去，像是乱划线，因此按照汇编代码相对于函数起始地址的偏移量（例如 +8) 作为序号进行解释。一共105个序号，其中很多相邻行可以合并起来看。

偏移地址 0, 2, 3 和偏移地址 101, 102, 103 的汇编解读

   0x0000000000401338 <+0>:     push   r12
   0x000000000040133a <+2>:     push   rbp
   0x000000000040133b <+3>:     push   rbx

   ...

   0x000000000040139d <+101>:   pop    rbx
   0x000000000040139e <+102>:   pop    rbp
   0x000000000040139f <+103>:   pop    r12

+0: push r12: 把 r12 寄存器内容压栈。对应的是 +103 的 pop 103, 是从栈上恢复 r12 寄存器。
为啥要压栈和恢复？因为 r12 寄存器要被当前函数 strings_not_equal 使用， 而调用规约规定， callee 要在函数结束时恢复 r12， 这样的话，前面一个调用 r12 的函数（frame）能继续用 r12。

+2: push rbp: 将基指针寄存器（Base Pointer，rbp）的内容压入栈中。rbp 通常用于标记当前栈帧的开始，它在函数调用过程中用于定位局部变量和函数参数。
显然， 先压入 r12， 再压入 rbp 是比较合理的。
对应的是 +102 的 pop rbp, 弹出 rbp。

+3 push rbx: 将 rbx 寄存器的内容压入栈中。rbx 是另一个被调用者保存寄存器，它在函数执行过程中用于保存一个临时值，或者作为一个指向数据的指针。
对应的是 +101 的 pop rbx, 恢复 rbx 寄存器。

callee-saved寄存器

在 x86_64 架构中，使用的是 System V AMD64 ABI 调用约定（这是大多数 Unix-like 系统，包括 Linux 和 macOS，所采用的）。根据这个调用约定，以下是被调用者保存（callee-saved）寄存器的列表：

RBX - 基址寄存器（Base register）
RBP - 基指针寄存器（Base pointer register）
R12 - 第12个通用寄存器
R13 - 第13个通用寄存器
R14 - 第14个通用寄存器
R15 - 第15个通用寄存器
RSP - 栈指针寄存器（Stack pointer register），虽然通常不直接保存和恢复，但必须在函数调用结束时保持一致。
被调用者保存的寄存器是指在函数调用过程中，如果一个函数需要修改这些寄存器，它必须在函数返回前将它们恢复到原始值。这意味着调用者可以期望这些寄存器在函数调用后保持不变。

caller-saved寄存器

除此之外，还有一些寄存器是调用者保存（caller-saved）的，也被称作易失性（volatile）寄存器，包括:

  • RAX - 累加器寄存器（Accumulator）：用于整数运算和返回值。
  • RCX - 计数寄存器（Counter）：用于字符串操作和循环计数。
  • RDX - 数据寄存器（Data register）：用于整数运算和输入/输出操作。
  • RSI - 源索引寄存器（Source Index）：在字符串和数组操作中用作源地址指针。
  • RDI - 目的索引寄存器（Destination Index）：在字符串和数组操作中用作目的地址指针。
  • R8 - 第8个通用寄存器：用于整数运算和传递函数参数。
  • R9 - 第9个通用寄存器：同样用于整数运算和传递函数参数。
  • R10 - 第10个通用寄存器：通常用于整数运算。
  • R11 - 第11个通用寄存器：通常用于整数运算。
  • XMM0-XMM15（浮点寄存器（用于浮点数和 SIMD 运算）：
    • XMM0-XMM7 - 用于浮点运算和 SIMD 运算的寄存器，同时也用于传递函数参数和返回值。
    • XMM8-XMM15 - 在某些系统上，这些额外的寄存器用于相同的目的，但主要是在函数调用中作为易失性寄存器使用。
      这些寄存器可以在函数调用中被自由修改，不需要保存和恢复它们的原始值。如果调用者希望在函数调用后使用这些寄存器的值，它必须在调用之前自己保存它们。

偏移地址 4, 7

   0x000000000040133c <+4>:     mov    rbx,rdi
   0x000000000040133f <+7>:     mov    rbp,rsi

前面提到 rbx 和 rbp 都是 callee-saved 寄存器， 已经在使用前保存原有值、 在函数结束时恢复原有值。
现在开始使用 rbx 和 rbp:
mov rbx, rdi: rdi 寄存器存放了函数 strings_not_equal() 第一个参数。这句汇编是意思是把第一个参数放到 rbx 寄存器里。
mov rbp, rsi: 类似上面这句， 是把第二个参数放到 rbp 寄存器里。

尝试写一下对应的 C 代码:

return_type strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;
    const char* p2 = s2;
}

偏移地址 94, 99 - 函数返回值类型

   0x0000000000401396 <+94>:    mov    edx,0x1
   0x000000000040139b <+99>:    mov    eax,edx

在汇编代码 ret 之前紧邻的代码中， 如果是往 eax 寄存器里写东西， 那说明函数返回值类型是 int。 eax 是用于 int 类型返回值的函数的寄存器。

mov edx, 0x1: 把数字1写入到 rdx 寄存器。前面提到过， rdx 是数据寄存器（Data register），用于整数运算和输入/输出操作。
mov eax, edx: 把 edx 寄存器内容写入到 eax 寄存器。

通过 edx 寄存器传递感觉是多余的，但由于不知道 CSAPP bomb 可执行文件的编译参数中，是否开启过优化选项， 因此不能确定能否直接干掉。

对应的 C 代码，更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;
    const char* p2 = s2;

    return 1;
}

偏移地址 10, 15, 18, 21, 26, 31, 34, 99 - 调用 string_length

   0x0000000000401342 <+10>:    call   0x40131b <string_length>
   0x0000000000401347 <+15>:    mov    r12d,eax
   0x000000000040134a <+18>:    mov    rdi,rbp
   0x000000000040134d <+21>:    call   0x40131b <string_length>
   0x0000000000401352 <+26>:    mov    edx,0x1
   0x0000000000401357 <+31>:    cmp    r12d,eax
   0x000000000040135a <+34>:    jne    0x40139b <strings_not_equal+99>

   0x000000000040139b <+99>:    mov    eax,edx

call 0x40131b <string_length>: 调用 C 语言函数 string_length. 前文分析过它， 返回值类型是 int， 也就是说返回值放在 eax 寄存器中。
mov r12d,eax: 前面提到过， r12 是 callee-saved register， 用来存放数据。这里是说，把调用 string_length(s1) 的结果，存放到 r12d。 此时 C 代码大概这样：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;    // p1: rbx
    const char* p2 = s2;    // p2: rbp
    int len1 = string_length(p1); // len1: r12d

    return 1;
}

mov rdi, rbp: 把 rbp 寄存器里的内容放到 rdi 寄存器， 也就是说接下来调用 string_length() 函数时，传入的第一个参数是 rbp 里的内容。 rbp 里现在是啥？

0x000000000040133f <+7>: mov rbp,rsi

没错，在偏移地址7处， 是把 strings_not_equal() 第二个参数放到了 rbp 里， 现在作为 string_length 的第一个参数。紧接着的汇编代码是 call 0x40131b <string_length>. 于是 C 代码更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);   // len2: eax

    return 1;
}

mov edx,0x1: 往寄存器 edx 里写入1。
cmp r12d,eax: 比较 r12d 和 eax 两个寄存器的值。其中 eax 寄存器存放的是，最近一次函数调用（返回值是整数）的结果，也就是 string_length(s2)的结果； r12d 存放的是是调用 string_length(s1) 的结果， 是在偏移地址15 时存入的。 因此，现在这句汇编执行的是，s1 和 s2 两个字符串长度的比较。
jne 0x40139b <strings_not_equal+99>: 如果比较的 s1 和 s2 的长度不相等， 那么跳转到偏移地址为99的汇编代码继续执行。 偏移地址99处的代码有分析过， 是把 edx 寄存器的值放入 eax, 然后函数返回。而现在 edx 里存放的是1（偏移地址26时写入的）。因此C代码更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);   // len2: eax
    if (len1 != len2)
    {
        return 1;
    }
}

偏移地址 36, 39, 41, 80, 85, 99

   0x000000000040135c <+36>:    movzx  eax,BYTE PTR [rbx]
   0x000000000040135f <+39>:    test   al,al
   0x0000000000401361 <+41>:    je     0x401388 <strings_not_equal+80>

   0x0000000000401388 <+80>:    mov    edx,0x0
   0x000000000040138d <+85>:    jmp    0x40139b <strings_not_equal+99>
   0x000000000040139b <+99>:    mov    eax,edx

movzx eax,BYTE PTR [rbx]: 把寄存器 rbx 里存放的值对应的内存地址处的值， 放到 eax 寄存器里， 并且注意 movzx 和 mov 有区别， movzx 是 move with zero extending 的意思，高位填充0。也就是说被放到 eax 的 [rbx], 是一个宽度小于 int 的内容. 对应的C代码：

char c1 = *(rbx);
// 也就是:
char c1 = *s1;

完整的 C 代码更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);   //
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
}

test al,al: test 指令执行的是 AND 操作。 test al, al 意思是 al 和自己做 AND 操作。 test 指令不存储结果， 只修改 ZF, SF, PF。显然，如果 al 本身是0，那么 ZF 将等于1.
je 0x401388 <strings_not_equal+80>: 如果 ZF 为1， 则跳转到偏移地址80的地方继续执行。 也就是说， 如果 al(eax的低8位，也就是刚刚C代码中的 c1)为0，那么就跳转到偏移地址80地方执行。 对应的 C 代码:

char c1 = *p1;
if (c1 == 0)
{
    goto offset80;
}

地址偏移80，85, 99处的汇编：
mov edx, 0x0: 往 edx 寄存器写入0。
jmp 0x40139b <strings_not_equal+99>: 无条件跳转到 offset99。
mov eax, edx: 把 edx 寄存器的值拷贝到 eax，也就是说 edx 里刚刚写入的0，是函数的返回值。

完整的C代码更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
}

偏移地址 43, 46, 58, 62

是在偏移地址41的地方， ZF 不为0的情况下，继续执行的代码。也就是 char c1 = *s1 后， c1 != '\0' 情况下，继续执行的代码。

   0x0000000000401363 <+43>:    cmp    al,BYTE PTR [rbp+0x0]
   0x0000000000401366 <+46>:    je     0x401372 <strings_not_equal+58>

   0x0000000000401372 <+58>:    add    rbx,0x1
   0x0000000000401376 <+62>:    add    rbp,0x1

cmp al, BYTE PTR [rbp+0x0]: 比较两个值，第一个值是 al 寄存器， 也就是 C 代码中我们自行定义的 c1 变量； 第二个是 BYTE PTR [rbp+0x0], 也就是 rbp 寄存器中存储的值对应的内存地址处存放的值。

cmp 指令，可以理解为两个操作数做减法，如果结果等于0，那么ZF就更新为1，否则ZF更新为0.

je 0x401372 <strings_not_equal+58>: 如果 ZF 为1（也就是cmp比较的两个操作数相等），那么跳转到偏移地址为58的地方。对应的C代码:

if (al == *rbp)
{
    goto label58
}

也就是：

if (c1 == *p2)
{
    goto label58
}

偏移地址为58的地方：
add rbx, 0x1: rbx 寄存器加1. 也就是 rbx 更新为 rbx + 1。 对应的C代码:

p1++;

偏移地址为62的地方：
add rbp, 0x1: 同上， rbp++:

p2++;

完整的C代码更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
    if (c1 == *p2)
    {
        p1++;
        p2++;
    }
}

偏移地址 66, 69, 71, 50, 53, 56, 94, 99

   0x000000000040137a <+66>:    movzx  eax,BYTE PTR [rbx]
   0x000000000040137d <+69>:    test   al,al
   0x000000000040137f <+71>:    jne    0x40136a <strings_not_equal+50>

   0x000000000040136a <+50>:    cmp    al,BYTE PTR [rbp+0x0]
   0x000000000040136d <+53>:    nop    DWORD PTR [rax]
   0x0000000000401370 <+56>:    jne    0x401396 <strings_not_equal+94>
   0x0000000000401396 <+94>:    mov    edx,0x1
   0x000000000040139b <+99>:    mov    eax,edx

movzx eax, BYTE PTR [rbx]: 把 rbx 寄存器里存放的值对应的内存地址处， 存放到 eax 寄存器。感觉这里是把 eax 寄存器当作临时变量用了。实际上偏移地址36和66的汇编代码一样：

   0x000000000040135c <+36>:    movzx  eax,BYTE PTR [rbx]
   0x000000000040137a <+66>:    movzx  eax,BYTE PTR [rbx]

含义自然也是一样的：char c1 = *s1. 只不过此时的 s1 已经是原始输入的 s1 再加 1 了。

test al, al: 让 AL 和 AL 做 AND 操作， 如果结果为1， 则ZF为0. 如果 AND 结果为0， 则 ZF 为1.

jne 0x40136a <strings_not_equal+50>: 检查 ZF， 如果ZF为1（也就是AL为0, 对应到C代码就是 c1 为 0），则跳转到偏移地址为50的地方继续执行。

对应的 C 代码

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
    if (c1 == *p2)
    {
        p1++;
        p2++;
    }
    c1 = *p1;
    if (c1 != '\0')
    {
        if (c1 != *p2)
        {
            return 1;
        }
    }
}

偏移地址 69, 71, 73, 78, 99

   0x000000000040137d <+69>:    test   al,al
   0x000000000040137f <+71>:    jne    0x40136a <strings_not_equal+50>
   0x0000000000401381 <+73>:    mov    edx,0x0
   0x0000000000401386 <+78>:    jmp    0x40139b <strings_not_equal+99>
   0x000000000040139b <+99>:    mov    eax,edx

if (c1 == '\0')
{
    return 0;
}

完整代码更新为：

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
    if (c1 == *p2)
    {
        p1++;
        p2++;
    }
    c1 = *p1;
    if (c1 != '\0')
    {
        if (c1 != *p2)
        {
            return 1;
        }
    }
    else
    {
        return 0;
    }
}

50, 53, 56, 58, 62

   0x000000000040136a <+50>:    cmp    al,BYTE PTR [rbp+0x0]
   0x000000000040136d <+53>:    nop    DWORD PTR [rax]
   0x0000000000401370 <+56>:    jne    0x401396 <strings_not_equal+94>
   0x0000000000401372 <+58>:    add    rbx,0x1
   0x0000000000401376 <+62>:    add    rbp,0x1

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
    if (c1 == *p2)
    {
goto label58;
    }
label58:
    p1++;
    p2++;

    c1 = *p1;
    if (c1 != '\0')
    {
        if (c1 != *p2)
        {
            return 1;
        }
        else
        {
            goto label58;
        }
    }
    else
    {
        return 0;
    }
}

43, 46, 48, 87, 92, 99

   0x0000000000401363 <+43>:    cmp    al,BYTE PTR [rbp+0x0]
   0x0000000000401366 <+46>:    je     0x401372 <strings_not_equal+58>
   0x0000000000401368 <+48>:    jmp    0x40138f <strings_not_equal+87>
   0x000000000040138f <+87>:    mov    edx,0x1
   0x0000000000401394 <+92>:    jmp    0x40139b <strings_not_equal+99>
   0x000000000040139b <+99>:    mov    eax,edx

if (c1 != *p2)
{
    return 1;
}

完整的C代码更新为:

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
    if (c1 == *p2)
    {
goto label58;
    }
    else
    {
        return 1;
    }
label58:
    p1++;
    p2++;

    c1 = *p1;
    if (c1 != '\0')
    {
        if (c1 != *p2)
        {
            return 1;
        }
        else
        {
            goto label58;
        }
    }
    else
    {
        return 0;
    }
}

整理代码

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }
    char c1 = *p1;                  // c1: eax
    if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
    {
        return 0;
    }
    if (c1 != *p2)
    {
        return 1;
    }
label58:
    p1++;
    p2++;

    c1 = *p1;
    if (c1 == '\0')
    {
        return 0;
    }
    if (c1 != '\0')
    {
        if (c1 != *p2)
        {
            return 1;
        }
        else
        {
            goto label58;
        }
    }
}

int strings_not_equal(const char* s1, const char* s2)
{
    const char* p1 = s1;            // p1: rbx
    const char* p2 = s2;            // p2: rbp
    int len1 = string_length(p1);   // len1: r12d
    int len2 = string_length(p2);
    if (len1 != len2)
    {
        return 1;
    }

    int ret = 0;
    for (; ;)
    {
        char c1 = *p1;                  // c1: eax
        if (c1 == '\0')                 // s1[0] 为 '\0', 而 s1, s2 长度相等， 说明 s2[0] 也是 '\0'
        {
            ret = 0;
            break;
        }
        if (c1 != *p2)
        {
            ret = 1;
            break;
        }
        p1++;
        p2++;
    }
    return ret;
}
baiyu33
关注
  • 20
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CSAPP-3e-Solutions:CSAPP 3e解决方案，已从已关闭的gitbook.io迁移到github.io
05-03
CSAPP-3e-解决方案 计算机系统：程序员的观点第三版解决方案建造先决条件x64 linux系统码头工人克隆码git clone https://github.com/DreamAndDead/CSAPP-3e-Solutions.gitcd CSAPP-3e-Solutions拉图像sudo docker ...
CSAPP实验-二进制炸弹writeup
y4ung
07-15 6522
0x01 题目概述 二进制炸弹是《深入理解计算机系统》的一个课程实验。 给定一个二进制文件bomb，及其主程序bomb.c文件，运行二进制文件bomb，一共有6关，用户需要通过6个输入来避免炸弹的爆炸。 我们需要通过对二进制文件进行逆向分析，得到能避开炸弹爆炸的合理的输入。 0x02 涉及知识点 汇编语言的基础，逆向分析工具的使用。 0x03 实验环境 Ubuntu16.04LTS，IDA Pro...
Vue学习（八）—函数式组件
sophiacan110的博客
11-11 507
函数式组件是什么： 一般的组件是有内部逻辑的，拿本项目来说，点了某个选项就会弹出来其他的选项或者改变其他选项的状态。这种组件就好像汪汪队的一个玩具，上面安装了按钮，按下某个按钮翅膀就会弹出来，再按一下翅膀就收回去，再按一个按钮就唱歌之类的。 但是还有一类组件就像是没有按钮的玩具，它的功能就是展示给人看，他的形态一直是一个样子。就类似在网页上传一张照片，然后就把照片展示出来而已。 但是为什么叫函数式组件呢？ 因为组件并不是玩具，而是一个打印玩具的盒子，有数据输入，通过这个黑盒子组件，就出现了一个玩具。
二进制炸弹(第二次实验)
热门推荐
我去
04-25 1万+
实验目的本实验通过要求你使用课程所学知识拆除一个“binary bombs”来增强对程序的机器级表示、汇编语言、调试器和逆向工程等方面原理与技能的掌握。 一个“binary bombs”（二进制炸弹，下文将简称为炸弹）是一个Linux可执行程序，包含了6个阶段（或层次、关卡）。炸弹运行的每个阶段要求你输入一个特定字符串，你的输入符合程序预期的输入，该阶段的炸弹就被拆除引信即解除了，否则炸弹“爆炸”
二进制拆弹实验详解linux,拆解二进制炸弹
weixin_30183847的博客
05-15 2236
拆解二进制炸弹一、实验目的1.理解C语言程序的机器级表示。2.初步掌握GDB调试器的用法。3.阅读C编译器生成的x86-64机器代码，理解不同控制结构生成的基本指令模式，过程的实现。二、 实验环境SecureCRT(10.105.222.110)LinuxObjdump命令反汇编GDB调试工具。。。。。三、实验内容登录bupt1服务器，在home目录下可以找到Evil博士专门为你量身定制的一个bo...
mjjanusa-malloc-lab-2-04360fc.zip_csapp malloc_malloc l_malloc
09-22
csapp 实验 这是csapp实验中的第三个系列，有关malloc 的改写，就发了有用的
tsh.rar_CSAPP shell_pudn csapp shell_tsh
09-24
根据csapp的handout实现简单的shell，包括执行前后台bg fg jobs quit等命令
csapp-3e-code-all.tar
05-29
csapp的编码工具，本科学习csapp的必备工具，安全可靠！ 稳定可用！Windows环境安装
CSAPP-15-213：CMU CSAPP
02-11
CSAPP-15-213 CMU CSAPP 相关资源 日志 状态 内容 日期 :white_heavy_check_mark: 阅读3.6 2020.06.18 :white_heavy_check_mark: lec6视频：机器编程：控制 2020.06.19 :white_heavy_check_mark: 阅读3.7 ...
Linux基础 -- 跨平台原子操作：ARM 汇编与 C 语言集成
sz66cm 学习随笔
04-28 221
linux 汇编 混合编程
8086：qemu执行汇编
[email protected]的博客
04-26 468
当使用qemu-system-i386命令并提供一个二进制文件作为参数时，QEMU会尝试以i386架构的处理器来执行这个二进制文件。虽然这个二进制文件不是一个完整的操作系统或磁盘镜像文件，但QEMU仍然可以尝试执行它，并显示输出结果。
【汇编】指令系统的寻址方式
m0_74209563的博客
04-22 1010
指令系统的寻址方式 七种寻址方式简介
后端开发是一个涉及广泛技术和工具的领域.docx
04-30
后端开发是一个涉及广泛技术和工具的领域，这些资源对于构建健壮、可扩展和高效的Web应用程序至关重要。以下是对后端开发资源的简要介绍： 首先，掌握一门或多门编程语言是后端开发的基础。Java、Python和Node.js是其中最受欢迎的几种。Java以其跨平台性和丰富的库而著名，Python则因其简洁的语法和广泛的应用领域而备受欢迎。Node.js则通过其基于JavaScript的单线程异步I/O模型，为Web开发提供了高性能的解决方案。 其次，数据库技术是后端开发中不可或缺的一部分。关系型数据库（如MySQL、PostgreSQL）和非关系型数据库（如MongoDB、Redis）各有其特点和应用场景。关系型数据库适合存储结构化数据，而非关系型数据库则更适合处理大量非结构化数据。 此外，Web开发框架也是后端开发的重要资源。例如，Express是一个基于Node.js的Web应用开发框架，它提供了丰富的API和中间件支持，使得开发人员能够快速地构建Web应用程序。Django则是一个用Python编写的Web应用框架，它采用了MVC的软件设计模式，使得代码结构更加清晰和易于维护。
华为数字化转型实践28个精华问答glkm.pptx
04-30
华为数字化转型实践28个精华问答glkm.pptx
新员工入职培训全流程资料包gl.zip
04-30
新员工入职培训全流程资料包（100+个文件） 1入职流程指引 万科新职员入职通知书 万科新职员入职引导手册 新进员工跟进管理表 新员工入职报到工作单(文职) 新员工入职报到流程 新员工入职流程表 新员工入职手续办理流程(工厂 新员工入职手续清单 新员工入职须知 新员工入职训流程 新员工入职引导表(导师用) 2 入职工具表格 3 培训方案计划 4培训管理流程 5培训教材课件 6 培训效果检测 7 员工管理制度 8 劳动合同协议 9 新员工培训PPT模板(28套)
三菱PLC通讯程序实例
04-30
FX5U PLC作为主、从站的通讯方式程序实例，以及包含详细说明文件...
技术需求报告-集行波测距与故障录波功能于一体的电网综合故障分析系统.docx
最新发布
04-30
技术需求报告-集行波测距与故障录波功能于一体的电网综合故障分析系统.docx
最新二开版本源码博客论坛源码,UI很漂亮,可切换皮肤界面.rar
04-30
最新二开版本源码博客论坛源码,UI很漂亮,可切换皮肤界面.rar最新二开版本源码博客论坛源码,UI很漂亮,可切换皮肤界面.rar
csapp 习题 - 如何实现异或 exclusive-or
05-25
异或（exclusive-or）操作是一种逻辑运算，用于比较两个二进制数的位。如果两个数的对应位相同，则结果为0，否则为1。在C语言中，异或操作用符号“^”表示。 如果要实现异或操作，可以使用以下代码： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值