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))

上期龙头开出奇数号码05，近10期龙头奇偶比7：3，本期龙头预测关注偶数号码，独胆参考08。

上期奖号和值为97，最近十期和值分别为116 105 118 106 100 103 84 137 64 97，最近十期和值分布在64-137之间。综合分析本期预计红球和值出现在123左右。

运转后果：（不错纯数字、纯字母~~~）

图片

图片

改造：使用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软件开发资讯