Linux内核(x86)入口代码模糊测试指南Part2（下篇）

在上一篇中，我们为读者更进一步介绍了各种标志寄存器、堆栈指针以及部分段寄存器，在本文中，我们将为读者介绍调试寄存器以及进入内核的不同方法。

成都创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站建设、成都网站设计、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的灌南网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

堆栈段（%ss）

寄存器%ss应该是我们在进入内核的指令之前设置的最后一个寄存器，这样我们就可以确保看到任何延迟陷阱或异常的影响。我们可以使用与上面%ds相同的代码；我们不使用popw %ss的原因是，我们可能已经将%rsp设置为指向一个“奇怪”的位置，所以此时堆栈可能无法使用。

32位兼容模式（%cs）

有趣的是：你实际上可以在执行过程中把你的64位进程改变成32位进程，甚至不需要告诉内核。CPU包含了一种机制，在ring 3模式下是允许的：远跳转指令。

特别是，我们要使用的指令是“绝对间接远跳转指令,地址由m16:32给出”。由于要弄清楚具体的语法和字节可能有点麻烦，所以下面将借助于一个完整的汇编例子进行解释。

 
 
 
    
  
  
  
  1.   .global main
    2. 
  
  
  
  2. main:
    3. 
  
  
  
  3.     ljmpl *target
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5. 1:
    6. 
  
  
  
  6.     .code32
    7. 
  
  
  
  7.     movl $1, %eax # __NR_exit == 1 from asm/unistd_32.h
    8. 
  
  
  
  8.     movl $2, %ebx # status == 0
    9. 
  
  
  
  9.     sysenter
    10. 
  
  
  
  10.     ret
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.     .data
    13. 
  
  
  
  13. target:
    14. 
  
  
  
  14.     .long 1b # address (32 bits)
    15. 
  
  
  
  15.     .word 0x23 # segment selector (16 bits)
    16.

这里，ljmpl指令使用target标签处的内存，该标签是一个32位指令指针，后跟一个16位段选择器（这里指向用户空间的32位代码段0x23）。这里的目标地址1b不是十六进制值，它实际上是对标签1的引用；b代表“向后”。这个标签处的代码是32位的，这就是为什么我们使用sysenter，而不是以前使用的syscall。调用约定也不同，实际上，我们需要使用32位ABI中的系统调用号（SYS_exit在64位系统上是60，但这里是1）。另一个有趣的事情是，如果你尝试在strace下运行这段代码，将会看到如下所示的结果：

 
 
 
    
  
  
  
  1. [...]
    2. 
  
  
  
  2. write(1, "\366\242[\204\374\177\0\0\0\0\0\0\0\0\0\0\376\242[\204\374\177\0\0\t\243[\204\374\177\0\0"..., 140722529079224
    3. 
  
  
  
  3. +++ exited with 0 +++
    4.

strace显然认为我们仍然是一个64位进程，并认为我们调用了write()，而实际上我们是在调用exit()（最后一行就证明了这一点，它清楚地告诉我们进程退出了）。

由于ljmp的内存操作数和目标地址都是32位的，我们需要确保它们都位于高32位都为0的地址中，最好的方法是使用mmap()和MAP_32BIT标志来分配内存。

 
 
 
    
  
  
  
  1. struct ljmp_target {
    2. 
  
  
  
  2.     uint32_t rip;
    3. 
  
  
  
  3.     uint16_t cs;
    4. 
  
  
  
  4. } __attribute__((packed));
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6. struct data {
    7. 
  
  
  
  7.     struct ljmp_target ljmp;
    8. 
  
  
  
  8. };
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. static struct data *data;
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12. int main(...)
    13. 
  
  
  
  13. {
    14. 
  
  
  
  14.     ...
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.     void *addr = mmap(NULL, PAGE_SIZE,
    17. 
  
  
  
  17.         PROT_READ | PROT_WRITE,
    18. 
  
  
  
  18.         MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT,
    19. 
  
  
  
  19.         -1, 0);
    20. 
  
  
  
  20.     if (addr == MAP_FAILED)
    21. 
  
  
  
  21.         error(EXIT_FAILURE, errno, "mmap()");
    22. 
  
  
  
  22.  
    23. 
  
  
  
  23.     data = (struct data *) addr;
    24. 
  
  
  
  24.  
    25. 
  
  
  
  25.     ...
    26. 
  
  
  
  26. }
    27. 
  
  
  
  27.  
    28. 
  
  
  
  28. void emit_code()
    29. 
  
  
  
  29. {
    30. 
  
  
  
  30.     ...
    31. 
  
  
  
  31.  
    32. 
  
  
  
  32.     // ljmp *target
    33. 
  
  
  
  33.     *out++ = 0xff;
    34. 
  
  
  
  34.     *out++ = 0x2c;
    35. 
  
  
  
  35.     *out++ = 0x25;
    36. 
  
  
  
  36.     for (unsigned int i = 0; i < 4; ++i)
    37. 
  
  
  
  37.         *out++ = ((uint64_t) &data->ljmp) >> (8 * i);
    38. 
  
  
  
  38.  
    39. 
  
  
  
  39.     // cs:rip (jump target; in our case, the next instruction)
    40. 
  
  
  
  40.     data->ljmp.cs = 0x23;
    41. 
  
  
  
  41.     data->ljmp.rip = (uint64_t) out;
    42. 
  
  
  
  42.  
    43. 
  
  
  
  43.     ...
    44. 
  
  
  
  44. }
    45.

这里有几件事需要注意：

这将改变CPU模式，这意味着后续指令必须在32位中有效（否则，您可能会得到一般保护故障或无效操作码异常）。

上面我们用来加载段寄存器的指令序列(例如movw ..., %ax; movw %ax, %ss)在32位和64位上有完全相同的编码，所以我们可以在切换到32位代码段后毫不费力地执行它——这对于确保我们在进入内核之前仍然可以加载%ss特别有用。

我们可以选择是否始终更改为段4（段选择器0x23），或者尝试更改为随机段选择器（例如使用get_random_segment_selector())。如果我们选择一个随机的，我们甚至可能不知道我们是仍然在32位还是64位模式下执行。

我们可能希望在从内核返回后尝试跳回我们的正常代码段（段6，段选择器0x33），如果我们没有退出、崩溃或被杀死的话。对于不同的段选择器，该过程完全相同。

调试寄存器（%dr0等）

x86上的调试寄存器用于设置代码断点和数据观察点。寄存器%dr0到%dr3用于设置实际的断点/观察点地址，寄存器%dr7用于控制这四个地址的使用方式（是断点还是观察点等）。

设置调试寄存器比我们目前看到的要棘手一些，因为你不能直接在用户空间加载它们。就像修改LDT一样，内核要确保我们不会在内核地址上设置断点或观察点，但更重要的是，CPU本身不允许ring 3直接修改这些寄存器。我所知道的设置调试寄存器的唯一方法就是使用ptrace()。

ptrace()是一个非常难用的API。有很多隐含的状态需要跟踪器手动跟踪，还有很多围绕信号处理的边缘情况。幸运的是，在这种情况下，我们只需要附加到子进程，设置调试寄存器，然后脱离即可；即使在我们停止跟踪之后，调试寄存器的变化也会持续存在。

 
 
 
    
  
  
  
  1. #include
    2. 
  
  
  
  2. #include
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. #include
    5. 
  
  
  
  5. #include
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. int main(...)
    8. 
  
  
  
  8. {
    9. 
  
  
  
  9.     pid_t child = fork();
    10. 
  
  
  
  10.     if (child == -1)
    11. 
  
  
  
  11.         error(EXIT_FAILURE, errno, "fork()");
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13.     if (child == 0) {
    14. 
  
  
  
  14.         // make us a tracee of the parent
    15. 
  
  
  
  15.         if (ptrace(PTRACE_TRACEME, 0, 0, 0) == -1)
    16. 
  
  
  
  16.             error(EXIT_FAILURE, errno, "ptrace(PTRACE_TRACEME)");
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18.         // give the parent control
    19. 
  
  
  
  19.         raise(SIGTRAP);
    20. 
  
  
  
  20.  
    21. 
  
  
  
  21.         ...
    22. 
  
  
  
  22.  
    23. 
  
  
  
  23.         exit(EXIT_SUCCESS);
    24. 
  
  
  
  24.     }
    25. 
  
  
  
  25.  
    26. 
  
  
  
  26.     // parent; wait for child to stop
    27. 
  
  
  
  27.     while (1) {
    28. 
  
  
  
  28.         int status;
    29. 
  
  
  
  29.         if (waitpid(child, &status, 0) == -1) {
    30. 
  
  
  
  30.             if (errno == EINTR)
    31. 
  
  
  
  31.                 continue;
    32. 
  
  
  
  32.  
    33. 
  
  
  
  33.             error(EXIT_FAILURE, errno, "waitpid()");
    34. 
  
  
  
  34.         }
    35. 
  
  
  
  35.  
    36. 
  
  
  
  36.         if (WIFEXITED(status))
    37. 
  
  
  
  37.             exit(WEXITSTATUS(status));
    38. 
  
  
  
  38.         if (WIFSIGNALED(status))
    39. 
  
  
  
  39.             exit(EXIT_FAILURE);
    40. 
  
  
  
  40.  
    41. 
  
  
  
  41.         if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP)
    42. 
  
  
  
  42.             break;
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.         continue;
    45. 
  
  
  
  45.     }
    46. 
  
  
  
  46.  
    47. 
  
  
  
  47.     // set debug registers and stop tracing
    48. 
  
  
  
  48.     if (ptrace(PTRACE_POKEUSER, child, offsetof(struct user, u_debugreg[0]), ...) == -1)
    49. 
  
  
  
  49.         error(EXIT_FAILURE, errno, "ptrace(PTRACE_POKEUSER)");
    50. 
  
  
  
  50.     if (ptrace(PTRACE_POKEUSER, child, offsetof(struct user, u_debugreg[7]), ...) == -1)
    51. 
  
  
  
  51.         error(EXIT_FAILURE, errno, "ptrace(PTRACE_POKEUSER)");
    52. 
  
  
  
  52.     if (ptrace(PTRACE_DETACH, child, 0, 0) == -1)
    53. 
  
  
  
  53.         error(EXIT_FAILURE, errno, "ptrace(PTRACE_DETACH)");
    54. 
  
  
  
  54.  
    55. 
  
  
  
  55.     ...
    56. 
  
  
  
  56. }
    57.

即使在这个小例子中，等待子程序停止也是有点麻烦的。waitpid()总是有可能在子程序到达raise(SIGTRAP)之前返回，例如，如果它被某个外部进程杀死了。我们对这些情况的处理方式也是简单的退出。

由于设置调试寄存器需要跟踪，处理信号被进行多次上下文切换（这些都很慢），我建议对每个子进程只做一次，然后让子进程连续多次尝试进入内核。

设置任何一个调试寄存器都可能失败，所以在实际的fuzzer中，我们可能希望忽略所有错误，每次将%dr7设置为一个断点，例如：

 
 
 
    
  
  
  
  1. // stddef.h offsetof() doesn't always allow non-const array indices,
    2. 
  
  
  
  2. // so precompute them here.
    3. 
  
  
  
  3. const unsigned int debugreg_offsets[] = {
    4. 
  
  
  
  4.     offsetof(struct user, u_debugreg[0]),
    5. 
  
  
  
  5.     offsetof(struct user, u_debugreg[1]),
    6. 
  
  
  
  6.     offsetof(struct user, u_debugreg[2]),
    7. 
  
  
  
  7.     offsetof(struct user, u_debugreg[3]),
    8. 
  
  
  
  8. };
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. for (unsigned int i = 0; i < 4; ++i) {
    11. 
  
  
  
  11.     // try random addresses until we succeed
    12. 
  
  
  
  12.     while (true) {
    13. 
  
  
  
  13.         unsigned long addr = get_random_address();
    14. 
  
  
  
  14.         if (ptrace(PTRACE_POKEUSER, child, debugreg_offsets[i], addr) != -1)
    15. 
  
  
  
  15.             break;
    16. 
  
  
  
  16.     }
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18.     // Condition:
    19. 
  
  
  
  19.     // 0 - execution
    20. 
  
  
  
  20.     // 1 - write
    21. 
  
  
  
  21.     // 2 - (unused)
    22. 
  
  
  
  22.     // 3 - read or write
    23. 
  
  
  
  23.     unsigned int condition = std::uniform_int_distribution
    24. 
  
  
  
  24.     if (condition == 2)
    25. 
  
  
  
  25.         condition = 3;
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27.     // Size
    28. 
  
  
  
  28.     // 0 - 1 byte
    29. 
  
  
  
  29.     // 1 - 2 bytes
    30. 
  
  
  
  30.     // 2 - 8 bytes
    31. 
  
  
  
  31.     // 3 - 4 bytes
    32. 
  
  
  
  32.     unsigned int size = std::uniform_int_distribution
    33. 
  
  
  
  33.  
    34. 
  
  
  
  34.     unsigned long dr7 = ptrace(PTRACE_PEEKUSER, child, offsetof(struct user, u_debugreg[7]), 0);
    35. 
  
  
  
  35.     dr7 &= ~((1 | (3 << 16) | (3 << 18)) << i);
    36. 
  
  
  
  36.     dr7 |= (1 | (condition << 16) | (size << 18)) << i;
    37. 
  
  
  
  37.     ptrace(PTRACE_POKEUSER, child, offsetof(struct user, u_debugreg[7]), dr7);
    38. 
  
  
  
  38. }
    39.

进入内核

在本系列的第一篇文章中，我们已经看到了如何进行系统调用的代码；在这里，我们使用相同的基本方法，但也考虑到所有其他进入内核的方式。正如我前面提到的，syscall指令不是进入64位内核的唯一方法，甚至不是进行系统调用的唯一方法。对于系统调用，我们有以下选项：

 
 
 
    
  
  
  
  1. int $0x80
    2. 
  
  
  
  2. sysenter
    3. 
  
  
  
  3. syscall
    4.

实际上，查看硬件生成的异常表也很有用。其中许多异常的处理方式与系统调用和常规中断略有不同；例如，当您试图加载一个带有无效段选择器的段寄存器时，CPU会将一个错误代码压入（内核）堆栈上。

我们可以触发许多异常，但不是所有的异常。例如，通过简单地执行除零来生成除零异常是非常简单的，但是我们不能轻松地按需生成NMI。（也就是说，我们可以做一些事情来使NMI更有可能发生，尽管是以一种不可控制的方式：如果我们在VM中测试内核，我们可以从主机注入NMI，或者我们可以启用内核NMI watchdog功能。）

 
 
 
    
  
  
  
  1. enum entry_type {
    2. 
  
  
  
  2.     // system calls + software interrupts
    3. 
  
  
  
  3.     ENTRY_SYSCALL,
    4. 
  
  
  
  4.     ENTRY_SYSENTER,
    5. 
  
  
  
  5.     ENTRY_INT,
    6. 
  
  
  
  6.     ENTRY_INT_80,
    7. 
  
  
  
  7.     ENTRY_INT3,
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.     // exceptions
    10. 
  
  
  
  10.     ENTRY_DE, // Divide error
    11. 
  
  
  
  11.     ENTRY_OF, // Overflow
    12. 
  
  
  
  12.     ENTRY_BR, // Bound range exceeded
    13. 
  
  
  
  13.     ENTRY_UD, // Undefined opcode
    14. 
  
  
  
  14.     ENTRY_SS, // Stack segment fault
    15. 
  
  
  
  15.     ENTRY_GP, // General protection fault
    16. 
  
  
  
  16.     ENTRY_PF, // Page fault
    17. 
  
  
  
  17.     ENTRY_MF, // x87 floating-point exception
    18. 
  
  
  
  18.     ENTRY_AC, // Alignment check
    19. 
  
  
  
  19.  
    20. 
  
  
  
  20.     NR_ENTRY_TYPES,
    21. 
  
  
  
  21. };
    22. 
  
  
  
  22.  
    23. 
  
  
  
  23. enum entry_type type = (enum entry_type) std::uniform_int_distribution
    24. 
  
  
  
  24.  
    25. 
  
  
  
  25. // Some entry types require a setup/preamble; do that here
    26. 
  
  
  
  26. switch (type) {
    27. 
  
  
  
  27. case ENTRY_DE:
    28. 
  
  
  
  28.     // xor %eax, %eax
    29. 
  
  
  
  29.     *out++ = 0x31;
    30. 
  
  
  
  30.     *out++ = 0xc0;
    31. 
  
  
  
  31.     break;
    32. 
  
  
  
  32. case ENTRY_MF:
    33. 
  
  
  
  33.     // pxor %xmm0, %xmm0
    34. 
  
  
  
  34.     *out++ = 0x66;
    35. 
  
  
  
  35.     *out++ = 0x0f;
    36. 
  
  
  
  36.     *out++ = 0xef;
    37. 
  
  
  
  37.     *out++ = 0xc0;
    38. 
  
  
  
  38.     break;
    39. 
  
  
  
  39. case ENTRY_BR:
    40. 
  
  
  
  40.     // xor %eax, %eax
    41. 
  
  
  
  41.     *out++ = 0x31;
    42. 
  
  
  
  42.     *out++ = 0xc0;
    43. 
  
  
  
  43.     break;
    44. 
  
  
  
  44. case ENTRY_SS:
    45. 
  
  
  
  45.     {
    46. 
  
  
  
  46.         uint16_t sel = get_random_segment_selector();
    47. 
  
  
  
  47.  
    48. 
  
  
  
  48.         // movw $imm, %bx
    49. 
  
  
  
  49.         *out++ = 0x66;
    50. 
  
  
  
  50.         *out++ = 0xbb;
    51. 
  
  
  
  51.         *out++ = sel;
    52. 
  
  
  
  52.         *out++ = sel >> 8;
    53. 
  
  
  
  53.     }
    54. 
  
  
  
  54.     break;
    55. 
  
  
  
  55. default:
    56. 
  
  
  
  56.     // do nothing
    57. 
  
  
  
  57.     break;
    58. 
  
  
  
  58. }
    59. 
  
  
  
  59.  
    60. 
  
  
  
  60. ...
    61. 
  
  
  
  61.  
    62. 
  
  
  
  62. switch (type) {
    63. 
  
  
  
  63.     // system calls + software interrupts
    64. 
  
  
  
  64.  
    65. 
  
  
  
  65. case ENTRY_SYSCALL:
    66. 
  
  
  
  66.     // syscall
    67. 
  
  
  
  67.     *out++ = 0x0f;
    68. 
  
  
  
  68.     *out++ = 0x05;
    69. 
  
  
  
  69.     break;
    70. 
  
  
  
  70. case ENTRY_SYSENTER:
    71. 
  
  
  
  71.     // sysenter
    72. 
  
  
  
  72.     *out++ = 0x0f;
    73. 
  
  
  
  73.     *out++ = 0x34;
    74. 
  
  
  
  74.     break;
    75. 
  
  
  
  75. case ENTRY_INT:
    76. 
  
  
  
  76.     // int $x
    77. 
  
  
  
  77.     *out++ = 0xcd;
    78. 
  
  
  
  78.     *out++ = std::uniform_int_distribution
    79. 
  
  
  
  79.     break;
    80. 
  
  
  
  80. case ENTRY_INT_80:
    81. 
  
  
  
  81.     // int $0x80
    82. 
  
  
  
  82.     *out++ = 0xcd;
    83. 
  
  
  
  83.     *out++ = 0x80;
    84. 
  
  
  
  84.     break;
    85. 
  
  
  
  85. case ENTRY_INT3:
    86. 
  
  
  
  86.     // int3
    87. 
  
  
  
  87.     *out++ = 0xcc;
    88. 
  
  
  
  88.     break;
    89. 
  
  
  
  89.  
    90. 
  
  
  
  90.     // exceptions
    91. 
  
  
  
  91.  
    92. 
  
  
  
  92. case ENTRY_DE:
    93. 
  
  
  
  93.     // div %eax
    94. 
  
  
  
  94.     *out++ = 0xf7;
    95. 
  
  
  
  95.     *out++ = 0xf0;
    96. 
  
  
  
  96.     break;
    97. 
  
  
  
  97. case ENTRY_OF:
    98. 
  
  
  
  98.     // into (32-bit only!)
    99. 
  
  
  
  99.     *out++ = 0xce;
    100. 
  
  
  
  100.     break;
    101. 
  
  
  
  101. case ENTRY_BR:
    102. 
  
  
  
  102.     // bound %eax, data
    103. 
  
  
  
  103.     *out++ = 0x62;
    104. 
  
  
  
  104.     *out++ = 0x05;
    105. 
  
  
  
  105.     *out++ = 0x09;
    106. 
  
  
  
  106.     for (unsigned int i = 0; i < 4; ++i)
    107. 
  
  
  
  107.         *out++ = ((uint64_t) &data->bound) >> (8 * i);
    108. 
  
  
  
  108.     break;
    109. 
  
  
  
  109. case ENTRY_UD:
    110. 
  
  
  
  110.     // ud2
    111. 
  
  
  
  111.     *out++ = 0x0f;
    112. 
  
  
  
  112.     *out++ = 0x0b;
    113. 
  
  
  
  113.     break;
    114. 
  
  
  
  114. case ENTRY_SS:
    115. 
  
  
  
  115.     // Load %ss again, with a random segment selector (this is not
    116. 
  
  
  
  116.     // guaranteed to raise #SS, but most likely it will). The reason
    117. 
  
  
  
  117.     // we don't just rely on the load above to do it is that it could
    118. 
  
  
  
  118.     // be interesting to trigger #SS with a "weird" %ss too.
    119. 
  
  
  
  119.  
    120. 
  
  
  
  120.     // movw %bx, %ss
    121. 
  
  
  
  121.     *out++ = 0x8e;
    122. 
  
  
  
  122.     *out++ = 0xd3;
    123. 
  
  
  
  123.     break;
    124. 
  
  
  
  124. case ENTRY_GP:
    125. 
  
  
  
  125.     // wrmsr
    126. 
  
  
  
  126.     *out++ = 0x0f;
    127. 
  
  
  
  127.     *out++ = 0x30;
    128. 
  
  
  
  128.     break;
    129. 
  
  
  
  129. case ENTRY_PF:
    130. 
  
  
  
  130.     // testl %eax, (xxxxxxxx)
    131. 
  
  
  
  131.     *out++ = 0x85;
    132. 
  
  
  
  132.     *out++ = 0x04;
    133. 
  
  
  
  133.     *out++ = 0x25;
    134. 
  
  
  
  134.     for (int i = 0; i < 4; ++i)
    135. 
  
  
  
  135.         *out++ = ((uint64_t) page_not_present) >> (8 * i);
    136. 
  
  
  
  136.     break;
    137. 
  
  
  
  137. case ENTRY_MF:
    138. 
  
  
  
  138.     // divss %xmm0, %xmm0
    139. 
  
  
  
  139.     *out++ = 0xf3;
    140. 
  
  
  
  140.     *out++ = 0x0f;
    141. 
  
  
  
  141.     *out++ = 0x5e;
    142. 
  
  
  
  142.     *out++ = 0xc0;
    143. 
  
  
  
  143.     break;
    144. 
  
  
  
  144. case ENTRY_AC:
    145. 
  
  
  
  145.     // testl %eax, (page_not_writable + 1)
    146. 
  
  
  
  146.     *out++ = 0x85;
    147. 
  
  
  
  147.     *out++ = 0x04;
    148. 
  
  
  
  148.     *out++ = 0x25;
    149. 
  
  
  
  149.     for (int i = 0; i < 4; ++i)
    150. 
  
  
  
  150.         *out++ = ((uint64_t) page_not_writable + 1) >> (8 * i);
    151. 
  
  
  
  151.     break;
    152. 
  
  
  
  152. }
    153.

小结

我们现在几乎拥有了所有的东西，我们需要真正开始进行模糊测试了！不过还有几件事要做……

如果你运行目前的代码，很快就会遇到一些问题。首先，我们使用的许多指令可能会导致崩溃（而且是故意的），这使得fuzzer速度很慢。通过为一些常见的终止信号（SIGBUS、SIGSEGV等）安装信号处理程序，我们可以跳过故障指令，（希望）在同一个子进程内继续执行。

其次，我们进行的一些系统调用可能会产生意想不到的副作用。特别是，我们并不希望在I/O上进行阻塞，因为这将使fuzzer停止运行。一种解决方法是安装一个间隔定时器报警，以检测子进程何时挂起。另一种方法可以是过滤掉某些已知会阻塞的系统调用（如read()、select()、sleep()等）。其他“不幸”的系统调用可能是fork()、exit()和kill()。fuzzer删除文件或以其他方式扰乱系统的可能性较小，但我们仍需要使用某种形式的沙盒（如setuid(65534)）。

如果你只是想看看最终的结果，这里有一个代码的链接：

https://github.com/oracle/linux-blog-sample-code/tree/fuzzing-the-linux-kernel-x86-entry-code

本文翻译自：https://blogs.oracle.com/linux/fuzzing-the-linux-kernel-x86-entry-code%2c-part-2-of-3如若转载，请注明原文地址。

分享文章：Linux内核(x86)入口代码模糊测试指南Part2（下篇）
网址分享：http://www.shufengxianlan.com/qtweb/news10/540010.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

动态网站知识

各行业网站

云服务器　　 　成都logo设计公司　　 　做网站　　 　成都主机托管　　 　网络推广外包　　 　眉山网站建设　　 　成都免费网站建设　　 　格蓝特设备　　 　成都网站建设　　 　蓬溪网站建设　　 　重庆联通机房托管　　 　四川中建建业　　 　梅州网站建设　　 　重庆网站建设　　 　SSL证书　　 　四川國際商會　　 　不锈钢防护栏　　 　自贡托管服务器　　 　成都网站维护　　 　成都包装设计公司