前言

上篇我们大概认识了哈希，对称和非对称加密算法，混合加密机制，这一次继续认识下OpenSSL加密标准，PKI加密体系，以及同态加密的概念。

(5)OpenSSL标准

OpenSSL 是一个安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL()协议，并提供丰富的应用程序供测试或其它目的使用。

OpenSSL并不是一种加密算法，它只是为加密算法提供了一个标准。我们这里用OpenSSL加密标准实现以下RSA加密。

"""
    @author: chaors

    @file: RSA.py

    @time: 2018/04/10 21:00

    @desc: 非对称加密算法:openSSL
"""

import rsa
import base64  #编码库
from OpenSSL.crypto import PKey  #处理公钥
from OpenSSL.crypto import TYPE_RSA, FILETYPE_PEM, FILETYPE_ASN1  #处理文件
from OpenSSL.crypto import dump_privatekey, dump_publickey  #key写入文件

pk = PKey()  #调用openssl加密标准
pk.generate_key(TYPE_RSA, 1024)  #1024位rsa类型
print(pk)

#秘钥写入文件
pubkey_file = dump_publickey(FILETYPE_PEM, pk)
privatekey_file = dump_privatekey(FILETYPE_ASN1, pk)

#秘钥读取
pubkey = rsa.PublicKey.load_pkcs1_openssl_pem(pubkey_file)
privatekey = rsa.PrivateKey.load_pkcs1(privatekey_file, "DER")
# privatekey1 = rsa.PublicKey.load_pkcs1_openssl_pem(privatekey_file)

print(pubkey.save_pkcs1())
print(privatekey.save_pkcs1())
# print(pubkey, privatekey, privatekey1)

data = rsa.encrypt("自古多情空余恨，此恨绵绵无绝期".encode("utf-8"), pubkey)  #加密
data = base64.b64encode(data)
print(data)
data_d = rsa.decrypt(base64.b64decode(data), privatekey)  #解密
print(data_d.decode("utf-8"))

(6)PKI加密体系

PKI并不代表某个特定的密码学技术和流程，PKI是建立在公私钥基础上实现安全可靠传递消 息和身份确认的一个通用框架。实现了PKI的平台可以安全可靠地管理网络中用户的密钥和 证书，包括多个实现和变种，知名的有RSA公司的PKCS（Public Key CryptographyStandards）标准和X.509规范等。

一般情况下，PKI至少包括如下组件：

• CA（Certification Authority）：负责证书的颁发和作废，接收来自RA的请求，是最核心的部分；

• RA（Registration Authority）：对用户身份进行验证，校验数据合法性，负责登记，审核过了就发给CA；

• 证书数据库：存放证书，一般采用LDAP目录服务，标准格式采用X.500 系列。

CA 是最核心的组件，主要完成对证书的管理。

常见的流程为，用户通过RA 登记申请证书，CA 完成证书的制造，颁发给用户。用户需要撤 销证书则向CA 发出申请。

之前章节内容介绍过，密钥有两种类型：用于签名和用于加解密，对应称为 签名密钥对 和 加 密密钥对 。

用户证书可以有两种方式。一般可以由 CA 来生成证书和私钥；也可以自己生成公钥和私钥， 然后由 CA 来对公钥进行签发。后者情况下，当用户私钥丢失后，CA 无法完成恢复。

PKI体系的简单使用

"""
    @author: chaors

    @file: PKIDemo.py

    @time: 2018/04/10 21:56

    @desc: PKI体系
"""

from  Crypto import  Random  #随机数
from  Crypto.Hash import SHA  #哈希
from Crypto.Cipher import PKCS1_v1_5 as CPKCS1_v1_5  #PKI体系加解密标准
from  Crypto.Signature import PKCS1_v1_5 as SPKCS1_v1_5  #PKI体系签名标准
from Crypto.PublicKey import RSA
import base64

rand_maker = Random.new().read  #随机数生成器
rsa = RSA.generate(1024, rand_maker)  #RSA实例
#生成秘钥
public_pem = rsa.publickey().exportKey()
private_pem = rsa.exportKey()

#保存秘钥
with open("master-public.pem", "wb") as file:
    file.write(public_pem)
with open("master-private.pem", "wb") as file:
    file.write(private_pem)

msg = "桃花树下桃花庵"
#加解密
with open("master-public.pem", "rb") as file:  #读取公钥加密
    key = file.read()  #读取key
    rsakey = RSA.importKey(key)  #导入key
    cipher = CPKCS1_v1_5.new(rsakey)  #遵循KPI标准
    cipher_txt = base64.b64encode(cipher.encrypt(msg.encode()))
    print("PKI encrypt:", cipher_txt)

with open("master-private.pem", "rb") as file:  #读取私钥解 密
    key = file.read()  #读取key
    rsakey = RSA.importKey(key)  #导入key
    cipher = CPKCS1_v1_5.new(rsakey)  #遵循KPI标准
    txt = cipher.decrypt(base64.b64decode(cipher_txt), rand_maker)
    print("PKI decrypt:", txt.decode())

#签名
with open("master-private.pem", "rb") as file:  #读取私钥签名
    key = file.read()  #读取key
    rsakey = RSA.importKey(key)  #导入key
    signer = SPKCS1_v1_5.new(rsakey)  #PKI体系签名工具
    digest = SHA.new()  #签名算法
    digest.update(msg.encode())  #导入签名数据
    sign = signer.sign(digest)  #签名
    signature = base64.b64encode(sign)  #编码
    print("PKI Sign:", signature)

with open("master-public.pem", "rb") as file:  #读取公钥验签
    key = file.read()  # 读取key
    rsakey = RSA.importKey(key)  # 导入key
    signer = SPKCS1_v1_5.new(rsakey)  # PKI体系签名工具
    digest = SHA.new()  # 签名算法
    digest.update(msg.encode())  # 导入签名数据
    print("PKI SignVerify:", signer.verify(digest, base64.b64decode(signature)))

(7)同态加密

同态加密（Homomorphic Encryption）是一种特殊的加密方法，允许对密文进行处理得到仍 然是加密的结果，即对密文直接进行处理，跟对明文进行处理再加密，得到的结果相同。从 代数的角度讲，即同态性。

同态加密在云时代的意义十分重大。目前，从安全角度讲，用户还不敢将敏感信息直接放到 第三方云上进行处理。如果有了比较实用的同态加密技术，则大家就可以放心的使用各种云 服务了。遗憾的是，目前已知的同态加密技术需要消耗大量的计算时间，还远达不到实用的水平。

如果我们有一个加密函数 f , 把明文A变成密文A’, 把明文B变成密文B’，也就是说 f(A) = A’ ， f(B) = B’ 。另外我们还有一个解密函数 f1能够将 f 加密后的密文解密成加密前的明文。

对于一般的加密函数，如果我们将A’和B’相加，得到C’。我们用f1对C’进行解密得到的结果一般是毫无意义的乱码。

但是，如果 f 是个可以进行同态加密的加密函数， 我们对C’使用 f1进行解密得到结果C， 这时候的C = A + B。

"""
    @author: chaors

    @file: HomomorphicEncryption.py

    @time: 2018/04/10 22:33

    @desc: 同态加密
"""

import numpy as np

#制造key
def create_key(w, m, n):
    S = (np.random.rand(m, n)*w/(2**16))  #随机数 max(S) < w

    return S
#加密
def encypt(x,
           S,  #秘钥
           m,
           n,  #范围
           w):  #向量
    e = (np.random.rand(m))  #随机数
    c = np.linalg.inv(S).dot((w*x)+e)  #加密

    return c
#解密
def decrypt(c, S, w):

    return (S.dot(c)/w).astype("int")  #解密

if __name__ == '__main__':
    x = np.array([1, 99, 250, 999, 33, 66, 512, 4096])
    print("x:",x)

    m = len(x)
    n = m
    w = 16
    S = create_key(w, m, n)
    print("key:", S)
    c = encypt(x, S, m, n, w)
    print("同态加密:", c)
    print("同态解密:", decrypt(c, S, w))
    #s*c = wx+e

这个同态加密小白我也是第一次听，看着多少还是有点懵逼。还不是太懂，不过今天就只能写到这了。