C 、汇编入门与逆向分析
c基础
C基本数据类型
复制char short int float long double
所占字节 32和64位系统有所区别 sizeof()
数据结构
复制数组、链表、栈、队列、tree
++i
i++
--i
运算符与优先级
循环结构、选择结构
复制if(a<1){
xxx
}else if(a==1){
xxx
}else{
xxx
}
switch(a){ //a整形数据
case 1:
xxx
case 2:
xxx
case 3:
xxx
default:
xxx
}
for(int i=0;i<100;i++){
xxx
}
while(i<100){
xxxx
}
do{
xxx
}while(i<100)
int *p[]= {};
指针
内存的地址，C语言允许用一个变量来存放指针，这种变量称为指针变量。指针变量可以存放基本类型数据的地址，也可以存放数组、函数以及其他指针变量的地址。
-
常见指针变量的定义
复制char*p :p指向一个char型数据，也可以指向一个char[]数组 char**q :q为一个二级指针，指向为char*数据 int (*p)[] :数组指针，它是一个指针，指向的是int[]数组 int *p[] : 指针数组，它是一个数组，数组里元素都是int* 型指针 int (*p)(int a, int b) :函数指针，本质为一个指针，可以指向的是 int fun(int a,int b)类型的函数 int *p(int a, int b): 指针函数，本质是一个函数，返回的一个int*型数据
结构体
复制struct Stu{
char *name;
int num;
int age;
char group;
float score;
};
或
typedef struct{
char *name;
int num;
int age;
char group;
float score;
}Stu;
结构体变量必须初始化，malloc、new
C
Stu *stu = malloc(sizeof(Stu))
C++
Stu *stu = new Stu()
stu->age
stu.age
C内存布局、分配方式
- 内存布局
- 分配方式
一个程序本质上都是由 Bss 段、Data段、Text段三个组成的
- Text段
通常是指用来存放程序执行二进制代码
- Bss段
一般是指用来存放程序中未初始化的全局变量
- Data段
包括三部分 heap(堆)、stack(栈)和静态数据区。
-
堆（heap）:用于存放进程执行中被动态分配的内存段。它的大小并不固定，可动态扩张或缩减。malloc或new(C++)申请,需主动释放free、delete,否则会造成内存泄漏
-
栈(stack)：编译器自动分配释放，存放函数传参，局部变量，函数括弧“{}”中定义的变量（但不包含static声明的变量。static意味着在数据段中存放变量
-
静态数据区: 已初始化的全局变量、静态变量和常量。
复制int a = 0; //全局初始化区，静态数据区
char *p1; //全局未初始化区 bss段
char* func(){//写法正确
char *str = "hello,world";
return str;
}
char* func1(){//写法错误,数组是不能作为函数返回值的，编译器把数组名认为是局部变量（数组）的地址，所以要用指针代替
char str[20] = "hello,world";//如果非要返回，可以用static修饰
return str;
}
char* func2(){
char *str = (char*)malloc(20);
str = "hello,world";
return str;//返回堆内存的指针
}
int main(int argc, const char*argv[])
{
static int a = 0; //全局（静态）初始化区，静态数据区
int b; //栈
char s[10] = "abc"; //字符串和s都是栈区，字符数组s在栈区分配内存
char *p3 = "bilei"; //"bilei"在常量区，p3在栈区
p2 = (char *)malloc(20); //分配成功堆区
//p2用完后必须主动释放
free(p2);
p2=NULL;//防止产生野指针。所谓野指针，即它指向的内存已被释放，单指针本身未释放，它指向的一块“垃圾”
}
汇编
常用指令
复制push、pop、add、sub、mov、lea、ldr、str、cmp、bl、blx、call(x86)
ret
复制push 压栈 pusb rbp
pop 出站. pop rbp
add :add eax,2 //eax = eax+2
sub :sub eax,2 //eax = eax-2
mov :赋值指令
ldr :读取
str :存储
mov R0, 1 //将0赋值给寄存器r0
LDR R0,[R1] // 将存储器地址为R1的字数据读入寄存器R0
LDR R0,[R1,R2] // 将存储器地址为R1+R2的字数据读入寄存器R0
LDR R0,[R1,#8] // 将存储器地址为R1+8的字数据读入寄存器R0
LDR R0,[R1,R2]! // 将存储器地址为R1+R2的字数据读入寄存器R0，并将新地址R1＋R2写入R1
LDR R0,[R1,#8]! // 将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1＋8写入R1
LDR R0,[R1],R2 // 将存储器地址为R1的字数据读入寄存器R0，并将新地址R1＋R2写入R1
LDR R0,[R1,R2,LSL#2]! // 将存储器地址为R1＋R2×4的字数据读入寄存器R0，并将新地址R1＋R2×4写入R1
LDR R0,[R1],R2,LSL#2 // 将存储器地址为R1的字数据读入寄存器R0，并将新地址R1＋R2×4写入R1
STR R0,[R1],#8 // 将R0中的字数据写入以R1为地址的存储器中，并将新地址R1＋8写入R1
STR R0,[R1,#8] // 将R0中的字数据写入以R1＋8为地址的存储器中
堆栈平衡
函数执行前后，函数里面的堆栈要保持不变，如果变了，也就是用了push、sub sp ,0x10，那么一定要在函数ret之前，恢复对栈原来的样子 (pop, add sp, 0x10). 如果堆栈不平衡，程序就会崩溃
arm64
复制rax，rbx，rcx，rdx，esi，edi，rbp，rsp，r8，r9，r10，r11，r12，r13，r14，r15。其中：
rax 作为函数返回值使用。
rsp 栈指针寄存器，指向栈顶
rdi，rsi，rdx，rcx，r8，r9 用作函数参数，依次对应第1参数，第2参数。。。
rbx，rbp，r12，r13，14，15 用作数据存储，调用子函数之前要备份它，以防他被修改
r10，r11 用作数据存储，使用之前要先保存原值
复制main: # @main
push rbp //压栈
mov rbp, rsp
sub rsp, 48 //分配栈空间 rsp栈顶指针
mov dword ptr [rbp - 4], edi
mov qword ptr [rbp - 16], rsi
mov eax, dword ptr [.L__const.main.s]
mov dword ptr [rbp - 24], eax
movabs rax, offset .L.str
mov qword ptr [rbp - 40], rax
mov edi, 20
call malloc
mov qword ptr [rbp - 32], rax
mov rdi, qword ptr [rbp - 32]
call free
mov qword ptr [rbp - 32], 0
xor eax, eax
add rsp, 48 //堆栈平衡
pop rbp //出站
ret
a:
.long 0 # 0x0
p1:
.quad 0
.L__const.main.s:
.asciz "abc"
.L.str:
.asciz "bilei"
armv7
复制main:
push {r11, lr}
mov r11, sp
sub sp, sp, #24
str r0, [r11, #-4]
str r1, [r11, #-8]
ldr r0, .LCPI0_0
str r0, [sp, #8]
ldr r0, .LCPI0_1
str r0, [sp]
mov r0, #20
bl malloc
str r0, [sp, #4]
ldr r0, [sp, #4]
bl free
mov r0, #0
str r0, [sp, #4]
mov sp, r11
pop {r11, lr}
bx lr
.LCPI0_0:
.long 6513249 @ 0x636261
.LCPI0_1:
.long .L.str
a:
.long 0 @ 0x0
p1:
.long 0
.L.str:
.asciz "bilei"
armv8
复制main: // @main
sub sp, sp, #64 // =64
stp x29, x30, [sp, #48] // 16-byte Folded Spill
add x29, sp, #48 // =48
stur w0, [x29, #-4]
stur x1, [x29, #-16]
adrp x8, .L__const.main.s
add x8, x8, :lo12:.L__const.main.s
ldr w9, [x8]
str w9, [sp, #24]
adrp x8, .L.str
add x8, x8, :lo12:.L.str
str x8, [sp, #8]
mov x0, #20
bl malloc
str x0, [sp, #16]
ldr x0, [sp, #16]
bl free
str xzr, [sp, #16]
mov w9, wzr
mov w0, w9
ldp x29, x30, [sp, #48] // 16-byte Folded Reload
add sp, sp, #64 // =64
ret
a:
.word 0 // 0x0
p1:
.xword 0
.L__const.main.s:
.asciz "abc"
.L.str:
.asciz "bilei"
实战
学习网站:https://godbolt.org/
https://files.cnblogs.com/files/pythonywy/测试so.zip
复制#include <stdlib.h>
#include <stdio.h>
typedef struct{
int age;
char *name;
int grade;
short fenshu;
}Student;
struct Test{
int num;
char c;
short data;
};
int sum(int a, int b){
return a+b;
}
void sum1(int *a){
a[1] = 2;
}
int main(int argc, const char * argv[]) {
// char *result_func = func();
for(int i=0;i<100;i++){
printf("%s\n",func3());
}
for(int i=0;i<100;i++){
printf("%s\n",func1());
}
for(int i=0;i<100;i++){
printf("%d\n",func2());
}
int a=2;
int array[8] = {1,2,3,4,5,6,7,8};
int array1[8] = {1,2,3,4,5,6,7,8};
int array2[8] = {1,2,3,4,5,6,7,8};
int array3[][3] = {{1,2,3},{4,5,6},{7,8,9}};
int *p_array[8] = {array,array1,array2};
int (*q_array)[3] = &array3[0];
int (*fun_p)(int a, int b);//函数指针
fun_p = sum;//将函数的首地址赋值给fun_p
int size1 =(int) sizeof(Test);
Student *stu = new Student();//申请内存空间，也可以mac
int size =(int) sizeof(Student);
stu->name = "bilei";
stu->age = 8;
stu->grade = 2;
int a = (*fun_p)(1,2);
char *q = (char*)malloc(8);
q = (stu->name);
int aa = *(q +1);
a = stu->name[1];
if(a>0){
a = sum(a, stu->age);
}
switch (a){
case 1:
a = a<<1;
case 2:
a = a<<2;
case 3:
a = a<<3;
case 4:
a = a<<4;
default:
a = a;
}
stu->grade = a;
short b = 2;
long l = 3;
char c = 'v';
char *p = "hello,world";
char q1 = *(p+1);
char s = *p+1;
sum1(array);
}
微信：
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 单线程的Redis速度为什么快？
· 展开说说关于C#中ORM框架的用法！
· Pantheons：用 TypeScript 打造主流大模型对话的一站式集成库
· SQL Server 2025 AI相关能力初探
· 为什么 退出登录 或 修改密码 无法使 token 失效