2024-08-16

BaseCTF 人生苦短我用Python（Misc）

代码

import base64
import hashlib

def abort(id):
    print('You failed test %d. Try again!' % id)
    exit(1)

print('Hello, Python!')
flag = input('Enter your flag: ')

if len(flag) != 38:
    abort(1)

if not flag.startswith('BaseCTF{'):
    abort(2)

if flag.find('Mp') != 10:
    abort(3)

if flag[-3:] * 8 != '3x}3x}3x}3x}3x}3x}3x}3x}':
    abort(4)

if ord(flag[-1]) != 125:
    abort(5)

if flag.count('_') // 2 != 2:
    abort(6)

if list(map(len, flag.split('_'))) != [14, 2, 6, 4, 8]:
    abort(7)

if flag[12:32:4] != 'lsT_n':
    abort(8)

if '😺'.join([c.upper() for c in flag[:9]]) != 'B😺A😺S😺E😺C😺T😺F😺{😺S':
    abort(9)

if not flag[-11].isnumeric() or int(flag[-11]) ** 5 != 1024:
    abort(10)

if base64.b64encode(flag[-7:-3].encode()) != b'MG1QbA==':
    abort(11)

if flag[::-7].encode().hex() != '7d4372733173':
    abort(12)

if set(flag[12::11]) != {'l', 'r'}:
    abort(13)

if flag[21:27].encode() != bytes([116, 51, 114, 95, 84, 104]):
    abort(14)

 if sum(ord(c) * 2024_08_15 ** idx for idx, c in enumerate(flag[17:20])) != 41378751114180610:
     abort(15)

if not all([flag[0].isalpha(), flag[8].islower(), flag[13].isdigit()]):
    abort(16)

if '{whats} {up}'.format(whats=flag[13], up=flag[15]).replace('3', 'bro') != 'bro 1':
    abort(17)

if hashlib.sha1(flag.encode()).hexdigest() != 'e40075055f34f88993f47efb3429bd0e44a7f479':
    abort(18)

print('🎉 You are right!')
import this

分析过程

1
2
3

def abort(id):
    print('You failed test %d. Try again!' % id)
    exit(1)

这个函数传入一个参数id，一旦传入参数，打印错误，根据函数调用情况来看，所以不能让if语句执行，所以if的条件要为否

条件1

1 2	if len(flag) != 38: abort(1)

要求flag字符串长度为38，那么构造字符串38

条件2

1 2	if not flag.startswith('BaseCTF{'): abort(2)

要求flag以’BaseCTF{‘开头，一定记住条件是反着的，如果开头不是这样，调用函数返回错误信息，所以这里一定要是这样，我们先用一种字符来占位

BaseCTF{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}

条件3

1 2	if flag.find('Mp') != 10: abort(3)

要求在字符串flag中搜索子字符串’Mp’，并且其索引值为10，那么就是从索引值10开始为’Mp’

BaseCTF{&&Mp&&&&&&&&&&&&&&&&&&&&&&&&&}

条件4

1 2	if flag[-3:] * 8 != '3x}3x}3x}3x}3x}3x}3x}3x}': abort(4)

要求从末尾倒着数3个字符×8之后是这个字符串，也就是最后三个字符是’3x}’

BaseCTF{&&Mp&&&&&&&&&&&&&&&&&&&&&&&3x}

条件5

1 2	if ord(flag[-1]) != 125: abort(5)

ord() 函数用于获取单个字符的Unicode码点

flag[-1]获取最后一个字符

125 是字符 ‘}’ 的Unicode码点

所以验证了flag最后一个字符

条件6

1 2	if flag.count('_') // 2 != 2: abort(6)

要求flag中的’_’的数量整除2等于2，那么就是’_‘的数量是4，但是还不知道位置，先看后面

条件7

1 2	if list(map(len, flag.split('_'))) != [14, 2, 6, 4, 8]: abort(7)

flag.split('_')：这个调用使用下划线（_）作为分隔符来分割字符串 flag

map 函数接受两个参数，第一个是一个函数（在这个例子中是 len 函数），第二个是一个可迭代对象（在这个例子中是 flag.split('_') 返回的列表）

map 函数会对可迭代对象中的每个元素应用第一个参数指定的函数，并返回一个迭代器，该迭代器包含应用函数后的结果，也就是map(len, ...) 会计算 flag.split('_') 返回的每个子字符串的长度，并返回一个包含这些长度的迭代器。

所以，相当于’_‘把整个flag分成了五段，且每段的数量就是列表中的数

BaseCTF{&&Mp&&_&&_&&&&&&_&&&&_&&&&&3x}

条件8

1 2	if flag[12:32:4] != 'lsT_n': abort(8)

这是一个切片，从索引值12开始到32（不包括）为止，步进为4

BaseCTF{&&Mpl&_&s_&&T&&&_&&&n_&&&&&3x}

条件9

1 2	if '😺'.join([c.upper() for c in flag[:9]]) != 'B😺A😺S😺E😺C😺T😺F😺{😺S': abort(9)

列表推导式 [c.upper() for c in flag[:9]]

这个列表推导式遍历 flag[:9] 中的每个字符 c，并将它们转换为大写（c.upper()）。

**'😺'.join(...)**：

这个方法尝试将列表推导式的结果（即一系列大写字符）使用 ‘😺’ 作为分隔符连接起来，形成一个新的字符串。

之前的所有过程都可以在pycharm上运行，但是这一步阻断了，之后的操作都不能再显示结果了，因为一旦你做了这一步，就违背了之前的以BaseCTF开头的条件，不做这一步，将会一直返回错误信息，所以这一条件没什么用，不用照着做

条件10

1 2	if not flag[-11].isnumeric() or int(flag[-11]) ** 5 != 1024: abort(10)

.isnumeric()：这是一个字符串方法，用于检查字符串中的所有字符是否都是数字字符

条件要求倒数第11个字符是否为数字，或者将其转换为整数的5次方是否为1024，or是任意满足就是true，所以让倒数第11位是数字且5次方为1024，所以为4

BaseCTF{&&Mpl&_&s_&&T&&&_&&4n_&&&&&3x}

条件11

1 2	if base64.b64encode(flag[-7:-3].encode()) != b'MG1QbA==': abort(11)

flag[-7:-3]：从倒数第7个字符到倒数第4个字符（不包括）切片

.encode()：这个方法将字符串（子串）编码成字节串（bytes）

base64.b64encode(...)：这是Python标准库中base64模块的一个函数，用于将字节串数据编码成Base64格式的字节串

所以这个’MG1QbA==’为Base64编码得来，那么直接解码，得到’0mPl’，将他放入flag中

BaseCTF{&&Mpl&_&s_&&T&&&_&&4n_&0mPl3x}

条件12

1 2	if flag[::-7].encode().hex() != '7d4372733173': abort(12)

.encode()：将字符串编码成字节串。

.hex()：这是字节串的一个方法，它将字节串中的每个字节转换为其16进制表示形式，并返回一个字符串。

从末尾以步进为7倒着取数，然后将其转换为16进制

所以将字符串从16进制转换为字符串就可以，网上有专门的转换工具，转换出来为’}Crs1s’，放入flag

BaseCTF{&1Mpl&_&s_&&T&&r_&&4n_C0mPI3x}

条件13

1 2	if set(flag[12::11]) != {'l', 'r'}: abort(13)

set()：将切片转换成一个集合（set）

从索引值为12的位置开始，步进11，设置值为’l’和’r’

发现这些值都已经设置过了，所以当验证吧

BaseCTF{&1Mpl&_&s_&&T&&r_&&4n_C0mPl3x}

条件14

1 2	if flag[21:27].encode() != bytes([116, 51, 114, 95, 84, 104]): abort(14)

从索引值21到27（不包括），放入ASCII值为这些的字符，为’t3r_Th’

BaseCTF{&1Mpl&_&s_&&Tt3r_Th4n_C0mPl3x}

条件15

1 2	if sum(ord(c) * 2024_08_15 ** idx for idx, c in enumerate(flag[17:20])) != 41378751114180610: abort(15)

flag[17:20]：切片，索引值17-20（不包括）

enumerate(...)：为这三个字符生成索引（0, 1, 2）

ord(c)：获取字符c的Unicode值。

2024_08_15 ** idx：计算2024_08_15的idx次幂。

sum(...)：把所有计算结果相加。

索引为17的字符为’_’，并且他的ASCII值为95，18和19是不知道的，设为x和y

结合得出一个公式：

95*20240815^0^+x*20240815^1^+y*20240815^2^=41378751114180610

直接写一个代码来遍历出x和y的值，能确定的是他们的ASCII值在0-127之间

代码如下：

for x in range(0,128):
    for y in range(0,128):
        if 95*20240815**0+x*20240815**1+y*20240815**2==41378751114180610:
            print(x,y)
#解出x=66，y=101

x和y对应的字符为B和e，填入flag

BaseCTF{&1Mpl&_&s_BeTt3r_Th4n_C0mPl3x}

条件16

1 2	if not all([flag[0].isalpha(), flag[8].islower(), flag[13].isdigit()]): abort(16)

.isalpha()方法检查是否是字母

.islower()方法本身会先检查字符是否是字母，然后才是否是小写

.isdigit()方法检查是否是一个数字

检查对应索引位置是否满足条件

得到一个线索，索引位置8为小写字母，但是也不知道值，所以先往下看

条件17

1 2	if '{whats} {up}'.format(whats=flag[13], up=flag[15]).replace('3', 'bro') != 'bro 1': abort(17)

.format() 方法对字符串 '{whats} {up}' 进行格式化。这里，{whats} 和 {up} 是占位符，它们将被 format() 方法中的关键字参数 whats 和 up 的值所替换。在这个例子中，whats 被替换为 flag[13] 的值，而 up 被替换为 flag[15] 的值

replace方法将’3’替换为’bro’输出结果，所以flag[13]=3，flag[15]=1

BaseCTF{&1Mpl3_1s_BeTt3r_Th4n_C0mPl3x}

条件18

1 2	if hashlib.sha1(flag.encode()).hexdigest() != 'e40075055f34f88993f47efb3429bd0e44a7f479': abort(18)

hashlib.sha1()函数需要一个字节串作为输入，而不是普通的字符串

.hexdigest()方法将计算出的哈希值（原本是一个字节串）转换为一个十六进制表示的字符串。

使用了Python的hashlib库来计算flag变量的SHA-1哈希值

现在就只差flag[8]没有计算出来

直接写一个代码