python 使用 cryptography 操作 openSSL 密匙

密匙使用步骤一般是：

    1. 私匙签名，发送签名后的数据， 公匙验证。

    2.公匙加密，发送加密后的数据，私匙解密。

一般使用情景是通过 openssl 生成密匙后再操作的。Linux下生成密匙也很简单。

yum 安装 openssl

yum -y install openssl

生成三个密匙文件。

rsa_private_key.pem 私匙文件

rsa_private_key_pkcs8.pem  pkcs8格式私匙， 

rsa_public_key.pem 公匙

openssl genrsa -out rsa_private_key.pem   1024  
openssl pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt -out rsa_private_key_pkcs8.pem 
openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem 

导入私匙：

序列化密钥可以选择使用密码在磁盘上进行加密。在这个例子中，我们加载了一个未加密的密钥，因此我们没有提供密码。如果密钥被加密，我们可以传递一个bytes对象作为 password参数。

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization

# 已有sar私匙， 导入
with open('Key.pem', 'rb') as  key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )

签名：

    私钥可用于签署消息。这允许任何拥有公钥的人验证该消息是由拥有相应私钥的人创建的。RSA签名需要特定的散列函数，并使用填充。以下是message使用RSA 进行签名的示例，带有安全散列函数和填充：

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

# 已有sar私匙， 导入
with open('Key.pem', 'rb') as  key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )

message = b"aaaa, bbbb, cccc"

# 签名操作
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print('签名后数据：  ', signature)

有效的签名填充是 PSS和 PKCS1v15.PSS 是任何新协议或应用的推荐选择，PKCS1v15 只应用于支持传统协议。

如果您的数据太大而无法在单个调用中传递，则可以分别对其进行散列并使用该值 Prehashed。

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric import utils

# 已有sar私匙， 导入
with open('Key.pem', 'rb') as  key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )

# 如果您的数据太大而无法在单个调用中传递，则可以分别对其进行散列并使用该值 Prehashed。


chosen_hash = hashes.SHA256()
hasher = hashes.Hash(chosen_hash, default_backend())
hasher.update(b"data &")
hasher.update(b"more data")
digest = hasher.finalize()
sig = private_key.sign(
    digest,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    utils.Prehashed(chosen_hash)
)
print('签名后数据: ', sig)

验证：

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

# 已有sar私匙， 导入
with open('Key.pem', 'rb') as key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )

message = b"123 xiao"

# 签名
signature = private_key.sign(
    # 原始数据
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print('签名后的数据: ', signature)


# 公匙导入
with open('Key_pub.pem', 'rb') as key_file:
    public_key = serialization.load_pem_public_key(
        key_file.read(),
        backend=default_backend()
    )
    
    
# 签名数据与原始数据不对，抛出异常
# 如果验证不匹配，verify()会引发 InvalidSignature异常。
public_key.verify(
    # 签名数据
    signature,
    # 原始数据
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

如果您的数据太大而无法在单个调用中传递，则可以分别对其进行散列并使用该值 Prehashed。

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric import utils

# 已有sar私匙， 导入
with open('Key.pem', 'rb') as key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )

chosen_hash = hashes.SHA256()
hasher = hashes.Hash(chosen_hash, default_backend())
hasher.update(b'data &')
hasher.update(b'more data')
digest = hasher.finalize()
sig = private_key.sign(
    digest,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    utils.Prehashed(chosen_hash)
)
print('签名后的数据: ', sig)


# 公匙导入
with open('Key_pub.pem', 'rb') as key_file:
    public_key = serialization.load_pem_public_key(
        key_file.read(),
        backend=default_backend()
    )


# 如果您的数据太大而无法在单个调用中传递，则可以分别对其进行散列并使用该值 Prehashed。
public_key.verify(
    sig,
    digest,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    utils.Prehashed(chosen_hash)
)

公匙，加密：

    因为是使用进行加密的RSA加密有趣的是 公共密钥，这意味着任何人都可以对数据进行加密。数据然后使用私钥解密。

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding


# 公匙导入
with open('Key_pub.pem', 'rb') as key_file:
    public_key = serialization.load_pem_public_key(
        key_file.read(),
        backend=default_backend()
    )


message = b'test data'
ciphertext = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print('加密数据： ', ciphertext)

私匙解密公私加密的信息：

  

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding


# 已有sar私匙， 导入
with open('Key.pem', 'rb') as key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )
    

plaintext = private_key.decrypt(
    # 加密的信息
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

print('解密数据: ', plaintext)

完整的公匙加密，私匙解密获取信息。

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding


# 公匙导入
with open('Key_pub.pem', 'rb') as key_file:
    public_key = serialization.load_pem_public_key(
        key_file.read(),
        backend=default_backend()
    )


message = b'test data'
ciphertext = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print('加密数据： ', ciphertext)


# 已有sar私匙， 导入
with open('Key.pem', 'rb') as key_file:
    private_key = serialization.load_pem_private_key(
        key_file.read(),
        password=None,
        backend=default_backend()
    )
    

plaintext = private_key.decrypt(
    # 加密的信息
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

print('解密数据: ', plaintext)