[WUSTCTF2020]Cr0ssfun

查壳

64位ELF文件

反编译

分析可以知道将V4转化为64位整数类型，进入check函数，check函数的返回值被转化为unsigned int 类，如果返回值为1，输出Your flag is correct, go and submit it!

跟进check函数

继续跟进就ok了

按照下标将他们组合起来就得到flagctf2020{cpp_@nd_r3verse_@re_fun}

脚本

感觉我做的好麻烦，去网上看看，同样很麻烦，顺了个没啥用的脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<iostream>
using namespace std;
int main()
{
	char a1[32];
	a1[1] = 'c';a1[25] ='@' ; a1[27] = 'e';
	  a1[4] = '2';
      a1[17] = 'r';
       a1[29] = 'f';
       a1[17]= 'r';
       a1[24] = '_';
       a1[2] = 't';
       a1[9] = 'c';
       a1[32] = '}';
       a1[19] = 'v';
       a1[5] = '0';
       a1[14] = 'n';
        a1[15] = 'd';
       a1[8] ='{';
       a1[18] = '3';
       a1[28] = '_';
       a1[21] = 'r';
        a1[0] = 'w';
      a1[6] = '2';
       a1[22] = 's';
       a1[31] = 'n';
       a1[12] = '_';
        a1[7] = '0';
       a1[16] = '_';
       a1[11] = 'p';
       a1[23] = 'e';
       a1[30] = 'u';
    	a1[10] = 'p';
       a1[13] = '@';
       a1[3] = 'f';
       a1[26] = 'r';
      a1[20] = 'e';
      for(int i=0;i<=32;i++)cout << a1[i];  
}

[UTCTF2020]basic-re

查壳

64位无壳文件

关键信息&反编译

shift+F12查找字符串发现好多关键词，进去看看

得到mTyqm7wjODkrNLcWl0eqO8K8gc1BPk1GNLgUpI==

base64Encode( )进去看看吧

base编码过程，从其中找到编码表

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0987654321/+

解密

把他们扔进CyberChef

[GWCTF 2019]xxor

查壳

64位ELF文件

查找关键信息

shift+F12查找关键字Congratulation!点进去看看吧

反编译

主要函数

sub_400770(v7, a2) = 1输出成功信息

LODWORD(v7[j]) = dword_601078;用于提取一个 64 位变量的低 32 位
HIDWORD(v7[j]) = dword_60107C;用于提取一个 64 位变量的高 32 位

深入sub_400686函数，发现只要获得其中需要的数据就可以逆向得到答案

这是那个判断函数，从中就可以获得上面需要的信息

用前几天学过的z3

1
2
3
4
5
6
7
8
9
10
11
12
13
from z3 import *
a1=[0]*6
a1[0],a1[1],a1[2],a1[3],a1[4],a1[5]=Ints('a1[0] a1[1] a1[2] a1[3] a1[4] a1[5]')
s = Solver()
s.add(a1[2] - a1[3]== 2225223423)
s.add(a1[3] + a1[4]== 4201428739)
s.add(a1[2] - a1[4]==1121399208)
s.add(a1[0] ==-548868226)
s.add(a1[5] == -2064448480)
s.add(a1[1] == 550153460)
if s.check()==sat:
    r=s.model()
print(r)

解密 ，然后再十六进制转化成字符串，得到flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
int main() {
unsigned int a2[4] = {2,2,3,4};
unsigned int a1[6] = { 3746099070,550153460, 3774025685 ,1548802262 ,2652626477 ,2230518816 };
unsigned int flag[6];
unsigned v3, v4;
unsigned int i,j;
for (j = 0; j < 6; j+=2)
{
v3 = a1[j];
v4 = a1[j+1];
unsigned long long int tem = (unsigned long long int)0x458BCD42 * 64;
unsigned int sum = (unsigned int) tem;
for(i = 0; i < 64; i++)
{
v4 -= (v3 + sum + 20) ^ ((v3 << 6) + a2[2]) ^ ((v3 >> 9) + a2[3]) ^ 16;
v3 -= (v4 + sum + 11) ^ ((v4 << 6) + a2[0]) ^ ((v4 >> 9) + a2[1]) ^ 32;
sum -= 0x458BCD42;
}
flag[j] = v3;
flag[j + 1] = v4;
}
for (int n = 0; n < 6; n++)
printf("%x", flag[n]);
return 0;
}

文件格式

1. ELF（Executable and Linkable Format）

  • 使用平台：Linux、Unix、类Unix系统（如FreeBSD、Android）。
  • 特点：
    • 支持多种架构（如x86、ARM、RISC-V）。
    • 支持动态链接和静态链接。
    • 结构清晰，包含ELF头、程序头表、节头表。
    • 常用于可执行文件、共享库（.so）、目标文件（.o）和核心转储。
  • 工具：readelf、objdump、nm。
  • 文件扩展名：.elf、.so、.o。

2. PE（Portable Executable）

  • 使用平台：Windows。
  • 特点：
    • 基于COFF（Common Object File Format）扩展。
    • 支持32位（PE32）和64位（PE32+）。
    • 包含DOS头、PE头、节表、导入表、导出表等。
    • 支持动态链接（DLL文件）和资源管理（如图标、菜单）。
  • 工具：dumpbin、PEview、CFF Explorer。
  • 文件扩展名：.exe、.dll、.sys。

3. Mach-O（Mach Object）

  • 使用平台：macOS、iOS。
  • 特点：
    • 支持多种架构（如x86、ARM）。
    • 包含Mach-O头、加载命令、段和节。
    • 支持动态链接（dylib）和框架（Framework）。
    • 支持代码签名和沙盒机制。
  • 工具：otool、nm、lipo。
  • 文件扩展名：.o、.dylib、.app。

1. 提取特定位

通过掩码操作，可以从数据中提取特定位。例如，提取一个字节的低4位：

1
2
3
byte = 0b10101100
mask = 0b00001111
result = byte & mask  # 结果为 0b00001100

2. 设置特定位

掩码操作可以设置数据中的特定位。例如，设置一个字节的第3位：

1
2
3
byte = 0b10101100
mask = 0b00000100
result = byte | mask  # 结果为 0b10101100

3. 清除特定位

掩码操作可以清除数据中的特定位。例如，清除一个字节的第5位：

1
2
3
byte = 0b10101100
mask = ~0b00100000
result = byte & mask  # 结果为 0b10001100

4. 切换特定位

掩码操作可以切换数据中的特定位。例如，切换一个字节的第2位：

1
2
3
byte = 0b10101100
mask = 0b00000010
result = byte ^ mask  # 结果为 0b10101110

5. 检查特定位

掩码操作可以检查数据中的特定位是否被设置。例如，检查一个字节的第7位：

python

复制

1
2
3
4
5
6
byte = 0b10101100
mask = 0b10000000
if byte & mask:
    print("第7位被设置")
else:
    print("第7位未被设置")

6. 组合掩码

多个掩码可以组合使用。例如，提取一个字节的第2位和第4位：

1
2
3
byte = 0b10101100
mask = 0b00001010
result = byte & mask  # 结果为 0b00001000

7. 移位操作

移位操作常与掩码操作结合使用。例如，提取一个32位整数的第5到第8位：

1
2
3
value = 0x12345678
mask = 0x000000F0
result = (value & mask) >> 4  # 结果为 0x00000005

Std库

1. 容器（Containers）

用于存储和管理数据的模板类，分为：

  • 顺序容器：按顺序存储元素。
    • vector：动态数组。
    • list：双向链表。
    • deque：双端队列。
    • array：固定大小数组（C++11）。
    • forward_list：单向链表（C++11）。
  • 关联容器：基于键值对的有序/无序集合。
    • set/multiset：有序唯一/重复集合。
    • map/multimap：有序键值对。
    • unordered_set/unordered_multiset：哈希表实现的集合（C++11）。
    • unordered_map/unordered_multimap：哈希表实现的键值对（C++11）。
  • 容器适配器：基于其他容器实现的接口。
    • stack：后进先出（LIFO）栈。
    • queue：先进先出（FIFO）队列。
    • priority_queue：优先级队列。
1
2
#include <vector>
std::vector<int> nums = {1, 2, 3};

2. 算法（Algorithms）

提供通用算法，通过 <algorithm> 头文件访问：

  • 非修改序列操作：for_each, find, count。
  • 修改序列操作：copy, fill, replace。
  • 排序和查找：sort, binary_search, lower_bound。
  • 数值操作：accumulate, inner_product（需 <numeric>）。
1
2
#include <algorithm>
std::sort(nums.begin(), nums.end());

3. 字符串处理（Strings）

  • std::string：动态字符串类，支持拼接、查找、替换等操作。
  • std::string_view：字符串视图（C++17），用于高效读取字符串片段。
1
2
std::string s = "Hello";
s.append(" World");

4. 输入/输出（I/O）

通过 <iostream>、<fstream> 等头文件提供：

  • 流对象：std::cin, std::cout, std::cerr, std::clog。
  • 文件操作：std::ifstream, std::ofstream。
  • 格式化工具：std::hex, std::setw, std::fixed（需 <iomanip>）。
1
2
#include <iostream>
std::cout << "Value: " << 42 << std::endl;

5. 智能指针（Smart Pointers）

用于自动内存管理（需 <memory>）：

  • std::unique_ptr：独占所有权的指针。
  • std::shared_ptr：共享所有权的指针。
  • std::weak_ptr：解决 shared_ptr 循环引用问题。
1
auto ptr = std::make_unique<int>(42);

6. 工具类与函数（Utilities）

  • 元编程：std::pair, std::tuple, std::variant（C++17）。
  • 类型操作：std::move（移动语义）, std::forward（完美转发）。
  • 时间和日期：std::chrono（需 <chrono>）。
  • 随机数生成：std::mt19937（需 <random>）。
1
std::pair<int, std::string> p = {1, "one"};

7. 多线程与并发（Concurrency）

通过 <thread>, <mutex>, <atomic> 等头文件支持：

  • 线程管理：std::thread, std::jthread（C++20）。
  • 同步机制：std::mutex, std::lock_guard, std::condition_variable。
  • 原子操作：std::atomic<T>。
1
2
3
#include <thread>
std::thread t([](){ std::cout << "Thread!"; });
t.join();

8. 异常处理（Exceptions）

  • 异常类：std::exception 及其子类（如 std::runtime_error）。
  • 异常工具：std::throw_with_nested（C++11）。
1
2
3
4
5
try {
    throw std::runtime_error("Error!");
} catch (const std::exception& e) {
    std::cerr << e.what();
}

9. 其他重要组件

  • 函数对象：std::function（包装函数指针、Lambda 等）。
  • 正则表达式：std::regex（需 <regex>）。
  • 文件系统操作：std::filesystem（C++17，需 <filesystem>）。
1
2
#include <functional>
std::function<int(int, int)> add = [](int a, int b) { return a + b; };