文章目錄

1、脫UPX殼
2、IDA反匯編靜態分析
3、偽隨機陣列
4、第一次錯誤的思路（沒有考慮完整）
5、沒有考慮的sub_41114F函式
6、OD動態分析
7、得到真正的flag
8、繼續的仔細分析（sub_411750函式）
9、關鍵的sub_411900函式
10、正確完整的代碼

首先下載運行ConsoleApplication2.exe：
在這里插入圖片描述

發現是輸入一個字串或者數字，錯誤就輸出“error”.

1、脫UPX殼

然后用PEiD查殼：
在這里插入圖片描述

發現有UPX的殼，再用Upx靜態脫殼機脫殼：
在這里插入圖片描述

2、IDA反匯編靜態分析

接下來用IDA打開脫殼后的ConsoleApplication2.exe，找到main函式：
在這里插入圖片描述

進入main_0()函式查看：
在這里插入圖片描述

main_0()函式的偽代碼是：

__int64 main_0()
{
  int v0; // edx
  __int64 v1; // ST04_8
  char v3; // [esp+0h] [ebp-160h]
  int v4; // [esp+D0h] [ebp-90h]
  int j; // [esp+DCh] [ebp-84h]
  int i; // [esp+E8h] [ebp-78h]
  char Str[104]; // [esp+F4h] [ebp-6Ch]

  srand(0xCu);
  j_memset(&unk_423D80, 0, 0x9C40u);
  for ( i = 1; i <= 20; ++i )
  {
    for ( j = 1; j <= i; ++j )
      dword_41A138[100 * i + j] = rand() % 100000;
  }
  sub_41134D("input your key with your operation can get the maximum:", v3);
  sub_411249("%s", Str);
  if ( j_strlen(Str) == 19 )
  {
    sub_41114F(Str);
    v4 = 0;
    j = 1;
    i = 1;
    dword_423D78 += dword_41A138[101];
    while ( v4 < 19 )
    {
      if ( Str[v4] == 76 )
      {
        dword_423D78 += dword_41A138[100 * ++i + j];
      }
      else
      {
        if ( Str[v4] != 82 )
        {
          sub_41134D("error\n", v3);
          system("pause");
          goto LABEL_18;
        }
        dword_423D78 += dword_41A138[100 * ++i + ++j];
      }
      ++v4;
    }
    sub_41134D("your operation can get %d points\n", dword_423D78);
    system("pause");
  }
  else
  {
    sub_41134D("error\n", v3);
    system("pause");
  }
LABEL_18:
  HIDWORD(v1) = v0;
  LODWORD(v1) = 0;
  return v1;
}

程式的邏輯就是先初始化了一個亂數種子srand(0xCu)，之后生成了一個特定的陣列元素大小在100000以內的偽亂數陣列dword_41A138，之后我們要輸入一個長度為19的字串，然后逐個判斷字串的字符是不是L(76)或者R(82)，不正確就輸出error，最后都正確就輸出“your operation can get %d points”，

3、偽隨機陣列

接下來開始破解，我們首先根據亂數種子srand(0xCu)得到偽亂數陣列dword_41A138：
源代碼：

#include<stdio.h>
#include <stdlib.h>

int main(){
    /// 亂數種子
    srand(0xCu);
    /// 存放亂數的陣列，陣列下標最大有100 * 20 + 20
    int dword_41A138[2100];
    int i , j;
    ///當前陣列下標
    int lab = 0;
    for ( i = 1; i <= 20; ++i ){
        ///%2d:對長度為2以內的數字右對齊
        printf("%2d ", i );
        for ( j = 1; j <= i; ++j ){
            lab = 100 * i + j;
            dword_41A138[lab] = rand() % 100000;
            ///%5d:對長度為5以內的數字右對齊
            printf("%5d ",dword_41A138[lab]);
        }
        printf("\n");
    }
    return 0;
}

運行結果：
在這里插入圖片描述

結合題目Mountain climbing（爬山），所以這個陣列dword_41A138就相當于一座山，而我們輸入19個字符‘L’和‘R’就是爬山的方向，從下面的代碼可以看出：

if ( Str[v4] == 76 )
      {
        dword_423D78 += dword_41A138[100 * ++i + j];
      }
      else
      {
        if ( Str[v4] != 82 )
        {
          sub_41134D("error\n", v3);
          system("pause");
          goto LABEL_18;
        }
        dword_423D78 += dword_41A138[100 * ++i + ++j];
      }

當輸入的字符為L=76時陣列下標100 * ++i表示往下走（例如從77走到5628），當輸入的字符為R=82時陣列下標100 * ++i + ++j表示表示往右下角走（例如從77走到6232），因為輸入的是19個字符，所以不管它是到底是L還是R，最終都會從第一行第一個數77走到第20行，

4、第一次錯誤的思路（沒有考慮完整）

結合最后輸出的“your operation can get %d points”（你的操作可以獲得%d分），我們可以知道這個游戲相當于一個從左上角走到右下角的爬山游戲，走過的路徑的每個位置上的數字加起來就是總得分，
由此我們可以逆推出最大的得分和對應的字串：
源代碼：

#include<stdio.h>
#include <stdlib.h>

int main(){
    /// 亂數種子
    srand(0xCu);
    /// 存放亂數的陣列，陣列下標最大有100 * 20 + 20
    int dword_41A138[2100];
    int i , j;
    ///當前陣列下標
    int lab = 0;
    for ( i = 1; i <= 20; ++i ){
        ///%2d:對長度為2以內的數字右對齊
        printf("%2d ", i );
        for ( j = 1; j <= i; ++j ){
            lab = 100 * i + j;
            dword_41A138[lab] = rand() % 100000;
            ///%5d:對長度為5以內的數字右對齊
            printf("%5d ",dword_41A138[lab]);
        }
        printf("\n");
    }
    ///分數
    int dword_423D78 = 0;
    ///分數的初值默認為第一行的第一個數
    dword_423D78 += dword_41A138[101];
    ///輸入的字串
    char Str[19];
    i = 1 ;
    j = 1 ;
    while(i < 20){
        printf("%d：", i);
        ///右下角的值大于下面的值
        if(dword_41A138[100 * (i + 1) + (j + 1)] > dword_41A138[100 * (i + 1) + j]){
            Str[i-1] = 'R';
            printf("%c  ",Str[i-1]);
            dword_423D78 += dword_41A138[100 * (++i) + (++j)];
        }else{
            Str[i-1] = 'L';
            printf("%c  ",Str[i-1]);
            dword_423D78 += dword_41A138[100 * (++i) + j];
        }
    }
    Str[19] = '\0';
    ///444740
    printf("\n最終的分數是：%d\n", dword_423D78);
    ///RRRRRLLRRRLRLRRRLRL
    printf("輸入的字串為：%s\n", Str);
    system("pause");
    return 0;
}

運行結果：
在這里插入圖片描述

但是把得到的字串輸入到ConsoleApplication2.exe，結果竟然是error：

5、沒有考慮的sub_41114F函式

我們再查看原始碼，發現最開始有個sub_41114F(Str)函式：
在這里插入圖片描述

開始點進去查看以為它是沒有用的，現在逐個點進去查看，這部分的函式呼叫是sub_41114F函式—>sub_411900函式->sub_4110A5函式->sub_411750函式：
sub_41114F函式：
在這里插入圖片描述

sub_411900函式：
在這里插入圖片描述

上面這個函式的引數都是沒法反編譯的，只能查看匯編代碼：
在這里插入圖片描述

繼續查看函式：
sub_4110A5函式：
在這里插入圖片描述

最終進入sub_411750函式：
在這里插入圖片描述

其中VirtualQuery和VirtualProtect都是虛擬記憶體API函式，LPCVOID lpAddress指的就是虛擬記憶體，int a2 應該是用來控制回圈的，int a3的值就是在前面的函式輸入的引數是4，
源代碼：

BOOL __cdecl sub_411750(LPCVOID lpAddress, int a2, int a3)
{
  int v3; // ST1C_4
  DWORD flOldProtect; // [esp+D4h] [ebp-2Ch]
  struct _MEMORY_BASIC_INFORMATION Buffer; // [esp+E0h] [ebp-20h]

  VirtualQuery(lpAddress, &Buffer, 0x1Cu);      // 該函式用來查詢記憶體中指定頁的特性，引數1指向希望查詢的虛擬地址；引數2是指向記憶體基本資訊結構的指標；引數3指定查詢的長度，
  // 該函式用來把已經分配的頁改變成保護頁，引數1指定分配頁的基地址；引數2指定保護頁的長度；引數3指定頁的保護屬性，取值PAGE_READ、PAGE_WRITE、PAGE_READWRITE等等；引數4用來回傳原來的保護屬性，
  VirtualProtect(Buffer.BaseAddress, Buffer.RegionSize, 0x40u, &Buffer.Protect);
  while ( 1 )
  {
    v3 = a2--;                                  // a2控制回圈次數
    if ( !v3 )
      break;
    *(_BYTE *)lpAddress ^= a3;                  // 虛擬地址上的值  異或 4 
    lpAddress = (char *)lpAddress + 1;          // 虛擬地址+1，到下一個
  }
  return VirtualProtect(Buffer.BaseAddress, Buffer.RegionSize, Buffer.Protect, &flOldProtect);
}

還是沒太看明白這個函式對Str字串做了什么操作，所以我們接下來結合OD來對它動態除錯，

6、OD動態分析

用OD打開ConsoleApplication2.exe：
搜索字串，找到題目輸出的字串“input your key with your operation can get the maximum:”：
在這里插入圖片描述

雙擊字串跳轉到它所在的位置
在這里插入圖片描述

ConsoleA.00417B30就是字串input your key with your operation can get the maximum:
在這里插入圖片描述

ConsoleA.0041134D就是輸出函式printf
在這里插入圖片描述

ConsoleA.00417B74就是 %s
在這里插入圖片描述

ConsoleA.00411249就是輸入函式scanf
在這里插入圖片描述

這些我們可以在IDA中得到驗證，
接下來我們在字串input your key with your operation can get the maximum:和輸入函式scanf后面下斷點：
輸入字串：RRRRRRRRRRRRRRRRRRR
在這里插入圖片描述

我們可以看到輸入的(ASCII “RRRRRRRRRRRRRRRRRRR”)，保存在堆疊地址=0019FE98上：
在這里插入圖片描述

我們繼續單步除錯，發現經過：
00411C4F E8 79F4FFFF call ConsoleA.004110CD
這一行，之后EAX = 0x00000013，正好是10進制的19：
在這里插入圖片描述

然后下面的一行：
00411C57 83F8 13 cmp eax,0x13
將eax的值和0x13比較大小，結合之前反編譯出來的原始碼：
if ( j_strlen(Str) == 19 )
我們可以知道ConsoleA.004110CD就是j_strlen函式，
接下來繼續單步運行，因為我們輸入的字串長度是19，所以能夠通過判斷，繼續跳轉運行：
在這里插入圖片描述

之后我們在
00411C8B E8 BFF4FFFF call ConsoleA.0041114F
后面一行下個斷點

在這里插入圖片描述
運行到這一行，我們就可以知道ConsoleA.0041114F函式對Str字串產生了什么影響了：

我們可以看到RRRRRRRRRRRRRRRRRRR經過了ConsoleA.0041114F函式之后變成了RVRVRVRVRVRVRVRVRVR，字串Str的偶數位上的字符都從R變成了V，這就是ConsoleA.0041114F函式的作用，

7、得到真正的flag

我們再重新運行，把輸入改成RRRRRLLRRRLRLRRRLRL：
在這里插入圖片描述

運行到剛剛ConsoleA.0041114F函式之后的斷點位置：
在這里插入圖片描述

我們可以看到RRRRRLLRRRLRLRRRLRL變成了RVRVRHLVRVLVLVRVLVL，就是把字串Str的偶數位置上的R變成V、L變成H，結合之前IDAfan編譯出來的0041114F函式的偽代碼，我們可以知道這應該就是*(_BYTE *)lpAddress ^= a3; // 虛擬地址上的值異或 4
的結果，其中V = R ^ 4 ;H = L ^ 4 ，
其實，到這里我們就已經可以知道正確的輸入字串就是RVRVRHLVRVLVLVRVLVL：
在這里插入圖片描述

即flag為：zsctf{RVRVRHLVRVLVLVRVLVL}，

8、繼續的仔細分析（sub_411750函式）

我們再繼續分析一下最內層的sub_411750函式，可以直接再OD中按快捷鍵Ctrl + G地址跟隨，輸入411750就可以跟隨到sub_411750函式了：
在這里插入圖片描述

接下來我們繼續單步運行，可以看到VirtualQuery和VirtualProtect函式并不會改變Str字串的值：
在這里插入圖片描述

但是，我們發現運行完sub_411750函式這部分的代碼，Str字串的值并沒有改變：
在這里插入圖片描述

也就是我們剛剛分析的由sub_411750函式來改變Str字串的值是錯誤的！！！
可是運行完sub_41114F函式之后Str字串的值是被改變了的，呼叫流程：sub_41114F函式—>sub_411900函式->sub_4110A5函式->sub_411750函式，所以真正改變Str字串的函式，不是sub_411750函式，而是sub_411900函式或者sub_4110A5函式，
繼續單步運行，從sub_411750函式回傳到sub_4110A5函式，發現sub_4110A5函式只是一個簡單的呼叫，不可能改變Str字串的值：
在這里插入圖片描述

9、關鍵的sub_411900函式

接著單步運行，從sub_4110A5函式回傳到sub_411900函式：
在這里插入圖片描述

在回傳sub_411900函式后，
1、先把堆疊 ss:[0019FD54]初始化為0用來控制回圈的跳轉，之后每次回圈加1，當它大于等于19時跳出回圈；
2、然后eax=ss:[0019FD54]大小范圍是0_{18，接著讓eax與1，偶數與1后eax為0，奇數與1后eax為1，這樣就可以區分開0}18中的奇數和偶數；
3、當eax為0、2、……等偶數時，這兩潭訓編
test eax,eax
je short 00411992
會跳過下面的改變字符的代碼，當eax為1、3、……等奇數時，這兩潭訓編不跳轉，繼續運行下面的改變字符的代碼，
4、之后繼續運行，把字串"RVRVRHLVRVLVLVRVLVL"首地址堆疊 ss:[0019FDA0]=0019FE98賦值給eax，之后eax+1獲得第二個字符‘V’的地址，再地址上的‘V’取出來給ecx，之后ecx異或4，把異或后的結果賦值給原來字串的對應位置；
通過這部分的代碼實作了改變字串RVRVRHLVRVLVLVRVLVL到 RRRRRLLRRRLRLRRRLRL的變化，

加上注釋的匯編代碼如下：

00411953    C745 BC 0000000>mov dword ptr ss:[ebp-0x44],0x0   ; 先把堆疊 ss:[0019FD54]初始化為0
0041195A    EB 09           jmp short ConsoleA.00411965       ; 跳轉到411965
0041195C    8B45 BC         mov eax,dword ptr ss:[ebp-0x44]   ;               eax = 堆疊 ss:[0019FD54]
0041195F    83C0 01         add eax,0x1                       ;               eax + 1
00411962    8945 BC         mov dword ptr ss:[ebp-0x44],eax   ;               堆疊 ss:[0019FD54] = eax
00411965    837D BC 13      cmp dword ptr ss:[ebp-0x44],0x13  ; 比較堆疊 ss:[0019FD54]，19
00411969    7D 29           jge short ConsoleA.00411994       ; JGE: 大于或等于轉移指令，跳出回圈
0041196B    8B45 BC         mov eax,dword ptr ss:[ebp-0x44]   ;               eax = 堆疊 ss:[0019FD54]
0041196E    25 01000080     and eax,0x80000001                ; eax與1   ；改變eax的值，偶數與1后eax為0，奇數與1后eax為1
00411973    79 05           jns short ConsoleA.0041197A       ; 如果符號位S為0,就跳轉到41197A  ；SF用來反映運算結果的符號位,它與運算結果的最高位相同
00411975    48              dec eax                           ;            ；上面eax與1的結果是0或者1，最高位始終為0，所以這個跳轉一直成立
00411976    83C8 FE         or eax,-0x2
00411979    40              inc eax
0041197A    85C0            test eax,eax                      ; eax為0時與的結果是0，ZF置1跳轉，為其他數字與的結果都是1
0041197C    74 14           je short ConsoleA.00411992        ; ZF等于1時進行跳轉411992
0041197E    8B45 08         mov eax,dword ptr ss:[ebp+0x8]    ; eax賦值為堆疊 ss:[0019FDA0]=0019FE98,(字串"RVRVRHLVRVLVLVRVLVL"首地址)
00411981    0345 BC         add eax,dword ptr ss:[ebp-0x44]   ; ss:[0019FD54]=00000001、……，eax+1 、……  ；eax的地址為第二個字符的地址19FE99
00411984    0FBE08          movsx ecx,byte ptr ds:[eax]       ; 把eax的當前地址上的值，送給ecx  ；因為上面的eax+1，所以取出來的是第二個字符'V'
00411987    83F1 04         xor ecx,0x4                       ; ecx異或4       ；第二個字符'V'異或4
0041198A    8B55 08         mov edx,dword ptr ss:[ebp+0x8]    ; 把字串首地址ss:[0019FDA0]=0019FE98，賦值給edx
0041198D    0355 BC         add edx,dword ptr ss:[ebp-0x44]   ; edx加上00000001、……    ；獲得當前被改變的那個字符的地址
00411990    880A            mov byte ptr ds:[edx],cl          ; d把異或后的值'R'，賦值給原來字串的對應位置
00411992  ^ EB C8           jmp short ConsoleA.0041195C       ; 跳轉到上面41195C繼續回圈

運行完第2輪回圈，第二個字符‘V’被改成了‘R’：
在這里插入圖片描述

運行完18輪回圈，字串RVRVRHLVRVLVLVRVLVL已經變成了RRRRRLLRRRLRLRRRLRL：
在這里插入圖片描述

到這我們就明白了Str字串被修改的具體原理了，
所以我們只要在源代碼加上Str字串被修改的代碼就可以了：

for(i = 1 ; i < 20 ; i++){
        ///當前i是偶數位
        if(i % 2 == 0){
            Str[i-1] ^= 4;
        }
    }

10、正確完整的代碼

源代碼：

#include<stdio.h>
#include <stdlib.h>

int main(){
    /// 亂數種子
    srand(0xCu);
    /// 存放亂數的陣列，陣列下標最大有100 * 20 + 20
    int dword_41A138[2100];
    int i , j;
    ///當前陣列下標
    int lab = 0;
    for ( i = 1; i <= 20; ++i ){
        ///%2d:對長度為2以內的數字右對齊
        printf("%2d ", i );
        for ( j = 1; j <= i; ++j ){
            lab = 100 * i + j;
            dword_41A138[lab] = rand() % 100000;
            ///%5d:對長度為5以內的數字右對齊
            printf("%5d ",dword_41A138[lab]);
        }
        printf("\n");
    }
    ///分數
    int dword_423D78 = 0;
    ///分數的初值默認為第一行的第一個數
    dword_423D78 += dword_41A138[101];
    ///輸入的字串
    char Str[19];
    i = 1 ;
    j = 1 ;
    while(i < 20){
        printf("%d：", i);
        ///右下角的值大于下面的值
        if(dword_41A138[100 * (i + 1) + (j + 1)] > dword_41A138[100 * (i + 1) + j]){
            Str[i-1] = 'R';
            printf("%c  ",Str[i-1]);
            dword_423D78 += dword_41A138[100 * (++i) + (++j)];
        }else{
            Str[i-1] = 'L';
            printf("%c  ",Str[i-1]);
            dword_423D78 += dword_41A138[100 * (++i) + j];
        }

    }
    Str[19] = '\0';
    ///444740
    printf("\n最終的分數是：%d\n", dword_423D78);
    ///RRRRRLLRRRLRLRRRLRL
    for(i = 1 ; i < 20 ; i++){
        ///當前i是偶數位
        if(i % 2 == 0){
            Str[i-1] ^= 4;
        }
    }
    ///RVRVRHLVRVLVLVRVLVL
    printf("輸入的字串為：%s\n", Str);
    system("pause");
    return 0;
}

運行結果：
在這里插入圖片描述

得到正確的flag：RVRVRHLVRVLVLVRVLVL，

轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/180868.html

標籤：區塊鏈

上一篇：PTA題目：順序表---插入結點

下一篇：開源一款QQ機器人

bugku-逆向-12、Mountain climbing

文章目錄

1、脫UPX殼

2、IDA反匯編靜態分析

3、偽隨機陣列

4、第一次錯誤的思路（沒有考慮完整）

5、沒有考慮的sub_41114F函式

6、OD動態分析

7、得到真正的flag

8、繼續的仔細分析（sub_411750函式）

9、關鍵的sub_411900函式

10、正確完整的代碼