优秀的人，不是不合群，而是他们合群的人里面没有你

古典密码我放在这里

http://106.14.63.154/CTF-%E8%A7%A3%E5%AF%86%E5%B8%B8%E7%94%A8%E7%BD%91%E5%9D%80%E9%9B%86%E5%90%88.html

现代加密

对称加密：（AES、DES）相对于与非对称加密而言，加密、解密用的密匙想同，就像日常生活中的钥匙，开门和锁门都是同一把。

非对称加密：（RSA）相对于上述的对称加密而言，加密、解密用的密匙不同，有公匙和私匙之分。

散列算法：md5，sha1这种

RSA字母意义

在密码学中，‌特别是在RSA算法中，‌n, p, e, 和 c 分别代表以下概念：‌

n：‌模数。其中n=p*q，‌这个值是公钥和私钥共同的一部分，‌用于计算。‌

‌
p 和 q ：n的两个因子

‌
e：‌公钥的一部分，‌用于加密数据。
‌
d：‌私钥的一部分，‌用于解密数据。‌

m：明文，原文文件。

‌
c：‌密文，加密后的文件。

‌
{N,e}称为公钥,{N,d}称为私钥

RSA加密原理

ras有公钥和私钥啦，他的基础是将两个大的质数相乘，然后用因式分解后的两个数作为密钥来加密。

ras主要涉及三个参数，ned，其中nd是私钥，ne是公钥。一般公钥加密，私钥解密。那么解密需要解出来私钥。

一般来说，ne也就是公钥，是公开的，但是n一般是两个很大（几千位）的大质数的乘积，很难解出来d。

密钥生成步骤

随机选择两个不相同的质数q和p

如61和53。（质数越大越安全。）

计算出p和q的乘积，也就是n(把n转换成二进制数据，二进制长度就是密钥的长度，一般选择1024位或者2048位)

n = 61×53 = 3233
代码 n=p*q
3233写成二进制是110010100001，一共有12位，所以这个密钥就是12位。
计算n的欧拉函数【对于任意正整数N，把少于或等于N ([1,N])，且与N互质的正整数(包括1)的个数，称作对N的欧拉函数，记作φ(n)。注：互质为两者没有除1外的公因数】

根据公式：
　　φ(n) = (p-1)(q-1)
    代码：phi = (p-1)(q-1)
算出φ(3233)等于60×52，即3120。

随机选择一个整数e，其中φ(n)>e>1，并且e与φ(n)互为质数（实际中e一般选择65537）

在1到3120之间，随机选择了17
计算e对于φ(n)和模反元素d

所谓”模反元素”就是指有一个整数d，可以使得ed被φ(n)除的余数为1。
　　ed ≡ 1 (mod φ(n))
这个式子等价于
　　ed - 1 = kφ(n)
于是，找到模反元素d，实质上就是对下面这个二元一次方程求解。
　　ex + φ(n)y = 1
已知 e=17, φ(n)=3120，
　　17x + 3120y = 1

解答得出x=-367 y=2

代码：d = gmpy2.invert(e,phi)

公钥一般提供的是（n，e），自己要算的是（n，d）
解密过程：m = c**d mod n,那么解密需要知道c，d，n

代码：m = pow(c,d,n)

分解n

分解n，使用在线网址http://www.factordb.com/

或者用yafu

打开yafu文件夹，在文件夹内右键打开cmd

然后用以下办法来分解n

纯输入方法

./yafu-x64.exe "factor(1455925529734358105461406532259911790807347616464991065301847)"

大整数装进txt里方法（记得在txt里面复制粘贴完数字后回车）

./yafu-x64.exe "factor(@)" -batchfile data.txt

例题演示

话不多说，直接上个经典题型吧

    ------ enc -------
DTlEiAKLE24m19es4TBWl4Uo2MvmQMEYqWBCFggWJlJSjCwl3fT9322ytgudiQW2raDh53e6t2ed
ygpFOP+MsAPXlU469rlmVng5JyDl0CF0ypevnaM5i+CvNT2mBoDadIYnPBVGMtj9HVVPDpMIgv5b
F9N5ddQS7JB21oDdQBdDLTkKvcSqegtjNFv04R8+yrqOMZYpzdCRRw0j/MMt2JefC6z36mjrTL85
A9EKlwKg5ydW7qELycfjBvzB/cwJ7mJ2I0xVPToa3sSLNDyddFttATwU6wmCa4XaWpTwVR/PfET2
FRj0p+8UwYSDdlLLh6gRUVURpT+2jc9zx/rhOw==

这个应该是私钥，看着base64加密过的，只能用python进行解密，用别的咳嗽

pk = (25572000680139535995611501720832880791477922165939342981900803052781801299380515116746468338767634903543966903733806796606602206278399959935132433794098659859300196212479681357625729637405673432324426686371817007872620401911782200407165085213561959188129407530503934445657941975876616947807157374921539755157591354073652053446791467492853468641331291383821277151309959102082454909164831353055082841581194955483740168677333571647148118920605752176786316535817860771644086331929655259439187676703604894258185651165017526744816185992824404330229600417035596255176459265305168198215607187593109533971751842888237880624087,65537)

开始解答啦~~

这就是 公钥 n 和 e

第一步分解n，使用在线网址http://www.factordb.com/index.php

输入进去，直接得到两个值，这两个值长度一样
p = 149930380465516707151079321019435489399072155945793735032334088844599773034021170995501688132861944516938448679935403246643441984203770825485165700862168437691254557323938150173733659070945061763789341407547559935070758242521126066900261360899379463301621378242061934281538210192731229473900396425739817670867

q = 170559166199281256887953076784727902849936084815549184550874370897326056825177365209113910954088389779180174518262922176726833811470419181874717574929460298509184863124213663255559781224744696195678069242025195218017449489985102637547369070225979448169459840545693721393354651993457943927480894225788038743661


第二部计算欧拉函数phi

n = p*q
phi = (p-1)*(q-1)
e = 65537

第三部计算d

d = gmpy2.invert(e,phi)


第四部处理c


解码

enc=base64.b64decode(enc)

结果是bytes类型，没法直接运算，要转换一下，这个可以把bytes类型转长整形

from crypto.Util.number import *

enc = bytes_to_long(enc)

这就是私钥

第五步揭秘

m = pow(c,d,n)

这个结果是计算结束了，但是还是长整形，需要转换成bytes类型，那就再转换一下

m = long_to_bytes(m)

正经的脚本：

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

p = 149930380465516707151079321019435489399072155945793735032334088844599773034021170995501688132861944516938448679935403246643441984203770825485165700862168437691254557323938150173733659070945061763789341407547559935070758242521126066900261360899379463301621378242061934281538210192731229473900396425739817670867

q = 170559166199281256887953076784727902849936084815549184550874370897326056825177365209113910954088389779180174518262922176726833811470419181874717574929460298509184863124213663255559781224744696195678069242025195218017449489985102637547369070225979448169459840545693721393354651993457943927480894225788038743661

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

e = 65537
n = p*q
d = gmpy2.invert(e,phi)

c = '''
DTlEiAKLE24m19es4TBWl4Uo2MvmQMEYqWBCFggWJlJSjCwl3fT9322ytgudiQW2raDh53e6t2ed
ygpFOP+MsAPXlU469rlmVng5JyDl0CF0ypevnaM5i+CvNT2mBoDadIYnPBVGMtj9HVVPDpMIgv5b
F9N5ddQS7JB21oDdQBdDLTkKvcSqegtjNFv04R8+yrqOMZYpzdCRRw0j/MMt2JefC6z36mjrTL85
A9EKlwKg5ydW7qELycfjBvzB/cwJ7mJ2I0xVPToa3sSLNDyddFttATwU6wmCa4XaWpTwVR/PfET2
FRj0p+8UwYSDdlLLh6gRUVURpT+2jc9zx/rhOw==
'''
c = base64.b64decode(c)
#print(c)
c = bytes_to_long(c)
m = pow(c,d,n)
print(m)
m = long_to_bytes(m)
print(m)

https://www.cnblogs.com/chenjiaxuan/p/15885305.html

第二种题目类型就是文件格式的，公钥密文格式都是文件格式，长的这丫样子~~~

解题思路如下：

    -----BEGIN PUBLIC KEY-----
这种开头的就是公钥文件，如果是文件，使用如下命令

提取公钥中的数据。kali下使用命令

openssl rsa -pubin -text -modulus -in pub.key
# pub.key是公钥

在kali下 openssl rsa -pubin -text -modulus -in pub.key > 1.txt保存到文本

数据是这样子

读取文件的内容

然后Exponent的值就是e
然后Modulus的值就是公钥里面的n的十六进制的结果，可以转换成十进制，然后再网站进行分解

e = 31337

n = 119514949101869418903318873112867362646835071069241106524305309393065463453656568774743760570131693630159578791023971219610889380592598543536351234572467281587006324435481617535146537233169791976943380665697114009764947413190424965605151568078201516319476934559728328089096265594820785319942352507655193149106742096711100954500911687865197173709176323170965183162767042434738106978751911965481346436431672573623281881734153294758147557422163198312359915688282919868328721978258906227136067834058632472297370857579705187167410321575782375360591482072103305682978126915060591553714123014075758332542543138964874724542072396937584280625337262888775332970921021304750133076287918708895881009630077473404974677880966925170111450054682589858406625668247502091263399827525224215993035344424566568011928443888310172591327112851125472052921219080258671669993973898127049957265386657286586085405099815473365810806674154776699651214819118383817272562813199977233417411126959716068072338393084310289588450441128514416597910759814182527294940228828417785903441042114817369303389645545333054503129561885740632378715731405799144085706505382819066670726261358910837171602305916072912729756717338147737273166145500948558122541808933901885205278570148809

分解
p = 345709341936068338730678003778405323582109317075021198605451259081268526297654818935837545259489748700537817158904946124698593212156185601832821337576558516676594811692389205842412600462658083813048872307642872332289082295535733483056820073388473845450507806559178316793666044371642249466611007764799781626418800031166072773475575269610775901034485376573476373962417949231752698909821646794161147858557311852386822684705642251949742285300552861190676326816587042282505137369676427345123087656274137257931639760324708350318503061363031086796994100943084772281097123781070811610760735943618425858558459014484742232018933

q = 345709341936068338730678003778405323582109317075021198605451259081268526297654818935837545259489748700537817158904946124698593212156185601832821337576558516676594811692389205842412600462658083813048872307642872332289082295535733483056820073388473845450507806559178316793666044371642249466611007764799781626418800031166072773475575269610775901034485376573476373962417949231752698909821646794161147858557311852386822684705642251949742285300552861190676326816587042282505137369676427345123087656274137257931639760324708350318503061363031086796994100943084772281097123781070811610760735943618425858558459014484742232019973
第三布根据已知条件计算私钥的n

n = pq
phi = (p-1)(q-1)
d = gmpy2.invert(e,phi)

4 或者用脚本rsatool.py

python rsatool.py -p 345709341936068338730678003778405323582109317075021198605451259081268526297654818935837545259489748700537817158904946124698593212156185601832821337576558516676594811692389205842412600462658083813048872307642872332289082295535733483056820073388473845450507806559178316793666044371642249466611007764799781626418800031166072773475575269610775901034485376573476373962417949231752698909821646794161147858557311852386822684705642251949742285300552861190676326816587042282505137369676427345123087656274137257931639760324708350318503061363031086796994100943084772281097123781070811610760735943618425858558459014484742232018933 -q 345709341936068338730678003778405323582109317075021198605451259081268526297654818935837545259489748700537817158904946124698593212156185601832821337576558516676594811692389205842412600462658083813048872307642872332289082295535733483056820073388473845450507806559178316793666044371642249466611007764799781626418800031166072773475575269610775901034485376573476373962417949231752698909821646794161147858557311852386822684705642251949742285300552861190676326816587042282505137369676427345123087656274137257931639760324708350318503061363031086796994100943084772281097123781070811610760735943618425858558459014484742232019973 -e 31337 -f PEM -o pri.pem

这样就直接生成了私钥的文件，还需要密文

然后用openssl解密，kali下使用命令

openssl rsautl -decrypt -in des.enc -inkey pri.pem -out xx.txt

RSA-Tool 2 by 使用方法

首先要知道这个工具能完成哪些运算

全数字用10进制,否则用16进制
e是默认16进制,如果要用10进制需要转换一下

https://tool.oschina.net/hexconvert/

上面选10进制,下面选16进制,正常情况17–>11;23—>17

若条件给了N，点击Factor N可转成素数p,q
若条件给了p和q就能转成N,点击Cale.D自动生成N，D

用一个案例演示一下就好了

已知一段 RSA 加密的信息为：0xdc2eeeb2782c 且已知加密所用的公钥：
(N=322831561921859 e = 23)请解密出明文，提交时请将数字转化为 ascii 码提交。
RSATool2，已知c，n，e求m

图中的 P、Q、R、D、E 分别就是 RSA 算法中的 p、q、N、d、e，右上角选择进制，注意不要弄错，e 只有十六进制可用，所以这里把 23 换成 17。
(如果给出的全部是数字就选用16进制，如果给出的是含有数字和字母的就选用16进制)

将N=322831561921859

左下角有一个 Factor N 的按钮，这是分解 N 的意思，点一下，会自动开始分解因数，得到 P=13574881、Q=23781539

再点一下 Calc. D，计算出d=42108459725927，这时可以看到 Test 按钮不再是灰色，表明可以使用简单的加解密功能，点它，弹出一个框

密文 0xdc2eeeb2782c，换算十进制 242094131279916，在密文框输入这个值
点 Decrypt，直接得到字符串 3a5Y

总结

1，看给的条件情况，若全是数字就是十进制，有字母试试十六进制
2，此工具的e需转成十六进制

若条件给了N，点击Factor N可转成素数p,q
因为n=p*q,所以有了p和q就能转成N,点击Cale.D自动生成N，D
最后点击test进行测试

数字转成字符串

使用代码

from Crypto.Util.number import *
print(long_to_bytes('456463216854648764352164316854651658446'))

python对称加密代码解读

案例1

先学一个基础知识，在Python中，^操作符是按位异或操作符。它用于对两个整数进行按位异或运算，即对两个整数的二进制表示进行逐位比较，如果相应位上的值不同，则结果为1，否则为0。

例如，假设有两个整数a和b，它们的二进制表示分别为a_bin和b_bin。那么a ^ b的结果将是一个新的整数，其二进制表示为a_bin ^ b_bin。

如果 a^b=c
那么 b = a^c
那么 a = b^c

举个例子：

from os import urandom
from secret import flag
key = urandom(1)

def xor(plaintext, key):
    ret = []
    for i in range(len(plaintext)):
        ret.append(plaintext[i] ^ key[0])
    return bytes(ret)

ciphertext = xor(flag, key)

print(ciphertext.hex())
# 9b919c9a8685cd8fa294c8a28c88cc89cea2ce9c878480

解答,又有常识，明文开头是flag{xxxxxxxx

# coding:utf-8
hex_value = "9b919c9a8685cd8fa294c8a28c88cc89cea2ce9c878480"
binary_value =  bytes.fromhex(hex_value)
key = (binary_value[0])^ord('f')
print(key)
flags = ''
for x in binary_value:
    flags+=chr(x^key)
print(flags)

下面是一个简单的示例：

a = 5  # 二进制表示为 0101
b = 3  # 二进制表示为 0011

result = a ^ b  # 二进制表示为 0110，即6

print(result)  # 输出 6

发现一段代码

import base64
def encode():
    flag = '*************'  # 这就是我们要逆向求出来的结果
    ciphertext = []   # 这个值在下面
    for i in range(len(flag)):  # 根据flag值的长度，输出
        s = chr(i ^ ord(flag[i]))
        # 这一段有点拗口，flag第一个值，转换成ascii的值纯数字，与i异或算法，得出来的结果使用chr转换成字母
        # 源关于^这个功能，我在上面介绍
        if i % 2 == 0:
            # 如果循环迭代到双数位置
            s = ord(s) + 10
            # s的结果+10
        else:
            s = ord(s) - 10
        ciphertext.append(str(s))
    return ciphertext[::-1]
    # 将结果倒置一下
ciphertext = [
'96', '65', '93', '123', '91', '97', '22', '93', '70', '102', '94', '132', '46', '112',
'64', '97', '88', '80', '82', '137', '90', '109', '99', '112']

结题代码一下就出来了

res=(ciphertext[::-1]) # 把正确结果调到正确
real = []  # 用来保存修改后的值
for i in range(len(res)):
    z = ''
    # 临时设置一个值，保存矫正的正确数字
    if i%2 ==0:
        z = (int(res[i])-10)
        # 同上逆向矫正
        z = chr(i^z)
        # 然后直接^运算
    else:
        z = (int(res[i]) + 10)
        z = chr(i ^ z)
    real.append(z)
print(''.join(real))

解题思路

rsatools

知道知道p和q，就能求出n
知道p和q和e，就能求出n和d
只要知道n，就能求出q和p

python脚本

知道p，q，e，c求m

用gmpy2库求解

from Crypto.Util.number import *

from gmpy2 import*

p=447685307 
q=2037
e=17
c=704796792
n=p*q
phi = (p-1)*(q-1)
d=inverse(e,phi)
m=pow(c,d,n)

print(m)

结题笔记

我找到一个整合很到位的网址：

https://blog.csdn.net/m0_74345946/article/details/131192056

就看这个就够了~~

c,n,e求m

已知一段 RSA 加密的信息为：0xdc2eeeb2782c 且已知加密所用的公钥：
(N=322831561921859 e = 23)请解密出明文，提交时请将数字转化为 ascii 码提交。
RSATool2



1. 图中的 P、Q、R、D、E 分别就是 RSA 算法中的 p、q、N、d、e，右上角选择进制，注意不要弄错，e 只有十六进制可用，所以这里把 23 换成 17。
(如果给出的全部是数字就选用16进制，如果给出的是含有数字和字母的就选用16进制)



2.将N=322831561921859 



3. 左下角有一个 Factor N 的按钮，这是分解 N 的意思，点一下，会自动开始分解因数，得到 P=13574881、Q=23781539



4. 再点一下 Calc. D，计算出d=42108459725927，这时可以看到 Test 按钮不再是灰色，表明可以使用简单的加解密功能，点它，弹出一个框


5. 密文 0xdc2eeeb2782c，换算十进制 242094131279916，在密文框输入这个值

6. 点 Decrypt，直接得到字符串 3a5Y

p,q,e求d

RSA 在一次RSA密钥对生成中， 假设 p=473398607161， q=4511491， e=17 求解出d



p = 9648423029010515676590551740010426534945737639235739800643989352039852507298491399561035009163427050370107570733633350911691280297777160200625281665378483 q = 11874843837980297032092405848653656852760910154543380907650040190704283358909208578251063047732443992230647903887510065547947313543299303261986053486569407 e = 65537 c = 83208298995174604174773590298203639360540024871256126892889661345742403314929861939100492666605647316646576486526217457006376842280869728581726746401583705899941768214138742259689334840735633553053887641847651173776251820293087212885670180367406807406765923638973161375817392737747832762751690104423869019034




使用方法


给出p=3,q=5,点击Calc.D即可自动算出N和D的值，如果已知N的值，点击Generate即可拿到P和Q的值，再点击test即可进行加密解密操作。

c,n,pq,qp,e求m

# coding:utf-8
from Crypto.Util.number import inverse,long_to_bytes
c= 8722269075970644434253339592758512788160408912707387632591552130175707843950684315083250494010055435391879036285103810263591951437829414438640307561645721347859659807138051841516634704123100270651976676182059252251162982609391666023674158274992400910869692389001622774140191223807887675081808561012755545464977015973615407965906513878979919700065923364884766974187303774330319143647840846354404070430118235352622445115153298578370521811697710289716188726587743282814946239856766713516166990341116198180068191759095913957606379780234116317390622824096667107736103270907349927467971817639795094030622157581511033950777
n= 10466186506773626671397261081802640650185744558208505628349249045496105597268556020207175016523119333667851114848452038431498926527983706092607207796937431312520131882751891731564121558651246025754915145600686076505962750195353958781726515647847167067621799990588328894365930423844435964506372428647802381074584935050067254029262890188260006596141011807724688556673520261743199388391094490191001701011230322653422314758778116196105077883955436582364267530633358016652912054880813710531145973799193443828969535902856467548523653920307742364119002349899553478815101092655897400295925170383678499125295006364960124859003
pq= 10466186506773626671397261081802640650185744558208505628349249045496105597268556020207175016523119333667851114848452038431498926527983706092607207796937431312520131882751891731564121558651246025754915145600686076505962750195353958781726515647847167067621799990588328894365930423844435964506372428647802381074488896197029704465200125337817646702009123916866455067019234171839614862660036737875747177391796376553159880972782837853473250804807544086701088829096838316550146794766718580877976153967582795248676367265069623900208276878140709691073369415161936376086988069213820933152601453587292943483693378833664901178324
qp= 10466186506773626671397261081802640650185744558208505628349249045496105597268556020207175016523119333667851114848452038431498926527983706092607207796937431312520131882751891731564121558651246025754915145600686076505962750195353958781726515647847167067621799990588328894365930423844435964506372428647802381074475956379708898904933143429835002718457573266164923043251954374464149976302585916538814746811455883837138715445492053610047383292461097590195481556557381952895539341802954749542143253491617052100969586396996063822508764438280468492894012685918249843558593322831683872737943676955669923498182824352081785243246
e = 65537
phi = pq*qp//n
print(phi)
d = inverse(e,phi)
m = pow(c,d,n)
print(long_to_bytes(m))

p,q,e,c球m

from Crypto.Util.number import *

from gmpy2 import*

p=447685307 
q=2037
e=17
c=704796792
n=p*q
phi = (p-1)*(q-1)
d=inverse(e,phi)
m=pow(c,d,n)

print(m)

p,q,e,c求m

1、RSA-Tool 2 by tE!

e = 65537 -> 10001

2、
c = 4772758911204771028049020670778336799568778930072841084057809867608022732611295305096052430641881550781141776498904005589873830973301898523644744951545345404578466176725030290421649344936952480254902939417215148205735730754808467351639943474816280980230447097444682489223054499524197909719857300597157406075069204315022703894466226179507627070835428226086509767746759353822302809385047763292891543697277097068406512924796409393289982738071019047393972959228919115821862868057003145401072581115989680686073663259771587445250687060240991265143919857962047718344017741878925867800431556311785625469001771370852474292194

print(pow(c,d,n))

m = 2077392566271985655506271571624317

10进制 -> 16进制：

666C61677B623462795F5235417D

Hex -> Text：
import gmpy2 
from Crypto.Util.number import *
print(long_to_bytes(m))
----- : flag{b4by_R5A}

e,n,c球解密c

使用RSA-Tool分解N，得到q、p；

calc获得D；运行test测试；

解密。



两套e,n,c
e都一样
解密c

import gmpy2 
import binascii

e = 65537 
n1 = 23686563925537577753047229040754282953352221724154495390687358877775380147605152455537988563490716943872517593212858326146811511103311865753018329109314623702207073882884251372553225986112006827111351501044972239272200616871716325265416115038890805114829315111950319183189591283821793237999044427887934536835813526748759612963103377803089900662509399569819785571492828112437312659229879806168758843603248823629821851053775458651933952183988482163950039248487270453888288427540305542824179951734412044985364866532124803746008139763081886781361488304666575456680411806505094963425401175510416864929601220556158569443747 
c1 = 1627484142237897613944607828268981193911417408064824540711945192035649088104133038147400224070588410335190662682231189997580084680424209495303078061205122848904648319219646588720994019249279863462981015329483724747823991513714172478886306703290044871781158393304147301058706003793357846922086994952763485999282741595204008663847963539422096343391464527068599046946279309037212859931303335507455146001390326550668531665493245293839009832468668390820282664984066399051403227990068032226382222173478078505888238749583237980643698405005689247922901342204142833875409505180847943212126302482358445768662608278731750064815

n2 = 22257605320525584078180889073523223973924192984353847137164605186956629675938929585386392327672065524338176402496414014083816446508860530887742583338880317478862512306633061601510404960095143941320847160562050524072860211772522478494742213643890027443992183362678970426046765630946644339093149139143388752794932806956589884503569175226850419271095336798456238899009883100793515744579945854481430194879360765346236418019384644095257242811629393164402498261066077339304875212250897918420427814000142751282805980632089867108525335488018940091698609890995252413007073725850396076272027183422297684667565712022199054289711 

c2 = 2742600695441836559469553702831098375948641915409106976157840377978123912007398753623461112659796209918866985480471911393362797753624479537646802510420415039461832118018849030580675249817576926858363541683135777239322002741820145944286109172066259843766755795255913189902403644721138554935991439893850589677849639263080528599197595705927535430942463184891689410078059090474682694886420022230657661157993875931600932763824618773420077273617106297660195179922018875399174346863404710420166497017196424586116535915712965147141775026549870636328195690774259990189286665844641289108474834973710730426105047318959307995062

p = gmpy2.gcd(n1,n2) # 欧几里得算法，p为两者的最大公约数 

q = n1 // p phi = (p-1)*(q-1)

d = gmpy2.invert(e,phi) 

m = gmpy2.powmod(c1,d,n1)

print(binascii.unhexlify(hex(m)[2:]))

------------------------------------------------------------------

共模攻击

两套e,n,c
n都一样
解密c



from Crypto.Util.number import *
from gmpy2 import gcdext
n = 27235417945955877305315479885923738091002489648238576298420353144290606241844795268855190436147498685165492060755987345495512936007288067090612151169350372157131202845335164852936826027543748199249663527064277075801738624261068045961935165466075600260635095351905680802124008717402352789256073813836721932197169205453298497476302051310321480078280697286848120573368705850987929047322275479477686185991959158293365719861923266921578216120593345055867463362968053157705303411833791697212926004547565287036158877828243035757746713073211087041718443527381725569319760574874661567422820859992033429002389706331862551586577
e1 = 87719
e2 = 115127
c1 = 12723299062942630102738910523127284020453510754363793479302698131176068181448118630269425082012593597113536871873123915346711244939183260297496153550011069638768889641583729617308811049169874609234313366012352794062135533546807652247715911033964005841883445120376024200010650691262425249900746974080354101662271143212209834938484294435476917626130580157149453281448465764839052361272515235095138180617635934233516729837888382915688797335109056423674889719794987380386893974570471932695261699069670046671186404302449907617090008457648408079266188590827125640645648577753563757615281059063894230204418179837299790981240
c2 = 17238453157666192628160667652079964464419809686355676673652527346926684465499606616211869859306437820671181312821289950470070172195118169114078251849239159342226576662588234935768080196285528192683608134619505915076956214519841925675469488935344185889533187844728589896328786401006361577506406151018141954956514476793256082068536455646532740293369284597041928140874543885080669341265244521368948715541882353406460347572422846786937251444710152509439835279217069720133512820478146959651987858758018527620328299630217640010364186930644634652609379041025628717065117341233985230402510916526309853729440439571799917729013

_,u,v = gcdext(e1,e2)
m = pow(c1,u,n) * pow(c2,v,n) % n
print(long_to_bytes(m))

---------------------------------------------------------

低加密指数攻击

import gmpy2
from Crypto.Util.number import *

def de(c, e, n):
    k = 0
    while True:
        m = c + n*k
        result, flag = gmpy2.iroot(m, e)
        if True == flag:
            return result
        k += 1
e= 3
n= 0x52d483c27cd806550fbe0e37a61af2e7cf5e0efb723dfc81174c918a27627779b21fa3c851e9e94188eaee3d5cd6f752406a43fbecb53e80836ff1e185d3ccd7782ea846c2e91a7b0808986666e0bdadbfb7bdd65670a589a4d2478e9adcafe97c6ee23614bcb2ecc23580f4d2e3cc1ecfec25c50da4bc754dde6c8bfd8d1fc16956c74d8e9196046a01dc9f3024e11461c294f29d7421140732fedacac97b8fe50999117d27943c953f18c4ff4f8c258d839764078d4b6ef6e8591e0ff5563b31a39e6374d0d41c8c46921c25e5904a817ef8e39e5c9b71225a83269693e0b7e3218fc5e5a1e8412ba16e588b3d6ac536dce39fcdfce81eec79979ea6872793
c= 0x10652cdfaa6b63f6d7bd1109da08181e500e5643f5b240a9024bfa84d5f2cac9310562978347bb232d63e7289283871efab83d84ff5a7b64a94a79d34cfbd4ef121723ba1f663e514f83f6f01492b4e13e1bb4296d96ea5a353d3bf2edd2f449c03c4a3e995237985a596908adc741f32365

m=de(c,e,n)
print(m)
print(long_to_bytes(m))









import gmpy2 
from Crypto.Util.number import *

def de(c, e, n): 
    k = 0 
    while True: 
        m = c + n * k result, flag = gmpy2.iroot(m, e) 
        if True == flag: 
            return result k += 1

e = 3 
n = 18970053728616609366458286067731288749022264959158403758357985915393383117963693827568809925770679353765624810804904382278845526498981422346319417938434861558291366738542079165169736232558687821709937346503480756281489775859439254614472425017554051177725143068122185961552670646275229009531528678548251873421076691650827507829859299300272683223959267661288601619845954466365134077547699819734465321345758416957265682175864227273506250707311775797983409090702086309946790711995796789417222274776215167450093735639202974148778183667502150202265175471213833685988445568819612085268917780718945472573765365588163945754761 
c = 150409620528139732054476072280993764527079006992643377862720337847060335153837950368208902491767027770946661

m = de(c, e, n) 
print(m) 
print(long_to_bytes(m))










from Crypto.Util.number import *

def get_pq(a,b,c):      # 由p+q和pq的值通过维达定理来求解p和q
    par=isqrt(b*b-4*a*c)   # 由上述可得，开根号一定是整数，因为有解
    x1,x2=(-b+par)//(2*a),(-b-par)//(2*a)
    return x1,x2

def wienerAttack(e,n):
    for dk in continued_fraction(e/n).convergents(): 
        d = dk.denominator()
        k = dk.numerator()
        if k==0:                     # 可能会出现连分数的第一个为0的情况，排除
            continue
        if (e*d-1)%k!=0:             # ed=1 (mod φ(n)) 因此如果找到了d的话，(ed-1)会整除 φ(n),也就是存在k使得(e*d-1)//k=φ(n)
            continue
        phi=(e*d-1)//k               # 这个结果就是 φ(n)
        px,qy=get_pq(1,n-phi+1,n)
        if px*qy==n:
            p,q=abs(int(px)),abs(int(qy))     # 可能会得到两个负数，负负得正未尝不会出现
            d=inverse(e,(p-1)*(q-1))     # 求ed=1 (mod  φ(n))的结果，也就是e关于 φ(n)的乘法逆元d
            return d
    print("该方法不适用")

n = 15088604128478468977566549781105092683347539947348937490176419856356065434456779556064092549108615523127666554897844330164168229344072311774605533892734588398052920720635504619280237988159486581078687811307922574023224119128640446733102319281384567142284146095475216753185154191721944236464638911559894028485432795189775795831433934161095833583153532968049868435932884483661140855893363480029071277412363917343948514737408834993781077430331977564387866552105817476279408735993480716805300450493181681413405987292272733017014550825672240924489724844725325931897081230290178227062710064903854344354557049800111205687197
e = 790142680055451797287471412348850571010486995509022389039756914714559607878217133093316171823607854252726685939931818326808367362243744306142193144042300423428274544907281455058012658772015876990050157589177318880578375252515206769099355808606968684061844566345930280809023645248443130147277438333825548805734080416665789226478379710244036997877325674271526429108712875192888158335939716083256112177193790258171223899489719203252256888818777923376238918119595364810493883858015687532376703938184808317229942799291302711237311062630130553574846019928363972312260820571126554487165159492848299527173505694474097994587
c = 5506806473846050197095534924873053009955837252724617326703967025931017796089327573032228468881762244339142609915863307479644751778961843466686220687863499734629695808563115879790742322778570499788472782252536410852811749191269483232006252750937168108094746385250524894904282857367448778825919736341780839616335236183799339760376367656113963860479277535575918673496483084779331958090456462677018388746643839357078746610506188838811958414895770899920197584850991513686247975668057301261160534405883093755580091313937238128158300865835312776083074991966213689048768359829887854513429838452992818030264685993228541502080
d = wienerAttack(e,n)
m = pow(c,d,n)
print(long_to_bytes(m))

n,e,c 其中e特别特别特别长

from Crypto.Util.number import *

def get_pq(a,b,c):      # 由p+q和pq的值通过维达定理来求解p和q
    par=isqrt(b*b-4*a*c)   # 由上述可得，开根号一定是整数，因为有解
    x1,x2=(-b+par)//(2*a),(-b-par)//(2*a)
    return x1,x2

def wienerAttack(e,n):
    for dk in continued_fraction(e/n).convergents(): 
        d = dk.denominator()
        k = dk.numerator()
        if k==0:                     # 可能会出现连分数的第一个为0的情况，排除
            continue
        if (e*d-1)%k!=0:             # ed=1 (mod φ(n)) 因此如果找到了d的话，(ed-1)会整除 φ(n),也就是存在k使得(e*d-1)//k=φ(n)
            continue
        phi=(e*d-1)//k               # 这个结果就是 φ(n)
        px,qy=get_pq(1,n-phi+1,n)
        if px*qy==n:
            p,q=abs(int(px)),abs(int(qy))     # 可能会得到两个负数，负负得正未尝不会出现
            d=inverse(e,(p-1)*(q-1))     # 求ed=1 (mod  φ(n))的结果，也就是e关于 φ(n)的乘法逆元d
            return d
    print("该方法不适用")

n = 468459887279781789188886188573017406548524570309663876064881031936564733341508945283407498306248145591559137207097347130203582813352382018491852922849186827279111555223982032271701972642438224730082216672110316142528108239708171781850491578433309964093293907697072741538649347894863899103340030347858867705231
e = 284100478693161642327695712452505468891794410301906465434604643365855064101922252698327584524956955373553355814138784402605517536436009073372339264422522610010012877243630454889127160056358637599704871937659443985644871453345576728414422489075791739731547285138648307770775155312545928721094602949588237119345
c = 350429162418561525458539070186062788413426454598897326594935655762503536409897624028778814302849485850451243934994919418665502401195173255808119461832488053305530748068788500746791135053620550583421369214031040191188956888321397450005528879987036183922578645840167009612661903399312419253694928377398939392827
d = wienerAttack(e,n)
m = pow(c,d,n)
print(long_to_bytes(m))

知道e,q,p,n

费马分解

代码，有计算出来的n和c，

import gmpy2,libnum
from Crypto.Util.number import getPrime
from secret import flag

e = 0x10001
p = getPrime(1024)
q = gmpy2.next_prime(p)
n = p * q
print("n =",n)
m = libnum.s2n(flag)
c = pow(m,e,n)
print("c =", c)
# n = 26737417831000820542131903300607349805884383394154602685589253691058592906354935906805134188533804962897170211026684453428204518730064406526279112572388086653330354347467824800159214965211971007509161988095657918569122896402683130342348264873834798355125176339737540844380018932257326719850776549178097196650971801959829891897782953799819540258181186971887122329746532348310216818846497644520553218363336194855498009339838369114649453618101321999347367800581959933596734457081762378746706371599215668686459906553007018812297658015353803626409606707460210905216362646940355737679889912399014237502529373804288304270563
# c = 18343406988553647441155363755415469675162952205929092244387144604220598930987120971635625205531679665588524624774972379282080365368504475385813836796957675346369136362299791881988434459126442243685599469468046961707420163849755187402196540739689823324440860766040276525600017446640429559755587590377841083082073283783044180553080312093936655426279610008234238497453986740658015049273023492032325305925499263982266317509342604959809805578180715819784421086649380350482836529047761222588878122181300629226379468397199620669975860711741390226214613560571952382040172091951384219283820044879575505273602318856695503917257

题目长得这样

结题答案如下

import gmpy2,libnum 
from Crypto.Util.number import getPrime 
from rsa import common 
import binascii 

n = 26737417831000820542131903300607349805884383394154602685589253691058592906354935906805134188533804962897170211026684453428204518730064406526279112572388086653330354347467824800159214965211971007509161988095657918569122896402683130342348264873834798355125176339737540844380018932257326719850776549178097196650971801959829891897782953799819540258181186971887122329746532348310216818846497644520553218363336194855498009339838369114649453618101321999347367800581959933596734457081762378746706371599215668686459906553007018812297658015353803626409606707460210905216362646940355737679889912399014237502529373804288304270563 

c = 18343406988553647441155363755415469675162952205929092244387144604220598930987120971635625205531679665588524624774972379282080365368504475385813836796957675346369136362299791881988434459126442243685599469468046961707420163849755187402196540739689823324440860766040276525600017446640429559755587590377841083082073283783044180553080312093936655426279610008234238497453986740658015049273023492032325305925499263982266317509342604959809805578180715819784421086649380350482836529047761222588878122181300629226379468397199620669975860711741390226214613560571952382040172091951384219283820044879575505273602318856695503917257 

e = 0x10001 

N=gmpy2.iroot(n,2) 
q=gmpy2.next_prime(N[0]) 
p=n//q l=(p-1)*(q-1) 
d=common.inverse(e,l) 
m=pow(c,d,n) 
print(binascii.unhexlify(hex(m)[2:]))

题目这样

e = 0x10001
p>>128<<128 = 0xd1c520d9798f811e87f4ff406941958bab8fc24b19a32c3ad89b0b73258ed3541e9ca696fd98ce15255264c39ae8c6e8db5ee89993fa44459410d30a0a8af700ae3aee8a9a1d6094f8c757d3b79a8d1147e85be34fb260a970a52826c0a92b46cefb5dfaf2b5a31edf867f8d34d2222900000000000000000000000000000000
n = 0x79e0bf9b916e59286163a1006f8cefd4c1b080387a6ddb98a3f3984569a4ebb48b22ac36dff7c98e4ebb90ffdd9c07f53a20946f57634fb01f4489fcfc8e402865e152820f3e2989d4f0b5ef1fb366f212e238881ea1da017f754d7840fc38236edba144674464b661d36cdaf52d1e5e7c3c21770c5461a7c1bc2db712a61d992ebc407738fc095cd8b6b64e7e532187b11bf78a8d3ddf52da6f6a67c7e88bef5563cac1e5ce115f3282d5ff9db02278859f63049d1b934d918f46353fea1651d96b2ddd874ec8f1e4b9d487d8849896d1c21fb64029f0d6f47e560555b009b96bfd558228929a6cdf3fb6d47a956829fb1e638fcc1bdfad4ec2c3590dea1ed3
c = 0x1b2b4f9afed5fb5f9876757e959c183c2381ca73514b1918d2f123e386bebe9832835350f17ac439ac570c9b2738f924ef49afea02922981fad702012d69ea3a3c7d1fc8efc80e541ca2622d7741090b9ccd590906ac273ffcc66a7b8c0d48b7d62d6cd6dd4cd75747c55aac28f8be3249eb255d8750482ebf492692121ab4b27b275a0f69b15baef20bf812f3cbf581786128b51694331be76f80d6fb1314d8b280eaa16c767821b9c2ba05dfde5451feef22ac3cb3dfbc88bc1501765506f0c05045184292a75c475486b680f726f44ef8ddfe3c48f75bb03c8d44198ac70e6b7c885f53000654db22c8cee8eb4f65eaeea2da13887aaf53d8c254d2945691

答案：

from Crypto.Util.number import *
import gmpy2

e = 0x10001
c = 0x1b2b4f9afed5fb5f9876757e959c183c2381ca73514b1918d2f123e386bebe9832835350f17ac439ac570c9b2738f924ef49afea02922981fad702012d69ea3a3c7d1fc8efc80e541ca2622d7741090b9ccd590906ac273ffcc66a7b8c0d48b7d62d6cd6dd4cd75747c55aac28f8be3249eb255d8750482ebf492692121ab4b27b275a0f69b15baef20bf812f3cbf581786128b51694331be76f80d6fb1314d8b280eaa16c767821b9c2ba05dfde5451feef22ac3cb3dfbc88bc1501765506f0c05045184292a75c475486b680f726f44ef8ddfe3c48f75bb03c8d44198ac70e6b7c885f53000654db22c8cee8eb4f65eaeea2da13887aaf53d8c254d2945691
p = 104447286451939566076017797038369998283019120860149982200602344749600436385708441695230995780714906769626731151644722579252428917819367256207463696691033967714073069435280785389775459281272218174741165454138432242201951151298026448827619971129737985262978620243577274864410816225725466321200461416855483876019
q = 147305526294483975294006704928271118039370615054437206404408410848858740256154476278591035455064149531353089038270283281541411458250950936656537283482331598521457077465891874559349872035197398406708610440618635013091489698011474611145014167945729411970665381793142591665313979405475889978830728651549052207969
n = p*q
phi = (p-1)*(q-1)
d = gmpy2.invert(e,phi)
m = pow(c,d,n)
print(m)
print(long_to_bytes(m))
#b'flag{Kn0wn_Hi9h_Bit5}'

致力于Python开发网络安全工具,分享Python底层与进阶知识，漏洞扫描器开发与爬虫开发

CTF-Crypto现代加密入门