5.12 汇编语言：仿写While循环语句

发表于 2023-07-27 分类于《灰帽黑客：攻守道》

循环语句（While）一种基本控制结构，它允许程序在条件为真的情况下重复执行一段代码块，直到条件为假为止。循环语句在处理需要重复执行的任务时非常有用，它可以让程序更加高效地处理大量数据或者重复性操作。一般来说，While循环由一个条件表达式、一个代码块组成。在每次循环迭代开始时，程序会首先检查条件表达式的值，如果为真，则执行代码块，然后再次检查条件表达式的值。只要条件表达式为真，循环就会一直继续执行；一旦条件表达式为假，循环将停止，程序继续执行循环之后的代码。

循环语句（While）一种基本控制结构，它允许程序在条件为真的情况下重复执行一段代码块，直到条件为假为止。循环语句在处理需要重复执行的任务时非常有用，它可以让程序更加高效地处理大量数据或者重复性操作。

一般来说，While循环由一个条件表达式、一个代码块组成。在每次循环迭代开始时，程序会首先检查条件表达式的值，如果为真，则执行代码块，然后再次检查条件表达式的值。只要条件表达式为真，循环就会一直继续执行；一旦条件表达式为假，循环将停止，程序继续执行循环之后的代码。

12.12 Do-While 循环结构优化

DO语句先执行循环体，后进行判断，如果通过则跳转到循环体首部继续执行，未通过则直接顺序向下走。DO循环效率最高，该循环在结构上非常精简，利用了程序执行时由低到高的特性，由于结构内只在结尾处做了判断，只使用了一条判断语句即实现了循环，因此已经无需在结构上进行任何优化了。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
.code
  main PROC
    mov dword ptr ds:[count],0     ; 初始化循环次数
  S1:
    xor eax,eax                    ; 执行循环体
    mov eax,dword ptr ds:[count]   ; 取出计数器
    add eax,1                      ; 递增
    mov dword ptr ds:[count],eax   ; 回写
    
    cmp dword ptr ds:[count],10    ; 与10做对比
    jl S1                          ; 小于则继续循环

    int 3
    invoke ExitProcess,0
  main ENDP
END main

12.13 While 循环结构优化

While语句先判断循环条件，后执行循环体，由于需要判断，该循环的构建需要使用两个跳转语句方可实现。While循环结构的效率要比Do循环结构低，While循环结构先比较再循环，因此无法利用程序执行顺序来完成循环，又因为While循环结构使用了2个跳转指令，在程序流程上就弱于Do循环。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
.code
  main PROC
    mov dword ptr ds:[count],0            ; 设置while初始化
  S1:
    cmp dword ptr ds:[count],10           ; 设置最大循环数
    jge loop_end                          ; 判断是否循环结束
    
    xor eax,eax                           ; 执行循环体
    
    mov eax,dword ptr ds:[count]           ; 取出循环条件
    add eax,1                              ; 递增
    mov dword ptr ds:[count],eax           ; 写回
    jmp S1
  
  loop_end:
    int 3

    invoke ExitProcess,0
  main ENDP
END main

为了提升While循环执行效率，编译器通常会将其转换为对等的Do循环，如果循环无法转成对等的Do循环，则可使用单层IF结构内部嵌套Do循环的方式来实现，外层IF则用来判断Do循环是否执行，例如如下案例中，首先外层使用IF语句判断循环条件，该语句内部则嵌套一个Do循环，以此来将While转为Do。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
.code
  main PROC
    mov dword ptr ds:[count],0            ; 设置初始条件
    
    ; 初次判断条件是否满足
    cmp dword ptr ds:[count],10
    jge loop_end
  S1:
    ; 循环体内部语句
    xor eax,eax
    
    ; 递增
    add dword ptr ds:[count],1
    
    ; 比较条件是否满足
    cmp dword ptr ds:[count],10
    jl S1
    
  loop_end:
    int 3

    invoke ExitProcess,0
  main ENDP
END main

12.15 Loop 循环结构优化

上方提到过的三种循环模式都是通过跳转指令与计数器构建的，与这三者不同汇编中默认提供了loop指令，专门用来实现循环计数功能，由于是汇编指令，所以此loop语句必须读入ECX寄存器内的次数作为循环终止条件，每次读入会自动递减，具体汇编代码如下。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
  result DWORD ?
  ArrayDW DWORD 8,7,9,4,3,7,5,8,9,3,0h

.code
  main PROC
    ; 通过loop实现的单层循环体
    xor eax,eax                       ; 用于累加数据
    mov ecx,10                        ; 设置循环次数
  s1:
    mov dword ptr ds:[count],ecx      ; 将循环次数备份
    xor ecx,ecx                       ; 清空寄存器
    mov ecx,10
    add eax,ecx                       ; 结果想加到eax
    mov ecx,dword ptr ds:[count]      ; 恢复循环次数
    loop s1
    
    mov dword ptr ds:[result],eax     ; 获取相加后的结果
    
    invoke ExitProcess,0
  main ENDP
END main

如果是双层循环体，则在使用loop语句构建时，必须考虑外层ECX中的循环计数该如何处理，通常会把外层循环计数保存在栈中，这是非常的理想的，保存在一个变量内也勉强凑活，只是效率上没有直接压入栈中高。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
  result DWORD ?
  ArrayDW DWORD 8,7,9,4,3,7,5,8,9,3,0h

.code
  main PROC
    ; 通过loop实现嵌套循环体
    mov ecx,9                   ; 控制外层循环数
  s2:
    push ecx                    ; 保存外层循环数
    mov ecx,9                   ; 设置内层循环数
  s3:
    mov eax,dword ptr ds:[ArrayDW + ecx * 4]
    cmp eax,3                    ; 与3作比较大于则跳
    ja jump
    loop s3
  jump:
    xor eax,eax
    pop ecx
    loop s2
    
    invoke ExitProcess,0
  main ENDP
END main

运用Loop指令实现对数组MyArray的由大到小排序，其中ArraySort子过程用于由大到小排序，子过程PrintArray用于循环输出排序后的结果。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 25,74,89,33,24,67,93,15,78,92
  Count DWORD 10
  PrCount DWORD ?
  szFmt BYTE '%d ',0dh,0ah,0

.code
  ; 数组排序函数
  ArraySort PROC
      mov ecx,dword ptr ds:[Count]      ; 获取到数组元素数
      dec ecx                           ; 数组减1
    L1:
      push ecx                          ; 入栈保存
      lea esi,dword ptr ds:[MyArray]    ; 得到数组基地址
      
    L2:
      mov eax,dword ptr ds:[esi]
      cmp eax,dword ptr ds:[esi + 4]    ; 比较第一个数组与第二个
      jg L3
      
      xchg eax,[esi + 4]                ; 交换数据
      mov [esi],eax
    L3:
      add esi,4
      loop L2
      
      pop ecx                           ; 弹出数据
      loop L1
      ret
  ArraySort ENDP
  
  ; 循环输出元素
  PrintArray PROC
      mov dword ptr ds:[PrCount],0            ; 初始化元素
      
    L1:
      mov ecx,dword ptr ds:[PrCount]          ; 获取循环次数
      cmp ecx,10                              ; 对比十次
      jge lop_end                             ; 判断是否可结束循环
      
      lea eax,dword ptr ds:[MyArray]          ; 获取数组基地址
      mov ebx,dword ptr ds:[eax + ecx * 4]    ; 比例因子寻址
      invoke crt_printf,addr szFmt,ebx
      
      mov ecx,dword ptr ds:[PrCount]          ; 取循环计数
      add ecx,1
      mov dword ptr ds:[PrCount],ecx          ; 递增后回写
      jmp L1
      
    lop_end:
      int 3
      ret

  PrintArray ENDP

  main PROC
    invoke ArraySort
    invoke PrintArray
  main ENDP
END main

12.16 仿写Do-While循环体

这段C++代码定义了一个包含10个元素的整型数组，然后在do-while循环中对数组进行遍历，并检查每一个数组元素是否满足下面的条件：它的值大于10并且下一个数组元素的值小于等于20。如果找到了满足条件的数组元素，则输出它和下一个数组元素的值，并跳出循环。如果循环结束都没有找到符合条件的数组元素，则直接退出程序。这段代码展示了如何使用循环和条件判断对数组进行遍历和筛选。

#include <stdio.h>
#include <Windows.h>

int main(int argc, char *argv[])
{
  int Array[10] = { 56,78,33,45,78,90,32,15,56,67 };
  int index = 0;

  do
  {
    if (Array[index] > 10 && Array[index + 1] <= 20)
    {
      printf("array[1] => %d array[2] => %d \n", Array[index], Array[index + 1]);
      break;
    }

    index = index + 1;
  } while (index < 10);

  system("pause");
  return 0;
}

由于是自己仿写，所以此处我使用了For形式的循环模式，首先初始化count=0进入L1循环后先来判断数组中第一个元素是否小于10，接着通过add eax,1将比例因子向后移动4字节，继续比较第二个数值是否小于等于20，如果都存在则直接输出该结果，并通过jmp lop_end跳转到程序结尾，否则递增count元素，并跳转到循环开头继续查找。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 56,78,33,45,78,90,32,15,56,67
  count DWORD ?
  szFmt BYTE 'array[1] => %d array[2] => %d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[count],0                     ; int index = 0;

  L1:
    mov eax,dword ptr ds:[count]
    cmp dword ptr ds:[MyArray + eax * 4],10        ; Array[index] > 10
    jle L2
    
    mov eax,dword ptr ds:[count]
    add eax,1
    cmp dword ptr ds:[MyArray + eax * 4],20        ; Array[index + 1] <= 20
    jg L2
    
    mov esi,dword ptr ds:[MyArray + eax * 4 - 4]   ; esi = Array[index]
    mov edi,dword ptr ds:[MyArray + eax * 4]       ; edi = Array[index+1]
    invoke crt_printf,addr szFmt,esi,edi
    jmp lop_end                                    ; break

  L2:
    mov eax,dword ptr ds:[count]
    add eax,1                                      ; index = index + 1;
    mov dword ptr ds:[count],eax
    cmp dword ptr ds:[count],10                    ; index < 10
    jl L1

  lop_end:                                           ; break
    int 3
  main ENDP
END main

12.17 仿写While循环体

这段C++代码定义了一个包含10个元素的整型数组，然后在while循环中对数组进行遍历，输出每一个数组元素的值。循环使用一个count变量作为计数器，从0开始逐步增加，直到count的值等于数组元素的总数。在循环内部，它通过count变量访问数组元素，并将它们的值作为参数传递给printf函数进行输出。这段代码展示了如何使用循环结构遍历数组元素。

#include <stdio.h>
#include <Windows.h>

int main(int argc,char *argv[])
{
  int Array[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int count = 0;

  while (count < sizeof(Array) / sizeof(int))
  {
    printf("value = %d \n", Array[count]);
    count = count + 1;
  }
  return 0;
}

首先初始化部分，设置ecx寄存器为比例因子，进入循环体后，通过寻址公式ds:[esi + ecx * 4]实现对数组地址的递增输出，此代码中的ds:[count]只用于控制循环体循环次数，ecx寄存器则只用做寻址因子使用。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 1,2,3,4,5,6,7,8,9,10
  count DWORD ?
  szFmt BYTE 'value = %d ',0dh,0ah,0
.code
  main PROC
    mov dword ptr ds:[count],0                 ; 初始化循环
    mov ecx,0                                  ; 设置循环计数(比例因子)

  S1:
    cmp dword ptr ds:[count],lengthof MyArray  ; 与数组总长度对比
    jge lop_end                                ; 是否结束
    
    lea esi,dword ptr ds:[MyArray]             ; 获取数组基地址
    mov ebx,dword ptr ds:[esi + ecx * 4]       ; 比例因子寻址
    invoke crt_printf,addr szFmt,ebx           ; 调用系统crt
    
    mov ecx,dword ptr ds:[count]
    add ecx,1                                   ; 计次循环递增
    mov dword ptr ds:[count],ecx
    jmp S1

  lop_end:
    int 3
    invoke ExitProcess,0
  main ENDP
END main

12.18 仿写While三层循环体

这段C++代码实现了一个三重循环，用于生成所有由1到4中不重复的三个数字组成的序列。在外层循环中，它使用变量x从1开始逐个增加，直到其值大于等于5。在中间循环中，它使用变量y从1开始逐个增加，直到其值大于等于5。在最内层循环中，它使用变量z从1开始逐个增加，直到其值大于等于5。然后它检查当前的x、y、z变量是否满足三个数不重复的条件，如果满足，则输出这三个数字，并进入第三个循环。循环结构使用变量z逐项增加，并在检查条件后继续下一个序列的生成。当z逐项增加完成后，中间循环使用变量y逐项增加。如此循环，直到所有由1到4的三个数字序列都被产生出来为止。

#include <windows.h>
#include <stdio.h>

int main(int argc,char * argv[])
{
  int x=1, y=1, z=1;

  while (x < 5)
  {
    while (y < 5)
    {
      while (z < 5)
      {
        
        if (x != z && x != y && y != z)
        {
          printf("%d,%d,%d \n", x, y, z);
        }
        z = z + 1;
      }
      z = 1;
      y = y + 1;
    }
    y = 1;
    x = x + 1;
  }
  return 0;
}

由于这段C代码使用了三层While循环，其构建为汇编代码时稍有些难度，我们首先把外层框架构建好，先来构建一个二层While循环结构，如下汇编代码中，我们通过变量x DWORD控制外层循环次数，内层循环次数则使用y DWORD变量来控制，当每次需要修改或读取变量时，则通过mov ecx,dword ptr ds:[x]指令将计数次数读入到ecx寄存器内，以此来保证循环次数不冲突。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  x DWORD ?
  y DWORD ?
  szFmt BYTE '外层循环: %d ---> 内层循环:%d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[x],1           ; x = 1
  
    ; 外层循环
  L1:
    mov ecx,dword ptr ds:[x]
    cmp ecx,5                        ; x < 5
    jge lop_end
    
    ; 内层循环
    mov dword ptr ds:[y],1           ; y = 1
    
  L2:
    mov ecx,dword ptr ds:[y]         ; ecx = y
    cmp ecx,5                        ; y < 5
    jge L3
    
    ; 循环过程执行(存放循环过程代码)
    mov esi,dword ptr ds:[x]
    mov edi,dword ptr ds:[y]
    invoke crt_printf,addr szFmt,esi,edi

    mov ecx,dword ptr ds:[y]
    add ecx,1                        ; y = y + 1
    mov dword ptr ds:[y],ecx
    jmp L2

  L3:
    mov ecx,dword ptr ds:[x]
    add ecx,1                        ; x = x + 1
    mov dword ptr ds:[x],ecx
    jmp L1
  
  lop_end:
    int 3 

  main ENDP
END main

既然二层结构可以被构建出来，那么我们利用这个原理，在二层基础之上增加一个z DWORD变量，用于对最内部的While语句进行计数，由此我们就可以构建出三层While循环结构，汇编代码如下所示，仔细看完全能看懂的。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  x DWORD ?
  y DWORD ?
  z DWORD ?
  szFmt BYTE '外层循环: %d ---> 中间层循环: %d ---> 内层循环: %d  ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[x],1           ; x = 1
  
    ; 外层循环
  L1: mov ecx,dword ptr ds:[x]
    cmp ecx,5                        ; x < 5
    jge lop_end
    
    ; 中间循环
    mov dword ptr ds:[y],1           ; y = 1
  L2: mov ecx,dword ptr ds:[y]         ; ecx = y
    cmp ecx,5                        ; y < 5
    jge L3                           ; 大于跳到最外层

    ; 内层循环
    mov dword ptr ds:[z],1           ; z = 1
    
  L5: mov ecx,dword ptr ds:[z]
    cmp ecx,5                        ; z < 5
    jge L4                           ; 大于跳到中间层
    
    ; 三层循环框架
    mov eax,dword ptr ds:[x]
    mov ebx,dword ptr ds:[y]
    mov ecx,dword ptr ds:[z]
    invoke crt_printf,addr szFmt,eax,ebx,ecx
    
    mov ecx,dword ptr ds:[z]
    add ecx,1                         ; z = z + 1
    mov dword ptr ds:[z],ecx
    
    jmp L5
    
  L4: mov ecx,dword ptr ds:[y]
    add ecx,1                        ; y = y + 1
    mov dword ptr ds:[y],ecx
    jmp L2

  L3: mov ecx,dword ptr ds:[x]
    add ecx,1                        ; x = x + 1
    mov dword ptr ds:[x],ecx
    jmp L1
  
  lop_end:
    int 3 

  main ENDP
END main

最后我们用上方三层结构作为框架使用，在其基础之上增加内部的IF判断功能实现，这样一来我们的三层While嵌套循环体的仿写就实现了，多说一句，在仿写时一定要注意次序跟规律谨慎些，写出来并不难。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  x DWORD ?
  y DWORD ?
  z DWORD ?
  szFmt BYTE '%d,%d,%d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[x],1           ; x = 1
  
    ; 外层循环
  L1: mov ecx,dword ptr ds:[x]
    cmp ecx,5                        ; x < 5
    jge lop_end
    
    ; 中间循环
    mov dword ptr ds:[y],1           ; y = 1
  L2: mov ecx,dword ptr ds:[y]         ; ecx = y
    cmp ecx,5                        ; y < 5
    jge L3                           ; 大于跳到最外层

    ; 内层循环
    mov dword ptr ds:[z],1           ; z = 1
    
  L5: mov ecx,dword ptr ds:[z]
    cmp ecx,5                        ; z < 5
    jge L4                           ; 大于跳到中间层
    
    ; 三层循环框架
    ;mov eax,dword ptr ds:[x]
    ;mov ebx,dword ptr ds:[y]
    ;mov ecx,dword ptr ds:[z]
    ;invoke crt_printf,addr szFmt,eax,ebx,ecx
    
    ; 开始在框架中搞事情
    mov eax,dword ptr ds:[x]
    cmp eax,dword ptr ds:[z]
    je L6
    mov eax,dword ptr ds:[x]
    cmp eax,dword ptr ds:[y]
    je L6
    mov eax,dword ptr ds:[y]
    cmp eax,dword ptr ds:[z]
    je L6
    
    invoke crt_printf,addr szFmt,dword ptr ds:[x],dword ptr ds:[y],dword ptr ds:[z]
    
  L6: mov ecx,dword ptr ds:[z]
    add ecx,1                         ; z = z + 1
    mov dword ptr ds:[z],ecx
    
    jmp L5
    
  L4: mov ecx,dword ptr ds:[y]
    add ecx,1                        ; y = y + 1
    mov dword ptr ds:[y],ecx
    jmp L2

  L3: mov ecx,dword ptr ds:[x]
    add ecx,1                        ; x = x + 1
    mov dword ptr ds:[x],ecx
    jmp L1
  
  lop_end:
    int 3 

  main ENDP
END main

12.19 仿写While实现二分法

该C++代码实现了一个二分查找算法，用于在已排序的数组中查找指定值的位置。代码中定义了一个BinSearch函数，通过对传入数组进行二分查找，最终返回要查找的值在数组中的索引值。main函数调用了BinSearch函数，在已知数组中查找指定值并输出其在数组中的索引。

#include <windows.h>
#include <stdio.h>

int BinSearch(int value[], const int SearchVal, int Count)
{
  int first = 0;
  int last = Count - 1;

  while (first <= last)
  {
    int mid = (last + first) / 2;      // 取中位数
    if (value[mid] < SearchVal)        // 中位数小于searchVal
    {                                  // 说明元素在后面
      first = mid + 1;
    }
    else if (value[mid] > SearchVal)
    {                                  // 否则说明元素在前
      last = mid - 1;
    }
    else
    { // 找到后返回中位数
      return mid;
    }
  }
  return -1;
}

int main(int argc, char *argv[])
{
  // 二分查找法,必须针对的是有序数组
  int Array[10] = { 1,2,3,4,5,6,7,8,9,10 };

  // 查找数组Array中索引7所在的下标
  int ret = BinSearch(Array, 7, 10);
  printf("数组下标: %d \n", ret);

  system("pause");
  return 0;
}

接着是尝试使用汇编实现这个查找逻辑，这段代码你一定可以看懂，细心些就好，我写的时候也思考了很长时间才写出来的。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 1,2,3,4,5,6,7,8,9,10
  
  SearchVal DWORD 7
  Count DWORD 10
  
  first DWORD ?
  last DWORD ?
  mid DWORD ?
  szFmt BYTE '%d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[first],0         ; first = 0;
    mov edi,dword ptr ds:[SearchVal]   ; 得到要查找的数
    lea ebx,dword ptr ds:[MyArray]     ; 得到数组基地址

    ; int last = Count - 1;
    mov eax,dword ptr ds:[Count]
    sub eax,1
    mov dword ptr ds:[last],eax
    
    ; while(first <=last)
  L1: mov ecx,dword ptr ds:[first]
    cmp ecx,dword ptr ds:[last]
    jg lop_end
    
    ; int mid = (last + first) / 2;
    mov eax,dword ptr ds:[last]
    add eax,dword ptr ds:[first]
    shr eax,1
    mov dword ptr ds:[mid],eax
    
    ; edx = value[mid]
    mov esi,dword ptr ds:[mid]
    shl esi,2
    mov edx,[ebx + esi]
    ;invoke crt_printf,addr szFmt,edx

    ; if(edx < SearchVal(edi))
    cmp edx,edi
    jge L2
    ; first = mid + 1;
    mov eax,dword ptr ds:[mid]
    add eax,1
    mov dword ptr ds:[first],eax
    jmp L1
  L2:
    ; else if (value[mid] > searchVal)
    cmp edx,edi
    jle L3
    ; last = mid - 1;
    mov eax,dword ptr ds:[mid]
    sub eax,1
    mov dword ptr ds:[last],eax
    jmp L1
  
  L3: ; else
    mov eax,dword ptr ds:[mid]
    invoke crt_printf,addr szFmt,eax
    jmp lop_end
    jmp L1
  lop_end:
    mov eax,-1
    int 3

  main ENDP
END main