非对称加密

非对称加密是一种加密方法，它使用一对密钥：公钥和私钥。与对称加密不同，非对称加密中，密钥对中的一个（公钥）用于加密数据，而另一个（私钥）用于解密数据。具体来说，非对称加密有以下几个重要特点和流程：

注：总结来说就是公加私解，非对称就体现在加密和解密使用秘钥不一样。

密钥对的生成：在非对称加密系统中，会生成一对密钥——公钥和私钥。公钥可以公开分发，而私钥则必须保密。

加密过程：

发送方使用接收方的公钥对信息进行加密。
加密后的信息通过网络传输给接收方。

解密过程：

接收方收到加密的信息后，使用自己的私钥进行解密，恢复原始信息。

安全性：

公钥和私钥是一对数学上相关的密钥。公钥公开后，理论上无法通过公钥推算出私钥，保证了私钥的安全性。

非对称加密算法通常基于一些数学难题，例如大数分解问题、离散对数问题等，这些问题在计算上具有很高的复杂性，难以在合理时间内破解。

常见的非对称加密算法：

RSA（Rivest-Shamir-Adleman）
ECC（Elliptic Curve Cryptography，椭圆曲线加密）
DSA（Digital Signature Algorithm，数字签名算法）

应用场景：

数字签名：使用私钥对数据进行签名，验证者可以使用公钥验证签名的真实性和数据的完整性。
密钥交换：在通信双方需要交换对称密钥时使用非对称加密来保护交换过程的安全。
身份认证：通过公钥和私钥验证用户身份，确保通信双方的合法性。

例子：假设Alice想给Bob发送一条加密信息：

Bob生成一对密钥，并将公钥公开给Alice。
Alice使用Bob的公钥加密信息，然后将加密后的信息发送给Bob。
Bob收到信息后，使用自己的私钥解密，恢复出Alice发送的原始信息。

反之，Bob给Alice发加密消息也是一样，通过这种方式，尽管公钥公开，但由于私钥的保密性，只有Bob能解密由其公钥加密的信息，保证了通信的安全性。

非对称加密在现代信息安全中扮演着至关重要的角色，为确保数据传输的安全和隐私提供了强有力的支持。

在Python中，我们可以使用cryptography库来实现非对称加密。以下是一个简单的示例，演示如何使用RSA算法进行非对称加密和解密。

首先，需要安装cryptography库：

pip install cryptography

然后，下面是具体的实现代码：

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# 生成RSA密钥对
def generate_keys():
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    public_key = private_key.public_key()
    return private_key, public_key

# 使用公钥加密消息
def encrypt_message(message, public_key):
    encrypted = public_key.encrypt(
        message.encode(),
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return encrypted

# 使用私钥解密消息
def decrypt_message(encrypted_message, private_key):
    decrypted = private_key.decrypt(
        encrypted_message,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return decrypted.decode()

# 保存密钥到文件
def save_keys(private_key, public_key):
    pem_private_key = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    pem_public_key = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )

    with open("private_key.pem", "wb") as private_file:
        private_file.write(pem_private_key)

    with open("public_key.pem", "wb") as public_file:
        public_file.write(pem_public_key)

# 从文件加载密钥
def load_keys():
    with open("private_key.pem", "rb") as private_file:
        private_key = serialization.load_pem_private_key(
            private_file.read(),
            password=None
        )

    with open("public_key.pem", "rb") as public_file:
        public_key = serialization.load_pem_public_key(
            public_file.read()
        )

    return private_key, public_key

# 示例使用
if __name__ == "__main__":
    message = "Hello, this is a secret message!"

    # 生成密钥对
    private_key, public_key = generate_keys()

    # 保存密钥对到文件
    save_keys(private_key, public_key)

    # 从文件加载密钥对
    private_key, public_key = load_keys()

    # 加密消息
    encrypted_message = encrypt_message(message, public_key)
    print(f"Encrypted message: {encrypted_message}")

    # 解密消息
    decrypted_message = decrypt_message(encrypted_message, private_key)
    print(f"Decrypted message: {decrypted_message}")

非对称加密

关于我

归档

乱语

思绪

友链