python模拟CSR证书请求

CSR——python

TTP处理证书

  • 创建证书签名请求（CSR）：类似于填写签证信息
  • 将CSR发送给可信的第三方（TTP）：这就像将你的信息发送到签证申请TTP办公室
  • 验证信息：不管怎样，TTP需要验证你提供的信息
  • 生成一个公钥：TTP签署你的CSR。这相当于TTP签署你的签证
  • 签发已验证的公钥：这相当于你在邮件中收到签证

注意：CSR以加密的方式绑定了你的私钥，因此，信息公钥、私钥和证书颁发机构的所有三个部分都以某种方式相关。这将创建所谓的信任链，因此你现在拥有一个有效的证书，可以用来核实你的身份。

python实现

可以在自己的机器上设置整个PKI基础设施，这正是本节中要做的。没有听起来那么难，所以别担心！成为一个真正的证书颁发机构要比采取以下步骤困难得多，但你将要读到的大体上是你运行自己的CA（证书颁发机构）所需的全部内容。

初始公钥和私钥对将是自签名证书。如果你真的要成为一个CA（证书颁发机构），那么这个私钥的安全是非常重要的。如果有人可以访问CA的公钥和私钥对，他也可以生成一个完全有效的证书，并且除了停止信任你的CA之外，你无法检测该问题。python当中我们使用socket套接字模拟了一套客户端和服务器。私钥保存在服务器上，生成私钥代码如下：

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa 
'''
使用RSA算法生成私钥
'''


def generate_private_key(filename: str, passphrase: str):
    private_key = rsa.generate_private_key(
        public_exponent=65537, key_size=2048, backend=default_backend()
    )

    utf8_pass = passphrase.encode("utf-8")
    algorithm = serialization.BestAvailableEncryption(utf8_pass)

    with open(filename, "wb") as keyfile:
        keyfile.write(
            private_key.private_bytes(
                encoding=serialization.Encoding.PEM,
                format=serialization.PrivateFormat.TraditionalOpenSSL,
                encryption_algorithm=algorithm,
            )
        )
		'''
		按指定的文件名将私钥写入磁盘。此文件使用提供的密码来加密。
		'''
    return private_key

此时就有两种方法可以生成私钥。

绕过CSR请求直接生成私钥

这个方法可以简单模拟证书签名机制。

from datetime import datetime, timedelta
from cryptography import x509
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives import hashes

def generate_public_key(private_key, filename, **kwargs):
    subject = x509.Name(
        [
            x509.NameAttribute(NameOID.COUNTRY_NAME, kwargs["country"]),
            x509.NameAttribute(
                NameOID.STATE_OR_PROVINCE_NAME, kwargs["state"]
            ),
            x509.NameAttribute(NameOID.LOCALITY_NAME, kwargs["locality"]),
            x509.NameAttribute(NameOID.ORGANIZATION_NAME, kwargs["org"]),
            x509.NameAttribute(NameOID.COMMON_NAME, kwargs["hostname"]),
        ]
    )

    # Because this is self signed, the issuer is always the subject
    issuer = subject '''这个地方由于是自签名，所以颁发者和使用者一样，不过通过CSR请求的时候，颁发者和使用者将会通过传参的方式写入'''

    # This certificate is valid from now until 30 days
    valid_from = datetime.utcnow()
    valid_to = valid_from + timedelta(days=30)

    # Used to build the certificate
    builder = (
        x509.CertificateBuilder()
        .subject_name(subject)
        .issuer_name(issuer)
        .public_key(private_key.public_key())
        .serial_number(x509.random_serial_number())
        .not_valid_before(valid_from)
        .not_valid_after(valid_to)
    )
    '''
		所有必需的信息添加到公钥生成器对象中，该对象需要进行签名。
    '''

    # Sign the certificate with the private key
    public_key = builder.sign(
        private_key, hashes.SHA256(), default_backend()
    ) '''用私钥签署公钥'''

    with open(filename, "wb") as certfile:
        certfile.write(public_key.public_bytes(serialization.Encoding.PEM))

    return public_key

使用上述两个函数我们就可以简单的实现快速生成公私钥对（key pair）

首先假设在服务器端生成好私钥（这个东西就不再变了）

private_key = generate_private_key("ca-private-key.pem", "password_by_yourself")
print(private_key)
>>> <cryptography.hazmat.backends.openssl.rsa._RSAPrivateKey object at 0x7ff05e22d700>

此时目录下会生成一个CA_private_key.pem的文件，文件内容格式为：

-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-256-CBC,5AF31374022ED7399D94EC644576265F

BRF3XTbzPNMYIG3H+L34EzdxgLY7zw/Cl1+bqooup/cbVwJN55+U5KDHfx1ANdEh
XvNcl8Ojeo3a+tuh78WHa68VePMYGRasOjORY1eIoqh+FKTBS3gpN9VcPpMdI2eC
L+vxhIP3e0gPqqJ3HVWvuOAAHhdS0HgkNklDdYyWNa3UTp48Z/09oi+TL7JGH7i7
i2BTyXkpnzVSQDxOhQ4J0VrO4iikluD5D1Vy5LQgQFxMYrcIpToCaH7tR8zt2gdx
3EyjVZoh5Cmm7YZaQ1KgFXmNrDu3wwZVHAmt2tvCuSFYTO0XZzY5R+kwk9UI0E02
TnVXqriogHptCZlBaTusz+s2SvoX0ntkTNraD4JXAPX+Foxo4yMmFaXelWwFA3/q
Kkiclfwsj6+V019HUyr5os84lmLBewQP/Og52QFUHjvRYwjGdw12P23dXLtNsaU9
OlR4cS4O9RocTD19yjDtAhnBP4rfaN0Av9CgNkPohR1bDk5IQ9xD8akgVF0m9fa/
DjD5DE8+tYhnWJ7exDlEKIPRfkmL+soD5Hq1lk3dcWcmSUpL77AlzWEVi3azqW9z
r1ky4RUNsQV+MVLFdlMyK3J7o6Nn4FtT7micy9BilLI3sKRHdeGppeLySxFo8BaQ
4dDkPu6503HsaWu1PXw6ZFozJBwVAOVLHVazgbAtXWJNPbKd6XrZn6B3Ivwkny7z
36TKN+xMxYU4y7MJ25hQy5fxjF4j6oHsuWn9s9vB/7sSd9Q5BkJ+oFGfY0UP3abw
JVjYVd3AadNFI8pgdjYhft7BN3zYsMHFGEv55ww+52i9rVtJ2/eYdc6PV7u1PIoc
ooYm6O8H1hCrbtR9lNTLj2LCX/dyhVkHbeqnY/HKapi+3bbvEU+sI19yCUZn2KtV
d/Fm1KPdHMarbhHRvYH6gHD4ZLi0x2tXbHHKiSMSsalJDH7giClLM/KmUxivXank
4k7DcmQ3efTQC62rgh65XGDqozosXHku+6l5FHZY5HMHqm6ThRa85qWCmOaLmu0o
4lhT3qLI+PWAeipGjGghGDa1xbYGqol0gZoEvX83Dh5YNzjlKLP0d4D7PxXzvdvr
fD+uWzdxd/JjREIdL/d3k7ZnmVfZeygQDSHabQLcz9JIU/yi61hLLTjiHvhLq3+e
pTMjNILBfyYcZ5xxGgXSgcskZgjR3yNL8XcLwUdeVXxWJXgF50sLj9FiRcbW4QtS
rgiyC+8J8f5UIQJar7/Sd8j4RHJ1V6zjFGf9E2heiGN2Hs6XT5AQr3Zg94bXDh7q
8Vfq6Pqn3apJO+2xAGePyak+dyHZ3YIP+qYcbJcrS7JsnR+i+sriLGHmh1l/xhOV
XHUsQxOPSma9UkQs63D9S+wVEGaEFGjYFKC2LoGnBd1r1+OdElS+Skk2xmiacLlM
lhuGAKknmnxP1XQxNgc/q7+UpRPnV8Y+mmbmGhwrXgtwlLLU33wHIUFMG4ZqB9+p
+y1rUgyxTGESvo0nXuWUotIQvT1PlFpE7Tn+eHjmOIOqk2uQO2xMnGynl8jZZJX7
klMlRJm9VhszE1UTiEjaUE54UEENsNmbwCfAMWT1PdOi/es4HCuCi+l0ymqZctym
-----END RSA PRIVATE KEY-----

这个东西会成为生成公钥到来源，生成公钥需要自己写一些参数

key = generate_public_key(
    private_key,
    filename="ca-private-key.pem",
    country="US",
    state="Maryland",
    locality="Baltimore",
    org="My CA Company",
    hostname="my-ca.com",
    )
print(key)

image-20221104232031210

现在就拥有了两个文件，一个是公钥，一个是私钥。

经过CSR请求

def generate_csr(private_key, filename, **kwargs):
    subject = x509.Name(
        [
            x509.NameAttribute(NameOID.COUNTRY_NAME, kwargs["country"]),
            x509.NameAttribute(
                NameOID.STATE_OR_PROVINCE_NAME, kwargs["state"]
            ),
            x509.NameAttribute(NameOID.LOCALITY_NAME, kwargs["locality"]),
            x509.NameAttribute(NameOID.ORGANIZATION_NAME, kwargs["org"]),
            x509.NameAttribute(NameOID.COMMON_NAME, kwargs["hostname"]),
        ]
    )

    # Generate any alternative dns names
    alt_names = []
    for name in kwargs.get("alt_names", []):
        alt_names.append(x509.DNSName(name))
    san = x509.SubjectAlternativeName(alt_names) '''设置备用DNS名称，该名称对你的证书有效'''

    builder = (
        x509.CertificateSigningRequestBuilder()
        .subject_name(subject)
        .add_extension(san, critical=False)
    )

    csr = builder.sign(private_key, hashes.SHA256(), default_backend())'''用私钥签署CSR'''
    with open(filename, "wb") as csrfile:
        csrfile.write(csr.public_bytes(serialization.Encoding.PEM))

    return csr

为了创建CSR，首先需要一个私钥。幸运的是，你可以在创建CA的私钥时使用相同的generate_private_key() 。使用上面的函数和前面定义的方法，可以执行以下操作：

server_private_key = generate_private_key("server-private-key.pem", "serverpassword")
print(server_private_key)

generate_csr(
    server_private_key,
    filename="server-csr.pem",
    country="US",
    state="Maryland",
    locality="Baltimore",
    org="My Company",
    alt_names=["localhost"],
    hostname="my-site.com")

image-20221104233028561

有了这两个文档，现在可以开始对密钥进行签名。通常，在这一步中会进行大量的验证。在实际项目中，CA会确保你拥有my-site.com，并要求你以各种方式证明它。在自己模拟CA服务器和客户端的时候，可以避免这些麻烦的证明，创建你自己的已验证的公钥。为此，你将在pki_helpers.py文件中添加另一个函数

def sign_csr(csr, ca_public_key, ca_private_key, new_filename):
    valid_from = datetime.utcnow()
    valid_until = valid_from + timedelta(days=30)

    builder = (
        x509.CertificateBuilder()
        .subject_name(csr.subject)
        .issuer_name(ca_public_key.subject)
        .public_key(csr.public_key())
        .serial_number(x509.random_serial_number())
        .not_valid_before(valid_from)
        .not_valid_after(valid_until)
    )

    for extension in csr.extensions:
        builder = builder.add_extension(extension.value, extension.critical)

    public_key = builder.sign(
        private_key=ca_private_key,
        algorithm=hashes.SHA256(),
        backend=default_backend(),
    )

    with open(new_filename, "wb") as keyfile:
        keyfile.write(public_key.public_bytes(serialization.Encoding.PEM))

现在就可以实现一个csr请求交互，并使用sign_csr()，需要加载CSR和CA的私钥和公钥，

  1. 从加载CSR开始
csr_file = open("server-csr.pem", "rb")
csr = x509.load_pem_x509_csr(csr_file.read(), default_backend())
print(csr)
'''<builtins.CertificateSigningRequest object at 0x7faadeef9d20>'''

  1. 将打开server-csr.pem文件，并使用x509.load_pem_x509_csr()创建csr对象。接下来，你需要加载CA的公钥

    ca_public_key_file = open("ca-public-key.pem", "rb")
ca_public_key = x509.load_pem_x509_certificate(
    ca_public_key_file.read(),
    default_backend())
print(ca_public_key)
'''<Certificate(subject=<Name(C=US,ST=Maryland,L=Baltimore,O=My CA Company,CN=my-ca.com)>, ...)>'''

  2. 创建了一个ca_public_key对象，它可以被sign_csr()使用。x509模块有一个便利的load-pem-x509-u certificate()来帮助你。最后一步是加载CA的私钥：

    ca_private_key_file = open("ca-private-key.pem", "rb")
ca_private_key = serialization.load_pem_private_key(
    ca_private_key_file.read(),
    getpass().encode("utf-8"),
    default_backend(),)

print(ca_private_key)

    image-20221104235739817

​ 回想一下，你的私钥是使用你指定的密码加密的，这个密码在生成CA_private_key时使用。

  1. 使用这三个组件，你现在可以签署CSR并生成已验证的公钥

    sign_csr(csr, ca_public_key, ca_private_key, "server-public-key.pem")

总结一下CSR请求的过程

  1. 要生成一个CA的私钥private_key，这个需要自定义一个password用来加密生成，然后存储在服务器内部
  2. CSR服务器通过private_key生成一个用于CSR请求的私钥server_private_key以及一个server_csr
  3. 客户端来访问的时候，首先会打开server_csr文件创建一个CSR对象，同时加载CA的公钥
  4. 再生成一个ca_public_key对象，然后加载CA的私钥
  5. 用sign_csr()进行验证

image-20221105001517319

客户端

客户端可以直接在与网页进行交互，但我需要的是后续通过socket套接字来完成这一任务

posted @ 2022-11-05 00:17  ivanlee717  阅读(637)  评论(0)  编辑  收藏  举报