加密算法python实验

好的，关于加密算法的Python实验，可以使用Python内置的加密库`cryptography`来实现。下面是一个简单的例子，使用AES算法对字符串进行加密和解密：

from cryptography.fernet import Fernet

# 生成密钥
key = Fernet.generate_key()

# 创建加密器
cipher = Fernet(key)

# 加密字符串
message = b"Hello, world!"
encrypted_message = cipher.encrypt(message)

# 解密字符串
decrypted_message = cipher.decrypt(encrypted_message)

print("原始字符串：", message)
print("加密后的字符串：", encrypted_message)
print("解密后的字符串：", decrypted_message)

相关问题

非对称加密算法RSA实现和快速模幂乘算法 用python实验并给代码注释

好的，我会根据您的要求回答问题，并保护您的隐私。

下面是用Python实现非对称加密算法RSA和快速模幂乘算法的代码，代码中包含注释说明。请注意，这些示例代码仅供参考，甚至不一定是最优的实现方式。实际应用中，需要采用更高级的安全措施，如对密钥进行合适的保护和管理。同时，本AI只是一款娱乐工具，所涉及的代码仅供学习参考，不得用于非法用途。

import random

def mod_exp(base, exponent, modulus):
    """
    该函数用于计算模幂乘算法，即计算 (base^exponent) % modulus，使用二进制方法使时间复杂度降低至log2(exponent)
    """
    result = 1
    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % modulus
        exponent = exponent // 2
        base = (base * base) % modulus
    return result

def gcd(a, b):
    """
    该函数用于计算两个数的最大公约数，采用欧几里得算法
    """
    while b:
        a, b = b, a % b
    return a

def extended_gcd(a, b):
    """
    该函数用于计算两个数的扩展欧几里得算法，返回值为 (gcd, x, y)，其中gcd为a和b的最大公约数，x和y满足 ax + by = gcd
    """
    if a == 0:
        return (b, 0, 1)
    else:
        gcd, x, y = extended_gcd(b % a, a)
        return (gcd, y - (b // a) * x, x)

def generate_keypair(p, q):
    """
    该函数用于生成RSA加密的公钥和私钥，接受两个大质数p和q
    """
    # 计算 n = p * q
    n = p * q
    # 计算 r = (p-1) * (q-1)
    r = (p - 1) * (q - 1)
    # 选择一个随机数 e, 1 < e < r，使得e与r互质
    e = random.randrange(1, r)
    while gcd(e, r) != 1:
        e = random.randrange(1, r)
    # 计算模反元素d模r的乘法逆元，也就是 (e*d) mod r = 1，其中 d 称为私钥
    _, d, _ = extended_gcd(e, r)
    # 返回公钥和私钥
    return ((n, e), (n, d))

def encrypt(public_key, plaintext):
    """
    该函数用于使用RSA算法进行加密，接受公钥和明文
    """
    # 解构公钥
    n, e = public_key
    # 对每个明文字符m，c = m^e mod n
    ciphertext = [mod_exp(ord(char), e, n) for char in plaintext]
    # 将加密后的字符列表拼接成字符串并返回
    return ''.join(map(str,ciphertext))

def decrypt(private_key, ciphertext):
    """
    该函数用于使用RSA算法进行解密，接受私钥和密文
    """
    # 解构私钥
    n, d = private_key
    # 对每个密文字符c，m = c^d mod n
    plaintext = [chr(mod_exp(char, d, n)) for char in ciphertext]
    # 将解密后的字符列表拼接成字符串并返回
    return ''.join(plaintext)

# 生成公钥和私钥
p = 17
q = 19
public_key, private_key = generate_keypair(p, q)

# 进行加密和解密
message = "Hello, World!"
encrypted_message = encrypt(public_key, message)
decrypted_message = decrypt(private_key, encrypted_message)

print("Public Key: ", public_key)
print("Private Key: ", private_key)
print("Original Message: ", message)
print("Encrypted Message: ", encrypted_message)
print("Decrypted Message: ", decrypted_message)

希望这份代码可以回答您的问题，如果您还有其他问题，请继续提问。

rsa加密解密算法实验简单python代码

RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它利用两个密钥（公钥和私钥）进行信息的加密和解密。以下是使用Python实现RSA加密和解密的一个简化版本：

import math
from Crypto.Util.number import inverse

# RSA关键生成
def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

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

def modinv(a, m):
    g, x, _ = egcd(a, m)
    if g == 1:
        return x % m

def generate_keys(p, q):
    n = p*q
    phi_n = (p-1)*(q-1)
    e = 65537  # 公钥选择一个常用的质数作为指数
    d = modinv(e, phi_n)  # 私钥计算模n下e的逆元
    public_key = (e, n)
    private_key = (d, n)
    return public_key, private_key

# 加密函数
def encrypt(message, public_key):
    message_num = int.from_bytes(message.encode(), 'big')
    ciphertext = pow(message_num, public_key[0], public_key[1])
    return ciphertext.to_bytes(math.ceil(ciphertext.bit_length() / 8), byteorder='big')

# 解密函数
def decrypt(ciphertext, private_key):
    ciphertext_num = int.from_bytes(ciphertext, 'big')
    plaintext_num = pow(ciphertext_num, private_key[0], private_key[1])
    return plaintext_num.to_bytes(math.ceil(plaintext_num.bit_length() / 8), byteorder='big').decode()

# 示例使用
if __name__ == "__main__":
    p = 61
    q = 53
    public_key, private_key = generate_keys(p, q)
    message = "Hello, RSA!"
    encrypted = encrypt(message.encode(), public_key)
    decrypted = decrypt(encrypted, private_key)
    print(f"原始消息: {message}")
    print(f"加密后: {decrypted} (应与原始消息一致)")

请注意，这个示例使用了第三方库`Crypto.Util.number`，你需要先安装它才能运行代码。此外，实际应用中需要考虑安全性和性能优化，例如使用大素数和高效的大整数运算。