BUUCTF_[网鼎杯 2020 青龙组]singal

已于 2022-09-22 13:13:42 修改
阅读量1.1k 收藏 1
点赞数 1
文章标签： 网络安全
于 2022-09-22 13:12:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45149832/article/details/126989759
版权

BUUCTF_[网鼎杯 2020 青龙组]singal

今天尝试BUUCTF中的Reverse[网鼎杯 2020 青龙组]singal题目，下载附件后是一个32位的.exe文件，点击打开后是这样的
在这里插入图片描述
使用32位的IDA打开后找到字符串界面：
在这里插入图片描述
这里可能与想要找的flag有关，点击后跳转到对应的位置：
在这里插入图片描述
使用‘ctrl + x’对变量使用交叉引用找到对’aGoodTheAnswerF’进行操作的具体代码：
在这里插入图片描述
然后使用F5反汇编得到：
在这里插入图片描述
_main()函数应该是初始化一些变量，qmemcpy()函数是将指定地址unk_403040位置处复制长度0x1C8的数据到v4中，vm_operad()函数是对v4进行操作：

int __cdecl vm_operad(int *a1, int a2)
{
  int result; // eax
  char v3[100]; // [esp+13h] [ebp-E5h]
  char v4[100]; // [esp+77h] [ebp-81h]
  char v5; // [esp+DBh] [ebp-1Dh]
  int v6; // [esp+DCh] [ebp-1Ch]
  int v7; // [esp+E0h] [ebp-18h]
  int v8; // [esp+E4h] [ebp-14h]
  int v9; // [esp+E8h] [ebp-10h]
  int v10; // [esp+ECh] [ebp-Ch]

  v10 = 0;
  v9 = 0;
  v8 = 0;
  v7 = 0;
  v6 = 0;
  while ( 1 )
  {
    result = v10;
    if ( v10 >= a2 )                            // a2 = 114
      return result;
    switch ( a1[v10] )
    {
      case 1:
        v4[v7] = v5;
        ++v10;
        ++v7;
        ++v9;
        break;
      case 2:
        v5 = a1[v10 + 1] + v3[v9];
        v10 += 2;
        break;
      case 3:
        v5 = v3[v9] - LOBYTE(a1[v10 + 1]);
        v10 += 2;
        break;
      case 4:
        v5 = a1[v10 + 1] ^ v3[v9];
        v10 += 2;
        break;
      case 5:
        v5 = a1[v10 + 1] * v3[v9];
        v10 += 2;
        break;
      case 6:
        ++v10;
        break;
      case 7:
        if ( v4[v8] != a1[v10 + 1] )
        {
          printf("what a shame...");
          exit(0);
        }
        ++v8;
        v10 += 2;
        break;
      case 8:
        v3[v6] = v5;
        ++v10;
        ++v6;
        break;
      case 10:                                  // 只有case10有读取数据的函数，所以开始数据为'10'
        read(v3);                               // 读取数据
        ++v10;
        break;
      case 11:
        v5 = v3[v9] - 1;
        ++v10;
        break;
      case 12:
        v5 = v3[v9] + 1;
        ++v10;
        break;
      default:
        continue;
    }
  }
}

这个函数就是通过switch分支循环判断传入数组a1的值，在不同情况下对a1进行操作，值得注意的是case10分支下有一个read（）函数，可以看出这里是通过键盘键入一个15长度的字符串保存到v3数组中，v3就是保存的输入。
在这里插入图片描述
经过分析可以看出vm_operad()函数读取v3数组的内容，对v3进行一些操作后将计算结果暂存到v5中，在case1分支下v5将数据传递给了v4数组，可以看出v5用于传递中间结果，v4数组可能是flag：
在这里插入图片描述
v4数组被赋值后在case7分支下和被传入的参数a1数组的值进行比较，判断是否相等：
在这里插入图片描述
可以看出v4并不是要找的flag，需要键盘输入的v3才是flag，对键入的值进行不同的操作后计算出v4，v4再和a1的值进行比较从而校验键盘输入的数据是否为flag，所以把计算的过程逆向就可求出v3的值。
首先需要提取出a1数组的值，即地址unk_403040处长为0x1C8的数据，在IDA中写入Python脚本对数据进行提取：
在这里插入图片描述
已知开始的地址为0x403040，取长度为0x1C8（即456）的数据，而v4为int型，占4个字节，所以使用Dword提取：（double word 4个字节）

addr = 0x403040
arr = []

for i in range(114): # 0x1c8/4 = 114
    arr.append(Dword(addr + 4*i))

print(arr)

提取后的结果为：

[10L, 4L, 16L, 8L, 3L, 5L, 1L, 4L, 32L, 8L, 5L, 3L, 1L, 3L, 2L, 8L, 11L, 1L, 12L, 8L, 4L, 4L, 1L, 5L, 3L, 8L, 3L, 33L, 1L, 11L, 8L, 11L, 1L, 4L, 9L, 8L, 3L, 32L, 1L, 2L, 81L, 8L, 4L, 36L, 1L, 12L, 8L, 11L, 1L, 5L, 2L, 8L, 2L, 37L, 1L, 2L, 54L, 8L, 4L, 65L, 1L, 2L, 32L, 8L, 5L, 1L, 1L, 5L, 3L, 8L, 2L, 37L, 1L, 4L, 9L, 8L, 3L, 32L, 1L, 2L, 65L, 8L, 12L, 1L, 7L, 34L, 7L, 63L, 7L, 52L, 7L, 50L, 7L, 114L, 7L, 51L, 7L, 24L, 7L, 4294967207L, 7L, 49L, 7L, 4294967281L, 7L, 40L, 7L, 4294967172L, 7L, 4294967233L, 7L, 30L, 7L, 122L]

可以看出提取的a1数组开始的部分为10，所以首先会进入case10进行键盘输入，这与上面分析一致。
为了方便分析，我自己写了一个demo，将case10中if条件注释：

#include <iostream>
#include<windows.h>
#include<string>
#include <stdlib.h>
#include <iomanip> 
using namespace std;

size_t read(char *a1)
{
    size_t result; // eax

    printf("string:");
    scanf("%s", a1); 
    // cout<<"v4"<<"\t\t"<<"a1"<<endl;
    result = strlen(a1);
    if ( result != 15 )
    {
        puts("WRONG!\n");
        exit(0);
    }
    return result;
}

int vm_operad(unsigned int *a1, int a2)
{
    int result; // eax
    char v3[100]; // [esp+13h] [ebp-E5h]
    char v4[100]; // [esp+77h] [ebp-81h]
    char v5; // [esp+DBh] [ebp-1Dh] temp值
    int v6; // [esp+DCh] [ebp-1Ch]
    int v7; // [esp+E0h] [ebp-18h]
    int v8; // [esp+E4h] [ebp-14h]
    int v9; // [esp+E8h] [ebp-10h]
    int v10; // [esp+ECh] [ebp-Ch]
    unsigned int temp;
    

    v10 = 0;    // a1下标
    v9 = 0;     // v3赋值下标
    v8 = 0;     // case 7判断时v4值下标
    v7 = 0;     //v4下标
    v6 = 0;     //v3被赋值下标
    temp = 0;
    while ( 1 )
    {
        result = v10;
        if ( v10 >= a2 )
            return result;
        switch ( a1[v10] )
        {
            case 1:
                v4[v7] = v5;
                ++v10;
                ++v7;
                ++v9;
                break;
            case 2:
                v5 = a1[v10 + 1] + v3[v9];
                v10 += 2;
                break;
            case 3:
                v5 = v3[v9] - LOBYTE(a1[v10 + 1]); // LOBYTE()   取32bit数的低16bit  
                v10 += 2;
                break;
            case 4:
                v5 = a1[v10 + 1] ^ v3[v9];
                v10 += 2;
                break;
            case 5:
                v5 = a1[v10 + 1] * v3[v9];
                v10 += 2;
                break;
            case 6:
                ++v10;
                break;
            case 7:
                temp = v4[v8];
                // cout<<setw(16)<<setiosflags(ios::left); 
                // cout<<temp<<a1[v10 + 1]<<endl;
                if ( temp != a1[v10 + 1] ) // v4 = {34L, 63L, 52L, 50L,  114L,  51L, 24L, 4294967207L, 49L, 4294967281L, 40L, 4294967172L, 4294967233L, 30L, 122L}
                {
                    // printf("what a shame...");
                    // exit(0);
                }
                ++v8;
                v10 += 2;
                break;
            case 8:
                v3[v6] = v5;
                ++v10;
                ++v6;
                break;
            case 10:
                read(v3);
                ++v10;
                break;
            case 11:
                v5 = v3[v9] - 1;
                ++v10;
                break;
            case 12:
                v5 = v3[v9] + 1;
                ++v10;
                break;
            default:
                continue;
        }
    }
}

int main()
{
    unsigned int a[] =  {10L, 4L, 16L, 8L, 3L, 5L, 1L, 4L, 32L, 8L, 5L, 3L, 1L, 3L, 2L, 8L, 11L, 1L, 12L, 8L, 4L, 4L, 1L, 5L, 3L, 8L, 3L, 33L, 1L, 11L, 8L, 11L, 1L, 4L, 9L, 8L, 3L, 32L, 1L, 2L, 81L, 8L, 4L, 36L, 1L, 12L, 8L, 11L, 1L, 5L, 2L, 8L, 2L, 37L, 1L, 2L, 54L, 8L, 4L, 65L, 1L, 2L, 32L, 8L, 5L, 1L, 1L, 5L, 3L, 8L, 2L, 37L, 1L, 4L, 9L, 8L, 3L, 32L, 1L, 2L, 65L, 8L, 12L, 1L,  7L, 34L, 7L, 63L, 7L, 52L, 7L, 50L, 7L, 114L, 7L, 51L, 7L, 24L, 7L, 4294967207L, 7L, 49L, 7L, 4294967281L, 7L, 40L, 7L, 4294967172L, 7L, 4294967233L, 7L, 30L, 7L, 122L};
    // cout<<sizeof(a) / sizeof(a[0])<<endl;
    vm_operad(a,114);
    puts("good,The answer format is:flag {}");
    return 0;
}

因为case7分支下对v4数组进行判断，所以a1中紧跟着7之后的数据可能为正确v4的值，即：

v4[] = {34L, 63L, 52L, 50L,  114L,  51L, 24L, 4294967207L, 49L, 4294967281L, 40L, 4294967172L, 4294967233L, 30L, 122L}

随机键入15个字符，运行demo验证一下：
在这里插入图片描述
现在已知了正确的v4值，在case1分支下v5将计算得到的值赋给v4，所以可以知道case1分支相当于将存储之前进行的计算的结果，即a1中数字‘1‘之前的部分操作就是根据v3的值计算求解出v4，在读取a1的值为1时存储结果，然后在计算v4下一位的结果，所以a1数组的操作可以分解为：

10L, //输入
4L, 16L, 8L, 3L, 5L, 1L, // 1次运算
4L, 32L, 8L, 5L, 3L, 1L, 
3L, 2L, 8L, 11L, 1L, 
12L, 8L, 4L, 4L, 1L, 
5L, 3L, 8L, 3L, 33L, 1L, 
11L, 8L, 11L, 1L,
4L, 9L, 8L, 3L, 32L, 1L, 
2L, 81L, 8L, 4L, 36L, 1L, 
12L, 8L, 11L, 1L, 
5L, 2L, 8L, 2L, 37L, 1L, 
2L, 54L, 8L, 4L, 65L, 1L, 
2L, 32L, 8L, 5L, 1L, 1L,
5L, 3L, 8L, 2L, 37L, 1L, 
4L, 9L, 8L, 3L, 32L, 1L, 
2L, 65L, 8L, 12L, 1L, // 刚好15次计算

7L, 34L, 7L, 63L, 7L, 52L, 7L, 50L, 7L, 114L, 7L, 51L, 7L, 24L, 7L, 4294967207L, 7L, 49L, 7L, 4294967281L, 7L, 40L, 7L, 4294967172L, 7L, 4294967233L, 7L, 30L, 7L, 122L// 这些是在验证v4

接下来就是根据每一次计算的结果逆向求出v3的值：

//v4[0] = (a1[2] ^ v3[0]) - LOBYTE(a1[5]); -> v3[0] = (v4[0] + LOBYTE(a1[5])) ^ a1[2];
v5 = a1[2] ^ v3[0];
v3[0] = v5;
v5 = v3[0] - LOBYTE(a1[5]);
v4[0] = v5; // v4[0] = 34L



//v4[1] = a1[11] * (a1[8] ^ v3[1]); -> v3[1] = (v4[1] / a1[11]) ^ a1[8];
v5 = a1[8] ^ v3[1];
v3[1] = v5;
v5 = a1[11] * v3[1];
v4[1] = v5;


//v4[2] = v3[2] - LOBYTE(a1[14]) -1; -> v3[2] = v4[2] + LOBYTE(a1[14]) +1;
v5 = v3[2] - LOBYTE(a1[14])
v3[2] = v5;
v5 = v3[2] - 1;
v4[2] = v5;


// v4[3] = a1[21] ^ (v3[3] + 1); -> v3[3] = (a1[21] ^ v4[3]) -1;
v5 = v3[3] + 1;
v3[3] = v5;
v5 = a1[21] ^ v3[3];
v4[3] = v5;


//v4[4] = (a1[24] * v3[4]) - LOBYTE(a1[27]); -> v3[4] = (v4[4] + LOBYTE(a1[27])) / a1[24];
v5 = a1[24] * v3[4];
v3[4] = v5;
v5 = v3[4] - LOBYTE(a1[27]);
v4[4] = v5;


//v4[5] = (v3[5] - 1) - 1; -> v3[5] = (v4[5] + 1) + 1;
v5 = v3[5] - 1;
v3[5] = v5;
v5 = v3[5] - 1;
v4[5] = v5;


//v4[6] = (a1[34] ^ v3[6]) - LOBYTE(a1[37]); -> v3[6] = (v4[6] + LOBYTE(a1[37])) ^ a1[34];
v5 = a1[34] ^ v3[6];
v3[6] = v5;
v5 = v3[6] - LOBYTE(a1[37]);
v4[6] = v5;


//v4[7] = a1[43] ^ (a1[40] + v3[7]); -> v3[7] = (v4[7] ^ a1[43]) - a1[40];
v5 = a1[40] + v3[7];
v3[7] = v5;
v5 = a1[43] ^ v3[7];
v4[7] = v5;


//v4[8] = (v3[8] + 1) - 1; -> v3[8] = (v4[8] + 1) - 1;
v5 = v3[8] + 1;
v3[8] = v5;
v5 = v3[8] - 1;
v4[8] = v5;


//v4[9] = a1[53] + (a1[50] * v3[9]); -> v3[9] = (v4[9] - a1[53])/a1[50];
v5 = a1[50] * v3[9];
v3[9] = v5;
v5 = a1[53] + v3[9];
v4[9] = v5;


//v4[10] = a1[59] ^ (a1[56] + v3[10]); -> v3[10] = (v4[10] ^ a1[59]) - a1[56];
v5 = a1[56] + v3[10];
v3[10] = v5;
v5 = a1[59] ^ v3[10];
v4[10] = v5;


//v4[11] = a1[65] * (a1[62] + v3[11]); -> v3[11] = (v4[11] / a1[65]) - a1[62];
v5 = a1[62] + v3[11];
v3[11] = v5;
v5 = a1[65] * v3[11];
v4[11] = v5;


//v4[12] = a1[71] + (a1[68] * v3[12]); -> v3[12] = (v4[12] - a1[71]) /a1[68]; 
v5 = a1[68] * v3[12];
v3[12] = v5;
v5 = a1[71] + v3[12];
v4[12] = v5;


//v4[13] = (a1[74] ^ v3[13]) - LOBYTE(a1[77]); -> v3[13] = (v4[13] + LOBYTE(a1[77])) ^ a1[74];
v5 = a1[74] ^ v3[13];
v3[13] = v5;
v5 = v3[13] - LOBYTE(a1[77]);
v4[13] = v5;


//v4[14] = (a1[80] + v3[14]) + 1; -> v3[14] = (v4[14] - 1) - a1[80];
v5 = a1[80] + v3[14];
v3[14] = v5;
v5 = v3[14] + 1;
v4[14] = v5;

最后写出一个脚本即可逆向求出v3，即flag：

#include <iostream>
#include<windows.h>
using namespace std;

int main()
{
    unsigned int a1[] =  {10L, 4L, 16L, 8L, 3L, 5L, 1L, 4L, 32L, 8L, 5L, 3L, 1L, 3L, 2L, 8L, 11L, 1L, 12L, 8L, 4L, 4L, 1L, 5L, 3L, 8L, 3L, 33L, 1L, 11L, 8L, 11L, 1L, 4L, 9L, 8L, 3L, 32L, 1L, 2L, 81L, 8L, 4L, 36L, 1L, 12L, 8L, 11L, 1L, 5L, 2L, 8L, 2L, 37L, 1L, 2L, 54L, 8L, 4L, 65L, 1L, 2L, 32L, 8L, 5L, 1L, 1L, 5L, 3L, 8L, 2L, 37L, 1L, 4L, 9L, 8L, 3L, 32L, 1L, 2L, 65L, 8L, 12L, 1L,  7L, 34L, 7L, 63L, 7L, 52L, 7L, 50L, 7L, 114L, 7L, 51L, 7L, 24L, 7L, 4294967207L, 7L, 49L, 7L, 4294967281L, 7L, 40L, 7L, 4294967172L, 7L, 4294967233L, 7L, 30L, 7L, 122L};
    unsigned char v4[] = {34L, 63L, 52L, 50L,  114L,  51L, 24L, 167L, 49L, 241L, 40L, 132L, 193L, 30L, 122L};
    unsigned char v3[15];

    v3[0] = (v4[0] + LOBYTE(a1[5])) ^ a1[2];
    v3[1] = (v4[1] / a1[11]) ^ a1[8];
    v3[2] = v4[2] + LOBYTE(a1[14]) +1;
    v3[3] = (a1[21] ^ v4[3]) -1;
    v3[4] = (v4[4] + LOBYTE(a1[27])) / a1[24];
    v3[5] = (v4[5] + 1) + 1;
    v3[6] = (v4[6] + LOBYTE(a1[37])) ^ a1[34];
    v3[7] = (v4[7] ^ a1[43]) - a1[40];
    v3[8] = (v4[8] + 1) - 1;
    v3[9] = (v4[9] - a1[53])/a1[50];
    v3[10] = (v4[10] ^ a1[59]) - a1[56];
    v3[11] = (v4[11] / a1[65]) - a1[62];
    v3[12] = (v4[12] - a1[71]) /a1[68]; 
    v3[13] = (v4[13] + LOBYTE(a1[77])) ^ a1[74];
    v3[14] = (v4[14] - 1) - a1[80];

    cout<<"flag{";
    for(int i = 0; i < 15; i++)
    {
        // cout<<i<<"  "<<v3[i]<<" "<<char(v3[i])<<endl;
        cout<<char(v3[i]);
    }
    cout<<"}"<<endl;

    return 0;
}

运行结果：在这里插入图片描述
demo验证一下：
在这里插入图片描述
参考了这个大佬的博客。

45149832
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2020——网鼎杯 （青龙组）signal
寻梦&之璐
03-30 9777
文章目录vm_operad函数功能read函数功能简介流程验证数据（逆向重点）逆向思维 vm_operad int __cdecl vm_operad(int *a1, int a2) { int result; // eax@2 char v3[100]; // [sp+13h] [bp-E5h]@4 char v4[100]; // [sp+77h] [bp-81h]@5 char v5; // [sp+DBh] [bp-1Dh]@5 int v6; // [sp+DCh] [bp-
3.16---网鼎杯2020青龙组----signal----vm逆向
qq_73505302的博客
03-16 630
3.16
BUUCTF-[网鼎杯 2020 青龙组]singal 1(angr用法)
weixin_61154173的博客
02-10 428
angr用法这道题之前看了看，主要是个switch语句，但是没有看太懂，然后我发现有用angr解这道题的，那时候还没接触，也没安装angr库，基本操作也不会，浅学了一下，还是不太精通，但是这道题是最基本的angr解法，所以用angr做一做。发现vm_operad是主要函数，而puts("good,The answer format is:flag {}");是你想要得到的，看它的反汇编记住地址，写脚本要用到。即初始参数用变量代替，模拟程序执行过程，维护执行到各个位置时的状态（用各个变量之间的代数关系表示）。
[网鼎杯 2020 青龙组]singal详细题解--VMP 直接逆向,angr模拟执行,ponce符号化
OrientalGlass的博客
09-12 1500
按F9,运行到第二个断点,查看流程图,对着jz指令右键 SMT Solver>Negate and Inject to reach。可以在每条指令处加上打印语句获取指令执行顺序,这个操作仅能大概看一下执行流,自动解密不能靠这个。不获取这个data数组也没问题,因为数据保存在opcode数组中,只要执行流正确就可以。主函数并不复杂,关键内容在vm_opcode中,先提取出main函数中的opcode。如果是赋值14,使用后自减,中间变量chr先赋值后,xyzj等的值变成13。
BUUCTF-[网鼎杯 2020 青龙组]singal——angr学习记录
weixin_52369224的博客
11-14 1668
​​​​​​学习结合b站的视频 环境配置：Ubuntu20.04+python3 ​​​​​​angr安装教程 切换到angr环境：workon angr 退出angr环境：deactivate 什么是符号执行： 符号执行 （Symbolic Execution）是一种程序分析技术。其可以通过分析程序来得到让特定代码区域执行的输入。使用符号执行分析一个程序时，该程序会使用符号值作为输入，而非一般执行程序时使用的具体值。在达到目标代码时，分析器可以得到相应的路径约束，然后通过约束求解器来...
2020网鼎杯青龙组Boom
05-12
【标题】"2020网鼎杯青龙组Boom" 涉及的是一个网络安全竞赛的场景，其中"网鼎杯"是中国国内知名的网络安全技术大赛，旨在提升参赛者的网络安全技能和应急处理能力。"青龙组"可能是比赛中的一个分组或者阶段，可能...
网鼎杯青龙组18道.rar
06-11
【标题】"网鼎杯青龙组18道.rar"是一个关于网络安全竞赛的资源压缩包，其中包含了2020年网鼎杯青龙组的比赛题目。网鼎杯是一项知名的网络安全技术竞赛，旨在提升参赛者的网络安全技能和实战能力，尤其针对青龙组，...
2020年网鼎杯青龙组赛题.zip
05-10
比赛试题附件，其中包括misc，re，crypto，pwn,这些资源仅供学习参考，禁止用于盈利活动。希望大家可以合理利用，谢谢。
2020网鼎杯青龙组白虎组部分试题.rar
05-14
2020网鼎杯青龙组白虎组部分试题 ，包括密码、杂项、逆向、PWN。希望可以帮助到大家复习。此次青龙难度大于白虎。
20200510.网鼎杯青龙组.zip
06-10
2020 5 10 网鼎杯 青龙组 比赛题目 web没有附件 其他基本都有 , 感谢各位师傅的整理
re学习（16）[网鼎杯 2020 青龙组]singal1（魔法库：angr）
m0_66039322的博客
07-15 389
对于angr做法没有必要关注这些过程，我们只要知道我们想要得到puts("good,The answer format is:flag {}");并且不想得到 printf("what a shame..."),找到相应的地址。（刚开始是看这个视频做的，但是有点看不懂，后来发现了可以用angr库做，而且更加方便~）即最终的flag为flag{757515121f3d478}看不懂，转angr~~~进入这个函数里面看看。
[网鼎杯 2020 青龙组]singal-复现
liaochonxiang的博客
06-10 106
/从“char*”到“int* ”的类型不兼容,编译器强制转为int*类型。//flag长度为15。//输出符合条件的code。case 10://可删除。case 6://可删除。case 7://可删除。//逆向过程为从后面向前面走。进入vm_operad函数。发现flag的长度为15。
2020网鼎杯 青龙组 逆向signal
lhk124的博客
11-25 621
signin 虚拟机题目 1.用angr解决 In [1]: import angr In [2]: p = angr.Project("./signal.exe") In [3]: init_state = p.factory.entry_state()
BUUCTF Reverse/[网鼎杯 2020 青龙组]singal
ookami6497的博客
07-31 560
BUUCTF Reverse/[网鼎杯 2020 青龙组]singal 先看文件信息，没有加壳 运行，又是字符串比较的题目 IDA32位打开，打开string窗口，跟随跳转 读入字符串 size_t __cdecl read(char *Str) { size_t result; // eax printf("string:"); scanf("%s", Str); result = strlen(Str); if ( result != 15 ) {
buuctf————[网鼎杯 2020 青龙组]singal
yhfgs的博客
10-18 227
1.查壳。 无壳，32位。 2.IDA反编译 可以看到主函数中关键函数为：vm_operad（）， 逻辑就是：用switch分层加密，加密的结果为a1中7值之后的东西。（没太搞懂） 3.解密（我学的太菜了，脚本没写出来，手撸的。） 4.get flag flag{757515121f3d478} ...
[BUUCTF]REVERSE——[网鼎杯 2020 青龙组]singal
mcmuyanga的博客
03-03 1069
[网鼎杯 2020 青龙组]singal 附件 步骤 例行检查，32位程序，无壳 本地试运行一下程序 32位ida载入，首先是找到main函数确定了flag字符串的样式flag{……} 根据输入点的提示字符串，找到对应函数，确定了字符串的长度是15 右击该函数，找到调用该函数的地方，来到了vm_operad（）函数处，看main函数可以知道，vm_operad里的参数v4在上面一行调用了qmemcpy函数，百度上说逆向里的qmemcpy=memcpy，memcpy在c语言里的拷贝函数，在unk_4
Buuctf-Reverse(逆向) 网鼎杯 2020 青龙组-singal Write up
weixin_50166464的博客
10-14 385
做逆向题太快乐了。--10.14 0x00 日常查壳 无壳64位 0x01 分析主函数 0x02 vm_operad 于是现在可以手解第一位flag 是可以发现如果只是改变加变减 乘变除是不能逆向回去 只是现在思路就是爆破出来 1. 我们现在拥有加密后的数据 2. 加密的算法 3. 就可以进行遍历每一个数和加密后的数据比对 0x03 GetFlag! #include <stdio.h> #include <string.h> i
re -16 buuctf [网鼎杯 2020 青龙组]singal（angr使用）
weixin_45847059的博客
11-23 512
[网鼎杯 2020 青龙组]singal 前话：先记录下angr的使用。参考了大佬的文章：https://blog.csdn.net/Breeze_CAT/article/details/106139253 在cmd中使用，不能在pycharm中使用。 >>> import angr >>> p = angr.Project(r'C:\Users\ASUS\Desktop\signal.exe') #地址前必须加r >>> state = p.facto
[re]符号执行一把梭：2020网鼎杯青龙组re_signal_wp
热门推荐
Breeze的博客
05-15 1万+
[re]符号执行一把梭：2020网鼎杯青龙组re_signal_wp 这道题是2020网鼎杯青龙组的一道逆向提signal，一道虚拟机逆向题目，题目本身不难，可以直接分析也可以符号执行秒掉。 题目分析 正常windows逆向，开局直接输flag，也不多bibi： 逆向分析程序： 程序开始将全局变量区的opcode作为参数给vm_operad函数，看名字也能看出是一个虚拟机分析的题目，先把opcode提取出来： \x0A \x04 \x10 \x08 \x03 \x05 \x01 \x04 \x20 \x
允许外网访问青龙面板
最新发布
10-10
要允许外网访问青龙面板，您需要进行以下操作： 1. 配置防火墙规则：确保服务器的防火墙允许外部访问面板的端口。默认情况下，青龙面板使用的是5700端口，您可以根据自己的需要进行配置。 2. 配置面板监听地址：打开青龙面板的配置文件 `config/auth.json`，将 `address` 字段的值修改为 `0.0.0.0`，表示监听所有可用的网络接口。 3. 配置登录验证：如果您希望对外网访问青龙面板进行登录验证，可以在 `config/auth.json` 文件中修改 `whitelist` 字段，添加允许访问的IP地址或IP段。 4. 重启青龙面板：保存配置文件后，重新启动青龙面板，使配置生效。 请注意，开放面板的外网访问涉及到网络安全风险，请确保您对服务器和青龙面板进行适当的安全防护和访问控制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值