用python写rsa加密和解密

RSA加密和解密可以使用Python中的Crypto模块实现。下面是一个简单的示例：

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

# 生成RSA密钥对
rsa_key = RSA.generate(2048)

# 获取公钥
public_key = rsa_key.publickey()

# 加密数据
cipher = PKCS1_OAEP.new(public_key)
encrypted_data = cipher.encrypt(b'Hello, World!')

# 解密数据
cipher = PKCS1_OAEP.new(rsa_key)
decrypted_data = cipher.decrypt(encrypted_data)

print(decrypted_data.decode())

在这个示例中，我们首先使用`RSA.generate()`函数生成了一个2048位的RSA密钥对，在使用`publickey()`方法获取公钥。然后使用公钥对数据进行加密，密文存储在`encrypted_data`变量中。最后使用私钥对密文进行解密，解密后的明文存储在`decrypted_data`变量中。

相关问题

python 写个 RSA加密解密

好的，下面是一个简单的 Python RSA加密解密程序：

import random
import math

# 模幂运算：计算 (base^exp) % mod
def exp_mode(base, exp, mod):
    result = 1
    while exp > 0:
        if exp % 2 == 1:
            result = (result * base) % mod
        base = (base * base) % mod
        exp = exp // 2
    return result

# 判断是否为质数
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

# 生成指定位数的质数
def generate_prime(bit):
    while True:
        p = random.randint(2**(bit-1), 2**bit-1)
        if is_prime(p):
            return p

# 求最大公约数
def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)

# 扩展欧几里得算法
def exgcd(a, b):
    if b == 0:
        return 1, 0, a
    else:
        x, y, gcd = exgcd(b, a % b)
        return y, x - (a // b) * y, gcd

# 生成 RSA公钥和私钥
def generate_rsa_key(bit):
    p = generate_prime(bit // 2)
    q = generate_prime(bit // 2)
    n = p * q
    phi = (p - 1) * (q - 1)
    e = 65537
    d, _, _ = exgcd(e, phi)
    d = (d % phi + phi) % phi
    return (e, n), (d, n)

# RSA加密
def rsa_encrypt(plaintext, public_key):
    e, n = public_key
    ciphertext = [exp_mode(ord(c), e, n) for c in plaintext]
    return ciphertext

# RSA解密
def rsa_decrypt(ciphertext, private_key):
    d, n = private_key
    plaintext = [chr(exp_mode(c, d, n)) for c in ciphertext]
    return ''.join(plaintext)

# 测试代码
if __name__ == '__main__':
    # 生成 RSA公钥和私钥
    public_key, private_key = generate_rsa_key(1024)

    # 显示公钥和私钥
    print('Public key:', public_key)
    print('Private key:', private_key)

    # 明文和密文
    plaintext = 'Hello, world!'
    ciphertext = rsa_encrypt(plaintext, public_key)
    decrypted_plaintext = rsa_decrypt(ciphertext, private_key)

    # 显示加密和解密结果
    print('Plaintext:', plaintext)
    print('Ciphertext:', ciphertext)
    print('Decrypted plaintext:', decrypted_plaintext)

上面的程序实现了基本的 RSA加密解密功能，生成了一个 1024位的 RSA公钥和私钥，对明文进行加密后再解密，最后输出加密前后的结果。

使用python实现RSA加密解密算法

RSA加密解密算法是一种非对称加密算法，需要使用公钥和私钥进行加密和解密。下面是使用Python实现RSA加密解密算法的示例代码：

import random
from math import gcd

def generate_key(p, q):
    n = p * q
    phi = (p - 1) * (q - 1)
    e = random.randrange(1, phi)
    g = gcd(e, phi)
    while g != 1:
        e = random.randrange(1, phi)
        g = gcd(e, phi)
    d = mod_inverse(e, phi)
    return ((e, n), (d, n))

def mod_inverse(a, m):
    g, x, y = extended_gcd(a, m)
    if g != 1:
        raise Exception('No modular inverse')
    return x % m

def extended_gcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = extended_gcd(b % a, a)
        return (g, x - (b // a) * y, y)

def encrypt(pk, plaintext):
    key, n = pk
    cipher = [pow(ord(char), key, n) for char in plaintext]
    return cipher

def decrypt(pk, ciphertext):
    key, n = pk
    plain = [chr(pow(char, key, n)) for char in ciphertext]
    return ''.join(plain)

p = 61
q = 53
public_key, private_key = generate_key(p, q)

message = 'Hello, world!'
print('Original message:', message)

ciphertext = encrypt(public_key, message)
print('Encrypted message:', ciphertext)

plaintext = decrypt(private_key, ciphertext)
print('Decrypted message:', plaintext)

在上面的实现中，我们首先定义了一些函数来生成RSA密钥、模反元素以及扩展欧几里得算法。然后，我们使用生成的公钥和私钥对原始消息进行加密和解密。