RSA算法过程：生成公钥和私钥：1. 立地生成大素数p，q2. N的欧拉函数 φ(N) = (p-1)(q-1)3. n = pq4. 取公钥e，使得e与φ(N)互质5. 推敲密钥d，使得(e*d)%φ(N) = 16. 公开公钥e和n， 精巧保存私钥d， 阵一火oula女王 调教，p，q加密：m为原文， c为密文c = m^e%n 即 m^e ≡ c (mod n)解密：m为原文， c为密文m = c^d%n 即 c^d ≡ m (mod n)

立地选两个不颠倒的质数61和53，并推敲两数的积N=61*53=3233，N的长度便是密钥长度。3233的二进制是110010100001，一共12位，是以这个密钥便是12位。骨子期骗中，RSA密钥一般是1024位，弥留的方法是2048位。

推敲N的欧拉函数 φ(N)=(p-1)(q-1)=60*52=3120.

在1到3120上立地取舍了一个立地数e与φ(N)互质，e=17。

推敲e对φ(N)的模反元素d，即ed-1=yφ(N)。 （ed不错被φ(N)整除余1(9不错被2整除余1) 即ed-1不错被φ(N)整除(8能被2整除) 即ed-1=yφ(N)）即求解：17x-3120y=1.用膨胀欧几里得算法求解。不错算出一组解(x，y)=(2753，-15)，即d=2753。完成推敲。其中N=3233，e=17，d=2753。是以公钥便是(N，e)=(3233，17)，私钥(N，d)=(3233，2753)。骨子期骗中公钥和私钥皆是取舍ASN.1纪律抒发的。算法一：

#代码小白
import random
from random import randint
 
def is_prime(n):
    """ 判断是否为素数 """
    for i in range(2， n):
        if n % i == 0:
            print('此素数输入失实')
            return 0
    print('素数输入正确')
 
 
def create_prime(start，stop):
    """ 立地生成指定限制内的素数 """
    if start < 2:
        start = 2
    for i in range(start， stop+1):
        for j in range(2， i):
            if i % j == 0:
                break
        else:
            yield i
 
def is_relprime(minv， maxv):
    """ 判断e与oula是否互质 """
    for i in range(2， minv + 1):
        if minv % i == 0 and maxv % i == 0:
            print('e与oula并不互为质数')
            return False
    print('e与oula互为质数')
    return True
 
def compute_prikey(ol，ee):
    """ 推敲私钥 """
    global d， k
    k = 1
    while (k * oula + 1) % e != 0:
        k += 1
    print(f'k={k}')
    d = int((k * oula + 1) / e)
    print(f'd={d}')
 
 
p = int(input("输入一个素数p: "))
is_prime(p)
q = int(input("再输入一个素数q: "))
is_prime(q)
 
n = p * q
print(f'n=p*q={n}')
oula = (p - 1) * (q - 1)
print(f'oula=(p - 1) * (q - 1)={oula}')
 
num=[]
for x in create_prime(0， oula):
    num.append(x)
e = random.choice(num)
print(f'立地质数:e={e}')
 
is_relprime(e，oula)
 
compute_prikey(oula，e)
 
print(f'为你生成的公钥是：(n，e)=({n}，{e})')
print(f'为你生成的私钥是：(n，d)=({n}，{d})')
 
m = int(input("输入需要加密的数据: "))
 
# n = int(input("输入您的公钥前排序列: "))
# e = int(input("输入您的公钥后排序列: "))
c = (m**e)%n
print(f"您赢得的密文是：{c}")
 
n = int(input("输入您的私钥前排序列: "))
d = int(input("输入您的私钥后排序列: "))
 
m = (c**d)%n
print(f'密文的解密遵守为：{m}')

开动遵守：（只能以数字，加密数据大会出错~~~）

巨乳娘大战僵尸

图片

图片

算法二：

'''（复制别东说念主的，找不到出处了~~~）'''
import random
 
'''  迂回相除法求最大协议数'''
def gcd(a， b):
    while b != 0:
        a， b = b， a % b
    return a
'''
欧几里得用于求两个数的乘法逆的膨胀算法
'''
""" 推敲私钥 """
def multiplicative_inverse(e，r):
    for i in range(r):
        if((e*i)%r == 1):
            return i
 
""" 判断是否为素数 """
def is_prime(num) -> object:
    if num == 2:
        return True
    if num < 2 or num % 2 == 0:
        return False
    for n in range(3， int(num ** 0.5) + 2， 2):
        if num % n == 0:
            return False
    return True
 
""" 判断pq是否皆为素数 """
def generate_keypair(p， q):
    if not (is_prime(p) and is_prime(q)):
        raise ValueError('Both numbers must be prime.')
    elif p == q:
        raise ValueError('p and q cannot be equal')
    # n = pq
    n = p * q
 
    # 欧拉函数φ(n)
    oula = (p - 1) * (q - 1)
 
    # 取舍一个整数e，使e和φ(n)为互质
    e = random.randrange(1， oula)
 
    # 用欧几里得算法考据e和φ(n)是互质
    g = gcd(e， oula)
    while g != 1:
        e = random.randrange(1， oula)
        g = gcd(e， oula)
 
    # 使用膨胀欧几里得算法生成私钥
    d = multiplicative_inverse(e， oula)
 
    # 复返全球和独有密钥 ，公钥是(e， n)，私钥是(d， n)
    return ((e， n)， (d， n))
 
 
def encrypt(pk， plaintext):
    # 将密钥解压缩到它的组件中
    key， n = pk
    #使用a^b mod m将明文中的每个字母诊疗为基于字符的数字
    cipher = [(ord(char) ** key) % n for char in plaintext]
    # 复返字节数组
    return cipher
 
 
def decrypt(pk1， pk2， ciphertext):
    #将密钥解压缩到其组件中
    key， n = pk1， pk2
    #把柄密文和密钥使用a^b mod m生成明文
    plain = [chr((char ** key) % n) for char in ciphertext]
    # 以字符串神气复返字节数组
    return ''.join(plain)
 
 
if __name__ == '__main__':
 
    p = int(input("输入一个素数: "))
    q = int(input("再输入一个素数: "))
 
    public， private = generate_keypair(p， q)
    print('为你生成的公钥是：'， public)
    print("为你生成的私钥是："， private)
 
    message = input("输入需要加密的数据: ")
    encrypted_msg = encrypt(public， message)
    print("您赢得的密文是："， ''.join(map(lambda x: str(x)， encrypted_msg)))
 
    privatee = []
    privatee.append(int(input('输入您的私钥前排序列')))
    privatee.append(int(input('输入您的私钥后排序列')))
 
    print('密文的解密遵守为：'， decrypt(privatee[0]， privatee[1]， encrypted_msg))

开动遵守：（不错纯数字、纯字母~~~）

图片

图片

考订：使用python库gmpy2库收场加解密:

参考原文归并：RSA算法之收场篇（Python版）_qmickecs的博客-CSDN博客

import gmpy2
from gmpy2 import mpz
import binascii
 
def gen_prime(rs):
    """生成二进制位数为1024的立地素数"""
    p = gmpy2.mpz_urandomb(rs， 1024)
    while not gmpy2.is_prime(p):
        p = p + 1
    return p
 
def gen_key():
    """生成密钥"""
    rs = gmpy2.random_state()
    p = gen_prime(rs)
    q = gen_prime(rs)
    return p， q
 
def encrypt(e， n， message):
    """将输入音书诊疗成16进制数字并加密，复旧utf-8字符串"""
    M = mpz(binascii.hexlify(message.encode('utf-8'))， 16)
    C = gmpy2.powmod(M， e， n)
    return C
 
def decrypt(d， n， C):
    """对输入的密文进行解密并解码"""
    M = gmpy2.powmod(C， d， n)
    return binascii.unhexlify(format(M， 'x')).decode('utf-8')
 
def main():
    # 密钥生成
    p， q = gen_key()
    n = p * q
    phi = (p - 1) * (q - 1)
    e = 65537
    d = gmpy2.invert(e， phi)
 
    # 输入音书
    message = input('输入待加密的音书：\n')
 
    # 加密
    C = encrypt(e， n， message)
    print('16进制密文：'， hex(C))
 
    # 解密
    print('解密后的音书：'， decrypt(d， n， C))
 
if __name__ == '__main__':
    main()
'''
输入待加密的音书：
34542
16进制密文： 0x56f8a6e0......
解密后的音书： 34542
-----------------
输入待加密的音书：
该怎样的
16进制密文： 0x25a1bca.....
解密后的音书： 该怎样的
-----------------
输入待加密的音书：
htgdhg
16进制密文： 0x6572366a62
解密后的音书： htgdhg
'''

补充：背面一篇Paillier加法同态著述中有补充考据RSA的乘法同态特质vb.net教程C#教程python教程。版权声明：本文为博主原创著述，除名 CC 4.0 BY-SA 版权协议，转载请附上原文出处归并和本声明。

原文归并：https://blog.csdn.net/qq_45286306/article/details/129330963女王 调教

本站仅提供存储就业，通盘内容均由用户发布，如发现存害或侵权内容，请点击举报。