校内纳新赛wp

字数统计: 4.8k字   |   阅读时长≈ 20分

给校内纳新赛出的五道题，涉及编码解码、LCG入门、古典密码入门、RSA和sagemath软件安装。都能被AI一把梭的难度，也是骗点新生来学密码（bushi）

纳新赛密码wp

编码code

简单

描述

1
2
计算机是如何传递信息的？
让我看看！！！

题目（带注释版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# How to use mathematics to represent information?   # 题目借鉴来源0XGame南京邮电2024
from Crypto.Util.number import bytes_to_long
from base64 import b64encode

# 读取flag.txt文件内容到变量flag
flag = open("flag.txt", "r").read()

# 将flag转换为字节数组
msg = flag.encode()

# 计算消息的长度
length = len(msg)

# 确保消息长度可以被4整除
assert length % 4 == 0

# 计算消息的块数
block = length // 4

# 将消息分割成4个块
m = [msg[block * i: block * (i + 1)] for i in range(4)]

# 第一个块直接写入文件m0.txt
m0 = m[0]
with open("m0.txt", "wb") as f:
    f.write(m0)

# 第二个块转换为长整数
m1 = bytes_to_long(m[1])

# 第三个块转换为十六进制字符串，并再次转换为字节数组
m2 = m[2].hex().encode()

# 第四个块转换为base64编码的字节数组
m3 = b64encode(m[3])

# 打印m1, m2, m3的值
print(f'm1 = {m1}\nm2 = {m2}\nm3 = {m3}')


"""
m1 = 443281125274097696282661878389435999
m2 = b'686f775f746f5f6465636f64655f74'
m3 = b'aGVzZV9jb2RlISEhISF9'
"""

解析

  • 第一个块m0直接写入m0.txt中，考察ctfer读取文件的能力，为后面题目做准备。
  • 第二个块m1被转换为长整数，这是将信息转换为数学表示的一种方式。
  • 第三个块m2被转换为十六进制字符串，然后再次转换为字节数组，这是另一种数学表示形式。
  • 第四个块m3被转换为base64编码的字节数组，这是将信息转换为数学表示的另一种方式。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from base64 import b64decode
from Crypto.Util.number import *


m0 = open("m0.txt", "r").read().encode()
m1 = 443281125274097696282661878389435999
m2 = b'686f775f746f5f6465636f64655f74'
m3 = b'aGVzZV9jb2RlISEhISF9'

# m1是一个长整数，我们将其转换为字节数组
m1 = long_to_bytes(m1)
# m2是一个十六进制字节串，我们先将其转换字符串然后再转换为长整数，然后转换为字节串
m2 = long_to_bytes(int(m2.decode(), 16))
# m3是一个base64编码的字节数组，我们将其解码
m3 = b64decode(m3)
# 将所有块合并成一个字节数组m
m = m0+m1+m2+m3
# 打印合并后的字节数组m的解码成字符串的结果
print(m.decode()) # SeeUSec{WOWWOW_U_really_learn_how_to_decode_these_code!!!!!}

# 字节串带有b""开头，字符串没有

FLAG

1
SeeUSec{WOWWOW_U_really_learn_how_to_decode_these_code!!!!!}

古典入门

中等

描述

1
古典密码大扫盲

题目（带注释版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# 打开文件flag.txt并读取内容到变量FLAG
with open("flag.txt", "r") as f:
    FLAG = f.read()

# 将FLAG分成两部分：flag1和flag2
# flag1是FLAG的前32个字符
flag1 = FLAG[:32]
# flag2是FLAG剩余的字符
flag2 = FLAG[32:]

# 定义密钥k1，用于加密flag1
k1 = "<<<<<<<<<<<<<<<<SeeU2024>>>>>>>>>>>>>>>>>>>>"

# 初始化变量c1，用于存储加密后的flag1
c1 = ""
# 遍历flag1中的每个字符
for i in range(len(flag1)):
    # 使用异或操作(XOR)进行加密
    # ord()函数获取字符的ASCII值，^是异或操作符
    # k1[i % len(k1)]确保密钥k1可以重复使用
    t = chr(ord(flag1[i]) ^ ord(k1[i % len(k1)]))
    # 将加密后的字符追加到c1中
    c1 += t

# 定义密钥k2，用于加密flag2
# 在这里，k2表示栅栏密码的行数
k2 = 4

# 初始化列表c2，用于存储加密后的flag2
c2 = []
# 获取flag2的长度
length = len(flag2)
# 外层循环控制栅栏密码的行数
for i in range(k2):
    # 内层循环控制每一行中的字符位置
    for j in range(i, length, k2):
        # 将flag2中的字符按栅栏密码的规则添加到c2列表中
        c2.append(flag2[j])

# 将加密后的flag1（c1）写入文件c1.txt
with open("c1.txt", "wb") as f1:
    f1.write(c1.encode())

# 将加密后的flag2（c2）转换为字符串并写入文件c2.txt
with open("c2.txt", "wb") as f2:
    f2.write(''.join(c2).encode())

解析

古典密码按照加密方法分为替换和移位

本题中

flag1$\to$c1：替换，异或

flag2$\to$c2：移位，栅栏密码

task.py流程

  1. 读取flag.txt：脚本首先打开并读取一个名为flag.txt的文件，该文件包含完整的flag。
  2. 分割flag：flag被分成两部分，flag1是前32个字符，flag2是剩余的字符。
  3. 加密flag1：
    • 使用异或操作对flag1进行加密，密钥是k1。
    • k1是一个可重复的字符串，用于确保可以与flag1中的每个字符进行异或操作。
    • 加密后的结果存储在变量c1中。
  4. 加密flag2：
    • 使用栅栏密码对flag2进行加密，密钥是k2，这里k2是栅栏密码的行数。
    • 栅栏密码的工作原理是将字符按行排列，然后按列读取来构造密文。
    • 加密后的结果存储在列表c2中。
  5. 写入加密后的flag：
    • 将加密后的flag1（即c1）写入文件c1.txt。
    • 将加密后的flag2（即c2）转换为字符串并写入文件c2.txt。

在CTF比赛中，这种类型的题目通常要求参与者解密这个过程，即解密c1.txt和c2.txt来获取原始的flag。上述代码提供了加密的过程，而参与者需要编写解密脚本来恢复原始的flag。

知识点

异或操作（XOR）

异或（exclusive OR，通常表示为 XOR）是一种在数字逻辑中使用的二进制操作，它产生一个真值（true value）当且仅当两个输入不相同时。在Python中，异或操作用 ^ 表示。

特点：
  • 如果两个比较的位相同，结果是0；如果不同，结果是1。
  • 异或操作是可交换的，即 a ^ b 和 b ^ a 的结果是相同的。
  • 异或操作是可结合的，即 (a ^ b) ^ c 和 a ^ (b ^ c) 的结果是相同的。
  • 任何数与0进行异或操作，结果都是其本身，即 a ^ 0 = a。
  • 任何数与其自身进行异或操作，结果是0，即 a ^ a = 0。
加密和解密：

在加密中，异或操作通常用于简单的加密算法，因为它的可逆性。以下是如何使用异或进行加密和解密的示例：

1
2
3
4
5
# 加密
ciphertext = chr(ord(plaintext[i]) ^ ord(key[i % len(key)]))

# 解密
decrypted_text = chr(ord(ciphertext[i]) ^ ord(key[i % len(key)]))

在这个例子中，plaintext 是要加密的文本，key 是密钥。加密和解密过程完全相同，因为异或操作的可逆性。这意味着你可以用相同的密钥对密文进行相同的操作来获取原始文本。

栅栏密码

栅栏密码是一种简单的转换密码，它将消息的字母分成几行（行数由密钥决定），然后按行读取来构造密文。

加密过程：
  1. 确定栅栏的“行数”（即密钥）。
  2. 将明文消息分成几行，每行的字符数相同或尽可能接近。
  3. 从第一行开始，按顺序读取每个字符，然后继续到下一行，直到消息的末尾。
解密过程：
  1. 确定栅栏的“行数”（即密钥）。
  2. 计算密文消息的总长度，并确定每行的字符数。
  3. 创建一个与密文长度相同的字符串数组。
  4. 按照加密时的相反顺序，将密文字符填充到数组中。
  5. 将数组转换回字符串，得到原始明文。
示例：

假设我们有明文 “HELLO WORLD” 和密钥 3（即分成3行）。

加密过程：

1
2
3
H . . O . . W . . .
. E . L . O . R . .
. . L . . L . . D .

按行读取得到密文：“HOL ELORLWD”.

解密过程：

  1. 确定密钥为3，密文长度为11。
  2. 计算每行的字符数，大约为4（11/3向上取整）。
  3. 创建一个长度为11的字符串数组。
  4. 按照加密时的相反顺序填充数组：
1
HOL ELORLWD

填充结果：

1
2
3
H . . O . . W . . .
. E . L . O . R . .
. . L . . L . . D .

5.将数组转换回字符串得到 “HELLO WORLD”。

本题为ctf初学者提供了异或操作和栅栏密码

背后的置换和移位这两大古典密码核心的基本理解。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 打开文件c1.txt并读取内容到变量c1
c1 = open("c1.txt", "r").read()

# 定义密钥k1，密钥是用于加密和解密的可重复字符串
k1 = "<<<<<<<<<<<<<<<<SeeU2024>>>>>>>>>>>>>>>>>>>>"

# 初始化变量m1，用于存储解密后的字符串
m1 = ''

# 遍历c1中的每个字符
for i in range(len(c1)):
    # 使用异或操作(XOR)进行解密，异或操作可以逆转加密过程
    # ord()函数获取字符的ASCII值，^是异或操作符
    t2 = chr(ord(c1[i]) ^ ord(k1[i % len(k1)]))
    # 将解密后的字符追加到m1中
    m1 += t2

# 打印解密后的字符串m1
print(m1) # SeeUSec{this_is_b@by_replacement

# 打开文件c2.txt并读取内容到变量c2
c2 = open("c2.txt", "r").read()

# 定义密钥k2，这里k2表示栅栏密码的行数
k2 = 4

# 获取密文c2的长度
n = len(c2)

# 初始化一个列表plaintext，长度与密文c2相同，用于存储解密后的字符
plaintext = [''] * n

# 初始化索引变量idx，用于追踪当前解密到的密文字符
idx = 0

# 外层循环控制栅栏密码的行数
for i in range(k2):
    # 内层循环控制每一行中的字符位置
    for j in range(i, n, k2):
        # 将密文字符放置到正确的位置上
        plaintext[j] = c2[idx]
        # 索引自增，指向下一个密文字符
        idx += 1

# 使用join()函数将列表plaintext转换为字符串m2
m2 = ''.join(plaintext)

# 打印解密后的字符串m2
print(m2) # _@nd_th1s_is_baby_shift!!0*0}

# 将两个解密后的字符串m1和m2拼接起来，得到完整flag
print(m1 + m2) # SeeUSec{this_is_b@by_replacement_@nd_th1s_is_baby_shift!!0*0}

FLAG

1
SeeUSec{this_is_b@by_replacement_@nd_th1s_is_baby_shift!!0*0}

baby_LCG

中等

1
2
这个LCG就是逊辣
你有可能需要了解一下:[python求模逆元_python 求模逆-CSDN博客](https://blog.csdn.net/m0_46607055/article/details/120790231)

题目（带注释版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from Crypto.Util.number import *  # 导入Crypto库中的number模块，用于处理数字相关操作
from random import randrange  # 导入random库中的randrange函数，用于生成随机数
bits = 512  # 定义密钥长度为512位

# 读取flag.txt文件内容到变量flag
flag = open("flag.txt", "rb").read()  # 以二进制模式读取flag.txt文件
m = bytes_to_long(flag)  # 将flag转换为长整数

# 定义LCG类，用于生成线性同余发生器
class LCG(object):
    def __init__(self, seed):  # 初始化方法，接收一个参数seed，用于指定初始状态
        self.N = getPrime(bits)  # 生成一个bits位长的素数N
        self.a = randrange(self.N)  # 生成一个N位长的随机数a
        self.b = randrange(self.N)  # 生成一个N位长的随机数b
        self.seed = seed % self.N  # 计算seed模N的结果，作为初始状态
        self.state = self.seed  # 设置初始状态为seed

    def next(self):  # 生成下一个随机数的方法
        self.state = (self.a * self.state + self.b) % self.N  # 使用线性同余发生器生成下一个随机数
        return self.state

    def show(self):  # 显示当前状态的方法
        return self.a, self.b, self.N  # 返回a, b, N的值

# 创建LCG实例，使用flag的长度作为种子
lcg = LCG(m)

# 生成下一个随机数并打印状态和随机数
t = lcg.next()
print("a, b, N =", lcg.show())  # 打印当前状态
print("t =", t)  # 打印生成的随机数
"""
a, b, N = (1378752619434943933785591780693716018664050557123518722301140245162895768407168240162306093951546967956912779165269642352934543087254572566669599956060387, 2606396920116946933049611106919710556311992662089455045180948208442532420748038482818285161345472390027502315696857114200070403821911000030677455069309730, 8396614074175608834043974256584188896561302956276378241853443845559690162831762023481498499086684260749196385524201072401155399503345843775243288541771037)
t = 3616138044023560411837659702316171418583279311144999057428090421000076027945616204165037620038343983511514237669506728220338423933986128767471891171733644
"""

解析

挑战目标：

  • 目标：理解线性同余发生器（LCG）的工作原理，并利用泄露的信息解密密文。

挑战1：基础LCG生成

  • 解析：
    • LCG类用于生成一个512位的线性同余发生器。
    • 初始化方法接收一个参数seed，用于指定初始状态。
    • next方法生成下一个随机数。
    • show方法显示当前状态。
    • 在这个挑战中，我们使用flag的长度作为种子创建了LCG实例。

挑战2：泄露的LCG状态

  • 目标：理解如何利用泄露的LCG状态解密密文。
  • 解析：
    • LCG实例泄露了三个状态值：a, b, N。
    • 这些状态值是生成随机数的关键信息。
    • 利用泄露的a, b, N，我们可以重新创建LCG实例，并使用它来生成密文。
    • 解密步骤：
      1. 从泄露中获取a, b, N。
      2. 使用这些值创建LCG实例。
      3. 使用LCG实例生成密文。

这里需要注意一点

在带模运算中，没有除法，只有逆元

$\frac {a}{b} \equiv a\cdot b^{-1} \pmod c$

python中Crypto.Util.number提供了inverse(b,c)函数计算b在模c下的逆元

EXP

1
2
3
4
5
6
7
8
from Crypto.Util.number import *
a, b, N = (1378752619434943933785591780693716018664050557123518722301140245162895768407168240162306093951546967956912779165269642352934543087254572566669599956060387, 2606396920116946933049611106919710556311992662089455045180948208442532420748038482818285161345472390027502315696857114200070403821911000030677455069309730, 8396614074175608834043974256584188896561302956276378241853443845559690162831762023481498499086684260749196385524201072401155399503345843775243288541771037)
t = 3616138044023560411837659702316171418583279311144999057428090421000076027945616204165037620038343983511514237669506728220338423933986128767471891171733644

m = (t-b)*inverse(a, N) % N
flag = long_to_bytes(m).decode()
print(flag) # SeeUSec{WoW_LCG_is_funny}

FLAG

1
SeeUSec{WoW_LCG_is_funny}

RSA_baby_to_EZ

困难

描述

1
2
3
RSA大锅炖，一共三道“主食”

hint1：上周我好像在qq群里发过一个PPT

题目（带注释版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
# 一共有三个挑战，由简单到中等，现在开始你的Rsa学习之旅吧
from Crypto.Util.number import *  # 导入Crypto库中的number模块，用于处理数字相关操作
from gmpy2 import *  # 导入gmpy2库，提供大数运算支持

FLAG = open("flag.txt", "r").read()  # 读取flag.txt文件内容到变量FLAG

# 定义RSA类，用于生成RSA密钥对并进行加密操作
class RSA:
    def __init__(self, bits):  # 初始化方法，接收一个参数bits，用于指定密钥长度
        self.p = getPrime(bits)  # 生成一个bits位长的素数p
        self.q = getPrime(bits)  # 生成一个bits位长的素数q
        self.n = self.p * self.q  # 计算n作为公钥的一部分，n = p * q
        self.phi = (self.p - 1) * (self.q - 1)  # 计算欧拉函数phi(n) = (p-1) * (q-1)
        self.e = getPrime(16)  # 生成一个16位长的素数e作为公钥的指数
        self.d = int(invert(self.e, self.phi))  # 计算私钥指数d，d是e模phi(n)的逆元

    def public_key(self):  # 返回公钥(e, n)
        return self.e, self.n

    def enRSA(self, m):  # 加密方法，接收明文m，返回密文c
        return powmod(m, self.e, self.n)  # 使用powmod进行模幂运算，计算m^e mod n

    def leak1(self):  # 泄露方法1，返回p
        return self.p

    def leak2(self):  # 泄露方法2，返回p, q, dp, dq
        dp = self.d % (self.p-1)  # dp是d模(p-1)的结果
        dq = self.d % (self.q-1)  # dq是d模(q-1)的结果
        return [self.p, self.q, dp, dq]

    def leak3(self):  # 泄露方法3，这里为空，可能是一个未完成的挑战
        pass

# ————————————————Challenge 1—————————————————————
flag1 = FLAG[:22]  # 取出FLAG的前22个字符
m1 = bytes_to_long(flag1.encode())  # 将flag1转换为长整数
rsa1 = RSA(512)  # 创建RSA实例，密钥长度为512位

print("[e1, n1] =", rsa1.public_key())  # 打印公钥(e1, n1)
print("leak1 =", rsa1.leak1())  # 打印泄露的p
print("c1 =", rsa1.enRSA(m1))  # 打印加密后的密文c1

# ————————————————Challenge 2—————————————————————
flag2 = FLAG[22:51]  # 取出FLAG的第22到第51个字符
m2 = bytes_to_long(flag2.encode())  # 将flag2转换为长整数
rsa2 = RSA(512)  # 创建RSA实例，密钥长度为512位

print("n2 =", rsa2.n)  # 打印n2
print("leak2 =", rsa2.leak2())  # 打印泄露的p, q, dp, dq
print("c2 =", rsa2.enRSA(m2))  # 打印加密后的密文c2

# ————————————————Challenge 3—————————————————————
flag3 = FLAG[51:]  # 取出FLAG的第51个字符之后的所有字符
m3 = bytes_to_long(flag3.encode())  # 将flag3转换为长整数
rsa3 = RSA(512)  # 创建RSA实例，密钥长度为512位

with open("c3.txt", "wb") as f1:  # 打开c3.txt文件用于写入
    c3 = rsa3.enRSA(m3)  # 加密flag3
    f1.write(str(c3).encode())  # 将密文c3写入文件

from Crypto.PublicKey import RSA as Rsa  # 导入Crypto库中的RSA模块
privatekey = Rsa.construct((int(rsa3.n), int(rsa3.e), int(rsa3.d)))  # 构造私钥
with open("privatekey.pem", "wb") as f2:  # 打开privatekey.pem文件用于写入
    f2.write(privatekey.export_key())  # 将私钥写入文件
"""
[e1, n1] = (46273, 85149570318873397545858079769801747450955741032317421776005716419879307923817534832164193613680490496899198747179647303049788793083184220527271752037270640212143211363856115525127078383954331240479800951293505781103223095879326704698309211730316889311752593547645238748228385316179656229727884957804439714433)
leak1 = 7413041528546333282980158884011567786378341098195756764620523543522445167822444906245616440118927873532694017556517597552504089137267962327881211623910649
c1 = 13267682737577234072298553007761836634855872006599433939169643193561466175233974840639113280734923882117950741744086006704115327654248899370247329393426911960661758439351132110520234301214086149622313552075784324585591251100779472720617755754518453380506866507345906649371853362101067958543959589477359832247

n2 = 107432543854774092208431878829945220254955894061523452818503401934880376723719083865494636901829804000349390550621987535965024326245060638437408387820545121067125455197772014196337996260254603923779086314851633132222865524770331728927643576271180409572296351322961124161817399282622793992641205552512901071323
leak2 = [9130952141310948270813914839164548768194568221076998554877157061550874337219340405866020045264267400572908708681520831038764240705162325675508325496370633, 11765754785716114411402094537441078398751766315315841015319990653119612632885850920215985583783664765349992133722712384540945876398088342800629916671564931, 2150611543954114376160596068541532175024110741850690594652629552572010948026328847142866870433229491837400709829533880641963725606771342882840407682660465, 11652086611223823308288391092583038539185239072274349707821865541796029774877598391672886685755362725322755678146227617119790330212874965768632388400411553]
c2 = 36143891114726447171881668756030896181416980920172151819411883676429937142736099660788215446252699693685766715960803478123837069372557401384774091091748636542226732421801866559240400874059658572337841851913255119308146024808197979353538214455355578879556557165693355484549592722433455227214988918929425562270
"""

解析

挑战1：基础RSA加密

  • 目标：理解RSA加密的基础流程，并利用泄露的信息解密密文。
  • 解析：
    • RSA类生成了一个512位的RSA密钥对，包括公钥（e, n）和私钥（d）。
    • leak1方法泄露了私钥中的一个素数p，这是解密的关键信息。
    • 加密函数enRSA使用公钥加密了flag的前22个字符。
    • 解密步骤：
      1. 从leak1获取p。
      2. 使用公钥（e, n）和泄露的p，可以计算q（因为n = p * q）。
      3. 计算phi(n) = (p-1) * (q-1)。
      4. 计算私钥d，它是e模phi(n)的逆元。
      5. 使用私钥d解密密文c1。

挑战2：利用已知私钥分量解密

  • 目标：理解如何使用RSA的私钥分量解密密文。
  • 解析：
    • 与挑战1类似，RSA类生成了一个512位的RSA密钥对。
    • leak2方法泄露了私钥中的两个素数p和q，以及两个私钥分量dp和dq。
    • 加密函数enRSA使用公钥加密了flag的第22到第51个字符。
    • 解密步骤：
      1. 从leak2获取$p, q, dp, dq$。
      2. 使用dp和dq可以解密密文c2，因为RSA加密的密文可以通过分别计算(c^dp mod p)和(c^dq mod q)来解密。
      3. 使用中国剩余定理（CRT）合并这两个解密结果，得到原始明文。

挑战3：RSA私钥文件泄露

  • 目标：理解如何使用RSA私钥文件解密密文。
  • 解析：
    • RSA类生成了一个512位的RSA密钥对。
    • 加密函数enRSA使用公钥加密了flag的第51个字符之后的所有字符。
    • 私钥被导出为PEM格式的文件privatekey.pem。
    • 解密步骤：
      1. 读取privatekey.pem文件获取私钥。
      2. 使用私钥解密文件c3.txt中的密文c3。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
from Crypto.Util.number import *
from gmpy2 import *

[e1, n1] = (46273, 85149570318873397545858079769801747450955741032317421776005716419879307923817534832164193613680490496899198747179647303049788793083184220527271752037270640212143211363856115525127078383954331240479800951293505781103223095879326704698309211730316889311752593547645238748228385316179656229727884957804439714433)
leak1 = 7413041528546333282980158884011567786378341098195756764620523543522445167822444906245616440118927873532694017556517597552504089137267962327881211623910649
c1 = 13267682737577234072298553007761836634855872006599433939169643193561466175233974840639113280734923882117950741744086006704115327654248899370247329393426911960661758439351132110520234301214086149622313552075784324585591251100779472720617755754518453380506866507345906649371853362101067958543959589477359832247

n2 = 107432543854774092208431878829945220254955894061523452818503401934880376723719083865494636901829804000349390550621987535965024326245060638437408387820545121067125455197772014196337996260254603923779086314851633132222865524770331728927643576271180409572296351322961124161817399282622793992641205552512901071323
leak2 = [9130952141310948270813914839164548768194568221076998554877157061550874337219340405866020045264267400572908708681520831038764240705162325675508325496370633, 11765754785716114411402094537441078398751766315315841015319990653119612632885850920215985583783664765349992133722712384540945876398088342800629916671564931, 2150611543954114376160596068541532175024110741850690594652629552572010948026328847142866870433229491837400709829533880641963725606771342882840407682660465, 11652086611223823308288391092583038539185239072274349707821865541796029774877598391672886685755362725322755678146227617119790330212874965768632388400411553]
c2 = 36143891114726447171881668756030896181416980920172151819411883676429937142736099660788215446252699693685766715960803478123837069372557401384774091091748636542226732421801866559240400874059658572337841851913255119308146024808197979353538214455355578879556557165693355484549592722433455227214988918929425562270


# ————————————————————————————solve 1————————————————————————————————————
p1 = leak1
q1 = n1 // p1
phi1 = (p1 - 1) * (q1 - 1)
d1 = invert(e1, phi1)
m1 = pow(c1, d1, n1)
flag1 = long_to_bytes(m1).decode()
print(flag1)  # SeeUSec{Start_to_solve

# ————————————————————————————solve 2————————————————————————————————————
p2, q2, dp, dq = leak2
def rsa(dp_, dq_, p, q, c):
    M1 = pow(c, dp_, p)
    M2 = pow(c, dq_, q)
    p_q = invert(p, q)
    m = M1 + p_q * ((M2 - M1) % q) * p
    flag = long_to_bytes(m).decode()
    return flag


flag2 = rsa(dp, dq, p2, q2, c2)
print(flag2)  # _WoW_u_really_know_dp&dq_leak

# ————————————————————————————solve 3————————————————————————————————————
from Crypto.PublicKey import RSA

with open("c3.txt", "rb") as f1:
    c3 = int(f1.read().decode())

key = RSA.import_key(open("privatekey.pem", "rb").read())
e = key.e
n = key.n
d = key.d

m3 = pow(c3, d, n)
flag3 = long_to_bytes(m3).decode()
print(flag3)  # _&&_U_2_m@ster_0f_RSA!!!!!!!}

print(flag1 + flag2 + flag3)  # SeeUSec{Start_to_solve_WoW_u_really_know_dp&dq_leak_&&_U_2_m@ster_0f_RSA!!!!!!!}

FLAG

1
SeeUSec{Start_to_solve_WoW_u_really_know_dp&dq_leak_&&_U_2_m@ster_0f_RSA!!!!!!!}

你有装sagemath软件并配置好了吗？

中等

描述

1
2
贤者拿到了一个EXP，按道理来说用python运行一下就能出flag了，但她不认识这个EXP的后缀名
你能帮帮贤者吗

题目（带注释版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from Crypto.Util.number import *

[p0, p_leak] = [342786932597899774080278919233, 2180942305879083313385699688688649770575401960705813731167982873307515150902453812164540872752066006325334111444533180891136]
c = 24392936069556102540199862517997854393197282565478496250081102802183371142865451971064225168186026592356841946552737541277265864134925745973738533069500679861657429567572859664345004643629443253743567163595062976314779951347071882927361459802175502199147574036049243190969884473120604525821980294488378077910
[e, n] = [65537, 105652349991856297963642142108557236066399488308106611883979661581002804036935073512170546163478780443651826779340719652444565906473476781249870360455121578629563389144896951722671963720247303540893194705960514108348935180482952376603146943444037124147845426576841065365107576028356631911076185405777461236441]

p_low = p0 % 2**100 + p_leak

PR.<x> = PolynomialRing(Zmod(n))
f = x*2^412 + p_low
f = f.monic()
res = f.small_roots(2^100,0.49)
print(res)  



p = int(res[0]*2^412 + p_low)
q = n//p
phi = (p-1)*(q-1)
d = inverse(e, phi)
m = int(pow(c, d, n))
print(long_to_bytes(m).decode())  # SeeUSec{SageMath_is_very_helpful_for_learning_about_cryptography}

解析

按照题目描述安装软件并配置

网上能搜到相关sagemath软件安装的详细教程

然后还需要我们自己给sagemath装个pycryptodome库

FLAG

1
SeeUSec{SageMath_is_very_helpful_for_learning_about_cryptography}
主要涉及技术：
Crypto、Web
一位23级大学牲

联系QQ:2146983392

欢迎@我，交流闲聊，交换友链

技术只学到一些皮毛
谢谢师傅们的关照