用python写一个加密解密

以下是一个简单的加密解密程序：

def encrypt(msg):
    """
    简单的加密函数：将每个字符的ASCII码加上固定值
    """
    key = 5
    encrypted_msg = ""
    for char in msg:
        encrypted_msg += chr(ord(char) + key)
    return encrypted_msg


def decrypt(encrypted_msg):
    """
    简单的解密函数：将每个字符的ASCII码减去固定值
    """
    key = 5
    msg = ""
    for char in encrypted_msg:
        msg += chr(ord(char) - key)
    return msg


# 测试
message = "Hello, World!"
encrypted_message = encrypt(message)
print("加密后的消息：", encrypted_message)
decrypted_message = decrypt(encrypted_message)
print("解密后的消息：", decrypted_message)

输出：

加密后的消息： Mjqqt,%%twqi&
解密后的消息： Hello, World!

当然，这只是一个简单的演示。实际应用中，需要更加复杂和安全的加密算法，例如AES、RSA等。

相关问题

Python写一个RSA加密解密

### 回答1：
好的，以下是一份使用 Python 实现 RSA 加密解密的示例代码：

import rsa

# RSA加密
def rsa_encrypt(plaintext, pub_key):
    # 加密
    ciphertext = rsa.encrypt(plaintext.encode(), pub_key)
    # 返回密文
    return ciphertext

# RSA解密
def rsa_decrypt(ciphertext, pri_key):
    # 解密
    plaintext = rsa.decrypt(ciphertext, pri_key).decode()
    # 返回明文
    return plaintext

# 生成公钥、私钥
(pub_key, pri_key) = rsa.newkeys(512)

# 待加密的明文
plaintext = "RSA encryption test"

# 调用RSA加密函数，进行加密
ciphertext = rsa_encrypt(plaintext, pub_key)

# 调用RSA解密函数，进行解密
decrypted_plaintext = rsa_decrypt(ciphertext, pri_key)

# 输出结果
print("待加密的明文：", plaintext)
print("加密后的密文：", ciphertext)
print("解密后的明文：", decrypted_plaintext)

注意：本代码仅供参考，实际使用中可能需要对代码进行一定的修改。

### 回答2：
RSA加密算法是一种非对称加密算法，可以用来对数据进行加密和解密。以下是使用Python编写的RSA加密解密的示例代码：

import rsa

# 生成RSA密钥对
(public_key, private_key) = rsa.newkeys(512)

# 要加密的原始数据
plaintext = 'Hello, RSA!'

# 使用公钥进行加密
ciphertext = rsa.encrypt(plaintext.encode(), public_key)

# 使用私钥进行解密
decrypted_text = rsa.decrypt(ciphertext, private_key).decode()

print('原始数据：', plaintext)
print('加密后数据：', ciphertext)
print('解密后数据：', decrypted_text)

这段代码使用`rsa`库生成了一个512位长度的RSA密钥对。然后，我们定义了要加密的原始数据`plaintext`为`Hello, RSA!`。接下来，使用公钥`public_key`对原始数据进行加密，加密后的数据存储在`ciphertext`中。最后，使用私钥`private_key`对加密后的数据进行解密，解密后的数据存储在`decrypted_text`中。

运行这段代码，我们可以看到输出结果为：

原始数据： Hello, RSA!
加密后数据： b'\x8e)...\x19'
解密后数据： Hello, RSA!

可以看到，在经过加密和解密过程后，解密后的数据与原始数据完全一致，证明RSA加密解密过程正确无误。

### 回答3：
RSA是一种非对称加密算法，可以用于数据的加密和解密过程。Python提供了一种库叫做`rsa`，可以简化RSA加密和解密过程的实现。

首先，我们需要安装`rsa`库。在终端中运行以下命令：

pip install rsa

安装完毕后，可以开始编写RSA加密和解密程序。

加密过程：

import rsa

# 生成密钥对（公钥和私钥）
(public_key, private_key) = rsa.newkeys(2048)

# 要加密的数据
message = b"Hello, RSA!"

# 使用公钥加密数据
encrypted_message = rsa.encrypt(message, public_key)

# 打印加密后的数据
print("加密后的数据：", encrypted_message)

解密过程：

import rsa

# 使用私钥解密数据
decrypted_message = rsa.decrypt(encrypted_message, private_key)

# 打印解密后的数据
print("解密后的数据：", decrypted_message)

在上面的例子中，我们使用了一个2048位的密钥对进行加密和解密。首先生成了一个新的密钥对，然后使用`rsa.encrypt`函数使用公钥对数据进行加密，最后使用`rsa.decrypt`函数使用私钥对数据进行解密。

需要注意的是，`rsa.encrypt`和`rsa.decrypt`函数接受的数据类型是`bytes`，所以在加密和解密过程中需要将字符串转换为`bytes`类型。

以上就是用Python写一个RSA加密解密的简单示例。当然，实际应用中还需要考虑更多的情况，比如键值的存储和管理，数据的序列化和反序列化，异常处理等。

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公钥和私钥，对明文进行加密后再解密，最后输出加密前后的结果。