Access Control

在pwn.college网站做Access Control部分前16题的记录。

1.

运行run发现要求flag文件权限，用ll查看flag权限发现能够读取，cat /flag查看。

2.

用ll查看flag权限发现能够读取，cat /flag查看。

3.

用ll命令发现flag文件变得没有任何权限，因此添加权限：

chmod +r flag

cat flag

4.

用ll查看flag权限发现满足要求，cat /flag查看。

5.

在/tmp用touch创建flag空文件，然后复制过来：

cp /flag /tmp/flag

此时覆盖了文件的数据内容，但文件属性和权限没有改变，可以cat出来。

6.

将hacker用户加入用户组：

usermod -aG group_xxx hacker

su hacker

cat /flag

7.

登录有读取flag权限的其他用户：

su user_qlurihvb

然后输入密码，就能cat flag。

8.

同样用su命令，登录创建文件的用户即可。

9.

本题要求理解多用户下的文件权限以及用su获取合适的用户来执行对应权限。题目给予的用户拥有flag的读取权限，于是同样用su命令，登录该用户即可获取flag。

10.

本题要求学会查看什么用户属于什么组。

只有“创建者所属组内的其他用户”对flag文件有读取权限，因此需要在给定的一系列用户中找到和root同为group_nwu的。

输入命令查看所有组信息：

cat /etc/group

输入命令：

su user_khbqhkai

输入对应密码即可获取flag。

11.

题目说已经将flag放在tmp目录下，并给了两个用户及其密码。观察发现tmp目录下只有一个文件夹是我们有权限的，登录第一个用户可以打开该文件夹。进入后用ls -l命令查看发现里面有一个文件，应为flag，需要切换到第二个用户才能读取它，即可获得flag。

12.

原理和上一题一样，只是嵌套的用户从两个变成了三个。

13.

本题考查强制访问控制机制，主体和客体均被赋予了相应的安全级别L=（C，S），其中C表示安全等级，S是类别集。安全等级从高到低分为4级：绝密（TS）、机密（S）、秘密（C）和非密（U）。

对于两个安全级别L1=（C1，S1）与L2=（C2，S2），定义：

L1≥L2，当且仅当C1≥C2，S2⊆S1

L1>L2，当且仅当C1>C2，S2⊂S1

L1<L2，当且仅当C1<C2，S1⊂S2

L1≤L2，当且仅当C1≤C2，S1⊆S2

如果L1和L2的关系都不属于以上情况，则其不可比较。

绝密级可以写绝密级，回答yes得到flag。

14.

本题回答强制访问控制机制的五个问题。总结：同等级之间可以读写，不同等级之间要记住信息只能从低级流向高级，即：高级只能读低级，低级只能写高级。

15.

本题中，同为TS级，类别互不包含，因此不可比较，互相之间没有读写权限，回答no得到flag。

16.

本题回答强制访问控制机制的五个问题。总结：要记住信息只能从低级流向高级，从大的类别集合流向其子集的类别集合。五个问题全回答no得到了flag。

cryptography

在pwn.college网站做cryptography部分前8题的记录。

1.XOR

要求算出170和51的异或值。代码如下：

1
2
3
4
a = 170
b = 51
result = hex(a ^ b)
print(result)

得到结果为153。

2.Hex

本题要求对16进制的数进行异或计算。代码如下：

1
2
3
4
a = 0x18
b = 0x79
result = hex(a ^ b)
print(result)

计算9次结果后得到flag。

3.ASCII

代码与上一题一致，只需在开始对应ascii码表将ascii码转为十六进制作为输入即可。回答9个问题后得到flag。

4.ASCII Strings

代码如下：

1
2
3
from Crypto.Util.strxor import strxor
result = strxor(b"omiCtCWmWk", b"$#&$$(&#&!")
print(result)

回答9个问题后得到flag。

5.One-Time Pad

将密文和密钥进行base64解码再进行一次异或即可得到flag。

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

def base64_to_str(base64_string):
    # 将 Base64 字符串解码为字节
    byte_data = base64.b64decode(base64_string)
    string_data = byte_data.hex()
    return string_data

a = base64_to_str("4pNtP31oGHe9Cg4D/CbNR0UXYgqB/5Spbl+MJu77R3PxpgmOuCDVt5hQhKPjnKqyWRGEDqskQVPG8A==")
b = base64_to_str("kuQDER4HdBvYbWt4tR6Md3BfGnnFptL+NGmhd7eCMzGH6EHkwnbmmfwC/u2Z0e7+LnbuQNJPOwS7+g==")
# print(a)
# print(b)
result = 0xe2936d3f7d681877bd0a0e03fc26cd474517620a81ff94a96e5f8c26eefb4773f1a6098eb820d5b7985084a3e39caab25911840eab244153c6f0 ^ 0x92e403111e07741bd86d6b78b51e8c77705f1a79c5a6d2fe3469a177b782333187e841e4c276e699fc02feed99d1eefe2e76ee40d24f3b04bbfa
# result = hex(result)
result = "70776e2e636f6c6c6567657b4938413035487873445946575a362d5159797442764e486a7a56332e64527a4e7a4d444c77676a4e796b7a577d0a"
output = ''
i = 0
while(True):
    if i >= len(result):
        break
    tmp = result[i:i+2]
    output += (chr(int(tmp,16)))
    i+=2
print(output)

6.many-Time Pad

任何数与0异或会得到其本身，输入与flag同样长度的全0表示的base64码：AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==

输出的密文即为密钥的base64码。解密代码如下：

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
import base64
from Crypto.Util.strxor import strxor

def base64_to_hex(base64_string):
    # 将 Base64 字符串解码为字节
    byte_data = base64.b64decode(base64_string)
    return byte_data

def hex_ascii(hex_data):
    output = ''
    i = 0
    while (True):
        if i >= len(hex_data):
            break
        tmp = hex_data[i:i + 2]
        output += (chr(int(tmp, 16)))
        i += 2
    return output

a = base64_to_hex("LH1+aEbGZnOwx07kX76Xc4Ga32knwPzMuPbqCqYjypK/e3Ph+t0Qqb9THqEy7TJqL/Q/LNzaRVicwg==") #flag密文
b = base64_to_hex("XAoQRiWpCh/VoCufGtTwEe7zuSpgjJStyMWhOOplmeOKDCq1tqdWh9sFZO9IoHYmWJNVYqWxPw/hyA==") #密钥的base64码

result = strxor(a, b).hex()

print(result)
result = hex_ascii(result)
print(result)

7.AES

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import sys
from Crypto.Cipher import AES
import base64

ciphertext = base64.b64decode("FfeV48OOpCKwvhtqEEDFxVAnnDx6taB9ydGO1/rUmTtXqq3Slltqni3ZzvKysnAfLpBherWAcszMw3C4M+0Neg==")
aes_key = base64.b64decode('Cta2eDbBOP1WmV81xkWYdQ==')

cipher = AES.new(aes_key, AES.MODE_ECB)
try:
    message = cipher.decrypt(ciphertext)
except ValueError:
    print("The message was modified!")
    sys.exit(1)

print("Message:", message.decode())

8.AES-ECB-CPA

可以进行选择明文攻击。选择明文输入，选择长度永远为1，将所有单个字符加密后的输出记录下来，挨个爆破出flag内容。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
from pwn import *

# Set architecture, os and log level
context(arch="amd64", os="linux", log_level="info")

# Load the ELF file and execute it as a new process.
challenge_path = "/challenge/run"
p = process(challenge_path)

dir = {}

strin = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm{}1234567890.+-*/=_"
for s in strin:
    print(s)
    res = p.recvuntil("e?", drop=False)
    print(res)
    p.sendline("1")
    p.sendline(s)

# Receive flag from the process
    r = p.recvline(keepends=False)
    word = r.decode(encoding='utf-8').split(': ')[1]
    print(word)
    dir[word] = s

flag = ""
for i in range(100):
    res = p.recvuntil("e?", drop=False)
    p.sendline("2")
    p.sendline(str(i))
    p.sendline("1")
    r = p.recvline(keepends=False)
    word = r.decode(encoding='utf-8').split(': ')[1]
    print(word)
    if(word not in dir):
        break
    flag += dir[word]

print(flag)

Intercepting Communication

在pwn.college网站做Intercepting Communication部分前10题的记录。

1.

用命令：nc 10.0.0.3 31337
pwn.college{gD40vedatQQZJwLHPd5oPJpL97M.dlTNzMDLwgjNykzW}

2.

用命令：nc -l 31337
pwn.college{gog0K4zdJ_HrSYsLPdNuoe4-poX.dBjNzMDLwgjNykzW}

3.

用命令：nmap 10.0.0.0/24

扫描子网网段。

nc 10.0.0.118 31337
pwn.college{kL-pgnb98gySRorBDpYfFb2r5Hm.dFjNzMDLwgjNykzW}

4.

用命令：nmap –min-parallelism 6000 10.0.0.0/16

快速扫描子网网段中大量ip

nc 10.0.135.47 31337
pwn.college{YM8NPTSO1kaGtqBABZcl4J6pI2t.dJjNzMDLwgjNykzW}

5.

打开wireshark，点击31337端口的tcp流量，追踪流得到flag。

pwn.college{kVTKxZhp0Pf6Hq4Dw9DZ5Jhwe9W.dNjNzMDLwgjNykzW}

6.

打开wireshark监听流量，追踪流，可以看到缓慢发出的flag。

由于打开wireshark需要时间，所以流0的信息不完整，等待一段时间后可以看流1得到完整数据。筛选单方向发送的信息得到flag：

pwn.college{0H9EBMigWUGyl0LAS2DYmzVzlsm.dRjNzMDLwgjNykzW}

7.

ip route show查看路由

用命令给自己添加ip路由表：

ip address add 10.0.0.2/24 dev eth0

监听31337端口：

nc -l 31337

pwn.college{kL7-vqtqC9_9gh9fvgnRP1DD6mz.dVjNzMDLwgjNykzW}

8.

需要用scapy库构建数据包。首先获取物理地址：

ip a

输入python进入控制台，输入命令：

1
2
from scapy.all import *
sendp(Ether(src="02:42:0a:21:6b:08",type=0xFFFF)/IP(src="10.33.107.8",dst= "10.0.0.3"),iface="eth0")

pwn.college{gwYcjx3cMASXlVyDcsk2ODoOBO1.dZjNzMDLwgjNykzW}

9.

与上一题同样输入python进入控制台，输入命令：

1
2
from scapy.all import *
sendp(Ether(src="a2:76:75:f2:ce:5f")/IP(src="10.33.107.8",dst= "10.0.0.3",proto=0xff),iface="eth0")

pwn.college{gHoiqWidLDmTgVpGfJRnw3rNr1-.ddjNzMDLwgjNykzW}

10.

与上一题同样输入python进入控制台，输入命令：

1
2
from scapy.all import *
sendp(Ether(src="a6:d6:77:aa:91:f9")/IP(src="10.33.107.8",dst= "10.0.0.3")/TCP(sport=31337,dport=31337,seq=31337,ack=31337,flags='APRSF'),iface="eth0")

pwn.college{gHoiqWidLDmTgVpGfJRnw3rNr1-.ddjNzMDLwgjNykzW}

Assembly Crash Course

在pwn.college网站做Assembly Crash Course部分的记录，由于做的时候没有记录，且都是写汇编语言，个人认为不好标注，因此没有什么描述，仅供参考思路。

average

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax,0
    mov r8,1
    mov rcx,0
    mov r9,rdi
    cmp r8,rsi
    ja done
o:  
    add rax,[r9]
    add r9,8
    add r8,1
    cmp r8,rsi
    jna o
    div rsi
done: nop
    '''))
print(p.recvallS()) #解码成str

bitwise-and

1
2
3
4
5
6
7
8
9
10
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    and rax,0
    or rax,rdi
    and rax,rsi
    '''))
print(p.recvallS()) #解码成str

byte-extraction

1
2
3
4
5
6
7
8
9
10
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax,rdi
    shl rax,0x0018
    shr rax,0x0038
    '''))
print(p.recvallS()) #解码成str

check-even

1
2
3
4
5
6
7
8
9
10
11
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    and rax,0x0000
    or rax,0x0001
    and rax,rdi
    xor rax,0x0001
    '''))
print(p.recvallS()) #解码成str

cmp

if [x] is 0x7f454c46:
y = [x+4] + [x+8] + [x+12]
else if [x] is 0x00005A4D:
y = [x+4] - [x+8] - [x+12]
else:
y = [x+4] * [x+8] * [x+12]

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.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov esi,[rdi+4]
    mov ebx,[rdi+8]
    mov ecx,[rdi+12]
    mov eax,[rdi]
    cmp eax,0x7f454c46
    je short s
    cmp eax,0x00005A4D
    je a
    mov eax,esi
    imul eax,ebx
    imul eax,ecx
    jmp done
a:  mov eax,esi
    sub eax,ebx
    sub eax,ecx
    jmp done
s:  mov eax,esi
    add eax,ebx
    add eax,ecx
    jmp done
done: nop
    '''))
print(p.recvallS()) #解码成str

most_common_byte

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

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

return max_freq_byte

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
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    push rbp
    mov rbp, rsp
    sub rsp, 256
    mov r9,0  ;i=0
loop1:
    mov r8,[rbp+r9]
    mov r10,rbp
    add r9,1
    cmp rdi,0
    je done
loop:
    mov rbx,0
    mov bl,[rdi]
    cmp rbx,0
    je done

    cmp bl,0x5a
    ja s
    mov rsi,rdi
    mov dil,bl
    call r8
    mov rdi,rsi
    mov [rdi],al

    add r9,1
s:
    add rdi,1
    jmp loop

done:
    mov rax,r9
    ret
    '''))
print(p.recvallS()) #解码成str

count non zero

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax,rdi
    test rdi, rdi
    jz done
loop:
    mov rbx,0
    mov bl,[rax]
    add rax,1
    cmp rbx,0
    jne loop
    sub rax,1
done:
    sub rax,rdi
    '''))
print(p.recvallS()) #解码成str

efficient-modul0

1
2
3
4
5
6
7
8
9
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov al, dil
    mov bx, si
    '''))
print(p.recvallS()) #解码成str

endian

1
2
3
4
5
6
7
8
9
10
11
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax, 0xdeadbeef00001337
    mov [rdi], rax
    mov rax, 0xc0ffee0000
    mov [rsi], rax
    '''))
print(p.recvallS()) #解码成str

increment

1
2
3
4
5
6
7
8
9
10
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()  #
p.send(asm('''
    mov rax,[0x404000]
    mov r9,0x1337
    add [0x404000],r9
    '''))
print(p.recvallS()) #解码成str

indirect

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    cmp rdi,4
    jnb o
    mov rax,rdi
    imul rax,8
    add rax,rsi
    jmp [rax]
o:  jmp [rsi+0x20]
    '''))
print(p.recvallS()) #解码成str

jump

1
2
3
4
5
6
7
8
9
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax,0x403000
    jmp rax
    '''))
print(p.recvallS()) #解码成str

memread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()  #mov rax,[0x404000]  mov [0x404000],rax
p.send(asm('''
    mov rdx,[0x404000]
    mov eax,[0x404000]
    mov rcx,rax
    mov rax,0
    mov ax,[0x404000]
    mov rbx,rax
    mov rax,0
    mov al,[0x404000]
    '''))
print(p.recvallS()) #解码成str

memsum

1
2
3
4
5
6
7
8
9
10
11
12
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax,[rdi]
    mov r9,rax
    mov eax,[rdi+8]
    add rax,r9
    mov [rsi],rax
    '''))
print(p.recvallS()) #解码成str

setupper

1
2
3
4
5
6
7
8
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov ah,0x42
    '''))
print(p.recvallS()) #解码成str

stack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov rax,[rsp]
    mov r8,[rsp+8]
    mov r9,[rsp+0x10]
    mov r10,[rsp+0x18]
    add rax,r8
    add rax,r9
    add rax,r10
    mov r8,4
    div r8
    push rax
    '''))
print(p.recvallS()) #解码成str

strlow

str_lower(src_addr):
i = 0
if src_addr != 0:
while [src_addr] != 0x00:
if [src_addr] <= 0x5a:
[src_addr] = foo([src_addr])
i += 1
src_addr += 1
return i

src_addr————rdi
return————rax.

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 *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    mov r9,0
    mov r8,0x403000
    cmp rdi,0
    je done
loop:
    mov rbx,0
    mov bl,[rdi]
    cmp rbx,0
    je done

    cmp bl,0x5a
    ja s
    mov rsi,rdi
    mov dil,bl
    call r8
    mov rdi,rsi
    mov [rdi],al

    add r9,1
s:
    add rdi,1
    jmp loop
done:
    mov rax,r9
    ret
    '''))
print(p.recvallS()) #解码成str

tranpoline

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from pwn import *
context.arch='amd64'
p=process('/challenge/run')
p.recvline()
p.send(asm('''
    jmp short s
    .rept 0x51
    nop
    .endr
s:  pop rdi
    mov rax,0x403000
    jmp rax
    '''))
print(p.recvallS()) #解码成str