from Crypto.Cipher import ChaCha20_Poly1305
import os

key = os.urandom(32)
nonce = os.urandom(12)

with open('flag.txt', 'rb') as f:
    plaintext = f.read()

cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce)

ct, tag = cipher.encrypt_and_digest(plaintext)

print(f"Encrypted Flag: {ct.hex()}")
print(f"Tag: {tag.hex()}")
print(f"Nonce: {nonce.hex()}")

with open('key.txt', 'w') as key_file:
    key_file.write(key.hex())

from Crypto.Cipher import ChaCha20_Poly1305
from binascii import unhexlify

# 已知的加密参数(替换为实际值)
key_hex = "173974535637a5ef30a116b03d00bd2fe751951ca3eaa62daec2b8f5ca5b6135"
nonce_hex = "d8ebeedec812a6d71240cc50"
ciphertext_hex = "20408b9fc498063ad53a4abb53633a6a15df0ddaf173012d620fa33001794dbb8c038920273464e13170e26d08923aeb"
tag_hex = "70ffcc508bf4519e7616f602123c307b"

# 转换十六进制为字节
key = unhexlify(key_hex)
nonce = unhexlify(nonce_hex)
ciphertext = unhexlify(ciphertext_hex)
tag = unhexlify(tag_hex)

# 创建解密器
cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce)

try:
    # 解密并验证
    plaintext = cipher.decrypt_and_verify(ciphertext, tag)
    print(f"解密后的明文: {plaintext.decode()}")
except ValueError as e:
    print(f"解密失败: {str(e)}")

def generate_payload(target_text, key):
    payload = ""
    key_length = len(key)

    for i, char in enumerate(target_text):
        if 'A' <= char <= 'Z':
            shift = ord(key[i % key_length])
            original_char = (ord(char) - 65 - shift + 65) % 26 + 65
            payload += chr(original_char)
        else:
            payload += char

    return payload


target_text = "QKEMK{7JB5_i5_W3SllD_3z_W3}"
key = "ISCTF"


payload = generate_payload(target_text, key)
print("Generated Payload:", payload)

import libnum
import gmpy2
from Crypto.Util.number import *

flag=b'ISCTF{********}'
m=bytes_to_long(flag)

p=libnum.generate_prime(1024)
q=libnum.generate_prime(1024)
n=p*q
e=0x10001
c=pow(m,e,n)
d=inverse(e,(p-1)*(q-1))
leak = (d+(pow(p,q,n)+pow(q,p,n)))%n

print("c=", c)
print("n=", n)
print("leak=", leak)

"""
c= 8989289659072309605793417141528767265266446236550650613514493589798432446586991233583435051268377555448062724563967695425657559568596372723980081067589103919296476501677424322525079257328042851349095575718347302884996529329066703597604694781627113384086536158793653551546025090807063130353950841148535682974762381044510423210397947080397718080033363000599995100765708244828566873128882878164321817156170983773105693537799111546309755235573342169431295776881832991533489235535981382958295960435126843833532716436804949502318851112378495533302256759494573250596802016112398817816155228378089079806308296705261876583997
n= 13424018200035368603483071894166480724482952594135293395398366121467209427078817227870501294732149372214083432516059795712917132804111155585926502759533393295089100965059106772393520277313184519450478832376508528256865861027444446718552169503579478134286009893965458507369983396982525906466073384013443851551139147777507283791250268462136554061959016630318688169168797939873600493494258467352326974238472394214986505312411729432927489878418792288365594455065912126527908319239444514857325441614280498882524432151918146061570116187524918358453036228204087993064505391742062288050068745930452767100091519798860487150247
leak= 9192002086528025412361053058922669469031188193149143635074798633855112230489479254740324032262690315813650428270911079121913869290893574897752990491429582640499542165616254566396564016734157323265631446079744216458719690853526969359930225042993006404843355356540487296896949431969541367144841985153231095140361069256753593550199420993461786814074270171257117410848796614931926182811404655619662690700351986753661502438299236428991412206196135090756862851230228396476709412020941670878645924203989895008014836619321109848938770269989596541278600166088022166386213646074764712810133558692545401032391239330088256431881
"""

import hashlib
import numpy as np
from queue import Queue
from heapq import heappush, heappop

maze_str = """
###############################P#...............#...#.......#.#####.###.#####.#.###.#####.#.....#...#.#.....#...#.#...#.#####.#.###.#.#######.#.#.###.#C..#.#.#...#.#...#...#.#.#...#.#.#.#.#.###.#.#.#.###.#.#.#.#.#.#.#.#...#...#.#.......#.#.#.###.#.###.#####.#########.###.#...#...#.....#.#.......#...#.#.#####.#####.#.#.#####.###.#...#...#...#...#...#...#.#...#.###.#.###.#.#######.#.#.#.#.#...#.#.#...#.#...#...#...#.#.###.#.#.#####.#.#.#.#######.###.#...#.....#...#.#.#...#.....#.#########.#####.#.###.#.###.#.#.....#.#...#...#...#...#.#.#.#.#.#.#.###.#.#####.###.#.#.#...#.#...#.#...#...#...#...#.#.###.###.#.#####.#.###.###.#.#...#.#.#.......#.#...#.#...#.#####.#.#######.#.#####.#.###.#...#.#.......#.#...#...#.#..E#.#.#.#.#######.###.#.#####.#.#.#...#.............#.....#.#.#.###############.#######.#.#.#.........#...#...#.....#...#.#.#######.#.#.#####.#.#######.#.......#...#.......#.........
"""

maze_str = '\n'.join([maze_str[i:i+31] for i in range(1, len(maze_str), 30)])

print(maze_str)

# Split the maze string into lines and remove empty lines
maze_lines = [line for line in maze_str.strip().split('\n') if line]

# Get dimensions
height = len(maze_lines)
width = len(maze_lines[0])

# Create numpy array
maze = np.zeros((height, width), dtype=int)

# Fill array and find special points
start = None
checkpoint = None
end = None

for i, line in enumerate(maze_lines):
    for j, char in enumerate(line):
        if char == '#':
            maze[i, j] = 1
        elif char == 'P':
            start = (i, j)
        elif char == 'C':
            checkpoint = (i, j)
        elif char == 'E':
            end = (i, j)

print("Maze array created with shape:", maze.shape)
print("Start position (P):", start)
print("Checkpoint position (C):", checkpoint)
print("End position (E):", end)


def get_direct_path(maze, start, end):
    rows, cols = maze.shape
    visited = set()
    q = Queue()
    q.put((start, []))  # (position, path)
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    direction_names = ['上', '下', '左', '右']

    while not q.empty():
        (i, j), path = q.get()

        if (i, j) == end:
            print("找到直接路径！")
            print("路径步骤:", ' '.join(path))
            print("总步数:", len(path))
            direction_map = {'上': 'l', '下': 'o', '左': 'v', '右': 'e'}
            path_new = [direction_map[d] for d in path]
            print("路径(使用love):", ''.join(path_new))
            print("MD5:", hashlib.md5(''.join(path_new).encode()).hexdigest())
            return path

        if (i, j) in visited:
            continue

        visited.add((i, j))

        for idx, (di, dj) in enumerate(directions):
            ni, nj = i + di, j + dj
            if (0 <= ni < rows and 0 <= nj < cols and
                maze[ni, nj] != 1 and (ni, nj) not in visited and
                    (ni, nj) != checkpoint):
                q.put(((ni, nj), path + [direction_names[idx]]))

    print("未找到不经过检查点的路径")
    return None


direct_path = get_direct_path(maze, start, end)

from PIL import Image
from Crypto.Util.number import bytes_to_long, long_to_bytes
import numpy as np

n = 29869349657224745144762606999
e = 65537

original_image_path = "flag.jpg"
img = Image.open(original_image_path)
img = img.convert("RGB")

img_array = np.array(img)
h, w, _ = img_array.shape

encrypted_array = np.zeros((h, w, 3), dtype=object)
for i in range(h):
    for j in range(w):
        r, g, b = int(img_array[i, j, 0]), int(img_array[i, j, 1]), int(img_array[i, j, 2])

        encrypted_array[i, j, 0] = pow(r, e, n)
        encrypted_array[i, j, 1] = pow(g, e, n)
        encrypted_array[i, j, 2] = pow(b, e, n)

np.save("encrypted_image.npy", encrypted_array)
print("图片已加密并保存为 encrypted_image.npy")

from PIL import Image
import numpy as np
import sympy

n = 29869349657224745144762606999
e = 65537

factors = list(sympy.factorint(n).keys())
p, q = factors[0], factors[1]

phi_n = (p - 1) * (q - 1)

d = pow(e, -1, phi_n)

encrypted_array = np.load("encrypted_image.npy", allow_pickle=True)
h, w, _ = encrypted_array.shape

decrypted_array = np.zeros((h, w, 3), dtype=np.uint8)
for i in range(h):
    for j in range(w):
        r, g, b = int(encrypted_array[i, j, 0]), int(encrypted_array[i, j, 1]), int(encrypted_array[i, j, 2])

        decrypted_array[i, j, 0] = pow(r, d, n)
        decrypted_array[i, j, 1] = pow(g, d, n)
        decrypted_array[i, j, 2] = pow(b, d, n)

decrypted_img = Image.fromarray(decrypted_array, 'RGB')
decrypted_img.save("decrypted_flag.jpg")

import gmpy2
import random
import binascii
from hashlib import sha256
from sympy import nextprime
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Util.number import long_to_bytes
from FLAG import flag
#flag = 'wdflag{123}'

def victory_encrypt(plaintext, key):
    key = key.upper()
    key_length = len(key)
    plaintext = plaintext.upper()
    ciphertext = ''

    for i, char in enumerate(plaintext):
        if char.isalpha():
            shift = ord(key[i % key_length]) - ord('A')
            encrypted_char = chr((ord(char) - ord('A') + shift) % 26 + ord('A'))
            ciphertext += encrypted_char
        else:
            ciphertext += char

    return ciphertext

victory_key = "WANGDINGCUP"
victory_encrypted_flag = victory_encrypt(flag, victory_key)

p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
a = 0
b = 7
xG = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
yG = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
G = (xG, yG)
n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
h = 1
zero = (0,0)

dA = nextprime(random.randint(0, n))

if dA > n:
    print("warning!!")

def addition(t1, t2):
    if t1 == zero:
        return t2
    if t2 == zero:
        return t2
    (m1, n1) = t1
    (m2, n2) = t2
    if m1 == m2:
        if n1 == 0 or n1 != n2:
            return zero
        else:
            k = (3 * m1 * m1 + a) % p * gmpy2.invert(2 * n1 , p) % p
    else:
        k = (n2 - n1 + p) % p * gmpy2.invert((m2 - m1 + p) % p, p) % p
    m3 = (k * k % p - m1 - m2 + p * 2) % p
    n3 = (k * (m1 - m3) % p - n1 + p) % p
    return (int(m3),int(n3))

def multiplication(x, k):
    ans = zero
    t = 1
    while(t <= k):
        if (k &t )>0:
            ans = addition(ans, x)
        x = addition(x, x)
        t <<= 1
    return ans

def getrs(z, k):
    (xp, yp) = P
    r = xp
    s = (z + r * dA % n) % n * gmpy2.invert(k, n) % n
    return r,s

z1 = random.randint(0, p)
z2 = random.randint(0, p)
k = random.randint(0, n)
P = multiplication(G, k)
hA = multiplication(G, dA)
r1, s1 = getrs(z1, k)
r2, s2 = getrs(z2, k)

print("r1 = {}".format(r1))
print("r2 = {}".format(r2))
print("s1 = {}".format(s1))
print("s2 = {}".format(s2))
print("z1 = {}".format(z1))
print("z2 = {}".format(z2))

key = sha256(long_to_bytes(dA)).digest()
cipher = AES.new(key, AES.MODE_CBC)
iv = cipher.iv
encrypted_flag = cipher.encrypt(pad(victory_encrypted_flag.encode(), AES.block_size))
encrypted_flag_hex = binascii.hexlify(iv + encrypted_flag).decode('utf-8')

print("Encrypted flag (AES in CBC mode, hex):", encrypted_flag_hex)

# output
# r1 = 86806104739558095745988469033305523200538774705708894815836887970976487278764
# r2 = 86806104739558095745988469033305523200538774705708894815836887970976487278764
# s1 = 93400851884262731807098055393482657423555590196362184363643455285862566867372
# s2 = 58741027521216057788923508334695668250013849866589902683641825341545919891746
# z1 = 47591695289461307212638536234394543297527537576682980326526736956079807805586
# z2 = 97911075901954715147720917205165523174582665086645698292621371632896283314804
# ('Encrypted flag (AES in CBC mode, hex):', u'86cd24e2914c0c4d9b87bea34005a98bd8587d14cae71909b917679d3328304e7915e6ba4cad1096faa4a85bc52f8056d3f21ef09516be8a5160f1b338a6b936')