x509 包

介绍

x509 包提供处理数字证书功能。

使用本包需要外部依赖 OpenSSL 3 的 ssl 和 crypto 动态库文件，故使用前需安装相关工具：

对于 Linux 操作系统，可参考以下方式：
- 如果系统的包管理工具支持安装 OpenSSL 3 开发工具包，可通过这个方式安装，并确保系统安装目录下含有 libssl.so、libssl.so.3、libcrypto.so 和 libcrypto.so.3 这些动态库文件，例如 Ubuntu 22.04 系统上可使用 sudo apt install libssl-dev 命令安装 libssl-dev 工具包；
- 如果无法通过上面的方式安装，可自行下载 OpenSSL 3.x.x 源码编译安装软件包，并确保安装目录下含有 libssl.so、libssl.so.3、libcrypto.so 和 libcrypto.so.3 这些动态库文件，然后可选择下面任意一种方式来保证系统链接器可以找到这些文件:
  - 在系统未安装 OpenSSL 的场景，安装时选择直接安装到系统路径下；
  - 安装在自定义目录的场景，将这些文件所在目录设置到环境变量 LD_LIBRARY_PATH 以及 LIBRARY_PATH 中。
对于 Windows 操作系统，可按照以下步骤：
- 自行下载 OpenSSL 3.x.x 源码编译安装 x64 架构软件包或者自行下载安装第三方预编译的供开发人员使用的 OpenSSL 3.x.x 软件包；
- 确保安装目录下含有 libssl.dll.a（或 libssl.lib）、libssl-3-x64.dll、libcrypto.dll.a(或 libcrypto.lib)、libcrypto-3-x64.dll 这些库文件；
- 将 libssl.dll.a（或 libssl.lib）、libcrypto.dll.a(或 libcrypto.lib) 所在的目录路径设置到环境变量 LIBRARY_PATH 中，将 libssl-3-x64.dll、libcrypto-3-x64.dll 所在的目录路径设置到环境变量 PATH 中。
对于 macOS 操作系统，可参考以下方式：
- 使用 brew install openssl@3 安装，并确保系统安装目录下含有 libcrypto.dylib 和 libcrypto.3.dylib 这两个动态库文件；
- 如果无法通过上面的方式安装，可自行下载 OpenSSL 3.x.x 源码编译安装软件包，并确保安装目录下含有 libcrypto.dylib 和 libcrypto.3.dylib 这两个动态库文件，然后可选择下面任意一种方式来保证系统链接器可以找到这些文件:
  - 在系统未安装 OpenSSL 的场景，安装时选择直接安装到系统路径下；
  - 安装在自定义目录的场景，将这些文件所在目录设置到环境变量 DYLD_LIBRARY_PATH 以及 LIBRARY_PATH 中。

如果未安装OpenSSL 3软件包或者安装低版本的软件包，程序可能无法使用并抛出相关异常 X509Exception: Can not load openssl library or function xxx.。

主要接口

interface Key

public interface Key <: ToString {
    func encodeToDer(): DerBlob
    func encodeToPem(): PemEntry
    static func decodeDer(encoded: DerBlob): Key
    static func decodeFromPem(text: String): Key
}

公钥用于签名验证或加密，私钥用于签名或解密，公钥和私钥必须相互匹配并形成一对。

该类为密钥类，无具体实现，供 PrivateKey/PublicKey 及用户扩展接口。

func decodeDer

static func decodeDer(encoded: DerBlob): Key

功能：将密钥从 DER 格式解码。

参数：

encoded：DER 格式的对象

返回值：由 DER 格式解码出的密钥

异常：

X509Exception : 当 DER 格式的私钥内容不正确，无法解析时抛出异常

func decodeFromPem

static func decodeFromPem(text: String): Key

功能：将密钥从 PEM 格式解码。

参数：

text：PEM 格式的字符流

返回值：由 PEM 格式解码出的密钥

interface PublicKey

public interface PublicKey <: Key {
    override func encodeToPem(): PemEntry
    static func decodeDer(blob: DerBlob): PublicKey
    static func decodeFromPem(text: String): PublicKey
}

func decodeDer

static func decodeDer(blob: DerBlob): PublicKey

功能：将公钥从 DER 格式解码。

参数：

blob：DER 格式的公钥对象

返回值：由 DER 格式解码出的公钥

异常：

X509Exception : 当 DER 格式的私钥内容不正确，无法解析时抛出异常

func decodeFromPem

static func decodeFromPem(text: String): PublicKey

功能：将公钥从 PEM 格式解码。

参数：

text：PEM 格式的公钥字符流

返回值：由 PEM 格式解码出的公钥

异常：

X509Exception：字符流不符合 PEM 格式时，或文件头不符合公钥头标准时抛出异常

interface DHParamters

public interface DHParamters <: Key {
    override func encodeToPem(): PemEntry
    static func decodeDer(blob: DerBlob): DHParamters
    static func decodeFromPem(text: String): DHParamters
}

func encodeToPem

override func encodeToPem(): PemEntry

功能：将 DH 密钥参数编码为 PEM 格式。

返回值： DH 密钥参数数据 PEM 格式编码生成的对象

func decodeDer

static func decodeDer(blob: DerBlob): DHParamters

功能：将 DH 密钥参数从 DER 格式解码。

参数：

blob：DER 格式的 DH 密钥参数对象

返回值：由 DER 格式解码出的 DH 密钥参数

异常：

X509Exception : 当 DER 格式的 DH 密钥参数内容不正确，无法解析时抛出异常

func decodeFromPem

static func decodeFromPem(text: String): DHParamters

功能：将 DH 密钥参数从 PEM 格式解码。

参数：

text：PEM 格式的 DH 密钥参数字符流

返回值：由 PEM 格式解码出的 DH 密钥参数

异常：

X509Exception：字符流不符合 PEM 格式时，或文件头不符合 DH 密钥参数头标准时抛出异常

interface PrivateKey

public interface PrivateKey <: Key {
    static func decodeDer(blob: DerBlob): PrivateKey
    static func decodeFromPem(text: String): PrivateKey
    static func decodeDer(blob: DerBlob, password!: ?String): PrivateKey
    static func decodeFromPem(text: String, password!: ?String): PrivateKey
    func encodeToDer(password!: ?String): DerBlob
    override func encodeToPem(): PemEntry
    func encodeToPem(password!: ?String): PemEntry
}

func decodeDer

static func decodeDer(blob: DerBlob): PrivateKey

功能：将私钥从 DER 格式解码。

参数：

blob：DER 格式的私钥对象

返回值：由 DER 格式解码出的私钥

异常：

X509Exception : 当 DER 格式的私钥内容不正确，无法解析时抛出异常

func decodeDer

static func decodeDer(blob: DerBlob, password!: ?String): PrivateKey

功能：将 DER 格式的私钥解密解码成 PrivateKey 对象，密码为 None 时则不解密。

参数：

blob：DER 格式的私钥
password：解密密码

返回值：解密解码后的私钥对象

异常：

X509Exception：解密解码失败，或者参数密码为空字符串

func decodeFromPem

static func decodeFromPem(text: String): PrivateKey

功能：将私钥从 PEM 格式解码。

参数：

text：PEM 格式的私钥字符流

返回值：由 PEM 格式解码出的私钥

异常：

X509Exception：字符流不符合 PEM 格式时，或文件头不符合公钥头标准时抛出异常

func decodeFromPem

static func decodeFromPem(text: String, password!: ?String): PrivateKey

功能：将 PEM 格式的私钥解密解码成 PrivateKey 对象，密码为 None 时则不解密。

参数：

text：PEM 格式的私钥
password：解密密码

返回值：解密解码后的私钥对象

异常：

X509Exception：解密解码失败，或者参数密码为空字符串

func encodeToDer

func encodeToDer(password!: ?String): DerBlob

功能：将私钥加密编码成 DER 格式，密码为 None 时则不加密。

参数：

password：加密密码

返回值：加密后的 DER 格式的私钥

异常：

X509Exception：加密失败，或者参数密码为空字符串

func encodeToPem

func encodeToPem(password!: ?String): PemEntry

功能：将私钥加密编码成 PEM 格式，密码为 None 时则不加密。

参数：

password：加密密码

返回值：加密后的 PEM 格式的私钥

异常：

X509Exception：加密失败，或者参数密码为空字符串

func encodeToPem

override func encodeToPem(): PemEntry

功能：将私钥编码成 PEM 格式。

返回值：编码后的 PEM 格式的私钥

异常：

X509Exception：编码失败

struct X509CertificateInfo

public struct X509CertificateInfo {
    public var serialNumber: SerialNumber
    public var notBefore: DateTime
    public var notAfter: DateTime
    public var subject: ?X509Name
    public var dnsNames: Array<String>
    public var emailAddresses: Array<String>
    public var IPAddresses: Array<IP>
    public var keyUsage: ?KeyUsage
    public var extKeyUsage: ?ExtKeyUsage

    public init(
        serialNumber!: ?SerialNumber = None,
        notBefore!: ?DateTime = None,
        notAfter!: ?DateTime = None,
        subject!: ?X509Name = None,
        dnsNames!: Array<String> = Array<String>(),
        emailAddresses!: Array<String> = Array<String>(),
        IPAddresses!: Array<IP> = Array<IP>(),
        keyUsage!: ?KeyUsage = None,
        extKeyUsage!: ?ExtKeyUsage = None
    )
}

X509CertificateInfo 结构包含了证书信息，包括证书序列号、有效期、实体可辨识名称、域名、email 地址、IP 地址、密钥用法和扩展密钥用法。

init

public init(
    serialNumber!: ?SerialNumber = None,
    notBefore!: ?DateTime = None,
    notAfter!: ?DateTime = None,
    subject!: ?X509Name = None,
    dnsNames!: Array<String> = Array<String>(),
    emailAddresses!: Array<String> = Array<String>(),
    IPAddresses!: Array<IP> = Array<IP>(),
    keyUsage!: ?KeyUsage = None,
    extKeyUsage!: ?ExtKeyUsage = None
)

功能：构造 X509CertificateInfo 对象。

参数：

serialNumber：数字证书序列号，默认值为 None，使用默认值时默认的序列号长度为 128 比特
notBefore：数字证书有效期开始时间，默认值为 None，使用默认值时默认的时间为 X509CertificateInfo 创建的时间
notAfter：数字证书有效期截止时间，默认值为 None，使用默认值时默认的时间为 notBefore 往后 1 年的时间
subject：数字证书使用者信息，默认值为 None
dnsNames：域名列表，需要用户保证输入域名的有效性，默认值为空的字符串数组
emailAddresses：email 地址列表，需要用户保证输入 email 的有效性，默认值为空的字符串数组
IPAddresses：IP 地址列表，默认值为空的 IP 数组
keyUsage：密钥用法，默认值为 None
extKeyUsage：扩展密钥用法，默认值为 None

异常：

X509Exception：输入的 IP 地址列表中包含无效的 IP 地址，则抛出异常

struct X509CertificateRequestInfo

public struct X509CertificateRequestInfo {
    public var subject: ?X509Name
    public var dnsNames: Array<String>
    public var emailAddresses: Array<String>
    public var IPAddresses: Array<IP>
 
    public init(
        subject!: ?X509Name = None,
        dnsNames!: Array<String> = Array<String>(),
        emailAddresses!: Array<String> = Array<String>(),
        IPAddresses!: Array<IP> = Array<IP>()
    )

X509CertificateRequestInfo 结构包含了证书请求信息，包括证书实体可辨识名称、域名、email 地址和 IP 地址。

init

public init(
    subject!: ?X509Name = None,
    dnsNames!: Array<String> = Array<String>(),
    emailAddresses!: Array<String> = Array<String>(),
    IPAddresses!: Array<IP> = Array<IP>()
)

功能：构造 X509CertificateRequestInfo 对象。

参数：

subject：数字证书的使用者信息，默认值为 None
dnsNames：域名列表，需要用户保证输入域名的有效性，默认值为空的字符串数组
emailAddresses：email 地址列表，需要用户保证输入 email 的有效性，默认值为空的字符串数组
IPAddresses：IP 地址列表，默认值为空的 IP 数组

异常：

X509Exception：输入的 IP 地址列表中包含无效的 IP 地址，则抛出异常

class X509Name

public class X509Name <: ToString {
    public init(
        countryName!: ?String = None,
        provinceName!: ?String = None,
        localityName!: ?String = None,
        organizationName!: ?String = None,
        organizationalUnitName!: ?String = None,
        commonName!: ?String = None,
        email!: ?String = None
    )
    public prop countryName: ?String
    public prop provinceName: ?String
    public prop localityName: ?String
    public prop organizationName: ?String
    public prop organizationalUnitName: ?String
    public prop commonName: ?String
    public prop email: ?String
    public override func toString(): String
}

证书实体可辨识名称（Distinguished Name）是数字证书中的一个重要组成部分，作用是确保证书的持有者身份的真实性和可信度，同时也是数字证书验证的重要依据之一。

X509Name 通常包含证书实体的国家或地区名称（Country Name）、州或省名称（State or Province Name）、城市名称（Locality Name）、组织名称（Organization Name）、组织单位名称（Organizational Unit Name）、通用名称（Common Name）。有时也会包含 email 地址。

init

    public init(
        countryName!: ?String = None,
        provinceName!: ?String = None,
        localityName!: ?String = None,
        organizationName!: ?String = None,
        organizationalUnitName!: ?String = None,
        commonName!: ?String = None,
        email!: ?String = None
    )

功能：构造 X509Name 对象。

参数：

countryName：国家或地区名称，默认值为 None
provinceName：州或省名称，默认值为 None
localityName：城市名称，默认值为 None
organizationName：组织名称，默认值为 None
organizationalUnitName：组织单位名称，默认值为 None
commonName：通用名称，默认值为 None
email：email 地址，默认值为 None

异常：

X509Exception：设置证书实体可辨识名称时失败，比如内存分配异常等内部错误，则抛出异常

prop countryName

public prop countryName: ?String

功能：返回证书实体的国家或地区名称。

返回值：Option，若证书实体中没有国家或地区名称，返回 None

prop provinceName

public prop provinceName: ?String

功能：返回证书实体的州或省名称。

返回值：Option，若证书实体中没有州或省名称，返回 None

prop localityName

public prop localityName: ?String

功能：返回证书实体的城市名称。

返回值：Option，若证书实体中没有城市名称，返回 None

prop organizationName

public prop organizationName: ?String

功能：返回证书实体的组织名称。

返回值：Option，若证书实体中没有组织名称，返回 None

prop organizationalUnitName

public prop organizationalUnitName: ?String

功能：返回证书实体的组织单位名称。

返回值：Option，若证书实体中没有组织单位名称，返回 None

prop commonName

public prop commonName: ?String

功能：返回证书实体的通用名称。

返回值：Option，若证书实体中没有通用名称，返回 None

prop email

public prop email: ?String

功能：返回证书实体的 email 地址。

返回值：Option，若证书实体中没有 email 地址，返回 None

func toString

public override func toString(): String

功能：生成证书实体名称字符串。

返回值：证书实体名称字符串，包含实体名称中存在的字段信息

struct DerBlob

public struct DerBlob <: Equatable<DerBlob> & Hashable {
    public init(content: Array<Byte>)
}

Crypto 支持配置二进制证书流，用户读取二进制证书数据并创建 DerBlob 对象后可将其解析成 X509Certificate / X509CertificateRequest / PublicKey / PrivateKey 对象。

operator func ==

public override operator func ==(other: DerBlob): Bool

功能：判等。

参数：

other：被比较的 DerBlob 对象

返回值：若对象相同，返回 true；否则，返回 false

operator func !=

public override operator func !=(other: DerBlob): Bool

功能：判不等。

参数：

other：被比较的 DerBlob 对象

返回值：若对象不同，返回 true；否则，返回 false

func hashCode

public override func hashCode(): Int64

功能：返回 DerBlob 对象哈希值。

返回值：对 DerBlob 对象进行哈希计算后得到的结果

struct PemEntry

public struct PemEntry <: ToString {
    public PemEntry(
        public let label: String,
        public let headers: Array<(String, String)>,
        public let body: ?DerBlob
    )
    public init(label: String, body: DerBlob)
}

PEM 文本格式经常用于存储证书和密钥，PEM 编码结构包含以下几个部分：第一行是 “-----BEGIN”，标签和 “-----” 组成的utf8编码的字符串；最后一行是 “-----END”，标签和 “-----” 组成的 utf8 编码的字符串；中间是正文，是实际二进制内容经过 base64 编码得到的可打印字符串, 详细的 PEM 编码规范可参考 rfc7468。在旧版的 PEM 编码标准中在第一行和正文之间还包含条目头，详见 rfc1421

单个 PEM 文件可能包含多个条目，单个条目可以是证书、密钥、请求或其他安全相关内容的 PEM 基础结构。密钥和证书链可以分别存储在多个 PEM 文件中，也可以存储在同一个 PEM 文件中。

为了支持不同的用户场景，我们提供了 PemEntry 和 Pem 类型，PemEntry 用于存储单个PEM 基础结构。

label

public let label: String

功能：PemEntry 实例的标签。

headers

public let headers: Array<(String, String)>

功能：PemEntry 实例的条目头。

body

public let body: ?DerBlob

功能：PemEntry 实例的二进制内容。

PemEntry

public PemEntry(
    public let label: String,
    public let headers: Array<(String, String)>,
    public let body: ?DerBlob
)

功能：构造 PemEntry 对象。

参数：

label：标签
headers：条目头
body：二进制内容

init

public init(label: String, body: DerBlob)

功能：构造 PemEntry 对象。

参数：

label：标签
body：二进制内容

func header

public func header(name: String): Iterator<String>

功能：通过条目头名称，找到对应条目内容。

参数：

name：条目头名称

返回值：条目头名称对应内容的迭代器

func encode

public func encode(): String

功能：返回PEM格式的字符串。行结束符将根据当前操作系统生成。

返回值：PEM 格式的字符串

func toString

public override func toString(): String

功能：返回 PEM 对象的标签和二进制内容的长度。

返回值：PEM 对象的标签和二进制内容的长度

LABEL_CERTIFICATE

public static let LABEL_CERTIFICATE = "CERTIFICATE"

功能：记录条目类型为证书

LABEL_X509_CRL

public static let LABEL_X509_CRL = "X509 CRL"

功能：记录条目类型为证书吊销列表

LABEL_CERTIFICATE_REQUEST

public static let LABEL_CERTIFICATE_REQUEST = "CERTIFICATE REQUEST"

功能：记录条目类型为证书签名请求

LABEL_PRIVATE_KEY

public static let LABEL_PRIVATE_KEY = "PRIVATE KEY"

功能：记录条目类型为 PKCS #8 标准未加密的私钥

LABEL_EC_PRIVATE_KEY

public static let LABEL_EC_PRIVATE_KEY = "EC PRIVATE KEY"

功能：记录条目类型为椭圆曲线私钥

LABEL_ENCRYPTED_PRIVATE_KEY

public static let LABEL_ENCRYPTED_PRIVATE_KEY = "ENCRYPTED PRIVATE KEY"

功能：记录条目类型为 PKCS #8 标准加密的私钥

LABEL_RSA_PRIVATE_KEY

public static let LABEL_RSA_PRIVATE_KEY = "RSA PRIVATE KEY"

功能：记录条目类型为 RSA 私钥

LABEL_PUBLIC_KEY

public static let LABEL_PUBLIC_KEY = "PUBLIC KEY"

功能：记录条目类型为公钥

LABEL_EC_PARAMETERS

public static let LABEL_EC_PARAMETERS = "EC PARAMETERS"

功能：记录条目类型为椭圆曲线参数

LABEL_DH_PARAMETERS

public static let LABEL_DH_PARAMETERS = "DH PARAMETERS"

功能：记录条目类型为 DH 密钥参数

struct Pem

public struct Pem <: Collection<PemEntry> & ToString {
    public Pem(private let items: Array<PemEntry>)
}

结构体 Pem 为条目序列，可以包含多个 PemEntry。

Pem

public Pem(private let items: Array<PemEntry>)

功能：构造 Pem 对象。

参数：

items：多个 PemEntry 对象

func encode

public func encode(): String

功能：返回PEM格式的字符串。行结束符将根据当前操作系统生成。

返回值：PEM 格式的字符串

func decode

public static func decode(text: String): Pem

功能：将 PEM 文本解码为条目序列。

参数：

text：PEM 字符串

返回值：PEM 条目序列

func toString

public override func toString(): String

功能：返回一个字符串，字符串内容是包含每个条目序列的标签。

返回值：包含每个条目序列的标签的字符串

func isEmpty

public override func isEmpty(): Bool

功能：判断 PEM 文本解码为条目序列是否为空。

返回值：PEM 文本解码为条目序列为空返回 true；否则，返回 false

func iterator

public override func iterator(): Iterator<PemEntry>

功能：生成 PEM 文本解码为条目序列的迭代器。

返回值：PEM 文本解码为条目序列的迭代器

prop size

public override prop size: Int64

功能：条目序列的数量。

示例

读取、解析证书

from std import fs.File
from crypto import x509.*

let readPath = "./files/root_rsa.cer"
main() {
    // 读取本地证书
    let pem = String.fromUtf8(File.readFrom(readPath))
    let certificates = X509Certificate.decodeFromPem(pem)

    // 解析证书中的必选字段
    let cert = certificates[0]
    println(cert)
    println("Serial Number: ${cert.serialNumber}")
    println("Issuer: ${cert.issuer}")
    println("NotBefore: ${cert.notBefore}")
    println("NotAfter: ${cert.notAfter}")
    println(cert.signatureAlgorithm)
    let signature = cert.signature
    println(signature.hashCode())
    println(cert.publicKeyAlgorithm)
    let pubKey = cert.publicKey
    println(pubKey.encodeToPem().encode())

    // 解析证书中的扩展字段
    println("DNSNames: ${cert.dnsNames}")
    println("EmailAddresses: ${cert.emailAddresses}")
    println("IPAddresses: ${cert.IPAddresses}")
    println("KeyUsage: ${cert.keyUsage}")
    println("ExtKeyUsage: ${cert.extKeyUsage}")

    // 解析证书使用者的可辨识名称
    println("Subject: ${cert.subject}")

    return 0
}

读取、验证证书

from std import fs.File
from crypto import x509.*
from std import time.DateTime

let prefixPath = "./files/"
let certFile = "servers.crt"
let rootFile = "roots.crt"
let middleFile = "middles.crt"

func getX509Cert(path: String)
{
    let pem = String.fromUtf8(File.readFrom(path))
    X509Certificate.decodeFromPem(pem)
}


func testVerifyByTime(cert: X509Certificate, roots: Array<X509Certificate>, middles: Array<X509Certificate>)
{
    var opt = VerifyOption()
    opt.roots = roots
    opt.intermediates = middles
    cert.verify(opt)
    println("Verify result: ${cert.verify(opt)}")
    opt.time = DateTime.of(year: 2023, month: 7, dayOfMonth: 1)
    println("Verify result:: ${cert.verify(opt)}")
}

func testVerifyByDNS(cert: X509Certificate)
{
    var opt = VerifyOption()
    opt.dnsName = "www.example.com"
    println("cert DNS names: ${cert.dnsNames}")
    let res = cert.verify(opt)
    println("Verify result: ${res}")
}


/**
 * The relation of certs.
 *    root[0]         root[1]
 *    /      \            |
 *  mid[0]  mid[1]    mid[2]
 *   |                  |
 *  server[0]         server[1]
*/
func testVerify(cert: X509Certificate, roots: Array<X509Certificate>, middles: Array<X509Certificate>)
{
    var opt = VerifyOption()
    opt.roots = roots
    opt.intermediates = middles
    let res = cert.verify(opt)
    println("Verify result: ${res}")
}

main() {
    // 2 server certs
    let certs = getX509Cert(prefixPath + certFile)
    // 2 root certs
    let roots = getX509Cert(prefixPath + rootFile)
    // 3 middle certs
    let middles = getX509Cert(prefixPath + middleFile)
    // Verify by time: true, false
    testVerifyByTime(certs[0], [roots[0]], [middles[0]])
    // Verify by dns: false
    testVerifyByDNS(certs[0])
    // cert0 <- root0: false
    testVerify(certs[0], [roots[0]], [])
    // cert0 <- middle0 <- root0: true
    testVerify(certs[0], [roots[0]], [middles[0]])
    // cert0 <- (middle0, middle1, middle2) <- (root0, root1) : true
    testVerify(certs[0], roots, middles)
    // cert1 <- middle0 <- root0: false
    testVerify(certs[1], [roots[0]], [middles[0]])
    // cert1 <- middle2 <- root1: true
    testVerify(certs[1], [roots[1]], [middles[2]])
    // cert1 <- (middle0, middle1, middle2) <- (root0, root1) : true
    testVerify(certs[1], roots, middles)
    return 0
}

创建、解析证书

from std import fs.*
from crypto import x509.*

main(){
    let x509Name = X509Name(
        countryName: "CN",
        provinceName: "beijing",
        localityName: "haidian",
        organizationName: "organization",
        organizationalUnitName: "organization unit",
        commonName: "x509",
        email: "test@email.com"
    )
    let serialNumber = SerialNumber(length: 20)
    let startTime: DateTime = DateTime.now()
    let endTime: DateTime = notBefore.addYears(1)
    let ip1: IP = Array<Byte>([8, 8, 8, 8])
    let ip2: IP = Array<Byte>([0, 1, 0, 1, 0, 1, 0, 1, 0, 8, 0, 8, 0, 8, 0, 8])
    let parentCertPem = String.fromUtf8(File("./certificate.pem", OpenOption.Open(true, false)).readToEnd())
    let parentCert = X509Certificate.decodeFromPem(parentCertPem)[0]
    let parentKeyPem = String.fromUtf8(File("./rsa_private_key.pem", OpenOption.Open(true, false)).readToEnd())
    let parentPrivateKey = PrivateKey.decodeFromPem(parentKeyPem)
    let usrKeyPem = String.fromUtf8(File("./ecdsa_public_key.pem", OpenOption.Open(true, false)).readToEnd())
    let usrPublicKey = PublicKey.decodeFromPem(usrKeyPem)

    let certInfo = X509CertificateInfo(serialNumber: serialNumber, notBefore: startTime, notAfter: endTime, subject: x509Name, dnsNames: Array<String>(["b.com"]), IPAddresses: Array<IP>([ip1, ip2]));
    let cert = X509Certificate(info, parent: parentCert, publicKey: usrPublicKey, privateKey: parentPrivateKey)

    println(cert)
    println("Serial Number: ${cert.serialNumber}")
    println("Issuer: ${cert.issuer}")
    println("Subject: ${cert.subject}")
    println("NotBefore: ${cert.notBefore}")
    println("NotAfter: ${cert.notAfter}")
    println(cert.signatureAlgorithm)
    println("DNSNames: ${cert.dnsNames}")
    println("IPAddresses: ${cert.IPAddresses}")

    return 0
}

创建、解析证书签名请求

from std import fs.*
from crypto import x509.*

main(){
    let x509Name = X509Name(
        countryName: "CN",
        provinceName: "beijing",
        localityName: "haidian",
        organizationName: "organization",
        organizationalUnitName: "organization unit",
        commonName: "x509",
        email: "test@email.com"
    )
    let ip1:IP = Array<Byte>([8, 8, 8, 8])
    let ip2:IP = Array<Byte>([0, 1, 0, 1, 0, 1, 0, 1, 0, 8, 0, 8, 0, 8, 0, 8])
    let rsaPem = String.fromUtf8(File("./rsa_private_key.pem", OpenOption.Open(true, false)).readToEnd())
    let rsa = PrivateKey.decodeFromPem(rsaPem)

    let csrInfo = X509CertificateRequestInfo(subject: x509Name, dnsNames: Array<String>(["b.com"]), IPAddresses: Array<IP>([ip1, ip2]));
    let csr = X509CertificateRequest(rsa, certificateRequestInfo:csrInfo, signatureAlgorithm: SHA256WithRSA)

    println("Subject: ${csr.subject.toString()}")
    println("IPAddresses: ${csr.IPAddresses}")
    println("dnsNames: ${csr.dnsNames}")

    return 0
}

仓颉用户手册