CertCTF 2025

Hade nöjet att delta i CertCTF som anordnades som en del av en kandidatuppsats inom digital forensik på Högskolan i Halmstad i samarbete med MSB och CERT-SE. För en som inte tidigare “tävlat” i CTF:er, utan bara tuggat igenom diverse Hack The Box, TryHackMe och OverTheWire så var CertCTF otrligt roligt och lärorikt.

Passade även på att dokumentera de flaggor jag lyckades samla på mig. Nedan följer en liten braindump jag knåpade ihop baserat på mina anteckningar. Jag fick tyvärr inte ihop alla flaggor jag hade hoppats på, men jag är nöjd med att ha placerat mig på 11:e plats av 61 deltagare. Inte illa för att vara första gången! 😉

När CTF:en startade fick man tillgång till en zip-fil innehållandes:

• Nätverksdump ifrån angreppet
• Windows-loggar ifrån en server som var utsatt
• Minnesdump från den utsatta servern

Inkluderat var även scenariot för CTF:en som finns att läsa nedan.

Intro

Gentle Dentals IT-ansvarig, Micke, har precis avslutat sin 45 minuter långa kafferast där han och chefen för tandvårdskliniken flitigt diskuterat dyra IT-säkerhetslösningar som chefen bedömer onödiga. När Micke sätter sig vid skrivbordet får han höra av tandläkaren Per att skrivaren beter sig konstigt.

När Micke undersöker skrivaren får han syn på en mini-dator som sitter inkopplad på ethernet-porten som skrivaren brukar använda. Micke får panik och inser att något fruktansvärt kan ha hänt. Han ringer dig som kan det här med IT-attacker och ber om hjälp då Gentle Dental har vissa viktiga, högt uppsatta kunder.

Du får ut all nätverkstrafik som skedde under Mickes kafferast på företagets nätverk tillsammans med händelseloggfiler och en minnesdump från deras fil-server. Ditt uppdrag är att utreda IT-attacken som skett för att ta reda på vad som har hänt.

Angriparens IPv4-address

Vilken IPv4-adress använde angriparen sig av initialt i attacken?

Format för svaret: 111.222.333.444

Konstaterade att det skickades otroligt mycket ARP-förfrågningar ifrån en specifik address, det ser helt klart ut som att någon skannar nätet efter svarande hosts. Flagga: 192.168.177.141

Domänkontrollantens IPv4-adress

Vilken IPv4-adress hade domänkontrollanten?

Format för svaret: 111.222.333.444

Domänkontrollanter pratar ofta LDAP, en sökning i nätverksdumpen på ldap så kan man konstatera att 192.168.177.129 snackar LDAP på port 389 och troligtvis är domänkontrollanten

Flagga: 192.168.177.129

FTP-Serverns IPv4-adress

Vilken IPv4-adress hade FTP-servern?

Format för svaret: 111.222.333.444

FTP använder oftast port 21. Söker man i nätverksdumpen efter trafik på port 21 så kan man se att angriparens server försöker prata mot flera IP adresser, men att det bara är 192.168.177.155 som svarar.

Flagga: 192.168.177.155

Angriparens hostname

Vad var angriparens hostname?

Lite klurigare men ändå ganska lätt. När man kollar på nätverksdumpen och filtrerar på angriparens server så kan man se att den gjorde den DHCP request. I DHCP requesten finns under Option 12 hostens hostname rakt upp och ned 👌

Flagga: Kali

Tidszon

Vilken lokal tid (svensk tid) anlände sista paketet i inspelningen av nätverkstrafiken? Avrunda neråt till hel sekund!

Format för svaret (HH:MM:SS): 01:23:45

Här var det bara att sätta wireshark till att visa lokal tid och scrolla längst ned i nätverksdumpen.

Flagga: 09:42:01

Windows Defender

Vilken MpPreference parameter ändrade angriparen för Windows Defender Antivirus?

Format för svaret: ParameterNamnet

Här fick man ta en titt i Windows defender loggarna.

Notera att registervärdet

HKLM\SOFTWARE\Microsoft\Windows Defender\Exclusions

ändras på något sätt. Detta är samma sak som att ändra i

Get-MpPreference | Select-Object ExclusionPath

Flaggan blir därmed: ExclusionPath

Obehörig inloggning

Angriparen lyckades logga in på en av datorerna på något sätt. Vilket Logon ID tillhör den obehöriga inloggningen?

Format för svaret: 0x123AB

Tittar man i Security loggarna efter events med Titta i Security loggarna efter angriparens lokala IP 192.168.155.141 så hittar man denna lyckade inloggning, jackpot!

Flagga: 0xFFCAB

Lösenord

Vilket lösenord använde angriparen för att logga in i utmaningen Obehörig inloggning

Format för svaret: Password123

Baserat på loggen i Obehörig inloggning vet vi tidpunkten för inloggning samt att autentiseringen gjordes via NTLM V2. NTLM V2 är vida känt att det är ett osäkert så detta borde man kunna knäcka. Vi har även tillgång till nätverkstrafiken för autentiseringen.

För o knäcka NTLMV2 behöver man veta lite saker: User, Domain, Challenge, NTLMV2Response samt HMAC-MD5.

Challengen kan vi hitta i Session Setup Responsen för NTLM autentiseringen Challenge: NTLM Server Challenge: 19c218f2f9a912c1

HMAC-MD5 och NTLMv2Response hittar vi i själva autentiseringen NTProofStr är samma som HMAC-MD5

HMAC-MD5: 7db9780888f4832bd162cf679cbffc0e

Scrollar man ner lite i samma packet så hittar vi även User och Domain

NTLMv2Response: 010100000000000080bf6de99591db01f7bccb719a3b1d400000000002001800470045004e0054004c004500440045004e00540041004c0001001400460054005000530045005200560049004300450004002400670065006e0074006c006500640065006e00740061006c002e006c006f00630061006c0003003a0046005400500053006500720076006900630065002e00670065006e0074006c006500640065006e00740061006c002e006c006f00630061006c00070008001829aae99591db010000000000000000

Detta kan man sedan lägga ihop till ett format som hashcat kan knäcka

FTPService::gentledental.local:19c218f2f9a912c1:7db9780888f4832bd162cf679cbffc0e:010100000000000080bf6de99591db01f7bccb719a3b1d400000000002001800470045004e0054004c004500440045004e00540041004c0001001400460054005000530045005200560049004300450004002400670065006e0074006c006500640065006e00740061006c002e006c006f00630061006c0003003a0046005400500053006500720076006900630065002e00670065006e0074006c006500640065006e00740061006c002e006c006f00630061006c00070008001829aae99591db010000000000000000

Använd valfri wordlist, t.ex rockyou

Kör igång katten med

hashcat.exe -a0 -m5600 hashcatcrack.txt rockyou.txt

• a0 specificerar straight mode, dvs applicera en wordlist.

• m5600 specificerar hash typen, i detta fall NetNTLMv2 hashes.

• hascatcrack.txt är strängen vi satte ihop tidigare.

• rockyou.txt är wordlisten vi använder.

Sverige, vi har ett resultat!

Session..........: hashcat
Status...........: Cracked

FTPSERVICE::gentledental.local:19c218f2f9a912c1:7db9780888f4832bd162cf679cbffc0e:010100000000000080bf6de99591db01f7bccb719a3b1d400000000002001800470045004e0054004c004500440045004e00540041004c0001001400460054005000530045005200560049004300450004002400670065006e0074006c006500640065006e00740061006c002e006c006f00630061006c0003003a0046005400500053006500720076006900630065002e00670065006e0074006c006500640065006e00740061006c002e006c006f00630061006c00070008001829aae99591db010000000000000000:DentalSurgery528

Lösenordet finns i slutet av strängen.

Flagga: DentalSurgery528

Angriparens server

Vilken IPv4-adress hade angriparens egna server?

Format för svaret: 111.222.333.444

I Powershell Operational loggarna kan man se att powershellscriptet som körs av angriparen b.la modiferar DNS Doh

Kort utklipp ur loggen:

$script:ClassName = 'ROOT/StandardCimv2/MSFT_DNSClientDohServerAddress'

Detta i kombination med den trafik som kan observeras gå ut ifrån FTP servern till en okänd IP, men som klassificeras som DNS trafik, fick mig att tänka att data exfiltreras via DNS. DNS-anropen ser även ytterst misstänkta ut, varför skulle något prata med Facebook domäner helt random?

Drog en kvalificerad gissning att 10.245.122.37 är angriparens server och det visade sig stämma.

Flagga: 10.245.122.37

Ransomware

Utöver den “vanliga” utmaningen fanns det även med en delutmaning gällande ransomware. Scenariot kan man läsa nedan.

Din kollega som har varit ansvarig för diskforensiken hittade en exekverbar fil och tre andra textfiler. En fil med känslig data verkar nu innehålla någon form av krypterad data. Kollegan är rätt säker på att den känsliga filen går att dekryptera och kommer till dig och ber om hjälp då du är expert inom områden såsom reverse engineering och kryptering.

Vad är nyckeln för att dekryptera filen?

Tillsammans med introt fick man även tillgång till filerna:

• ransom_note.txt
• pubkey.txt
• sensative_data.encrypted
• enc.exe

enc.exe användes för att kryptera filen.

pubkey.txt innehöll en publik nyckel: 506395958

sensative_data.encrypted innehöll krypterad data i formatet

(540488803, 187826906) (512275051, 36345508)...

Om man öppnar upp enc.exe i Ghidra och pillar runt lite så kan man hitta funktionen nedan som gissningsvis används för att generera den public keyn.

Efter mycket googlande, och lite AI-chattande, fick jag följande svar som kändes rimligt:

void gen_pub_k(uint param_1)
{
  mod_exp(2, param_1, 0x40000017);
  return;
}

mod_exp(base, exponent, modulus): This function is likely performing modular exponentiation:

result = (2^{\text{param_1}}) \mod 0x40000017 The value 0x40000017 in decimal is 1073741847, which is close to 2^30 , possibly chosen for cryptographic reasons.

param_1 is the exponent (probably a secret key or part of the key derivation process).

Bara ett par klick bort i Ghidra så hittar man mod_exp funktionen.

Exakt hur denna fungerar är för mig en gåta, man skulle kanske läst lite krypteringskurser på högskolan… Men ChatGPT hade ett svar!

Med det sagt hjälpte den också till att generera ett Python-script för att räkna ut den privata nyckeln, om något fick man modifiera det lite så att det skulle fungera..

import math

def brute_force_discrete_log(base, modulus, public_key, max_attempts=2**24):
    """Brute-force method to find x in base^x ≡ public_key (mod modulus)"""
    value = 1  # Start with base^0 = 1
    for x in range(max_attempts):
        if value == public_key:
            return x  # Found private key!
        value = (value * base) % modulus  # Compute next power
    return None  # Not found within the attempt limit

def baby_step_giant_step(base, modulus, public_key):
    """Baby-step Giant-step algorithm for discrete logarithm"""
    m = math.isqrt(modulus) + 1  # Step size
    table = {}

    # Baby-step: Compute base^j % modulus for j in [0, m]
    value = 1
    for j in range(m):
        table[value] = j
        value = (value * base) % modulus

    # Compute base^(-m) mod modulus (modular inverse of base^m)
    base_inv_m = mod_inverse(pow(base, m, modulus), modulus)

    # Giant-step: Compute public_key * base^(-i*m) % modulus
    value = public_key
    for i in range(m):
        if value in table:
            return i * m + table[value]  # Solution found
        value = (value * base_inv_m) % modulus

    return None  # No solution found

# Given values
base = 2
modulus = 1073741847  # 0x40000017
public_key = 506395958  # Example public key (replace with actual value)

# Try brute-force first (for small keys)
private_key = brute_force_discrete_log(base, modulus, public_key)
if private_key is None:
    print("Brute-force failed, trying Baby-Step Giant-Step...")
    private_key = baby_step_giant_step(base, modulus, public_key)

if private_key is not None:
    print(f"Recovered private key: {private_key}")
else:
    print("Failed to recover the private key.")

Kör man detta så resulterar det i att man får ut den privata nycklen som användes vid krypteringen, 177370085.

I Ghidra kan man kolla vidare och hitta följande funktion, som används för att kryptera datan.

void eg_enc(int param_1,uint param_2,uint *param_3,uint *param_4)

{
  int iVar1;
  uint uVar2;
  uint uVar3;
  
  iVar1 = rand();
  uVar3 = iVar1 % 0x40000016 + 1;
  uVar2 = mod_exp(2,uVar3,0x40000017);
  *param_3 = uVar2;
  uVar3 = mod_exp(param_2,uVar3,0x40000017);
  *param_4 = (uVar3 * param_1) % 0x40000017;
  return;
}

Men ännu lite AI hjälp kan man få ut följande lösning:

Även här fick man lite hjälp med att generera ett script som avkrypterar filerna med hjälp av private keyn.

from sympy import mod_inverse

def elgamal_decrypt(private_key, p, c1, c2):
    """Decrypts a single ElGamal encrypted pair (c1, c2)."""
    s = pow(c1, private_key, p)  # Compute shared secret: s = c1^private_key mod p
    s_inv = mod_inverse(s, p)  # Compute modular inverse of s
    M = (c2 * s_inv) % p  # Recover plaintext
    return M

# Given values
p = 1073741847  # Prime modulus
private_key = 177370085  # Recovered private key

# Encrypted data from file
encrypted_pairs = [
    (540488803, 187826906), (512275051, 37345508), (231599851, 823437630),
    (631399654, 628252041), (1035050165, 1006835836), (896417195, 206453254),
    (14141576, 263001145), (204987116, 186642158), (606374554, 598224082),
    (547306682, 128791588), (587262377, 531917810), (982294489, 538345953),
    (471862643, 967908048), (634400714, 763656344), (375171454, 544183238),
    (1055094817, 793021731), (39117044, 951544349), (361114958, 4360479),
    (327139844, 501552997), (467622466, 316485080), (36903752, 556784675),
    (44658571, 501318067), (443001524, 1031119903), (555206443, 620324572),
    (499990172, 366058919)
]

# Decrypt all pairs
decrypted_messages = [elgamal_decrypt(private_key, p, c1, c2) for c1, c2 in encrypted_pairs]

print("Decrypted messages:", decrypted_messages)

Kör man detta resluterar det i gäng med ASCII värden:

Decrypted messages: [mpz(80), mpz(101), mpz(108), mpz(108), mpz(101), mpz(95), mpz(83), mpz(118), mpz(97), mpz(110), mpz(115), mpz(108), mpz(111), mpz(115), mpz(95), mpz(72), mpz(97), mpz(114), mpz(95), mpz(83), mpz(118), mpz(97), mpz(110), mpz(115), mpz(10)]

Som i sin tur kan avkodas till text:

decrypted_ascii = [80, 101, 108, 108, 101, 95, 83, 118, 97, 110, 115, 108, 111, 115, 95, 72, 97, 114, 95, 83, 118, 97, 110, 115, 10]
decrypted_text = "".join(chr(c) for c in decrypted_ascii)
print(decrypted_text)

Resultat?

Flagga 1: 177370085

Flagga 2: Pelle_Svanslos_Har_Svans

Slut på det roliga

Kan absolut inte säga att jag förstår allting som görs, speciellt inte den bakomliggaande mattematiken, men någonting nytt har man ändå lärt sig. Att decompila binärfiler och hitta funktioner i den var ändå riktigt kul! Utredningsflaggorna kände jag mig hemma på, medan ransomware var betydligt klurigare.

Man kan inte slänga under stolen att AI är ett användbart verktyg, speciellt när man själv har ett litet hum om vad det är man vill få ut. Utan ChatGPT och Deepseeks utvecklande resonemang hade jag lätt fastnat på vissa bitar. Handlar helt enkelt om att använda dem på rätt sätt, man får se dem som en förlängning av ens egna förmåga.

Hade jag haft lite mer tid under helgen är jag säker på att hade kunnat ta några av de andra flaggorna, speciellt de som hade med autentiseringen att göra.

En full writeup av CTF:ens alla flaggor finns på organisatörernas github: https://github.com/heltseriost/CertCTF2025-Writeup

Läste igenom samtliga och blir lite frustrerad när man inser att man var så nära att lösa en flagga, men inte riktigt nådde hela vägen. En riktig miss jag gjorde var att inte titta på minnesdumpen, fastnade totalt i event loggar och decompiling. Men det är en del av att fortsätta lära sig.

Till nästa CTF, som inte är allt för långt borta, tar jag med mig detta. Att inte fastna allt för djupt i detaljerna, likaså försöka bilda mig en bild av hela händelseförloppet och inte bara varje individuell flagga.

Allt som allt en rolig CTF, speciellt för en nybörjare. Ransomware delen var svår, men ändå görbar med hjälp av google och lite AI. Helt klart nöjd med min 11:e plats.

Avslutningsvis…

https://www.youtube.com/watch?v=bLlj_GeKniA

Ses på lan, eller kanske på UNDUTMANINGEN 2025 🤠