import base64
# 先把字母调换A换成Z，z换成a，然后倒序逐个字符转为二进制，在将二进制倒序逐步放⼊密文中
# 加密函数
def encode():
    with open('test1.txt','r') as f:
        result = ''
        for char in f.read():
            if char.isalpha():  
                if char.islower():
                    result += chr(122 - ord(char) + 97)  
                else:
                    result += chr(90 - ord(char) + 65)  
            else:
                result += char  # 保留⾮字⺟字符
        encrypted_text = ''.join(format(ord(char), '08b')[::-1] for char in 
result[::-1])
        text = ''.join(chr(int(encrypted_text[i:i + 8], 2)) for i in range(0, 
len(encrypted_text), 8))
    with open('m.txt','w',encoding='utf-8') as w:
        w.write(text)
 # 解密函数
def decode():
    with open ('m.txt','r',encoding='utf-8') as f:
        binary_encoding = ''.join(format(ord(char), '08b') for char in f.read())
        decrypted_text = ''.join(chr(int(binary_encoding[i:i + 8][::-1], 2)) for i 
in range(0, len(binary_encoding), 8))
        result = ""
        for char in decrypted_text[::-1]:
            if char.isalpha():  # 仅处理字母字符
                if char.islower():
                    result += chr(122 - ord(char) + 97) 
                else:
                    result += chr(90 - ord(char) + 65)  
            else:
                result += char  # 保留非字母字符
        return result
# 测试
encode()
print(decode())

strr='BAAAACBAAAACBAAAACBABACBAAAACABBBBCBAAAACBBAAACBBAAACBAAACBAAAACAAABBCBAAAACA
ABACBAAAACACBAAAACBBAAACBBAAACAABBBCBAAAACABBBBCBBAAACAAAABCBBAAACAAAAACBAAAACBABAC
BAAAACABBBBCBBAAACAAAABCBAAAACBBBBACBAAAACAABACBAAAACACBBAAACAAABBCAABBBCBAACBAAAAC
AAABBCBAAAACABBBBCBAAAACAAABBCBBAAACABCBBAAACBBBAACBAAAACAAABBCBBAAACABCBAAAACBAAAA
CBAAAACAABACBBAAACBBAAACBBAAACBAA'
p=''
for item in strr.split('C'):
   for i in item:
       if i=='A':
           p+='.'
       if i=='B':
           p+='-'
   p+=' '
print(p)

from flag import flag
import gmpy2
from Crypto.Util.number import *
import random
import time

assert flag.startswith(b'flag{') and flag.endswith(b'}\n')
assert len(flag) == 57

flag1 = flag[:14]
flag2 = flag[14:28]
flag3 = flag[28:42]
flag4 = flag[42:]

def q1():
    # 奇怪的随机
    random.seed(int(time.time()))
    for i in flag1:
        key = random.randint(0, 255)
        print(hex(key ^ i)[2:], end='')
    print()

def q2():
    # 好像是RSA耶
    p = getPrime(768)
    q = getPrime(768)
    n = p * q
    e = 65537
    c = pow(int.from_bytes(flag2, 'big'), e, n)
    print('n =', n)
    print('c =', c)
    print('gift = ', p^q)

def q3():
    # 好欸，gift会帮你大忙
    p = getPrime(1024)
    q = getPrime(1024)
    n = p * q
    e = 65537
    c = pow(int.from_bytes(flag3, 'big'), e, n)
    print('n =', n)
    print('c =', c)
    print('gift = ', p>>128<<128)

def q4():
    # 好像是仿射密码O.o?
    while True:
        a = random.randint(1, 255)
        if gmpy2.gcd(a, 256) == 1:
            break
    b = random.randint(1, 255)
    for i in flag4:
        print(hex((a * i + b) % 256)[2:], end='')
    print()

if __name__ == '__main__':
    q1()
    q2()
    q3()
    q4()

def e1():
    start = 1694746197
    end = 1794832585
    ci = bytearray.fromhex(c1)
    # print(ci)
    flag_str = 'flag{'
    key_str = b''
    for i in range(5):
        key_str += bytes([ci[i] ^ ord(flag_str[i])])
    # print(key_str)
    import random
    for i in range(start, end):
        random.seed(i)
        if random.randint(0, 255) == key_str[0]:
            if random.randint(0, 255) == key_str[1]:
                if random.randint(0, 255) == key_str[2]:
                    if random.randint(0, 255) == key_str[3]:
                        if random.randint(0, 255) == key_str[4]:
                            # print(i)
                            break
    random.seed(i)
    for i in range(len(ci)):
        print(chr(ci[i] ^ random.randint(0, 255)), end='')
    print()

def phase3(high_p, n):
   R.<x> = PolynomialRing(Zmod(n), implementation='NTL')
   p = high_p + x
   x0 = p.small_roots(X = 2^128, beta = 0.1)[0]
   
   P = int(p(x0))
   Q = n // P
   
   assert n == P*Q
       print("P = ", P)
   print("Q = ", Q)
   
   d = inverse_mod(65537, (P-1)*(Q-1))
   
n = 
19611845515284359662247227180782154029099865864933830186692165788116252384024980174
73615145822253832497538413583221968215685013928285421083320210181349076358369944751
81423331528255192483979496104477684477996955046186481993760941924669084974192244526
41187038667468266935808858291459629906505815855969713811506880442509946417170294700
32160880511613766457813006156077785410519767924484133215530439161248901356301760068
94098374697248742412324528671161472657454063671885455747912939097848134863072413289
93821317365701875974313778396271741605711150401667698186661451787280291106456128869
490333363854095115406461539484155281
high_p = 
12486169997030204062244994885683576189016578219922865040910688519470496181374653275
41707085905701844099285694575813137706637613849745987858675244587538853943003691255
59144501770075324888609868206057317301995740969619175284309266906598553310708904405
631582250925691470251725783174086755863681042731595837997056
phase3(high_p, n)

def e4():
    s4 = bytearray.fromhex(c4)
    int_a = s4[-1]
    int_b = s4[-2]
    # print(hex(int_a), hex(int_b))
    CONST_A = ord("\n")
    CONST_B = ord("}")
    k = ((int_a - int_b) * gmpy2.invert((CONST_A - CONST_B), 256)) % 256
    # print(k)
    b = (int_a - k * CONST_A) % 256
    # print(b)
    # 仿射密码解密
    for i in s4:
        print(chr((i-b)*gmpy2.invert(k, 256) % 256), end='')

from qiskit import *
 from qiskit.visualization import plot_histogram
 # Use Aer's qasm_simulator
 simulator = Aer.get_backend('qasm_simulator')
 # Create a Quantum Circuit acting on the q register
 circuit = QuantumCircuit(36, 3)
 # Add a H gate on qubit 0
 circuit.x(0)
 circuit.x(1)
 circuit.i(2)
 circuit.x(3)
 circuit.x(4)
 circuit.x(5)
 circuit.i(6)
 circuit.x(7)
 circuit.x(8)
 circuit.x(9)
 circuit.i(10)
 circuit.x(11)
 circuit.i(12)
 circuit.x(13)
 circuit.i(14)
 circuit.i(15)
 circuit.x(16)
 circuit.i(17)
 circuit.x(18)
 circuit.i(19)
 for xxx in range(20):
    circuit.h(xxx)
 # Add a CX (CNOT) gate on control qubit 0 and target qubit 1
 circuit.ccx(3,7,21)
 circuit.ccx(2,6,23)
 circuit.ccx(12,13,24)
 circuit.ccx(10,11,25)
 circuit.ccx(14,15,26)
 circuit.ccx(1,5,27)
 circuit.ccx(9,10,28)
 circuit.ccx(0,4,29)
 circuit.ccx(5,11,30)
 circuit.ccx(2,8,31)
 circuit.cx(21,24)
 circuit.x(27)
 circuit.ccx(4,30,31)
 circuit.cx(24,25)
 circuit.cx(27,30)
 circuit.ccx(4,11,32)
 circuit.ccx(23,24,26)
 circuit.ccx(27,28,29)
 circuit.ccx(30,32,34)
 circuit.cx(29,31)
 circuit.cx(17,34)
 circuit.cx(31,33)
 circuit.ccx(18,34,35)
 circuit.x(33)
 circuit.measure(35,2)
 circuit.ccx(34,31,20)
 # Map the quantum measurement to the classical bits
 circuit.measure(33,0)
 circuit.measure(34,1)
 # qc_cir.measure_all()
 # Execute the circuit on the qasm simulator
 re = simulator.run(circuit,shots=1000000).result()
 # re = execute(qc_cir,simulator,shots=100).result()
 # Grab results from the job
 # Returns counts
 counts = re.get_counts()
 print(counts)
 print(len(counts))
 circuit.draw(output='mpl')

def fibonacci_shift_decrypt(encrypted_text, fib_list):
   decrypted_text = ""
   for i, char in enumerate(encrypted_text):
       if char.isalpha():  # 只对字母字符进行解密
           shift = fib_list[i]  # 从预先计算的斐波那契数列表中获取偏移量
           char_code = ord(char)
           offset = 65 if char.isupper() else 97  # 大写字母和小写字母的ASCII码基点不同
           # 解密字符并添加到解密文本中
           decrypted_char = chr(((char_code - offset - shift) % 26) + offset)
           decrypted_text += decrypted_char
       else:
           decrypted_text += char  # 非字母字符保持不变
   return decrypted_text
# 预先计算的斐波那契数列表
fib_list = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]
# 测试
encrypted_text = "hmcvxg_nsb_oabhd"
decrypted_text = fibonacci_shift_decrypt(encrypted_text, fib_list)
print("Decrypted Text:", decrypted_text)

import base64
import string
# Base64编解码
def b64en(path_in, path_out):
    with open(path_in, 'rb') as fileObj:
        image_data = fileObj.read()
        base64_data = base64.b64encode(image_data)
        fout = open(path_out, 'w')
        fout.write(base64_data.decode())
        fout.close()
    pass
 def b64de(path_in, path_out):
    b64_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
    # 读取需要解码的⽂本⽂件
    with open(path_in, "r", encoding="utf-8") as text_file:
        encoded_string = text_file.read()
    # 去除⽆效字符和换⾏符
    encoded_string = ''.join(filter(lambda c: c in b64_table, 
encoded_string)).replace("\n", "")
    # 将Base64编码字符串转换为字节串
    encoded_bytes = bytes(encoded_string, "utf-8")
    # 初始化解码后的字节串和计数器
    decoded_bytes = bytearray()
    cnt = 0
    # 逐个解码Base64字符
    for b64_char in encoded_bytes:
        # 计算Base64字符在字符表中的索引
        index = b64_table.index(chr(b64_char))
        # 根据计数器的值，将16位的⼆进制数填⼊32位的缓冲区中
        if cnt == 0:
            buffer = index << 2
            cnt = 1
        elif cnt == 1:
            buffer |= (index >> 4) & 0x03
            decoded_bytes.append(buffer)
            buffer = (index & 0x0f) << 4
            cnt = 2
        elif cnt == 2:
            buffer |= (index >> 2) & 0x0f
            decoded_bytes.append(buffer)
            buffer = (index & 0x03) << 6
            cnt = 3
        else:
            buffer |= index
            decoded_bytes.append(buffer)
            cnt = 0
    #print(decoded_bytes)
    # 将解码后的字节串写⼊图⽚⽂件
    with open(path_out, "wb") as image_file:
        image_file.write(decoded_bytes)
    
if __name__ == '__main__':
    b64en("pic.jpg", "pic")
    b64de("pic", "de_pic.jpg")

import string
 import re
 def grid_decrypt(encrypted_message):
    decrypted_message = ""
    length = len(encrypted_message)
    for i in range(length):
        if i % 2 == 0 and i != length-1:
            decrypted_message += encrypted_message[i]
    for i in range(length):
        if i % 2 == 1:
            decrypted_message += encrypted_message[i]
    if length % 2:
        decrypted_message += encrypted_message[-1]
    return decrypted_message
 def decrypt_message(encrypted_message, r, k):
    for i in range(r):
        encrypted_message = encrypted_message[-1] + encrypted_message[:-1]
        encrypted_message = grid_decrypt(encrypted_message)
    replace_message = r'[#$&()\[\]<>?!%^@+=]'
    encrypted_message = re.sub(replace_message, '', encrypted_message)

    plain_message = ""
    for char in encrypted_message:
        if char in string.ascii_lowercase:
            plain_char = chr(((ord(char) - k - 97 + 26) % 26) + 97)
            plain_message += plain_char
        elif char in string.ascii_uppercase:
            plain_char = chr(((ord(char) - k - 65 + 26) % 26) + 65)
            plain_message += plain_char
        else:
            plain_message += char
    return plain_message
 encrypted_message = "1$0Osdy__s_<mp6H1{Jf5V@SE0+pY6_=!Hwv06w0V7}xk"
 for k in range(26):
    for r in range(10, 20):
        decrypted_message = decrypt_message(encrypted_message, r, k)
        if "flag{" in decrypted_message:
            print(f"r={r},k={k},: {decrypted_message}")

# md5爆破key：
import hashlib
 str1 = "d567b916876527"
 str2 = "891b14d536be997e8d5"
 str3 = "7b916876527d8"
 str4 = "1b14d536b"
 str5 = "997e8"
 # 将所有可打印字符存⼊数组 , ⽤于遍历所有字符
res = [' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '
', '.', '/', '0', '1', '2', '3', '4', '5',
 '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C',
 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
 'Z', '[', ']', '^', '_', '`', 'a', 'b',
 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
 'y', 'z', '{', '|', '}', '~ ']
 def getMd5(plaintext):
    md5Object = hashlib.md5()
    md5Object.update(plaintext.encode('utf-8'))
    return md5Object.hexdigest()
    
for i in res:
    for j in res:
        for k in res:
            for l in res:
                plaintext = str1 + i + str2 + j + str3 + k + str4 + l + str5
 # 拼接明⽂字符串
                md5 = getMd5(plaintext)
 # 判断是否成功
                if md5.startswith("0e79216") and md5.endswith("0948"):
                print("Success! The plaintext is:", plaintext)
                exit(0)
 print("No match found.")
 #因为四层循环，需要等待⼀⼩段时间才能运⾏出来结果
 #Success! The plaintext is:
 d567b916876527d891b14d536be997e8d567b916876527d891b14d536be997e8

from Crypto.Cipher import AES
import random
from gmpy2 import *
def generate_random_bytes(length):
   return bytes([random.randint(0, 255) for _ in range(length)])
def main():
   enc_flag =
b"\x189\xdb\x11t\xb8\xc5\xe8\xe5\xa8n\x04'XH\x13\x9c9\xe8\x88\x0c>\xe7\xde\t\xa0\xad\x7f\xb4u\x1f\xc1"
   hex_key_str ="d567b916876527d891b14d536be997e8d567b916876527d891b14d536be997e8"
   hex_iv_str = "33a4235ea4d294c113c5ff98447c927a"
   key = bytes.fromhex(hex_key_str)
   iv = bytes.fromhex(hex_iv_str)
   aes = AES.new(key, AES.MODE_CBC, iv)
   print(aes.decrypt(enc_flag))

if __name__ == "__main__":
   main()
# flag{O.o_y0u_can_so1v3_AES_now!}

null='''
0 0 0 0 0 0 
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
'''
m='''
0 0 0 0 0 0
0 1 0 0 0 1
0 0 0 0 0 1
0 0 0 0 0 1
0 0 0 0 0 1
0 1 1 1 1 1
'''
c='''
1 1 0 0 0 0 
0 0 0 0 0 0
1 1 0 0 0 0
0 0 1 1 0 0
0 0 1 1 0 0
0 0 1 1 0 0
'''
y='''
0 0 0 0 0 0 
0 1 0 1 0 0
0 1 0 1 0 0
0 1 0 1 0 0
0 1 0 1 0 0
0 1 0 1 0 0
'''
d='''
0 0 0 0 0 0 
1 1 1 1 1 1
0 0 0 0 0 0
1 1 0 0 0 0
0 0 1 1 0 0
0 0 0 0 1 1
'''
s='''
0 1 1 0 0 0 
0 1 1 0 0 0
0 0 1 1 0 0
0 0 1 1 0 0
0 0 1 1 0 0
0 0 0 0 0 0
'''
h='''
0 0 0 0 0 0 
0 1 1 1 1 1
0 0 0 0 0 0
0 1 1 1 1 1
0 0 0 1 0 0
0 0 0 0 0 0
'''
e='''
0 0 0 0 0 0 
1 0 0 0 1 0
1 0 0 0 0 0
1 0 0 0 0 0
1 1 1 1 1 0
0 0 0 0 0 0
'''
i='''
0 0 0 0 0 0 
0 0 1 1 0 0
0 0 1 1 0 0
0 0 0 0 0 0
0 0 1 1 0 0
0 0 1 1 0 0
'''
'''
还有⼏个字⺟的图，找不到啦，反正就是这样
'''
print(m+c+null+i+s+null+a+null+g+o+o+d+null+g+a+m+e)

def decrypt(text):
    en_text = ""
    for c in text:
        if c == " ":
            en_text += "_"
        elif c == "a":
            en_text += "@"
        elif c == "c":
            en_text += "("
        elif c == "d":
            en_text += "$"
        elif c == "e":
            en_text += "3"
        elif c == "o":
            en_text += "0"
        elif c == "i":
            en_text += "!"
        else:
            en_text += c.upper()
    return en_text
text = "now you know acropalypse~"
print("flag{%s}" % decrypt(text))