ds:[eax*4+0x557960] 的意思是0x557960处是一个数组，这个数组每个元素大小是4，eax是数组下标。

要观察EAX的值每次是否都为固定
ReadProcessMemory地址eax*4+0x557960和地址0x55792C
如果[eax*4+0x557960]不等于0则执行地址[eax*4+0x557960]处的汇编代码
如果等于0则执行地址[0x55792C]处的代码

delphi好像是可以内嵌汇编的。

[QUOTE=弥迦;1413848]ds:[eax*4+0x557960] 的意思是0x557960处是一个数组，这个数组每个元素大小是4，eax是数组下标。[/QUOTE]

这段代码shellcode咋写

[QUOTE=千千万;1413849]要观察EAX的值每次是否都为固定
ReadProcessMemory地址eax*4+0x557960和地址0x55792C
如果[eax*4+0x557960]不等于0则执行地址[eax*4+0x557960]处的汇编代码
如果等于0则执行地址[0x55792C]处的代码[/QUOTE]

shellcode咋写这段代码。

shellcode用内联汇编写吧。，没写过delphi的，你需要去查下delphi怎么内联汇编，把你贴的汇编放进去就好了。eax的值应该是一样的。

内联汇编用的还是挺多的，lz自己动手丰衣足食吧

内联汇编照抄即可

ds:[eax*4+0x557960],这个地址是动态的，注入dll里的地址
ds:[eax*4+0x557960],这个动态的地址怎么用汇编定位到

eax值不一样，ds:[eax*4+0x557960],动态的，注入dll里的地址
ds:[eax*4+0x557960],这个动态的地址怎么用汇编定位到

eax值不一样，ds:[eax*4+0x557960],动态的，注入dll里的地址
ds:[eax*4+0x557960],这个动态的地址怎么用汇编定位到

求救感谢

用delphi写只需加asm end
asm
pushad
pushfd
cmp dword ptr ds:[eax*4+$557960],$0
je short $75253538
popfd
popad
add esp,$4
jmp dword ptr ds:[eax*4+$557960]
  popfd
  popad
  jmp dword ptr ds:[$55792C]
end;

[QUOTE=sabason;1414117]用delphi写只需加asm end
asm
pushad
pushfd
cmp dword ptr ds:[eax*4+$557960],$0
je short $75253538
popfd
popad
add esp,$4
jmp dword ptr ds:[...[/QUOTE]

问题是这个$557960地址是动态的，是我注入DLL里的地址，怎么动态地位一下，感谢感谢

求教感谢

RVA + 基址

再详细一点行吗，感谢

求教求教

你要先找这个地址，动态的还要往上，一直找到调用他的基址，就是不变的地址
你自己用的时候要从基址反推再赋值给他
         +20H       +30H
比如a    ->     b     ->你这个动态地址
a是基址不变的，不会的话用CE找他吧

然后你写的就是 a+20h+30h 只是个意思，20h,30h可能是存在哪个寄存器里的值，你看CE的反跟踪会告诉你
比如 a+ebi  定位到b
b再加一个什么定位到 你这个地址

function add(x, y: Integer): Integer;
      var count: Integer;
      begin
      asm
      MOV EAX, x      {把 x 值放入寄存器 EAX}
      MOV ECX, y      {把 y 值放入寄存器 ECX}
      ADD EAX, ECX    {把 EAX + ECX 的值放入 EAX}
      MOV count, EAX  {把 EAX 的值给变量 count}
      end;
      Result := count; {返回值}
      //asm 中每个语句换行即可分句, 无须 ; 在这里加上也没有问题}
      end;

      procedure TForm1.Button1Click(Sender: TObject);
      var i: Integer;
      begin
      i := add(2, 8); // EPrivilege with message Privileged instruction
      Memo1.Lines.Add(format('%d', [i]));
      end;

      procedure Proc(w, x, y, z:integer);
      var a, b, c, d, e, f, g: Integer;
      begin
      asm
      mov a, eax
      mov b, ebx
      mov c, ecx
      mov d, edx
      end;
      Form1.Memo1.Lines.Add(format('%d   %d   %d   %d',[a, b, c, d]));
      end;

      function Proc2(w, x, y, z: Integer): Integer;
      var a, b, c, d, e, f, g: Integer;
      begin
      asm
      mov a, eax
      mov b, ebx
      mov c, ecx
      mov d, edx
      end;
      //Form1.Memo1.Lines.Add(format('%d   %d   %d   %d',[a, b, c, d])); // 如果加上此句注释则返回值为 0 ，不加此句则为 11
      end;

      procedure TForm1.Button3Click(Sender: TObject);
      var i: Integer;
      begin
      Proc(11, 22, 33, 44);
      // 前三个参数通过寄存器传递, 其他参数存于栈.
      // EAX 先接受第一个参数再接受返回值, EBX ECX 接受后面两个参数.
      // 0   0   33   22
      i := Proc2(11, 22, 33, 44);
      Memo1.Lines.Add(format('%d', [i])); // 11
      end;

      procedure TForm1.Button4Click(Sender: TObject);
      var i: Integer;   // 4 字节、32 位
      w: Word;      // 2 字节、16 位
      b1, b2: Byte; // 1 字节、 4 位
      begin
      {
      EAX 32 位
      --------------------------------
      |               |     AX 16 位  |
      ----------------
      |AH 8 位|AL 8 位|
      }
      i  := maxint;
      w  := 0;
      b1 := 0;
      b2 := 0;
      asm
      mov eax, i  // EAX 寄存器 返回类型 Integer、LongWord、AnsiString、Pointer、Class
      mov w, ax   // AX 寄存器 返回类型 SmallInt、Word
      mov b1, ah
      mov b2, al  // AL 寄存器 返回类型 Char、Byte
      end;
      Form1.Memo1.Lines.Add(Format('w=%d   b1=%d   b2=%d',[w, b1, b2]));
      // w=65535; b1=255; b2=255 给 ecx 赋值后, cx ch cl 都有值了!

      i  := 8;
      w  := 0;
      b1 := 0;
      b2 := 0;
      asm
      mov ebx, i
      mov w, bx
      mov b1, bh
      mov b2, bl
      end;
      Form1.Memo1.Lines.Add(Format('w=%d   b1=%d   b2=%d',[w, b1, b2]));
      // w=8   b1=0   b2=8

      i  := 60000;
      w  := 0;
      b1 := 0;
      b2 := 0;
      asm
      mov edx, i
      mov w, dx
      mov b1, dh
      mov b2, dl
      end;
      Form1.Memo1.Lines.Add(Format('w=%d   b1=%d   b2=%d',[w, b1, b2]));
      // w=60000   b1=234   b2=96
      end;

      function AsmFun(x: Integer): Integer;
      asm
      add eax, eax // 相当于 Result := x * 2;
      // eax 可以获取第一个参数, 同时又是函数的返回值, 所以可以如此简洁!}
      end;

      procedure TForm1.Button5Click(Sender: TObject);
      var i: Integer;
      begin
      i := AsmFun(8);
      Memo1.Lines.Add(format('%d', [i])); // 16
      end;

      function Fun(x: Integer): Integer;
      asm
      mov ecx, &x       // 在汇编中访问 Delphi 的变量 x 可以使用 & 操作符
      dec ecx           // 汇编中的 dec 是减 1 指令, 和 Delphi 是一样的}
      mov @Result, ecx  // 在本例中去掉 @ 也可以, 暂时不知怎么回事
      end;

      procedure TForm1.Button6Click(Sender: TObject);
      var i: Integer;
      begin
      i := Fun(9);
      Memo1.Lines.Add(format('%d', [i])); // 8
      end;

      function Fun2(var x,y: Integer): Integer;
      asm
      mov eax, x         {现在 eax 中只是 x 的地址}
      mov eax, [eax]     { [eax] 是取值, 是不是类似于 P^ ? }
      mov edx, y
      add eax, [edx]
      //mov @Result, eax {在这里, 这句可有可无}
      end;

      procedure TForm1.Button7Click(Sender: TObject);
      var a, b: Integer;
      begin
      a := 1;
      b := 8;
      a := Fun2(a, b);
      Memo1.Lines.Add(IntToStr(a)); {9}
      end;

      // 常量可以在汇编语句中运算
      function Fun3: Integer;
      const
      a = 11;
      b = 5;
      asm
      mov eax, a - b
      end;

      //变量不可以, 方法中的参数也都属于变量

      function Fun4: Integer;
      var x, y: Integer;
      asm
      mov x, 11
      mov y, 5
      //mov eax, x-y {不能这样使用}
      mov eax, x
      sub eax, y     {sub 是减, 就像 add 是加一样}
      end;

      procedure TForm1.Button8Click(Sender: TObject);
      var i: Integer;
      begin
      i := Fun3;
      Memo1.Lines.Add(format('%d', [i])); // 6
      i := Fun4;
      Memo1.Lines.Add(format('%d', [i])); // 6
      end;

      // 使用应该保护的 ebx 寄存器
      function Fun5(x: Integer): Integer;
      {
      前面提到 32 位的寄存器有: EAX EBX ECX EDX ESP EBP ESI EDI;
      其中, EAX ECX EDX 是自由使用的.
      那么剩下的 EBX ESP EBP ESI EDI 五个寄存器就是应该保护的!
      所谓保护, 并不是不可以使用,
      而是在使用前先把其中的值寄存在另外一个地方, 用完后再恢复其值.
      如果不这样做, 有可能会发生意想不到的错误.
      }
      asm
      push ebx // push 是入栈指令, 栈就是系统自动分配的内存
      mov  ebx, x
      inc  ebx
      mov  @Result, ebx
      pop  ebx // pop 是出栈指令, 也就是恢复 ebx 寄存器原来的值
      end;

      procedure TForm1.Button9Click(Sender: TObject);
      var i: Integer;
      begin
      i := Fun5(8);
      Memo1.Lines.Add(format('%d', [i])); // 9
      end;

      //十进制
      function Fun6: Integer;
      asm
      mov eax, 255
      end;

      //十进制数后面也可以加个 D(大小写无关)
      function Fun7: Integer;
      asm
      mov eax, 255D
      end;

      //二进制后面加 B(大小写无关)
      function Fun8: Integer;
      asm
      mov eax, 11111111B
      end;

      //八进制后面加 O(大小写无关)
      function Fun9: Integer;
      asm
      mov eax, 377O
      end;

      //十六进制前面加 $
      function Fun10: Integer;
      asm
      mov eax, $FF
      end;

      //十六进制也可以是后面加 H(大小写无关)
      function Fun11: Integer;
      asm
      mov eax, 0FFH {使用这种方法, 数字的首位不能是字母, 不然会被认为成标识符}
      end;

      //非汇编代码的 Delphi 只支持用 $ 表示十六进制
      function Fun12: Integer;
      begin
      Result := $FF;
      end;

      procedure TForm1.Button10Click(Sender: TObject);
      begin
      with Memo1.Lines do
      begin
      Add(format('%d', [Fun6])); // 255
      Add(format('%d', [Fun7])); // 255
      Add(format('%d', [Fun8])); // 255
      Add(format('%d', [Fun9])); // 255
      Add(format('%d', [Fun10])); // 255
      Add(format('%d', [Fun11])); // 255
      Add(format('%d', [Fun12])); // 255
      end;
      end;

      procedure TForm1.Button11Click(Sender: TObject);
      var ByteNum: Byte;
      begin
      { 逻辑非 Not:
      not 1 = 0;
      not 0 = 1;
      }
      //赋值 11111111B (255) 取反:
      asm
      mov al, 11111111B {eax 包含 ax; ax 包含 al; al 是 eax 的低八位}
      not al            {给 11111111 取反会得到 00000000}
      mov ByteNum, al   {把寄存器 al 中的值给变量 ByteNum}
      end;
      Memo1.Lines.Add(IntToStr(ByteNum)); {0}

      {  逻辑或 Or:
      1 or 0 = 1;
      0 or 1 = 1;
      1 or 1 = 1;  // 逻辑异或 1 Xor 1 = 0;
      0 or 0 = 0;
      }
      asm
      mov al, 10101010B {170}
      mov cl, 01010101B {85}
      or  al, cl
      mov ByteNum, al
      end;
      Memo1.Lines.Add(IntToStr(ByteNum)); {255}

      {  逻辑与 And:
      1 and 1 = 1;
      1 and 0 = 0;
      0 and 1 = 0;
      0 and 0 = 0;
      }
      asm
      mov al, 11111111B {255}
      mov cl, 11111111B {255}
      and al, cl
      mov ByteNum, al
      end;
      Memo1.Lines.Add(IntToStr(ByteNum)); {255}

      { 逻辑异或 Xor:
      1 Xor 0 = 1;
      0 Xor 1 = 1;
      1 Xor 1 = 0;  // 常用来置 0 , 与逻辑或不同:   1 or 1 = 1;
      0 Xor 0 = 0;
      }

      asm
      mov al, 11111111B {255}
      mov cl, 11111111B {255}
      xor al, cl
      mov ByteNum, al
      end;
      Memo1.Lines.Add(IntToStr(ByteNum)); {0}
      end;

      procedure TForm1.Button12Click(Sender: TObject);
      var ByteNum: Byte;
      begin
      //右移 shr
      asm
      mov al, 10000000B {128}
      shr al, 1         {shr 10000000 一次会得到 01000000}
      mov ByteNum, al
      end;
      Memo1.Lines.Add(IntToStr(ByteNum)); {64; shr 相当于 ÷2}

      //左移 shl
      asm
      mov al, 00000001B {1}
      shl al, 1            {shl 一次会得到 00000010}
      shl al, 1            {shl 两次会得到 00000100}
      mov ByteNum, al
      end;
      Memo1.Lines.Add(IntToStr(ByteNum)); {4; shl 相当于 ×2}
      end;

      procedure TForm1.Button13Click(Sender: TObject);
      var B: Byte;
      W: Word;
      C: Cardinal;
      begin
      {Byte 是1字节(8位)无符号整型, 其最大值是 111111112}
      asm
      mov B, 11111111B;
      end;
      Memo1.Lines.Add(IntToStr(B)); {255}

      {Word 是2字节(16位)无符号整型, 其最大值是 11111111 111111112}
      asm
      mov W, 1111111111111111B;
      end;
      Memo1.Lines.Add(IntToStr(W)); {65535}

      {Cardinal 是4字节(32位)无符号整型, 其最大值是 11111111 11111111 11111111 111111112}
      asm
      mov C, 11111111111111111111111111111111B;
      end;
      Memo1.Lines.Add(IntToStr(C)); {4294967295}

      {它们的最小值都是 0}
      end;

      procedure TForm1.Button14Click(Sender: TObject);
      var I: Integer;
      begin
      // Integer 类型是4字节(32位)有符号整数, 最高位是符号位, 如果是正数, 符号位是 0、负数的符号位是1
      // 所以 Integer 的最大值是: 01111111 11111111 11111111 111111112
      asm
      mov I, 01111111111111111111111111111111B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {2147483647}

      //有符号整数的负数等于相同正数的反码 + 1; Integer 最大值是:
      //01111111 11111111 11111111 111111112; 其反码是:
      //10000000 00000000 00000000 000000002; 反码 + 1 以后是:
      //10000000 00000000 00000000 000000012
      asm
      mov I, 10000000000000000000000000000001B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {-2147483647}

      //那 Integer 的最小值是多少呢?
      //应该是: 10000000 00000000 00000000 000000002
      asm
      mov I, 10000000000000000000000000000000B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {-2147483648}

      //11111111 11111111 11111111 111111112 是?
      asm
      mov I, 11111111111111111111111111111111B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {-1}

      //Integer 类型的 0 在内存中是: 00000000 00000000 00000000 000000002
      asm
      mov I, 00000000000000000000000000000000B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {0}

      //Integer 类型的 10010 的二进制是: 00000000 00000000 00000000 011001002
      asm
      mov I, 00000000000000000000000001100100B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {100}

      //算 Integer 类型的 -10010:
      //00000000 00000000 00000000 01100100 的反码是:
      //11111111 11111111 11111111 10011011 ; 反码 + 1 以后是:
      //11111111 11111111 11111111 10011100
      asm
      mov I, 11111111111111111111111110011100B;
      end;
      Memo1.Lines.Add(IntToStr(I));           {-100}
      end;

希望有用

内联就可以了

75253520    60              pushad
75253521    9C              pushfd
75253522    833C85 60795500>cmp dword ptr ds:[eax*4+0x557960],0x0
7525352A    74 0C           je short wow64cpu.75253538
7525352C    9D              popfd
7525352D    61              popad
7525352E    83C4 04         add esp,0x4
75253531    FF2485 60795500 jmp dword ptr ds:[eax*4+0x557960]
75253538    9D              popfd
75253539    61              popad
7525353A  ^ FF25 2C795500   jmp dword ptr ds:[0x55792C]       ; //75252329

这是HOOK Zw函数的
比如hook NtDeviceIoControlFile
1FE7960是起始地址 NtDeviceIoControlFile索引号是4，那么4*4+0x1FE7960，这个地址存放的是hook自己构建的函数地址
上边这段用代码怎么写，帮我写下谢谢

arr[索引] := dword(@hookfunction);