def decrypt(enc):
    dec = ''
    for i in enc:
        dec += bin(i ^ 25)[2:].rjust(8, '0')
    enc = dec[:]
    dec = ''
    for i in range(0, len(enc), 4):
        dec += (enc[i + 2] + enc[i + 3] + enc[i] + enc[i + 1])
    enc = dec[:]
    dec = ''
    for i in enc[::-1]:
        dec += '1' if i == '0' else '0'
    final = b''
    for i in range(0, len(dec), 8):
        final += bytes([int(dec[i:i + 8], 2)])
    return final

enc = bytes.fromhex(open('loader_enc', 'r').read())
loader = decrypt(enc)
open('wpoffice_aam.ocx', 'wb').write(loader)

enc = bytes.fromhex(open('lurefile_enc', 'r').read())
lurefile = decrypt(enc)
open('EDGE_Group_Interview_NDA.docx', 'wb').write(lurefile)

import struct

def rotl32(x, n):
    return ((x << n) & 0xffffffff) | (x >> (32 - n))

def pack4(b):
    return struct.unpack('<I', bytes(b))[0]

def unpack4(x):
    return list(struct.pack('<I', x))

class ChaCha20:
    def __init__(self, key: bytes, nonce: bytes, counter: int = 0):
        assert len(key) == 32
        assert len(nonce) == 12
        self.state = [0] * 16
        self.keystream32 = [0] * 16
        self.counter = counter
        self.position = 64
        self.key = key
        self.nonce = nonce
        self._init_block()
        self._set_counter(counter)

    def _init_block(self):
        constants = b"expand 32-byte k"
        key = self.key
        nonce = self.nonce
        self.state[0] = pack4(constants[0:4])
        self.state[1] = pack4(constants[4:8])
        self.state[2] = pack4(constants[8:12])
        self.state[3] = pack4(constants[12:16])
        for i in range(8):
            self.state[4 + i] = pack4(key[i * 4:(i + 1) * 4])
        self.state[12] = 0
        for i in range(3):
            self.state[13 + i] = pack4(nonce[i * 4:(i + 1) * 4])

    def _set_counter(self, counter):
        self.state[12] = counter & 0xffffffff
        self.state[13] = pack4(self.nonce[:4]) + ((counter >> 32) & 0xffffffff)

    def _quarterround(self, x, a, b, c, d):
        x[a] = (x[a] + x[b]) & 0xffffffff
        x[d] = rotl32(x[d] ^ x[a], 16)
        x[c] = (x[c] + x[d]) & 0xffffffff
        x[b] = rotl32(x[b] ^ x[c], 12)
        x[a] = (x[a] + x[b]) & 0xffffffff
        x[d] = rotl32(x[d] ^ x[a], 8)
        x[c] = (x[c] + x[d]) & 0xffffffff
        x[b] = rotl32(x[b] ^ x[c], 7)

    def _block_next(self):
        x = self.state[:]
        for _ in range(10):
            self._quarterround(x, 0, 4, 8, 12)
            self._quarterround(x, 1, 5, 9, 13)
            self._quarterround(x, 2, 6, 10, 14)
            self._quarterround(x, 3, 7, 11, 15)
            self._quarterround(x, 0, 5, 10, 15)
            self._quarterround(x, 1, 6, 11, 12)
            self._quarterround(x, 2, 7, 8, 13)
            self._quarterround(x, 3, 4, 9, 14)
        for i in range(16):
            self.keystream32[i] = (x[i] + self.state[i]) & 0xffffffff
        self.state[12] = (self.state[12] + 1) & 0xffffffff
        if self.state[12] == 0:
            self.state[13] = (self.state[13] + 1) & 0xffffffff
            assert self.state[13] != 0

    def xor(self, data: bytes) -> bytes:
        output = bytearray()
        keystream = bytearray()
        for word in self.keystream32:
            keystream.extend(struct.pack('<I', word))
        for byte in data:
            if self.position >= 64:
                self._block_next()
                keystream = bytearray()
                for word in self.keystream32:
                    keystream.extend(struct.pack('<I', word))
                self.position = 0
            output.append(byte ^ keystream[self.position])
            self.position += 1
        return bytes(output)

key = bytes.fromhex("ad9c5aca9977d04c73be579199a827049b6dd9840091ffe8e23acc05e1d4a657")
iv = bytes.fromhex("edc9ce049daeba35b8687740")

enc = open('USOPrivate_enc', 'rb').read()
dec = b''
cipher = ChaCha20(key, iv, counter=1)
for i in range(0, 0x2D903, 16):
    dec += cipher.xor(enc[i:i+16])
    cipher.state[12] = cipher.state[12] + 1 & 0xffffffff
open('USOPrivate_dec', 'wb').write(dec)

from base64 import b64decode
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

enc = b64decode("zTJFPv1/59Of+S7AlhXPufXxy5abaigGREwmiXSvF9Q=")
key = b"x!P<&}mjH2YHRQ',"

cipher = AES.new(key, AES.MODE_CBC, key)
dec = unpad(cipher.decrypt(enc), AES.block_size)
print(dec)

from typing import Optional
import logging
import zipfile

def bit_check(n: bytes) -> int:
    return len(n) * 8

def rotr32(x: int, n: int) -> int:
    return (x >> n) + ((x << (32 - n))) & 0xffffffff

def rotl32(x: int, n: int) -> int:
    return (x << n) + ((x >> (32 - n))) & 0xffffffff

class HC256():
    def __init__(
        self,
        key: bytes,
        iv: bytes,
        log_level: Optional[int] = logging.WARN
    ):
        logging.basicConfig()
        self.logger = logging.getLogger(__name__)
        self.logger.setLevel(log_level)

        if bit_check(key) != 256:
            self.logger.warning("keylen != 256 bits, null-padding")

        if bit_check(iv) != 256:
            self.logger.warning("ivlen != 256 bits, null-padding")

        key = key + b"\x00" * (32 - len(key))
        iv = iv + b"\x00" * (32 - len(iv))
        # Convert to list of DWORD
        self.key = [
            int.from_bytes(key[i:i+4], byteorder="little")
            for i in range(len(key))[::4]
        ]

        self.iv = [
            int.from_bytes(iv[i:i+4], byteorder="little")
            for i in range(len(iv))[::4]
        ]

        self.logger.debug(f"key: {self.key}")
        self.logger.debug(f"iv: {self.iv}")
        self.__init_cipher()
        self.ctr = 0

    def __init_cipher(self):
        def f1(x):
            return (rotr32(x, 7) ^ rotr32(x, 18) ^ (x >> 3)) & 0xffffffff

        def f2(x):
            return (rotr32(x, 17) ^ rotr32(x, 19) ^ (x >> 10)) & 0xffffffff

        if len(self.key) != 8:
            raise ValueError("Invalid key len!")

        if len(self.iv) != 8:
            raise ValueError("Invalid IV len!")

        self.logger.debug("Setting key/IV")
        self.ctr = 0
        w = [0] * 2560
        self.P = None
        self.Q = None

        for i in range(len(self.key)):
            w[i] = self.key[i]
            w[i+8] = self.iv[i]

        for i in range(16, 2560):
            w[i] = ((
                ((f2(w[i-2]) + w[i-7]) & 0xffffffff) +
                (f1(w[i-15]) + w[i-16]) & 0xffffffffff
            ) + i) & 0xffffffff
        self.P = w[512:1536]
        self.Q = w[1536:]
        if len(self.P) != 1024 or len(self.Q) != 1024:
            raise ValueError(f"P/Q invalid len: P: {len(self.P)}, Q: {len(self.Q)}")
        # Run 4096 iters.
        self.logger.debug("Running keystream iterations before cipher")
        for i in range(4096):
            self.keystream()

    def keystream(self) -> int:
        r = None

        def g1(x: int, y: int) -> int:
            return ((rotr32(x, 10) ^ rotr32(y, 23)) + self.Q[(x ^ y) % 1024]) & 0xffffffff

        def g2(x: int, y: int) -> int:
            return ((rotr32(x, 10) ^ rotr32(y, 23)) + self.P[(x ^ y) % 1024]) & 0xffffffff

        def h1(x: int) -> int:
            r = self.Q[x & 0xff]
            r = (r + self.Q[256 + ((x >> 8) & 0xff)]) & 0xffffffff
            r = (r + self.Q[512 + ((x >> 16) & 0xff)]) & 0xffffffff
            r = (r + self.Q[768 + ((x >> 24) & 0xff)]) & 0xffffffff
            return r & 0xffffffff

        def h2(x: int) -> int:
            r = self.P[x & 0xff]
            r = (r + self.P[256 + ((x >> 8) & 0xff)]) & 0xffffffff
            r = (r + self.P[512 + ((x >> 16) & 0xff)]) & 0xffffffff
            r = (r + self.P[768 + ((x >> 24) & 0xff)]) & 0xffffffff
            return r & 0xffffffff

        j = self.ctr % 1024
        j3 = (j - 3) % 1024
        j10 = (j - 10) % 1024
        j12 = (j - 12) % 1024
        j1023 = (j - 1023) % 1024
        if self.ctr < 1024:
            self.P[j] = (
                self.P[j] +
                self.P[j10] +
                g1(self.P[j3], self.P[j1023])
            ) & 0xffffffff
            r = h1(self.P[j12])
            r = (r ^ self.P[j]) & 0xffffffff
        else:
            self.Q[j] = (
                self.Q[j] +
                self.Q[j10] +
                g2(self.Q[j3], self.Q[j1023])
            ) & 0xffffffff
            r = h2(self.Q[j12])
            r = (r ^ self.Q[j]) & 0xffffffff

        self.ctr = (self.ctr + 1) & 0x7ff
        return r

    def crypt(self, cipher: bytes) -> bytes:
        uncipher = list(cipher)
        i = 0
        while i < len(cipher):
            k = self.keystream()
            self.logger.debug(f"keystream[{i}]: {k}")
            j = 0
            while (j < 4 and i < len(cipher)):
                uncipher[i] ^= (k & 0xff)
                i += 1
                j += 1
                k = (k >> 8)

        return bytes(uncipher)

key = b'LH*x239udC<*sd_Sej%lOa0$&ujHl(.R'
encdat = open('enc_dat','rb').read()
cipher = HC256(key, key)
decdat = cipher.crypt(encdat)
open('PK_dat','wb').write(decdat)
zipfile.ZipFile('PK_dat', 'r').extractall('.')