Computer Science on Nan0inPsyLog

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都是?

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

git && github指令速学速记

Mon, 25 Aug 2025 14:58:00 +0000

基础须知

什么是版本管理和版本管理系统

git是一个VCS（Version Control System），用于管理修改了的code, 支持不同的对于一个项目的版本管理，使其更容易与他人合作并实时记录一系列操作。当然文件文档也可以。有了git, 就可以进行版本回溯、diff等操作，了解到一个项目的构建历史。当然也可以实现合并不同的分支、或者创建在不同的分支操作等等

安装

windows直接去github release下载，会有一系列操作告知的

linux在cli中根据不同的发行版进行拉取安装即可

分支 commit 等基础命令

GIT仓库保存目录下文件的快照，并希望提交记录尽可能轻量

条件允许的情况下，它会将当前版本与仓库中的上一个版本进行对比，并把所有的差异打包到一起作为一个提交记录。

git会保存提交的历史记录

这也是为什么大多数提交记录的上面都有 parent 节点的原因

在本地commit存储和读取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


git add . #将文件添加进跟踪列表
git add -u #只添加已跟踪文件的修改和删除
git add -A #一次性添加所有修改 = git add . && git add -u
git add <file name> #添加单个文件


git commit --allow-empty #允许未经过改变的提交（为了git log的跟踪）到本地git进行存储
git commit # 会基于parent进行一次节点的commit
git commit -m "some explanations"

git rm <file name> #删除文件，但是本地暂存

Git Branch

“我想基于这个提交以及它所有的 parent 提交进行新的工作。”

Git的分支非常轻量，并且早建分支！多用分支！，分支会简单指向某个提交记录。

即使创建再多的分支也不会造成储存或内存上的开销，

branch和commit结合起来，便可以协同工作。

信息的管理

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


git branch #列出分支
git checkout -b <name> #新分支并跳转过去
git branch -r <name> #查看远程分支
git checkout other_branch #切换分支，在主分支下实现不同分支拉取转换，这样才能使commit对应不同分支

git switch -c <新分支名> <想切换 拉取的分支> #在2.23版本引入，会开始逐渐取代checkout
git switch - #撤销操作

git log #查看目前位置我们每次的记录

git diff #查看区别
git status #也是查看区别
git tag #查看所有可以跳转的版本分支等

信息的合并和rebase

我要把这两个 parent 节点本身及它们所有的祖先都包含到一个分支

一般来说新建一个分支，在其上开发某个新功能，开发完成后再合并回主线。

图一

图二

git merge bugFix后,main包含了所有对代码库的修改，之后我们也可以再次移动bugFix分支, 将其merge到main上，此时所有的分支都会颜色相同，包含所有的代码修改

gir rebase为第二种办法，会取出一系列提交记录后复制到另外部分，图二便是在bugFix后rebase的结果，注意原本的提交记录会继续保留

1
2
3
4
5
6
7
8
9


git checkout -b bugFix
git commit
git checkout main
git commit #这样就是两个分支了
git chekout bugFix
git rebase main #现在bugFix的功能分支也基于main来并行工作了


git rebase <upstream> <branch>

GIT特性

HEAD

HEAD是对当前分支的符号引用，总是指向分支上最近一次提交记录。通常指向分支名，提交的时候修改分支状态，我们也可以通过HEAD以可见的样子看到状态。简单来说就是指向当前节点的

通常用来表示当前工作区基于哪个版本进行开发，也可以理解为当前开发所在分支的最后一次提交

1

cat .git/HEAD # 查看head

分离的 HEAD

分离的 HEAD 就是让其指向了某个具体的提交记录而不是分支名。在命令执行之前的状态如下所示：

HEAD -> main -> C1

HEAD 指向 main， main 指向 C1。而如果我们check out C1了，则HEAD->C1

注意这里checkout 的地方是commit的标签，用于修改指向commit

记住！head的分离是基于commit的，而切换分支是不会分离的

那么分离头指针操作，适合的场景都有哪些呢？
如果我们想基于某次提交做一些新的尝试，而且不确定这些代码要不要合入正式分支的时候，可以使用这种方式。在这上面的修改不会影响其他分支，也不用创建新的分支

相对引用

git log用来查看提交对应的哈希

哈希值在真实的 Git 世界中也会更长（译者注：基于 SHA-1，共 40 位）git通常根据前几位就可以识别了

相对引用则非常给力，我们从一个易于记忆的地方开始计算

1
2
3
4


^ #向上移动一个提交记录
~<num> #向上移动多个提交记录
main^ #即main的父节点 两个^^则是第二个父节点
main~<num> #多次后退，~不指定数字的时候跟^作用类似

我们也可以用HEAD作为参照物

1
2


git checkout xx
git checkout HEAD^ git checkout HEAD^ ...

这样就可以不停向上了

你会想，会不会^后面也可以跟数字呢？可以的兄弟，可以的

1

HEAD^<num>^<num>

实际上如果我们在HEAD上有多个分支，那么^后面跟的数字就是决定去哪一个分支，而不是步数

强制修改分支位置

1

git branch -f main HEAD^3 #将分支强制指向HEAD的第三级parent提交

撤销变更

git reset 把分支记录回退几个提交记录实现撤销变更，原来指向的提交记录会变的像没有提交一样

reset对远程分支无效

git revert 则是用于远程分支的撤销
- 其会产生一次commit专门用来记录撤销

注意谨慎使用git reset –hard而彻底删除工作区和暂存区的修改，执行前务必确认没有需要保留的未提交内容。这时候就可以

git reflog 备份操作记录
- 误删也可以找到历史哈希值恢复：git reset –hard <哈希>

快捷的整理提交记录

git cherry-pick <commit1> <commit2> 可以方便快捷的把提交复制到HEAD下，形成新的提交分支链，我们可以用其来整理main分支

1
2


git checkout <目标分支>
git cherry-pic <commit hash1><commit hash2>/<branch>

要在心里牢记 cherry-pick 可以将提交树上任何地方的提交记录取过来追加到 HEAD 上

由此可以有操作

1
2
3
4


git checkout <分支>
git commit --amend #进行一定修改
git checkout <分支> #切换回去
git cherry-pick <需要的>

来进行少量提交和整理

交互式rebase

使用带--interactive的rebase命令，简写为-1

git rebase -i <commit>

其会打开一个UI界面列出被复制到目标分支的备选提交记录以及一系列的哈希、提交说明，可以确定顺序、选择的commit等

这个ui编辑器可以选为vim neovim nano等等

tag

给commit设定一个永远指向其的锚点tag

1
2
3
4
5
6
7


git tag #查看所有标签
git tag <tag> <commit hash>
git tag -d <tag> #删除本地标签

git push origin <tag> or --tags #推送标签/推送所有标签到远程
git checkout <tag> #此时头指针会分离，无法commit
git describe <ref> #ref可以是任何能被 Git 识别成提交记录的引用

describe输出<tag>_<numcommits>_g<hash>

tag是离ref 最近的标签
numcommits是表示ref和tag相差多少提交记录

如下

远程仓库

当我们从远程clone的时候，例如在main分支，实际上是origin/<分支>即origin，这是远程分支的规范命名

<remote name>/<branch name>，通常就是oringin

进行设置

根据不同的系统进行安装后，我们使用git config进行设置

1
2
3
4


git config --global user.name "your name" # your name
git config --global user.email "your email" # your email
git config --global core.editor vim # your favourite editor
git config --global color.ui true

进行基础设置

当我们在别的项目中进行初始化，则需要

git init，实现将一个已存在本地的项目变为一个git仓库或是初始化一个空仓库，也是我们经常使用的一个指令（没有初始化的仓库有很多指令是用不了的）

配置公钥ssh key

现在常用ed25519和rsa。目录在~/.ssh

1
2


ssh-keygen -t ed25519 -C "your_email@example.com" #生成ssh key
cat ~/.ssh/id_ed25519.pub #出现的公钥复制到github

然后到github添加ssh key后就可以将远程切换成ssh格式

1
2


git remote set-url origin git@github.com:nan0in/NJUPA_nan0in.git
ssh -T git@github.com #测试

然后就可以愉快的Push了

与远程进行交互、进行提交

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


git remote #查看远程仓库名字
git remote -v #查看当前远程仓库地址
git remote add origin https://github.com/example/repo.git # 添加远程仓库
git remote set-url origin https://new-url.git # 修改远程仓库链接，通常在拉下来其他仓库后后进行修改

git push <远程仓库名称> <分支名称> #提交到远程 一半是
git pull <远程仓库名称> <分支名称> #拉取远程最新仓库 

git fetch #直接从远程仓库更新数据并更新本地的远程分支指针
git fetch oringin #拉取origin所有分支
git fetch origin main #拉取main

注意！fetch不会更新本地的main分支，可以理解为只是对远程的数据进行了下载

可以通过下面方式合并到main，git pull则自动实现了fetch和merge的操作

1
2


git fetch
git merge o/main

pull requests?(PR)

远程服务器拒绝直接推送(push)提交到main, 因为策略配置要求 pull requests 来提交更新.

发生偏离了怎么办？

如果远程的分支和本地原本拉下来的分支出现了偏差，我们需要在push前进行rebase或者merge创建好新的合并分支。或者如上文进行git pull同步

1
2
3


git fetch
git rebase o/main #or git merge o/main
git push

这样便可以将我们的工作移动到最新的提交记录下

也可以直接

1
2


git pull --rebase #直接git pull也可以
git push

通常和远程工作的时候我们就会通过上面的方式同步到远程main下然后推送，这样远程的main始终是集成的开发分支

但是rebase的话不会保留原来的分支树，这时候就可以使用merge开始建立准备push到main的链后还保留原来的树

1
2
3


git merge branch1
git merge branch2
git push

注意事项

提交

注意规范，

commit的时候注意自己“干了什么”
一个提交只做一件事（如 “修复登录按钮样式”“新增用户列表接口”），避免一次提交包含多个不相关的修改。这样后续回滚或查看历史时更精准。
❌ 不好：git commit -m “修改了一堆东西"
✅ 推荐：git commit -m “fix: 修复移动端登录按钮点击无响应问题"
提交信息要规范
用简洁明了的语言描述 “做了什么”，最好遵循约定式提交（Conventional Commits）：
- feat: 新增xxx功能（新功能）
- fix: 修复xxxbug（bug 修复）
- docs: 更新接口文档（文档修改）
- refactor: 重构用户模块代码（代码重构，不影响功能）
  避免模糊描述（如 “改了点东西”“更新”）。
提交前检查修改内容
提交前用 git status 确认要提交的文件，用 git diff 检查具体修改内容，避免误提交敏感信息（如密码、密钥）或无关文件（如日志、临时文件）。

分支

名称尽量有意义：

feature/user-login（新功能：用户登录）
bugfix/payment-error（bug 修复：支付错误）
hotfix/security-vulnerability（紧急修复：安全漏洞）
避免 dev1、test （除非你在本地测试自己的仓库）等模糊名称。

主分支保持稳定：

main/master 分支应始终保持可部署状态，开发新功能时从主分支创建新分支，完成后通过 PR/MR 合并，

.gitingore

一开始以为是正则，结果不是，流汗了

直接写名字就可以

*. 名称通配符
 递归匹配，例如src//*.test.txt匹配任意目录下的test
/ 放开头仅忽略根目录下文件
!取消定义的忽略规则

一般会把dotfiles 环境变量 log cache等写入

一些特性

对跟踪的文件无效——即git add 或git commit过的文件，修改ignore也改不了
- git rm --cached <file name> #从commit暂存区移除保留本地文件
优先级是相对当前目录的，当然根目录就是整个仓库生效

参考链接

git-github,roadmap

www.youtube.com/watch?v=2ReR1YJrNOM

learngitbranching.js.org/?demo=&locale=zh_CN

t0fv404

南大PA 0 1小记

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

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

计算机系统-多功能 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

波形检测和仿真都测试无误

通过游戏和《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指令如同先祖的血液，在历史的长河奔腾不息

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 教程