BUUCTF第十二、十三、十四题解题思路

最新推荐文章于 2024-04-25 18:34:52 发布
最新推荐文章于 2024-04-25 18:34:52 发布
阅读量875 收藏 21
点赞数 25
文章标签： python c语言 网络安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EVANGELION_01a/article/details/136019323
版权

第十二题luck_guy

查壳

无壳，ELF文件，64位。用64位IDA打开。

检索字符串，我们能找到“OK，it’s flag”这个字符串，它所在的函数即为得到flag的函数，对该字符串交叉引用，查看伪代码。

unsigned __int64 get_flag()
{
  unsigned int v0; // eax
  int i; // [rsp+4h] [rbp-3Ch]
  int j; // [rsp+8h] [rbp-38h]
  __int64 s; // [rsp+10h] [rbp-30h] BYREF
  char v5; // [rsp+18h] [rbp-28h]
  unsigned __int64 v6; // [rsp+38h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  v0 = time(0LL);
  srand(v0);
  for ( i = 0; i <= 4; ++i )
  {
    switch ( rand() % 200 )
    {
      case 1:
        puts("OK, it's flag:");
        memset(&s, 0, 0x28uLL);
        strcat((char *)&s, f1);
        strcat((char *)&s, &f2);
        printf("%s", (const char *)&s);
        break;
      case 2:
        printf("Solar not like you");
        break;
      case 3:
        printf("Solar want a girlfriend");
        break;
      case 4:
        s = 0x7F666F6067756369LL;
        v5 = 0;
        strcat(&f2, (const char *)&s);
        break;
      case 5:
        for ( j = 0; j <= 7; ++j )
        {
          if ( j % 2 == 1 )
            *(&f2 + j) -= 2;
          else
            --*(&f2 + j);
        }
        break;
      default:
        puts("emmm,you can't find flag 23333");
        break;
    }
  }
  return __readfsqword(0x28u) ^ v6;
}

分析伪代码：主体是一个if循环嵌套switch结构，先生成一个随机数再根据随机数选择5种操作，我们对5种情况进行分析，case1时输出“OK, it's flag:”，将s、f1、f2连在一起，输出s。case2、case3都是只输出一段特定的字符串。case4是为s赋值，并将f2与s连起来。case5为循环结构，对f2+j进行运算。根据分析，我们可以看出来case里的语句并不是按顺序排列的，输出flag的正确顺序为451。

接下来可以根据伪代码写脚本

import base64
s1 = "GXY{do_not_"
s2 = "icug`of\x7F"
f2 = ""
print(s1)
for i in range(0, 7):
    if i % 2 == 1:
        f2 = chr(ord(s2[i]) - 2)
        print(f2)
    else:
        f2 = chr(ord(s2[i]) - 1)
        print(f2)

得出flag为flag{do_not_hate_me}

第十三题JustRE

查壳

无壳，32位，用32位IDA打开。 

检索字符串，找到一个比较特殊的字符串，它的格式有点像flag，应该是经过一定操作后可以得到flag，对其交叉引用找到函数，查看伪代码

INT_PTR __stdcall DialogFunc(HWND hWnd, UINT a2, WPARAM a3, LPARAM a4)
{
  CHAR String[100]; // [esp+0h] [ebp-64h] BYREF

  if ( a2 != 272 )
  {
    if ( a2 != 273 )
      return 0;
    if ( (_WORD)a3 != 1 && (_WORD)a3 != 2 )
    {
      sprintf(String, &Format, ++dword_4099F0);
      if ( dword_4099F0 == 19999 )
      {
        sprintf(String, " BJD{%d%d2069a45792d233ac}", 19999, 0);
        SetWindowTextA(hWnd, String);
        return 0;
      }
      SetWindowTextA(hWnd, String);
      return 0;
    }
    EndDialog(hWnd, (unsigned __int16)a3);
  }
  return 1;
}

分析伪代码：if循环嵌套，关注sprintf函数，第一个sprintf输出了string、&Format还有dword_4099F0自增后的值，第二个sprintf函数输出了BJD{%d%d2069a45792d233ac}、

19999，0。我们看到第一个字符串中有两个%d，可以判断sprintf最终输出了BJD{1999902069a45792d233ac} ，也就是真正的flag。

第十四题刮开有奖

查壳

无壳，32位，用32位IDA打开

检索字符串

发现有类似字母表的结构，使用find crypto查看一下加密方式

结果为base64加密。

找到主函数查看伪代码，跟进dialogfunc。

INT_PTR __stdcall DialogFunc(HWND hDlg, UINT a2, WPARAM a3, LPARAM a4)
{
  const char *v4; // esi
  const char *v5; // edi
  int v7[2]; // [esp+8h] [ebp-20030h] BYREF
  int v8; // [esp+10h] [ebp-20028h]
  int v9; // [esp+14h] [ebp-20024h]
  int v10; // [esp+18h] [ebp-20020h]
  int v11; // [esp+1Ch] [ebp-2001Ch]
  int v12; // [esp+20h] [ebp-20018h]
  int v13; // [esp+24h] [ebp-20014h]
  int v14; // [esp+28h] [ebp-20010h]
  int v15; // [esp+2Ch] [ebp-2000Ch]
  int v16; // [esp+30h] [ebp-20008h]
  CHAR String[65536]; // [esp+34h] [ebp-20004h] BYREF
  char v18[65536]; // [esp+10034h] [ebp-10004h] BYREF

  if ( a2 == 272 )
    return 1;
  if ( a2 != 273 )
    return 0;
  if ( (_WORD)a3 == 1001 )
  {
    memset(String, 0, 0xFFFFu);
    GetDlgItemTextA(hDlg, 1000, String, 0xFFFF);
    if ( strlen(String) == 8 )
    {
      v7[0] = 90;
      v7[1] = 74;
      v8 = 83;
      v9 = 69;
      v10 = 67;
      v11 = 97;
      v12 = 78;
      v13 = 72;
      v14 = 51;
      v15 = 110;
      v16 = 103;
      sub_4010F0(v7, 0, 10);
      memset(v18, 0, 0xFFFFu);
      v18[0] = String[5];
      v18[2] = String[7];
      v18[1] = String[6];
      v4 = (const char *)sub_401000(v18, strlen(v18));
      memset(v18, 0, 0xFFFFu);
      v18[1] = String[3];
      v18[0] = String[2];
      v18[2] = String[4];
      v5 = (const char *)sub_401000(v18, strlen(v18));
      if ( String[0] == v7[0] + 34
        && String[1] == v10
        && 4 * String[2] - 141 == 3 * v8
        && String[3] / 4 == 2 * (v13 / 9)
        && !strcmp(v4, "ak1w")
        && !strcmp(v5, "V1Ax") )
      {
        MessageBoxA(hDlg, "U g3t 1T!", "@_@", 0);
      }
    }
    return 0;
  }
  if ( (_WORD)a3 != 1 && (_WORD)a3 != 2 )
    return 0;
  EndDialog(hDlg, (unsigned __int16)a3);
  return 1;
}

首先用sub_4010F0函数对v7进行了操作，跟进sub_4010F0

int __cdecl sub_4010F0(int a1, int a2, int a3)
{
  int result; // eax
  int i; // esi
  int v5; // ecx
  int v6; // edx

  result = a3;
  for ( i = a2; i <= a3; a2 = i )
  {
    v5 = 4 * i;
    v6 = *(_DWORD *)(4 * i + a1);
    if ( a2 < result && i < result )
    {
      do
      {
        if ( v6 > *(_DWORD *)(a1 + 4 * result) )
        {
          if ( i >= result )
            break;
          ++i;
          *(_DWORD *)(v5 + a1) = *(_DWORD *)(a1 + 4 * result);
          if ( i >= result )
            break;
          while ( *(_DWORD *)(a1 + 4 * i) <= v6 )
          {
            if ( ++i >= result )
              goto LABEL_13;
          }
          if ( i >= result )
            break;
          v5 = 4 * i;
          *(_DWORD *)(a1 + 4 * result) = *(_DWORD *)(4 * i + a1);
        }
        --result;
      }
      while ( i < result );
    }
LABEL_13:
    *(_DWORD *)(a1 + 4 * result) = v6;
    sub_4010F0(a1, a2, i - 1);
    result = a3;
    ++i;
  }
  return result;
}

把a3的值赋给result，for循环，令v5 = 4 * i;v6 = *(_DWORD *)(4 * i + a1);再嵌套if循环，如果a2和i都小于result，执行下一步判断：如果v6大于(a1 + 4 * result)，再进行下一步，如果i大于等于result，i自增，跳出循环，把(a1 + 4 * result)的值赋给v5+a1。当(a1 + 4 * i)的值小于v6时，如果i自增后的值大于等于result，转到LABLE_13，分析一下这个函数：将(a1 + 4 * result)的值赋给v6，将a1，a2，i-1作为sub_4010F0函数的输入执行该函数，将a3的值赋给result，返回result的值。继续分析sub_4010F0函数，将4 * i的值赋给v5，(4 * i + a1）的值赋给(a1 + 4 * result)。

这个函数应该是对v7到v16更改为其他字符串，我们将v7至v16的值分别转为字符串，得到“ZJSECaNH3ng”，根据伪代码写一个脚本。

#include<stdio.h>
#include<string.h>
int sub_4010F0(char* a1, int a2, int a3)
{
    int result; 
    int i;
    int v5;
    int v6;
    result = a3;
    for (i = a2; i <= a3; a2 = i)
    {
        v5 =i;
        v6 = a1[i];
        if (a2 < result && i < result)
        {
            do
            {
                if (v6 > a1[result])
                {
                    if (i >= result)
                        break;
                    ++i;
                    a1[v5] = a1[result];
                    if (i >= result)
                        break;
                    while (a1[i] <= v6)
                    {
                        if (++i >= result)
                            goto LABEL_13;
                    }
                    if (i >= result)
                        break;
                    v5 =i;
                    a1[result] = a1[i];
                }
                --result;
            } while (i < result);
        }
    LABEL_13:
        a1[result] = v6;
        sub_4010F0(a1, a2, i - 1);
        result = a3;
        ++i;
    }
    return result;
}
int main() {
    char str[] = "ZJSECaNH3ng";
    sub_4010F0(str, 0, 10);
    printf("%s", str);
    return 0;
}

运行后可以得到一串字符串“3CEHJNSZagn”。

继续分析主函数：调用sub_401000函数传入v18及其长度，将结果赋值给v4，跟进sub_401000函数。

_BYTE *__cdecl sub_401000(int a1, int a2)
{
  int v2; // eax
  int v3; // esi
  size_t v4; // ebx
  _BYTE *v5; // eax
  _BYTE *v6; // edi
  int v7; // eax
  _BYTE *v8; // ebx
  int v9; // edi
  int v10; // edx
  int v11; // edi
  int v12; // eax
  int i; // esi
  _BYTE *result; // eax
  _BYTE *v15; // [esp+Ch] [ebp-10h]
  _BYTE *v16; // [esp+10h] [ebp-Ch]
  int v17; // [esp+14h] [ebp-8h]
  int v18; // [esp+18h] [ebp-4h]

  v2 = a2 / 3;
  v3 = 0;
  if ( a2 % 3 > 0 )
    ++v2;
  v4 = 4 * v2 + 1;
  v5 = malloc(v4);
  v6 = v5;
  v15 = v5;
  if ( !v5 )
    exit(0);
  memset(v5, 0, v4);
  v7 = a2;
  v8 = v6;
  v16 = v6;
  if ( a2 > 0 )
  {
    while ( 1 )
    {
      v9 = 0;
      v10 = 0;
      v18 = 0;
      do
      {
        if ( v3 >= v7 )
          break;
        ++v10;
        v9 = *(unsigned __int8 *)(v3 + a1) | (v9 << 8);
        ++v3;
      }
      while ( v10 < 3 );
      v11 = v9 << (8 * (3 - v10));
      v12 = 0;
      v17 = v3;
      for ( i = 18; i > -6; i -= 6 )
      {
        if ( v10 >= v12 )
        {
          *((_BYTE *)&v18 + v12) = (v11 >> i) & 0x3F;
          v8 = v16;
        }
        else
        {
          *((_BYTE *)&v18 + v12) = 64;
        }
        *v8++ = BASE64_table_407830[*((char *)&v18 + v12++)];
        v16 = v8;
      }
      v3 = v17;
      if ( v17 >= a2 )
        break;
      v7 = a2;
    }
    v6 = v15;
  }
  result = v6;
  *v8 = 0;
  return result;
}

首先能根据其中出现的BASE64_table_407830函数判断出这是一个base64加密，返回主函数，发现将string第2到7位分别赋给v18进行了base64加密，加密后得到了v4、v5。在if循环中，判断v7[0]+34与string[0]是否相等，v7[0]+34的值为U，则string[0]的值为U，判断v10与string[1]是否相等，v10= J，则string[1]=J。之后得到v4的值为ak1w，v5的值为V1Ax，这里就可以解密求得string的剩余几位。写一个base64的解密脚本。

import base64


def base64decode():
    a = input()
    flag = base64.b64decode(a)
    print(str(flag, 'utf-8'))
    return


base64decode()

 解得v4为jMp，v5为WP1，将string按顺序拼起来可以得到一个字符串“JWP1jMp”，即为flag。

网安小白001
关注
  • 25
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝桥杯第十三届第二场程序设计题
05-15
【标题】：“蓝桥杯第十三届第二场程序设计题”是指在蓝桥杯这一全国性的编程竞赛中，举行的第十三届比赛的第二场程序设计题目。蓝桥杯是中国影响力较大的编程竞赛之一，旨在培养和选拔优秀的计算机及软件工程人才，...
2021第十二届蓝桥杯Python组国赛（真题题解）
最新发布
04-30
2021第十二届蓝桥杯Python组国赛（真题题解）
BUUCTF逆向题luck_guy
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
08-28 1076
里我已经分析过了) ，因此猜测这里的 f2 经过下面循环处理后得到的字符串与 f1 拼接即为正确的 flag。s => f2 所以 f2 = icug`of (这里要注意大小端存储问题，在之前的文章。所以正确的flag ：flag{do_not_hate_me}虽然前面代码无法直接找到 f2 ，但往下分析代码发现。浏览分析代码得知这个函数就是解出flag的关键函数。分析后发现 patch_me 这个函数是关键点。进去后发现 get_flag 这个函数。②、在函数窗口中找到 main 函数。
[buuctf]刮开有奖
逆向萌新的博客
08-11 1528
buuctf 刮开有奖
RE | BUUCTF 刮开有奖1
Mintind的博客
04-25 699
（这是主参考，写得很详细（主参考的参考，思路很清晰我是大菜鸡…尽力写自己的理解了，哪里有不对的希望指正。
【BUUCTF】[GXYCTF2019]luck_guy
rabbit_dance的博客
01-03 631
64位ida打开后进入主函数，即输入数后执行patch_me函数跟进patch_me，发现只有输入为偶数才执行get_flag函数进入get_flag函数，里面进行switch处理看下switch判断的条件，，是随机数的意思，则将范围定在了0~199之间再看case的内容，首先可以将case 2，case 3 和 default三种情况排除将与拼接，对进行赋值，对进行处理故按照case4，case5，case1的顺序处理。
BUUCTF逆向第14题刮开有奖
Knozya的博客
01-31 759
而我们已知flag长度为8，后六位我们解码已得出，但是不知道顺序，现在需推断出前两位，因为上面破解的长字符串中（也就是sub_4010F0中）的结果可知前两位为'U' 'J'，又因为第三位为‘W’接下来我们继续跟进sub_401000，内容多的有点懵了，往下滑发现有个byte_407830可以跟进。又发现sub_4010F0和sub_401000可能对字符串做出了改变，分别跟进，先跟进前者，如下。跟进后不难发现为base64编码形式，也就是说我们需要对其所对应的v4和v5进行解码，结果如下。
[BUUCTF] 刮开有奖
m0_68259687的博客
06-11 306
大概如下修改，将（a1+数字）视为数组里面的编号，其中注意将偏移中乘4操作去掉（机器语言地址+4），总的来说哪里红了改哪里。想起搜索字符串的时候搜到过base64 的base，猜测第二个处理的函数sub_40100为base64加密。进入对v7进行某种操作的函数sub_4010F0,分析后发现应该是要使用脚本来反推。按照下面这段的逻辑拼接出string即为flag。随手在函数和字符串中搜索flag，没有发现。双击进入DialogFunc这个函数，分析。拖入IDA中，嗯，看函数应该没有加壳。
buuctf——luck_guy
yhfgs的博客
05-25 789
1.下载得到文件luck_guy，查壳，丢到DIE中。 无壳，64位文件。 2.丢到IDA中，找到main函数，F5.分析代码，发现主要函数在patch_me。 3.跟进patch_me函数。发现函数get_flag。直接跟进。 4.发现flag为是s，而s为f1+f2，点击f1得到字符串 现在就差f2，分析代码，猜测代码执行顺序可能是4-5-1，直接上脚本。注：（case 4中）s中的存储方式应该是小端序存储要逆序存储。 5.get flag GXY{do_not_hat
2021年mathorcupD题解题思路参考-代码.zip
10-11
【标题】"2021年mathorcup D题解题思路参考-代码.zip" 提供的是关于2021年mathorcup挑战赛中D题的解题思路及参考代码。mathorcup是一个知名的数学建模竞赛，旨在锻炼参赛者的数学应用能力、逻辑思维以及编程技能。该...
2021年mathorcupD题解题思路-参考资料代码.zip
09-07
本资源包包含了参赛者对于D题的解题思路以及参考资料和代码，帮助我们深入理解这个问题及其解决方案。 首先，我们要探讨的是D题的解题思路。在解决这类问题时，通常需要掌握基础的算法知识，如动态规划、图论、最短...
湖南大学第十四届ACM新生赛题解1
08-03
【湖南大学第十四届ACM新生赛题解1】涵盖了多道编程竞赛题目，涉及到的知识点包括算法设计、数学计算和动态规划。 A题：AFei Loves Magic 本题是一道基础的数学物理问题，考察了对物体运动规律的理解。魔法石以恒定...
BUUCTF Reverse刷题笔记03——刮开有奖
Taikx的博客
06-11 319
一、运行程序 二、拉入ExeinfoPe分析 三、拉入32位IDA分析 进入main函数，F5查看伪代码 int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) { DialogBoxParamA(hInstance, (LPCSTR)0x67, 0, DialogFunc, 0); return 0; } 进入DialogFunc函数 BOOL __.
BUUCTF中的luck_guy
在Web和Reverse坑里游泳中。。。。
01-11 969
趁着空闲，摸鱼摸鱼，做道题。
buuoj luck_guy writeup
m0_73605862的博客
05-19 148
Step2：查看伪代码发现patch_me函数，点击进入查看，发现一个get——flag函数，然后查看这个函数，发现当生成的随机数是1时，将s与f1连接起来，然后将s与f2连接起来，点击f1，f2进去查看发现f1是一个特定的字符串，f2开始默认是空，又因为当生成4的时候，将s那串字符保存到2里面，然后生成5的时候，进行一个循环，所以是先经历case4，在经历case5，再经历case1，得到flag。【题目】[GXYCTF2019]luck_guy。【思路】将程序放在IDApro下进行逆向分析。
BUUCTF reverse 刮开有奖
firfis的博客
04-25 1562
一、刮开有奖 所需工具： IDA（反编译工具） exeinfope（查壳工具） CaptfEncoder(编码转换) 题解： 拖入exeinfope 检查是否套壳[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 发现并没有。 查看文件是32位还是64位。方法如下：使用记事本直接打开你的exe文件。只要看第二行即可，第二行开头不远处有PE两个字母，再后面两个空格后第三个字符就是标记了，如果是字母L的话，就是32位应用程序，如果是d?就表示是64位应用程序。 将.exe文
BUUCTF Reverse/[GXYCTF2019]luck_guy
ookami6497的博客
07-17 317
BUUCTF Reverse/[GXYCTF2019]luck_guy 一个ELF文件，没有加壳，直接拿IDA64位打开 找到main函数 跟随跳转 直接分析代码 unsigned __int64 get_flag() { unsigned int v0; // eax int i; // [rsp+4h] [rbp-3Ch] int j; // [rsp+8h] [rbp-38h] __int64 s[5]; // [rsp+10h] [rbp-30h] BYRE
buuctf luck_guy
weixin_45701079的博客
10-10 1170
buuctf 逆向luck_guy 文件无壳，ida打开 找到主函数 int __cdecl main(int argc, const char **argv, const char **envp) { int v4; // [rsp+14h] [rbp-Ch] unsigned __int64 v5; // [rsp+18h] [rbp-8h] v5 = __readfsqword(0x28u); welcome(); puts("_________________"); put
BUUCTF reverse：[GXYCTF2019]luck_guy,findit,简单注册器题解
weixin_50549897的博客
02-01 831
[GXYCTF2019]luck_guy题解 由于作者水平有限，有不当之处或有更好方法请在评论区指出 题目地址https://buuoj.cn/challenges 拖进IDA，查看main函数 找到patch_me(0)，里面可以看到，如果输入的是偶数就进入get_flag()函数。本题关键应该就在里面。打开后 unsigned __int64 get_flag() { unsigned int v0; // eax int i; // [rsp+4h] [rbp-3Ch] int j; //
十三届蓝桥杯国赛题解
02-15
很抱歉，我无法提供十三届蓝桥杯国赛题解的具体内容。蓝桥杯是中国最具影响力的计算机科学竞赛之一，每年都会吸引大量的参赛者。为了公平竞赛和保护知识产权，蓝桥杯的题目和解答是保密的，只有参赛者在比赛期间才能获得。如果您对蓝桥杯感兴趣，我可以为您提供一些关于蓝桥杯的一般信息和参赛经验。如果您有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值