buuctf-re (持续更新）

buuctf

1.easyre

查壳：

image-20210105181744994

没有壳，且为64位程序

分析：

image-20210105182318295

使用ida64分析该文件发现，只是简单的判断我们的输入相等则输出flag。

image-20210105181939132

#flag{this_Is_a_EaSyRe}

2.reverse1

查壳：

image-20210105182602212

无壳，64位程序

分析：

使用ida64分析

image-20210105182856224

输入的Str1字符串与Str2字符串比较，若相等则为flag。而Str2在进行比较之前做了一个变化，将 字符串中的字符 o 替换为 0.

故将Str2简单的替换一下即为flag

image-20210105183135228

#{hell0_w0rld}

3.reverse2

查壳：

image-20210105183328285

无壳，且为64位elf文件

分析：

image-20210105183542302

跟上题一样的套路，如果将flag中的i和r字符，替换为1

image-20210105183716521

手动还原即为flag

#{hack1ng_fo1_fun}

4.内涵的软件

查壳：

image-20210105184051676

无壳，32位程序

分析：

image-20210105185538070

分析了一段时间也没出来，突然回去看了一样hint。

结合hint

flag就是加上花括号里面的值image-20210105185606708

（这真的很内涵

image-20210105185508518

#flag{49d3c93df25caad81232130f3d2ebfad}

5.新年快乐

查壳：

image-20210105185826559

有upx壳，32位程序。

脱壳：

可以有工具脱也可以用esp定律法手脱。

分析:

image-20210105190454476

输入与v4进行判断。

v4=HappyNewYear!

结合hint

image-20210105190534320

#flag{HappyNewYear!}

6.[BJDCTF 2nd]guessgame

查壳：

image-20210106130115556

分析：

image-20210106130725962

明文显示。

#BJD{S1mple_ReV3r5e_W1th_0D_0r_IDA}

7.helloword

查壳：

image-20210106130933518

分析：

image-20210106131020276

#flag{7631a988259a00816deda84afb29430a}

8.xor

查壳：

image-20210106131123822

分析：

image-20210106133138985

对输入的字符进行了异或加密。

流程是下个字符异或上一个字符，然后与global中的字符进行比较。

解密即global中的字符与下一个字符进行异或即可。

解密：

str=[ 0x66, 0x0A, 0x6B, 0x0C, 0x77, 0x26, 0x4F, 0x2E, 0x40, 0x11,
  0x78, 0x0D, 0x5A, 0x3B, 0x55, 0x11, 0x70, 0x19, 0x46, 0x1F,
  0x76, 0x22, 0x4D, 0x23, 0x44, 0x0E, 0x67, 0x06, 0x68, 0x0F,
  0x47, 0x32, 0x4F]

flag=''

for i in range(0,len(str)-1):
    str[i]^=str[i+1]
    flag+=chr(str[i])

print(chr(0x66)+flag)


#flag{QianQiuWanDai_YiTongJiangHu}

9.reverse3

查壳：

image-20210106133422078

无壳，32位程序

分析：

IDA打开，查看字符串

image-20210106133517770

出现base64的表，猜测存在base64编码

image-20210106133556741

加密流程：

base64编码-->每个字符的acii码+下标-->与Str2比较

解密流程：

Str2的每个字符的acii码-下标-->base64解码

解密：

import base64

str='e3nifIH9b_C@n@dH'
flag=''
for i in range(len(str)):
    flag+=chr(ord(str[i])-i)
print(base64.b64decode(flag).decode('utf-8'))
#{i_l0ve_you}

flag{i_l0ve_you}

10.不一样的flag

查壳：

image-20210106140306427

无壳，32位程序

分析：

image-20210106140408535

发现有上下左右，猜测为迷宫题。开始那串01可能为地图。

分为5个一组有

image-20210106140522501

解密：

走一下

# *1111
# 01000
# 01010
# 00010
# 1111#
222441144222	

flag{222441144222}

11.SimpleRev

查壳：

image-20210106191606084

无壳，64位程序

分析：

image-20210106203814943

将KEY变成小写。

然后规定输入的字符为大写，然后进行一系列变化后字符与test的字符相等。

脚本：

一套逆向算法，一套爆破

test = 'killshadow'
key = 'ADSFKNDCLS'
for i in key:
    i += chr(ord(i) + 32)
    print(i[1:], end='')
flag1 = [0]*len(test)
key = 'adsfkndcls'
for i in range(len(test)):
    flag1[i]=(ord(test[i])-97)
print(flag1,end='')
flag2=[0]*len(test)
for i in range(len(test)):
    flag2[i]=(97-ord(key[i%10])-39)
print(flag2)
for i in range(len(test)):
    for f in range(ord('A'),ord('Z')+1):
        enc=f
        if flag1[i]==(enc-39-ord(key[i%10])+97)%26:

            print(chr(f),end='')

flag=''
for i in range(len(test)):
    for f in range(ord('A'),ord('Z')+1):
        enc=f
        if test[i]==chr((enc-39-ord(key[i%10])+97)%26+97):
            flag+=chr(f)
print(flag)

#flag{KLDQCUDFZO}

12.Java逆向解密

分析：

image-20210106204532847

输入的字符串中的字符+‘@’后的acii与32异或。然后与KEYList里面的值相等。

解密就是KEYList减去‘@’再与32异或

脚本：

str=[180, 136, 137, 147, 191, 137, 147, 191, 148, 136, 133, 191, 134, 140, 129, 135, 191, 65]
flag=''
for i in str:
    i=(i-ord('@'))^32
    flag+=chr(i)
print(flag)
#This_is_the_flag_!

13.刮开有奖

查壳：

image-20210106205207233

32位未加壳

分析：

image-20210106213440120

重新初始化v7的值，使用动态调试直接获得变化后的值。

image-20210106213524463

然后发现该函数位base64编码函数。

image-20210106213610383

base64的值给出了，直接获得原值，image-20210106213755834然后image-20210106213636204

求一下剩下的值。

最后得到flag为

flag{UJWP1jMp}

14.[BJDCTF 2nd]8086

查壳：

image-20210106213904862

未知文件？

打开ida查看

image-20210106214012361

密文异或了。

直接解密看看

s=']U[du~|t@{z@wj.}.~q@gjz{z@wzqW~/b;'
flag=''
for i in range(len(s)):
    flag+=chr(ord(s[i])^0x1f)
print(flag)
#BJD{jack_de_hu1b1an_xuede_henHa0}

15.[GKCTF2020]Check_1n

查壳：

image-20210106214434115

无壳，32位程序

分析：

image-20210106214529766

首先要找开机密码。

image-20210106214634358

发现一串疑似base64的字符串，拿去解密image-20210106215039867

接着还发现一串。编码。

image-20210106215023048

image-20210106215004144

这是非预期解，我们继续，正常分析。image-20210106215417023

image-20210106215406615

打砖块死亡后出现flag

image-20210106215603074

image-20210106215555759

flag{f5dfd0f5-0343-4642-8f28-9adbb74c4ede}

16.findit

查壳:

image-20210107112114147

未加固

分析：

image-20210107112207930

把代码扣下来，直接解密就行了

脚本：

c++

#include <iostream>

int main()
{
    
    char a[] = { 'T', 'h', 'i', 's', 'I', 's', 'T', 'h', 'e', 'F', 'l', 'a', 'g', 'H', 'o', 'm', 'e' };
    char b[] = { 'p', 'v', 'k', 'q', '{', 'm', '1', '6', '4', '6', '7', '5', '2', '6', '2', '0', '3', '3', 'l', '4', 'm', '4', '9', 'l', 'n', 'p', '7', 'p', '9', 'm', 'n', 'k', '2', '8', 'k', '7', '5', '}' };
    unsigned char x[17] = {};
    unsigned char y[38] = {};
    for (int i = 0; i < 17; i++) {
        if ((a[i] < 'I' && a[i] >= 'A') || (a[i] < 'i' && a[i] >= 'a')) {
            x[i] = (char)(a[i] + 18);
        }
        else if ((a[i] < 'A' || a[i] > 'Z') && (a[i] < 'a' || a[i] > 'z')) {
            x[i] = a[i];
        }
        else {
            x[i] = (char)(a[i] - '');
        }
    }
    for (int i2 = 0; i2 < 38; i2++) {
        if ((b[i2] < 'A' || b[i2] > 'Z') && (b[i2] < 'a' || b[i2] > 'z')) {
            y[i2] = b[i2];
        }
        else {
            y[i2] = (char)(b[i2] + 16);
            if ((y[i2] > 'Z' && y[i2] < 'a') || y[i2] >= 'z') {
                y[i2] = (char)(y[i2] - 26);
            }
        }
    }
    for (int i = 0; i < 38; i++) {
        printf("%c", y[i]);
    }
   
}

python

b=['p', 'v', 'k', 'q', '{', 'm', '1', '6', '4', '6', '7', '5', '2', '6', '2', '0', '3', '3', 'l', '4', 'm', '4', '9', 'l', 'n', 'p', '7', 'p', '9', 'm', 'n', 'k', '2', '8', 'k', '7', '5', '}']
y=[0]*len(b)
for i in range(len(b)):
    if ((b[i] < 'A' or b[i] > 'Z') and (b[i] < 'a' or b[i] > 'z')) :
        y[i] = b[i]
    else:
        y[i] = chr(ord(b[i] )+ 16)
        if ((y[i] > 'Z' and y[i] < 'a') or y[i] >= 'z') :
            y[i] = (chr) (ord(y[i]) - 26)
for i in y:
    print(i,end='')

17:[GXYCTF2019]luck_guy

查壳：image-20210107115140571

无壳，64位程序

分析：

image-20210107121418503

照着流程分析下去，解密即可

脚本：

str='icug`ofx7F'
print(len(str))
flag1='GXY{do_not_'
flag2=''
for i in range(8):
    if (i%2==1):
        flag2+=chr(ord(str[i])-2)
    else:
        flag2+=chr(ord(str[i])-1)

print(flag1+flag2)
#GXY{do_not_hate_me}
#注意，题目提交是flag{***}形式

18.简单注册器

查壳：image-20210107121506103

未加壳

分析：

分析代码流程发现，会对输入的字符串进行判断，输入不正确就跳出，那我们改smali代码，使其条件永远成立即可得flag

image-20210107123136857

image-20210107123022120

image-20210107122957933

另外一种解法，就是直接扣出这段代码，跑一下

image-20210107123302381

flag{59acc538825054c7de4b26440c0999dd}

19.[GWCTF 2019]pyre

分析：

使用umcompyle6反编译pyc文件

image-20210107123628017

简单的逆向一下就出来了

脚本：

# l = len(input1)
# for i in range(l):
#     num = ((input1[i] + i) % 128 + 128) % 128
#     code += num
#
# for i in range(l - 1):
#     code[i] = code[i] ^ code[(i + 1)]
code = ['x1f', 'x12', 'x1d', '(', '0', '4', 'x01', 'x06', 'x14', '4', ',', 'x1b', 'U', '?', 'o', '6', '*', ':', 'x01', 'D', ';', '%', 'x13']
str=[0]*len(code)
print()
for i in range(len(code)):
    str[i]=ord(code[i])
print(str)
str=str[::-1]
print(str)
for i in range(len(str)-1):
    str[i+1]=str[i]^str[i+1]
str=str[::-1]
print(str)
for i in range(len(str)):
    for f in range(0x20,0x7f):
        enc=f
        if(str[i]==((enc + i) % 128 + 128) % 128):
            print(chr(f),end='')
#GWHT{Just_Re_1s_Ha66y!}

20.RSA

解析key.得到N和e

写脚本解密即可。

import gmpy2
import rsa
 
e=65537
n=86934482296048119190666062003494800588905656017203025617216654058378322103517
p=285960468890451637935629440372639283459
q=304008741604601924494328155975272418463
 
phin = (p-1) * (q-1)
d=gmpy2.invert(e, phin)
 
key=rsa.PrivateKey(n,e,int(d),p,q)
 
with open("flag.enc","rb") as f:
    f=f.read()
    print(rsa.decrypt(f,key))
#flag{decrypt_256}

21.[BJDCTF2020]JustRE

查壳：

image-20210107153835920

32位无壳

分析：

image-20210107154526975

动调直接改条件成立即可得到flag

image-20210107154504054

22.CrackRTF

查壳：

image-20210107154700203

无壳32位

分析：

image-20210107162446487

第一步是的输入的6个数字，与“@DBAapp”进行拼接，然后经过sub_40100A后与40位的字符串进行比较。

我们打开sub_40100A发现

image-20210107162640352

好家伙，就看到hash，想到hash加密，但是有很多类型，拷贝函数名去网上现学了一波。

CryptCreateHash的第二参数如下图，为sha1加密

image-20210107162745162

我们直接爆破。

import hashlib
flag2='@DBApp'
for i in range(100000,999999):
    h2 = hashlib.sha1(str(i).encode()+flag2.encode())
    flags = h2.hexdigest()
    if "6e32d0943418c2c33385bc35a1470250dd8923a9" == flags:
            print (str(i)+flag2)
            print (flags)

可以得到我们输入的六个数字为

123321

进入第二关

image-20210107162929559

也是有一个加密函数加密了，我们继续分析。

image-20210107163012744

查看官方文档可知，此处为MD5加密image-20210107163032580

在线破解了一下，都破解不了。

那只能继续看程序流程

image-20210107164650920

读取AAA文件然后取内容进入sub_401005进行异或操作，然后传出来写入.rtf。

（然后下面百度的，不知道怎么做了）

原来是.rtf的文件头是固定的，而异或后传进来的前六个数刚好是文件头，所以在百度找到前六个数在做异或就可得到加密前的密文了。

image-20210107164505133

s = "{\rtf1"

a = [0x05, 0x7D, 0x41, 0x15, 0x26, 0x01]

flag = ""
for i in range(0, len(s)):
    x = ord(s[i]) ^ a[i]
    flag += chr(x)
print(flag)
#~!3a@0

然后按循序输入我们的答案即可，

然后当前目录下生成了

image-20210107170521078

23.

查壳：

image-20210107170919000

无壳64位

分析：

shift+f12发现

image-20210107171022634

了base64的表，猜测存在base64加密。

--------------复习了期末了，考完下再写了------------------------------------

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/pupububu/p/14237601.html