Python RSA中的十进制代码太大

我试图用python实现RSA算法，但有时当我执行代码时，数学结果对于十进制代码来说太大，当我尝试解密密码上下文时，结果不是原始字符串。我不知道出了什么问题，请回答我，如果代码是错误的，或者有一种方法可以将大的十进制代码转换为小写

代码如下：

import random

def primes(min, max):
    for i in range(min, max):
        if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 or i % 7 == 0:
            pass
        else:
            yield i
            # print(i)

def gdc(n1, n2):
    while n2:
        n2, n1 = n1 % n2, n2
    return n1

def private_keys(n, phi):
    for i in range(2, phi):
        if gdc(n, i) == 1 and gdc(phi, i) == 1:
            yield i

def public_keys(phi, private_key, maximum):
    for i in range(phi + 1, phi + maximum):
        if i * private_key % phi == 1:
            yield i

def encrypt_string(key, n, string):
    cipher_context = ''
    for word in string:
        word_ascii = ord(word)
        encrypted_word_ascii = word_ascii ** key % n
        print(f'{word_ascii} {encrypted_word_ascii}')
        cipher_context += chr(encrypted_word_ascii)
    return cipher_context

def decrypt_string(key, n, cipher_context):
    plain_text = '' 
    for encrypted_word in cipher_context:
        encrypted_ascii_word = ord(encrypted_word)
        ascii_word = encrypted_ascii_word ** key % n
        print(f'{encrypted_ascii_word} {ascii_word}')
        plain_text += chr(ascii_word)
    return plain_text

minimum = 10
maximum = 200

generated_primes = [i for i in primes(minimum, maximum)]

prime1 = random.choice(generated_primes)
generated_primes.remove(prime1)
prime2 = random.choice(generated_primes)

print(f'Primo 1 (p): {prime1}')
print(f'Primo 2 (q): {prime2}')

n = prime1 * prime2
print(f'n: {n}')

phi = (prime1 - 1) * (prime2 - 1)
print(f'phi: {phi}')

generated_private_keys = [i for i in private_keys(n, phi)]
# print(generated_private_keys)
private_key = random.choice(generated_private_keys)
print(f'Chave privada: {private_key}')

maximum_pub = 100000
generated_public_keys = []
while generated_public_keys == []:
    generated_public_keys = [i for i in public_keys(phi, private_key, maximum_pub)]
    maximum_pub *= 10
#print(generated_public_keys)
public_key = random.choice(generated_public_keys)
print(f'Chave publica: {public_key}')

text = 'Testando exemplo de criptografia RSA'
print(text)

cipher_context = encrypt_string(public_key, n, text)
print(frase_criptografada.encode('utf-16', 'surrogatepass'))

print()

plain_text = decrypt_string(private_key, n, cipher_context)
print(plain_text)

奇怪输出的示例：

Primo 1 (p): 169
Primo 2 (q): 89
n: 15041
phi: 14784
Chave privada: 2557
Chave publica: 71509
Testando exemplo de criptografia RSA
84 2294
101 12893
115 10294
116 8826
97 6974
110 2528
100 8836
111 3010
32 981
101 12893
120 12756
101 12893
109 10392
112 6807
108 5035
111 3010
32 981
100 8836
101 12893
32 981
99 8549
114 10813
105 6683
112 6807
116 8826
111 3010
103 13610
114 10813
97 6974
102 9670
105 6683
97 6974
32 981
82 9195
83 9482
65 9971
b'\xff\xfe\xf6\x08]26(z">\x1b\xe0\t\x84"\xc2\x0b\xd5\x03]2\xd41]2\x98(\x97\x1a\xab\x13\xc2\x0b\xd5\x03\x84"]2\xd5\x03e!=*\x1b\x1a\x97\x1az"\xc2\x0b*5=*>\x1b\xc6%\x1b\x1a>\x1b\xd5\x03\xeb#\n%\xf3&'

2294 9340
12893 8200
10294 12842
8826 4744
6974 8196
2528 7052
8836 8199
3010 3582
981 13916
12893 8200
12756 2434
12893 8200
10392 11679
6807 13996
5035 3579
3010 3582
981 13916
8836 8199
12893 8200
981 13916
8549 99
10813 7056
6683 5890
6807 13996
8826 4744
3010 3582
13610 5888
10813 7056
6974 8196
9670 13986
6683 5890
6974 8196
981 13916
9195 5867
9482 13967
9971 10478
⑼ ㈪ኈ ᮌ ෾㙜 ং ⶟㚬෻෾㙜  㙜cᮐᜂ㚬ኈ෾ᜀᮐ 㚢ᜂ 㙜᛫㚏⣮

---

这里有几个问题

你的素数发生器坏了。在您给出的示例中，169等于132，因此p的这个值没有用处

通常，公共指数（e）是一个固定的小数字，如257或65537。没有必要选择一个大于phi的数字，并且e（71509）大于n（15041）的值毫无意义

您应该使用以下公式计算私有指数（d）。我不相信你使用的方法会给出可靠的结果。（严格来说，无论如何都应该使用。）

显然，加密单个字符不提供安全性。要处理较大的p和q值，需要使用模幂运算。幸运的是，这是Python内置的：

（c**d）%n

可以替换为

pow（c，d，n）

，后者速度快得多，并且对于较大的d值不会崩溃。

sympy

Python库中有许多函数，您可能会发现它们很有用，包括

randprime（）

和

gcdex（）

（扩展欧几里德算法）。只要在命令行中键入

pip install sympy

即可安装它，如果它还不可用的话