we1c0me_t0 my odyssey domain

折返

Fri, 10 Apr 2026 00:00:00 +0800

我觉得，因为爱好或者冲动想做一件对自己或者他人都非常好的事，无论发生什么，都能把这件好事坚持下去的人，才能叫作高手

何况是在技术记录与分享这件事上，现在看看自己前年的帖子往往会惊叹于自己原来当时技术还算不错，25 年发生了很多事情，自己也开始变得追求短平快的节奏，最终也导致了某些坚持了几年的梦想无疾而终，或者说叫惨败收场，而落得如今这种地步

今天也不知道是怎么了，可能是过于无聊，也可能是睡了很久，起来就做了一个抽象视频，然后翻阅着以前留下的手稿，感觉好像是另一个人写的

也许我迷茫了 20 个月只是迷路了，我需要尝试迷途知返

这几天开始会写 web 的帖子

寄存器部分寻址方式

Wed, 22 Jan 2025 00:00:00 +0800

到底日更变成拖更变成月更了，水一篇吧，实在太忙了，~~或者你们想看的话我更新高等数学也行~~

借鉴来源：

# ASM 源码：

section .data
    msg db "Welcome_to_CTFshow_PWN", 0

section .text
    global _start

_start:

; 立即寻址方式
    mov eax, 11         ; 将11赋值给eax
    add eax, 114504     ; eax加上114504
    sub eax, 1          ; eax减去1

; 寄存器寻址方式
    mov ebx, 0x36d      ; 将0x36d赋值给ebx
    mov edx, ebx        ; 将ebx的值赋值给edx

; 直接寻址方式
    mov ecx, msg      ; 将msg的地址赋值给ecx

; 寄存器间接寻址方式
    mov esi, msg        ; 将msg的地址赋值给esi
    mov eax, [esi]      ; 将esi所指向的地址的值赋值给eax

; 寄存器相对寻址方式
    mov ecx, msg        ; 将msg的地址赋值给ecx
    add ecx, 4          ; 将ecx加上4
    mov eax, [ecx]      ; 将ecx所指向的地址的值赋值给eax

; 基址变址寻址方式
    mov ecx, msg        ; 将msg的地址赋值给ecx
    mov edx, 2          ; 将2赋值给edx
    mov eax, [ecx + edx*2]  ; 将ecx+edx*2所指向的地址的值赋值给eax

; 相对基址变址寻址方式
    mov ecx, msg        ; 将msg的地址赋值给ecx
    mov edx, 1          ; 将1赋值给edx
    add ecx, 8          ; 将ecx加上8
    mov eax, [ecx + edx*2 - 6]  ; 将ecx+edx*2-6所指向的地址的值赋值给eax

; 输出字符串
    mov eax, 4          ; 系统调用号4代表输出字符串
    mov ebx, 1          ; 文件描述符1代表标准输出
    mov ecx, msg        ; 要输出的字符串的地址
    mov edx, 22         ; 要输出的字符串的长度
    int 0x80            ; 调用系统调用

; 退出程序
    mov eax, 1          ; 系统调用号1代表退出程序
    xor ebx, ebx        ; 返回值为0
    int 0x80            ; 调用系统调用

# 详解：

# 1. .data 段

section .data
    msg db "Welcome_to_CTFshow_PWN", 0

解释：

.data 段：用来存放程序中的已初始化数据，这些数据在程序运行时会被加载到内存中。
msg db ：声明一个字符串 "Welcome_to_CTFshow_PWN" ，以字节（ db = Define Byte）存储，并以 0 结尾，表示字符串结束符（类似 C 语言的 \0 ）。
地址： msg 是一个标签，代表该字符串的内存地址，供后续使用。

# 2. .text 段

section .text
global _start

_start:

解释：

.text 段：存放程序的代码（指令）。
_start ：程序的入口，系统从这里开始执行程序（对应 Linux 的 ELF 文件格式的起点）。

# 3. 立即寻址方式

mov eax, 11         ; 将11赋值给eax
add eax, 114504     ; eax加上114504
sub eax, 1          ; eax减去1

解释：

立即寻址方式：操作数是一个立即数，直接嵌入在指令中。例如 11 和 114504 。
过程

：
1. mov eax, 11 ：将立即数 11 加载到寄存器 eax 中。
2. add eax, 114504 ：将立即数 114504 加到 eax 的当前值上。
3. sub eax, 1 ：将 eax 的值减去立即数 1 。
硬件实现：立即数直接写入指令的操作数字段，CPU 解码指令后直接将值加载到指定寄存器中。

# 4. 寄存器寻址方式

mov ebx, 0x36d      ; 将0x36d赋值给ebx
mov edx, ebx        ; 将ebx的值赋值给edx

解释：

寄存器寻址方式：操作数在寄存器中，CPU 直接对寄存器进行操作。
过程

：
1. mov ebx, 0x36d ：将立即数 0x36d 加载到寄存器 ebx 。
2. mov edx, ebx ：将寄存器 ebx 的值复制到寄存器 edx 。
硬件实现：寄存器之间的数据传递不需要访问内存，速度非常快。

# 5. 直接寻址方式

mov ecx, msg      ; 将msg的地址赋值给ecx

解释：

直接寻址方式：操作数的地址直接给出，即指令中明确指出操作数所在的内存地址。
过程

：
- mov ecx, msg ：将标签 msg 所指向的内存地址加载到寄存器 ecx 。
硬件实现：CPU 将指令中的地址字段直接解析为内存地址，然后取出对应地址的内容。

# 6. 寄存器间接寻址方式

mov esi, msg        ; 将msg的地址赋值给esi
mov eax, [esi]      ; 将esi所指向的地址的值赋值给eax

解释：

寄存器间接寻址方式：寄存器中存储的是操作数的内存地址，操作数存储在该地址中。
过程

：
1. mov esi, msg ：将 msg 的地址加载到寄存器 esi 。
2. mov eax, [esi] ：从 esi 指向的内存地址中读取数据，并存储到寄存器 eax 。
硬件实现

：
- CPU 读取寄存器 esi 的值（作为内存地址）。
- 然后去内存中访问该地址，取出存储的值加载到寄存器 eax 。

# 7. 寄存器相对寻址方式

mov ecx, msg        ; 将msg的地址赋值给ecx
add ecx, 4          ; 将ecx加上4
mov eax, [ecx]      ; 将ecx所指向的地址的值赋值给eax

解释：

寄存器相对寻址方式：寄存器中存储基地址，操作数的地址是基地址加上一个偏移量。
过程

：
1. mov ecx, msg ：将 msg 的地址加载到寄存器 ecx 。
2. add ecx, 4 ：将 ecx 加上偏移量 4 。
3. mov eax, [ecx] ：从 ecx 指向的地址读取数据到寄存器 eax 。
硬件实现

：
- 计算内存地址： ecx + 4 。
- 访问该地址并读取数据。

# 8. 基址变址寻址方式

mov ecx, msg        ; 将msg的地址赋值给ecx
mov edx, 2          ; 将2赋值给edx
mov eax, [ecx + edx*2]  ; 将ecx+edx*2所指向的地址的值赋值给eax

解释：

基址变址寻址方式：地址是基地址加上索引值（ edx ），并根据一个比例因子（如 *2 ）计算得到。
过程

：
1. mov ecx, msg ：加载基地址到寄存器 ecx 。
2. mov edx, 2 ：加载索引值 2 到寄存器 edx 。
3. mov eax, [ecx + edx*2] ：计算地址为 ecx + edx*2 ，然后读取该地址的数据到 eax 。
硬件实现

：
- 地址计算： ecx + edx*2 。
- 访问该内存地址并读取数据。

# 9. 相对基址变址寻址方式

mov ecx, msg        ; 将msg的地址赋值给ecx
mov edx, 1          ; 将1赋值给edx
add ecx, 8          ; 将ecx加上8
mov eax, [ecx + edx*2 - 6]  ; 将ecx+edx*2-6所指向的地址的值赋值给eax

解释：

相对基址变址寻址方式：地址是基地址加索引值乘比例因子再加偏移量。
过程

：
1. mov ecx, msg ：加载基地址到 ecx 。
2. mov edx, 1 ：加载索引值 1 到 edx 。
3. add ecx, 8 ：将偏移量 8 加到 ecx 。
4. mov eax, [ecx + edx*2 - 6] ：计算地址为 ecx + edx*2 - 6 ，然后读取数据到 eax 。
硬件实现

：
- 地址计算： ecx + edx*2 - 6 。
- 访问该地址并读取数据。

# 10. 系统调用（输出字符串）

mov eax, 4          ; 系统调用号4代表输出字符串
mov ebx, 1          ; 文件描述符1代表标准输出
mov ecx, msg        ; 要输出的字符串的地址
mov edx, 22         ; 要输出的字符串的长度
int 0x80            ; 调用系统调用

解释：

过程

：
1. mov eax, 4 ：设置系统调用号为 4 （ sys_write ）。
2. mov ebx, 1 ：文件描述符为 1 （标准输出）。
3. mov ecx, msg ：输出字符串的地址。
4. mov edx, 22 ：字符串的长度。
5. int 0x80 ：触发软中断，调用 Linux 内核的系统调用。
硬件实现

：
- 将参数放入寄存器（ eax , ebx , ecx , edx ）。
- 调用 int 0x80 ，切换到内核模式执行 sys_write 。

# 11. 退出程序

mov eax, 1          ; 系统调用号1代表退出程序
xor ebx, ebx        ; 返回值为0
int 0x80            ; 调用系统调用

解释：

过程

：
1. mov eax, 1 ：设置系统调用号为 1 （ sys_exit ）。
2. xor ebx, ebx ：返回值为 0 。
3. int 0x80 ：触发软中断，调用内核终止程序。

# 总结

寻址方式：
1. 立即寻址：直接在指令中给出操作数。
2. 寄存器寻址：操作数在寄存器中。
3. 直接寻址：操作数的地址直接给出。
4. 间接寻址：通过寄存器指向的地址访问数据。
5. 相对寻址：基址 + 偏移量。
6. 基址变址寻址：基址 + 索引 * 比例因子。
7. 相对基址变址寻址：基址 + 索引 * 比例因子 + 偏移量。
系统调用：
- 使用 int 0x80 切换到内核模式执行特定操作。
这个 int 0x80 有点小关键的，有时候打 shellcode 会用

为啥拖更qwq

Tue, 07 Jan 2025 00:00:00 +0800

期末这几周过的实在是过于炸裂了，又臭又长，寒假大约的确虽然但是也许可能可以保证起码周更

寒假给大家来电 heap exp 和 C 语言笑传啥的干货

让我静静的学网络安全不行吗

为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学为什么我要学法学

我布药挂科啊啊啊啊啊啊啊啊呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜呜

C语言入门知识点&基础思路（三）

Tue, 24 Dec 2024 00:00:00 +0800

All the moves like Jagger

# C 语言哭传（三）

本期开始涉及的知识点，所含知识尽量补多一点，尽量能从一题的角度理解一个点

本期含递归 (tips: 挑战题)，函数指针，今天来点大家想看的东西奥（otto 音

本文或者以后也是，涉及到大模型的回答，均使用 o1/o1-mini 模型或者 claude3.5 模型，我也会重审，基本不会误导大家

来几个填选。题不在多，在精。一道题可能自己做 1 分钟就过了，要求我给别人讲可能就是半小时，但是去研究底层的这半小时远比自己做的一分钟收获的多，收获的深

# 8.15 指针

这个程序就是倒序输出，没什么好说的，主要是拓展的一些东西

答案:

Java

dBase

CLanguage

Pascal

# 思路知识点：

有同学不太熟悉 & 和 * 这两个指针相关基本操作，大概 talk 一下

# `&` 运算符和 `*` 运算符

& 运算符（取地址符）：用于获取变量的内存地址。
int x = 10;
int *ptr = &x; //ptr 指向变量 x 的地址
* 运算符（解引用符）：用于访问指针所指向的内存地址上的值。
int y = *ptr; //y 的值为 x，即 10

& 运算符用于获取变量的地址。

\* 运算符用于解引用指针，访问其指向的值。

# 拓展：

数组名本身不是指针：虽然数组名在某些情况下表现得像指针，但它们在内存中是一个固定的地址，不能像指针变量那样改变指向
不能进行指针运算：你不能对数组名进行指针运算，例如 a + 1 在某些情况下是合法的，但不能改变 a 本身的地址
使用 sizeof(a) 时，得到的是整个数组的大小，而不是指针的大小
sizeof(ptrA) 返回指针的大小（通常是 4 或 8 个字节，取决于系统架构）。
将数组作为函数参数传递时，实际上传递的是指向数组第一个元素的指针
在 C 语言中，数组名（例如整型数组 a[] 或是字符型数组 b[] ）在大多数表达式中会退化为指向数组第一个元素的指针。这意味着在这些上下文中，你可以将数组名当作指针来使用。例如：

	int a[10];
	char b[20];

	int ptrA = a; //a 退化为 int，指向 a [0]
	char ptrB = b; //b 退化为 char，指向 b [0]

防止大家把字符数组初始化，字符串数组们的初始化，也提一下：

# char *a []，char a [] 与 char a [][] (含大模型 o1 的回答)：

声明一：
char *a[] = { "Pascal", "C Language", "dBase", "Java" };
声明二：
char a[] = { "Pascal", "C Language", "dBase", "Java" };
# 分析与解释

# 1. 声明一： char *a[]
类型说明：

这是一个指针数组，即数组中的每个元素都是一个指向 char 类型的指针。

每个指针指向一个字符串字面量（字符串常量）。

内存分配：

数组 a 本身在内存中分配了一组指针（通常在栈上）。

每个字符串字面量（如 "Pascal" ）存储在只读存储区（例如，常量区）中，多个指针指向这些字符串。

可修改性：

指针本身可以修改，即可以让指针指向不同的字符串。

字符串内容通常是只读的，尝试修改会导致未定义行为（通常是程序崩溃）。
示例：
#include <stdio.h>
    
int main() {
    char *a[] = { "Pascal", "C Language", "dBase", "Java" };
    // 访问第一个字符串
    printf("%s\n", a[0]); // 输出: Pascal
    
    // 修改指针，指向另一个字符串
    a[0] = "Python";
    printf("%s\n", a[0]); // 输出: Python
    
    // 尝试修改字符串内容（不推荐，可能导致崩溃）
    //a [0][0] = 'p'; // 未定义行为
    
    return 0;
}
# 2. 声明二： char a[]
类型说明：

这是一个字符数组，即数组中的每个元素都是一个 char 类型的字符。

然而，您的声明尝试用多个字符串字面量初始化一个字符数组，这是不合法的。

问题说明：

在 C 语言中， char a[] = { "Pascal", "C Language", "dBase", "Java" }; 是非法的，因为 char a[] 只能初始化为单个字符串或单个字符数组。

如果您想存储多个字符串，应使用二维字符数组或指针数组。
可能的正确声明：

方式一：二维字符数组
char a[][20] = { "Pascal", "C Language", "dBase", "Java" };
这里， a 是一个二维字符数组，每个子数组最多可以存储 19 个字符（第 20 个字符留给字符串结束符 \0 ）。

方式二：指针数组（与声明一相同）
char *a[] = { "Pascal", "C Language", "dBase", "Java" };
内存分配：

二维字符数组在内存中分配了一个连续的字符块，用于存储所有字符串的字符。

每个字符串的长度需要在声明时指定（如上例中的 20 ），以确保有足够的空间存储字符串和结束符。

可修改性：

字符数组中的字符是可修改的，可以直接更改数组中的字符。

字符串字面量（如果使用指针数组）通常是只读的，无法修改。
示例：二维字符数组
#include <stdio.h>
    
int main() {
    char a[][20] = { "Pascal", "C Language", "dBase", "Java" };
        
    // 访问第一个字符串
    printf("%s\n", a[0]); // 输出: Pascal
    
    // 修改字符内容
    a[0][0] = 'p';
    printf("%s\n", a[0]); // 输出: pascal
    
    return 0;
}
# 主要异同点总结

方面 char *a[] （指针数组） char a[][] （二维字符数组）

类型数组中的每个元素是 char 指针（指向字符串）数组中的每个元素是 char ，整体形成二维数组

内存分配 指针存储在数组中，字符串存储在只读存储区（或堆 / 静态区）所有字符串字符存储在连续的数组内存中

可修改性 指针可修改指向，但字符串内容通常不可修改字符数组中的字符可修改

内存大小 仅存储指针，内存占用较少，但字符串分散存储分配足够的空间存储所有字符，内存占用较大但连续

灵活性 更灵活，可以指向不同长度的字符串需要预先定义每个字符串的最大长度

访问方式 通过指针访问，每个字符串独立通过二维数组下标访问，每个字符串按数组索引排列

字符串长度 每个字符串长度可以不同每个字符串的最大长度固定（由数组声明时指定，如 20 ）

# 选择使用哪种方式

使用指针数组（ char \*a[] ）的情况：

当字符串长度不固定且可能变化时。

当需要指向不同来源的字符串（如动态分配的字符串）。

节省内存，因为只存储指针，而不是为每个字符串预留固定空间。

使用二维字符数组（ char a[][] ）的情况：

当字符串长度相对固定且已知时。

当需要修改字符串内容时。

需要保证所有字符串在内存中连续存储，便于某些操作（如批量处理）。

# 总结

char \*a[] 是一个指针数组，每个元素指向一个字符串字面量，适用于字符串长度不固定且不需要修改内容的场景。

char a[][] 是一个二维字符数组，所有字符串的字符存储在连续的内存中，适用于字符串长度相对固定且需要修改内容的场景。

希望以上解释能帮助您更好地理解这两种声明的异同。如果您有更多问题，欢迎继续提问！

方面	*`char a[]` （指针数组）**	`char a[][]` （二维字符数组）
类型	数组中的每个元素是 `char` 指针（指向字符串）	数组中的每个元素是 `char` ，整体形成二维数组
内存分配	指针存储在数组中，字符串存储在只读存储区（或堆 / 静态区）	所有字符串字符存储在连续的数组内存中
可修改性	指针可修改指向，但字符串内容通常不可修改	字符数组中的字符可修改
内存大小	仅存储指针，内存占用较少，但字符串分散存储	分配足够的空间存储所有字符，内存占用较大但连续
灵活性	更灵活，可以指向不同长度的字符串	需要预先定义每个字符串的最大长度
访问方式	通过指针访问，每个字符串独立	通过二维数组下标访问，每个字符串按数组索引排列
字符串长度	每个字符串长度可以不同	每个字符串的最大长度固定（由数组声明时指定，如 `20` ）

# 8.16 指针

就是

$2^3-2^2$

慢慢来，主函数传参后，f1 指向 fa，f2 指向 fb，也就是 f 调用的 fa 和 fb，fa 就是乘方 fb 就是立方。用的是函数指针而已

# 函数指针

	#include <stdio.h>
	// 定义函数 fa，计算 x 的平方
	int fa(int x)
	{
	return (x * x);
	}
	// 定义函数 fb，计算 x 的立方
	int fb(int x)
	{
	return (x * x * x);
	}
	// 定义函数 f，接受两个函数指针 f1 和 f2，以及一个整数 x
	// 它调用 f2 (x) 减去 f1 (x) 的结果
	int f(int (f1)(int), int (f2)(int), int x)
	{
	return (f2(x) - f1(x));
	}
	int main()
	{
	int i;
	// 调用函数 f，将 fa 和 fb 作为参数传递，并传入 x=2
	i = f(fa, fb, 2);
	printf("%d", i); // 输出结果
	return 0;
	}

# 主要概念

函数指针的声明
int (*f1)(int)
- 解释：
  - int ：表示函数返回类型为 int 。
  - (*f1) ： f1 是一个指针，指向一个函数。
  - (int) ：表示这个函数接受一个 int 类型的参数。
- 整体含义： f1 是一个指向接受一个 int 参数并返回 int 的函数的指针。
函数指针的使用

在函数 f 中， f1 和 f2 都是函数指针，分别指向不同的函数（ fa 和 fb ）。通过这些指针， f 函数可以调用传入的函数并执行相应的操作。
return (f2(x) - f1(x));
- 这里， f2(x) 调用了指针 f2 所指向的函数（即 fb(x) ），
- f1(x) 调用了指针 f1 所指向的函数（即 fa(x) ）。
- 最终返回 fb(x) - fa(x) 的结果。
在 main 函数中传递函数指针
i = f(fa, fb, 2);
- 这里， fa 和 fb 作为参数传递给函数 f 。由于 fa 和 fb 本身就是函数的名称，在这种上下文中，它们会自动转换为指向这些函数的指针。

# 拓展：函数指针的优势（含 o1 模型回答）

回调函数：

函数指针允许将函数作为参数传递，从而实现回调机制。这在实现事件驱动编程或需要在不同情况下执行不同操作时非常有用。

	void execute(int (*func)(int), int x) {
	printf("Result: %d\n", func(x));
	}

	int main() {
	execute(fa, 5); // 对于被调函数来说，传入了 fa 给指针 func，func 指向了 fa，所以就是调用 fa (5)
	execute(fb, 3); // 调用 fb (3)
	return 0;
	}

动态函数调用：

根据程序的运行状态，可以动态选择要调用的函数。

	int (*operation)(int);// 注意，现在是在主函数里，直接定义一个指针，函数指针

	if (condition) {
	operation = fa;
	} else {
	operation = fb;
	}

	int result = operation(4);// 已经有了指向的对象，加个参数即可调用

构建函数表：

可以将多个函数指针存储在数组中，方便管理和调用。

	int (*functions[2])(int) = {fa, fb};

	for(int i = 0; i < 2; i++) {
	printf("Result: %d\n", functions[i](2));// 你看懂了吗？~
	}

# 再补两句

函数指针的类型必须匹配：

声明函数指针时，返回类型和参数类型必须与所指向的函数完全一致，否则会导致未定义行为。
函数指针的声明语法可能有些复杂，尤其是在函数指针作为参数或返回值时。

可以使用 typedef 简化声明。
typedef int (*func_ptr)(int);
int f(func_ptr f1, func_ptr f2, int x) {
return f2(x) - f1(x);
}

# 8.17 指针

fun 函数典型的互换操作，同时初具递归雏形（大约的确不算递归）

整体函数所做的事情非常简单，单纯的逆序对调罢了

答案是 8162

做个递归吧

# 挑战：8.13 递归

涉及了第一章讲过的取位操作，可以去复习一下

此外， +'0' ：将数字转换为对应的字符。例如， 3 + '0' 结果是字符 '3' 。

递归在计算机里算是一个比较经典的玩法了，比较考验人类的思维。

# 递归函数解析

递归函数通常包括两个主要部分：

基准情况（Base Case）： 确定递归何时停止。
递归情况（Recursive Case）： 函数调用自身，以逐步逼近基准情况。

在本题中：

基准情况： 当 n / 10 等于 0 时，表示已经处理到最低位的数字，不再需要递归。
递归情况： 当 n / 10 不等于 0 时，继续处理更高位的数字。

先说一下答案:a+1 、n%10+'0' , 也就是还没到最后一位的时候指针向前就是空 1, 再加一个基本的取位操作就是空 2

难点在于理解递归

其实对我本人来说，递归的难点在于递归完成之后的事情和递归的编写，就比如这道题，递归结束后的回溯花了我一定时间去理解。我也很久没摸递归了

以下的话可能有点抽象需要去理解

# 递归

if 触发之后，调用自身，但是本次主调函数还是没执行完的，又不是循环的 break, 也就是不管被调函数递归了多少轮，主调函数终究会执行最后一句 * a = ___ 当出现了第一个执行完毕，不会调用函数的被调函数后，触发了基准情况

现在，通过 (o1), 让我们一步一步地看这个递归函数是如何工作的。

# 初始调用： `convert(a, 483)`

参数：
- a 指向字符数组的起始位置（即 a[0] ）。
- n = 483
执行步骤：
1. 计算 i = 483 / 10 = 48 （整除）。
2. 因为 48 != 0 ，所以递归调用 convert(a + 1, 48) 。

# 第一次递归调用： `convert(a + 1, 48)`

参数：
- a + 1 指向数组的下一个位置（即 a[1] ）。
- n = 48
执行步骤：
1. 计算 i = 48 / 10 = 4 。
2. 因为 4 != 0 ，所以递归调用 convert(a + 2, 4) 。

# 第二次递归调用： `convert(a + 2, 4)`

参数：
- a + 2 指向数组的下一个位置（即 a[2] ）。
- n = 4
执行步骤：
1. 计算 i = 4 / 10 = 0 。
2. 因为 0 == 0 ，不再递归，直接执行 *a = (4 % 10) + '0' = '4' ，即 a[2] = '4' 。

注意， 此处将开始回溯

# 回到第一次递归调用： `convert(a + 1, 48)`

现在继续执行之前的调用
- 执行 *a = (48 % 10) + '0' = '8' ，即 a[1] = '8' 。

此处的理解就是，对于第二次那次 convert 的执行，a 相对于最后一次还是 a+1, 被传入的 n 是上一次的 i 也就是最开始的那个 n/10, 即 48, 直接执行取末尾的操作即可

# 回到初始调用： `convert(a, 483)`

继续执行之前的调用
- 执行 *a = (483 % 10) + '0' = '3' ，即 a[0] = '3' 。

此处的理解就是，对于本次 convert 的执行，a 就是字符数组的开始，直接执行取末位的操作即可

# 总结:

调用层级	参数 `a` 指向的位置	参数 `n`	执行操作	赋值结果
初始调用	`a[0]`	`483`	递归调用 `convert(a+1, 48)`	-
第一次递归调用	`a[1]`	`48`	递归调用 `convert(a+2, 4)`	-
第二次递归调用	`a[2]`	`4`	赋值 `a[2] = '4'`	`a[2] = '4'`
回到第一次递归	`a[1]`	`48`	赋值 `a[1] = '8'`	`a[1] = '8'`
回到初始调用	`a[0]`	`483`	赋值 `a[0] = '3'`	`a[0] = '3'`

	convert(a, 483)
	│
	└── convert(a+1, 48)
	│
	└── convert(a+2, 4)
	├── 赋值 a[2] = '4'
	└── 返回到 convert(a+1, 48)
	├── 赋值 a[1] = '8'
	└── 返回到 convert(a, 483)
	├── 赋值 a[0] = '3'
	└── 返回到 main(此题没有)

# 拓展：递归调用栈 (入门者选择性阅读此段)

递归函数通过函数调用栈（Call Stack）来管理函数调用和返回。每一次递归调用都会在调用栈上创建一个新的栈帧，用于保存该调用的局部变量和返回地址。

# 示例：将 483 转换为 "384"

初始调用： convert(a, 483)

第一次递归： convert(a + 1, 48)

第二次递归： convert(a + 2, 4)

递归终止：不再递归，赋值 '4' 到 a[2]

返回到第二次调用：赋值 '8' 到 a[1]

返回到初始调用：赋值 '3' 到 a[0]

主函数：添加 '\0' ，完成字符串

#

# 1. 初始调用： convert(a, 483)
参数：

a 指向字符数组的起始位置（ a[0] ）。

n = 483

执行步骤：

计算 i = 483 / 10 = 48

因为 48 != 0 ，所以递归调用 convert(a + 1, 48)
调用栈：
[convert(a, 483)]
# 2. 第一次递归调用： convert(a + 1, 48)
参数：

a + 1 指向数组的第二个位置（ a[1] ）。

n = 48

执行步骤：

计算 i = 48 / 10 = 4

因为 4 != 0 ，所以递归调用 convert(a + 2, 4)
调用栈：
[convert(a, 483)]
[convert(a + 1, 48)]
# 3. 第二次递归调用： convert(a + 2, 4)
参数：

a + 2 指向数组的第三个位置（ a[2] ）。

n = 4

执行步骤：

计算 i = 4 / 10 = 0

因为 0 == 0 ，不再递归，直接赋值 *a = '4' （ a[2] = '4' ）
调用栈：
[convert(a, 483)]
[convert(a + 1, 48)]
[convert(a + 2, 4)]
赋值结果：

a[2] = '4'
# 4. 递归返回：返回到第一次递归调用
完成 convert(a + 2, 4) 后：

执行 *a = (48 % 10) + '0' = '8' （ a[1] = '8' ）
调用栈：
[convert(a, 483)]
[convert(a + 1, 48)]
赋值结果：

a[1] = '8'
# 5. 递归返回：返回到初始调用
完成 convert(a + 1, 48) 后：

执行 *a = (483 % 10) + '0' = '3' （ a[0] = '3' ）
调用栈：
[convert(a, 483)]
赋值结果：

a[0] = '3'
# 可视化调用栈

为了更直观地理解，让我们用图示表示递归调用和返回过程。
调用栈顶部
┌────────────────────┐
│ convert(a + 2, 4)  │
│ 执行 *a = '4'      │
└────────────────────┘
      返回
┌────────────────────┐
│ convert(a + 1, 48) │
│ 执行 *a = '8'      │
└────────────────────┘
      返回
┌────────────────────┐
│ convert(a, 483)     │
│ 执行 *a = '3'      │
└────────────────────┘
      返回
每一次递归调用都会在栈上新增一个栈帧（函数调用的上下文），当一个调用完成后，控制权自动返回到上一个栈帧的位置，继续执行后续的代码。

有时间细说这个递归

先到这吧，4 道题花一上午，效率越来越低了，来两道数学去了。递归有点说法的，下个坑考虑开递归

安装一个‘小’工具有点想跟powershell爆了

Tue, 24 Dec 2024 00:00:00 +0800

昨天戴✌分享了一个非常好玩的终端命令修补工具

安装的时候我真的是 fuck 了有点麻烦，尤其是最后用在 powershell 的时候

由此引入一下修改 $PROFILE 文件和 PowerShell 中的配置吧

# 修改 `$PROFILE` 文件

是 PowerShell 中的一种配置方法，用于在启动 PowerShell 会话时自动执行某些命令或定义函数。这个文件相当于一个 PowerShell 会话的启动脚本，可以用来设置环境变量、定义函数、别名、导入模块等。

# `$PROFILE` 文件的原理

在 PowerShell 中， $PROFILE 是一个特殊的自动变量，指向 PowerShell 配置文件的路径。该文件在每次启动 PowerShell 会话时被自动执行，通常用于配置用户偏好和初始化一些常用的设置。

# 具体解释

路径： $PROFILE 变量指向的是当前用户的 PowerShell 配置文件路径。你可以通过以下命令查看 $PROFILE 的内容：
$PROFILE
对于大多数用户，默认路径通常是：
- Windows: C:\Users\<YourUsername>\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1
- Linux/macOS: ~/.config/powershell/profile.ps1
功能：在 $PROFILE 文件中，PowerShell 会加载其中定义的命令和配置。例如，你可以在文件中加入以下内容：
1. 定义函数：在 $PROFILE 文件中，你可以定义你常用的 PowerShell 函数，这些函数会在每次启动 PowerShell 会话时自动可用。例如：
  function greet {
  Write-Host "Hello, $args"
  }
  每次启动 PowerShell 后， greet 函数就可以立即使用。
2. 设置别名：你还可以在 $PROFILE 中定义别名，使得长命令可以简化。例如：
  Set-Alias ll Get-ChildItem
  这样，在 PowerShell 中使用 ll 就等同于使用 Get-ChildItem 命令。
3. 自动加载模块：在 $PROFILE 中定义常用模块的导入命令。比如：
  Import-Module posh-git
4. 配置环境变量：可以在 $PROFILE 文件中配置特定的环境变量或调整系统设置。例如：
  $env:PATH += ";C:\Program Files\MyTools"
如何被加载：每次启动一个新的 PowerShell 会话时，系统会自动加载 $PROFILE 文件中的所有内容，执行其中的命令。

# `$PROFILE` 文件的种类

PowerShell 有多种类型的 $PROFILE 文件，取决于你是在全局范围还是仅在当前用户会话中进行配置。

当前用户的 PowerShell 配置文件：

这个文件只影响当前用户的 PowerShell 会话。通常路径是：
- Windows: C:\Users\<YourUsername>\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1
- Linux/macOS: ~/.config/powershell/profile.ps1
你可以通过以下命令查看当前用户配置文件的路径：
$PROFILE
全局 PowerShell 配置文件：

如果你希望影响所有用户（管理员级别），可以编辑系统范围内的 $PROFILE 文件。路径通常是：
- Windows: C:\Program Files\WindowsPowerShell\Microsoft.PowerShell_profile.ps1
- Linux/macOS: /etc/powershell/profile.ps1
你可以通过以下命令查看系统范围内配置文件的路径：
$PROFILE.AllUsersCurrentHost
特定主机的 PowerShell 配置文件：

除了全局和用户配置文件，还有针对特定主机的配置文件。例如，你可以为 PowerShell ISE 定义一个单独的配置文件。不同主机的路径如下：
- Windows PowerShell： $PROFILE.AllUsersCurrentHost
- PowerShell ISE： $PROFILE.AllUsersISEHost
这些配置文件允许你根据不同的使用场景配置 PowerShell 环境。

# 修改 `$PROFILE` 文件的目的

此情况，修改 $PROFILE 文件的目的是让 PowerShell 会话在启动时自动定义 fuck 函数。

因为 fuck 函数是 pip 安装的，得手动配

这样，就可以在 PowerShell 中通过输入 fuck 来调用 thefuck ，而不需要每次都手动配置。

当把 Invoke-Expression (& thefuck --alias) 这样的命令添加到 $PROFILE 中时，PowerShell 在启动时会自动执行该命令，创建 fuck 函数，从而使你可以在会话中使用该命令。

但是，由于在我的环境下，直接在 $PROFILE 文件中运行 thefuck --alias 可能会导致问题（如 Invoke-Expression 错误），所以我们通常建议手动将输出的函数定义复制到 $PROFILE 中，而不是直接执行 thefuck --alias 命令。这种方法更加稳定，避免了潜在的错误。

# 总结

$PROFILE 文件 是一个 PowerShell 配置文件，用于在启动 PowerShell 会话时自动执行一些命令或配置，通常用于定义函数、别名、模块加载等。
修改 $PROFILE 文件 可以使一些常用功能在每次启动 PowerShell 时自动生效，避免每次手动配置。
敲一个 fuck 就能让你的 bash 或者 shell 麻溜改命令，好玩捏

公告栏

Mon, 23 Dec 2024 00:00:00 +0800

# welcome to my cyber world！

# 公告栏

当前版本：v1.20 2026-04-10

2026-04-10 v1.20 新增功能

近期恢复更新，同时搞了一个腾讯云服务器，现在可以从下面两个 url 访问本 blog：
http://152.136.170.39/ 腾讯云服务器，国内访问较快，请不要进行攻击因为腾讯会给我发短信 qwq

或

https://0d0-1yp0.github.io/

已修复问题：

修复了网页偶现不显示中文而是英文的 bug，现在绝大多数情况下正常显示中文。

已知问题:

网页更新在推送后，有缓存的用户不刷新无法获取最新网页，或者需要多次刷新，同时，正常来讲文章封面是随机可刷新的，但由于网页缓存一般在体验上是固定的，正在想办法

支付宝的魂灵经常飘荡在微信赞赏上方，我服了马跌

版本预告：

即将加入音乐播放器。

暂时不会开放评论区，某师傅说要给我打 xss 我害怕

往期版本，问题修复见公告最下方，有需要建站的可以参考可能出现的问题然后修一修

欢迎各位，希望大家都能坚持下去。。。！

本 blog 仅用于技术分享，暂不开放评论区。转载请遵守相关法律法规 ==

！！！任何文章涉及侵权请联系本人，本人将在 24 小时内立刻删除！！！

可以反馈体验或 bug

转载请标出处，目前只在 CSDN 搬自己的文章

https://blog.csdn.net/2201_75506722?type=blog

其他地方见到均为盗版，帮点举报，感谢您的帮助

欢迎分享与收藏

20241222：另，冬至日快乐，两年没在今天吃饺子啦，希望明年大任务完成能更好点吧

建这个站很累但是真的很值得

20260410：大任务大失败，我完蛋啦

D's odyssey 26/04/10

# 往期问题修复 & 版本优化

2024-12-24 v1.12 热补丁修复

现已修复长文章出现图片丢失无法显示的情况（改动了一处 js 文件，可能造成性能略微损失，以后过长的文章会分 P）

2024-12-23 v1.11 热补丁修改

修复了公告里的一处错别字（？）
由于支付宝实名显示规则暂仅开放微信充电，感谢您的一片热心，心意领了～顺便相当于修复了支付宝赞赏码过丑的问题和手机端赞赏偶现 bug 的问题（？）

2024-12-22 v1.01 热补丁修改

修复了腾讯云 COS 存储桶因为我欠了三分钱当场给我图片毙了 35 小时还没给我发短信的严重 BUG（？）

# 往期大版本更新

大版本更新：v1.10 2024-12-22

现在文章封面除了我的随机图库，还可以自定义了
新增打赏充电功能
标签，分类功能上线，便于各位审计自己需要的东西

大版本更新：v1.00 2024-12-20

打造了五天五夜的站闪耀登场！
可以拉到最下方查看本站存活时间以及访问量哦～

C语言入门知识点&基础思路（二）

Mon, 23 Dec 2024 00:00:00 +0800

tips：本期有挑战题

你我不曾感受过

# C 语言笑传又来了说是

最近用了 copilot，真不是一般的小机灵鬼，感觉被狠狠监视了

你坝还啥也没写呢，先给我猜出来了

练题还是把它老人家闭了吧，否则手写代码的时候直接变小丑

上题！

注意，以下答案仅供参考，指针这部分我也还在学习中，答案对了也可能不代表规范性适合严格的考试！

# 6.7 字符串

我说我本来想学指针，结果突然发现字符串忘没了于是滚回去复习有人信吗哈哈哈哈哈哈哈

此题注意事项：

博主脑子有点不灵活，先不上链表动态内存之类的高级操作，先用大数组苟分，后面再试高级操作（挖坑）
打 pwn 后遗症犯了总想来点阴的
同学，你的思路是什么？我的思路不一定就适合你哦

# 思路知识点：

scanf ("% s") 遇到空格就会停止读取，不会读入空格，在读取字符串时会自动在末尾添加 '\0' 结束符（可以想象 scanf 格式化字符串的本质）
gets (): 会自动添加 '\0', 但不安全，已废弃（但也许考试的话是可以用的）
如果要处理带空格的字符串输入，更推荐用 fgets ()（但也许考试的话是没必要的）

	char word[1000];
	fgets(word, sizeof(word), stdin);

strlen () 不会把 '\0' 计算在内，它只计算到 '\0' 之前的字符个数，比如 "hello" 的 strlen () 结果是 5，但是 '\0' 确实会占用数组的一个位置 (word [5])。

	char word[1000];
	scanf("%s", word);

	word[0] = 'h'
	word[1] = 'e'
	word[2] = 'l'
	word[3] = 'l'
	word[4] = 'o'
	word[5] = '\0' //scanf 自动添加的结束符

回车键 (\n) 不会被 scanf ("% s") 存储，如果用 fgets ()，回车符会被存储，并且 '\0' 会在回车符之后

是的我刚才拿 scanf 搓半天才发现自己是人机，阴 4 你 8 了

上 wp！！

	#include<stdio.h>
	#include<string.h>
	int main()
	{
	char word[1000];
	int num=0,i;
	fgets(word,1000,stdin);// 别忘了，假设用 scanf 的话，字符串变量名本身就是个指针，不要加取地址符
	for(i=0;i<strlen(word);i++) if(word[i] == ' ') num++;
	num++;// 最后一个词算上
	printf("%d",num);
	return 0;
	}

~~<u> 好了我们可以去干一把指针了 </u>~~

# 挑战：8.7 字符变换

真成笑传了，西八

# 思路知识点：

ASCII 中，32 是空格也就是上文的‘ ’，0-9 是 48-57，A-Z 是 65-90，a-z 是 97-122，也就是大写加 32 就是小写
这个挑战只是题干长，我们用心想想是可以秒的。可以回看上面字符串在内存里的存储，可能可以更直观一点
首尾相连考虑 strcat，注意它会干掉第一个 \0

char *strcat(char *dest, const char *src);

指针的基本知识要牢牢掌握，另外要理解字符和数字的变换
思路上没有太复杂的东西，一定要注意 * 和 & 的运用，以及字符串变量名指针的本质

此题注意事项：

此题主要是指针部分比较难，可以对着源码回忆，想想如果是你你会怎么做
~~好好读题，不要看见长题干就不想做，啊对我说的就是我自己~~
由于函数传虚参实参规则，拿指针打会更稳

我们先一步一步来，以下是我个人解题过程中进行的尝试

对，都来看我没了 copilot 后的铸币操作吧哈哈哈哈哈哈哈我真得不想活辣！！

# 解题过程（最终答案在最后面）:

	#include<stdio.h>
	#include<string.h>
	#include<stdlib.h>
	int lens=0;
	void StringCode(char a,char b)
	{
	char c[200];
	c[0]='\0';
	strcat(c,a);
	strcat(c,a);// 首尾相连完成了，暂时存在 c 里，其实就是为了方便第 slen/2 以后的字符
	for(int i=0;i<lens;i++)// 开始遍历了
	{
	if((c+i)-(c+i+(lens/2)) <'a')
	{
	while ((c+i)<'a') (c+i)=*(c+i)+26;
	}
	else if ((c+i)-(c+i+(lens/2)) >'z')
	{
	while ((c+i)>'z') (c+i)=*(c+i)-26;
	}

	}
	*(c+lens)='\0';
	printf("source=%s",c);// 手动截断
	}

	int main()
	{
	char a[100],b[100];
	scanf("%s",a);
	lens=strlen(a);
	StringCode(a,b);
	// printf ("原字符串 =% s\n 新字符串 =% s",a,b);
	// printf("source=%s",a);
	return 0;
	}

以下是个人独白，各位低血压可以看看。其实写到这里就差一句话就成功了，可惜后面越改越偏：

先到这里。输入 Weihua，得到的结果是 source=qeihua

也就是 W 正常变了，其他的还没变，迈出了第一步。理论是可行的

但是，为什么别的没有变呢？？？

在第 10 行后加入 printf ("source=% s\n",c);，发现结果是

source=WeihuaWeihua
source=qeihua

字符串正常拼接了。再把 i 全都打印发现确实已经循环过五次了，手动加的截断点也是正常的

岂有此理？

先把 a 和 b 加上吧，先不调试了，

等等。。。。？？？？

渐渐的写入迷了，导致忘记了题目，接下来半小时越改越偏

最后突然发现，WTF 不对啊，我要打的不是差值吗，这给我干哪来了

有时候就感觉这脑子里面装的是一坨

好了，没啥想说的了已经，上最终 wp

	#include<stdio.h>
	#include<string.h>
	#include<stdlib.h>
	int lens=0;
	void StringCode(char a,char b)
	{
	char c[200];
	c[0]='\0';
	strcat(c,a);
	strcat(c,a);// 首尾相连完成了，暂时存在 c 里，其实就是为了方便第 slen/2 以后的字符
	for (int i = 0; i < lens; i++) (c+i)=(c+i)-*(c+i+(lens/2));
	for(int i=0;i<lens;i++)// 开始遍历了
	{
	if((c+i) <'a') while ((c+i)<'a') (c+i)=(c+i)+26;
	if ((c+i) >'z') while ((c+i)>'z') (c+i)=(c+i)-26;
	(b+i)=(c+i);
	}
	*(b+lens)='\0';
	}

	int main()
	{
	char a[100],b[100];
	scanf("%s",a);
	lens=strlen(a);
	StringCode(a,b);
	printf("old=%s\nnew=%s",a,b);
	return 0;
	}

AI 依赖有时候真的会导致搓代码搓一半开始自嗨了，唉

今天就先做到这吧，已经铸币了

不懂的可以到 csdn dd 我，我看到后一定第一时间尽力解答

挖了但是还没填的坑呜呜呜

Mon, 23 Dec 2024 00:00:00 +0800

挖了 copilot 教学的坑
挖了 2020 网鼎逆向复盘的坑
挖了 sagemath 命令行教学的坑

# 哈哈哈哈哈哈哈，自己挖坑自己跳了说是

以一道CTF题真正初识RSA

Sun, 22 Dec 2024 00:00:00 +0800

给我的 crypto 入个门，入个门被数学✌薄纱

本文借 (chao) 鉴 (xi) 了鄙校北神上课用的用例，希望明年上课的师弟搜到这个文章不会影响佬师上课啊哈哈哈 ww

开始前可以看一眼 RSA 的基本原理，本文不会提到很深

~~数学不好，密码还是太难了，一个字都看不懂哈哈哈哈哈哈哈~~

先用一个入门的 pip 包吧

pip install pycryptodome

开始，根据一道 CTF 题慢慢来

# 先改一下 flag 以调通 newcomer.py 代码

题目：初识 RSA
来源：XSCTF 新人选拔赛
描述：p 和 q 藏起来了，你能帮我找到它们吗？

我找个 damn

	from Crypto.Util.number import bytes_to_long,inverse,getPrime
	from flag import flag

	m = bytes_to_long(flag)

	p = getPrime(1024)
	q = getPrime(1024)
	n = p*q
	print(n)
	e = 65537

	c = pow(m,e,n)

	pq = p*(q-1)
	qp = q*(p-1)

	print("c=",c)
	print("n=",n)
	print("pq=",pq)
	print("qp=",qp)

	'''
	c= 8722269075970644434253339592758512788160408912707387632591552130175707843950684315083250494010055435391879036285103810263591951437829414438640307561645721347859659807138051841516634704123100270651976676182059252251162982609391666023674158274992400910869692389001622774140191223807887675081808561012755545464977015973615407965906513878979919700065923364884766974187303774330319143647840846354404070430118235352622445115153298578370521811697710289716188726587743282814946239856766713516166990341116198180068191759095913957606379780234116317390622824096667107736103270907349927467971817639795094030622157581511033950777
	n= 10466186506773626671397261081802640650185744558208505628349249045496105597268556020207175016523119333667851114848452038431498926527983706092607207796937431312520131882751891731564121558651246025754915145600686076505962750195353958781726515647847167067621799990588328894365930423844435964506372428647802381074584935050067254029262890188260006596141011807724688556673520261743199388391094490191001701011230322653422314758778116196105077883955436582364267530633358016652912054880813710531145973799193443828969535902856467548523653920307742364119002349899553478815101092655897400295925170383678499125295006364960124859003
	pq= 10466186506773626671397261081802640650185744558208505628349249045496105597268556020207175016523119333667851114848452038431498926527983706092607207796937431312520131882751891731564121558651246025754915145600686076505962750195353958781726515647847167067621799990588328894365930423844435964506372428647802381074488896197029704465200125337817646702009123916866455067019234171839614862660036737875747177391796376553159880972782837853473250804807544086701088829096838316550146794766718580877976153967582795248676367265069623900208276878140709691073369415161936376086988069213820933152601453587292943483693378833664901178324
	qp= 10466186506773626671397261081802640650185744558208505628349249045496105597268556020207175016523119333667851114848452038431498926527983706092607207796937431312520131882751891731564121558651246025754915145600686076505962750195353958781726515647847167067621799990588328894365930423844435964506372428647802381074475956379708898904933143429835002718457573266164923043251954374464149976302585916538814746811455883837138715445492053610047383292461097590195481556557381952895539341802954749542143253491617052100969586396996063822508764438280468492894012685918249843558593322831683872737943676955669923498182824352081785243246
	'''

原题是引入的 flag 文件，把那行注释掉，下面加一行自己写的 flag 就行，记得用 b 包裹

# 用自己的语言写出 RSA 公钥和私钥的计算公式（使用 p，q，phi，n，e，d 为符号）

设 p，q 为大质数，n=pq

phi=(p-1)(q-1)

根据欧拉函数，phi=(p-1)(q-1)，此部分的证明可以搜一下或者问问强大的大语言模型

e=65537 (公钥指数，任意小于 phi 并与其互质的即可)

d=inverse (e,phi)(私钥指数)

inverse 在库里带了，求逆元的意思

公钥对即为 e，n；私钥对即为 d，n

# 利用题目下方注释中的已知变量计算 phi，并利用 inverse 函数编程计算 e 在模 phi 意义下的乘法逆元，记为 d，根据程序运行结果写出 d 的具体数值；

别想太多，n=p*q，那么极其显然

phi 就是 pqqp/n（别把这里面的 pq 理解成 p * q，看上面的 python 代码哦同学）

（请忽略我的背景柚子厨怎么你了 wwwwwww）

sagemath 命令行还有一些常用的东西，可以看我其他的文章（挖坑）

你算对了吗？

phi=(pq*qp) //n，这句话如果用单 / 会报 OverflowError: integer division result too large for a float。是除法运算导致的类型溢出，用双 // 即可。

单 / 就是执行浮点数除法，即普通的除法操作，双 // 就是执行整数除法，即地板除法

# 根据下列给出的 p、q、e，根据 RSA 算法编程计算公钥 n 与私钥 d；

p=173747400775037237499119138628710917207976935718394035613063219109153197713240288497094852951328821120301146137416392125632164384666157952079993477037237778043103278877799120982366215399159107746276881271883220494577745511406216675640773966244559596835970378099355485746784486359013819361014997811485589135463

q=131816585373639721213952582957741137275970828607414189698553233434142961482639192734668517311468596205692079539001403643395543816907261944034422413069781755026864643651448329100659792941632674865761952547883089120086825249692433942528976412805682521697534499714513072333159601382118300897685368738513700813533

e=65537

没什么好说的，建议同学们先自己做一下在对答案，错了回去看看上面的

n=22902789087710692282201627723972920087676945775651369909558749681603601877066490004280829887082860024866325792922333359888979450409785852136285331867214311784932513053946349686873084098919921626735642656688483918867105990444133292660146552582773030563402978424369091489168537829677450378086515187008083500599611600232061376101775199885242634728744796816625633726726074004731386467983188726961022911791843528459801349329514692878947844318287016330210241002676592845651108656701768277324789376390295075009358573926461653230171198186299924562887630088294834319717425915382663997302617669638278141644149065887129240620779

d=19271863372140646463624718313226644858249851666842334809381515307252297674818586817615620577428910108660806391844117335212132837202625393102518076757881313639679468046843452495262065227324059965356828746942945552493466195508226172853946655099900580076597708945613657755972616318922476707819049590581423940789934387916037469210407055279325381173039093072419831193470910945428027164177392052950722125466565541460489747701257832749756103367996775905993293368370146016279539314698750416709668194421867922941773222876602958853233196249715041186342934713607756322667953880385223035641130659335671630397231173571336884350777

# 利用上述公钥 n、e 对你名字全拼（如：liuyangfan）进行加密

	from Crypto.Util.number import bytes_to_long,inverse,getPrime,long_to_bytes
	# #from flag import flag

	flag=b'flag coming~'

	m = bytes_to_long(flag)


	p=173747400775037237499119138628710917207976935718394035613063219109153197713240288497094852951328821120301146137416392125632164384666157952079993477037237778043103278877799120982366215399159107746276881271883220494577745511406216675640773966244559596835970378099355485746784486359013819361014997811485589135463
	q=131816585373639721213952582957741137275970828607414189698553233434142961482639192734668517311468596205692079539001403643395543816907261944034422413069781755026864643651448329100659792941632674865761952547883089120086825249692433942528976412805682521697534499714513072333159601382118300897685368738513700813533
	e=65537
	n=22902789087710692282201627723972920087676945775651369909558749681603601877066490004280829887082860024866325792922333359888979450409785852136285331867214311784932513053946349686873084098919921626735642656688483918867105990444133292660146552582773030563402978424369091489168537829677450378086515187008083500599611600232061376101775199885242634728744796816625633726726074004731386467983188726961022911791843528459801349329514692878947844318287016330210241002676592845651108656701768277324789376390295075009358573926461653230171198186299924562887630088294834319717425915382663997302617669638278141644149065887129240620779
	d=19271863372140646463624718313226644858249851666842334809381515307252297674818586817615620577428910108660806391844117335212132837202625393102518076757881313639679468046843452495262065227324059965356828746942945552493466195508226172853946655099900580076597708945613657755972616318922476707819049590581423940789934387916037469210407055279325381173039093072419831193470910945428027164177392052950722125466565541460489747701257832749756103367996775905993293368370146016279539314698750416709668194421867922941773222876602958853233196249715041186342934713607756322667953880385223035641130659335671630397231173571336884350777

	c = pow(m,e,n)
	print("c=",c)

豪丸，哈哈

# 利用上述私钥 d，将下列密文 c 解密为明文（用 long_to_bytes 转为字节码打印）

c=22383445933736798279478032679517743837766449187698865398822423786317612396771654040156586654564003392384975014045643201026069165276350584034120841617657486555798948939049343900381125798000000172357016404870066390095970211708364996514629691512019106870733929516372325207940525326467947232996619729431748024769431567208774806188872803942768881324395058229038610826245541466028073553184615680354118655959979504640632739098044460639023736294401801478667944983999124796530293982085703611284581213900570723479615642643430713949661089128106079384524944632103663244376051089098793845750645708721359256022997797080498949228931

	from Crypto.Util.number import bytes_to_long,inverse,getPrime,long_to_bytes
	# #from flag import flag

	p=173747400775037237499119138628710917207976935718394035613063219109153197713240288497094852951328821120301146137416392125632164384666157952079993477037237778043103278877799120982366215399159107746276881271883220494577745511406216675640773966244559596835970378099355485746784486359013819361014997811485589135463
	q=131816585373639721213952582957741137275970828607414189698553233434142961482639192734668517311468596205692079539001403643395543816907261944034422413069781755026864643651448329100659792941632674865761952547883089120086825249692433942528976412805682521697534499714513072333159601382118300897685368738513700813533
	e=65537
	n=22902789087710692282201627723972920087676945775651369909558749681603601877066490004280829887082860024866325792922333359888979450409785852136285331867214311784932513053946349686873084098919921626735642656688483918867105990444133292660146552582773030563402978424369091489168537829677450378086515187008083500599611600232061376101775199885242634728744796816625633726726074004731386467983188726961022911791843528459801349329514692878947844318287016330210241002676592845651108656701768277324789376390295075009358573926461653230171198186299924562887630088294834319717425915382663997302617669638278141644149065887129240620779
	d=19271863372140646463624718313226644858249851666842334809381515307252297674818586817615620577428910108660806391844117335212132837202625393102518076757881313639679468046843452495262065227324059965356828746942945552493466195508226172853946655099900580076597708945613657755972616318922476707819049590581423940789934387916037469210407055279325381173039093072419831193470910945428027164177392052950722125466565541460489747701257832749756103367996775905993293368370146016279539314698750416709668194421867922941773222876602958853233196249715041186342934713607756322667953880385223035641130659335671630397231173571336884350777
	c = 22383445933736798279478032679517743837766449187698865398822423786317612396771654040156586654564003392384975014045643201026069165276350584034120841617657486555798948939049343900381125798000000172357016404870066390095970211708364996514629691512019106870733929516372325207940525326467947232996619729431748024769431567208774806188872803942768881324395058229038610826245541466028073553184615680354118655959979504640632739098044460639023736294401801478667944983999124796530293982085703611284581213900570723479615642643430713949661089128106079384524944632103663244376051089098793845750645708721359256022997797080498949228931
	pq = p*(q-1)
	qp = q*(p-1)
	phi=(pq*qp) //n
	d=inverse(e,phi)
	c=pow(c,d,n)

	print(long_to_bytes(c))

当然，flag 没变哦，答案还是 “flag coming~”

豪丸，当然，碰到几个难题就老实了

C语言入门知识点&基础思路（一）

Fri, 20 Dec 2024 00:00:00 +0800

giants

# C 语言笑传之猜猜背（一）

半年没碰 c 语言入门题，已成咸鱼矣

遂，have a try

古语有云，c 语言入门必刷青览，古语有云，难度不如 OI 一根

我又不如青览一根，何如？算了哪有不疯的

# 取位

说实话半年没摸真忘了是取位，还以为 a100+b10+c 这种操作来着

难度不大，就是旁边的师弟差点没把我气死矣

# 思路知识点：

取位的操作也就是利用好取余和整数除 10 即可

此题注意事项：

取的位自己验一下就行

上 wp

	#include<stdio.h>
	int main()
	{
	for (int i = 10; i <=100; i++) if (i%10 == i/10) printf("%d ",i);
	for (int i = 100; i <=1000; i++) if (i%10 == i/100) printf("%d ",i);
	return 0;
	}

如果不知 1000 的话就得用表达式表示范围了，以后再说

# 数组

善，我入个门，不输出就行，删除什么链表什么 free 什么的，有缘再叙！

掐指一算，我就多开一个数组负责标记好了

# 思路知识点：

这里就没啥知识点了，硬说的话，用另一个数组做标记算思路吧

此题注意事项：

博主之前第 10 行不小心写的 i++。第 12 行不小心写的 j [i] == 1
少看多做，看和做是两回事

代码别写错

废话少说，show me the code！！！

	#include<stdio.h>
	int main()
	{
	int a[10],j[10];
	int i;
	for (i = 0; i < 10; i++)
	{
	j[i]=0;
	scanf("%d",&a[i]);
	for (int k = 0; k < i; k++) if (a[i] == a[k]) j[i]=1;
	}
	for (i = 0; i <= 10; i++) if(j[i] == 0) printf("%d ",a[i]);

	return 0;
	}

下播！

D's domain

24/12/20

pwndbg操作方式个人总结（一）

Fri, 20 Dec 2024 00:00:00 +0800

# 将 pwndbg 输出重定向到另一个终端（TTY）：

打开另一个终端
- 启动一个新的终端窗口或在当前终端中使用 tmux 、 screen 等工具分割出新的窗口。
- 使用 tty 命令获取该终端的设备文件路径。例如：
  $ tty
  /dev/pts/1
在 pwndbg 中设置输出重定向
- 在 GDB（pwndbg）中输入以下命令，将上下文输出重定向到新的终端：
```
set context-output /dev/pts/1
```
- 现在，pwndbg 的上下文信息（如 context 命令的输出）将显示在 /dev/pts/1 对应的终端中。
恢复默认设置（可选）
- 想将输出恢复到默认终端，可以使用：
```
set context-output /dev/tty
```

# pwndbg 的基础操作:

附上一个佬的原文链接，写的真的很厉害 ovo 就不重复赘述了

原文链接：https://blog.csdn.net/XiDPPython/article/details/142690569

# Pwndbg 额外操作

特别适用于逆向工程和漏洞利用。以下是一些常用的 pwndbg 命令及其用途：

# 常用命令：

context （或 ctx ）

显示当前调试的上下文信息，包括寄存器、堆栈、代码和内存映射等。
- 用法：
  - context ：显示默认的上下文信息。
  - context code ：仅显示代码段的反汇编。
  - context regs ：仅显示寄存器信息。
  - context stack ：仅显示堆栈内容。
  - context all ：显示所有可用的上下文信息。
hexdump

以十六进制形式显示内存内容。
- 用法：
  - hexdump ADDRESS ：从指定地址开始显示内存内容。
telescope

类似于 hexdump ，但提供更友好的内存查看方式，自动解析指针和字符串。
- 用法：
  - telescope ADDRESS ：从指定地址开始显示内存内容。
vmmap

显示当前进程的内存映射信息。
- 用法：
  - vmmap ：列出所有内存段及其权限。
search

在内存中搜索特定的字节序列或模式。
- 用法：
  - search PATTERN ：搜索指定的模式。
pie

处理位置无关可执行文件（PIE）的相关命令。
- 用法：
  - pie breakpoint OFFSET ：在偏移地址处设置断点。
rop

帮助查找 ROP（Return-Oriented Programming）小工具。
- 用法：
  - rop ：列出可用的 ROP 小工具。
got 和 plt

查看全局偏移量表（GOT）和过程链接表（PLT）。
- 用法：
  - got ：显示 GOT 表信息。
  - plt ：显示 PLT 表信息。
aslr

控制地址空间布局随机化（ASLR）。
- 用法：
  - aslr on ：启用 ASLR。
  - aslr off ：禁用 ASLR。
elf-info

显示当前可执行文件的 ELF 格式信息。
- 用法：
  - elf-info ：显示 ELF 文件的段和节信息。

# pwndbg 积累操作 (本人个人经常会用到的一些操作)

# (gdb) info functions win

All functions matching regular expression "win": Non-debugging symbols:

0x080484cb win

还会更新

2020网鼎RE

Wed, 18 Dec 2024 00:00:00 +0800

# 还木写完 ^^ 先开个坑

# 代码分析：

	int __cdecl main(int argc, const char argv, const char envp)
	{
	int v4[117]; // [esp+18h] [ebp-1D4h] BYREF

	__main();
	qmemcpy(v4, &unk_403040, 0x1C8u);
	vm_operad(v4, 114);
	puts("good,The answer format is:flag {}");
	return 0;
	}

# 逐行解释：

函数签名：
int __cdecl main(int argc, const char **argv, const char **envp)
- 标准的 main 函数入口。
- __cdecl 是调用约定，表示参数从右到左入栈，由调用者清理栈。
变量声明：
int v4[117]; // [esp+18h] [ebp-1D4h] BYREF
- 声明了一个包含 117 个整数的数组 v4 。
- 注释指出了栈偏移量，表示 v4 位于栈帧的 [ebp - 0x1D4] 位置。
- BYREF 表示该变量以引用方式传递给函数。
调用 __main() ：
__main();
- 这是编译器（如 GCC）在初始化时调用的函数，用于设置全局构造函数等。
- 在逆向工程中，它通常可以忽略，对主要逻辑影响不大。
调用 qmemcpy() ：
qmemcpy(v4, &unk_403040, 0x1C8u);
- 将内存从 &unk_403040 复制到 v4 ，长度为 0x1C8 字节（456 字节）。
- qmemcpy 类似于标准的 memcpy ，但可能是 IDA Pro 的内部函数。
调用 vm_operad() ：
vm_operad(v4, 114);
- 调用函数 vm_operad ，传入参数 v4 和 114 。
- 这里的 114 可能表示操作码的数量、数据长度或某个关键值。
输出信息：
puts("good,The answer format is:flag {}");
- 输出提示信息，告诉我们答案的格式是 flag {} 。
返回语句：
return 0;
- 标准的 main 函数返回，表示程序正常结束。

# 深入分析：

# 1. 理解数据复制操作：

数据源 unk_403040 ：
- unk_403040 是未知的全局数据，位于地址 0x403040 。
- 我们需要查看该地址处的数据内容，可能是加密的数据、字节码、操作码等。
复制操作：
- 将 456 字节的数据复制到 v4 。
- v4 的大小为 117 * 4 = 468 字节（因为每个 int 是 4 字节），所以复制操作是安全的。

# 2. 分析 `vm_operad()` 函数：

函数作用猜测：
- 从函数名来看， vm_operad 可能表示 “虚拟机操作”。
- 这暗示该函数可能是一个虚拟机解释器，执行传入的字节码或操作码。
参数 114 的含义：
- 114 可能表示操作码的数量或某个关键参数。
- 可能与复制的数据长度或某种校验有关。

# 3. 反汇编 `vm_operad()` ：

步骤：
- 在 IDA 中，定位并反汇编 vm_operad 。
- 分析函数的控制流程，查看是否有循环、跳转表或条件判断。
寻找模式：
- 操作码解析： 检查是否有读取 v4 中数据作为操作码的逻辑。
- 栈操作： 查看是否有自定义的栈，用于模拟指令执行。
- 关键函数调用： 寻找与字符串比较、加密解密、输出相关的函数调用。

# 4. 堆栈不平衡问题的原因：

异常的栈操作：
- 如果 vm_operad 在执行过程中直接修改了栈指针（如 ESP 寄存器），会导致 IDA 无法正确跟踪栈帧，出现堆栈不平衡的提示。
解决方法：
- 手动调整： 在 IDA 中，可以手动修改栈平衡，在函数属性中调整栈偏移。
- 分析调用约定： 确保函数的入口和出口栈平衡，即进入和离开函数时，栈指针应恢复到相同的值。

# 5. 修改 `call` 指令的值为 `0` 的意义：

跳过函数调用：
- 将 call 指令的目标地址修改为 0 ，相当于调用了一个空函数，可能会导致程序崩溃或无操作返回。
- 在逆向过程中，这种修改用于跳过某些干扰性的函数，如反调试、反虚拟化或延时函数。
保持栈平衡：
- 即使修改了 call ，也需要确保栈的平衡。
- 可以用 NOP 指令替换 call ，或者调整栈指针，使得程序继续正常执行。

# 可视化结构图：

# 函数调用栈：

[ 高地址 ]
+-----------------------+
| 命令行参数 envp       |
+-----------------------+
| 命令行参数 argv       |
+-----------------------+
| 参数个数 argc         |
+-----------------------+
| 返回地址              | <-- 调用 __main() 压入的返回地址
+-----------------------+
| 返回地址              | <-- 调用 main() 压入的返回地址
+-----------------------+
| 旧的 EBP              | <-- 基指针 EBP
+-----------------------+
| 局部变量 v4[117]      | <-- 栈帧中的变量
+-----------------------+
[ 低地址 ]

# 程序执行流程：

开始执行 main() 。
调用 __main() ：初始化操作。
数据复制：将数据从 unk_403040 复制到 v4 。
执行 vm_operad(v4, 114) ：
- 可能解释执行 v4 中的数据。
- 关键的逻辑可能在此函数中。
输出提示信息：告诉我们答案的格式。
程序结束：返回 0 。

# 成为逆向大师的指导：

# 1. 深入分析 `unk_403040` ：

查看数据内容：
- 在 IDA 中，跳转到地址 0x403040 ，查看数据是否为可读字符串、操作码或其他格式。
- 如果是字节码，尝试手动解析。
数据模式识别：
- 检查是否有明显的加密或混淆迹象。
- 如果数据不可读，可能需要解密或解码。

# 2. 解析 `vm_operad()` 的逻辑：

反汇编并注释：
- 逐行反汇编 vm_operad ，添加注释，理解每个指令的作用。
- 关注寄存器的使用、条件跳转和函数调用。
构建操作码表：
- 如果 vm_operad 是解释器，可能有一个操作码对应的指令集。
- 建立操作码与指令的映射，模拟执行过程。

# 3. 解决堆栈不平衡：

理解栈帧结构：
- 熟悉函数调用约定，如 cdecl 、 stdcall 等。
- 理解栈指针（ESP）和基指针（EBP）的变化。
修正 IDA 中的堆栈信息：
- 使用 IDA 的功能，手动设置函数的栈调整值。
- 在函数属性中，设置正确的输入输出栈大小。

# 4. 实践调试技巧：

使用调试器：
- 在动态调试器（如 OllyDbg、x64dbg）中运行程序，观察运行时的行为。
- 设置断点，查看寄存器和内存的变化。
脚本和自动化：
- 利用 IDA Python 编写脚本，自动提取和分析数据。
- 学习使用其他逆向工具，如 Ghidra、Radare2。

# 5. 解决逆向挑战：

寻找密钥或 Flag：
- 关注 vm_operad 中的比较、循环和条件跳转。
- 可能需要输入特定的数据，或者从 v4 中提取信息。
学习常见的加密和编码方式：
- 熟悉 Base64、异或加密、移位加密等常用技巧。
- 了解字符串加密和解密的过程。

# 总结：

通过逐步分析代码，我们了解到：

程序从全局未知数据 unk_403040 中复制了一段数据到本地变量 v4 。
通过调用 vm_operad ，可能对这段数据进行了解析或执行。
输出的信息提示我们，答案的格式是 flag {} 。

要进一步解开这个逆向题，需要：

深入分析 vm_operad 的逻辑，理解其功能。
可能需要模拟或重现 vm_operad 的执行过程。
从 v4 或其他数据中提取出隐藏的 flag 。

建议：

耐心研究：逆向工程需要耐心和细致的分析，逐行理解代码。
多练习：通过解决更多的逆向题目，积累经验。
学习基础：巩固计算机体系结构、汇编语言和操作系统的知识。
交流讨论：与他人分享和讨论你的发现，可以获得新的思路。

希望以上分析对你有所帮助，继续努力，你一定能成为一名出色的逆向工程师！\

好的，让我们进一步分析 vm_operad 函数的具体实现，逐步理解它的逻辑和可能的用途。

# 代码分析：

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

	v9 = 0;
	v8 = 0;
	v7 = 0;
	v6 = 0;
	v5 = 0;
	while ( 1 )
	{
	result = v9;
	if ( v9 >= a2 )
	return result;
	switch ( a1[v9] )
	{
	case 1:
	Str[v6 + 100] = v4;
	++v9;
	++v6;
	++v8;
	break;
	case 2:
	v4 = a1[v9 + 1] + Str[v8];
	v9 += 2;
	break;
	case 3:
	v4 = Str[v8] - LOBYTE(a1[v9 + 1]);
	v9 += 2;
	break;
	case 4:
	v4 = a1[v9 + 1] ^ Str[v8];
	v9 += 2;
	break;
	case 5:
	v4 = a1[v9 + 1] * Str[v8];
	v9 += 2;
	break;
	case 6:
	++v9;
	break;
	case 7:
	if ( Str[v7 + 100] != a1[v9 + 1] )
	{
	printf("what a shame...");
	exit(0);
	}
	++v7;
	v9 += 2;
	break;
	case 8:
	Str[v5] = v4;
	++v9;
	++v5;
	break;
	case 10:
	read(Str);
	++v9;
	break;
	case 11:
	v4 = Str[v8] - 1;
	++v9;
	break;
	case 12:
	v4 = Str[v8] + 1;
	++v9;
	break;
	default:
	continue;
	}
	}
	}

# 逐行解释：

变量声明：
- int result; ：用于存储函数返回值。
- char Str[200]; ：字符数组，用于存储字符串或数据。
- char v4; ：临时变量，用于存储中间计算的结果。
- int v5, v6, v7, v8, v9; ：多个整数变量，用于索引和计数。
初始化：
- v9 初始化为 0 ，作为主循环的索引。
- v5 , v6 , v7 , v8 也初始化为 0 ，它们分别用于处理字符串和跟踪状态。
主循环：
- while (1) ：无限循环，直到 return 语句。
- result = v9; ：在每次循环开始时更新 result 为当前索引。
- if (v9 >= a2) return result; ：如果索引 v9 超过输入参数 a2 ，则返回当前结果，结束循环。
switch 语句：
- 根据 a1[v9] 的值进行不同操作， a1 是输入的整数数组。

# 每种情况的分析：

case 1:
Str[v6 + 100] = v4;
- 将 v4 存入 Str 数组的偏移量 v6 + 100 ，并更新 v6 和 v8 。
case 2:
v4 = a1[v9 + 1] + Str[v8];
- 将 a1 中下一个元素与 Str[v8] 相加，结果存入 v4 ，并将 v9 增加 2 。
case 3:
v4 = Str[v8] - LOBYTE(a1[v9 + 1]);
- 将 Str[v8] 减去 a1[v9 + 1] 的低字节（使用 LOBYTE ），结果存入 v4 。
case 4:
v4 = a1[v9 + 1] ^ Str[v8];
- 使用按位异或操作将 a1[v9 + 1] 与 Str[v8] 进行运算。
case 5:
v4 = a1[v9 + 1] * Str[v8];
- 将 a1[v9 + 1] 与 Str[v8] 相乘，结果存入 v4 。
case 6:
++v9;
- 仅增加 v9 ，不进行任何其他操作。
case 7:
if (Str[v7 + 100] != a1[v9 + 1]) {
printf("what a shame...");
exit(0);
}
- 检查 Str[v7 + 100] 是否等于 a1[v9 + 1] ，如果不等，则打印错误信息并退出程序。
case 8:
Str[v5] = v4;
- 将 v4 存入 Str 数组的偏移量 v5 ，并更新 v5 。
case 10:
read(Str);
- 从输入读取数据到 Str 中。
case 11:
v4 = Str[v8] - 1;
- 将 Str[v8] 减去 1 ，结果存入 v4 。
case 12:
v4 = Str[v8] + 1;
- 将 Str[v8] 加上 1 ，结果存入 v4 。
default:
- 不执行任何操作，继续循环。

# 潜在用途分析：

# 1. 逻辑概述：

vm_operad 函数似乎是一个简单的虚拟机或解释器，它根据传入的指令数组 a1 逐步操作数组 Str 和变量 v4 。
这个函数可以执行多种操作，如加法、减法、乘法、异或等，处理相应的数据并将结果存储在 Str 中。

# 2. 关键指令：

读入数据：通过 read(Str) 可能是让用户输入数据以进一步处理。
条件检查：在 case 7 中，如果输入不匹配，会导致程序退出，表明某些输入的有效性检查。

# 3. 输出逻辑：

puts("what a shame...") 提示可能与程序的输入或逻辑错误有关，提示用户输入的值不符合预期。

# 建议的进一步步骤：

观察输入数据结构：分析传入的 a1 数组内容，特别是其在 main 函数中是如何被填充的。
跟踪执行：使用调试工具逐步跟踪 vm_operad 的执行，观察 Str 和 v4 的变化。
构造测试用例：通过手动构造适当的 a1 数组来观察函数的行为，以找到可能的输出或 flag 。

希望这个分析对你进一步理解 vm_operad 的逻辑有帮助！如果你还有其他问题或者需要更深入的讨论，请告诉我！

堆栈不平衡，布栈

Thu, 28 Nov 2024 00:00:00 +0800

# 堆栈不平衡

通常是由于函数调用和返回过程中堆栈操作的不匹配。每当调用一个函数时，程序会将当前的栈指针（SP）和返回地址压入堆栈，这会影响到后续的堆栈操作。

例如，假设一个函数调用 func ，在进入 func 时，栈指针会增加（即压入返回地址）。如果在 func 中未正确地平衡堆栈（比如未能弹出相应的值），那么在返回时，栈指针可能会指向一个不正确的位置，导致堆栈不平衡。

至于栈指针的修改，可以通过调整指令来确保调用的函数有正确的返回地址。例如，修改 call 指令的目标地址为 0 ，可以防止调用某个函数，这在某些逆向工程中是用于跳过不必要的函数调用或陷阱，达到对程序行为的控制。

简单来说，理解堆栈的操作顺序和调用约定是非常重要的。通过反汇编工具分析这些操作，可以更好地理解程序的执行流程和潜在的漏洞。你可以从调试程序，观察栈的变化入手，加深对这些概念的理解。

要深入理解堆栈不平衡的问题，我们可以从堆栈的工作原理和汇编代码角度进行分析。

# 1. 堆栈的基本概念

堆栈是一种后进先出（LIFO）的数据结构，用于存储函数调用的信息，包括返回地址、局部变量和参数。堆栈的顶端通常由栈指针（SP）指向。

# 2. 函数调用的过程

当一个函数被调用时，会执行以下步骤：

保存返回地址：调用指令（如 call func ）会将当前指令的下一条地址压入堆栈。
调整栈指针：栈指针会减少（在 x86 架构中，栈向下增长）。
进入函数体：函数内部可以通过栈来存储局部变量。

# 示例代码

push ebp           ; 保存旧的基指针
mov ebp, esp      ; 设置新的基指针
sub esp, 16       ; 为局部变量分配空间

; 函数体

mov esp, ebp      ; 恢复栈指针
pop ebp           ; 恢复旧的基指针
ret                ; 返回

# 3. 堆栈不平衡的原因

如果在函数中未正确弹出压入的值，或者在返回之前没有恢复堆栈状态，就会导致堆栈不平衡。比如，如果你在函数内部多次压入值而没有相应的弹出，堆栈将继续增长，最终导致溢出。

# 4. 栈指针的修改

栈指针的修改通常涉及 push 和 pop 指令。例如，如果需要跳过某个函数的执行，可以将 call 指令的目标地址更改为 0 ，这样不会实际调用任何函数，从而避免栈指针的进一步修改。

# 伪代码示例

call 0x0         ; 不会改变堆栈状态

# 5. 可视化结构图

[ ESP ]   -->  | Return Address | <-- call func
               | Local Var 1    |
               | Local Var 2    |
               | ...            |
               | Old EBP        |
[ EBP ]   -->  | Base Pointer   |

# 6. 逆向工程的实用技巧

使用调试工具：例如 GDB 或 x64dbg，逐步执行代码，观察堆栈的变化。
分析调用约定：了解不同平台（如 x86 和 x64）的调用约定，这对逆向非常重要。
编写脚本：可以使用 Python 等语言结合工具（如 IDA Pro 或 Ghidra）自动化分析任务。

掌握这些基础知识后，继续深入学习汇编语言和计算机体系结构将有助于你成为真正的逆向工程大师！

# 布栈

教我做一道 CTF 中的 pwn 题: #!/usr/bin/env python from pwn import * sh = process ('./ret2libc1') binsh_addr = 0x8048720 system_plt = 0x08048460 payload = flat ([b'a' * 112, system_plt, b'b' * 4, binsh_addr]) sh.sendline (payload) sh.interactive () 这里我们需要注意函数调用栈的结构，如果是正常调用 system 函数，我们调用的时候会有一个对应的返回地址，这里以 'bbbb' 作为虚假的地址，其后参数对应的参数内容。你看他布栈的时候，为什么要 system_plt 后面要布一个虚假的地址，然后才是参数呢，这里没太懂

这道题目是典型的 ret2libc 攻击 (Return-to-libc)，目标是通过覆盖栈上的返回地址，绕过程序的正常流程，转而调用 system() 函数来执行命令（在这个例子中是 /bin/sh ）。为了理解为什么 system_plt 后面需要填充一个虚假的地址（ b'b' * 4 ），我们需要详细分析下栈结构和函数调用的过程。

# 背景知识

在 x86 架构的程序中，函数调用的基本过程如下：

压栈：当一个函数被调用时，程序会将当前的 返回地址 压入栈中，这个返回地址是程序调用该函数后，程序应该跳转回来的地址。
参数传递：在栈上，函数的参数会紧随返回地址之后依次被压入栈中。
栈帧结构：每次函数调用时，都会为该函数分配一个栈帧，栈帧中包含：
- 返回地址：指向调用函数之后的代码位置。
- 参数：该函数的参数。

# 攻击思路

在这道题中，我们要利用程序中的漏洞，覆盖栈上的返回地址，使得程序在执行 ret （返回指令）时跳到我们指定的地址，也就是 system() 函数的地址。

# 分析代码

	#!/usr/bin/env python
	from pwn import *

	sh = process('./ret2libc1')

	binsh_addr = 0x8048720
	system_plt = 0x08048460
	payload = flat([b'a' * 112, system_plt, b'b' * 4, binsh_addr])
	sh.sendline(payload)

	sh.interactive()

binsh_addr = 0x8048720 ：这是我们要传给 system() 函数的参数地址，也就是 /bin/sh 字符串的地址。 system() 函数需要一个字符串参数，在这里我们传递的是 /bin/sh 的地址， system() 会执行该命令，启动一个 shell。
system_plt = 0x08048460 ：这是 system 函数的地址，在程序中的 PLT（Procedure Linkage Table） 区域。PLT 是程序用来调用动态库函数的一个表，每当程序要调用动态库中的函数时，都会先跳转到 PLT 处，由 PLT 去调用函数的实际地址。
payload = flat([b'a' * 112, system_plt, b'b' * 4, binsh_addr]) ：
- b'a' * 112 ：这里填充的是 112 个字节 a ，这是覆盖栈帧到返回地址的部分。程序会首先执行一些前期的操作（例如栈的初始化、局部变量等），然后遇到返回地址。因为栈的布局是从高地址到低地址的，所以我们填充 a 字符来覆盖返回地址的空间，确保在覆盖掉返回地址后，后面的内容是我们想要填充的内容。
- system_plt ：这是我们覆盖的返回地址。当栈上的返回地址被覆盖为 system_plt 后，程序将跳转到 system() 函数。这个 system_plt 的地址是硬编码的，它会让程序跳转到 system() 的实际地址。注意，这个地址是 PLT 表中的地址，在动态链接的程序中，PLT 是一个跳转表，用于跳转到 system 函数的实际实现地址。
- b'b' * 4 ：这是一个 虚假的返回地址，也就是说这是我们填充在 system_plt 后的一个占位符。这个部分的大小是 4 字节（通常是 x86 架构的指针大小）。为什么要填充这个虚假的返回地址呢？因为 system() 函数的调用约定是需要一个参数（即 /bin/sh 的地址）。这个虚假的返回地址用于模拟栈上 system() 函数执行完之后返回的地址。我们这样做是为了让栈结构保持正确，在调用 system() 时，栈帧结构要完整，所以我们需要一个假的返回地址来确保 system() 执行完成后能正确返回。实际上，在这道题中，虚假的地址 b'b' * 4 会被 system() 执行后丢弃。
- binsh_addr ：这是我们传递给 system() 函数的参数 /bin/sh 字符串的地址。 system() 函数需要一个字符串作为参数，这个参数是 system() 在执行时使用的命令，告诉它启动一个 shell。
sh.sendline(payload) ：这一行是将构造好的 payload 发送到程序中，触发栈的溢出和返回地址的修改。
sh.interactive() ：执行完 payload 后，程序将进入交互模式，让我们与程序进行交互，通常在这种 CTF 题目中，这意味着我们已经成功地获得了一个 shell，可以执行命令。

# 为什么要填充虚假的地址？

在调用 system() 函数时，通常在栈上需要有一个返回地址，指示函数执行完之后应该跳转到哪里。由于 system() 是一个库函数，它执行完成后并不会返回到一个特定的地址，而是会根据调用栈返回到调用它的地方。但是，由于我们要用 ret2libc 攻击来绕过正常的程序流程，我们通过修改返回地址，使得程序跳转到 system() 函数。但是 system() 函数的调用约定仍然需要栈上有一个正确的返回地址（即调用 system() 后程序会跳回的地址）。

由于 system() 在执行后会返回，我们需要一个虚假的返回地址来填补栈上的空隙，确保栈帧结构完整。
我们用 b'b' * 4 来填充这个虚假的返回地址。这里的 4 字节是因为在 x86 架构中，返回地址是一个指针，占用 4 字节。

# 总结

system_plt 是我们想跳转到的地址，即 system() 函数的入口。
虚假的返回地址 ( b'b' * 4 ) 用于保证栈帧的完整性，它只是一个占位符。 system() 执行后会跳过这个虚假的地址，并且返回到 system() 函数的调用者。
binsh_addr 是传递给 system() 函数的参数，即 /bin/sh 的地址， system() 会执行它，启动一个 shell。

这个过程通过巧妙地控制栈上的返回地址，利用系统中已经存在的库函数来执行恶意代码，从而达到绕过程序控制并获取 shell 的目的。

Meiyacup2024菜鸟个人总结（一）

Tue, 12 Nov 2024 00:00:00 +0800

# Meiyacup2024 菜鸟个人总结（一）

以下内容仅用作个人复盘以及分享参考的思路。

我已经菜得离谱了！！！这里没有好东西啦！

去打 2024 美亚线下了，今年比去年弱了好多好多，比赛结果非常非常差~~但是也是尽力了~~一坨就是一坨

比赛的时候，网断了才发现犯了非常离谱的错误，赛前明明注意到了内存取证题，但是没系统练过也没调试 volatility

python3 掉 setup.py, 然后发现网上教程有敲 python3 vol.py 的，然后我发现可以直接敲 vol

不太懂于是复盘之后 chat 了一下

事实上还发现了依赖项问题。因为我的 kali 中又有 python2 又有 python3, 总是产生一些奇奇怪怪的问题

总之以后还是多用虚拟环境吧，正好 2024 的 kali 更新规则了

# 至于赛题:

举个赛题的例子

列出 firefox 的 pid

比赛的时候不联网，个人赛时间紧迫又没法看 help。只能拿本地的 llama3.1 跑一下 vol 的命令，最后给的一堆人机指令

这里就丢了 10 分，后面还有一个解压然后开火眼即取的手机镜像题也没拿到分，太着急了可能是

这里的 20 分拿回来就是第二了，仅次于通天戴，可惜没有如果 == 难受了一整天

美亚的内存取证工具什么都出不来，火眼的连镜像都打不开，除非 vol 否则一个都跑不出来

以后一定好好复习

纪念一下自己人机级别蠢到家的指令

正确做法：

vol -f xxx.raw [plugin] -- 额外参数

for example：

vol -f RAM_Capture_David_Laptop.raw windows.info

结果：

出来了，windows 信息

那么这道题的话

vol -f RAM_Capture_David_Laptop.raw windows.pslist

或者更好的

vol -f RAM_Capture_David_Laptop.raw windows.pslist | grep "firefox.exe"

o1-pre 会给出 vol -f RAM_Capture_David_Laptop.raw pslist 这个指令，但是 vol3.x 就不行了，因为这个比赛直接炸掉了

为什么有时候大脑不转呢

	#include <stdio.h>

	int main() {
	char *a[] = { "Pascal", "C Language", "dBase", "Java" };
	// 访问第一个字符串
	printf("%s\n", a[0]); // 输出: Pascal

	// 修改指针，指向另一个字符串
	a[0] = "Python";
	printf("%s\n", a[0]); // 输出: Python

	// 尝试修改字符串内容（不推荐，可能导致崩溃）
	//a [0][0] = 'p'; // 未定义行为

	return 0;
	}

	#include <stdio.h>

	int main() {
	char a[][20] = { "Pascal", "C Language", "dBase", "Java" };

	// 访问第一个字符串
	printf("%s\n", a[0]); // 输出: Pascal

	// 修改字符内容
	a[0][0] = 'p';
	printf("%s\n", a[0]); // 输出: pascal

	return 0;
	}

	typedef int (*func_ptr)(int);

	int f(func_ptr f1, func_ptr f2, int x) {
	return f2(x) - f1(x);
	}

	调用栈顶部
	┌────────────────────┐
	│ convert(a + 2, 4) │
	│ 执行 *a = '4' │
	└────────────────────┘
	返回
	┌────────────────────┐
	│ convert(a + 1, 48) │
	│ 执行 *a = '8' │
	└────────────────────┘
	返回
	┌────────────────────┐
	│ convert(a, 483) │
	│ 执行 *a = '3' │
	└────────────────────┘
	返回

	if (Str[v7 + 100] != a1[v9 + 1]) {
	printf("what a shame...");
	exit(0);
	}

	int x = 10;
	int *ptr = &x; //ptr 指向变量 x 的地址

	function greet {
	Write-Host "Hello, $args"
	}

we1c0me_t0 my odyssey domain

折返

寄存器部分寻址方式

# ASM 源码：

# 详解：

# 1. .data 段

# 2. .text 段

# 3. 立即寻址方式

# 4. 寄存器寻址方式

# 5. 直接寻址方式

# 6. 寄存器间接寻址方式

# 7. 寄存器相对寻址方式

# 8. 基址变址寻址方式

# 9. 相对基址变址寻址方式

# 10. 系统调用（输出字符串）

# 11. 退出程序

# 总结

为啥拖更qwq

C语言入门知识点&基础思路（三）

# C 语言哭传（三）

# 8.15 指针

# 思路知识点：

# & 运算符和 * 运算符

# 拓展：

# char *a []，char a [] 与 char a [][] (含大模型 o1 的回答)：

# 分析与解释

# 1. 声明一： char *a[]

# 2. 声明二： char a[]

# 主要异同点总结

# 选择使用哪种方式

# 总结

# 8.16 指针

# 函数指针

# 主要概念

# 拓展：函数指针的优势（含 o1 模型回答）

# 再补两句

# 8.17 指针

# 挑战：8.13 递归

# 递归函数解析

# 递归

# 初始调用： convert(a, 483)

# 第一次递归调用： convert(a + 1, 48)

# 第二次递归调用： convert(a + 2, 4)

# 回到第一次递归调用： convert(a + 1, 48)

# 回到初始调用： convert(a, 483)

# 总结:

# 拓展：递归调用栈 (入门者选择性阅读此段)

# 示例：将 483 转换为 "384"

#

# 1. 初始调用： convert(a, 483)

# 2. 第一次递归调用： convert(a + 1, 48)

# 3. 第二次递归调用： convert(a + 2, 4)

# 4. 递归返回：返回到第一次递归调用

# 5. 递归返回：返回到初始调用

# 可视化调用栈

安装一个‘小’工具有点想跟powershell爆了

# 修改 $PROFILE 文件

# $PROFILE 文件的原理

# 具体解释

# $PROFILE 文件的种类

# 修改 $PROFILE 文件的目的

# 总结

公告栏

# welcome to my cyber world！

# 公告栏

# 往期问题修复 & 版本优化

# 往期大版本更新

C语言入门知识点&基础思路（二）

# C 语言笑传又来了说是

# 6.7 字符串

# 思路知识点：

# 挑战：8.7 字符变换

# 思路知识点：

# 解题过程（最终答案在最后面）:

挖了但是还没填的坑呜呜呜

# 哈哈哈哈哈哈哈，自己挖坑自己跳了说是

以一道CTF题真正初识RSA

# 先改一下 flag 以调通 newcomer.py 代码

# 用自己的语言写出 RSA 公钥和私钥的计算公式（使用 p，q，phi，n，e，d 为符号）

# 利用题目下方注释中的已知变量计算 phi，并利用 inverse 函数编程计算 e 在模 phi 意义下的乘法逆元，记为 d，根据程序运行结果写出 d 的具体数值；

# `&` 运算符和 `*` 运算符

# 1. **声明一： `char *a[]`**

# 2. 声明二： `char a[]`

# 初始调用： `convert(a, 483)`

# 第一次递归调用： `convert(a + 1, 48)`

# 第二次递归调用： `convert(a + 2, 4)`

# 回到第一次递归调用： `convert(a + 1, 48)`

# 回到初始调用： `convert(a, 483)`

# 示例：将 `483` 转换为 `"384"`

# 1. 初始调用： `convert(a, 483)`

# 2. 第一次递归调用： `convert(a + 1, 48)`

# 3. 第二次递归调用： `convert(a + 2, 4)`

# 修改 `$PROFILE` 文件

# `$PROFILE` 文件的原理

# `$PROFILE` 文件的种类

# 修改 `$PROFILE` 文件的目的

# 2. 分析 `vm_operad()` 函数：

# 3. 反汇编 `vm_operad()` ：

# 5. 修改 `call` 指令的值为 `0` 的意义：

# 1. 深入分析 `unk_403040` ：

# 2. 解析 `vm_operad()` 的逻辑：