CTF总结

CTF misc crypto re pyjail总结

MISC

常见文件16进制头尾

一些CTF题目标附件会去掉文件头，需要补全文件头，在一些文件里也可能隐藏多个文件，这就需要认识文件尾/文件头以方便提取或做判断，题目附件在下载的时间可能会没有文件后缀，无法判断是那种文件，由于各文件的16进制都有规定格式，在将文件在 010Editor 中打开后根据文件16进制头可以判断是哪一种文件，总之需要认识常见文件头以及格式，010里面有模板，方便识别各类文件，但也会有识别出错的情况，MISC题目千变万化...
PNG

文件头 89 50 4E 47 0D 0A 1A 0A
文件尾  AE 42 60 82
**JPEG **

文件头 FF D8 FF
文件尾 FF D9
GIF

**文件头 47 49 46 38 39(37) 61 **
文件尾 00 3B
BMP

文件头 42 4D
ZIP

文件头 50 4B 03 04
**文件尾 50 4B 01 02 / 50 4B 05 06 **
RAR Archive (rar)
文件头：52 61 72 21
Wave (wav)
文件头：57 41 56 45
其他16进制

TGA

未压缩的前4字节 00 00 02 00 RLE压缩的前5字节 00 00 10 00 00
TIFF (tif)

文件头：49 49 2A 00
ico
文件头：00 00 01 00
MS Word/Excel (xls.or.doc)
文件头：D0 CF 11 E0
MS Access (mdb) 文件头：
53 74 61 6E 64 61 72 64 20 4A
WordPerfect (wpd) 文件头：
FF 57 50 43
Adobe Acrobat (pdf) 文件头：
25 50 44 46 2D 31 2E
application/vnd.visio(vsd) 文件头：
D0 CF 11 E0 A1 B1 1A E1
Email [thorough only] (eml) 文件头：
44 65 6C 69 76 65 72 79 2D 64 61 74 65 3A
Outlook Express (dbx) 文件头：
CF AD 12 FE C5 FD 74 6F
Outlook (pst) 文件头：
21 42 44 4E
Rich Text Format (rtf) 文件头：
7B 5C 72 74 66
txt 文件(txt) 文件头：Unicode：FE FF / Unicode big endian：FF FE / UTF-8：EF BB BF /ANSI编码是没有文件头的
audio(Audio)
文件头： 4D 54 68 64
audio/x-aac（aac）
文件头：FF F1(9)
AVI (avi) 文件头：41 56 49 20
Real Audio (ram) 文件头：2E 72 61 FD
Real Media (rm) 文件头：2E 52 4D 46
MPEG (mpg) 文件头：00 00 01 BA(3)
Quicktime (mov) 文件头：6D 6F 6F 76
Windows Media (asf) 文件头：30 26 B2 75 8E 66 CF 11
MIDI (mid) 文件头：4D 54 68 64
XML (xml) 文件头：3C 3F 78 6D 6C
HTML (html) 文件头：68 74 6D 6C 3E
Quicken (qdf) 文件头：AC 9E BD 8F
Windows Password (pwl) 文件头：E3 82 85 96
windows证书文件(der) 文件头：30 82 03 C9
CAD (dwg) 文件头：41 43 31 30
Windows Shortcut (lnk) 文件头：4C 00 00 00
Windows reg(reg) 文件头：52 45 47 45 44 49 54 34
注：并非全部文件只收集常见，够用
隐写术

常用工具：

**16进制查看：010Editor  winhex **
音频查看：Audacity
等等
遇到举例
png：

起首先容一款好用的检测png隐写工具
zsteg：https://github.com/zed-0xff/zsteg
一些隐藏的文件，lsb隐写等都可以检测到
binwalk:
可以检测分离文件

1. #检测图片
2. binwalk filename
3. DECIMAL       HEXADECIMAL     DESCRIPTION
4. --------------------------------------------------------------------------------
5. 0             0x0             PNG image, 640 x 1743, 8-bit/color RGBA, non-interlaced
6. #分离图片
7. binwalk -e filename
8. (可能报错使用 binwlak -e filename --run-as=root)
9. #刀操作，也可以分离图片
10. dd if=filename of=newfilename skip=DECIMAL bs=1

复制代码

foremost:
同样可以分离文件，而且细分化，有log，有时间有奇效

1. foremost -o 存放文件名 文件名

复制代码

使用非常方便：

1. zsteg filename
2. 或
3. zsteg filename -a
4. 还有其他参数指令
5. zsteg -h

复制代码

宽高隐写：
png文件最常见的就是宽高隐写，通过修改宽高隐藏一些内容，这类图片肉眼一样平常无法判断，有的倒非常显着，可以通过修改宽高的16进制来实验规复，但有可能无法得到预期图片，可以通过工具或者crc爆破得到正确的宽高再修改文件的16进制得到原来的图片。
文件16进制中：
隐藏的信息可能存放在16进制文件尾，使用010打开在末尾处查看，也可能存放在文件中，使用搜索实验寻找
010功能强大
IDAT隐写：
pngcheck可以检测文件IDAT，粉碎，多余
文件IDAT通常中间的会保持一致再满了的时间才会举行下一个
此时就需要提取或者删除来达到规复的目标
里面通常会有zilb，也可能隐写在这里面
StegSolve：一款工具
png jpg gif都可以使用，检测图片lsb隐写，各颜色通道等
Data Extract：lsb隐写等
Frame Browser：gif帧分析
exiftool：
查看图片exif等信息，flag可能隐藏在这里
PNGdebugger/TweakPNG（png工具）：
均可查看png文件数据，支持修改删除等操作
stegpy：
带有key的隐写

1. stegpy filename -p

复制代码

png相干隐写暂时这么多
JPEG/JPG:

EXIF：
最常见的就是EXIF,备注，具体信息等，会有提示信息或者flag，
使用exiftool:

1. exiftool filename

复制代码

或在线：EXIF信息查看器 (tuchong.com)
文件16进制：
同png一样，也可能存放在末尾或者文件中。
文件提取：
存在附件文件，使用binwalk/foremost
JSteg&&JPHide&&OutGuess&&F5:
四个隐写方式
可以使用相应工具提取
Stegdetect 可以资助探测
SilentEye：
jpg或者wav文件隐写flag
一些非预期（strings filename）
音频隐写：

MP3/WAV：
使用Audacity查看波形图或者频谱图，一些信息会隐藏在上面，波形图的摩斯暗码，频谱图可能有key，pass，乃至flag等
MP3Stego：MP3隐写工具

1. encode -E txt -P 密码 MP3文件
2. decode -X -P 密码 MP3name

复制代码

这种一样平常会有pass提示在文件尾等
LSB:DerbyCon CTF - WAV Steganography · ethackal
deepsound:WAV工具
需要暗码
dtmf2num：拨号音
音频滴滴滴
MMSSTV：
一种电报，可以将音频转化为图片，音频多嘈杂
SilentEye：wav工具
xls：

文件可能存在隐写有二维码，手点检测块是否不同，将其黑白变化得到二维码，可以使用QR扫描得到flag
使用7z点开里面存在内容，这类欠好找可以使用步伐寻找等
word：

字体隐藏：ctrl+a修改全局字体得到隐藏内容，修改设置得到隐藏文字，修改后缀或使用7z打开得到里面的文件，可能存在flag等有用信息
pyc隐写：

使用剑龙隐写可以得到隐藏的flag

1. stegosaurus -x pycname

复制代码

CRYPTO

常见编码：

rabbit/aes/des加密：
U2FsdGVkX1通常为rabbit密文头，特征类似base64（aes ，des相似）
rabbit为一种流暗码，其详情高速流暗码——Rabbit - 掘金 (juejin.cn)
在线解密网：在线Rabbit加密 | Rabbit解密- 在线工具 (sojson.com)

1. 例子：
2. U2FsdGVkX188nKW3XYAppATn9y3lZg==  解密为：flag

复制代码

base家属：

(base64是每6bit位一个映射base32是每5bit位一个映射base16是每bit4位一个映射)
base64加密：（ 编码后的数据比原始数据略长，为原来的4/3）
密文结尾通常为，由(A-Z、a-z、0-9、+、/)组成，以为填充
加密原理：用64个可打印字符表现二进制全部数据的方法...(Base64 算法原理，以及编码、解码【加密、解密】 先容 - 程默 - 博客园 (cnblogs.com))

1. 例子：
2. ZmxhZ3tiYXNlfQ== 解密为：flag{base}

复制代码

在线解密网：Base64 编码/解码 - 在线工具 (toolhelper.cn)
base58加密：（在比特币加密中有涉及，区块链）
base58的编码表相比base64少了数字0，大写字母I，O，小写字母 l (这个是L），以及符号‘+’和‘/’
加密原理：将字符流转成256进制的一个超大数 然后不绝的模58

1. 例子：
2. 2w6zoHymm2SU4UfhE 解密为： flag{base58}

复制代码

在线解密网：在线Base58编码解码 (lddgo.net)
base32加密：
由（A-Z、2-7）32个可见字符构成，“=”符号用作后缀填充，无数字+/，会有多个=。

1. 例子：
2. MZWGCZ33MJQXGZJTGJ6Q====  解密为： flag{base32}

复制代码

在线解密网：Base32编码解码，Base32在线转换工具 - 千千秀字 (qqxiuzi.cn)
base16加密：
将二进制文件转换成由16个字符组成的文本，由a-z,0-9组成，无=填充,与md5，hex相似。

1. 例子：
2. 666c61677b6261736531367d  解密为：flag{base16}

复制代码

在线解密网：Base16编码解码，Base16在线转换工具 - 千千秀字 (qqxiuzi.cn)
除此之外还有
base62，base85，base91，base92，base100。
base91的密文由91个字符（0-9，a-z，A-Z,!#$%&()*+,./:;?@[]^_`{|}~”）组成
base100为表情包

<strong>base85为BOu!rDst>tGAhM (c1^s1*c2^s2)%n = ((m^e1%n)^s1%n*(m^e2%n)^s2%n)%n #(a * b) % p = (a % p * b % p) % p=> (c1^s1*c2^s2)%n = ((m^e1)^s1%n*(m^e2)^s2%n)%n #((a % p) ^ b) % p =a ^ b % p=> (c1^s1*c2^s2)%n = ((m^e1)^s1*(m^e2)^s2)%n # (a % p * b % p) % p=(a * b) % p=>(c1^s1*c2^s2)%n = ((m^(e1*s1)*(m^(e2*s2))%n #。幂的乘方，底数稳定，指数相乘。(c1^s1*c2^s2)%n = (m^(e1*s1+e2*s2))%n  # 同底数幂相乘，底数稳定，指数相加。因为 e1*s1+e2*s2 = 1 得：(c1^s1*c2^s2)%n = (m^1)%n(c1^s1*c2^s2）%n=m[/code]同一m，同一n,不同e，举行加密。在不知道d的情况下，可以举行解密
wiener(维纳)攻击脚本

1. from Crypto.Util.number import *
2. n = p * q
3. m = "flag"
4. m = bytes_to_long(m)
5. e = 65537
6. phi = (p-1)*(q-1)
7. d = inverse(e,phi)
8. c = pow(m,e,n)
9. m = pow(c,d,n)
10. flag = long_to_bytes(m)

复制代码

低加密指数广播攻击

1. def isqrt(n):
2.   x = n
3.   y = (x + n // x) // 2
4.   while y < x:
5.     x = y
6.     y = (x + n // x) // 2
7.   return x
9. def fermat(n, verbose=True):
10.     a = isqrt(n) # int(ceil(n**0.5))
11.     b2 = a*a - n
12.     b = isqrt(n) # int(b2**0.5)
13.     count = 0
14.     while b*b != b2:
15.         # if verbose:
16.         #     print('Trying: a=%s b2=%s b=%s' % (a, b2, b))
17.         a = a + 1
18.         b2 = a*a - n
19.         b = isqrt(b2) # int(b2**0.5)
20.         count += 1
21.     p=a+b
22.     q=a-b
23.     assert n == p * q
24.     # print('a=',a)
25.     # print('b=',b)
26.     # print('p=',p)
27.     # print('q=',q)
28.     # print('pq=',p*q)
29.     return p, q
30. fermat(n)

复制代码

解密脚本2

1. import gmpy2
2. import libnum
4. p=
5. q=
6. e=
7. c=
9. n=p*q
10. phi_n=(p-1)*(q-1)
12. #求逆元
13. #d=libnum.invmod(e,phi_n)
14. d=gmpy2.invert(e,phi_n)
16. m=pow(c,d,n)
17. print(m)
18. print(libnum.n2s(int(m)).decode())
19. 出题脚本
20. p,q接近，很快就能分解
21. import libnum
22. import gmpy2
24. p=libnum.generate_prime(1024)
25. #下一个素数
26. q=gmpy2.next_prime(p)
27. print(p)
28. print(q)
29. print(gmpy2.is_prime(q))
30. e=65537
31. m="flag{20d6e2da95dcc1fa5f5432a436c4be18}"
32. m=libnum.s2n(m)
33. n=p*q
34. phi_n=(p-1)*(q-1)
35. d=libnum.invmod(e,phi_n)
36. c=pow(m,e,n)
38. print("n=",n)
39. print ("e=",e)
40. print ("c=",c)

复制代码

N不互素（共享素数）

解题脚本

1. import  gmpy2
2. import libnum
4. def isqrt(n):
5.   x = n
6.   y = (x + n // x) // 2
7.   while y < x:
8.     x = y
9.     y = (x + n // x) // 2
10.   return x
12. def fermat(n, verbose=True):
13.     a = isqrt(n) # int(ceil(n**0.5))
14.     b2 = a*a - n
15.     b = isqrt(n) # int(b2**0.5)
16.     count = 0
17.     while b*b != b2:
19.         # if verbose:
21.         #     print('Trying: a=%s b2=%s b=%s' % (a, b2, b))
23.         a = a + 1
24.         b2 = a*a - n
25.         b = isqrt(b2) # int(b2**0.5)
26.         count += 1
27.     p=a+b
28.     q=a-b
29.     assert n == p * q
31.     # print('a=',a)
33.     # print('b=',b)
35.     print('p=',p)
36.     print('q=',q)
38.     # print('pq=',p*q)
40.     return p, q
41. n=
42. e= 65537
43. c=
44. pq=fermat(n)
45. p=pq[0]
46. q=pq[1]
47. phi_n=(p-1)*(q-1)
48. #求逆元
49. #d=libnum.invmod(e,phi_n)
50. d=gmpy2.invert(e,phi_n)
51. m=pow(c,d,n)
52. print(m)
53. print(libnum.n2s(int(m)).decode())

复制代码

dp泄漏

解密脚本

1. from Crypto.PublicKey import RSA
3. p=
4. q=
5. n=
6. d=
7. e= 65537
10. rsa_components = (n, e)
11. keypair = RSA.construct(rsa_components)
12. with open('pubckey.pem', 'wb') as f :
13.     f.write(keypair.exportKey())
14. from Crypto.PublicKey import RSA
16. p= 787228223375328491232514653709
17. q= 814212346998672554509751911073
18. n= 640970939378021470187479083920100737340912672709639557619757
19. d= 590103645243332826117029128695341159496883001869370080307201
20. e= 65537
23. rsa_components = (n,e,d,p,q)
24. keypair = RSA.construct(rsa_components)
25. with open('private1.pem', 'wb') as f :
26.     f.write(keypair.exportKey())
27. 公钥读取
28. from Crypto.PublicKey import RSA
29. with open("pubckey.pem","rb") as f:
30.     key = RSA.import_key(f.read())
31.     print('n = %d' % key.n)
32.     print('e = %d' % key.e)
33. 私钥读取
34. from Crypto.PublicKey import RSA
35. with open("private1.pem","rb") as f:
36.     key = RSA.import_key(f.read())
37.     print('n = %d' % key.n)
38.     print('e = %d' % key.e)
39.     print('d = %d' % key.d)
40.     print('p = %d' % key.p)
41.     print('q = %d' % key.q)
42. 出题脚本 -基于N分解的题目
43. import libnum
44. import gmpy2
45. from Crypto.PublicKey import RSA
47. p=libnum.generate_prime(1024)
48. #下一个素数
49. q=int(gmpy2.next_prime(p))
50. e=65537
51. m="flag{}"
52. m=libnum.s2n(m)
53. n=p*q
54. c=pow(m,e,n)
55. flag_c=libnum.n2s(c)
56. rsa_components = (n, e)
57. keypair = RSA.construct(rsa_components)
58. with open('pubckey1.pem', 'wb') as f :
59.     f.write(keypair.exportKey())
60. with open("flag.txt","wb") as f:
61.     f.write(flag_c)
64. 解题脚本
65. import libnum
66. import gmpy2
67. from Crypto.PublicKey import RSA
70. def isqrt(n):
71.   x = n
72.   y = (x + n // x) // 2
73.   while y < x:
74.     x = y
75.     y = (x + n // x) // 2
76.   return x
78. def fermat(n, verbose=True):
79.     a = isqrt(n) # int(ceil(n**0.5))
80.     b2 = a*a - n
81.     b = isqrt(n) # int(b2**0.5)
82.     count = 0
83.     while b*b != b2:
84.         # if verbose:
85.         #     print('Trying: a=%s b2=%s b=%s' % (a, b2, b))
86.         a = a + 1
87.         b2 = a*a - n
88.         b = isqrt(b2) # int(b2**0.5)
89.         count += 1
90.     p=a+b
91.     q=a-b
92.     assert n == p * q
93.     # print('a=',a)
94.     # print('b=',b)
95.     # print('p=',p)
96.     # print('q=',q)
97.     # print('pq=',p*q)
98.     return p, q
101. with open("pubckey1.pem","rb") as f:
102.     key = RSA.import_key(f.read())
103.     n=key.n
104.     e=key.e
106. with open("flag.txt","rb") as f:
107.     c=f.read()
108.     c=libnum.s2n(c)
110. #费马分解,
111. n1=fermat(n)
112. p=n1[0]
113. q=n1[1]
114. phi_n=(p-1)*(q-1)
115. #求逆元
116. d=libnum.invmod(e,phi_n)
117. m=pow(c,d,n)
118. print(m)
119. print(libnum.n2s(int(m)).decode())
121. 进阶——自动生成密钥及加解密
122. from Crypto.Cipher import PKCS1_v1_5
123. from Crypto import Random
124. from Crypto.PublicKey import RSA
125. from Crypto.Cipher import PKCS1_OAEP
128. random_generator = Random.new().read
129. rsa = RSA.generate(2048, random_generator)

复制代码

dp,dq

解题脚本

1. private_key = rsa.exportKey()
3. # print(private_key.decode('utf-8'))
5. with open('rsa_private_key.pem', 'wb')as f:
6.     f.write(private_key)

复制代码

n是p的r次方

解密脚本
先分解n

1. public_key = rsa.publickey().exportKey()
3. # print(public_key.decode('utf-8'))
5. with open('rsa_public_key.pem', 'wb')as f:
6.     f.write(public_key)
9. #测试用密钥加密
10. public_key = RSA.importKey(public_key)
11. msg='flag'
12. pk = PKCS1_v1_5.new(public_key)
13. encrypt_text = pk.encrypt(msg.encode())
14. print(encrypt_text)
16. #测试密钥解密
17. private_key = RSA.importKey(private_key)
18. pk = PKCS1_v1_5.new(private_key)
19. msg = pk.decrypt(encrypt_text,0)
20. print(msg)
22. #两种标准
23. rsa_components = (n, e, int(d), p, q)
24. arsa = RSA.construct(rsa_components)
25. rsakey = RSA.importKey(arsa.exportKey())
26. rsakey = PKCS1_OAEP.new(rsakey)
27. decrypted = rsakey.decrypt(c)
28. print(decrypted)

复制代码

RSA NC不互素

解题脚本

1. #coding:utf-8
2. import gmpy2
3. import libnum
5. n=
6. e1=
7. c1=
8. e2=
9. c2=
11. #共模攻击
12. #共模攻击函数
13. def rsa_gong_N_def(e1,e2,c1,c2,n):
14.     e1, e2, c1, c2, n=int(e1),int(e2),int(c1),int(c2),int(n)
15.     s = gmpy2.gcdext(e1, e2)
16.     s1 = s[1]
17.     s2 = s[2]
18.     if s1 < 0:
19.         s1 = - s1
20.         c1 = gmpy2.invert(c1, n)
21.     elif s2 < 0:
22.         s2 = - s2
23.         c2 = gmpy2.invert(c2, n)
24.     m = (pow(c1,s1,n) * pow(c2 ,s2 ,n)) % n
25.     return int(m)
26. m = rsa_gong_N_def(e1,e2,c1,c2,n)
27. print(m)
28. print(libnum.n2s(int(m)))

复制代码

sage脚本_p高位攻击

脚本1

1. c1 = pow(m, e1, n)
2. c2 = pow(m, e2, n)
3. e1，e2互质，则有
5. gcd(e1,e2)=1
6. 根据扩展欧几里德算法 对于不完全为 0 的整数 a，b，gcd（a，b）表示 a，b 的最大公约数。那么一定存在整数 x，y 使得 gcd（a，b）=ax+by
8. e1*s1+e2*s2 = 1
9. s1、s2皆为整数，但是一正一负，假设s1为正数,s2为负数
11. 因为
13. c1 = m^e1%n
14. c2 = m^e2%n
15. 可得：
17. (c1^s1*c2^s2)%n = ((m^e1%n)^s1(m^e2%n)^s2)%n
18. 根据模运算性质： 幂运算是一种关于幂的数学运算。同底数幂相乘，底数不变，指数相加。同底数幂相除，底数不变，指数相减。幂的乘方，底数不变，指数相乘。
20. (a * b) % p = (a % p * b % p) % p
21. a ^ b % p = ((a % p) ^ b) % p

复制代码

sage脚本_维纳变形（三素数pqr）

这一段代码求d

1. (c1^s1*c2^s2)%n = ((m^e1%n)^s1*(m^e2%n)^s2)%n
3. => (c1^s1*c2^s2)%n = ((m^e1%n)^s1%n*(m^e2%n)^s2%n)%n #(a * b) % p = (a % p * b % p) % p
5. => (c1^s1*c2^s2)%n = ((m^e1)^s1%n*(m^e2)^s2%n)%n #((a % p) ^ b) % p =a ^ b % p
7. => (c1^s1*c2^s2)%n = ((m^e1)^s1*(m^e2)^s2)%n # (a % p * b % p) % p=(a * b) % p
9. =>(c1^s1*c2^s2)%n = ((m^(e1*s1)*(m^(e2*s2))%n #。幂的乘方，底数不变，指数相乘。
11. (c1^s1*c2^s2)%n = (m^(e1*s1+e2*s2))%n  # 同底数幂相乘，底数不变，指数相加。
12. 因为 e1*s1+e2*s2 = 1 得：
14. (c1^s1*c2^s2)%n = (m^1)%n
16. (c1^s1*c2^s2）%n=m

复制代码

PEM证书格式

from Crypto.Util.number import *
q = 0x00befff9907f75bb7ad561131b5c76ae137bd67ae0e32b90f92b997b044277cab3dfeb84f255138127e1a4e53751a68db743a00ed8acc58f33107fe35db6b4813bc048db48bd530bcb35fba434dbb70e27d78aede2de0d4745df35a245417b8c74a31a7b55a77db45ebd6ed1dc4b3dcaa435a79dbf7240d96775372e64b58b0803
dq = 0x1c1005fdea0c454075eb6e603dc49e2cf4abfd9fdf20be8b2d91be5650e1c2e18ccbd0dbbe0e4092b87f7ec212f812a8538247cc240e5eccd4e6c564367cece3f78b7cd482249a7dffef7a1fde0c56431a532a4283f7957a39a26ab61c39e7d81742c3ce40eea23aad40840b06ef0c3ff6362b623e8a32a715bcc6cf3b31333b
c = 2329206064672111950904450292941421573350591294207157652026787098178545948258554492347649016030892000747909819064473414536692222493030122267884839986067073054508582403564557167583565364976046083954888777809177108315052118912603290095925912298584322873410379937455462434313487981715516761071523410121549134193124709612876311518391130974466069686830456036397449773159386026998482557500868323733155606973727191287617806211911722356975478414165867941665666556476756617951672736466672410799762479373101996896644454778482896784598378016390592459460753042458284030795009957030383305268628413551730442224404807955926606496353
m = pow(c, dq, q)
print(long_to_bytes(m))

1. 解密脚本
2. import gmpy2
3. import libnum
5. def continuedFra(x, y):
6.     """计算连分数
7.     :param x: 分子
8.     :param y: 分母
9.     :return: 连分数列表
10.     """
11.     cf = []
12.     while y:
13.         cf.append(x // y)
14.         x, y = y, x % y
15.     return cf
16. def gradualFra(cf):
17.     """计算传入列表最后的渐进分数
18.     :param cf: 连分数列表
19.     :return: 该列表最后的渐近分数
20.     """
21.     numerator = 0
22.     denominator = 1
23.     for x in cf[::-1]:
24.         # 这里的渐进分数分子分母要分开
25.         numerator, denominator = denominator, x * denominator + numerator
26.     return numerator, denominator
27. def solve_pq(a, b, c):
28.     """使用韦达定理解出pq，x^2−(p+q)∗x+pq=0
29.     :param a:x^2的系数
30.     :param b:x的系数
31.     :param c:pq
32.     :return:p，q
33.     """
34.     par = gmpy2.isqrt(b * b - 4 * a * c)
35.     return (-b + par) // (2 * a), (-b - par) // (2 * a)
36. def getGradualFra(cf):
37.     """计算列表所有的渐近分数
38.     :param cf: 连分数列表
39.     :return: 该列表所有的渐近分数
40.     """
41.     gf = []
42.     for i in range(1, len(cf) + 1):
43.         gf.append(gradualFra(cf[:i]))
44.     return gf
47. def wienerAttack(e, n):
48.     """
49.     :param e:
50.     :param n:
51.     :return: 私钥d
52.     """
53.     cf = continuedFra(e, n)
54.     gf = getGradualFra(cf)
55.     for d, k in gf:
56.         if k == 0: continue
57.         if (e * d - 1) % k != 0:
58.             continue
59.         phi = (e * d - 1) // k
60.         p, q = solve_pq(1, n - phi + 1, n)
61.         if p * q == n:
62.             return d
65. n=
66. e=
67. c=
69. d=wienerAttack(e, n)
70. m=pow(c, d, n)
71. print(libnum.n2s(m).decode())

复制代码

Standard commands
asn1parse         ca                ciphers           cms
crl               crl2pkcs7         dgst              dhparam
dsa               dsaparam          ec                ecparam
enc               engine            errstr            gendsa
genpkey           genrsa            help              list
nseq              ocsp              passwd            pkcs12
pkcs7             pkcs8             pkey              pkeyparam
pkeyutl           prime             rand              rehash
req               rsa               rsautl            s_client
s_server          s_time            sess_id           smime
speed             spkac             srp               storeutl
cast-cbc          cast5-cbc         cast5-cfb         cast5-ecb
cast5-ofb         des               des-cbc           des-cfb
des-ecb           des-ede           des-ede-cbc       des-ede-cfb
des-ede-ofb       des-ede3          des-ede3-cbc      des-ede3-cfb
des-ede3-ofb      des-ofb           des3              desx
idea              idea-cbc          idea-cfb          idea-ecb
idea-ofb          rc2               rc2-40-cbc        rc2-64-cbc
rc2-cbc           rc2-cfb           rc2-ecb           rc2-ofb
rc4               rc4-40            seed              seed-cbc
seed-cfb          seed-ecb          seed-ofb          sm4-cbc
sm4-cfb           sm4-ctr           sm4-ecb           sm4-ofb

1. import libnum
2. from gmpy2 import invert, gcd, iroot
4. def op(x):
5.     res = 1
6.     for i in x:
7.         res *= i
8.     return res
10. def CRT(m, a):
11.     assert (len(m) == len(a))
12.     M = op(m)
13.     sum = 0
14.     for m, a in zip(m, a):
15.         Mi = M // m
16.         ti = invert(Mi, m)
17.         sum += a * ti * Mi
18.     return sum % M
19. def GCRT(m, a):
20.     assert (len(m) == len(a))
21.     curm, cura = m[0], a[0]
22.     for m, a in zip(m[1:], a[1:]):
23.         d = gcd(curm, m)
24.         c = a - cura
25.         assert (c % d == 0)
26.         K = c // d * invert(curm // d, m // d)
27.         cura += curm * K
28.         curm = curm * m // d
29.     return cura % curm
31. e= 23
32. n= [, , , , , , ]
33. c= [, , , , , , ]
35. m = CRT(n, c)
36. m1 = iroot(m, e)  # 开e次方
37. print(m1)
38. print(libnum.n2s(int(m1[0])))

复制代码

Usage: rsa [options]
Valid options are:
-help              Display this summary  查看资助
-inform format     Input format, one of DER PEM  指定输入格式
-outform format    Output format, one of DER PEM PVK  指定输出格式
-in val            Input file  输入文件
-out outfile       Output file  输出文件
-pubin             Expect a public key in input file  盼望输入时一个公钥
-pubout            Output a public key  输出公钥文件
-passout val       Output file pass phrase source  给输出文件设置暗码
-passin val        Input file pass phrase source  输入文件的暗码
-RSAPublicKey_in   Input is an RSAPublicKey  指定输入是一个RSA公钥
-RSAPublicKey_out  Output is an RSAPublicKey  指定输出是一个RSA公钥
-noout             Don't print key out  不要打印输入的密钥内容
-text              Print the key in text  用文本格式打印密钥内容
-modulus           Print the RSA key modulus  打印RSA密钥的模数
-check             Verify key consistency   检测密钥是否一致
-*                 Any supported cipher  其他参数
-pvk-strong        Enable 'Strong' PVK encoding level (default)  启用“强”PVK编码级别（默认）
-pvk-weak          Enable 'Weak' PVK encoding level  启用“弱”PVK编码级别
-pvk-none          Don't enforce PVK encoding  不强制执行PVK编码
-engine val        Use engine, possibly a hardware device  指定解析引擎

1. import binascii,gmpy2
2. from functools import reduce
4. import libnum
7. def CRT(mi, ai):
8.     assert(reduce(gmpy2.gcd,mi)==1)
9.     assert (isinstance(mi, list) and isinstance(ai, list))
10.     M = reduce(lambda x, y: x * y, mi)
11.     ai_ti_Mi = [a * (M // m) * gmpy2.invert(M // m, m) for (m, a) in zip(mi, ai)]
12.     return reduce(lambda x, y: x + y, ai_ti_Mi) % M
14. e= 23
15. n= [, , , , , , ]
16. c= [, , , , , , ]
18. m=gmpy2.iroot(CRT(n, c), e)[0]
19. print(m)
20. print(libnum.n2s(int(m)))

复制代码

openssl rsa -in key.pem -inform PEM

1. import libnum
2. import gmpy2
5. e= 65537
6. n1=
7. n2=
8. c1=
9. c2=
12. #求最大公约数
13. q=gmpy2.gcd(n1,n2)
14. p1=n1//q
16. phi_n=(q-1)*(p1-1)
17. #求逆元d
18. d1=libnum.invmod(e,phi_n)
19. m=pow(c1,d1,n1)
20. print(m)
21. #数字转字节，转字符串
22. print(libnum.n2s(int(m)).decode())

复制代码

openssl rsa -in key.pem -inform PEM -text

1. #coding:utf-8
2. import libnum
3. import gmpy2
5. n=
6. e= 65537
7. dp=
8. c=
10. for i in range(1,65535):
11.     p=(dp*e-1)//i+1
12.     if n%p==0:
13.         q=n//p
14.         break
15. print(p)
16. print(q)
17. phi_n= (p-1)*(q-1)
18. d=gmpy2.invert(e,phi_n)
19. m=pow(c,d,n)
20. print(m)
21. flag=libnum.n2s(int(m)).decode()
22. print(flag)

复制代码

RSA Private-Key: (1023 bit, 2 primes)
modulus:
70:64:78:79:fa:43:ae:e8:a5:d3:78:57:54:b7:98:
8d:12:b1:4b:98:cf:39:be:21:b5:d9:0f:3e:32:64:
e3:16:cf:99:c3:05:8b:89:48:0f:2b:46:a0:ed:a9:
be:e6:b4:d7:53:19:96:71:ef:17:ba:b4:ec:25:7a:
ab:e4:5e:7e:b6:f6:68:14:65:97:a0:c9:a0:5d:05:
23:e7:51:1e:88:52:a7:6e:aa:92:e8:1d:16:af:ac:
7a:f5:22:42:3a:a0:09:83:11:0c:e2:d6:50:99:d3:
7c:74:8c:c2:ae:a0:e2:a9:f4:b0:61:3f:d8:a3:0a:
8c:bd:89:18:7d:b4:7f:85
publicExponent: 65537 (0x10001)
privateExponent:
2f:2e:7e:44:f6:82:a3:52:97:0a:87:62:61:f6:10:
dc:68:14:75:9f:d8:9e:6c:ea:c9:e4:2d:39:f6:fd:
d3:37:28:3f:6c:57:4f:94:79:e3:a4:4f:2a:0f:9b:
4a:c0:9e:fa:25:b0:80:2f:a4:27:5a:01:c9:80:92:
56:c6:af:c4:03:2f:fd:48:6f:9e:02:96:81:a3
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。