def grouper(iterable, n, fillvalue=None):    """returns a generator which iterates iterable in groups of size n.    in case the last group is incomplete, it is padded with fillvalue"""    args = [iter(iterable)] * n    return itertools.izip_longest(fillvalue=fillvalue, *args)def rol(val, n, width):    """equivalent to the x86 rol opcode"""    return (val << n) & ((1<<width)-1) | \           ((val & ((1<<width)-1)) >> (width-n))def encrypt(key, plain):    size = len(plain)-2    enc = io.BytesIO(plain)    # phase 1    key_cyclic = grouper(itertools.cycle(key), 4)    for _ in xrange(0, size&(~0x3), 2): # align the size of the data to a multiple of 4 bytes        # get the next key dword        k = "".join(key_cyclic.next())        k = struct.unpack("<I", k)[0]        # get the next data dword        d = enc.read(4)        d = struct.unpack("<I", d)[0]        # XOR them and put it back to the data        e = k^d        e = struct.pack("<I", e)        enc.seek(-4, os.SEEK_CUR)        enc.write(e)        # go back 2 bytes in the data stream (so that loop iterations overlap)        enc.seek(-2, os.SEEK_CUR)    # phase 2    enc.seek(0, os.SEEK_SET)    key_cyclic = grouper(itertools.cycle(key), 4)    for i in xrange(0, size&(~0x3), 4):        # get the next key dword        k = "".join(key_cyclic.next())        k = struct.unpack("<I", k)[0]        # get the next data dword        d = enc.read(4)        d = struct.unpack("<I", d)[0]        # rotate the data dword        e = rol(d, 5, 32)        # XOR it with the key dword        e = e^k        # swap the byte order        e = struct.pack(">I", e)        # put the data dword back        enc.seek(-4, os.SEEK_CUR)        enc.write(e)    return enc.getvalue()def encrypt_file(key, file):    # len(key) == 25000    # leave the first 4 bytes as-is    file.seek(4, os.SEEK_SET)    # encrypt the rest of the first 1MB of the file    plain_data = file.read(0x100000 - 4)    enc_data = encrypt(key, plain_data)    file.seek(4, os.SEEK_SET)    file.write(enc_data)    # leave the rest of the file as is

key_len = 25000def ror(val, n, width):    return ((val & ((1<<width)-1)) >> n) | \           (val << (width-n) & ((1<<width)-1))def recover_stream_key(plain, enc, idx):    assert len(plain) == len(enc)    assert len(plain) >= 4 + idx + key_len     plain = io.BytesIO(plain)    enc = io.BytesIO(enc)    assert plain.read(4) == enc.read(4)    plain.seek(idx & (~3), os.SEEK_CUR)    enc.seek(idx & (~3), os.SEEK_CUR)    stream_key = io.BytesIO()    for i in xrange(0, key_len + (idx % 4), 4):        # read the next plain dword        p = plain.read(4)        p = struct.unpack("<I", p)[0]        # read the next encrypted dword and undo the bit shifts on it        e = enc.read(4)            # unswap the byte order        e = struct.unpack(">I", e)[0]            # ROR back 5 bits        e = ror(e, 5, 32)        # XOR the plain and normalized encrypted dwords        k = p^e        k = struct.pack("<I", k)        # write the stream key dword to the recovered stream key stream        if i == 0:            stream_key.write(k[idx % 4:])        elif i < key_len:            stream_key.write(k)        else: # i == key_len            stream_key.write(k[:-idx % 4])    stream_key = stream_key.getvalue()    assert len(stream_key) == key_len    return stream_key

def decrypt(stream_key, enc):    size = len(enc) - 2    plain = io.BytesIO(enc)    stream_key_cyclic = grouper(itertools.cycle(stream_key), 4)    for i in xrange(0, size&(~3), 4):        # read the next stream key dword        sk = "".join(stream_key_cyclic.next())        sk = struct.unpack("<I", sk)[0]        # read the next encrypted dword and undo the bit shifts on it        e = plain.read(4)            # unswap the byte order        e = struct.unpack(">I", e)[0]            # ROR back 5 bits        e = ror(e, 5, 32)        # XOR the normalized encrypted dword with the stream key dword to recover        # the plain dword        p = e^sk        p = struct.pack("<I", p)        plain.seek(-4, os.SEEK_CUR)        plain.write(p)    return plain.getvalue()def decrypt_file(stream_key, file):    assert len(stream_key) == key_len    # leave the first 4 bytes as-is    file.seek(4, os.SEEK_SET)    # decrypt the rest of the first 1MB of the file    enc_data = file.read(0x100000 - 4)    plain_data = decrypt(stream_key, enc_data)    file.seek(4, os.SEEK_SET)    file.write(plain_data)    # leave the rest of the file as is

key_bitlen = 25000*8def k_for_i(i):    i_dword = i >> 5 # the index of the dword for bit i    i_offset = i % 32 # the index of bit i in its dword    i = i + key_bitlen    k = []    k.append((i_dword << 6) + i_offset)    if i_offset < 16:        k.append(k[0] - 16)    else:        k.append(k[0] + 16)    k.append((i_dword << 5) + ((i_offset + 5) % 32))    return [x % key_bitlen for x in k if x >= 0]

# fix the following parameters to those of your ownstream_key_idx = 25000 # the stream key idx you recoveredstream_key_path = "key-stream-idx-25000.bin" # the path to the stream key you recoveredoriginal_key_path = "key.bin" # the path to write the original key toimport itertoolsimport structdef grouper(iterable, n, fillvalue=None):    args = [iter(iterable)] * n    return itertools.izip_longest(fillvalue=fillvalue, *args)def str2bits(s):    bits = []    for dword in grouper(s, 4):        dword = "".join(dword)        dword = struct.unpack("<I", dword)[0]        bits += [(dword >> i) & 1 for i in xrange(32)]    return bitsdef bits2str(bits):    s = []    for dword_bits in grouper(bits, 32):        dword = 0        for i, bit in enumerate(dword_bits):            dword = dword | (bit << i)        s.append(struct.pack("<I", dword))    return "".join(s)with open(stream_key_path) as f:    stream_key = f.read()assert len(stream_key) == 25000stream_key_bits = str2bits(stream_key)Y = vector(GF(2), 200000, stream_key_bits)# create a matrix with the equations for the stream key bitA_i_j_s = gen_equations(stream_key_idx)A = matrix(GF(2), 200000, sparse=True)for i, A_i_j in enumerate(A_i_j_s):    for j in A_i_j:        A[i,j] = 1# recover the original key bitsX = A.solve_right(Y)key_bits = [int(x) for x in X.list()]key = bits2str(key_bits)with open(original_key_path, 'wb') as f:    f.write(key)