CTF-Crypto暑期刷题记录

以下题目来源：nssctf

❕📓 ‧₊˚ 🦢

01 [鹤城杯 2021]easy_crypto

🚩flag：NSSCTF{IlUqU9O5guX6YiITsRNPiQmbhNRjGuTP}

💡hint：古典密码 其他 词频分析

核心价值观解码。

while 1:
    str1 = input('输入要解码的文本：')
    list1 = ['富强', '民主', '文明', '和谐', '自由', '平等', '公正', '法治', '爱国', '敬业', '诚信', '友善']
    list1 = [list1.index(str1[f1 << 1] + str1[f1 << 1 | 1]) for f1 in range(int(len(str1)/2))]
    a = 0
    list2 = []
    while a < len(list1):
        if list1[a] < 10:
            list2.append(str(list1[a]))
        elif list1[a] == 10:
            a += 1
            list2.append(hex(list1[a]+10)[2:])
        else:
            a += 1
            list2.append(hex(list1[a]+6)[2:])
        a += 1
    str1 = bytes.fromhex(''.join(list2)).decode('utf-8')
    print('解码结果：', str1, '\n'*3)

02 [强网拟态 2021]拟态签到题

🚩flag：NSSCTF{GaqY7KtEtrVIX1Q5oP5iEBRCYXEAy8rT}

💡hint：Base家族 古典密码 其他

Base64 cyberchef自动转化

03 [SWPUCTF 2021 新生赛]crypto8

🚩flag：NSSCTF{cheese_is_power}

💡hint：古典密码 其他 uuencode

拿到题目之后是：

73E-30U1&>V-H965S95]I<U]P;W=E<GT`

根据题目标签推测是uuencode。

使用网站解码：

http://www.hiencode.com/uu.html

NSSCTF{cheese_is_power}

04 [SWPUCTF 2021 新生赛]crypto7

🚩flag：NSSCTF{md5yyds}

💡hint： md5爆破

题目信息：

69f7906323b4f7d1e4e972acf4abfbfc,得到的结果用NSSCTF{}包裹。

一眼md5

使用网站进行解密：https://www.somd5.com

得到结果：

md5yyds

05 [SWPUCTF 2021 新生赛]crypto6

🚩flag：NSSCTF{5e110989-dc43-1bd3-00b4-9009206158fe}

💡hint：Base家族 古典密码

题目信息：

var="************************************"
flag='NSSCTF{' + base64.b16encode(base64.b32encode(base64.b64encode(var.encode()))) + '}'
print(flag)

小明不小心泄露了源码，输出结果为：4A5A4C564B36434E4B5241544B5432454E4E32465552324E47424758534D44594C4657564336534D4B5241584F574C4B4B463245365643424F35485649534C584A5A56454B4D4B5049354E47593D3D3D，你能还原出var的正确结果吗？

梳理加密过程，是先进行base64编码，编码后的字符串再进行base32编码，然后是base16编码。

那么根据过程返回去，是先16，再32，再64，写脚本解题即可。

解密脚本：

import base64

encoded = "4A5A4C564B36434E4B5241544B5432454E4E32465552324E47424758534D44594C4657564336534D4B5241584F574C4B4B463245365643424F35485649534C584A5A56454B4D4B5049354E47593D3D3D"

# Base16 decode
b16_decoded = base64.b16decode(encoded, casefold=True)
print("After b16 decode:", b16_decoded)

# Base32 decode
b32_decoded = base64.b32decode(b16_decoded)
print("After b32 decode:", b32_decoded)

# Base64 decode
b64_decoded = base64.b64decode(b32_decoded)
print("After b64 decode:", b64_decoded)

# Convert to string
var = b64_decoded.decode('utf-8')
print("Original var:", var)

最终flag：

NSSCTF{5e110989-dc43-1bd3-00b4-9009206158fe}

06 [SWPUCTF 2021 新生赛]ez_caesar

🚩flag：NSSCTF{youhaveknowcaesar}

💡hint：Base家族 古典密码 凯撒密码

题目信息：

import base64
def caesar(plaintext):
    str_list = list(plaintext)
    i = 0
    while i < len(plaintext):
        if not str_list[i].isalpha():
            str_list[i] = str_list[i]
        else:
            a = "A" if str_list[i].isupper() else "a"
            str_list[i] = chr((ord(str_list[i]) - ord(a) + 5) % 26 + ord(a) or 5)
        i = i + 1

    return ''.join(str_list)

flag = "*************************"
str = caesar(flag)
print(str)

#str="U1hYSFlLe2R0em1mYWpwc3RiaGZqeGZ3fQ=="

flag经过题目中凯撒加密得到str，编写脚本进行逆过程即可。

尝试过先凯撒解密再base64不行，原来是先base64再凯撒解密。

解题脚本如下：

import base64
def caesar(plaintext):
    str_list = list(plaintext)
    i = 0
    while i < len(plaintext):
        if not str_list[i].isalpha():
            str_list[i] = str_list[i]
        else:
            a = "A" if str_list[i].isupper() else "a"
            str_list[i] = chr((ord(str_list[i]) - ord(a) + 21) % 26 + ord(a) or 21)
        i = i + 1

    return ''.join(str_list)

str="U1hYSFlLe2R0em1mYWpwc3RiaGZqeGZ3fQ=="
str=base64.b64decode(str).decode('utf-8')
flag=caesar(str)

print(flag)

NSSCTF{youhaveknowcaesar}

07 [SWPUCTF 2021 新生赛]ez_caesar

🚩flag：NSSCTF{whenthepigwanttoeat}

💡hint：凯撒密码 ROT 古典密码

题目信息：

AFFPGS{pbatenghyngvbaf!!!},建议直接秒了

凯撒密码爆破：

def caesar_brute_force(ciphertext):
    for shift in range(1, 26):  # 尝试所有可能的位移（1到25）
        decrypted = ""
        for char in ciphertext:
            if char.isalpha():  # 只处理字母
                if char.isupper():
                    # 大写字母解密
                    decrypted_char = chr(((ord(char) - ord('A') - shift) % 26) + ord('A'))
                else:
                    # 小写字母解密
                    decrypted_char = chr(((ord(char) - ord('a') - shift) % 26) + ord('a'))
                decrypted += decrypted_char
            else:
                # 非字母字符直接保留
                decrypted += char
        print(f"Shift {shift}: {decrypted}")

# 密文
ciphertext = "AFFPGS{pbatenghyngvbaf!!!}"
caesar_brute_force(ciphertext)

得到：

NSSCTF{congratulations!!!}

08 [SWPUCTF 2021 新生赛]pigpig

🚩flag：NSSCTF{congratulations!!!}

💡hint：古典密码 其他 猪圈密码

之前练习misc见过的，猪圈密码。

解密网站：http://www.hiencode.com/pigpen.html

![截屏2025-08-12 13.27.12](/Users/serenius/Library/Application Support/typora-user-images/截屏2025-08-12 13.27.12.png)

NSSCTF{whenthepigwanttoeat}

09 [SWPUCTF 2021 新生赛]ez_rsa

🚩flag：NSSCTF{08bb8fb628da85923e5734a75ac19ffe}

💡hint：RSA

p = 1325465431
q = 152317153
e = 65537
计算出d,将d用MD5加密后包裹NSSCTF{}提交

解题脚本：

import math
import hashlib

# 给定的参数
p = 1325465431
q = 152317153
e = 65537

# 计算 n 和 φ(n)
n = p * q
phi_n = (p - 1) * (q - 1)

# 计算 d (e 的模反元素)
def extended_gcd(a, b):
    if b == 0:
        return a, 1, 0
    else:
        g, x, y = extended_gcd(b, a % b)
        return g, y, x - (a // b) * y

# 计算 d
g, x, y = extended_gcd(e, phi_n)
if g != 1:
    raise ValueError("e 和 φ(n) 不互质，无法计算 d")
else:
    d = x % phi_n  # 确保 d 是正数

# 计算 d 的 MD5 哈希
d_str = str(d)
md5_hash = hashlib.md5(d_str.encode()).hexdigest()

# 包裹成 flag
flag = f"NSSCTF{{{md5_hash}}}"

print("计算得到的 d:", d)
print("MD5 哈希:", md5_hash)
print("Flag:", flag)

运行结果：

计算得到的 d: 43476042047970113
MD5 哈希: 08bb8fb628da85923e5734a75ac19ffe
Flag: NSSCTF{08bb8fb628da85923e5734a75ac19ffe}

10 [LitCTF 2023]梦想是红色的 (初级)

🚩flag：NSSCTF{为之则易,不为则难}

💡hint：RSA

题目描述: 曾经我有个梦想。

自由友善公正公正敬业法治自由自由和谐平等自由自由公正法治诚信民主诚信自由自由诚信民主爱国友善平等诚信富强友善爱国自由诚信民主敬业爱国诚信民主友善爱国平等爱国爱国敬业敬业友善爱国公正敬业爱国敬业和谐文明诚信文明友善爱国自由诚信民主爱国爱国诚信和谐友善爱国自由友善平等爱国友善平等友善自由诚信自由平等爱国爱国敬业敬业友善爱国敬业敬业友善自由友善平等诚信自由法治诚信和谐

核心价值观解密，很红。

使用脚本：

while 1:
    str1 = input('输入要解码的文本：')
    list1 = ['富强', '民主', '文明', '和谐', '自由', '平等', '公正', '法治', '爱国', '敬业', '诚信', '友善']
    list1 = [list1.index(str1[f1 << 1] + str1[f1 << 1 | 1]) for f1 in range(int(len(str1)/2))]
    a = 0
    list2 = []
    while a < len(list1):
        if list1[a] < 10:
            list2.append(str(list1[a]))
        elif list1[a] == 10:
            a += 1
            list2.append(hex(list1[a]+10)[2:])
        else:
            a += 1
            list2.append(hex(list1[a]+6)[2:])
        a += 1
    str1 = bytes.fromhex(''.join(list2)).decode('utf-8')
    print('解码结果：', str1, '\n'*3)

运行结果：

LitCTF{为之则易,不为则难}

记得改成NSSCTF{}

11 [鹤城杯 2021]A_CRYPTO

🚩flag：NSSCTF{W0w_y0u_c4n_rea11y_enc0d1ng!}

💡hint：ROT base

4O595954494Q32515046324757595N534R52415653334357474R4N575955544R4O5N4Q46434S4O59474253464Q5N444R4Q51334557524O5N4S424944473542554O595N44534O324R49565746515532464O49345649564O464R4R494543504N35

import base64


def caesar13_decode(text):
    """凯撒13解密（ROT13）"""
    result = []
    for char in text:
        if 'A' <= char <= 'Z':
            result.append(chr((ord(char) - ord('A') + 13) % 26 + ord('A')))
        elif '0' <= char <= '9':
            result.append(char)  # 数字不处理
        else:
            result.append(char)  # 其他字符保留
    return ''.join(result)


def decode_layers(ciphertext):
    """多层解码：ROT13 → Base16 → Base32 → Base64 → Base85"""
    # Step 1: ROT13
    step1 = caesar13_decode(ciphertext)
    print(f"After ROT13: {step1}")

    # Step 2: Base16
    try:
        step2 = base64.b16decode(step1.encode()).decode()
        print(f"After Base16: {step2}")
    except:
        step2 = step1
        print("Base16 decode failed, skipping...")

    # Step 3: Base32
    try:
        step3 = base64.b32decode(step2.encode()).decode()
        print(f"After Base32: {step3}")
    except:
        step3 = step2
        print("Base32 decode failed, skipping...")

    # Step 4: Base64
    try:
        step4 = base64.b64decode(step3.encode()).decode()
        print(f"After Base64: {step4}")
    except:
        step4 = step3
        print("Base64 decode failed, skipping...")

    # Step 5: Base85
    try:
        step5 = base64.b85decode(step4.encode()).decode()
        print(f"After Base85: {step5}")
    except:
        step5 = step4
        print("Base85 decode failed, skipping...")

    return step5


# 测试密文
ciphertext = "4O595954494Q32515046324757595N534R52415653334357474R4N575955544R4O5N4Q46434S4O59474253464Q5N444R4Q51334557524O5N4S424944473542554O595N44534O324R49565746515532464O49345649564O464R4R494543504N35"

# 执行解密
final_result = decode_layers(ciphertext)
print("\nFinal Result:", final_result)

flag{W0w_y0u_c4n_rea11y_enc0d1ng!}

12 [LitCTF 2023]Hex？Hex！(初级)

🚩flag：NSSCTF{tai111coollaaa!}

💡hint：hex

hex_string = "4c69744354467b746169313131636f6f6c6c616161217d"

# 方法1：使用 bytes.fromhex() 和 decode()
decoded_str = bytes.fromhex(hex_string).decode('utf-8')
print("方法1结果:", decoded_str)

# 方法2：使用 codecs 模块
import codecs
decoded_str = codecs.decode(hex_string, 'hex').decode('utf-8')
print("方法2结果:", decoded_str)

# 方法3：手动转换（适用于学习原理）
def hex_to_str(hex_str):
    return ''.join([chr(int(hex_str[i:i+2], 16)) for i in range(0, len(hex_str), 2)])

print("方法3结果:", hex_to_str(hex_string))

13 [BJDCTF 2020]base??

🚩flag：NSSCTF{D0_Y0u_kNoW_Th1s_b4se_map}

💡hint：base

dict:{0: 'J', 1: 'K', 2: 'L', 3: 'M', 4: 'N', 5: 'O', 6: 'x', 7: 'y', 8: 'U', 9: 'V', 10: 'z', 11: 'A', 12: 'B', 13: 'C', 14: 'D', 15: 'E', 16: 'F', 17: 'G', 18: 'H', 19: '7', 20: '8', 21: '9', 22: 'P', 23: 'Q', 24: 'I', 25: 'a', 26: 'b', 27: 'c', 28: 'd', 29: 'e', 30: 'f', 31: 'g', 32: 'h', 33: 'i', 34: 'j', 35: 'k', 36: 'l', 37: 'm', 38: 'W', 39: 'X', 40: 'Y', 41: 'Z', 42: '0', 43: '1', 44: '2', 45: '3', 46: '4', 47: '5', 48: '6', 49: 'R', 50: 'S', 51: 'T', 52: 'n', 53: 'o', 54: 'p', 55: 'q', 56: 'r', 57: 's', 58: 't', 59: 'u', 60: 'v', 61: 'w', 62: '+', 63: '/', 64: '='}

chipertext:
FlZNfnF6Qol6e9w17WwQQoGYBQCgIkGTa9w3IQKw

解题脚本：

# 给定的字典映射
mapping = {
    0: 'J', 1: 'K', 2: 'L', 3: 'M', 4: 'N', 5: 'O', 6: 'x', 7: 'y', 8: 'U', 9: 'V',
    10: 'z', 11: 'A', 12: 'B', 13: 'C', 14: 'D', 15: 'E', 16: 'F', 17: 'G', 18: 'H',
    19: '7', 20: '8', 21: '9', 22: 'P', 23: 'Q', 24: 'I', 25: 'a', 26: 'b', 27: 'c',
    28: 'd', 29: 'e', 30: 'f', 31: 'g', 32: 'h', 33: 'i', 34: 'j', 35: 'k', 36: 'l',
    37: 'm', 38: 'W', 39: 'X', 40: 'Y', 41: 'Z', 42: '0', 43: '1', 44: '2', 45: '3',
    46: '4', 47: '5', 48: '6', 49: 'R', 50: 'S', 51: 'T', 52: 'n', 53: 'o', 54: 'p',
    55: 'q', 56: 'r', 57: 's', 58: 't', 59: 'u', 60: 'v', 61: 'w', 62: '+', 63: '/',
    64: '='
}

# 密文
ciphertext = "FlZNfnF6Qol6e9w17WwQQoGYBQCgIkGTa9w3IQKw"

# 步骤1：创建反向映射字典（字符 → 数字）
reverse_mapping = {v: k for k, v in mapping.items()}

# 步骤2：将密文字符转换为对应的数字
numbers = []
for char in ciphertext:
    if char in reverse_mapping:
        numbers.append(reverse_mapping[char])
    else:
        print(f"警告：字符 '{char}' 不在映射字典中！")
        numbers.append(0)  # 默认用0代替（可根据需要修改）

print("转换后的数字序列:", numbers)

# 步骤3：将数字转换为Base64索引（0-63）
# 观察字典，发现索引64对应'='，所以需要模64处理
base64_indices = [num % 64 for num in numbers]
print("Base64索引序列:", base64_indices)

# 步骤4：将Base64索引转换为标准Base64字符
base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
base64_str = ''.join([base64_chars[idx] for idx in base64_indices])
print("Base64字符串:", base64_str)

# 步骤5：解码Base64
import base64
decoded_bytes = base64.b64decode(base64_str)
decoded_text = decoded_bytes.decode('utf-8')
print("最终解密结果:", decoded_text)

BJD{D0_Y0u_kNoW_Th1s_b4se_map}

14 [SWPUCTF 2021 新生赛]traditional

🚩flag：NSSCTF{Da01sall}

💡hint：其他

题目：
西方的二进制数学的发明者莱布尼茨，从中国的八卦图当中受到启发，演绎并推论出了数学矩
阵，
最后创造的二进制数学。二进制数学的诞生为计算机的发明奠定了理论基础。而计算机现在改
变
了我们整个世界，改变了我们生活，而他的源头却是来自于八卦图。现在，给你一组由八卦图
方位
组成的密文，你能破解出其中的含义吗？
震坤艮震艮震坤巽坤坤巽震震巽兑震艮震震离艮震离艮
格式：NSSCTF{}

_hash = {"乾":"111" , "兑":"011" , "离":"101" , "震":"001" , "巽":"110" , "坎":"010" , "艮":"100" , "坤":"000"}
text = "震坤艮 震艮震 坤巽坤 坤巽震 震巽兑 震艮震 震离艮 震离艮"
flag = ""
for i in text:
    try:
        flag += ''.join(_hash[i])
    except KeyError:
        flag += ''.join(" ")
print("flag = " , flag)
_flag = ''
for j in range(0 , len(flag) , 10):
    _flag += ''.join((chr((int(flag[j:j + 10] , 2)))))
print("NSSCTF{" + _flag + "}")

NSSCTF{Da01sall}

15 [SWPUCTF 2021 新生赛]crypto2

🚩flag：NSSCTF{xxxxx******xxxxx}

💡hint：RSA 共模攻击

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



flag  = '***************'

p = getPrime(512)
q = getPrime(512)
m1 = bytes_to_long(bytes(flag.encode()))


n = p*q
e1 = getPrime(32)
e2 = getPrime(32)
print()

flag1 = pow(m1,e1,n)
flag2 = pow(m1,e2,n)
print('flag1= '+str(flag1))
print('flag2= '+str(flag2))
print('e1= ' +str(e1))
print('e2= '+str(e2))
print('n= '+str(n))


#flag1= 100156221476910922393504870369139942732039899485715044553913743347065883159136513788649486841774544271396690778274591792200052614669235485675534653358596366535073802301361391007325520975043321423979924560272762579823233787671688669418622502663507796640233829689484044539829008058686075845762979657345727814280
#flag2= 86203582128388484129915298832227259690596162850520078142152482846864345432564143608324463705492416009896246993950991615005717737886323630334871790740288140033046061512799892371429864110237909925611745163785768204802056985016447086450491884472899152778839120484475953828199840871689380584162839244393022471075
#e1= 3247473589
#e2= 3698409173
#n= 103606706829811720151309965777670519601112877713318435398103278099344725459597221064867089950867125892545997503531556048610968847926307322033117328614701432100084574953706259773711412853364463950703468142791390129671097834871371125741564434710151190962389213898270025272913761067078391308880995594218009110313

RSA 共模攻击

解题脚本：

from gmpy2 import gcdext, invert, powmod
from Crypto.Util.number import long_to_bytes

# 给定数据
flag1 = 100156221476910922393504870369139942732039899485715044553913743347065883159136513788649486841774544271396690778274591792200052614669235485675534653358596366535073802301361391007325520975043321423979924560272762579823233787671688669418622502663507796640233829689484044539829008058686075845762979657345727814280
flag2 = 86203582128388484129915298832227259690596162850520078142152482846864345432564143608324463705492416009896246993950991615005717737886323630334871790740288140033046061512799892371429864110237909925611745163785768204802056985016447086450491884472899152778839120484475953828199840871689380584162839244393022471075
e1 = 3247473589
e2 = 3698409173
n = 103606706829811720151309965777670519601112877713318435398103278099344725459597221064867089950867125892545997503531556048610968847926307322033117328614701432100084574953706259773711412853364463950703468142791390129671097834871371125741564434710151190962389213898270025272913761067078391308880995594218009110313

# 步骤1：计算扩展欧几里得系数
g, s, t = gcdext(e1, e2)
assert g == 1  # 确保e1和e2互质

# 步骤2：调整系数确保非负
if s < 0:
    s = -s
    flag1 = invert(flag1, n)
if t < 0:
    t = -t
    flag2 = invert(flag2, n)

# 步骤3：恢复明文
m = powmod(flag1, s, n) * powmod(flag2, t, n) % n
flag = long_to_bytes(m)

print("解密结果:", flag)

NSSCTF{xxxxx******xxxxx}

16 [羊城杯 2021]Bigrsa

🚩flag：NSSCTF{xxxxx******xxxxx}

💡hint：共享素数 RSA 不互素

题目描述：

from Crypto.Util.number import *
from flag import *

n1 = 103835296409081751860770535514746586815395898427260334325680313648369132661057840680823295512236948953370895568419721331170834557812541468309298819497267746892814583806423027167382825479157951365823085639078738847647634406841331307035593810712914545347201619004253602692127370265833092082543067153606828049061
n2 = 115383198584677147487556014336448310721853841168758012445634182814180314480501828927160071015197089456042472185850893847370481817325868824076245290735749717384769661698895000176441497242371873981353689607711146852891551491168528799814311992471449640014501858763495472267168224015665906627382490565507927272073
e = 65537
m = bytes_to_long(flag)
c = pow(m, e, n1)
c = pow(c, e, n2)

print("c = %d" % c)

# output
# c = 60406168302768860804211220055708551816238816061772464557956985699400782163597251861675967909246187833328847989530950308053492202064477410641014045601986036822451416365957817685047102703301347664879870026582087365822433436251615243854347490600004857861059245403674349457345319269266645006969222744554974358264

解题脚本：

from Crypto.Util.number import *
import gmpy2

n1 = 103835296409081751860770535514746586815395898427260334325680313648369132661057840680823295512236948953370895568419721331170834557812541468309298819497267746892814583806423027167382825479157951365823085639078738847647634406841331307035593810712914545347201619004253602692127370265833092082543067153606828049061
n2 = 115383198584677147487556014336448310721853841168758012445634182814180314480501828927160071015197089456042472185850893847370481817325868824076245290735749717384769661698895000176441497242371873981353689607711146852891551491168528799814311992471449640014501858763495472267168224015665906627382490565507927272073
e = 65537

c = 60406168302768860804211220055708551816238816061772464557956985699400782163597251861675967909246187833328847989530950308053492202064477410641014045601986036822451416365957817685047102703301347664879870026582087365822433436251615243854347490600004857861059245403674349457345319269266645006969222744554974358264

p = gmpy2.gcd(n1,n2)
q1 = n1 // p
q2 = n2 // p
phi1 = (p-1)*(q1-1)
phi2 = (p-1)*(q2-1)
d1 = gmpy2.invert(e,phi1)
d2 = gmpy2.invert(e,phi2)
c1 = pow(c,d2,n2)
m = pow(c1,d1,n1)

print(long_to_bytes(m))

b’SangFor{qSccmm1WrgvIg2Uq_cZhmqNfEGTz2GV8}’

17 [LitCTF 2023]家人们！谁懂啊，RSA签到都不会 (初级)

🚩flag：NSSCTF{it_is_easy_to_solve_question_when_you_know_p_and_q}

💡hint： RSA 不互素

from Crypto.Util.number import *
from secret import flag

m = bytes_to_long(flag)
p = getPrime(512)
q = getPrime(512)
e = 65537
n = p*q
c = pow(m,e,n)
print(f'p = {p}')
print(f'q = {q}')
print(f'c = {c}')
'''
p = 12567387145159119014524309071236701639759988903138784984758783651292440613056150667165602473478042486784826835732833001151645545259394365039352263846276073
q = 12716692565364681652614824033831497167911028027478195947187437474380470205859949692107216740030921664273595734808349540612759651241456765149114895216695451
c = 108691165922055382844520116328228845767222921196922506468663428855093343772017986225285637996980678749662049989519029385165514816621011058462841314243727826941569954125384522233795629521155389745713798246071907492365062512521474965012924607857440577856404307124237116387085337087671914959900909379028727767057
'''

题目分析

给定：

明文 m 经过 RSA 加密：c = pow(m, e, n)
已知 p, q, e, c，需要恢复 m

数学原理

计算 n = p * q
计算欧拉函数 φ(n) = (p-1) * (q-1)
计算私钥 d = inverse(e, φ(n))
解密明文 m = pow(c, d, n)

解题脚本：

from Crypto.Util.number import long_to_bytes

# 给定数据
p = 12567387145159119014524309071236701639759988903138784984758783651292440613056150667165602473478042486784826835732833001151645545259394365039352263846276073
q = 12716692565364681652614824033831497167911028027478195947187437474380470205859949692107216740030921664273595734808349540612759651241456765149114895216695451
e = 65537
c = 108691165922055382844520116328228845767222921196922506468663428855093343772017986225285637996980678749662049989519029385165514816621011058462841314243727826941569954125384522233795629521155389745713798246071907492365062512521474965012924607857440577856404307124237116387085337087671914959900909379028727767057

# 步骤1：计算n和欧拉函数
n = p * q
phi = (p - 1) * (q - 1)

# 步骤2：计算私钥d
d = pow(e, -1, phi)  # Python 3.8+ 语法，等同于 inverse(e, phi)

# 步骤3：解密明文
m = pow(c, d, n)

# 步骤4：将明文转换为字符串
flag = long_to_bytes(m)

print("解密结果:", flag)

解密结果: b’LitCTF{it_is_easy_to_solve_question_when_you_know_p_and_q}’

18 [LitCTF 2023]你是我的关键词(Keyworld) (初级)

🚩flag：NSSCTF{Y0U_AR3_MY_KEYW0RD}

💡hint： 其他

关键字密码在线解密网站：

http://www.hiencode.com/keyword.html

注意这里解密密码是you

LITCTF{Y0U_AR3_MY_KEYW0RD}

19 [LitCTF 2023]Is this only base?

🚩flag：NSSCTF{LeT_Us_H4V3_fU0!!!!!}

💡hint： 栅栏密码 凯撒密码 Base家族

题目描述：

SWZxWl=F=DQef0hlEiSUIVh9ESCcMFS9NF2NXFzM
今年是本世纪的第23年呢

import base64

# 原始密文（W型栅栏解密后的结果）
rail_fence_decrypted = "SWZxWlFDe0liUV9ScF9FNFMzX2NSMCEhISEhfQ=="

# 步骤1：Base64解码
base64_decoded = base64.b64decode(rail_fence_decrypted).decode('utf-8')
print("Base64解码结果:", base64_decoded)  # 输出: IfqZQC{IbQ_Rp_E4S3_cR0!!!}

# 步骤2：凯撒解密（枚举所有偏移量）
def caesar_decrypt(ciphertext, shift):
    result = ""
    for char in ciphertext:
        if char.isalpha():
            ascii_offset = ord('A') if char.isupper() else ord('a')
            decrypted_char = chr((ord(char) - ascii_offset - shift) % 26 + ascii_offset)
            result += decrypted_char
        else:
            result += char
    return result

# 尝试所有可能的凯撒偏移（0-25）
for shift in range(26):
    decrypted = caesar_decrypt(base64_decoded, shift)
    if "CTF" in decrypted:  # 根据题目特征筛选
        print(f"偏移量 {shift}: {decrypted}")

LitCTF{LeT_Us_H4V3_fU0!!!!!}

20 [SWPU 2020]happy

🚩flag：NSSCTF{happy_rsa_1}

💡hint：RSA 素数分解 共享素数

('c=', '0x7a7e031f14f6b6c3292d11a41161d2491ce8bcdc67ef1baa9eL')
('e=', '0x872a335')
#q + q*p^3 =1285367317452089980789441829580397855321901891350429414413655782431779727560841427444135440068248152908241981758331600586
#qp + q *p^2 = 1109691832903289208389283296592510864729403914873734836011311325874120780079555500202475594

解题脚本：

import math
from Crypto.Util.number import inverse, long_to_bytes
from paramiko.util import mod_inverse

#A = q + q*p^3
#B = qp + q *p^2
A = 1285367317452089980789441829580397855321901891350429414413655782431779727560841427444135440068248152908241981758331600586
B = 1109691832903289208389283296592510864729403914873734836011311325874120780079555500202475594
c = 0x7a7e031f14f6b6c3292d11a41161d2491ce8bcdc67ef1baa9e
e = 0x872a335
#通过换算，A和B的最大公因数是q(1+p)
C = math.gcd(A,B)
#p * C = B
p = B // C
q = C // (1 + p)
n = p * q
phi = (p - 1) * (q - 1)
d = mod_inverse(e,phi)
m = pow(c,d,n)
print(long_to_bytes(m))

21 [安洵杯 2019]JustBase

🚩flag：NSSCTF{22-QWERTYUIO-PLKJHGFDS-AZXCVBNM}

💡hint：base

VGhlIGdlb@xvZ#kgb@YgdGhlIEVhcnRoJ#Mgc#VyZmFjZSBpcyBkb@!pbmF)ZWQgYnkgdGhlIHBhcnRpY#VsYXIgcHJvcGVydGllcyBvZiB#YXRlci$gUHJlc@VudCBvbiBFYXJ)aCBpbiBzb@xpZCwgbGlxdWlkLCBhbmQgZ@FzZW(!cyBzdGF)ZXMsIHdhdGVyIGlzIGV$Y@VwdGlvbmFsbHkgcmVhY#RpdmUuIEl)IGRpc#NvbHZlcywgdHJhbnNwb#J)cywgYW%kIHByZWNpcGl)YXRlcyBtYW%%IGNoZW!pY@FsIGNvbXBvdW%kcyBhbmQgaXMgY@(uc#RhbnRseSBtb@RpZnlpbmcgdGhlIGZhY@Ugb@YgdGhlIEVhcnRoLiBFdmFwb#JhdGVkIGZyb@)gdGhlIG(jZWFucywgd@F)ZXIgdmFwb#IgZm(ybXMgY@xvdWRzLCBzb@!lIG(mIHdoaWNoIGFyZSB)cmFuc#BvcnRlZCBieSB#aW%kIG(@ZXIgdGhlIGNvbnRpbmVudHMuIENvbmRlbnNhdGlvbiBmcm(tIHRoZSBjbG(!ZHMgcHJvdmlkZXMgdGhlIGVzc@VudGlhbCBhZ@VudCBvZiBjb@%)aW%lbnRhbCBlcm(zaW(uOiByYWluLlRoZSByYXRlIGF)IHdoaWNoIGEgbW(sZWN!bGUgb@Ygd@F)ZXIgcGFzc@VzIHRob#VnaCB)aGUgY#ljbGUgaXMgbm()IHJhbmRvbQpBbmQgdGhlIGZsYWcgaXM^IENURnsyMi!RV)VSVFlVSU*tUExLSkhHRkRTLUFaWENWQk%NfQ==

解题脚本：

import base64

# 更改为自己的base.txt文件路径
my_file = './justaBase/base.txt'

try:
    with open(my_file, 'r') as file:
        my_str = file.read()
        print('文件读取成功，内容为', my_str)
except FileNotFoundError:
    print(f"文件 '{my_file}' 未找到")
except Exception as e:
    print(f"读取文件时出错：{e}")

my_dict = {'!': '1', '@': '2', '#': '3', '$': '4', '%': '5', '^': '6', '&': '7', '*': '8', '(': '9', ')': '0'}
flag_str = ''

for i in my_str:
    if i in my_dict:
        flag_str += my_dict[i]
    else:
        flag_str += i
print("特殊符号替换后字符串为%s" % flag_str)
print("base64解码后字符串为%s" % base64.b64decode(flag_str).decode())

22 [AFCTF 2018]BASE

🚩flag：NSSCTF{U_5h0u1d_Us3_T00l5}

💡hint：hex base

解题脚本：

自动解码多层嵌套的 Base16/Base32/Base64 编码

import base64
file = open("flag_encode.txt", "r")

text = file.read()

while (1):
    try:
        text = base64.b16decode(text).decode()
    except:
        try:
            text = base64.b32decode(text).decode()
        except:
            try:
                text = base64.b64decode(text).decode()
            except:
                print(text)
                break;

23 [NSSCTF 2022 Spring Recruit]classic

🚩flag：NSSCTF{no_why}

💡hint：base 古典 凯撒

UZZJAM{UIXETGR7TMWD42SKTCWEP4AG_mhrlmshnayfihzl}

解题脚本：

import re

def caesar_decrypt(ciphertext):
    """自动凯撒解密并筛选有效结果"""
    possible_flags = []
    for shift in range(26):  # 尝试所有可能的偏移量
        decrypted = ""
        for char in ciphertext:
            if char.isupper():
                decrypted += chr((ord(char) - ord('A') - shift) % 26 + ord('A'))
            elif char.islower():
                decrypted += chr((ord(char) - ord('a') - shift) % 26 + ord('a'))
            else:
                decrypted += char  # 保留非字母字符

        # 筛选条件：包含常见 Flag 格式或可读单词
        if re.search(r'[A-Za-z]+\{.*\}', decrypted):
            possible_flags.append((shift, decrypted))

    return possible_flags

# 密文输入
ciphertext = "UZZJAM{UIXETGR7TMWD42SKTCWEP4AG_mhrlmshnayfihzl}"

# 执行解密
results = caesar_decrypt(ciphertext)

# 输出结果
if not results:
    print("未找到有效解密结果！")
else:
    print("可能的 Flag（按优先级排序）：")
    for shift, flag in sorted(results, key=lambda x: -len(x[1])):  # 按长度排序（越长越可能）
        print(f"偏移量 {shift}: {flag}")

    # 自动推荐最可能的结果
    best_guess = max(results, key=lambda x: len(re.findall(r'[A-Za-z0-9_]', x[1])))
    print(f"\n推荐结果（偏移量 {best_guess[0]}）: {best_guess[1]}")

NSSCTF{NBQXMZK7MFPW42LDMVPXI4TZ_fakeflagtrybase}

然后使用base自动解码脚本：

import base64

# 打开文件并读取内容
#file = open("flag_encode.txt", "r")
#text = file.read()
text = "NBQXMZK7MFPW42LDMVPXI4TZ"
# 无限循环，直到解码失败
while (1):
    try:
        # 尝试 Base16 解码
        text = base64.b16decode(text).decode()
    except:
        try:
            # Base16 失败后尝试 Base32
            text = base64.b32decode(text).decode()
        except:
            try:
                # Base32 失败后尝试 Base64
                text = base64.b64decode(text).decode()
            except:
                # 所有解码均失败，输出结果并退出循环
                print(text)
                break

得到：

have_a_nice_try

24 [SWPUCTF 2021 新生赛]crypto4

🚩flag：NSSCTF{have_a_nice_try}

💡hint：RSA

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

flag  = '**********'

p = getPrime(512)
q = next_prime(p)
m1 = bytes_to_long(bytes(flag.encode()))


e = 0x10001
n = p*q


flag1 = pow(m1,e,n)
print('flag= '+str(flag1))
print('n= '+str(n))


flag= 10227915341268619536932290456122384969242151167487654201363877568935534996454863939953106193665663567559506242151019201314446286458150141991211233219320700112533775367958964780047682920839507351492644735811096995884754664899221842470772096509258104067131614630939533042322095150722344048082688772981180270243
n= 52147017298260357180329101776864095134806848020663558064141648200366079331962132411967917697877875277103045755972006084078559453777291403087575061382674872573336431876500128247133861957730154418461680506403680189755399752882558438393107151815794295272358955300914752523377417192504702798450787430403387076153

解题脚本：

from gmpy2 import isqrt, next_prime, mpz
from Crypto.Util.number import long_to_bytes

# 给定数据
flag1 = 10227915341268619536932290456122384969242151167487654201363877568935534996454863939953106193665663567559506242151019201314446286458150141991211233219320700112533775367958964780047682920839507351492644735811096995884754664899221842470772096509258104067131614630939533042322095150722344048082688772981180270243
n = 52147017298260357180329101776864095134806848020663558064141648200366079331962132411967917697877875277103045755972006084078559453777291403087575061382674872573336431876500128247133861957730154418461680506403680189755399752882558438393107151815794295272358955300914752523377417192504702798450787430403387076153
e = 0x10001

# 步骤1：分解n（利用p和q相邻的特性）
def factor_n(n):
    sqrt_n = isqrt(n)
    p = sqrt_n
    while True:
        if n % p == 0:
            return p, n // p
        p -= 1

p, q = factor_n(mpz(n))
print("分解结果:")
print("p =", p)
print("q =", q)

# 步骤2：计算私钥d
phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)

# 步骤3：解密明文
m1 = pow(flag1, d, n)
flag = long_to_bytes(m1)

print("\n解密结果:", flag)

分解结果:
p = 7221289171488727827673517139597844534869368289455419695964957239047692699919030405800116133805855968123601433247022090070114331842771417566928809956044421
q = 7221289171488727827673517139597844534869368289455419695964957239047692699919030405800116133805855968123601433247022090070114331842771417566928809956045093

解密结果: b’NSSCTF{no_why}’

25 [AFCTF 2018]你能看出这是什么加密么

🚩flag：NSSCTF{R54_|5_$0_$imp13}

💡hint：RSA

p=0x928fb6aa9d813b6c3270131818a7c54edb18e3806942b88670106c1821e0326364194a8c49392849432b37632f0abe3f3c52e909b939c91c50e41a7b8cd00c67d6743b4f

q=0xec301417ccdffa679a8dcc4027dd0d75baf9d441625ed8930472165717f4732884c33f25d4ee6a6c9ae6c44aedad039b0b72cf42cab7f80d32b74061

e=0x10001

c=0x70c9133e1647e95c3cb99bd998a9028b5bf492929725a9e8e6d2e277fa0f37205580b196e5f121a2e83bc80a8204c99f5036a07c8cf6f96c420369b4161d2654a7eccbdaf583204b645e137b3bd15c5ce865298416fd5831cba0d947113ed5be5426b708b89451934d11f9aed9085b48b729449e461ff0863552149b965e22b6

解题脚本：

import gmpy2
from Crypto.Util.number import *

p = 0x928fb6aa9d813b6c3270131818a7c54edb18e3806942b88670106c1821e0326364194a8c49392849432b37632f0abe3f3c52e909b939c91c50e41a7b8cd00c67d6743b4f

q = 0xec301417ccdffa679a8dcc4027dd0d75baf9d441625ed8930472165717f4732884c33f25d4ee6a6c9ae6c44aedad039b0b72cf42cab7f80d32b74061

e = 0x10001

c = 0x70c9133e1647e95c3cb99bd998a9028b5bf492929725a9e8e6d2e277fa0f37205580b196e5f121a2e83bc80a8204c99f5036a07c8cf6f96c420369b4161d2654a7eccbdaf583204b645e137b3bd15c5ce865298416fd5831cba0d947113ed5be5426b708b89451934d11f9aed9085b48b729449e461ff0863552149b965e22b6
d = gmpy2.invert(e, (p - 1) * (q - 1))
m = pow(c, d, p * q)
print(long_to_bytes(m))

b’\x02\xd3\xe4v\xea\x80r\x83\xda\x99\x88\xf5#\x08\xbbAT\x8b\xaf\xd2\xf4\xdc\x9f\xd3\xbf\xb7A\xc3\xcc\xc5`\xa1\x8b\x86\x18y\xd0&\x88\x10\xef\xbe\x83\xcer\xceC\x17\xec[\xb7%\x08\xef\x16\x1f\xab\x0c\x96\xa3\xdc N^\x8e,\xa3\x11{\x99U\xcd\x15o\xd7B\xf4L\x8f}&\xc5$\xca\xd5;\xf9\x02Y\xc1\xbbS\xfd4\x83M\x96\xa9\xbd;\x83/\xf7\x00afctf{R54_|5_$0_$imp13}’

26 [鹤城杯 2021]Crazy_Rsa_Tech

🚩flag：NSSCTF{H0w_Fun_13_HAstads_broadca5t_AtTack!}

💡hint：RSA

from Crypto.Util.number import *
from Crypto.Util.Padding import *

FLAG = bytes_to_long(pad(b"flag{??????}",64))
def init_key():
    p, q = getPrime(512), getPrime(512)
    n = p*q
    e = 9
    while(GCD((p-1)*(q-1),e)!=1):
        p, q = getPrime(512), getPrime(512)
        n = p*q
    d = inverse(e,(p-1)*(q-1))
    return n,e,d

n_list=list()
c_list=list()
for i in range(9):
    N,e,d=init_key()
    n_list.append(N)
    c=pow(FLAG,e,N)
    c_list.append(pow(FLAG,e,N))
    assert(pow(c,d,N)==FLAG)
print("n_list:",n_list)
print("c_list:",c_list)

n_list: [71189786319102608575263218254922479901008514616376166401353025325668690465852130559783959409002115897148828732231478529655075366072137059589917001875303598680931962384468363842379833044123189276199264340224973914079447846845897807085694711541719515881377391200011269924562049643835131619086349617062034608799, 92503831027754984321994282254005318198418454777812045042619263533423066848097985191386666241913483806726751133691867010696758828674382946375162423033994046273252417389169779506788545647848951018539441971140081528915876529645525880324658212147388232683347292192795975558548712504744297104487514691170935149949, 100993952830138414466948640139083231443558390127247779484027818354177479632421980458019929149817002579508423291678953554090956334137167905685261724759487245658147039684536216616744746196651390112540237050493468689520465897258378216693418610879245129435268327315158194612110422630337395790254881602124839071919, 59138293747457431012165762343997972673625934330232909935732464725128776212729547237438509546925172847581735769773563840639187946741161318153031173864953372796950422229629824699580131369991913883136821374596762214064774480548532035315344368010507644630655604478651898097886873485265848973185431559958627423847, 66827868958054485359731420968595906328820823695638132426084478524423658597714990545142120448668257273436546456116147999073797943388584861050133103137697812149742551913704341990467090049650721713913812069904136198912314243175309387952328961054617877059134151915723594900209641163321839502908705301293546584147, 120940513339890268554625391482989102665030083707530690312336379356969219966820079510946652021721814016286307318930536030308296265425674637215009052078834615196224917417698019787514831973471113022781129000531459800329018133248426080717653298100515701379374786486337920294380753805825328119757649844054966712377, 72186594495190221129349814154999705524005203343018940547856004977368023856950836974465616291478257156860734574686154136925776069045232149725101769594505766718123155028300703627531567850035682448632166309129911061492630709698934310123778699316856399909549674138453085885820110724923723830686564968967391721281, 69105037583161467265649176715175579387938714721653281201847973223975467813529036844308693237404592381480367515044829190066606146105800243199497182114398931410844901178842049915914390117503986044951461783780327749665912369177733246873697481544777183820939967036346862056795919812693669387731294595126647751951, 76194219445824867986050004226602973283400885106636660263597964027139613163638212828932901192009131346530898961165310615466747046710743013409318156266326090650584190382130795884514074647833949281109675170830565650006906028402714868781834693473191228256626654011772428115359653448111208831188721505467497494581]
c_list: [62580922178008480377006528793506649089253164524883696044759651305970802215270721223149734532870729533611357047595181907404222690394917605617029675103788705320032707977225447998111744887898039756375876685711148857676502670812333076878964148863713993853526715855758799502735753454247721711366497722251078739585, 46186240819076690248235492196228128599822002268014359444368898414937734806009161030424589993541799877081745454934484263188270879142125136786221625234555265815513136730416539407710862948861531339065039071959576035606192732936477944770308784472646015244527805057990939765708793705044236665364664490419874206900, 85756449024868529058704599481168414715291172247059370174556127800630896693021701121075838517372920466708826412897794900729896389468152213884232173410022054605870785910461728567377769960823103334874807744107855490558726013068890632637193410610478514663078901021307258078678427928255699031215654693270240640198, 14388767329946097216670270960679686032536707277732968784379505904021622612991917314721678940833050736745004078559116326396233622519356703639737886289595860359630019239654690312132039876082685046329079266785042428947147658321799501605837784127004536996628492065409017175037161261039765340032473048737319069656, 1143736792108232890306863524988028098730927600066491485326214420279375304665896453544100447027809433141790331191324806205845009336228331138326163746853197990596700523328423791764843694671580875538251166864957646807184041817863314204516355683663859246677105132100377322669627893863885482167305919925159944839, 2978800921927631161807562509445310353414810029862911925227583943849942080514132963605492727604495513988707849133045851539412276254555228149742924149242124724864770049898278052042163392380895275970574317984638058768854065506927848951716677514095183559625442889028813635385408810698294574175092159389388091981, 16200944263352278316040095503540249310705602580329203494665614035841657418101517016718103326928336623132935178377208651067093136976383774189554806135146237406248538919915426183225265103769259990252162411307338473817114996409705345401251435268136647166395894099897737607312110866874944619080871831772376466376, 31551601425575677138046998360378916515711528548963089502535903329268089950335615563205720969393649713416910860593823506545030969355111753902391336139384464585775439245735448030993755229554555004154084649002801255396359097917380427525820249562148313977941413268787799534165652742114031759562268691233834820996, 25288164985739570635307839193110091356864302148147148153228604718807817833935053919412276187989509493755136905193728864674684139319708358686431424793278248263545370628718355096523088238513079652226028236137381367215156975121794485995030822902933639803569133458328681148758392333073624280222354763268512333515]

解题脚本：

from Crypto.Util.number import *
from gmpy2 import *
n_list = [
   71189786319102608575263218254922479901008514616376166401353025325668690465852130559783959409002115897148828732231478529655075366072137059589917001875303598680931962384468363842379833044123189276199264340224973914079447846845897807085694711541719515881377391200011269924562049643835131619086349617062034608799,
   92503831027754984321994282254005318198418454777812045042619263533423066848097985191386666241913483806726751133691867010696758828674382946375162423033994046273252417389169779506788545647848951018539441971140081528915876529645525880324658212147388232683347292192795975558548712504744297104487514691170935149949,
   100993952830138414466948640139083231443558390127247779484027818354177479632421980458019929149817002579508423291678953554090956334137167905685261724759487245658147039684536216616744746196651390112540237050493468689520465897258378216693418610879245129435268327315158194612110422630337395790254881602124839071919,
   59138293747457431012165762343997972673625934330232909935732464725128776212729547237438509546925172847581735769773563840639187946741161318153031173864953372796950422229629824699580131369991913883136821374596762214064774480548532035315344368010507644630655604478651898097886873485265848973185431559958627423847,
   66827868958054485359731420968595906328820823695638132426084478524423658597714990545142120448668257273436546456116147999073797943388584861050133103137697812149742551913704341990467090049650721713913812069904136198912314243175309387952328961054617877059134151915723594900209641163321839502908705301293546584147,
   120940513339890268554625391482989102665030083707530690312336379356969219966820079510946652021721814016286307318930536030308296265425674637215009052078834615196224917417698019787514831973471113022781129000531459800329018133248426080717653298100515701379374786486337920294380753805825328119757649844054966712377,
   72186594495190221129349814154999705524005203343018940547856004977368023856950836974465616291478257156860734574686154136925776069045232149725101769594505766718123155028300703627531567850035682448632166309129911061492630709698934310123778699316856399909549674138453085885820110724923723830686564968967391721281,
   69105037583161467265649176715175579387938714721653281201847973223975467813529036844308693237404592381480367515044829190066606146105800243199497182114398931410844901178842049915914390117503986044951461783780327749665912369177733246873697481544777183820939967036346862056795919812693669387731294595126647751951,
   76194219445824867986050004226602973283400885106636660263597964027139613163638212828932901192009131346530898961165310615466747046710743013409318156266326090650584190382130795884514074647833949281109675170830565650006906028402714868781834693473191228256626654011772428115359653448111208831188721505467497494581]
c_list = [
   62580922178008480377006528793506649089253164524883696044759651305970802215270721223149734532870729533611357047595181907404222690394917605617029675103788705320032707977225447998111744887898039756375876685711148857676502670812333076878964148863713993853526715855758799502735753454247721711366497722251078739585,
   46186240819076690248235492196228128599822002268014359444368898414937734806009161030424589993541799877081745454934484263188270879142125136786221625234555265815513136730416539407710862948861531339065039071959576035606192732936477944770308784472646015244527805057990939765708793705044236665364664490419874206900,
   85756449024868529058704599481168414715291172247059370174556127800630896693021701121075838517372920466708826412897794900729896389468152213884232173410022054605870785910461728567377769960823103334874807744107855490558726013068890632637193410610478514663078901021307258078678427928255699031215654693270240640198,
   14388767329946097216670270960679686032536707277732968784379505904021622612991917314721678940833050736745004078559116326396233622519356703639737886289595860359630019239654690312132039876082685046329079266785042428947147658321799501605837784127004536996628492065409017175037161261039765340032473048737319069656,
   1143736792108232890306863524988028098730927600066491485326214420279375304665896453544100447027809433141790331191324806205845009336228331138326163746853197990596700523328423791764843694671580875538251166864957646807184041817863314204516355683663859246677105132100377322669627893863885482167305919925159944839,
   2978800921927631161807562509445310353414810029862911925227583943849942080514132963605492727604495513988707849133045851539412276254555228149742924149242124724864770049898278052042163392380895275970574317984638058768854065506927848951716677514095183559625442889028813635385408810698294574175092159389388091981,
   16200944263352278316040095503540249310705602580329203494665614035841657418101517016718103326928336623132935178377208651067093136976383774189554806135146237406248538919915426183225265103769259990252162411307338473817114996409705345401251435268136647166395894099897737607312110866874944619080871831772376466376,
   31551601425575677138046998360378916515711528548963089502535903329268089950335615563205720969393649713416910860593823506545030969355111753902391336139384464585775439245735448030993755229554555004154084649002801255396359097917380427525820249562148313977941413268787799534165652742114031759562268691233834820996,
   25288164985739570635307839193110091356864302148147148153228604718807817833935053919412276187989509493755136905193728864674684139319708358686431424793278248263545370628718355096523088238513079652226028236137381367215156975121794485995030822902933639803569133458328681148758392333073624280222354763268512333515]
n = 1
for i in n_list:
   n = n * i

n_ = []
for i in n_list:
   n_.append(n // i)

t = []
for i in range(9):
   t.append(inverse(n_[i], n_list[i]))

x = 0
for i in range(len(n_list)):
   x = c_list[i] * n_[i] * t[i] + x
x = x % n
print(x)
x = iroot(x, 9)[0]
print(long_to_bytes(x))

3678337284039442047026947312380394506988284605153398380909870598085147736828709178219597429308046538374273111663234962853201175297522552444068549756304348183089003998584929250444862897734669616839072634559776823068102560978738392642133409979083241310818961120830565330801827594023873873703163937572703881578432281109467318674533265052430906776650900523035132668203491899352234368836316318216812572637893433384928785981896373747430646617935503364537613820302679656375356094380483213814869276308187497478084540603362678580814022322799191778371368875742773945120383365613028633102737056410926701477700008313642639347163933146129361496566648131161287075292980980083166106192999528561889437021539352391671756010617540361596164032486633114877739259434431765044242037641759566659268290619705700083536966807192023377334915872207418596226819579720241509860110741821630775501873143209229299530346706612248414951753383716954165108266753409813119293227854442685830689203424064786691447734948037502729127922328149002842971722645909768174575776908113523451541199095073733017029558396658874593357205426105429760517295964966905772455366037986657671195106462661190327510507460112791663031458690187525393979689469548319821181450874331998372947479866557921497942728807505035932385939931524294822439633516457845581452433022749099648076725811489217888688273759202726271093237450290814247396662589614216704
b’flag{H0w_Fun_13_HAstads_broadca5t_AtTack!}\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16\x16’

27 [SWPUCTF 2021 新生赛]crypto9

🚩flag：NSSCTF{dd5f0021-7a8e-ee05-f25e-7882abc5d984}

💡hint：其他

AKKPLX{qv5x0021-7n8w-wr05-x25w-7882ntu5q984}
脚本给你了，去解吧

letter_list = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'  # 字母表


# 根据输入的key生成key列表
def Get_KeyList(key):
    key_list = []
    for ch in key:
        key_list.append(ord(ch.upper()) - 65)
    return key_list


# 加密函数
def Encrypt(plaintext, key_list):
    ciphertext = ""

    i = 0
    for ch in plaintext:  # 遍历明文
        if 0 == i % len(key_list):
            i = 0
        if ch.isalpha():  # 明文是否为字母,如果是,则判断大小写,分别进行加密
            if ch.isupper():
                ciphertext += letter_list[(ord(ch) - 65 + key_list[i]) % 26]
                i += 1
            else:
                ciphertext += letter_list[(ord(ch) - 97 + key_list[i]) % 26].lower()
                i += 1
        else:  # 如果密文不为字母,直接添加到密文字符串里
            ciphertext += ch
    return ciphertext


# 解密函数
def Decrypt(ciphertext, key):
    plaintext = ""

    i = 0
    for ch in ciphertext:  # 遍历密文
        if 0 == i % len(key_list):
            i = 0
        if ch.isalpha():  # 密文为否为字母,如果是,则判断大小写,分别进行解密
            if ch.isupper():
                plaintext += letter_list[(ord(ch) - 65 - key_list[i]) % 26]
                i += 1
            else:
                plaintext += letter_list[(ord(ch) - 97 - key_list[i]) % 26].lower()
                i += 1
        else:  # 如果密文不为字母,直接添加到明文字符串里
            plaintext += ch
    return plaintext


if __name__ == '__main__':
    print("加密请按D,解密请按E:")
    user_input = input();
    while (user_input != 'D' and user_input != 'E'):  # 输入合法性判断
        print("输入有误!请重新输入:")
        user_input = input()

    print("请输入密钥:")
    key = input()
    while (False == key.isalpha()):  # 输入合法性判断
        print("输入有误!密钥为字母,请重新输入:")
        key = input()

    key_list = Get_KeyList(key)

    if user_input == 'D':
        # 加密
        print("请输入明文:")
        plaintext = input()
        ciphertext = Encrypt(plaintext, key_list)
        print("密文为:\n%s" % ciphertext)
    else:
        # 解密
        print("请输入密文:")
        ciphertext = input()
        plaintext = Decrypt(ciphertext, key_list)
        print("明文为:\n%s" % plaintext)

解题脚本：

letter_list = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'  # 字母表

def Get_KeyList(key):
    """将密钥转换为数字列表（A=0, B=1, ...）"""
    return [ord(ch.upper()) - 65 for ch in key]

def Decrypt(ciphertext, key):
    """维吉尼亚解密函数"""
    plaintext = ""
    key_list = Get_KeyList(key)
    i = 0
    for ch in ciphertext:
        if i % len(key_list) == 0:
            i = 0
        if ch.isalpha():
            if ch.isupper():
                plaintext += letter_list[(ord(ch) - 65 - key_list[i]) % 26]
            else:
                plaintext += letter_list[(ord(ch) - 97 - key_list[i]) % 26].lower()
            i += 1
        else:
            plaintext += ch
    return plaintext

# 密文输入
ciphertext = "AKKPLX{qv5x0021-7n8w-wr05-x25w-7882ntu5q984}"

# 尝试常见密钥
common_keys = ["CTF", "FLAG", "NSS", "KEY", "SECRET"]
for key in common_keys:
    decrypted = Decrypt(ciphertext, key)
    print(f"密钥 '{key}': {decrypted}")

# 如果常见密钥无效，尝试暴力破解所有3字母密钥
if not any("NSS" in Decrypt(ciphertext, key) for key in common_keys):
    print("\n尝试暴力破解3字母密钥...")
    from itertools import product
    for key_tuple in product(letter_list, repeat=3):
        key = ''.join(key_tuple)
        decrypted = Decrypt(ciphertext, key)
        if "NSS" in decrypted:  # 假设Flag包含"NSS"
            print(f"找到可能密钥: {key}, 解密结果: {decrypted}")
            break

密钥 ‘CTF’: YRFNSS{oc5s0021-7l8d-rp05-e25r-7882lap5o984}
密钥 ‘FLAG’: VZKJGM{qp5s0021-7c8w-qm05-m25w-7882hoj5q984}
密钥 ‘NSS’: NSSCTF{dd5f0021-7a8e-ee05-f25e-7882abc5d984}
密钥 ‘KEY’: QGMFHZ{gr5z0021-7d8s-yh05-t25y-7882dpw5g984}
密钥 ‘SECRET’: IGIYHE{yr5v0021-7w8s-dz05-t25u-7882wpb5y984}

28 [SWPUCTF 2021 新生赛]crypto5

🚩flag：NSSCTF{because_i_like}

💡hint：RSA

flag= 25166751653530941364839663846806543387720865339263370907985655775152187319464715737116599171477207047430065345882626259880756839094179627032623895330242655333
n= 134109481482703713214838023035418052567000870587160796935708584694132507394211363652420160931185332280406437290210512090663977634730864032370977407179731940068634536079284528020739988665713200815021342700369922518406968356455736393738946128013973643235228327971170711979683931964854563904980669850660628561419

这个题目信息，只给了一个ciphertext(flag)和n，得知为RSA。思考一下RSA几种常见攻击，可以断定这是低加密指数小明文攻击。

from Crypto.Util.number import *
import gmpy2
flag = 25166751653530941364839663846806543387720865339263370907985655775152187319464715737116599171477207047430065345882626259880756839094179627032623895330242655333
e = 2
# e从2开始遍历，随便找一个较小的值，我这里取的是2**6。运行找到可以开e次方的flag，并得到其结果

while(e < 2**6):
    e += 1
    print(gmpy2.iroot(flag , e))        
# 添加一个print语句，将结果复制粘贴，转换格式
print(long_to_bytes(29305044677847256883031643626546437461373017758852477))

(mpz(29305044677847256883031643626546437461373017758852477), True)
(mpz(2239787367494658961926395047063833603906), False)
(mpz(30211023082079078184793394727428), False)
(mpz(171187162713350842203231979), False)
(mpz(30607823753538418950179), False)
(mpz(47326391870653513426), False)
(mpz(308305161786402933), False)
(mpz(5496455501691892), False)
(mpz(203782133965548), False)
(mpz(13083851218710), False)
(mpz(1281610142349), False)
(mpz(174950918127), False)
(mpz(31145010208), False)
(mpz(6879417989), False)
(mpz(1814981430), False)
(mpz(555252340), False)
(mpz(192421706), False)
(mpz(74138084), False)
(mpz(31280773), False)
(mpz(14275227), False)
(mpz(6974518), False)
(mpz(3617160), False)
(mpz(1977120), False)
(mpz(1132082), False)
(mpz(675554), False)
(mpz(418271), False)
(mpz(267679), False)
(mpz(176479), False)
(mpz(119521), False)
(mpz(82942), False)
(mpz(58846), False)
(mpz(42602), False)
(mpz(31417), False)
(mpz(23563), False)
(mpz(17950), False)
(mpz(13871), False)
(mpz(10862), False)
(mpz(8610), False)
(mpz(6903), False)
(mpz(5592), False)
(mpz(4575), False)
(mpz(3778), False)
(mpz(3146), False)
(mpz(2640), False)
(mpz(2233), False)
(mpz(1901), False)
(mpz(1630), False)
(mpz(1406), False)
(mpz(1219), False)
(mpz(1063), False)
(mpz(932), False)
(mpz(821), False)
(mpz(727), False)
(mpz(646), False)
(mpz(577), False)
(mpz(517), False)
(mpz(465), False)
(mpz(420), False)
(mpz(380), False)
(mpz(345), False)
(mpz(315), False)
(mpz(287), False)
b’NSSCTF{because_i_like}’

29 [LitCTF 2023]原来你也玩原神 (初级)

🚩flag：NSSCTF{YUANLAINIYEWANYUANSHENWWW}

💡hint：其他

题目描述:旅行者收到了一封奇怪的来信，是提瓦特大陆的语言！

我玩原神但是我看不懂）

![截屏2025-08-12 16.27.55](/Users/serenius/Library/Application Support/typora-user-images/截屏2025-08-12 16.27.55.png)

最后一行，对照拉丁文。

LITCTF{YUANLAINIYEWANYUANSHENWWW}

来自一个大佬的截图：

![截屏2025-08-12 16.29.28](/Users/serenius/Library/Application Support/typora-user-images/截屏2025-08-12 16.29.28.png)

30 [AFCTF 2018]Vigenère

🚩flag：NSSCTF{Whooooooo_U_Gotcha!}

💡hint：维吉尼亚 古典密码 字频统计

在线解密网站：https://www.guballa.de/vigenere-solver\

断网工具：https://github.com/atomcated/Vigenere

![截屏2025-08-12 16.32.58](/Users/serenius/Library/Application Support/typora-user-images/截屏2025-08-12 16.32.58.png)

31 [BJDCTF 2020]rsa

🚩flag：NSSCTF{p_is_common_divisor}

💡hint：共享素数 RSA 素数分解

from Crypto.Util.number import getPrime,bytes_to_long

flag=open("flag","rb").read()

p=getPrime(1024)
q=getPrime(1024)
assert(e<100000)
n=p*q
m=bytes_to_long(flag)
c=pow(m,e,n)
print c,n
print pow(294,e,n)

p=getPrime(1024)
n=p*q
m=bytes_to_long("BJD"*32)
c=pow(m,e,n)
print c,n

'''
output:
12641635617803746150332232646354596292707861480200207537199141183624438303757120570096741248020236666965755798009656547738616399025300123043766255518596149348930444599820675230046423373053051631932557230849083426859490183732303751744004874183062594856870318614289991675980063548316499486908923209627563871554875612702079100567018698992935818206109087568166097392314105717555482926141030505639571708876213167112187962584484065321545727594135175369233925922507794999607323536976824183162923385005669930403448853465141405846835919842908469787547341752365471892495204307644586161393228776042015534147913888338316244169120  13508774104460209743306714034546704137247627344981133461801953479736017021401725818808462898375994767375627749494839671944543822403059978073813122441407612530658168942987820256786583006947001711749230193542370570950705530167921702835627122401475251039000775017381633900222474727396823708695063136246115652622259769634591309421761269548260984426148824641285010730983215377509255011298737827621611158032976420011662547854515610597955628898073569684158225678333474543920326532893446849808112837476684390030976472053905069855522297850688026960701186543428139843783907624317274796926248829543413464754127208843070331063037
381631268825806469518166370387352035475775677163615730759454343913563615970881967332407709901235637718936184198930226303761876517101208677107311006065728014220477966000620964056616058676999878976943319063836649085085377577273214792371548775204594097887078898598463892440141577974544939268247818937936607013100808169758675042264568547764031628431414727922168580998494695800403043312406643527637667466318473669542326169218665366423043579003388486634167642663495896607282155808331902351188500197960905672207046579647052764579411814305689137519860880916467272056778641442758940135016400808740387144508156358067955215018
979153370552535153498477459720877329811204688208387543826122582132404214848454954722487086658061408795223805022202997613522014736983452121073860054851302343517756732701026667062765906277626879215457936330799698812755973057557620930172778859116538571207100424990838508255127616637334499680058645411786925302368790414768248611809358160197554369255458675450109457987698749584630551177577492043403656419968285163536823819817573531356497236154342689914525321673807925458651854768512396355389740863270148775362744448115581639629326362342160548500035000156097215446881251055505465713854173913142040976382500435185442521721  12806210903061368369054309575159360374022344774547459345216907128193957592938071815865954073287532545947370671838372144806539753829484356064919357285623305209600680570975224639214396805124350862772159272362778768036844634760917612708721787320159318432456050806227784435091161119982613987303255995543165395426658059462110056431392517548717447898084915167661172362984251201688639469652283452307712821398857016487590794996544468826705600332208535201443322267298747117528882985955375246424812616478327182399461709978893464093245135530135430007842223389360212803439850867615121148050034887767584693608776323252233254261047
'''

解题脚本：

from Crypto.Util.number import long_to_bytes
from math import gcd
from gmpy2 import invert

# 给定数据
c1 = 12641635617803746150332232646354596292707861480200207537199141183624438303757120570096741248020236666965755798009656547738616399025300123043766255518596149348930444599820675230046423373053051631932557230849083426859490183732303751744004874183062594856870318614289991675980063548316499486908923209627563871554875612702079100567018698992935818206109087568166097392314105717555482926141030505639571708876213167112187962584484065321545727594135175369233925922507794999607323536976824183162923385005669930403448853465141405846835919842908469787547341752365471892495204307644586161393228776042015534147913888338316244169120
n1 = 13508774104460209743306714034546704137247627344981133461801953479736017021401725818808462898375994767375627749494839671944543822403059978073813122441407612530658168942987820256786583006947001711749230193542370570950705530167921702835627122401475251039000775017381633900222474727396823708695063136246115652622259769634591309421761269548260984426148824641285010730983215377509255011298737827621611158032976420011662547854515610597955628898073569684158225678333474543920326532893446849808112837476684390030976472053905069855522297850688026960701186543428139843783907624317274796926248829543413464754127208843070331063037
hint = 381631268825806469518166370387352035475775677163615730759454343913563615970881967332407709901235637718936184198930226303761876517101208677107311006065728014220477966000620964056616058676999878976943319063836649085085377577273214792371548775204594097887078898598463892440141577974544939268247818937936607013100808169758675042264568547764031628431414727922168580998494695800403043312406643527637667466318473669542326169218665366423043579003388486634167642663495896607282155808331902351188500197960905672207046579647052764579411814305689137519860880916467272056778641442758940135016400808740387144508156358067955215018

c2 = 979153370552535153498477459720877329811204688208387543826122582132404214848454954722487086658061408795223805022202997613522014736983452121073860054851302343517756732701026667062765906277626879215457936330799698812755973057557620930172778859116538571207100424990838508255127616637334499680058645411786925302368790414768248611809358160197554369255458675450109457987698749584630551177577492043403656419968285163536823819817573531356497236154342689914525321673807925458651854768512396355389740863270148775362744448115581639629326362342160548500035000156097215446881251055505465713854173913142040976382500435185442521721
n2 = 12806210903061368369054309575159360374022344774547459345216907128193957592938071815865954073287532545947370671838372144806539753829484356064919357285623305209600680570975224639214396805124350862772159272362778768036844634760917612708721787320159318432456050806227784435091161119982613987303255995543165395426658059462110056431392517548717447898084915167661172362984251201688639469652283452307712821398857016487590794996544468826705600332208535201443322267298747117528882985955375246424812616478327182399461709978893464093245135530135430007842223389360212803439850867615121148050034887767584693608776323252233254261047

# 步骤1：通过共享素数攻击分解n1和n2
q = gcd(n1, n2)
assert q != 1  # 确保成功分解
p1 = n1 // q
p2 = n2 // q

# 步骤2：暴力枚举e（已知e < 100000）
for e in range(1, 100000):
    if pow(294, e, n1) == hint:
        print(f"找到e = {e}")
        break
else:
    raise ValueError("未找到正确的e")

# 步骤3：解密flag
phi = (p1 - 1) * (q - 1)
d = invert(e, phi)
m = pow(c1, d, n1)
flag = long_to_bytes(m)

print("解密结果:", flag)

找到e = 52361
解密结果: b’BJD{p_is_common_divisor}’

32 [HDCTF 2023]Normal_Rsa

🚩flag：NSSCTF{0b3663ed-67e4-44e2-aee7-7c2d8665b63c}

💡hint：共享素数 RSA 素数分解

from Crypto.Util.number import *
#from shin import flag


m=bytes_to_long(b'HDCTF{0b3663ed-67e4-44e2-aee7-7c2d8665b63c}')
e=65537
p=getPrime(256)
#q=getPrime(512)
q=6704006258427795304220450411280948926213189680360135534636452074716135019217911134480777251273836898349926894302122011679095979445240343891749741039976761
r=getPrime(512)
n=p*q*r
P=pow(p,2,n)
Q=pow(q,2,n)
c=pow(m,e,n)
print(f"P = {P}")
print(f"Q = {Q}")
print(f"n = {n}")
print(f"c = {c}")
'''
P = 6773247693445539441213578786581644136043035242620265251725630106817272212428325283262417364786451280269516220237289567904055371962564710888510272312707201
Q = 44943699913039047357456835559925378512493523252980366265686899925123157887149890185055864945749408514100461655676474535153113631214288057465776668291975220848776401405531599573114898492452990847774628035552581539370236080368457643523158920565504112005843410442573511095306233906498204203659537135943420051121
n = 4785613888465991171479248142015453309149548888755453367991501772592797686075465426815591528773123474962122102667475893532087343900904799831474817826058951265607078893487357878501280782935653048309499430170214015422492927323961394806106719569168457890040223027119115392961801582406287167644266319898276785787730947633037300317098453409851410936140488150390919951503767522517809035474567
c = 2247027561636791381460194811205520085150851211795956750955965051548230844233212462525163107917067768507367576366327035846089534916090521357212722275045521111077106695721780943857231570836500588468487620819893688830570842176795906808347617421353983094639290979158413935035603633331786978227439155042365130799647385116773171906670409535157184391352888875130028955334874727206292146950544
'''

解题脚本：

import gmpy2
from libnum import n2s
P = 6773247693445539441213578786581644136043035242620265251725630106817272212428325283262417364786451280269516220237289567904055371962564710888510272312707201
Q = 44943699913039047357456835559925378512493523252980366265686899925123157887149890185055864945749408514100461655676474535153113631214288057465776668291975220848776401405531599573114898492452990847774628035552581539370236080368457643523158920565504112005843410442573511095306233906498204203659537135943420051121
n = 4785613888465991171479248142015453309149548888755453367991501772592797686075465426815591528773123474962122102667475893532087343900904799831474817826058951265607078893487357878501280782935653048309499430170214015422492927323961394806106719569168457890040223027119115392961801582406287167644266319898276785787730947633037300317098453409851410936140488150390919951503767522517809035474567
c = 2247027561636791381460194811205520085150851211795956750955965051548230844233212462525163107917067768507367576366327035846089534916090521357212722275045521111077106695721780943857231570836500588468487620819893688830570842176795906808347617421353983094639290979158413935035603633331786978227439155042365130799647385116773171906670409535157184391352888875130028955334874727206292146950544
e = 65537
p = gmpy2.isqrt(P)
q = gmpy2.isqrt(Q)
r = n // p // q
phi = (p - 1) * (r - 1)
d = gmpy2.invert(e, phi)
m = pow(c, d, r)
decrypted_message = n2s(int(m))
print("Decrypted message:", decrypted_message)

Decrypted message: b’HDCTF{0b3663ed-67e4-44e2-aee7-7c2d8665b63c}’

33 [NSSCTF 2022 Spring Recruit]Vigenere

🚩flag：NSSCTF{crypto_needs_you}

💡hint：维吉尼亚 古典密码 字频统计

在线解密网站：https://www.guballa.de/vigenere-solver\

断网工具：https://github.com/atomcated/Vigenere

![截屏2025-08-12 16.43.25](/Users/serenius/Library/Application Support/typora-user-images/截屏2025-08-12 16.43.25.png)

NSSCTF{crypto_needs_you}

🚩flag：NSSCTF{8e4b2888-6148-4003-b725-3ff0d93a6ee4}

💡hint：base

j2rXjx8yjd=YRZWyTIuwRdbyQdbqR3R9iZmsScutj2iqj3/tidj1jd=D
GHI3KLMNJOPQRSTUb%3DcdefghijklmnopWXYZ%2F12%2B406789VaqrstuvwxyzABCDEF5

换表base64

import base64
import string
from Crypto.Util.number import *
str1 = "j2rXjx8yjd=YRZWyTIuwRdbyQdbqR3R9iZmsScutj2iqj3/tidj1jd=D"
new  = "GHI3KLMNJOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF"
inti = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

print (base64.b64decode(str1.translate(str.maketrans(new,inti))))

b’flag{8e4b2888-6148-4003-b725-3ff0d93a6ee4}’

35 [BJDCTF 2020]EasyRSA

🚩flag：NSSCTF{Advanced_mathematics_is_too_hard!!!}

💡hint：RSA

from Crypto.Util.number import getPrime,bytes_to_long
from sympy import Derivative
from fractions import Fraction
from secret import flag

p=getPrime(1024)
q=getPrime(1024)
e=65537
n=p*q
z=Fraction(1,Derivative(arctan(p),p))-Fraction(1,Derivative(arth(q),q))
m=bytes_to_long(flag)
c=pow(m,e,n)
print(c,z,n)
'''
output:
7922547866857761459807491502654216283012776177789511549350672958101810281348402284098310147796549430689253803510994877420135537268549410652654479620858691324110367182025648788407041599943091386227543182157746202947099572389676084392706406084307657000104665696654409155006313203957292885743791715198781974205578654792123191584957665293208390453748369182333152809882312453359706147808198922916762773721726681588977103877454119043744889164529383188077499194932909643918696646876907327364751380953182517883134591810800848971719184808713694342985458103006676013451912221080252735948993692674899399826084848622145815461035
32115748677623209667471622872185275070257924766015020072805267359839059393284316595882933372289732127274076434587519333300142473010344694803885168557548801202495933226215437763329280242113556524498457559562872900811602056944423967403777623306961880757613246328729616643032628964072931272085866928045973799374711846825157781056965164178505232524245809179235607571567174228822561697888645968559343608375331988097157145264357626738141646556353500994924115875748198318036296898604097000938272195903056733565880150540275369239637793975923329598716003350308259321436752579291000355560431542229699759955141152914708362494482
15310745161336895413406690009324766200789179248896951942047235448901612351128459309145825547569298479821101249094161867207686537607047447968708758990950136380924747359052570549594098569970632854351825950729752563502284849263730127586382522703959893392329333760927637353052250274195821469023401443841395096410231843592101426591882573405934188675124326997277775238287928403743324297705151732524641213516306585297722190780088180705070359469719869343939106529204798285957516860774384001892777525916167743272419958572055332232056095979448155082465977781482598371994798871917514767508394730447974770329967681767625495394441

'''

解题脚本：

from Crypto.Util.number import long_to_bytes
from gmpy2 import isqrt, invert

# 给定数据
c = 7922547866857761459807491502654216283012776177789511549350672958101810281348402284098310147796549430689253803510994877420135537268549410652654479620858691324110367182025648788407041599943091386227543182157746202947099572389676084392706406084307657000104665696654409155006313203957292885743791715198781974205578654792123191584957665293208390453748369182333152809882312453359706147808198922916762773721726681588977103877454119043744889164529383188077499194932909643918696646876907327364751380953182517883134591810800848971719184808713694342985458103006676013451912221080252735948993692674899399826084848622145815461035
z = 32115748677623209667471622872185275070257924766015020072805267359839059393284316595882933372289732127274076434587519333300142473010344694803885168557548801202495933226215437763329280242113556524498457559562872900811602056944423967403777623306961880757613246328729616643032628964072931272085866928045973799374711846825157781056965164178505232524245809179235607571567174228822561697888645968559343608375331988097157145264357626738141646556353500994924115875748198318036296898604097000938272195903056733565880150540275369239637793975923329598716003350308259321436752579291000355560431542229699759955141152914708362494482
n = 15310745161336895413406690009324766200789179248896951942047235448901612351128459309145825547569298479821101249094161867207686537607047447968708758990950136380924747359052570549594098569970632854351825950729752563502284849263730127586382522703959893392329333760927637353052250274195821469023401443841395096410231843592101426591882573405934188675124326997277775238287928403743324297705151732524641213516306585297722190780088180705070359469719869343939106529204798285957516860774384001892777525916167743272419958572055332232056095979448155082465977781482598371994798871917514767508394730447974770329967681767625495394441
e = 65537

# 步骤1：计算 p + q = sqrt(z + 2n)
s = isqrt(z + 2 * n)
assert s * s == z + 2 * n  # 验证是否为完全平方数

# 步骤2：解方程 x² - s*x + n = 0
delta = s * s - 4 * n
p = (s - isqrt(delta)) // 2
q = n // p

# 验证 p 和 q
assert p * q == n
assert p + q == s

# 步骤3：计算私钥 d
phi = (p - 1) * (q - 1)
d = invert(e, phi)

# 步骤4：解密明文 m
m = pow(c, d, n)
flag = long_to_bytes(m)

print("解密结果:", flag)

解密结果: b’BJD{Advanced_mathematics_is_too_hard!!!}’

36 [SWPUCTF 2021 新生赛]crypto1

🚩flag：NSSCTF{d64dba66-b608-4255-b888-0b0f25c2f90e}

💡hint：RSA

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



flag  = '****************************'
flag = {"asfajgfbiagbwe"}
p = getPrime(2048)
q = getPrime(2048)
m1 = bytes_to_long(bytes(flag.encode()))

e1e2 = 3087
n = p*q
print()

flag1 = pow(m1,e1,n)
flag2 = pow(m1,e2,n)
print('flag1= '+str(flag1))
print('flag2= '+str(flag2))
print('n= '+str(n))


#flag1= 463634070971821449698012827631572665302589213868521491855038966879005784397309389922926838028598122795187584361359142761652619958273094398420314927073008031088375892957173280915904309949716842152249806486027920136603248454946737961650252641668562626310035983343018705370077783879047584582817271215517599531278507300104564011142229942160380563527291388260832749808727470291331902902518196932928128107067117198707209620169906575791373793854773799564060536121390593687449884988936522369331738199522700261116496965863870682295858957952661531894477603953742494526632841396338388879198270913523572980574440793543571757278020533565628285714358815083303489096524318164071888139412436112963845619981511061231001617406815056986634680975142352197476024575809514978857034477688443230263761729039797859697947454810551009108031457294164840611157524719173343259485881089252938664456637673337362424443150013961181619441267926981848009107466576314685961478748352388452114042115892243272514245081604607798243817586737546663059737344687130881861357423084448027959893402445303299089606081931041217035955143939567456782107203447898345284731038150377722447329202078375870541529539840051415759436083384408203659613313535094343772238691393447475364806171594
#flag2= 130959534275704453216282334815034647265875632781798750901627773826812657339274362406246297925411291822193191483409847323315110393729020700526946712786793380991675008128561863631081095222226285788412970362518398757423705216112313533155390315204875516645459370629706277876211656753247984282379731850770447978537855070379324935282789327428625259945250066774049650951465043700088958965762054418615838049340724639373351248933494355591934236360506778496741051064156771092798005112534162050165095430065000827916096893408569751085550379620558282942254606978819033885539221416335848319082054806148859427713144286777516251724474319613960327799643723278205969253636514684757409059003348229151341200451785288395596484563480261212963114071064979559812327582474674812225260616757099890896900340007990585501470484762752362734968297532533654846190900571017635959385883945858334995884341767905619567505341752047589731815868489295690574109758825021386698440670611361127170896689015108432408490763723594673299472336065575301681055583084547847733168801030191262122130369687497236959760366874106043801542493392227424890925595734150487586757484304609945827925762382889592743709682485229267604771944535469557860120878491329984792448597107256325783346904408
#n= 609305637099654478882754880905638123124918364116173050874864700996165096776233155524277418132679727857702738043786588380577485490575591029930152718828075976000078971987922107645530323356525126496562423491563365836491753476840795804040219013880969539154444387313029522565456897962200817021423704204077133003361140660038327458057898764857872645377236870759691588009666047187685654297678987435769051762120388537868493789773766688347724903911796741124237476823452505450704989455260077833828660552130714794889208291939055406292476845194489525212129635173284301782141617878483740788532998492403101324795726865866661786740345862631916793208037250277376942046905892342213663197755010315060990871143919384283302925469309777769989798197913048813940747488087191697903624669415774198027063997058701217124640082074789591591494106726857376728759663074734040755438623372683762856958888826373151815914621262862750497078245369680378038995425628467728412953392359090775734440671874387905724083226246587924716226512631671786591611586774947156657178654343092123117255372954798131265566301316033414311712092913492774989048057650627801991277862963173961355088082419091848569675686058581383542877982979697235829206442087786927939745804017455244315305118437

解题脚本：

import gmpy2
import libnum
import sympy
from Crypto.Util.number import long_to_bytes


def RsaSameModuleAttack(e1, e2, c1, c2, n):
    e1, e2, c1, c2, n = int(e1), int(e2), int(c1), int(c2), int(n)
    print("i,e2:", e1, e2)
    print(gmpy2.gcd(e1, e2))
    s = gmpy2.gcdext(e1, e2)
    print(s)
    s1 = s[1]
    s2 = s[2]
    if s1 < 0:
        s1 = - s1
        c1 = gmpy2.invert(c1, n)
    elif s2 < 0:
        s2 = - s2
        c2 = gmpy2.invert(c2, n)
    m = (pow(c1, s1, n) * pow(c2, s2, n)) % n
    return int(m)


def lowEncryptionIndex(c, n, e):
    for k in range(200000000):
        if gmpy2.iroot(k * n + c, e)[1]:
            return gmpy2.iroot(k * n + c, e)[0]
    return False


if __name__ == '__main__':
    flag1 = 463634070971821449698012827631572665302589213868521491855038966879005784397309389922926838028598122795187584361359142761652619958273094398420314927073008031088375892957173280915904309949716842152249806486027920136603248454946737961650252641668562626310035983343018705370077783879047584582817271215517599531278507300104564011142229942160380563527291388260832749808727470291331902902518196932928128107067117198707209620169906575791373793854773799564060536121390593687449884988936522369331738199522700261116496965863870682295858957952661531894477603953742494526632841396338388879198270913523572980574440793543571757278020533565628285714358815083303489096524318164071888139412436112963845619981511061231001617406815056986634680975142352197476024575809514978857034477688443230263761729039797859697947454810551009108031457294164840611157524719173343259485881089252938664456637673337362424443150013961181619441267926981848009107466576314685961478748352388452114042115892243272514245081604607798243817586737546663059737344687130881861357423084448027959893402445303299089606081931041217035955143939567456782107203447898345284731038150377722447329202078375870541529539840051415759436083384408203659613313535094343772238691393447475364806171594
    flag2 = 130959534275704453216282334815034647265875632781798750901627773826812657339274362406246297925411291822193191483409847323315110393729020700526946712786793380991675008128561863631081095222226285788412970362518398757423705216112313533155390315204875516645459370629706277876211656753247984282379731850770447978537855070379324935282789327428625259945250066774049650951465043700088958965762054418615838049340724639373351248933494355591934236360506778496741051064156771092798005112534162050165095430065000827916096893408569751085550379620558282942254606978819033885539221416335848319082054806148859427713144286777516251724474319613960327799643723278205969253636514684757409059003348229151341200451785288395596484563480261212963114071064979559812327582474674812225260616757099890896900340007990585501470484762752362734968297532533654846190900571017635959385883945858334995884341767905619567505341752047589731815868489295690574109758825021386698440670611361127170896689015108432408490763723594673299472336065575301681055583084547847733168801030191262122130369687497236959760366874106043801542493392227424890925595734150487586757484304609945827925762382889592743709682485229267604771944535469557860120878491329984792448597107256325783346904408
    n = 609305637099654478882754880905638123124918364116173050874864700996165096776233155524277418132679727857702738043786588380577485490575591029930152718828075976000078971987922107645530323356525126496562423491563365836491753476840795804040219013880969539154444387313029522565456897962200817021423704204077133003361140660038327458057898764857872645377236870759691588009666047187685654297678987435769051762120388537868493789773766688347724903911796741124237476823452505450704989455260077833828660552130714794889208291939055406292476845194489525212129635173284301782141617878483740788532998492403101324795726865866661786740345862631916793208037250277376942046905892342213663197755010315060990871143919384283302925469309777769989798197913048813940747488087191697903624669415774198027063997058701217124640082074789591591494106726857376728759663074734040755438623372683762856958888826373151815914621262862750497078245369680378038995425628467728412953392359090775734440671874387905724083226246587924716226512631671786591611586774947156657178654343092123117255372954798131265566301316033414311712092913492774989048057650627801991277862963173961355088082419091848569675686058581383542877982979697235829206442087786927939745804017455244315305118437
    e1e2 = 3087
    for e1 in range(2, e1e2):
        if e1e2 % e1 == 0:
            e2 = e1e2 // e1
            if gmpy2.gcd(e1, e2):
                c = RsaSameModuleAttack(e1, e2, flag1, flag2, n)
                e = gmpy2.gcd(e1, e2)
                result = lowEncryptionIndex(c, n, e)
                if result:
                    print(long_to_bytes(result))

运行时间会比较长：

b’\x10H\x9e\xdd\x1f9\xbd\x96\xa1u\xa1oVxR\xe4\x84\xe4fb\xc5\x1bKfO\xddE\xb5*\xf6”\x91zY\xb2\x8f\xe7\x89\xcd\x046\xd9\x12\x1d9\xe7\x14\x08\xb3\xd6\xcd\x8f\xb7\xa1v+\xba\x85\xe0(:w\xce\xf5ol\xe9;\x8e\xd0b\x1e\x14\n\x92\x0b\xe9\x99\xd5G\x95\x082\xb4\xc3\x8cL\xd5\x0c^p\xec\xa4\x01\x88E\x15\x8a}i%K`\xf5\xff\xfen<\x0e\xc3\x88u\x07\x82\xb8\xdc\xbf\xb0\xcba\xe3\xe1\xeb\xbf\xc0\x12#\xfd8\x02I\x83\xc5\xcffr\xdb\x85\xf6\xed\x93\x10\n\x1b\xfb\x10M\xa1\xa1\x82t\xcb\xbc\xae\x19\x91R\x81\xd0\xdc\xafF\xba\x95A\xe6\x02\x06Lyu\xb2Iv\xb5\xdf\x1d-=\x16\xe7@)\x83m\x08Y\xca$V\xcaI\xc1\xf0\xcf\x94:ca\xc4\x0f\xa2\xf4\nz\xbbR\x90\x01\,\xdf;\xe0|\xbb\xc1\xab\xf4k\xb7^\xb9T\xcc;Xp\x9e\xe9\xed\xf7\x83\x10\xebr\xf3?\xd9\x81 \xf7)\xf6\xdd\xb9\xb8\x12B\x913_$\xbd\x0fm!>\xd2\'~P\x9f\xbcJ\xb0\xf1B\xbd\x17!\x9co\xeb/\x08<\xad\xfb\xe7R\xbc\x11\xc8\x845\x062\x10\x82\xc6p\xbb\xe7$\x8b\x08N\x06\xa80\x9f\n\x90T\x9bd\xd1\xa9\x80\xab\xad\x8c6\xcf\x80\xe0\xa8*7\x99\x1f\xb2\xf92}\x1d\xb1w\xb1\xb8\x9f;\x06\x0bC\xc5\xfeG\xc3M\xfcg\xa0h\x8d\xac\rl\xb4F\xb9\xb5\xaa\xcc\x9f\xf96V\xf69\xec\x8e=:\xf5K%\xd3\xe3!OC\xd6\xcb,\xaa|P3\x07\xdfF\xb9\x12\xeb\x84\xe4\xc6;g\x08\xab\x1a\x9b\xfe\x10\x96l\x9dP:\xc5\xf8\x00L\xd6L7\x10\x10\x1c\xb5\xeb\x9dT\xc2Y\xd9s\x8d\x99\xb5[.\xd5\xfe\x95Q\xc4$~F\xad\x1d-?\x0fo\xd1\xbe\r\xa0\xeb\xf9X\xd3”\x13\x03Tm2=\xb7\x87Fs\x07\x8dJ<\xe8\xe2bL$\xab\x83\x00Y\r\xea\xe6_Y\xc7\xcf\x1b\x02\xf26\xd7]\xb8\xc0\xe2'\x86\x9b\xc4x\x99\x10\x92\xdbF\x95\xc3\x13M|j\xe1\xa7w\xd7’
b’NSSCTF{d64dba66-b608-4255-b888-0b0f25c2f90e}’
b’Y\x81U\xd5<R[w\x10\xe6\x1d9\xecq?\x01\x1ew\x1cq\xa6\xa9>\x8fH|F\x0f37\xf7\xb9\xd8\xf1\n\xff\xac\xba\xc8\xa5j\xec\xe78\x19\xf2\x831B\xca\x96\xd12\xa3L2\xb6\xaf\xe6\xfd\x16\xe3ER\x87L\xc6[\x929\xbd\xd2=\x12\x9c\x991\x86$0\x16\xd9\x8c\xf5m\xa53'\xf0\xe9\xa9L\x8c\xc6\x13/1\xf1D\xc2\xb2\xa1\xd7\xe8\x81k6m\xfa\x86;\xb9X\x86\x85`\xe3\x9f\x84\xfaW\xf2\x1d\xe5\xe4\xa5\xb9K\xed\x16\xdb\xdb\xbe\x00:\x7f\x91|+\xba\x90\x8c\xd4\xc4)>6\xf81\xe7\xff\xb6M0\x80\xfd2J#\x16\xb8\xb4\x10\xed\xc4S4\xd3?\xf0\x0b\rG8\x8e\xa8\xceU\t2+\xbe\xb1\x0er\x98o9\xf5{\x1ab\x03,G\nn\r\xf6\x1a\xd1v\xe7\x9dO\xdf\x7f\x9d\xb2\xf8\x13\x84\xea\xc5\x83\xc5\x11\xea\x9c\xe1\xfc\x8aWs\xb17\x88\xa8\xfa\xd3\x1d\xf9\x9c\x08X\xdc\xdc\x8d J1igg\x97\x10}V\xa0?\xca\x91\x84\xd5\xcf\xc0\x90\x8c\x94\xf1)\xd9pl\xddJ\x91r2q\xfd?\xcc\xbd\xde\r\xe7\xe2#7tmI\x9c\xea\xee\\x99lME\xbb\xe5\xb5\xaf]\xf2\x08\xec\x16\x01(M\xab\xfan\xc9\x02\x0e\x7f\x94Z\x8e\xad\xaa\xa5g\xb7h\xc5d\xdc%y\x91\xcfS_.\x93\xac\xc9/\x86\xdf\xe0\xf0L\x96\x17\x82H\xd7\xa8c\xefEZ\xd4p\x16”\xcc\x00\xa7\xaa\r\xbe\x9f}\xd9\\xe3\xd9\xde\x9c[\xa6\xd25\xddx\xb0\xb5\xcd5\xe9u\x04\xbf\xcfZ\xa4=\x8eE\x91\xf3'\xe627F\x0f\x9b&\x1d\xd6lG\xdb\xa5\x91\xab\xc4\x1f\n]\x9e\xf5F\xe2\xc3\xac\xbf+2\xec\xc1\xb3\x89\x8b\x91.\x9c\xe73\xd0\xb4v\xdd\x83\xb3t\x02\x01\x98\xc1tsP\x90\xde\xf3\x85\xcd\xda\xd6u_\xab\x0eIvs\x01{oQI\x1c\xbd{\x945\xfc\xa5\xe2c\x16\x9e)\xb0\x80D\xb2%\xa45\xca\x94\xdc\xd2v=\xd9{-~&*\xfa\x94j\x80\xab&\xdcS\xf1\x92\x91^\xa5\x13\\xe5\xb3Z’

37 [BJDCTF 2020]rsa_output

🚩flag：NSSCTF{r3a_C0mmoN_moD@_4ttack}

💡hint：RSA

{21058339337354287847534107544613605305015441090508924094198816691219103399526800112802416383088995253908857460266726925615826895303377801614829364034624475195859997943146305588315939130777450485196290766249612340054354622516207681542973756257677388091926549655162490873849955783768663029138647079874278240867932127196686258800146911620730706734103611833179733264096475286491988063990431085380499075005629807702406676707841324660971173253100956362528346684752959937473852630145893796056675793646430793578265418255919376323796044588559726703858429311784705245069845938316802681575653653770883615525735690306674635167111,2767}

{21058339337354287847534107544613605305015441090508924094198816691219103399526800112802416383088995253908857460266726925615826895303377801614829364034624475195859997943146305588315939130777450485196290766249612340054354622516207681542973756257677388091926549655162490873849955783768663029138647079874278240867932127196686258800146911620730706734103611833179733264096475286491988063990431085380499075005629807702406676707841324660971173253100956362528346684752959937473852630145893796056675793646430793578265418255919376323796044588559726703858429311784705245069845938316802681575653653770883615525735690306674635167111,3659}

message1=20152490165522401747723193966902181151098731763998057421967155300933719378216342043730801302534978403741086887969040721959533190058342762057359432663717825826365444996915469039056428416166173920958243044831404924113442512617599426876141184212121677500371236937127571802891321706587610393639446868836987170301813018218408886968263882123084155607494076330256934285171370758586535415136162861138898728910585138378884530819857478609791126971308624318454905992919405355751492789110009313138417265126117273710813843923143381276204802515910527468883224274829962479636527422350190210717694762908096944600267033351813929448599

message2=11298697323140988812057735324285908480504721454145796535014418738959035245600679947297874517818928181509081545027056523790022598233918011261011973196386395689371526774785582326121959186195586069851592467637819366624044133661016373360885158956955263645614345881350494012328275215821306955212788282617812686548883151066866149060363482958708364726982908798340182288702101023393839781427386537230459436512613047311585875068008210818996941460156589314135010438362447522428206884944952639826677247819066812706835773107059567082822312300721049827013660418610265189288840247186598145741724084351633508492707755206886202876227

解题脚本：

import gmpy2
from Crypto.Util.number import *

# 两组公钥模数相同 => 共模攻击
n = 21058339337354287847534107544613605305015441090508924094198816691219103399526800112802416383088995253908857460266726925615826895303377801614829364034624475195859997943146305588315939130777450485196290766249612340054354622516207681542973756257677388091926549655162490873849955783768663029138647079874278240867932127196686258800146911620730706734103611833179733264096475286491988063990431085380499075005629807702406676707841324660971173253100956362528346684752959937473852630145893796056675793646430793578265418255919376323796044588559726703858429311784705245069845938316802681575653653770883615525735690306674635167111

e1 = 2767
n1 = 21058339337354287847534107544613605305015441090508924094198816691219103399526800112802416383088995253908857460266726925615826895303377801614829364034624475195859997943146305588315939130777450485196290766249612340054354622516207681542973756257677388091926549655162490873849955783768663029138647079874278240867932127196686258800146911620730706734103611833179733264096475286491988063990431085380499075005629807702406676707841324660971173253100956362528346684752959937473852630145893796056675793646430793578265418255919376323796044588559726703858429311784705245069845938316802681575653653770883615525735690306674635167111
c1 = 20152490165522401747723193966902181151098731763998057421967155300933719378216342043730801302534978403741086887969040721959533190058342762057359432663717825826365444996915469039056428416166173920958243044831404924113442512617599426876141184212121677500371236937127571802891321706587610393639446868836987170301813018218408886968263882123084155607494076330256934285171370758586535415136162861138898728910585138378884530819857478609791126971308624318454905992919405355751492789110009313138417265126117273710813843923143381276204802515910527468883224274829962479636527422350190210717694762908096944600267033351813929448599

e2 = 3659
n2 = 21058339337354287847534107544613605305015441090508924094198816691219103399526800112802416383088995253908857460266726925615826895303377801614829364034624475195859997943146305588315939130777450485196290766249612340054354622516207681542973756257677388091926549655162490873849955783768663029138647079874278240867932127196686258800146911620730706734103611833179733264096475286491988063990431085380499075005629807702406676707841324660971173253100956362528346684752959937473852630145893796056675793646430793578265418255919376323796044588559726703858429311784705245069845938316802681575653653770883615525735690306674635167111
c2 = 11298697323140988812057735324285908480504721454145796535014418738959035245600679947297874517818928181509081545027056523790022598233918011261011973196386395689371526774785582326121959186195586069851592467637819366624044133661016373360885158956955263645614345881350494012328275215821306955212788282617812686548883151066866149060363482958708364726982908798340182288702101023393839781427386537230459436512613047311585875068008210818996941460156589314135010438362447522428206884944952639826677247819066812706835773107059567082822312300721049827013660418610265189288840247186598145741724084351633508492707755206886202876227

# 共模攻击时， gcd(e1, e2) = 1 => 存在s1 s2使得 e1*s1+e2*s2 = 1  s1与s2一正一负
# 并且有m = (c1^s1)*(c2^s2)
# gmpy2.gcdext(e1,e2) 用于求式子 e1*x+e2*y=gcd(e1,e2) 的解
#   Return a 3-element tuple (g,s,t) such that
#         g == gcd(a,b) and g == a*s + b*t

def rsa_mod_same_N(e1, c1, e2, c2, n):
    s, s1, s2 = gmpy2.gcdext(e1, e2)
    print(s, s1, s2)
    m = gmpy2.mod(gmpy2.powmod(c1, s1, n)*gmpy2.powmod(c2,s2,n), n)
    return m

m = rsa_mod_same_N(e1, c1, e2, c2, n)
print(long_to_bytes(m))

1 -201 152
b‘BJD{r3a_C0mmoN_moD@_4ttack}’

38 [闽盾杯 2021]decode

🚩flag：NSSCTF{G00d_w4y_tO_cR4ck_RS4}

💡hint：RSA

n1:
15228664629164509105936278301396170708905691970126305196584505186788860519598413718493859625462561931380632032431490419378905593909771649295663481782473029836321132574188559245931660756414915507930357509270674460219615256962333464689419869130366867401404262606367700782040693275068101244535880649261286041921882470460606034302142183971677715439862839410834231609821777031530457674591868138859358815039755085358568037032478394036448363183057305077227769673701227083943898736796552550712057417053897722979700329662099072959306298177351997084389916443815546425080826441671985030755256185725913397986385179516049927425591
n2:
28182418532443955655250943929828439725377604572088962537896240628709829618999901367131159759359513146864646169253348651905865895468151210748207509325666501438590382812326109260537618829438786609626137074778638549998280533912080708785604673270460635181275360847313985764185991865570533815651261638439461846512012164531330949433517277559149828806588070421852157781670188281908625986974579194819272643409859915715455134433970119584552350648013116998668938513347083566970423327936691885137812528912263666957628197241313496232397910546498542303925205356813548741679943691886217742767778075067797422624969714343428365022749
n3:
18355811159408154065817199279776805621878757240392366715869421799780946779485225342662736231980532326015283372375030686507311099745671828649419794838611580909610100636296701054995302819692794479292794716441442731393027118795245239019609474743841061251498233337758043553376098591254587406941205804917663153256036922860462415387926973551020540123742773938055950168965005226319984869124543783579240130888344231027912143592472823564266887957101575622993773291455143915263715932280728961208233983782906070719786115187115449430196335973764600533097718947377609348244073036523422892353195107093782201003551217830556519184839
e1:
65537
e2:
27751
e3:
65537
c1:
5368342382489380107251269030258282008067103595899117880173297169710980852124379736420135829984131832023988667774795223808420069001078159756328642298736759964890517323144475742861501409284299556459601222657540302786301791897975932176538612601162552795835603779910738886150925504885639254302406755008796950704938463132687940418772021406619622090999564746948113296328739593309200238996686945891130656599419832796482095787039339269564880847130379179831744694000940207887150388411084465949903406848727641093033681144598595895383689139227400553234701993087147186292040330589331703587405822925483701667354935313494938769206
c2:
21521672635651854919517759696514027081496995002884626306313384597771682621826437868933822942195279941318573525337109548152966094293276717095298929811895186384560362917891928656637913236676702009205642367801075592458101830488916914437754803979953027152373619293870115731171449223105986403604973873007338969000153480949617700626516389419935352576014084068271819009465242491467427642787306345049280205827574043586767133396458785487959251540831856187380154825027964867977651727983254127239427622549059938701125498520279503972702883327594442747467858234391945790597844344295786118320620376681461727686876948563884520137741
c3:
13940747781246179701167820858098775936269078279837839169409057305686612176371099274767269714494905207551971162649902129137425806839867713157472497469542260664882313041602553845621113546259276402534229231780532278276697961222319054833980226978574905974878218905613341365260453461080117407529132948986104191917111000811731784483944945364091757083949827612260904757837644538366763161154611658652020868326985526984718638276184626634240096213703958275241215175054246685206226179114590838833694648062135027841593419815101363262701960507235056752424778384286627997500871204804629047307688466887868894491042058198480775705486

解题脚本：

from functools import *
from Crypto.Util.number import *
import gmpy2
n1 = 15228664629164509105936278301396170708905691970126305196584505186788860519598413718493859625462561931380632032431490419378905593909771649295663481782473029836321132574188559245931660756414915507930357509270674460219615256962333464689419869130366867401404262606367700782040693275068101244535880649261286041921882470460606034302142183971677715439862839410834231609821777031530457674591868138859358815039755085358568037032478394036448363183057305077227769673701227083943898736796552550712057417053897722979700329662099072959306298177351997084389916443815546425080826441671985030755256185725913397986385179516049927425591
n2 = 28182418532443955655250943929828439725377604572088962537896240628709829618999901367131159759359513146864646169253348651905865895468151210748207509325666501438590382812326109260537618829438786609626137074778638549998280533912080708785604673270460635181275360847313985764185991865570533815651261638439461846512012164531330949433517277559149828806588070421852157781670188281908625986974579194819272643409859915715455134433970119584552350648013116998668938513347083566970423327936691885137812528912263666957628197241313496232397910546498542303925205356813548741679943691886217742767778075067797422624969714343428365022749
n3 = 18355811159408154065817199279776805621878757240392366715869421799780946779485225342662736231980532326015283372375030686507311099745671828649419794838611580909610100636296701054995302819692794479292794716441442731393027118795245239019609474743841061251498233337758043553376098591254587406941205804917663153256036922860462415387926973551020540123742773938055950168965005226319984869124543783579240130888344231027912143592472823564266887957101575622993773291455143915263715932280728961208233983782906070719786115187115449430196335973764600533097718947377609348244073036523422892353195107093782201003551217830556519184839
e1 = 65537
e2 = 27751
e3 = 65537
c1 = 5368342382489380107251269030258282008067103595899117880173297169710980852124379736420135829984131832023988667774795223808420069001078159756328642298736759964890517323144475742861501409284299556459601222657540302786301791897975932176538612601162552795835603779910738886150925504885639254302406755008796950704938463132687940418772021406619622090999564746948113296328739593309200238996686945891130656599419832796482095787039339269564880847130379179831744694000940207887150388411084465949903406848727641093033681144598595895383689139227400553234701993087147186292040330589331703587405822925483701667354935313494938769206
c2 = 21521672635651854919517759696514027081496995002884626306313384597771682621826437868933822942195279941318573525337109548152966094293276717095298929811895186384560362917891928656637913236676702009205642367801075592458101830488916914437754803979953027152373619293870115731171449223105986403604973873007338969000153480949617700626516389419935352576014084068271819009465242491467427642787306345049280205827574043586767133396458785487959251540831856187380154825027964867977651727983254127239427622549059938701125498520279503972702883327594442747467858234391945790597844344295786118320620376681461727686876948563884520137741
c3 = 13940747781246179701167820858098775936269078279837839169409057305686612176371099274767269714494905207551971162649902129137425806839867713157472497469542260664882313041602553845621113546259276402534229231780532278276697961222319054833980226978574905974878218905613341365260453461080117407529132948986104191917111000811731784483944945364091757083949827612260904757837644538366763161154611658652020868326985526984718638276184626634240096213703958275241215175054246685206226179114590838833694648062135027841593419815101363262701960507235056752424778384286627997500871204804629047307688466887868894491042058198480775705486
p = gmpy2.gcd(n1,n2)
q = gmpy2.gcd(n2,n3)
def attack(p,q,e,c):
    n = p * q
    phi = (p - 1) * (q - 1)
    d = gmpy2.invert(e,phi)
    m = long_to_bytes(pow(c,d,n))
    print(m)
attack(p,n1 // p,e1,c1)
attack(p,n2 // p,e2,c2)
attack(q,n3 // q,e3,c3)

b”hahaha, you’ve got the flag didn’t you !the front part is :flag{G00d_w4”
b”hahaha, you’ve got the flag didn’t you !the middle part is :y_tO_cR”
b”hahaha, you’ve got the flag didn’t you !the last part is :4ck_RS4}”

39 [LitCTF 2023]md5的破解

🚩flag：NSSCTF{md5can123dexrypt213thoughcrpsh}

💡hint：md5

from Crypto.Util.number import *
from hashlib import md5
from secret import flag

#flag全是由小写字母及数字组成
m=md5(flag).hexdigest()
print(flag[:13]+flag[15:18]+flag[19:34]+flag[35:38])
print(m)
# b'LitCTF{md5can3derypt213thoughcrsh}'
# 496603d6953a15846cd7cc476f146771

解题脚本：

# 附件信息
from Crypto.Util.number import *
# from hashlib import md5
# from secret import flag
#
# #flag全是由小写字母及数字组成
# m=md5(flag).hexdigest()
# print(flag[:13]+flag[15:18]+flag[19:34]+flag[35:38])
# print(m)
# b'LitCTF{md5can3derypt213thoughcrsh}'
# 496603d6953a15846cd7cc476f146771

# 解码：
import string
import hashlib
dic = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_}{'
for i in dic:
    for j in dic:
        for k in dic:
            for l in dic:
              s = 'LitCTF{md5can'+i+j+'3de'+k+'rypt213thoughcr'+l+'sh}'
              print(s)
              if hashlib.md5(s.encode('utf-8')).hexdigest() == '496603d6953a15846cd7cc476f146771':
                 print("Find it: "+s)
                 exit(0)

LitCTF{md5can123dexrypt213thoughcrpsh}

40 [WUSTCTF 2020]佛说：只能四天

🚩flag：NSSCTF{ni_hao_xiang_xiang_da_wo}

💡hint：其他

圣经分为《旧约全书》和《新约全书》

尊即寂修我劫修如婆愍闍嚤婆莊愍耨羅嚴是喼婆斯吶眾喼修迦慧迦嚩喼斯願嚤摩隸所迦摩吽即塞願修咒莊波斯訶喃壽祗僧若即亦嘇蜜迦須色喼羅囉咒諦若陀喃慧愍夷羅波若劫蜜斯哆咒塞隸蜜波哆咤慧聞亦吽念彌諸嘚嚴諦咒陀叻咤叻諦缽隸祗婆諦嚩阿兜宣囉吽色缽吶諸劫婆咤咤喼愍尊寂色缽嘚闍兜阿婆若叻般壽聞彌即念若降宣空陀壽愍嚤亦喼寂僧迦色莊壽吽哆尊僧喼喃壽嘚兜我空所吶般所即諸吽薩咤諸莊囉隸般咤色空咤亦喃亦色兜哆嘇亦隸空闍修眾哆咒婆菩迦壽薩塞宣嚩缽寂夷摩所修囉菩阿伏嘚宣嚩薩塞菩波吶波菩哆若慧愍蜜訶壽色咒兜摩缽摩諦劫諸陀即壽所波咤聞如訶摩壽宣咤彌即嚩蜜叻劫嘇缽所摩闍壽波壽劫修訶如嚩嘇囉薩色嚤薩壽修闍夷闍是壽僧劫祗蜜嚴嚩我若空伏諦念降若心吽咤隸嘚耨缽伏吽色寂喃喼吽壽夷若心眾祗喃慧嚴即聞空僧須夷嚴叻心願哆波隸塞吶心須嘇摩咤壽嘚吶夷亦心亦喃若咒壽亦壽囑囑

题目中的圣经分为《旧约全书》和《新约全书》应该是指只有新约佛伦禅才解的出来
然后出来的是社会主义核心价值观，解完以后是一串字符，根据提示得出这啥栅栏密码
在栅栏解密的穷举中找到R5UALCUVJDCGD63RQISZTBOSO54JVBORP5SAT2OEQCWY6CGEO53Z67L_doyouknowCaesar_
得出凯撒加密，穷举结果，发现都是大写，且数字范围位2~7，应该是base32
解出wctf2020{ni_hao_xiang_xiang_da_wo}

CTF-Crypto暑期刷题记录

01 [鹤城杯 2021]easy_crypto

02 [强网拟态 2021]拟态签到题

03 [SWPUCTF 2021 新生赛]crypto8

04 [SWPUCTF 2021 新生赛]crypto7

05 [SWPUCTF 2021 新生赛]crypto6

06 [SWPUCTF 2021 新生赛]ez_caesar

07 [SWPUCTF 2021 新生赛]ez_caesar

08 [SWPUCTF 2021 新生赛]pigpig

09 [SWPUCTF 2021 新生赛]ez_rsa

10 [LitCTF 2023]梦想是红色的 (初级)

11 [鹤城杯 2021]A_CRYPTO

12 [LitCTF 2023]Hex？Hex！(初级)

13 [BJDCTF 2020]base??

14 [SWPUCTF 2021 新生赛]traditional

15 [SWPUCTF 2021 新生赛]crypto2

16 [羊城杯 2021]Bigrsa

17 [LitCTF 2023]家人们！谁懂啊，RSA签到都不会 (初级)

18 [LitCTF 2023]你是我的关键词(Keyworld) (初级)

19 [LitCTF 2023]Is this only base?

20 [SWPU 2020]happy

21 [安洵杯 2019]JustBase

22 [AFCTF 2018]BASE

23 [NSSCTF 2022 Spring Recruit]classic

24 [SWPUCTF 2021 新生赛]crypto4

25 [AFCTF 2018]你能看出这是什么加密么

26 [鹤城杯 2021]Crazy_Rsa_Tech

27 [SWPUCTF 2021 新生赛]crypto9

28 [SWPUCTF 2021 新生赛]crypto5

29 [LitCTF 2023]原来你也玩原神 (初级)

30 [AFCTF 2018]Vigenère

31 [BJDCTF 2020]rsa

32 [HDCTF 2023]Normal_Rsa

33 [NSSCTF 2022 Spring Recruit]Vigenere

34 [CISCN 2023 初赛]Sign_in_passwd

35 [BJDCTF 2020]EasyRSA

36 [SWPUCTF 2021 新生赛]crypto1

37 [BJDCTF 2020]rsa_output

38 [闽盾杯 2021]decode

39 [LitCTF 2023]md5的破解

40 [WUSTCTF 2020]佛说：只能四天