RSA个人总结合集 + 部分例题

已于 2025-01-27 18:00:50 修改
阅读量1.5k 收藏 47
点赞数 22
分类专栏： 加密 文章标签： python
于 2025-01-27 17:56:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_63166189/article/details/145381309
版权

RSA简介

杂七杂八简介

  • p、q：RSA算法使用两个大质数p和q来生成公钥和私钥，这两个质数需要足够大以保证安全性

  • d：RSA算法，公钥和私钥是一对互补的密钥，其中私钥由两个部分组成：d和n，d为私钥，使用扩展欧几里得算法，n为公钥，n=pq

    • 计算欧拉函数φ(n) = (p-1)(q-1)
    • 选取一个正整数 e（1<e<φ(n)），使得 e 和 φ(n) 互质。
    • 计算 d，满足 d ≡ e^-1 (mod φ(n))。

  • dp、dq：其是为了加速加密过程从而产生的预处理值

    • 计算方法
      • ps: ≡ 意为同余，例25≡1(mod 8)，即25和1对8取余相同
      • e*dp ≡ 1(mod p-1)
      • e*dq ≡ 1(mod q-1)

  • e：公钥，满足ed≡1(mod φ(n))

  • c：c是RSA算法中的密文，公钥加密后生成的


  1. 选择两个⼤素数p和q，计算出模数N = p * q
  2. 计算φ = (p−1) * (q−1) 即N的欧拉函数，然后选择⼀个e (1<e<φ)，且e和φ互质
  3. 取e的模反数为d，计算⽅法: e * d ≡ 1 (mod φ)
  4. 对明⽂m进⾏加密：c = pow(m, e, N)，得到的c即为密⽂
  5. 对密⽂c进⾏解密，m = pow(c, d, N)，得到的m即为明⽂
--------------------------------------------------参考资料-------------------------------------------------
RSA原理及各种题型总结  https://blog.youkuaiyun.com/vhkjhwbs/article/details/101160822
CTF中的RSA套路  https://www.cnblogs.com/nul1/p/13489269.html
CTF中的RSA及攻击方法笔记  https://www.freebuf.com/articles/web/257835.html
你想要的RSA解题技巧（二）  https://cloud.tencent.com/developer/article/1076063
CTF中的RSA 算法 https://www.cnblogs.com/NPFS/p/13383625.html

稍微认真的

对于大素数p和q，计算n=p×q非常简单，但是在已知n的情况下分解因子得到p和q则相当困难。

选取较大素数p、q（一般大于512bit，且p不等于q）：n = p*q

求n欧拉函数φ(n)=φ§×φ(q)=(p-1)×(q-1)

选取一个与φ（n）互质的整数e，求得e模φ（n）的逆元d，e×d≡1modφ(n)

则<n，e>为公钥，<n，d>为私钥

设m位明文，c为密文，加解密操作如下：
请添加图片描述

数论基础

模运算规则

(a + b) % p = (a % p + b % p) % p
(a - b) % p = (a % p - b % p) % p
(a * b) % p = (a % p * b % p) % p
(a ^ b) % p = ((a % p)^b) % p

结合律

((a+b) % p + c) % p = (a + (b+c) % p) % p
((a*b) % p * c)% p = (a *(b*c)%p) % p

交换律

(a + b) % p = (b + a) % p
(a * b) % p = (b * a) % p

分配律

((a +b)% p * c) % p = ((a * c) %p + (b * c) % p) % p

重要定理：

a ≡ b(mod n)，a与b对模n同余

≡是数论中表示同余的符号，b(mod n)是表示b对n取余

若a≡b (% p)，则对于任意的c，都有(a + c) ≡ (b + c) (%p)
若a≡b (% p)，则对于任意的正整数c，都有(a * c) ≡ (b * c) (%p)
若a≡b (% p)，c≡d (% p)，则 (a + c) ≡ (b + d) (%p)，(a - c) ≡ (b - d) (%p)，
(a * c) ≡ (b * d) (%p)

最大公因子

两个数互素是指：二者除了1以外没有共同的因子，如果a和n的最大公因子等于1，那么可写作gcd(a,n)=1

欧几里得算法

辗转相除法

欧几里得扩展算法

如果gcd(a, b) = c，则存在x, y，使得c = ax + by

模的逆元：
简单来说，求a的逆，就是找一个 x，使得 1 = ( a ∗ x ) ( m o d n ) 1 = (a*x){\pmod n} 1=(a∗x)(modn)，也可记作 a − 1 ≡ x ( m o d n ) a^{-1} \equiv x{\pmod {n}} a−1≡x(modn)

费马小定理和欧拉定理：

请添加图片描述

题目 and 脚本

分解n

在线网站分解

http://factordb.com/


Yafu分解

在RSA中，当p、q的取值差异过⼤或过于相近的时候，使⽤yafu可以快速的把n值分解出p、q值，原理是
使⽤Fermat⽅法与Pollard rho⽅法等。

  • n较⼩，可直接分解

    yafu-x64 factor(16422644908304291)

  • n较大，保存文件分解

    注意文件末尾必须存在一个换行

    yafu-x64 "factor(@)" -batchfile 1.txt

wiener-attack 当n，e太大太小使用

当n太大太小使用

import gmpy2


def transform(x, y):  # 使用辗转相处将分数 x/y 转为连分数的形式
    res = []
    while y:
        res.append(x // y)
        x, y = y, x % y
    return res


def continued_fraction(sub_res):
    numerator, denominator = 1, 0
    for i in sub_res[::-1]:  # 从sublist的后面往前循环
        denominator, numerator = numerator, i * numerator + denominator
    return denominator, numerator  # 得到渐进分数的分母和分子，并返回


# 求解每个渐进分数
def sub_fraction(x, y):
    res = transform(x, y)
    res = list(map(continued_fraction, (res[0:i] for i in range(1, len(res)))))  # 将连分数的结果逐一截取以求渐进分数
    return res


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


def wienerAttack(e, n):
    for (d, k) in sub_fraction(e, n):  # 用一个for循环来注意试探e/n的连续函数的渐进分数，直到找到一个满足条件的渐进分数
        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 = gmpy2.invert(e, (p - 1) * (q - 1))  # 求ed=1 (mod  φ(n))的结果，也就是e关于 φ(n)的乘法逆元d
            return d
    print("该方法不适用")


e = 46867417013414476511855705167486515292101865210840925173161828985833867821644239088991107524584028941183216735115986313719966458608881689802377181633111389920813814350964315420422257050287517851213109465823444767895817372377616723406116946259672358254060231210263961445286931270444042869857616609048537240249
n = 86966590627372918010571457840724456774194080910694231109811773050866217415975647358784246153710824794652840306389428729923771431340699346354646708396564203957270393882105042714920060055401541794748437242707186192941546185666953574082803056612193004258064074902605834799171191314001030749992715155125694272289
d = wienerAttack(e, n)
print("d=", d)

利用公约数分解----多个n

通常会发现题⽬给了多个n，均不相同，并且都是2048bit，4096bit级别，⽆法正⾯硬杠，并且明⽂都没什么联系，e也⼀般取65537。可以直接gcd(n1,n2)求出⼀个因数。

import gmpy2
n1 = 9051013965404084482870087864821455535159008696042953021965631089095795
348830954383127323853272528967729311045179605407693592665683311660581204886
571146327720288455874927281128121117323579691204792399913106627543274457036
172455814805715668293705603675386878220947722186914112990452722174363713630
297685159669328951520891938403452797650685849523658191947411429068829734053
745180460758604283051344339641429819373112365211739216160420494167071996438
506850526168389386850499796102003625404245645796271690310748804327
n2 = 1322594839617960381606204641871721479266851241362509156999752436424399
599196101889415005920782409383742045137524055031005020939896450631851899162
014257592662378041153225723070198582162942572203060872203557069047417125923
815394709531030352283197166466606754264903446162172565623486900550129342397
518470192972917007728025143621616729305856003008900614022437542567957118178
720698271247726143257953798127805575534457376707695179331206248027500456465
7590263719816033564139497109942073701755011873153205366238585665743
p = gmpy2.gcd(n1, n2)
print ('gcd(n1, n2):\n', p)
q1 = n1 / p
q2 = n2 / p
print ('q1 is:\n', q1)
print ('q2 is:\n', q2)

公钥私钥

读取公钥

当得到一个公钥文件，后缀可能为pub，pem

使用kali命令

openssl rsa -text -modulus -pubin -in pubkey.pem

去得到n和e

在这里插入图片描述

其中modulus为n，exponent为e

再去分解n，得到p，q

亦或者使用

from Crypto.PublicKey import RSA

with open("./key.pub", "rb") as file:
    key = file.read()

print(key)
pub = RSA.importKey(key)
n = pub.n
e = pub.e
print("n = ", n)
print("e = ", e)

生成私钥

import rsa
priv = rsa.PrivateKey(n,e,d,p,q)


cr4-poor-rsa

得到一个文件，使用file命令检测属于什么类型

file 文件名

得到为tar

改后缀，打开压缩包，
在这里插入图片描述

对key.pub使用openssl命令获取内容

在这里插入图片描述

e=65537

n=833810193564967701912362955539789451139872863794534923259743419423089229206473091408403560311191545764221310666338878019

分解得

p=863653476616376575308866344984576466644942572246900013156919

q=965445304326998194798282228842484732438457170595999523426901

然后计算d值

d = invert(e,(p-1)(q-1))

d = 521250646663056391768764366517618655312275374668692430321064634566533568373969990465313092928455546989832961905578375473

然后计算私钥

import rsa
priv = rsa.PrivateKey(n,e,d,p,q)

最后打开flag.b64

在这里插入图片描述

那就先解码在使用私钥解密

with open("./flag.b64", "rb") as file:
    cipher = file.read()
cipher = base64.b64decode(cipher)
flag = rsa.decrypt(cipher, priv).decode()
print(flag)

RSA常见攻击

因式分解

常用工具

  • sagemath
  • yafu
  • 在线网站factordb

低加密质数小明文攻击m非常小，且e比较小，导致加密后得c仍然小于n

如果加密指数m非常小，且e比较小，导致加密后得c仍然小于n，那么便可直接对密文开e次方

# -*- coding: cp936 -*-
import binascii

import gmpy2

n = 0x52d483c27cd806550fbe0e37a61af2e7cf5e0efb723dfc81174c918a27627779b21fa3c851e9e94188eaee3d5cd6f752406a43fbecb53e80836ff1e185d3ccd7782ea846c2e91a7b0808986666e0bdadbfb7bdd65670a589a4d2478e9adcafe97c6ee23614bcb2ecc23580f4d2e3cc1ecfec25c50da4bc754dde6c8bfd8d1fc16956c74d8e9196046a01dc9f3024e11461c294f29d7421140732fedacac97b8fe50999117d27943c953f18c4ff4f8c258d839764078d4b6ef6e8591e0ff5563b31a39e6374d0d41c8c46921c25e5904a817ef8e39e5c9b71225a83269693e0b7e3218fc5e5a1e8412ba16e588b3d6ac536dce39fcdfce81eec79979ea6872793
e = 0x3
c = 0x10652cdfaa6b63f6d7bd1109da08181e500e5643f5b240a9024bfa84d5f2cac9310562978347bb232d63e7289283871efab83d84ff5a7b64a94a79d34cfbd4ef121723ba1f663e514f83f6f01492b4e13e1bb4296d96ea5a353d3bf2edd2f449c03c4a3e995237985a596908adc741f32365

print('n=', n)
print('c=', c)

print('[+]Detecting m...')
result = gmpy2.iroot(c, 3)

print('  [-]The c has cubic root?', result[1])
print('  [-]The m is:', '{:x}'.format(result[0]))
m = result[0]
print(binascii.unhexlify(hex(m)[2:]))

共模攻击

使用相同n，不同得模数e1，e2且e1，e2互素，对同一组明文进行加密，得到密文c1，c2，就可在不计算私钥得情况下计算出明文

即已知n,e1,e2,c1,c2

g,x,y = gmpy2.gcdext(e1,e2)
m = (pow(c1,x,n)*pow(c2,y,n))%n

广播攻击

对于相同明文m，使用相同的指数e和不同的模数n1,n2,…,ni，加密得到i组密文，可使用中国剩余定理

def crt(a,n):
  sum = 0
  prd = reduce(lambda a, b: a*b, n)
  
  for n_i, a_i in zip(n, a):
    p = prod / n_i
    sum += a_i * gmpy2.invert(p, n_i)*p
  return sum % prod
n = [n1,n2,n3]
c = [c1,c2,c3]
x = crt(c, n)
print(gmpy2.iroot(x,e))

低解密指数攻击 维也纳攻击

解密指数d较低

或者en大

coppersmith’s High Bots Attack

已知明文很大部分，即m=m0+x

详情见D:\atool\crypto\RSA-and-LLL-attacks-master

Rabin’s RSA

特点：一个密文对应四个明文，但不是每一个都有意义

且其e=2，pq都对4取余得3

  • 加密过程：c≡m^2 mod n
  • 解密过程
  • 在这里插入图片描述

在这里插入图片描述

解密脚本

import gmpy2
import codecs

def squareMod(c, mod):          # 模意义下开根，找到 x, 使得 x^2 % mod = c
    assert(mod % 4 == 3)
    res = gmpy2.powmod(c, (mod+1)//4, mod)
    return res, mod - res

def getPlaintext(x, y, p, q):   # 假设 m%p=x, m%q=y, 求明文
    res = x*q*gmpy2.invert(q, p) + y*p*gmpy2.invert(p, q)
    return res % (p*q)

def solve(c, p, q):             # 已知 p,q, 解密 c
    px = squareMod(c, p)
    py = squareMod(c, q)

    for x in px:
        for y in py:
            yield getPlaintext(x, y, p, q)

c = open('flag.enc', 'rb').read()
c = int(codecs.encode(c, 'hex'), base=16)

p = 275127860351348928173285174381581152299
q = 319576316814478949870590164193048041239

for msg in solve(c, p, q):
    res = hex(msg)[2:]
    if len(res) % 2 == 1:
        res = '0' + res

    print(codecs.decode(res, 'hex'))

参考脚本

已知 n，e，c 求 m

第一步：这种题目要先分解出p,q，可以使用在线分解工具http://www.factordb.com/进行分解，也可以使用下面暴力分解脚本进行分解，代码如下所示

# -*- coding:utf-8 -*-
from Crypto.Util.number import *


def f(x, n):
    return (pow(x, n - 1, n) + 3) % n


def rho(n):
    i = 1
    while True:
        a = getRandomRange(2, n)
        b = f(a, n)
        j = 1
        while True:
            p = GCD(abs(a - b), n)
            print('{} in {} circle'.format(j, i))
            if p == n:
                break
            elif p > 1:
                return (p, n // p)
            else:
                a = f(a, n)
                b = f(f(b, n), n)
            j += 1
        i += 1


def main():
    #n = 84236796025318186855187782611491334781897277899439717384242559751095347166978304126358295609924321812851255222430530001043539925782811895605398187299748256080526691975084042025794113521587064616352833904856626744098904922117855866813505228134381046907659080078950018430266048447119221001098505107823645953039
    n = 38915622445322594788113853812230848083133274092845339659216148461050062802771
    print("rho(n) = ",rho(n))


if __name__ == '__main__':
    main()

然后破解

import gmpy2
import binascii


c = 34533624647193630459864898193867716746457242698156942414136896826169638045191
n = 38915622445322594788113853812230848083133274092845339659216148461050062802771
e = 65537

p = 184447441856923584506972548629664462921
q = 210984885740565358250291732634631217851

# invert是求乘法逆元
d = gmpy2.invert(e,(p-1)*(q-1))
#print("d = ",d)

jiemi = hex(pow(c,D,n))[2:]
print(binascii.unhexlify(jiemi))

已知 p，q，e 求 d

import gmpy2
p= 18255878996579787209
q= 324206965464727676218470615969477348407
e= 13
phi_n= (p - 1) * (q - 1)
d = gmpy2.invert(e, phi_n)
print("d is:")
print (d)

已知dp，dq，c，p，q 求m

#!/usr/bin/python3

import gmpy2 
from Crypto.Util.number import long_to_bytes

dp=5052882267944459896063942392534379448810718093348381758286781811719311663310063302173760032982142586285079042828546912467138475161693026139283139414185935
dq=8778400270622276402687979905385226435600717274058228963159983444750011003782436556279419782403013228295325114848834289405247546524131313104685306273705481


c=126532907580099364343184491768646529625198629422625132086837277388311620436342303548372778988466885452676106624249993145364094931515804016688045515844551913407187806695920008237063017356722982532180950578657415816037585713774844783414877587745164572907604833861956805820826575330755221423176730512522016231899
p=12703830329315842567550642290233844551989413115578044857207995534378659933185699107475417626944054884619067220234567806128777927903935084746622131729293883
q=13227646254242570726391882350245593196835449566365947429669506242811060886921793037704557843316080241482324099322834773980909766089991351871376104597517673


InvQ=gmpy2.invert(q,p) 
mp=pow(c,dp,p) 
mq=pow(c,dq,q) 
m=(((mp-mq)*InvQ)%p)*q+mq

print(long_to_bytes(m))

仅已知c，c特别大 【c = m^e mod n】

import gmpy2
from Crypto.Util.number import long_to_bytes

c= 70648271870529018298808886692660001235938402498859964208263409228294415956391386882206991779337601969468744143154220156908990882519717884837945906532856617909820634715854106067161582726782479804159872876992853415864029799581913231177768699278743865744051081912845185335254212638849627195499382733556635858876295634685104897939348828134359144172975276459715762939123096110061586424369639959775521808682889540769193855829876997008128536903490299132154510356729022499408881154087899262032022855765099359626306072450220026018989683836905274747226301294492449246981491703637969852470324929139841720904168369016701475473723817222435805118280228349995037458691540317562924025604518558871782328127664484684356019553232422829444404192009366087224101978739443672545344658651273357576407371982381712751927195093709853829098510072742432249637952525032152431697014721551432098156200586978917577793422057597440719114480618877894616871959869916614058028831275788375950733806459764284840487325149337299990855084479898075589047172548147875475208055116347806096743889904780424630991082111584954172971348812743549982114088569643724870601775753587500487587232004365616342285254951215710149051425199567406281845437620161540582331552889378213717815240687946879147182009028055465175524929611814188527384223348841689860466118240991278594716972892815411269840685462905179556339480041379983668015257914037862901765474982683391249869954470639078475799966417324353131574185612380759323772536955664969364984771648781609746891888279115194051967522808187234763670188472064410745331155700030125511119592595872233060513965829818176890051306809753236542584083528178867508482630064114676825193611148863808117676651877021193525941919029447722940424850259638483259618630908803708352705413985045710677257866844109324594946057235660716032547419296152445756960506166306142244870597217375420785364387192306982268095293440397581098253894684144767233449993257607977934129268826833178031802975929524501934934571709387124594721454624740923550910142337887938218289407086085953807593009004062815408946161107775999354280866956654098094276407491110119245931585538677207353167309009711825693274002853552686144987620601712501856763042883463793285988502606582149509061672725832529050936604314856886070993609898668742138501623378819838961657769663146089896801201156992228867361774391692716488518726007591552311991840025005427255145632627726384869513359648324145841090361264259057089609185017730717955467211726509629
for e in range(2,100):
    out = gmpy2.iroot(c,e)
    if out[1]:
        #print(out)
        #print(hex(out[0]))
        print("e = %d,   out[1] = %s" % (e,long_to_bytes(out[0])))

已知n1，n2，c1，c2，e 求 m


#!/usr/bin/python3 
#coding:utf-8 
#@Author:醉清风 

import gmpy2  
from Crypto.Util.number import long_to_bytes  
''' 
lines = open('tmp.txt','r').readlines()  
 
c1 = int(lines[2],16)  
c2 = int(lines[6],16)  
n1 = int(lines[0])  
n2 = int(lines[4])  
'''

e=65537
n1=824309976713255040678774414315188911324305343946939068909416612709427405647590959202342069019687909827092434444738101792679253192217384554228922429405912765227299967576480004693502002706412618405848902047952249003683180646566555226980812871255985212785459728851482116385274886923030294336883118688943249637504111890941209117072125746914179382718841738938542647288128064878216596964710061943380933923317756767868900496106852496453030519617669299982705549374229502330525781052290174942572613344201021252879326095620935532484506572612967292839330025773029359908312962614731172968139177410904955609738349904997096375511564814382685053981249781750176436863678070180664579983017200009530939815220400486376740060465859081480696946249903279025539697834581358967123153969680757041410395146786259547823312557522601991424424780515118072828799902432329203842554206968777062590538956711084620951141331083100850610394090226480405466880324484810299761769275660553824905489329036439444269606193857756472844072315538452095272865161396795572965527449721108417342506231371917632592432396627440113643668181341007626924926752996257541349928107829776244387124514376067059436403317102173969866403920047378658985491771106094848218483420872665866345564496827
c1=619914776107204299421445515173752551578219512744832453386701408956131174382320293166571812398142061624071844793902243230988065164689738932213640598607827763120716664826659348935506492768840667618225389848502303543184323923750014314468273838436900100602616360301578680417070089037669208417514209496064782776638328659280595442584379339709690595064375146973041893766612952550104106304945793198707913036776562970941681277387345166363055403617979919206215550071922838408131362316374998986152131970583571257394242002989402779457115646413931644663555330819307049576617764087014494844129906098270686406058331758868723651041516567453323769768954687687202307774567305854473941230877789037414544400622116272774149579612412707977679341464711326395329328746997671371678549747416132575437991623923520089934467780767741968218870533906551561755021778559582638320070802534402702441689980582215813996309661425381981953031455267480573603282477682645039060338023983236132572154559608798674661049316746566458858853902292172161686826090441354261889811244610252422433735484707855667726547016802906293840413275921015090833094030889513775808522094907659133321728552859456301911921882441570565302485792013026978232768832198065043569203133298692101550276793242

n2=905589252405843373769915380293297111534760160714737080968066656272265067237261488456971858456917989327188732044692331992189086519820435633306176464411261896021205034205490970644012401822191880790030875680376477319350989208508591406379353590606990790187262655027873609762696926884097121412806124968361945732028625146592611563133972373222186510357547047870461524686536342088980414561620202107652793943447542030500100100438546978201140485266000991269033918263304132180594282910120350517431177243383393951480422824952551390879069092986257009179295057946730605973160346524195449500021703749379427308594689270698548425547616170119689641602115020951172647164330653185839148908281150010508830578946902028400175833666756810132914706574636302946981088249485384995123961868977200184192366871488238130493276320548228987765469367680884015794318055385681062658024380060853629777987397931994453740025625110420802340709951010187420093537470088728911794883713099533087772597248823814645583216509715894593709142551596518622892980794670674353243620390795154580419812174256794942916769770550059026084217681241980763703393095418708693297369255695621169620925250022220663830988716484961599451891633153226183322921970730586750473413763286928431026521685503
c2=673931551637686573733931629946259955273050809105413358970865200931337620800601472110603043036230330369308198862836020608370123474012622263062171294537227742055596124838615523641277612651513376399422388728998723881390750022802888924469874997383403315092150360404739350111053494140814081500234944823944838342851486117828948012785473829786919168505899092926364319233270563625167199627187969831097779544020398227294075980803974781408640110508283074795045029934267450514279868306481527002838558049458432355280575187364797865249444744186956192622171429969229590383633312442290257337521345975778920638983724068169611670153900548976779043697802190755538297452687741381067668713313038012240461367852752324450730890453516495687244181415711446356025503068925532832441729497205951722171806849453544384230181139694995076734472488950052672657187723121538897634719634849656096065795251013915979636071103988880297602168171474689743253367371894201376237227289251967333720190335216940010089300129979229084907563995802063939925492798235466279747474279314734378363118765257958698347531646918232605837643662036855703017542230709453864001404693532353827244434156882808171822447915265832615174700571049925710515965628161428609658333071907595502748554057056



# 求出n1与n2的最大公因数即为p，之后就可以得到q和d，从而求解m。
p1 = gmpy2.gcd(n1, n2)  
assert (p1 != 1)  
p2 = n1 // p1  
p3 = n2 // p1  

d1 = gmpy2.invert(e, (p1 - 1) * (p2 - 1))  
d2 = gmpy2.invert(e, (p1 - 1) * (p3 - 1))  
m1 = pow(c1, d1, n1)  
m2 = pow(c2, d2, n2)  
print(long_to_bytes(m1)+long_to_bytes(m2))

已知n1，n2，e，c2 求m

# -*- coding:utf-8 -*-
from Crypto.Util.number import *
from flag import *

import math
import gmpy2

# https://cloud.tencent.com/developer/article/1076063
# https://www.cnblogs.com/NPFS/p/13383625.html
# 16进制到ASCII字符串在线转换工具  https://coding.tools/cn/hex-to-ascii

n1 = 103835296409081751860770535514746586815395898427260334325680313648369132661057840680823295512236948953370895568419721331170834557812541468309298819497267746892814583806423027167382825479157951365823085639078738847647634406841331307035593810712914545347201619004253602692127370265833092082543067153606828049061
n2 = 115383198584677147487556014336448310721853841168758012445634182814180314480501828927160071015197089456042472185850893847370481817325868824076245290735749717384769661698895000176441497242371873981353689607711146852891551491168528799814311992471449640014501858763495472267168224015665906627382490565507927272073
e = 65537
# m = bytes_to_long(flag)
# c1 = pow(m, e, n1)
# c2 = pow(c1, e, n2)

c2 = 60406168302768860804211220055708551816238816061772464557956985699400782163597251861675967909246187833328847989530950308053492202064477410641014045601986036822451416365957817685047102703301347664879870026582087365822433436251615243854347490600004857861059245403674349457345319269266645006969222744554974358264



print("------------------1 分解n---------------------")
p = math.gcd(n1, n2)
print ("n1，n2共有的共因素p=",math.gcd(n1, n2))

print("------------------2 求q1,q2---------------------")
q1=n1//p
q2=n2//p
print("q1=",q1)
print("q2=",q2)


p0 = gmpy2.mpz(p)#初始化大整数
q_1 = gmpy2.mpz(q1)
q_2 = gmpy2.mpz(q2)
#e = gmpy2.mpz(65537)
e = 65537
r_1 = (p0-1)*(q_1-1)
r_2 = (p0-1)*(q_2-1)
d_1 = gmpy2.invert(e,r_1)  # invert（e，r）返回d使得e * d == 1 mod r，如果不存在d，则返回0
d_2 = gmpy2.invert(e,r_2)
print("d_1=",d_1)
print("d_2=",d_2)

print("------------------3 求c1,c2---------------------")
m2 = pow(c2, d_2, n2)
c1 = m2
print("m2=",m2)

# c = pow(m, e, n1)     
m1 = pow(c1, d_1, n1)
print("m1=",m1)
hex_m1 = hex(m1)
print("hex_m1=",hex_m1)

已知e，d，N 求p，q

#!/usr/bin/python2
#coding:utf-8 
import random
from md5 import md5
 
def gcd(a, b):
   if a < b:
     a, b = b, a
   while b != 0:
     temp = a % b
     a = b
     b = temp
   return a
 
def getpq(n,e,d):
	p = 1
	q = 1
	while p==1 and q==1:
		k = d * e - 1
		g = random.randint ( 0 , n )
		while p==1 and q==1 and k % 2 == 0:
			k /= 2
			y = pow(g,k,n)
			if y!=1 and gcd(y-1,n)>1:
				p = gcd(y-1,n)
				q = n/p
	return p,q
 
def main():
	n = 16352578963372306131642407541567045533766691177138375676491913897592458965544068296813122740126583082006556217616296009516413202833698268845634497478988128850373221853516973259086845725813424850548682503827191121548693288763243619033224322698075987667531863213468223654181658012754897588147027437229269098246969811226129883327598021859724836993626315476699384610680857047403431430525708390695622848315322636785398223207468754197643541958599210127261345770914514670199047435085714403641469016212958361993969304545214061560160267760786482163373784437641808292654489343487613446165542988382687729593384887516272690654309
	e = 65537
	d = 9459928379973667430138068528059438139092368625339079253289560577985304435062213121398231875832264894458314629575455553485752685643743266654630829957442008775259776311585654014858165341757547284112061885158006881475740553532826576260839430343960738520822367975528644329172668877696208741007648370045520535298040161675407779239300466681615493892692265542290255408673533853011662134953869432632554008235340864803377610352438146264524770710345273439724107080190182918285547426166561803716644089414078389475072103315432638197578186106576626728869020366214077455194554930725576023274922741115941214789600089166754476449453
	p,q = getpq(n,e,d)
	print("p:",p) 
	print("q:",q)
	print("Flag: flag{%s}" %md5(str(p + q)).hexdigest())
if __name__ == '__main__':
	main()

peiqi=(p+520)*(q+520)

import gmpy2
import binascii

n=26609708421376677628454402900087009846291167287676911113310671001067916215975654619357943078675057781284419971876364188201285756254849493795101184689472972451252559267516902582277554505702670110528791300961267369272080284734306320521513748467464633545459859474195548892296577923424451509458569436363709731402197392186162426572460924170144815459280292038798573517240473723212917475994555278140089160884080770934882248855992019482512867322735936930918031567624003424284507526700957286437082738893899468444943650565398213516262653534101927337725614414267105976588592783298584640344155571836662897588729868409203459117059
e=65537
peiqi=26609708421376677628454402900087009846291167287676911113310671001067916215975654619357943078675057781284419971876364188201285756254849493795101184689472972451252559267516902582277554505702670110528791300961267369272080284734306320521513748467464633545459859474195548892296577923424451509458569436363709731572253846238252647161985685432295738082766877396752019943012580636589164644125010073946413108951305564059881537794476457602047138719485228161010739405064157783241778448944470473298163156034126054406807297456937129548816176179704045207131224909988357244665869859061263890702529905040557579134990132844969289396259
c3=5482202777490716534742001860730733245703162680164829063899425154796149111749426755752696933474476315957195654145886661833161128752650489114348801850277281013599078248459234726247608999052658393093261773012085995729908722425867518715231403283837324730986276769991562455242112930535955638946020374499583285967368081356098316200877276281391326176072541717343183325729633161998105304336388217903809696260815719456619790067591554832909766088841683629739632809828420661566086443444796658031348007908713779060772794447103923388464348339614504047304444504066194611260026519898801631578959669217929301004775518173581480779628

pq = n
paq = (peiqi-n-520*520)//520

a=gmpy2.mpz(1)
b=gmpy2.mpz(-paq)
c=gmpy2.mpz(n)
i=gmpy2.mpz(gmpy2.iroot(b*b-4*a*c,2)[0])

x1=(-b-i)//2
x2=(-b+i)//2

p1=x2
q1=x1
p2=x2+2
q2=x1+2

n1_ol=(p1-1)*(q1-1)
n2_ol=(p1+520-1)*(q1+520-1)

d3=gmpy2.invert(e,n2_ol)
m3=gmpy2.powmod(c3,d3,peiqi)
d2=gmpy2.invert(e,n1_ol)
m2=gmpy2.powmod(m3,d2,n)

for i in range(0,30):
	try:
		print(i)
		#m1 = m1 + n 想多了~~
		m1=gmpy2.iroot(m2,i)[0]
		print(hex(m1)[2:])
		'''
		# python2 output
		print(hex(m1)[2:].decode("hex"))
		'''
		# python3 output
		m=hex(m1)[2:]
		print(binascii.unhexlify(m))
	except:
		continue

例题

xctf wtc_rsa_bbq ，n转为16进制后有一堆f后缀，那么我们可以将n+1开根号

给了两个文件，用脚本读取内容

from Crypto.PublicKey import RSA
from Crypto.Util.number import *
from gmpy2 import *
import libnum
c=bytes_to_long(open('cipher.bin','rb').read())
key=RSA.importKey(open('key.pem').read())
n,e=key.n,key.e
print(c)
print(hex(n))
print(e)

于是我们能发现
在这里插入图片描述

n的16进制，后面是一堆f，那么如果我们将n+1就会得到一个非常规整的数，那么我们假设s = sqrt(n+1) 那么n = s^2 - 1，那么p=s-1 ,q =s+1

于是乎直接分解出qp

验证是否正确

assert p * q == n and isPrime(p) and isPrime(q)

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

c = bytes_to_long(open('cipher.bin', 'rb').read())
key = RSA.importKey(open('key.pem').read())
n, e = key.n, key.e
# print(hex(n)[2:])
s = iroot(n + 1, 2)[0]
p = s - 1
q = s + 1
assert p * q == n and isPrime(p) and isPrime(q)
d = inverse(e, (p - 1) * (q - 1))
print(long_to_bytes(pow(c, d, n)))

不止一个pi---------即约剩余系

from flag import flag
from Crypto.Util.number import *
import gmpy2
p = getPrime(1024)
q = getPrime(1024)
n = p**3*q**2
print("q = ",q)
print("p = ",p)
m = bytes_to_long(flag.encode())
c = pow(m,65537,n)
print("c = ",c)

# q =  115478867870347527660680329271012852043845868401928361076102779938370270670897498759391844282137149013845956612257534640259997979275610235395706473965973203544920469416283181677660262509481282536465796731401967694683575843183509430017972506752901270887444490905891490955975762524187534052478173966117471143713
# p =  171790960371317244087615913047696670778115765201883835525456016207966048658582417842936925149582378305610304505530997833147251832289276125084339614808085356814202236463900384335878760177630501950384919794386619363394169016560485152083893183420911295712446925318391793822371390439655160077212739260871923935217
# c =  4459183928324369762397671605317600157512712503694330767938490496225669985050002776253470841193156951087663107866714426230222002399666306287642591077990897883174134404896800482234781531592939043551832049756571987010173667074168282355520711905659013076509353523088583347373358980842707686611157050425584598825151399870268083867269912139634929397957514376826145870752116583185351576051776627208882377413433140577461314504762388617595282085102271510792305560608934353515552201553674287954987323321512852114353266359364282603487098916608302944694600227628787791876600901537888110093703612414836676571562487005330299996908873589228072982641114844761980143047920770114535924959765518365614709272297666231481655857243004072049094078525569460293381479558148506346966064906164209362147313371962567040047084516510135054571080612077333228195608109065475260832580192321853906138811139036658485688320161530131239854003996457871663456850196483520239675981391047452381998620386899101820782421605287708727667663038905378115235163773867508258208867367314108701855709002634592329976912239956212490788262396106230191754680813790425433763427315230330459349320412354189010684525105318610102936715203529222491642807382215023468936755584632849348996666528981269240867612068382243822300418856599418223875522408986596925018975565057696218423036459144392625166761522424721268971676010427096379610266649911939139451989246194525553533699831110568146220347603627745407449761792135898110139743498767543521297525802809254842518002190381508964357001211353997061417710783337

在这里插入图片描述

这里就是对phi进行了变化，不是以前简单的都-1相乘

但也很简单

import gmpy2
from Crypto.Util.number import long_to_bytes

q = 115478867870347527660680329271012852043845868401928361076102779938370270670897498759391844282137149013845956612257534640259997979275610235395706473965973203544920469416283181677660262509481282536465796731401967694683575843183509430017972506752901270887444490905891490955975762524187534052478173966117471143713
p = 171790960371317244087615913047696670778115765201883835525456016207966048658582417842936925149582378305610304505530997833147251832289276125084339614808085356814202236463900384335878760177630501950384919794386619363394169016560485152083893183420911295712446925318391793822371390439655160077212739260871923935217
c = 4459183928324369762397671605317600157512712503694330767938490496225669985050002776253470841193156951087663107866714426230222002399666306287642591077990897883174134404896800482234781531592939043551832049756571987010173667074168282355520711905659013076509353523088583347373358980842707686611157050425584598825151399870268083867269912139634929397957514376826145870752116583185351576051776627208882377413433140577461314504762388617595282085102271510792305560608934353515552201553674287954987323321512852114353266359364282603487098916608302944694600227628787791876600901537888110093703612414836676571562487005330299996908873589228072982641114844761980143047920770114535924959765518365614709272297666231481655857243004072049094078525569460293381479558148506346966064906164209362147313371962567040047084516510135054571080612077333228195608109065475260832580192321853906138811139036658485688320161530131239854003996457871663456850196483520239675981391047452381998620386899101820782421605287708727667663038905378115235163773867508258208867367314108701855709002634592329976912239956212490788262396106230191754680813790425433763427315230330459349320412354189010684525105318610102936715203529222491642807382215023468936755584632849348996666528981269240867612068382243822300418856599418223875522408986596925018975565057696218423036459144392625166761522424721268971676010427096379610266649911939139451989246194525553533699831110568146220347603627745407449761792135898110139743498767543521297525802809254842518002190381508964357001211353997061417710783337
e = 65537
n = p ** 3 * q ** 2
print(f'n={n}')
phi = p*p * (p - 1) * q * (q - 1)
d = gmpy2.invert(e, phi)
m = pow(c, d, n)
print(long_to_bytes(m))

Rabin’s RSA

考的是一个新的加密方法rabin的加密

from Crypto.Util.number import *
from secret import flag
p = getPrime(64)
q = getPrime(64)
assert p % 4 == 3
assert q % 4 == 3

n = p * q

e = 2
m = bytes_to_long(flag)

c = pow(m,e,n)

print('n =', n)
print('c =', c)

# n = 201354090531918389422241515534761536573
# c = 20442989381348880630046435751193745753

非常明显的rabin加密方式，那么就是分解n得出pq，从而带入求解

import gmpy2
import codecs

def squareMod(c, mod):          # 模意义下开根，找到 x, 使得 x^2 % mod = c
    assert(mod % 4 == 3)
    res = gmpy2.powmod(c, (mod+1)//4, mod)
    return res, mod - res

def getPlaintext(x, y, p, q):   # 假设 m%p=x, m%q=y, 求明文
    res = x*q*gmpy2.invert(q, p) + y*p*gmpy2.invert(p, q)
    return res % (p*q)

def solve(c, p, q):             # 已知 p,q, 解密 c
    px = squareMod(c, p)
    py = squareMod(c, q)

    for x in px:
        for y in py:
            yield getPlaintext(x, y, p, q)

c = open('flag.enc', 'rb').read()
c = int(codecs.encode(c, 'hex'), base=16)

p = 275127860351348928173285174381581152299
q = 319576316814478949870590164193048041239

for msg in solve(c, p, q):
    res = hex(msg)[2:]
    if len(res) % 2 == 1:
        res = '0' + res

    print(codecs.decode(res, 'hex'))

[SWPU 2020]happy 求解方程

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

二元方程求解

from gmpy2 import mpz, root
from sympy import symbols, Eq, solve

c = 0x7a7e031f14f6b6c3292d11a41161d2491ce8bcdc67ef1baa9e
e = 0x872a335
k1 = mpz(1285367317452089980789441829580397855321901891350429414413655782431779727560841427444135440068248152908241981758331600586)
k2 = mpz(1109691832903289208389283296592510864729403914873734836011311325874120780079555500202475594)

# 定义符号变量
p, q = symbols('p q')
#sympy 定义符号变量 p 和 q

# 定义方程
eq1 = Eq(q + q * p**3, k1)
eq2 = Eq(q * p + q * p**2, k2)

# 从第一个方程解出 q
q_expr = solve(eq1, q)[0]

# 将 q 的表达式代入第二个方程
eq3 = Eq(q_expr * p + q_expr * p**2, k2)

# 解关于 p 的方程
p_solutions = solve(eq3, p)

# 输出 p 的解
for p_sol in p_solutions:
    print(f"p = {p_sol}")
    q_sol = q_expr.subs(p, p_sol)
    print(f"q = {q_sol}")

在这里插入图片描述

很明显第二才是

pq已知正常解

import gmpy2
from Crypto.Util.number import long_to_bytes
from gmpy2 import mpz, root
from sympy import symbols, Eq, solve

c = 0x7a7e031f14f6b6c3292d11a41161d2491ce8bcdc67ef1baa9e
e = 0x872a335

p = 1158310153629932205401500375817
q = 827089796345539312201480770649

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

[鹤城杯 2021]Crazy_Rsa_Tech 低加密指数广播攻击

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]

很明显的提示，直接上脚本

import gmpy2
from Crypto.Util.number import long_to_bytes


def crt(b, m):
    '''中国剩余定理'''
    # 判断是否互素
    for i in range(len(m)):
        for j in range(i + 1, len(m)):
            if gmpy2.gcd(m[i], m[j]) != 1:
                print("m中含有不是互余的数")
                return -1
    # 乘积
    M = 1
    for i in range(len(m)):
        M *= m[i]
    # 求M/mi
    Mm = []
    for i in range(len(m)):
        Mm.append(M // m[i])
    # 求Mm[i]的乘法逆元
    Mm_ = []
    for i in range(len(m)):
        _, a, _ = gmpy2.gcdext(Mm[i], m[i])
        Mm_.append(int(a % m[i]))
    # 求MiM'ibi的累加
    y = 0
    for i in range(len(m)):
        print(Mm[i] * Mm_[i] * b[i])
        y += (Mm[i] * Mm_[i] * b[i])
    y = y % M
    return y

#
# enc = [{
#            "c": 7366067574741171461722065133242916080495505913663250330082747465383676893970411476550748394841437418105312353971095003424322679616940371123028982189502042,
#            "e": 10,
#            "n": 25162507052339714421839688873734596177751124036723831003300959761137811490715205742941738406548150240861779301784133652165908227917415483137585388986274803},
#        {
#            "c": 21962825323300469151795920289886886562790942771546858500842179806566435767103803978885148772139305484319688249368999503784441507383476095946258011317951461,
#            "e": 10,
#            "n": 23976859589904419798320812097681858652325473791891232710431997202897819580634937070900625213218095330766877190212418023297341732808839488308551126409983193},
#        {
#            "c": 6569689420274066957835983390583585286570087619048110141187700584193792695235405077811544355169290382357149374107076406086154103351897890793598997687053983,
#            "e": 10,
#            "n": 18503782836858540043974558035601654610948915505645219820150251062305120148745545906567548650191832090823482852604346478335353784501076761922605361848703623},
#        {
#            "c": 4508246168044513518452493882713536390636741541551805821790338973797615971271867248584379813114125478195284692695928668946553625483179633266057122967547052,
#            "e": 10,
#            "n": 23383087478545512218713157932934746110721706819077423418060220083657713428503582801909807142802647367994289775015595100541168367083097506193809451365010723},
#        {
#            "c": 22966105670291282335588843018244161552764486373117942865966904076191122337435542553276743938817686729554714315494818922753880198945897222422137268427611672,
#            "e": 10,
#            "n": 31775649089861428671057909076144152870796722528112580479442073365053916012507273433028451755436987054722496057749731758475958301164082755003195632005308493},
#        {
#            "c": 17963313063405045742968136916219838352135561785389534381262979264585397896844470879023686508540355160998533122970239261072020689217153126649390825646712087,
#            "e": 10,
#            "n": 22246342022943432820696190444155665289928378653841172632283227888174495402248633061010615572642126584591103750338919213945646074833823905521643025879053949},
#        {
#            "c": 1652417534709029450380570653973705320986117679597563873022683140800507482560482948310131540948227797045505390333146191586749269249548168247316404074014639,
#            "e": 10,
#            "n": 25395461142670631268156106136028325744393358436617528677967249347353524924655001151849544022201772500033280822372661344352607434738696051779095736547813043},
#        {
#            "c": 15585771734488351039456631394040497759568679429510619219766191780807675361741859290490732451112648776648126779759368428205194684721516497026290981786239352,
#            "e": 10,
#            "n": 32056508892744184901289413287728039891303832311548608141088227876326753674154124775132776928481935378184756756785107540781632570295330486738268173167809047},
#        {
#            "c": 8965123421637694050044216844523379163347478029124815032832813225050732558524239660648746284884140746788823681886010577342254841014594570067467905682359797,
#            "e": 10,
#            "n": 52849766269541827474228189428820648574162539595985395992261649809907435742263020551050064268890333392877173572811691599841253150460219986817964461970736553},
#        {
#            "c": 13560945756543023008529388108446940847137853038437095244573035888531288577370829065666320069397898394848484847030321018915638381833935580958342719988978247,
#            "e": 10,
#            "n": 30415984800307578932946399987559088968355638354344823359397204419191241802721772499486615661699080998502439901585573950889047918537906687840725005496238621}]
#


# e = 10
# c = []
# n = []
#
# for i in range(len(enc)):
#     c.append(enc[i]["c"])
#     n.append(enc[i]["n"])

n = [71189786319102608575263218254922479901008514616376166401353025325668690465852130559783959409002115897148828732231478529655075366072137059589917001875303598680931962384468363842379833044123189276199264340224973914079447846845897807085694711541719515881377391200011269924562049643835131619086349617062034608799, 92503831027754984321994282254005318198418454777812045042619263533423066848097985191386666241913483806726751133691867010696758828674382946375162423033994046273252417389169779506788545647848951018539441971140081528915876529645525880324658212147388232683347292192795975558548712504744297104487514691170935149949, 100993952830138414466948640139083231443558390127247779484027818354177479632421980458019929149817002579508423291678953554090956334137167905685261724759487245658147039684536216616744746196651390112540237050493468689520465897258378216693418610879245129435268327315158194612110422630337395790254881602124839071919, 59138293747457431012165762343997972673625934330232909935732464725128776212729547237438509546925172847581735769773563840639187946741161318153031173864953372796950422229629824699580131369991913883136821374596762214064774480548532035315344368010507644630655604478651898097886873485265848973185431559958627423847, 66827868958054485359731420968595906328820823695638132426084478524423658597714990545142120448668257273436546456116147999073797943388584861050133103137697812149742551913704341990467090049650721713913812069904136198912314243175309387952328961054617877059134151915723594900209641163321839502908705301293546584147, 120940513339890268554625391482989102665030083707530690312336379356969219966820079510946652021721814016286307318930536030308296265425674637215009052078834615196224917417698019787514831973471113022781129000531459800329018133248426080717653298100515701379374786486337920294380753805825328119757649844054966712377, 72186594495190221129349814154999705524005203343018940547856004977368023856950836974465616291478257156860734574686154136925776069045232149725101769594505766718123155028300703627531567850035682448632166309129911061492630709698934310123778699316856399909549674138453085885820110724923723830686564968967391721281, 69105037583161467265649176715175579387938714721653281201847973223975467813529036844308693237404592381480367515044829190066606146105800243199497182114398931410844901178842049915914390117503986044951461783780327749665912369177733246873697481544777183820939967036346862056795919812693669387731294595126647751951, 76194219445824867986050004226602973283400885106636660263597964027139613163638212828932901192009131346530898961165310615466747046710743013409318156266326090650584190382130795884514074647833949281109675170830565650006906028402714868781834693473191228256626654011772428115359653448111208831188721505467497494581]
c = [62580922178008480377006528793506649089253164524883696044759651305970802215270721223149734532870729533611357047595181907404222690394917605617029675103788705320032707977225447998111744887898039756375876685711148857676502670812333076878964148863713993853526715855758799502735753454247721711366497722251078739585, 46186240819076690248235492196228128599822002268014359444368898414937734806009161030424589993541799877081745454934484263188270879142125136786221625234555265815513136730416539407710862948861531339065039071959576035606192732936477944770308784472646015244527805057990939765708793705044236665364664490419874206900, 85756449024868529058704599481168414715291172247059370174556127800630896693021701121075838517372920466708826412897794900729896389468152213884232173410022054605870785910461728567377769960823103334874807744107855490558726013068890632637193410610478514663078901021307258078678427928255699031215654693270240640198, 14388767329946097216670270960679686032536707277732968784379505904021622612991917314721678940833050736745004078559116326396233622519356703639737886289595860359630019239654690312132039876082685046329079266785042428947147658321799501605837784127004536996628492065409017175037161261039765340032473048737319069656, 1143736792108232890306863524988028098730927600066491485326214420279375304665896453544100447027809433141790331191324806205845009336228331138326163746853197990596700523328423791764843694671580875538251166864957646807184041817863314204516355683663859246677105132100377322669627893863885482167305919925159944839, 2978800921927631161807562509445310353414810029862911925227583943849942080514132963605492727604495513988707849133045851539412276254555228149742924149242124724864770049898278052042163392380895275970574317984638058768854065506927848951716677514095183559625442889028813635385408810698294574175092159389388091981, 16200944263352278316040095503540249310705602580329203494665614035841657418101517016718103326928336623132935178377208651067093136976383774189554806135146237406248538919915426183225265103769259990252162411307338473817114996409705345401251435268136647166395894099897737607312110866874944619080871831772376466376, 31551601425575677138046998360378916515711528548963089502535903329268089950335615563205720969393649713416910860593823506545030969355111753902391336139384464585775439245735448030993755229554555004154084649002801255396359097917380427525820249562148313977941413268787799534165652742114031759562268691233834820996, 25288164985739570635307839193110091356864302148147148153228604718807817833935053919412276187989509493755136905193728864674684139319708358686431424793278248263545370628718355096523088238513079652226028236137381367215156975121794485995030822902933639803569133458328681148758392333073624280222354763268512333515]
e = 9

r = crt(c, n)

print(gmpy2.iroot(r, e))
flag = gmpy2.iroot(r, e)[0]
print(long_to_bytes(flag))

[SWPUCTF 2021 新生赛]crypto5 低加密指数小明文 + e的猜测

flag= 25166751653530941364839663846806543387720865339263370907985655775152187319464715737116599171477207047430065345882626259880756839094179627032623895330242655333
n= 134109481482703713214838023035418052567000870587160796935708584694132507394211363652420160931185332280406437290210512090663977634730864032370977407179731940068634536079284528020739988665713200815021342700369922518406968356455736393738946128013973643235228327971170711979683931964854563904980669850660628561419

明显n比flag大很多

猜测是低加密，但是不知道e，那就爆破尝试

# -*- coding: cp936 -*-
import binascii

import gmpy2

p = 12567387145159119014524309071236701639759988903138784984758783651292440613056150667165602473478042486784826835732833001151645545259394365039352263846276073
q = 12716692565364681652614824033831497167911028027478195947187437474380470205859949692107216740030921664273595734808349540612759651241456765149114895216695451
c = 25166751653530941364839663846806543387720865339263370907985655775152187319464715737116599171477207047430065345882626259880756839094179627032623895330242655333
n = 134109481482703713214838023035418052567000870587160796935708584694132507394211363652420160931185332280406437290210512090663977634730864032370977407179731940068634536079284528020739988665713200815021342700369922518406968356455736393738946128013973643235228327971170711979683931964854563904980669850660628561419
e = 3

print('n=', n)
print('c=', c)

print('[+]Detecting m...')
result = gmpy2.iroot(c, e)

print('  [-]The c has cubic root?', result[1])
print('  [-]The m is:', '{:x}'.format(result[0]))
m = result[0]
print(binascii.unhexlify(hex(m)[2:]))

[RoarCTF2019]babyRSA–威尔逊定理+n=p*q*r

(B!)%Aimport sympy
import random

def myGetPrime():
    A= getPrime(513)
    print(A)
    B=A-random.randint(1e3,1e5)
    print(B)
    return sympy.nextPrime((B!)%A)
p=myGetPrime()
#A1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467234407
#B1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467140596

q=myGetPrime()
#A2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858418927
#B2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858351026

r=myGetPrime()

n=p*q*r
#n=85492663786275292159831603391083876175149354309327673008716627650718160585639723100793347534649628330416631255660901307533909900431413447524262332232659153047067908693481947121069070451562822417357656432171870951184673132554213690123308042697361969986360375060954702920656364144154145812838558365334172935931441424096270206140691814662318562696925767991937369782627908408239087358033165410020690152067715711112732252038588432896758405898709010342467882264362733
c=pow(flag,e,n)
#e=0x1001
#c=75700883021669577739329316795450706204502635802310731477156998834710820770245219468703245302009998932067080383977560299708060476222089630209972629755965140317526034680452483360917378812244365884527186056341888615564335560765053550155758362271622330017433403027261127561225585912484777829588501213961110690451987625502701331485141639684356427316905122995759825241133872734362716041819819948645662803292418802204430874521342108413623635150475963121220095236776428
#so,what is the flag?

后半段就是一个简单的rsa加密，没什么，主要是求pq，存在一个(B!)%A，给了我们AB，但显然是不能直接去求，太大，超出计算范围，这里就用到一个定理----威尔逊定理

当且仅当p为素数时：( p -1 )! ≡ -1 ( mod p )

于是我们就可以知道

( A -1 )! ≡ -1 ( mod A )
又知道B比A小，那么就是说A-1的阶乘包含B的阶乘，那么可转换为
( A -1 )(A-2)....(B+1)(B!) ≡ -1 ( mod A )
在转，由于A-1对A取模也是-1，所以二者相约，得
(A-2)....(B+1)(B!) mod A = 1 ( mod A )
那么B! % A 的结果就是(A-2)....(B+1) (mod A)的逆元
那么现在就可以去写代码求解


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


def get_p_q(A, B):
    tmp = 1
    for i in range(B + 1, A - 1):
        tmp *= i
        tmp %= A

    tmp_imv = gmpy2.invert(tmp, A)  # 模反函数，即求对tmp模A后的逆元
    re = sympy.nextprime(tmp_imv)
    return re


A1 = 21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467234407
B1 = 21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467140596

A2 = 16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858418927
B2 = 16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858351026

n = 85492663786275292159831603391083876175149354309327673008716627650718160585639723100793347534649628330416631255660901307533909900431413447524262332232659153047067908693481947121069070451562822417357656432171870951184673132554213690123308042697361969986360375060954702920656364144154145812838558365334172935931441424096270206140691814662318562696925767991937369782627908408239087358033165410020690152067715711112732252038588432896758405898709010342467882264362733
e = 0x1001
c = 75700883021669577739329316795450706204502635802310731477156998834710820770245219468703245302009998932067080383977560299708060476222089630209972629755965140317526034680452483360917378812244365884527186056341888615564335560765053550155758362271622330017433403027261127561225585912484777829588501213961110690451987625502701331485141639684356427316905122995759825241133872734362716041819819948645662803292418802204430874521342108413623635150475963121220095236776428

p = get_p_q(A1, B1)
q = get_p_q(A2, B2)
r = n // p // q
print(r)
phi = (p - 1) * (q - 1) * (r - 1)
d = gmpy2.invert(e, phi)
f = pow(c, d, n)
print(long_to_bytes(f))

[SWPUCTF 2021 新生赛]crypto1 e1e2m1m2n且e1e2的积

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




n = 609305637099654478882754880905638123124918364116173050874864700996165096776233155524277418132679727857702738043786588380577485490575591029930152718828075976000078971987922107645530323356525126496562423491563365836491753476840795804040219013880969539154444387313029522565456897962200817021423704204077133003361140660038327458057898764857872645377236870759691588009666047187685654297678987435769051762120388537868493789773766688347724903911796741124237476823452505450704989455260077833828660552130714794889208291939055406292476845194489525212129635173284301782141617878483740788532998492403101324795726865866661786740345862631916793208037250277376942046905892342213663197755010315060990871143919384283302925469309777769989798197913048813940747488087191697903624669415774198027063997058701217124640082074789591591494106726857376728759663074734040755438623372683762856958888826373151815914621262862750497078245369680378038995425628467728412953392359090775734440671874387905724083226246587924716226512631671786591611586774947156657178654343092123117255372954798131265566301316033414311712092913492774989048057650627801991277862963173961355088082419091848569675686058581383542877982979697235829206442087786927939745804017455244315305118437
c1 = 463634070971821449698012827631572665302589213868521491855038966879005784397309389922926838028598122795187584361359142761652619958273094398420314927073008031088375892957173280915904309949716842152249806486027920136603248454946737961650252641668562626310035983343018705370077783879047584582817271215517599531278507300104564011142229942160380563527291388260832749808727470291331902902518196932928128107067117198707209620169906575791373793854773799564060536121390593687449884988936522369331738199522700261116496965863870682295858957952661531894477603953742494526632841396338388879198270913523572980574440793543571757278020533565628285714358815083303489096524318164071888139412436112963845619981511061231001617406815056986634680975142352197476024575809514978857034477688443230263761729039797859697947454810551009108031457294164840611157524719173343259485881089252938664456637673337362424443150013961181619441267926981848009107466576314685961478748352388452114042115892243272514245081604607798243817586737546663059737344687130881861357423084448027959893402445303299089606081931041217035955143939567456782107203447898345284731038150377722447329202078375870541529539840051415759436083384408203659613313535094343772238691393447475364806171594
c2 = 130959534275704453216282334815034647265875632781798750901627773826812657339274362406246297925411291822193191483409847323315110393729020700526946712786793380991675008128561863631081095222226285788412970362518398757423705216112313533155390315204875516645459370629706277876211656753247984282379731850770447978537855070379324935282789327428625259945250066774049650951465043700088958965762054418615838049340724639373351248933494355591934236360506778496741051064156771092798005112534162050165095430065000827916096893408569751085550379620558282942254606978819033885539221416335848319082054806148859427713144286777516251724474319613960327799643723278205969253636514684757409059003348229151341200451785288395596484563480261212963114071064979559812327582474674812225260616757099890896900340007990585501470484762752362734968297532533654846190900571017635959385883945858334995884341767905619567505341752047589731815868489295690574109758825021386698440670611361127170896689015108432408490763723594673299472336065575301681055583084547847733168801030191262122130369687497236959760366874106043801542493392227424890925595734150487586757484304609945827925762382889592743709682485229267604771944535469557860120878491329984792448597107256325783346904408
e1e2 = 3087

import libnum
import gmpy2


def rsa_gong_N_def(e1, e2, c1, c2, n):  # 共模攻击函数
    e1, e2, c1, c2, n = int(e1), int(e2), int(c1), int(c2), int(n)
    print("e1,e2:", e1, e2)
    s = gmpy2.gcdext(e1, e2)
    print("mpz:", 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 de(c, e, n):  # 因为此时的m不是真正的m，而是m^k，所以对m^k进行爆破
    k = 0
    while k < 1000:  # 指定k小于1000
        mk = c + n * k
        flag, true1 = gmpy2.iroot(mk, e)  # 返回的第一个数值为开方数，第二个数值为布尔型，可整除为true，可自行测试
        if True == true1:
            # print(libnum.n2s(int(flag)))
            return flag
        k += 1


for e1 in range(2, e1e2):
    if e1e2 % e1 == 0:  # 爆破可整除的e
        e2 = e1e2 // e1
        c = rsa_gong_N_def(e1, e2, c1, c2, n)
        e = gmpy2.gcd(e1, e2)
        m1 = de(c, e, n)
        if m1:  # 指定输出m1
            print(libnum.n2s(int(m1)))

[BJDCTF 2020]EasyRSA Fraction的了解 + 列方程

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

'''

在这里插入图片描述

7922547866857761459807491502654216283012776177789511549350672958101810281348402284098310147796549430689253803510994877420135537268549410652654479620858691324110367182025648788407041599943091386227543182157746202947099572389676084392706406084307657000104665696654409155006313203957292885743791715198781974205578654792123191584957665293208390453748369182333152809882312453359706147808198922916762773721726681588977103877454119043744889164529383188077499194932909643918696646876907327364751380953182517883134591810800848971719184808713694342985458103006676013451912221080252735948993692674899399826084848622145815461035
32115748677623209667471622872185275070257924766015020072805267359839059393284316595882933372289732127274076434587519333300142473010344694803885168557548801202495933226215437763329280242113556524498457559562872900811602056944423967403777623306961880757613246328729616643032628964072931272085866928045973799374711846825157781056965164178505232524245809179235607571567174228822561697888645968559343608375331988097157145264357626738141646556353500994924115875748198318036296898604097000938272195903056733565880150540275369239637793975923329598716003350308259321436752579291000355560431542229699759955141152914708362494482
from gmpy2 import *
from Crypto.Util.number import long_to_bytes
c = 7922547866857761459807491502654216283012776177789511549350672958101810281348402284098310147796549430689253803510994877420135537268549410652654479620858691324110367182025648788407041599943091386227543182157746202947099572389676084392706406084307657000104665696654409155006313203957292885743791715198781974205578654792123191584957665293208390453748369182333152809882312453359706147808198922916762773721726681588977103877454119043744889164529383188077499194932909643918696646876907327364751380953182517883134591810800848971719184808713694342985458103006676013451912221080252735948993692674899399826084848622145815461035
z = 32115748677623209667471622872185275070257924766015020072805267359839059393284316595882933372289732127274076434587519333300142473010344694803885168557548801202495933226215437763329280242113556524498457559562872900811602056944423967403777623306961880757613246328729616643032628964072931272085866928045973799374711846825157781056965164178505232524245809179235607571567174228822561697888645968559343608375331988097157145264357626738141646556353500994924115875748198318036296898604097000938272195903056733565880150540275369239637793975923329598716003350308259321436752579291000355560431542229699759955141152914708362494482
n = 15310745161336895413406690009324766200789179248896951942047235448901612351128459309145825547569298479821101249094161867207686537607047447968708758990950136380924747359052570549594098569970632854351825950729752563502284849263730127586382522703959893392329333760927637353052250274195821469023401443841395096410231843592101426591882573405934188675124326997277775238287928403743324297705151732524641213516306585297722190780088180705070359469719869343939106529204798285957516860774384001892777525916167743272419958572055332232056095979448155082465977781482598371994798871917514767508394730447974770329967681767625495394441
e = 0x10001

ppq = iroot(z+2*n, 2)[0]
psq = iroot(z-2*n, 2)[0]
p = (ppq + psq) // 2
q = (ppq - psq) // 2

d = invert(e, (p-1)*(q-1))
print(long_to_bytes(powmod(c, int(d), n)))

[LitCTF 2023]yafu (中级) n分解成多个小的乘积

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

m = bytes_to_long(flag)
n  = 1
for i in range(15):
    n *=getPrime(32)
e = 65537
c = pow(m,e,n)
print(f'n = {n}')
print(f'c = {c}')
'''
n = 15241208217768849887180010139590210767831431018204645415681695749294131435566140166245881287131522331092026252879324931622292179726764214435307
c = 12608550100856399369399391849907846147170257754920996952259023159548789970041433744454761458030776176806265496305629236559551086998780836655717
'''

import gmpy2
from Crypto.Util.number import *
import libnum
e = 65537
n = 15241208217768849887180010139590210767831431018204645415681695749294131435566140166245881287131522331092026252879324931622292179726764214435307
c = 12608550100856399369399391849907846147170257754920996952259023159548789970041433744454761458030776176806265496305629236559551086998780836655717
f_list=libnum.factorize(n)
print(f_list)
phi=1
for f in f_list:
    phi*=(f-1)*f**(f_list[f]-1)
d=gmpy2.invert(e,phi)
print(long_to_bytes(pow(c,d,n)))
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
信息系统安全知识点总结
Steve·Curcy
06-21 4704
细节内容请参照LowBee 信息系统安全客观题-选择客观题-填空主观题演讲内容名词解释零知识证明DSAHMQV 客观题-选择 安全管理评估工具通常不包括（D） A 问卷调查    B 检查列表 C 访谈提纲    D 漏洞扫描 以下那组全部都是多边安全模型（C） A BLP和BIBA    B BIBA和C-W C BN和BMA    D C-W和BN 客观题-填空 计算机病毒的生命周期一般包括：潜伏、传播、触发和发作四个阶段 网络信息安全攻击的阶段包括：侦查、扫描、获取访问、维持访问和掩盖行踪 用
BUU-Crypto-RSA刷题记录(1)
luoluopeach
09-28 712
写在前面的： RSA在比赛中特别常见，不熟悉原理的话可以看看这两篇文章 RSA加密算法详细解说 RSA的自我介绍(1) 1.RSA 题目： 在一次RSA密钥对生成中，假设p=473398607161，q=4511491，e=17 求解出d作为flga提交 方法一：使用RSA-Tool得到d 方法二： // import gmpy2 e = 17 p = 473398607161 q = 4511491 phi = (p-1)*(q-1) d = gmpy2.invert(e,phi) print(d
二、RSA加密
weixin_43234021的博客
10-16 4172
CTF中的RSA及攻击方法笔记1 数论基础1.1 模运算规则2 RSA相关题目2.1 已知 n，e，c 求 m2.2 已知 p，q，e 求 d2.3 已知dp，dq，c，p，q 求m2.4 仅已知c，c特别大 【c = m^e mod n】2.5 已知n1，n2，c1，c2，n 求 m2.6 已知n1，n2，e，c2 求m2.7 已知e，d，N 求p，q 1 数论基础 参考链接：https://www.freebuf.com/articles/web/257835.html 1.1 模运算规则 模运算与基
CTF中关于RSA的常见题型
abtgu的博客
09-11 1万+
CTF中关于RSA的常见题型 关RSA算法原理的描述请看https://blog.youkuaiyun.com/weixin_43790779/article/details/105622327 1.已知(p, q, e)，求d。 示例：【CTF秀-crypto4】 p=447685307 q=2037 e=17，提交flag{d}即可。 解题思路： import gmpy2 p = 447685307 q = 2037 e = 17 phi = (p-1)*(q-1) d = gmpy2.invert(e,phi
RSA例题一
weixin_30466421的博客
08-22 712
首先看题目： e=3 n=2288548090746910915994727233356537510931048506721146154388138671820144210696791485247498917617526961222996646116006587231091609614821625342984992198841234273270687599810033775...
RSA基础题型
Mark的博客
10-29 984
1、RSAROLL 题目介绍： RSA roll！roll！roll！ Only number and a-z （don’t use editor which MS provide） 然后是题目： {920139713,19} 704796792 752211152 274704164 18414022 368270835 483295235 263072905 459788476 483295235 459788476 663551792 475206804 459788476 428313374 47
CTF ——crypto ——RSA原理及各种题型总结
热门推荐
小锤队长的博客
09-23 6万+
RSA原理及各种题型总结 Table of Contents 一，原理： 信息传递的过程： rsa加密的过程： 二，CTF 中的 常见的十种类型： 1，已知 p ，q，e 求 d？ 2，已知 n（比较小），e 求 d？ 3，已知 公钥（n, e） 和 密文 c 求 明文 m？ 4，已知密文文件 flag.enc / cipher.bin /flag.b64和 公钥文件 ...
asc量子计算机,[推荐][原创]CTF-RSA常见题型、思路及解法
weixin_33411250的博客
07-22 1341
RSA入门:写在前面:这篇文章是帮助对RSA不熟悉的朋友且需要较为快速、深入的了解RSA而写的不涉及非常晦涩难懂的数学知识和算法(不过最简单的原理说明还是有的)攻击方法也是最容易遇到的(RSA的进阶篇除外)并且所有的例题都是比较新的,甚至还有刚刚结束的比赛的题目基本原理:公钥与私钥的产生：(1)进行加密之前，首先找出2个不同的大质数p和q(2)计算n=p*q(3)根据欧拉函数，求得φ(n)=φ(p...
【算法基础总结】算法基础 (算法竞赛，面试...)
Skyed_blue的博客
03-16 2933
算法基础 ​ （By: Skyed_blue 转载注明作者) 文章目录算法基础前言dfs(深度优先遍历)bfs(广度优先遍历)二分查找(二分枚举)并查集位运算双指针栈(stack)字典树(trie)前缀和初等数论贪心动态规划(dp)结语 前言 本篇为算法基础整合，主要偏向于对基础算法的总结和整理。本篇将会介绍个人刷算法题的一些经验，基础算法的简要描述，基础算...
RSA2此资源为i春秋上的一道RSA的题目，里面包含题目的附件以及解题用到的工具。
09-04
此资源为i春秋上的一道RSA的题目，里面包含题目的附件以及解题用到的工具。
RSA破解运算题目
06-04
公匙N=1889570071，加密指数e1 = 1021763679，e2 = 519424709 密文c1 = 1244183534 ，c2 = 732959706。
用实例讲解RSA加密算法(精)
05-03
用实例讲解RSA加密算法(精)
RSA算法详解与练习
Atkx's Blog
10-04 6904
RSA算法 1.随机选择两个不相等的质数p和q。 2.计算p和q的乘积n(n=pq),n的长度就是密钥长度。 3.计算n的欧拉函数φ(n)： φ(n) = (p-1)(q-1) 4.随机选择一个整数e，也就是公钥当中用来加密的那个数字 条件是1< e < φ(n)，且e与φ(n) 互质。 5.计算e对于φ(n)的模反元素d。也就是密钥当中用来解密的那个数字 所谓"模反元素"就是指有一个整数d，可以使得ed被φ(n)除的余数为1，ed ≡1 (mod φ(n)) 。 6.将n和e封装成公钥，n和d
RSA算法和习题分析。
weixin_30588729的博客
05-27 838
RSA算法概述如下：找两素数p和q取n=p*q取t=(p-1)*(q-1)取任何一个数e,要求满足e<t并且e与t互素（就是最大公因数为1）取d*e%t==1这样最终得到三个数： nde设消息为数M (M <n)设c=(M**d)%n就得到了加密后的消息c 设m=(c**e)%n则 m == M，从而完成对c的解密。注：**表示次方,上面两式中的d和e可以互换。在对称加密中：n...
buu [GUET-CTF2019]BabyRSA
ao52426055的博客
12-01 1490
查看题目 观察题目给的条件，给了p+q，（p+1)(q+1)，e，d,以及密文C. RSA的解密公式：M=C^d mod n 所以我们只要求出n即可。(n = pq) n = (p+1)(q+1) - (p+q) - 1 求M的值，已知C，d，n后 用函数pow(),即可求出 import libnum a = 0x1232fecb92adead91613e7d9ae5e36fe6bb765317d6ed38ad890b4073539a6231a6620584cea5730b5af83a3e80cf30
#RSA基础入门 (buu选题）
最新发布
m0_73194782的博客
07-17 1208
buu前几道最基础的rsa题目，实时更新
每日一练RSA (20 分)
S_JYYDS的博客
04-17 1318
每日一练RSA (20 分)
公钥体系实例RSA
Zetaa的博客
08-26 826
RSA中为什么涉及大整数的因式分解？ RSA中为什么模数n是由两个质数相乘得来的，1个或者多个质数相乘可不可以呢？ RSA的设计逻辑？ RSA中核心的三个困难问题： 求n以内与n互质的元素的个数，要么就是穷举计算，要么当知道n的因式分解则可以借助欧拉函数直接快速得出计算结果，目前还不存在其他的求解方法。 基于欧拉函数的求解需要知道数n的因式分解，进而引发因式分解的需求，而对于一个很大的数进行因式...
C++实现RSA算法详解与Crypto++库使用
资源摘要信息:"本资源是关于使用Crypto++库中的C++ RSA函数的实现方法。RSA加密算法是一种广泛应用于数据加密和数字签名的非对称加密算法。Crypto++是一个C++标准库，它提供了各种密码学算法的实现，包括但不限于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值