Why The Bear Has No Tail (50) - TFC CTF 2025

import random
from secret_stuff import FLAG

class Challenge():
    def __init__(self):
        self.n = 2**26
        self.k = 2000
        # self.words = [i for i in range(n)]
        # self.buf = random.choices(self.words, k=k)
        self.index = 0

    def get_sample(self):
        self.index += 1
        if self.index > self.k:
            print("Reached end of buffer")
        else:
            print("uhhh here is something but idk what u finna do with it: ", random.choices(range(self.n), k=1)[0])

    def get_flag(self):
        idxs = [i for i in range(256)]
        key = random.choices(idxs, k=len(FLAG))
        omlet = [ord(FLAG[i]) ^ key[i] for i in range(len(FLAG))]
        print("uhh ig I can give you this if you really want it... chat?", omlet)

    def loop(self):
        random.random()
        while True:
            print("what you finna do, huh?")
            print("1. guava")
            print("2. muava")
            choice = input("Enter your choice: ")
            if choice == "1":
                self.get_sample()
            elif choice == "2":
                self.get_flag()
            else:
                print("Invalid choice")


if __name__ == "__main__":
    c = Challenge()
    c.loop()

def choices(self, population, weights=None, *, cum_weights=None, k=1):
    """Return a k sized list of population elements chosen with replacement.

    If the relative weights or cumulative weights are not specified,
    the selections are made with equal probability.

    """
    random = self.random
    n = len(population)
    if cum_weights is None:
        if weights is None:
            floor = _floor
            n += 0.0    # convert to float for a small speed improvement
            return [population[floor(random() * n)] for i in _repeat(None, k)]
    ...

ut = Untwister()
for sample in samples:
    #Just send stuff like "?11????0011?0110??01110????01???"
        #Where ? represents unknown bits
    ut.submit("{sample:026b}" + '?' * 6)
    ut.submit("?" * 32)

r2 = ut.get_random()
...

#!/usr/bin/env python3
from pwn import remote
import re
import ast, re
from main import Untwister

MENU_PROMPT = b"Enter your choice: "
ROUND_START = b"what you finna do, huh?"
END_OF_BUFFER = b"Reached end of buffer"
HOST = "the-bear-0307da4edd8dc924.challs.tfcctf.com"
PORT = 1337

SAMPLE_RE = re.compile(rb"idk what u finna do with it:\s*(\d+)")

def parse_sample(blob: bytes):
    if END_OF_BUFFER in blob:
        return None
    m = SAMPLE_RE.search(blob)
    if m:
        return int(m.group(1))
    ints = re.findall(rb"(\d+)", blob)
    if ints:
        return int(ints[-1])
    return None

def recover_flag(samples, encrypted_flag):
    ut = Untwister()

    # Submit each 32-bit tempered output with unknown high 6 bits.
    # Submit full 32-bit unknown
    for sample in samples:
        bits = f"{sample:026b}".replace("0b", "") + "?" * 6
        assert len(bits) == 32
        ut.submit(bits)
        ut.submit("?" * 32)

    r2 = ut.get_random()
    L = len(encrypted_flag)

    idxs = [i for i in range(256)]
    key = r2.choices(idxs, k=L)
    flag = "".join(chr(e ^ k) for e, k in zip(encrypted_flag, key))
    return flag

def solve():
    r = remote(HOST, PORT, ssl=True)
    samples = []
    try:
        r.recvuntil(MENU_PROMPT)
        for _ in range(1200):
            r.sendline(b"1")
            blob = r.recvuntil(ROUND_START)

            sample = parse_sample(blob)
            samples.append(sample)
            r.recvuntil(MENU_PROMPT)

        print(f"Collected {len(samples)} samples")
        r.sendline(b"2")
        blob = r.recvuntil(ROUND_START)

        # Extract the printed list from the blob
        m = re.search(rb"\[.*\]", blob, re.S)
        if not m:
            print("No omlet found")
            return
        omlet = ast.literal_eval(m.group().decode())
        print(omlet)
        print("Recovered flag: ", recover_flag(samples, omlet))
        r.recvuntil(MENU_PROMPT)
    finally:
        r.close()

if __name__ == "__main__":
    # Connect with TLS
    solve()