Aggregator

YAK-SSA，古希腊掌管PHP代码审计的神

不安全
1 year 3 months ago
之前的文章中曾为大家简单介绍过线上代码审计平台ssa.to今天牛牛就来为大家详细介绍一下如何用ssa进行PHP的代码审计tp封装的辅助参数，I/request方法thinkphp中的封装了请求对象，$

日本警告中国黑客攻击

Solidot
1 year 3 months ago
日本政府周三对中国黑客攻击发出了警告。日本警视厅将该黑客组织命名为 MirrorFace，其活动始于 2019 年，最初目标是媒体、政治组织、智库和大学，2023 年后转向制造商和研究机构。日本称，MirrorFace 攻击目标包括了日本外交部和国防部、宇航局，以及政界人士、记者、私营公司和科技智库。

LLVM IR 深入研究分析

安全脉搏
1 year 3 months ago
前置知识

LLVM是C++编写的构架编译器的框架系统，可用于优化以任意程序语言编写的程序。

LLVM IR可以理解为LLVM平台的汇编语言，所以官方也是以语言参考手册(Language Reference Manual)的形式给出LLVM IR的文档说明。既然是汇编语言，那么就和传统的CUP类似，有特定的汇编指令集。但是它又与传统的特定平台相关的指令集(x86,ARM,RISC-V等)不一样，它定位为平台无关的汇编语言。也就是说，LLVM IR是一种相对于CUP指令集高级，但是又是一种低级的代码中间表示（比抽象语法树等高级表示更加低级)。

LLVM IR即代码的中间表示，有三种形式：

  • .ll 格式：人类可以阅读的文本(汇编码) -->这个就是我们要学习的IR

  • .bc 格式：适合机器存储的二进制文件

  • 内存表示

下面给出.ll格式和.bc格式生成及相互转换的常用指令清单：

.c -> .ll：clang -emit-llvm -S a.c -o a.ll
.c -> .bc: clang -emit-llvm -c a.c -o a.bc
.ll -> .bc: llvm-as a.ll -o a.bc
.bc -> .ll: llvm-dis a.bc -o a.ll
.bc -> .s: llc a.bc -o a.s

那么我们以一道CTF赛题来分析实验，学习LLVM IR

实验解析

题目附件直接给出了中间表示.II文件

打开查看一下汇编码，毕竟.II文件是人类可以阅读的文本，这边笔者使用的是Sublime Text（使用VScode查看即可）代码量不多，大概600行

题目初步分析

我们直接寻找一下main函数

我们可以看出题目经历了两次RC4，然后Base64，我们从上面可以看到密文，RC4_key,我们直接一把锁，cyberchef启动，会发现解不出来，那么程序应该做了其他的操作，最朴素的，我们可以想到把RC4魔改了，base64魔改等等。

So！继续学习研究ing


【帮助网安学习，以下所有学习资料免费领！领取资料加 we~@x：dctintin，备注 “安全脉搏” 获取！】

① 网安学习成长路径思维导图
② 60 + 网安经典常用工具包
③ 100+SRC 漏洞分析报告
④ 150 + 网安攻防实战技术电子书
⑤ 最权威 CISSP 认证考试指南 + 题库
⑥ 超 1800 页 CTF 实战技巧手册
⑦ 最新网安大厂面试题合集（含答案）
⑧ APP 客户端安全检测指南（安卓 + IOS）


.II详细分析

所以本着学习的态度，我们这时候应该掏出LLVM Language Reference Manual(官方文档)来简单了解学习一些常见指令、符号标识以及特性。这边给出一些分析 .ll 中间文件的算法流程

@ - 全局变量
% - 局部变量
alloca - 在当前执行的函数的堆栈帧中分配内存，当该函数返回到其调用者时，将自动释放内存
i32 - 32位4字节的整数
align - 对齐
load - 读出，store写入
icmp - 两个整数值比较，返回布尔值
br - 选择分支，根据条件来转向label，不根据条件跳转的话类型goto
label - 代码标签
call - 调用函数

首先看到一些全局变量，知道了RC4_key = llvmbitccipher = "TSzkWKgbMHszXaj@kLBmRrnTxsNtZsSOtZzqYikCw="

我们继续分析，重点分析各个function

b64encode

b64encode 魔改

  1. 每三个字符，24位，切分成4断，每段6位。

  2. 将6位对应的值 (value+ 59)&0xff 则是编码后的值。

 %22 = getelementptr inbounds i8, i8* %19, i64 %21        // 取出当前处理字符
 %23 = load i8, i8* %22, align 1
 %24 = zext i8 %23 to i32                                 // 类型强制转化
 %25 = ashr i32 %24, 2                                   // 算数右移两位   input[i]>>2
 %26 = add nsw i32 %25, 59                                 //    input[i]+59
 %27 = trunc i32 %26 to i8                                //    强制转化  相当于 &0xff
 %28 = load i8*, i8** %6, align 8
 %29 = load i32, i32* %9, align 4
 %30 = sext i32 %29 to i64
 %31 = getelementptr inbounds i8, i8* %28, i64 %30        // 存储base64 编码串
 store i8 %27, i8* %31, align 1
 %32 = load i8*, i8** %4, align 8
 %33 = load i32, i32* %7, align 4
 %34 = sext i32 %33 to i64
 %35 = getelementptr inbounds i8, i8* %32, i64 %34
 %36 = load i8, i8* %35, align 1
 %37 = zext i8 %36 to i32
 %38 = and i32 %37, 3                              // 获取第一个字符 低两位
 %39 = shl i32 %38, 4                                // 左移四位 RC4_init

RC4_init 正常，无魔改

define dso_local void @Rc4_Init(i8*, i32) #0 {                           //RC4_init function
 %3 = alloca i8*, align 8
 %4 = alloca i32, align 4
 %5 = alloca i32, align 4
 %6 = alloca i32, align 4
 store i8* %0, i8** %3, align 8
 store i32 %1, i32* %4, align 4                                         //初始化S，T盒
 call void @llvm.memset.p0i8.i64(i8* align 16 getelementptr inbounds ([256 x i8], [256 x i8]* @s, i64 0, i64 0), i8 0, i64 256, i1 false)
 call void @llvm.memset.p0i8.i64(i8* align 16 getelementptr inbounds ([256 x i8], [256 x i8]* @t, i64 0, i64 0), i8 0, i64 256, i1 false)
 store i32 0, i32* %5, align 4
 br label %7

7:                                                ; preds = %26, %2
 %8 = load i32, i32* %5, align 4
 %9 = icmp slt i32 %8, 256
 br i1 %9, label %10, label %29                          //如果 %9 为真（即 %8 小于 256），跳转到标签 %10；否则跳转到标签 %29，根据t打乱s盒

10:                                               ; preds = %7
 %11 = load i32, i32* %5, align 4
 %12 = trunc i32 %11 to i8
 %13 = load i32, i32* %5, align 4
 %14 = sext i32 %13 to i64
 %15 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %14
 store i8 %12, i8* %15, align 1
 %16 = load i8*, i8** %3, align 8
 %17 = load i32, i32* %5, align 4
 %18 = load i32, i32* %4, align 4
 %19 = urem i32 %17, %18
 %20 = zext i32 %19 to i64
 %21 = getelementptr inbounds i8, i8* %16, i64 %20
 %22 = load i8, i8* %21, align 1
 %23 = load i32, i32* %5, align 4
 %24 = sext i32 %23 to i64
 %25 = getelementptr inbounds [256 x i8], [256 x i8]* @t, i64 0, i64 %24
 store i8 %22, i8* %25, align 1
 br label %26

26:                                               ; preds = %10
 %27 = load i32, i32* %5, align 4
 %28 = add nsw i32 %27, 1
 store i32 %28, i32* %5, align 4
 br label %7

29:                                               ; preds = %7
 store i32 0, i32* %6, align 4
 store i32 0, i32* %5, align 4
 br label %30

30:                                               ; preds = %54, %29
 %31 = load i32, i32* %5, align 4
 %32 = icmp slt i32 %31, 256
 br i1 %32, label %33, label %57

33:                                               ; preds = %30
 %34 = load i32, i32* %6, align 4
 %35 = load i32, i32* %5, align 4
 %36 = sext i32 %35 to i64
 %37 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %36
 %38 = load i8, i8* %37, align 1
 %39 = zext i8 %38 to i32
 %40 = add nsw i32 %34, %39
 %41 = load i32, i32* %5, align 4
 %42 = sext i32 %41 to i64
 %43 = getelementptr inbounds [256 x i8], [256 x i8]* @t, i64 0, i64 %42
 %44 = load i8, i8* %43, align 1
 %45 = zext i8 %44 to i32
 %46 = add nsw i32 %40, %45
 %47 = srem i32 %46, 256
 store i32 %47, i32* %6, align 4
 %48 = load i32, i32* %5, align 4
 %49 = sext i32 %48 to i64
 %50 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %49
 %51 = load i32, i32* %6, align 4
 %52 = sext i32 %51 to i64
 %53 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %52
 call void @swap(i8* %50, i8* %53)                                                //call swap function
 br label %54 RC4_enc

RC4_enc 魔改 多了一层xor 89

define dso_local void @Rc4_Encrypt(i8*, i32) #0 {                                //RC4_enc function
 %3 = alloca i8*, align 8
 %4 = alloca i32, align 4
 %5 = alloca i8, align 1
 %6 = alloca i8, align 1
 %7 = alloca i8, align 1
 %8 = alloca i8, align 1
 store i8* %0, i8** %3, align 8
 store i32 %1, i32* %4, align 4
 store i8 0, i8* %6, align 1
 store i8 0, i8* %7, align 1
 store i8 0, i8* %8, align 1
 br label %9

9:                                                ; preds = %14, %2
 %10 = load i8, i8* %8, align 1
 %11 = zext i8 %10 to i32
 %12 = load i32, i32* %4, align 4
 %13 = icmp ult i32 %11, %12
 br i1 %13, label %14, label %64

14:                                               ; preds = %9
 %15 = load i8, i8* %6, align 1
 %16 = zext i8 %15 to i32
 %17 = add nsw i32 %16, 1
 %18 = srem i32 %17, 256
 %19 = trunc i32 %18 to i8
 store i8 %19, i8* %6, align 1
 %20 = load i8, i8* %7, align 1
 %21 = zext i8 %20 to i32
 %22 = load i8, i8* %6, align 1
 %23 = zext i8 %22 to i64
 %24 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %23               //生成密钥流
 %25 = load i8, i8* %24, align 1
 %26 = zext i8 %25 to i32
 %27 = add nsw i32 %21, %26
 %28 = srem i32 %27, 256
 %29 = trunc i32 %28 to i8
 store i8 %29, i8* %7, align 1
 %30 = load i8, i8* %6, align 1
 %31 = zext i8 %30 to i64
 %32 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %31
 %33 = load i8, i8* %7, align 1
 %34 = zext i8 %33 to i64
 %35 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %34              //经典Swap了再加
 call void @swap(i8* %32, i8* %35)
 %36 = load i8, i8* %6, align 1
 %37 = zext i8 %36 to i64
 %38 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %37
 %39 = load i8, i8* %38, align 1
 %40 = zext i8 %39 to i32
 %41 = load i8, i8* %7, align 1
 %42 = zext i8 %41 to i64
 %43 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %42
 %44 = load i8, i8* %43, align 1
 %45 = zext i8 %44 to i32
 %46 = add nsw i32 %40, %45
 %47 = srem i32 %46, 256
 %48 = sext i32 %47 to i64
 %49 = getelementptr inbounds [256 x i8], [256 x i8]* @s, i64 0, i64 %48
 %50 = load i8, i8* %49, align 1
 store i8 %50, i8* %5, align 1
 %51 = load i8, i8* %5, align 1
 %52 = zext i8 %51 to i32
 %53 = xor i32 %52, 89                                                         //xor 89
 %54 = load i8*, i8** %3, align 8
 %55 = load i8, i8* %8, align 1
 %56 = zext i8 %55 to i64
 %57 = getelementptr inbounds i8, i8* %54, i64 %56
 %58 = load i8, i8* %57, align 1
 %59 = zext i8 %58 to i32
 %60 = xor i32 %59, %53                                                        //xor k
 %61 = trunc i32 %60 to i8
 store i8 %61, i8* %57, align 1
 %62 = load i8, i8* %8, align 1
 %63 = add i8 %62, 1
 store i8 %63, i8* %8, align 1
 br label %9

64:                                               ; preds = %9
 ret void
} main

main函数逻辑cipher -->RC4_init-->RC4_enc-->RC4_enc-->b64encode需要注意一下在RC4_enc的参数中，传入的数据块长度是固定的16，所以说程序进行两次RC4_enc的原因也就确定了，是为了分两次对程序进行加密，也算是一点点小手段，总之，即使让你好好分析.II代码，考察对软件分析的细节，耐心，嘻嘻。

OK,理清楚逻辑，就可以试着敲代码解密啦。

解密

逆向分析过程明了之后，那么写代码就简单多了

#include<stdio.h>
unsigned char s[300],t[300];
void b64decode(unsigned char * enc,unsigned char* dec);
void Rc4_dec1(int len, unsigned char *enc);
void Rc4_Init(char *key,int len);
void Rc4_dec2(int len, unsigned char *enc);
int main() {
   unsigned char enc[50]="TSz`kWKgbMHszXaj`@kLBmRrnTxsNtZsSOtZzqYikCw=";
   unsigned char dec1[50]={0x00};
   char key[10] ="llvmbitc";
   unsigned char a[50];
   int i=0;      

   b64decode(enc,dec1);
   Rc4_Init(key,8);
   Rc4_dec1(16,&dec1[16]);
   for(i=0;i<16;i++) {
       dec1[i+16]^=dec1[i];
   }
   Rc4_Init(key,8);
   Rc4_dec2(16,dec1);
   printf("%s",dec1);

   return 0;
}
void b64decode(unsigned char * enc,unsigned char* dec) {
   int i=0,j=0;
   for(i=0;i<40;i+=4) {
       dec[j] = ((enc[i]-59)<<2)&0xfc | (((enc[i+2]-59)>>4))&3;
       dec[j+1] = (((enc[i+2]-59)&0xf)<<4) | (((enc[i+1]-59)>>2)&0xf);
       dec[j+2] = (((enc[i+1]-59)&3)<<6) | ((enc[i+3]-59)&0x3f);
       j+=3;
   }
   dec[j] = ((enc[i]-59)<<2)&0xfc | (((enc[i+1]-59)>>4))&3;
   dec[j+1] = (((enc[i+2]-59)>>2)&0xf) | (((enc[i+1]-59)<<4)&0xf0);
   dec[j+2]=0;
}

void Rc4_Init(char *key,int len) {
   int i=0,v5=0;
   unsigned char temp;
   for(i=0;i<256;i++) {
       s[i] =i;
       t[i] = key[i%len];
   }
   for(i=0;i<256;i++) {
       v5=(s[i]+t[i]+v5)%256;
       temp = s[i];
       s[i]= s[v5];
       s[v5]=temp;

   }
}
void Rc4_dec1(int len, unsigned char *enc) {
   int v3=0,v5=0,i,j;
   unsigned char temp;
   for(i=0;i<len;i++) {
       v3=(v3+1)%256;
       v5=(s[v3]+v5)%256;
       temp=s[v3];
       s[v3]=s[v5];
       s[v5]=temp;
   }
   v5=v3=0;
   for(i=0;i<len;i++) {
       v3=(v3+1)%256;
       v5 = (s[v3]+v5)%256;
       temp = s[v3];
       s[v3]=s[v5];
       s[v5]=temp;
       enc[i]^=s[(s[v5]+s[v3])%256]^0x59;
   }
}
void Rc4_dec2(int len, unsigned char *enc) {
   int v3=0,v5=0,i,j;
   unsigned char temp;
   v5=v3=0;
   for(i=0;i<len;i++) {
       v3=(v3+1)%256;
       v5 = (s[v3]+v5)%256;
       temp = s[v3];
       s[v3]=s[v5];
       s[v5]=temp;
       
       enc[i]^=s[(s[v5]+s[v3])%256]^0x59;
   }
}

flag{Hacking_for_fun@reverser$!}

总结

通过这么一道CTF题目，深入学习LLVM IR的冰山一角，认真实验，细细分析，相信会对你有极大帮助。当然，如果单从解题来说，对于解决这道题有很多的办法，比如说将.II转化为可执行文件，然后IDA分析，但我们旨在学习LLVM IR，这里不再过多赘述。

  


[email protected]

LLVM IR 深入研究分析

不安全
1 year 3 months ago
LLVM是C++编写的构架编译器的框架系统，可用于优化以任意程序语言编写的程序。LLVM IR可以理解为LLVM平台的汇编语言，所以官方也是以语言参考手册(Language Ref

MFC框架软件逆向研究

安全脉搏
1 year 3 months ago
MFC框架简介

什么是mfc？

MFC库是开发Windows应用程序的C++接口。MFC提供了面向对象的框架，采用面向对象技术，将大部分的Windows API 封装到C++类中，以类成员函数的形式提供给程序开发人员调用。

简单来说，MFC是一种面向对象，用于开发windows应用程序的框架，突出特点是封装了大部分windows API，便于开发人员使用（写win挂方便）。

MFC程序的运行过程分为以下四步：

  1. 利用全局应用程序对象theApp启动应用程序。

  2. 调用全局应用程序对象的构造函数，从而调用基类（CWinApp）的构造函数,完成应用程序的一些初始化工作，并将应用程序对象的指针保存起来。

  3. 进入WinMain函数。在AfxWinMain函数中获取子类的指针，利用指针实现上述的三个函数，从而完成窗口的创建注册等工作。

  4. 进入消息循环，一直到WM_QUIT。

那么问题来了，我们如何逆向mfc程序呢？因为其封装了大部分windows API，逆向起来也复杂了不少，因为需要了解大量的windows api 并且熟悉windows编程。下面进行讲解。

MFC如何逆向

如下图，是MFC框架软件的基本界面，可以看到，就是一堆button，主要逆向也是check button。

那么，对于MFC逆向，我们主要需要知道的是，当我们执行某个操作（点击某个按钮）的时候，程序会执行什么处理函数。在mfc中，程序是使用消息机制来实现操作响应的，这个是消息映射表的代码：

struct AFX_MSGMAP{
   AFX_MSGMAP * pBaseMessageMap;
   AFX_MSGMAP_ENTRY * lpEntries;
}
struct AFX_MSGMAP_ENTRY{
   UINT nMessage;    //Windows Message
   UINT nCode        //Control code or WM_NOTIFY code
   UINT nID;         //control ID (or 0 for windows messages)
   UINT nLastID;     //used for entries specifying a range of control id's
   UINT nSig;        //signature type(action) or pointer to message
   AFX_PMSG pfn;     //routine to call (or specical value)
}

其中这个AFX_MSGMAP_ENTRY中的最后一个成员AFX_PMSG就是一个函数指针，指向了当前控件绑定的函数。同时，这个nID成员描述的是当前控件的ID，利用这个ID就能确定我们所寻找的控件。然后这个AFX_MSGMAP结构体则会记录一个指向AFX_MSGMAP_ENTRY的指针，于是查找控件的注册函数的思路可以缩小为:

  • 找到AFX_MSGMAP

  • 找到控件的ID --- 关键就是找ID

那么，我们又该怎么找到控件ID呢，俗话说“工欲善其事，必先利其器”，作为逆向分析人员，肯定要选择好分析的工具了，很庆幸，我们站在巨人的肩膀上，针对mfc软件程序的逆向分析，前辈们已经开发了一些非常好用的小工具，我们可以直接使用它们。例如：

  1. xspy

  2. ResourceHacker

  3. 彗星小助手

其中我们主要用的是xspy，mfc分析利器如下图所示

逆向实验-以CTF赛题为例讲解 demo1 - MFC初探

打开程序软件

程序的标题Flag就在控件中，然后界面内容是让我们找一个key。很明显，我们需要找到两个东西

  1. 标题找Flag（也就是找窗口句柄）

  2. 内容找key

根据这些内容，告诉我们我们去找控件，然后这时候就要掏出xspy了。不然的话，我们如果使用老一套经典分析流程，die+ida对用架构分析，会发生下面这样的事。首先die查个架构，查个壳

好家伙，VMP壳，PE32ida走起，如下图，emmm....

这样的话，我们很难继续往下分析，所以我们使用xspy分析。使用方法如下图

首先我们找到了Flag_enc(944c8d100f82f0c18b682f63e4dbaa207a2f1e72581c2f1b)我们知道特定的，窗口句柄叫 HWND

然后我们可以发现一条特殊的onMsgOnMsg:0464,func= 0x00402170(MFC1.exe+ 0x002170 )为什么特殊呢，因为只有它并不是以宏的形式出现，应该是作者自定义的消息，没有button等东西，所以程序怎么点击都无法触发任何效果；并且传入一个特殊数字0464，来触发效果。

那么，我们需要去发送这条消息来出发func函数以获取我们需要的key

#include<Windows.h>
#include<stdio.h>
int main()
{
   HWND h = FindWindowA(NULL, "Flag就在控件里");
   if (h)
   {
       SendMessage(h, 0x0464, 0, 0);
       printf("success");
   }
   else printf("failure");
}

使用 API FindWindow 获取窗口句柄，SendMessage发送消息，得到了key{I am a Des key}

最后DES解密即可

flag{thIs_Is_real_kEy_hahaaa}


Junk_instruction-西湖论剑

下面，再讲解一道大型比赛的赛题来实验打开，看到这个朴素的界面可以鉴定是MFC框架。

我们看到了一个input，还有一个check button，很明显，我们首先就需要去找check button的id&注册函数。

xspy-MFC分析

check按钮的id为03e9，同时窗口存在OnCommand: notifycode=0000 id=03e9,func= 0x00C72420(Junk_Instruction.exe+ 0x002420 )函数。那么对应的check逻辑肯定在基址+偏移0x002420处。打开ida，找到check函数 sub_402420 ，如下图

可以看到有一个条件判断：if ( (unsigned __int8)sub_402600(v2 + 16) )。一眼顶针，两个分支分别是弹出正确和错误的对话框，为什么呢？if else函数体内容基本一样。当然我们还是动态调试一下

所以enc函数很明显就是sub_402600这个函数中就出现了很多垃圾指令了，也就对应上题目名称Junk_instruction了。

去花-IDA分析

爆红

花指令，经典call $+5起手，就是先用一个call压好返回地址，再把栈里的返回地址弹出来，改一下，压回去，如此反复。去掉也很简单，我们把下述累死指令块全部nop掉即可，有好几处，一模一样。

当然，我们使用idapython脚本自动去花

   from ida_bytes import get_bytes, patch_bytes
   import re
   addr = 0x402600
   end = 0x402fe3
   buf = get_bytes(addr, end-addr)
   def nopp(s):
       s = s.group(0)
       print("".join(["%02x"%i for i in s]))
       s = b"\x90"*len(s)
       return s
   pattern  = b"\xe8\x00\x00\x00\x00\x58\x89.*?\xc3.*?\x22"
   buf = re.sub(pattern , nopp, buf, flags=re.I)
   patch_bytes(addr, buf)
   print("Done")

加密

去除花指令，简单审计发现是对程序进行RC4加密，最后还对输入进行了个倒叙

去花后，整理一下，代码如下

char __thiscall sub_402600(void *this, int a2)
{
 const WCHAR *v2; // eax
 void *v3; // eax
 char v5[511]; // [esp+9h] [ebp-4BBh] BYREF
 int v6; // [esp+208h] [ebp-2BCh]
 char *v7; // [esp+20Ch] [ebp-2B8h]
 int v8; // [esp+210h] [ebp-2B4h]
 size_t Count; // [esp+214h] [ebp-2B0h]
 int v10; // [esp+218h] [ebp-2ACh]
 size_t v11; // [esp+21Ch] [ebp-2A8h]
 char *v12; // [esp+220h] [ebp-2A4h]
 char *v13; // [esp+224h] [ebp-2A0h]
 int v14; // [esp+228h] [ebp-29Ch]
 char v15[4]; // [esp+22Ch] [ebp-298h] BYREF
 char *Source; // [esp+230h] [ebp-294h]
 void *v17; // [esp+234h] [ebp-290h]
 char cipher[32]; // [esp+238h] [ebp-28Ch]
 const char *v19; // [esp+258h] [ebp-26Ch]
 char *v20; // [esp+25Ch] [ebp-268h]
 int i; // [esp+260h] [ebp-264h]
 char *p_Destination; // [esp+264h] [ebp-260h]
 char v23; // [esp+26Dh] [ebp-257h]
 char v24; // [esp+26Eh] [ebp-256h]
 char v25; // [esp+26Fh] [ebp-255h]
 char v26[28]; // [esp+270h] [ebp-254h] BYREF
 char v27[256]; // [esp+28Ch] [ebp-238h] BYREF
 char key[256]; // [esp+38Ch] [ebp-138h] BYREF
 char Destination; // [esp+48Ch] [ebp-38h] BYREF
 char v30[39]; // [esp+48Dh] [ebp-37h] BYREF
 int v31; // [esp+4C0h] [ebp-4h]

 v17 = this;
 v31 = 3;
 cipher[0] = 91;
 cipher[1] = -42;
 cipher[2] = -48;
 cipher[3] = 38;
 cipher[4] = -56;
 cipher[5] = -35;
 cipher[6] = 25;
 cipher[7] = 126;
 cipher[8] = 110;
 cipher[9] = 62;
 cipher[10] = -53;
 cipher[11] = 22;
 cipher[12] = -111;
 cipher[13] = 125;
 cipher[14] = -1;
 cipher[15] = -81;
 cipher[16] = -35;
 cipher[17] = 118;
 cipher[18] = 100;
 cipher[19] = -80;
 cipher[20] = -9;
 cipher[21] = -27;
 cipher[22] = -119;
 cipher[23] = 87;
 cipher[24] = -126;
 cipher[25] = -97;
 cipher[26] = 12;
 cipher[27] = 0;
 cipher[28] = -98;
 cipher[29] = -48;
 cipher[30] = 69;
 cipher[31] = -6;
 v2 = (const WCHAR *)sub_401570(&a2);
 v14 = sub_4030A0(v2);
 v10 = v14;
 v3 = (void *)sub_401570(v14);
 sub_403000(v3);
 sub_4012A0(v15);
 Source = (char *)unknown_libname_1(v26);
 v20 = Source;
 v13 = Source + 1;
 v20 += strlen(v20);
 v11 = ++v20 - (Source + 1);
 Count = v11;
 Destination = 0;
 memset(v30, 0, sizeof(v30));
 strncpy(&Destination, Source, v11);
 if ( sub_402AF0(&Destination) )
 {
   v23 = 0;
   v25 = 0;
LABEL_7:
   v24 = v25;
 }
 else
 {
   strcpy(key, "qwertyuiop");                  // key
   memset(&key[11], 0, 0xF5u);
   memset(v27, 0, sizeof(v27));
   memset(v5, 0, sizeof(v5));
   v19 = key;
   v7 = &key[1];
   v19 += strlen(v19);
   v6 = ++v19 - &key[1];
   RC4_init((int)v27, key, v19 - &key[1]);     // RC4_init
   p_Destination = &Destination;
   v12 = v30;
   p_Destination += strlen(p_Destination);
   v8 = ++p_Destination - v30;
   RC4_crypt((int)v27, (int)&Destination, p_Destination - v30);// RC4_crypto
   for ( i = 31; i >= 0; --i )
   {
     if ( v30[i - 1] != cipher[i] )            // 倒叙
     {
       v25 = 0;
       goto LABEL_7;
     }
   }
   v24 = 1;
 }
 LOBYTE(v31) = 0;
 sub_403060(v26);
 v31 = -1;
 sub_4012A0(&a2);
 return v24;
} 解密

首先提取密文，利用插件Lazy_ida 5BD6D026C8DD197E6E3ECB16917DFFAFDD7664B0F7E58957829F0C009ED045FA

key-->qwertyuiop

cyberchef 得解

flag{973387a11fa3f724d74802857d3e052f}

  


[email protected]

MFC框架软件逆向研究

不安全
1 year 3 months ago
什么是mfc？MFC库是开发Windows应用程序的C++接口。MFC提供了面向对象的框架，采用面向对象技术，将大部分的Windows API 封装到C++类中，以类成员函数的形式提

【反恐】2024年12月全球恐怖主义事件

不安全
1 year 3 months ago
利用全球涉恐智慧库对全球2024年12月1日至12月31日发生的恐怖主义事件进行统计，共检索到恐怖主义事件70件，事件导致350人死亡，106人受伤。其中：一、东南亚2起，死亡4人。1、泰国1起，死亡

CVE-2024-43659 | Iocharger 24120701 Charging Station credentials storage (DIVD-2024-00035)

Vuldb Updates
1 year 3 months ago
A vulnerability has been found in Iocharger 24120701 and classified as problematic. Affected by this vulnerability is an unknown functionality of the component Charging Station. The manipulation leads to unprotected storage of credentials. This vulnerability is known as CVE-2024-43659. An attack has to be approached locally. There is no exploit available. It is recommended to upgrade the affected component.
vuldb.com

Managed ad