【k8s admission 学习】使用 go 语言创建自签证书及签发证书
在使用openssl创建证书时,遵循的步骤是 创建秘钥 > 创建CA > 生成要颁发证书的秘钥 > 使用CA签发证书。不管是根证书,中级证书还是终端域名证书,都需要先生成一个私钥,然后通过私钥来获取公钥再进行证书签名,OpenSSL 可以通过。这样我们就配置好了三级证书的签名请求了,这里都是分开写的,大部分代码都是一样的,可以写成一个方法,这里就不扩展了。如上,我们完成了证书的生成、存储和读取等能
使用go 创建证书
参考
- 自动管理 Admission Webhook TLS 证书
- 何使用go创建CA,并使用CA签署证书 非常棒
- 使用Go语言生成自签CA证书
- 使用golang进行证书签发和双向认证
- OpenSSL生成root CA及签发证书
流程
首先梳理一下流程 —— 创建秘钥 > 创建CA > 生成要颁发证书的秘钥 > 使用CA签发证书
- 正常情况下,电脑会内置 CA 机构证书(用于验证其他证书),但这个 CA 机构证书是需要花钱注册的,所以我们自行创建个 CA 机构,用于签发和验证证书
- 同时我们需要考虑将 CA 的机构证书,分发给需要验证证书的客户端(相当于内置到电脑中,只不过这一步是需要我们自己做,付费的 CA 机构证书是让厂商或浏览器直接嵌入了)
- 创建 CA 机构。
- 填写证书签名请求 CSR,
- 创建公私钥,
- 之后利用自己 csr 和私钥 对自己的 csr 和 公钥进行签名,也就是自签名,生成 CA 机构证书(证书内包含就是一些个人信息、网站信息、有效期和最重要的公钥(用于验证其他证书))
- 签名其他证书。
- 填写证书签名请求 CSR,
- 创建公私钥,
- 之后利用 CA 机构的 csr 和私钥 对自己的 csr 和 公钥进行签名,实现证书的签发
创建证书流程
本篇文章中,将描述如何使用go创建CA,并使用CA签署证书。在使用openssl创建证书时,遵循的步骤是 创建秘钥 > 创建CA > 生成要颁发证书的秘钥 > 使用CA签发证书。这种步骤,那么我们现在就来尝试下。
创建证书的颁发机构
首先,会从将从创建 CA 开始。CA 会被用来签署其他证书
// 对证书进行签名
ca := &x509.Certificate{
SerialNumber: big.NewInt(2019),
Subject: pkix.Name{
CommonName: "domain name",
Organization: []string{"Company, INC."},
Country: []string{"US"},
Province: []string{""},
Locality: []string{"San Francisco"},
StreetAddress: []string{"Golden Gate Bridge"},
PostalCode: []string{"94016"},
},
NotBefore: time.Now(), // 生效时间
NotAfter: time.Now().AddDate(10, 0, 0), // 过期时间 年月日
IsCA: true, // 表示用于CA
// openssl 中的 extendedKeyUsage = clientAuth, serverAuth 字段
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
// openssl 中的 keyUsage 字段
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
BasicConstraintsValid: true,
}
接下来需要对证书生成公钥和私钥
caPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
if err != nil {
return err
}
然后生成证书:
// 第一个参数 rand.Reader 就是生成个随机数
// 第二个参数 ca 是 待签证书(此处后续改为其他证书,实现对其他证书的签名,此处是自签,用于构造 ca 机构证书)
// 第三个参数 ca 是 ca机构证书
// 第四个参数 &caPrivKey.PublicKey 对应着 第二个参数申请证书对应的公钥(因为证书就是为了安全传输公钥)
// 第五个参数 caPrivKey 是 ca 机构的私钥,用于签名证书,这样第二个证书被签名后,传给客户,客户就可以通过内置ca机构证书中的公钥,解开并验证第二个证书
caBytes, err := x509.CreateCertificate(rand.Reader, ca, ca, &caPrivKey.PublicKey, caPrivKey)
if err != nil {
return err
}
我们看到的证书内容是PEM编码后的,现在caBytes
我们有了生成的证书,我们将其进行 PEM 编码以供以后使用:
caPEM := new(bytes.Buffer)
pem.Encode(caPEM, &pem.Block{
Type: "CERTIFICATE",
Bytes: caBytes,
})caPrivKeyPEM := new(bytes.Buffer)
pem.Encode(caPrivKeyPEM, &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(caPrivKey),
})
创建证书
证书的 x509.Certificate
与CA的 x509.Certificate
属性有稍微不同,需要进行一些修改
cert := &x509.Certificate{
SerialNumber: big.NewInt(1658),
Subject: pkix.Name{
CommonName: "domain name",
Organization: []string{"Company, INC."},
Country: []string{"US"},
Province: []string{""},
Locality: []string{"San Francisco"},
StreetAddress: []string{"Golden Gate Bridge"},
PostalCode: []string{"94016"},
},
IPAddresses: []net.IP{}, // 这里就是openssl配置文件中 subjectAltName 里的 IP:/IP=
DNSNames: []string{}, // 这里就是openssl配置文件中 subjectAltName 里的 DNS:/DNS=
NotBefore: time.Now(),
NotAfter: time.Now().AddDate(10, 0, 0),
SubjectKeyId: []byte{1, 2, 3, 4, 6},
// 这里就是openssl中的extendedKeyUsage
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
KeyUsage: x509.KeyUsageDigitalSignature,
}
注:这里会在证书中特别添加了
DNS
和IP
(这个不是必须的),这个选项的增加代表的我们的证书可以支持多域名
为该证书创建私钥和公钥:
certPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
if err != nil {
return err
}
使用CA签署证书
有了上述的内容后,可以创建证书并用CA进行签名
certBytes, err := x509.CreateCertificate(rand.Reader, cert, ca, &certPrivKey.PublicKey, caPrivKey)
if err != nil {
return err
}
要保存成证书格式需要做PEM编码
certPEM := new(bytes.Buffer)
pem.Encode(certPEM, &pem.Block{
Type: "CERTIFICATE",
Bytes: certBytes,
})certPrivKeyPEM := new(bytes.Buffer)
pem.Encode(certPrivKeyPEM, &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(certPrivKey),
})
把上面内容融合为一起
创建一个 ca.go
里面是创建ca和颁发证书的逻辑
package mainimport (
"bytes"
cr "crypto/rand"
"crypto/rsa"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"math/big"
"math/rand"
"net"
"os"
"time"
)type CERT struct {
CERT []byte
CERTKEY *rsa.PrivateKey
CERTPEM *bytes.Buffer
CERTKEYPEM *bytes.Buffer
CSR *x509.Certificate
}func CreateCA(sub *pkix.Name, expire int) (*CERT, error) {
var (
ca = new(CERT)
err error
) if expire < 1 {
expire = 1
}
// 为ca生成私钥
ca.CERTKEY, err = rsa.GenerateKey(cr.Reader, 4096)
if err != nil {
return nil, err
} // 对证书进行签名
ca.CSR = &x509.Certificate{
SerialNumber: big.NewInt(rand.Int63n(2000)),
Subject: *sub,
NotBefore: time.Now(), // 生效时间
NotAfter: time.Now().AddDate(expire, 0, 0), // 过期时间
IsCA: true, // 表示用于CA
// openssl 中的 extendedKeyUsage = clientAuth, serverAuth 字段
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
// openssl 中的 keyUsage 字段
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
BasicConstraintsValid: true,
}
// 创建证书
// caBytes 就是生成的证书
ca.CERT, err = x509.CreateCertificate(cr.Reader, ca.CSR, ca.CSR, &ca.CERTKEY.PublicKey, ca.CERTKEY)
if err != nil {
return nil, err
}
ca.CERTPEM = new(bytes.Buffer)
pem.Encode(ca.CERTPEM, &pem.Block{
Type: "CERTIFICATE",
Bytes: ca.CERT,
})
ca.CERTKEYPEM = new(bytes.Buffer)
pem.Encode(ca.CERTKEYPEM, &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(ca.CERTKEY),
}) // 进行PEM编码,编码就是直接cat证书里面内容显示的东西
return ca, nil
}func Req(ca *x509.Certificate, sub *pkix.Name, expire int, dns []string, ip []net.IP) (*CERT, error) {
var (
cert = &CERT{}
err error
)
cert.CERTKEY, err = rsa.GenerateKey(cr.Reader, 4096)
if err != nil {
return nil, err
}
if expire < 1 {
expire = 1
}
cert.CSR = &x509.Certificate{
SerialNumber: big.NewInt(rand.Int63n(2000)),
Subject: *sub,
IPAddresses: ip,
DNSNames: dns,
NotBefore: time.Now(),
NotAfter: time.Now().AddDate(expire, 0, 0),
SubjectKeyId: []byte{1, 2, 3, 4, 6},
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
KeyUsage: x509.KeyUsageDigitalSignature,
} cert.CERT, err = x509.CreateCertificate(cr.Reader, cert.CSR, ca, &cert.CERTKEY.PublicKey, cert.CERTKEY)
if err != nil {
return nil, err
} cert.CERTPEM = new(bytes.Buffer)
pem.Encode(cert.CERTPEM, &pem.Block{
Type: "CERTIFICATE",
Bytes: cert.CERT,
})
cert.CERTKEYPEM = new(bytes.Buffer)
pem.Encode(cert.CERTKEYPEM, &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(cert.CERTKEY),
})
return cert, nil
}func Write(cert *CERT, file string) error {
keyFileName := file + ".key"
certFIleName := file + ".crt"
kf, err := os.Create(keyFileName)
if err != nil {
return err
}
defer kf.Close() if _, err := kf.Write(cert.CERTKEYPEM.Bytes()); err != nil {
return err
} cf, err := os.Create(certFIleName)
if err != nil {
return err
}
if _, err := cf.Write(cert.CERTPEM.Bytes()); err != nil {
return err
}
return nil
}
如果需要使用的话,可以引用这些函数
package mainimport (
"crypto/x509/pkix"
"log"
"net"
)func main() {
subj := &pkix.Name{
CommonName: "chinamobile.com",
Organization: []string{"Company, INC."},
Country: []string{"US"},
Province: []string{""},
Locality: []string{"San Francisco"},
StreetAddress: []string{"Golden Gate Bridge"},
PostalCode: []string{"94016"},
}
ca, err := CreateCA(subj, 10)
if err != nil {
log.Panic(err)
} Write(ca, "./ca") crt, err := Req(ca.CSR, subj, 10, []string{"test.default.svc", "test"}, []net.IP{}) if err != nil {
log.Panic(err)
} Write(crt, "./tls")
}
遇到的问题
panic: x509: unsupported public key type: rsa.PublicKey
这里是因为 x509.CreateCertificate
的参数 privatekey
需要传入引用变量,而传入的是一个普通变量
注:x509: only RSA and ECDSA public keys supported
一些参数的意思
extendedKeyUsage
:增强型密钥用法(参见"new_oids"字段):服务器身份验证、客户端身份验证、时间戳。
extendedKeyUsage = critical,serverAuth, clientAuth, timeStamping
keyUsage
: 密钥用法,防否认(nonRepudiation)、数字签名(digitalSignature)、密钥加密(keyEncipherment)。
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
Reference
其他参考资料
生成私钥证书
不管是根证书,中级证书还是终端域名证书,都需要先生成一个私钥,然后通过私钥来获取公钥再进行证书签名,OpenSSL 可以通过 ecparam
子命令生成 ECC 私钥证书,Go 的标准库 crypto/ecdsa
也提供了 ECC 生成私钥的方法,我们稍微进行一下封装:
// 生成 ECC 私钥
func GeneratePrivateKey() (key *ecdsa.PrivateKey) {
key, _ = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
return
}
这里的 elliptic.P256()
就是 prime256v1
,这样我们就有了一个通用的生成 ECC 私钥的方法了。
构建证书签名请求 CSR
Go 提供了标准库 crypto/x509
给我们提供了 x509 签证的能力,我们可以先通过 x509.Certificate
构建证书签名请求 CSR 然后再进行签证。
x509.Certificate
参数解析
x509.Certificate
有以下参数可配置:
Version
: 证书的版本,数字1,2,3
。SerialNumber
:证书序列号,标识证书的唯一整数,重复的编号无法安装到系统里。SignatureAlgorithm
: 签证书的算法标识,缺省。PublicKeyAlgorithm
: 生成公钥的算法,缺省。Subject
:证书持有者的信息。Country
: 国家,CN。Province
: 省。Locality
: 市。Organization
: 证书持有者组织名称。OrganizationalUnit
: 证书持有者组织唯一标识。CommonName
: 证书持有者通用名,需保持唯一,否则验证会失败。
NotBefore
: 证书有效期开始时间。NotAfter
: 证书过期时间。EmailAddresses
: 需要颁发证书的邮箱地址。DNSNames
: 需要颁发证书的 DNS,也就是域名。IPAddresses
: 需要颁发证书的 IP 地址。URIs
: 需要颁发证书的 URI。BasicConstraintsValid
: 为true
表示IsCA
/MaxPathLen
/MaxPathLenZero
有效,为false
忽略这几个配置。IsCA
: 是否为CA证书,CA证书可以为下级证书签证,为false
代表是终端证书,不能继续签证,根证书和中级证书都应该为true
。MaxPathLen
: 表示证书链中可在此证书之后的非自颁发中级证书的最大层级,我们只需要1个中级证书就可以了,根证书设置为1,中级证书设置为0,那么中级证书就不能继续签署中级证书了。-1
表示未设置,且MaxPathLenZero == false && MaxPathLen == 0
视为-1
。MaxPathLenZero
:MaxPathLen == 0
。KeyUsage
: 定义了证书包含的密钥的用途。KeyUsageDigitalSignature
: 用于数字签名,常用于具有完整性的实体身份验证和数据源身份验证。可以用于CA证书或终端证书。KeyUsageContentCommitment
: 公钥可用于提供不可否认服务,这可以防止签名实体错误地拒绝某些操作。当发生冲突时,应该有一个可靠的第三方来对签名的数据进行辨伪。KeyUsageKeyEncipherment
: 用于加密对称密钥,目标解密密钥,随后使用它来加密和解密实体之间的数据。KeyUsageDataEncipherment
: 用于加密和解密实际应用程序数据。KeyUsageKeyAgreement
: 使用密钥协商协议与目标建立对称密钥,然后可以使用对称密钥来加密和解密实体之间发送的数据。KeyUsageCertSign
: 用于校验公钥证书的签名,只能用于 CA 证书。KeyUsageCRLSign
: 用于验证证书吊销列表的签名,只能用于 CA 证书。KeyUsageEncipherOnly
: 公钥仅用于在执行密钥协商时加密数据。KeyUsageDecipherOnly
: 公钥仅用于在执行密钥协商时解密数据。
ExtKeyUsage
: 该扩展表示被认证的公钥的用途,可以替换或作为KeyUsage扩展的补充ExtKeyUsageAny
: 未知。ExtKeyUsageServerAuth
: 建立 TLS 连接时进行服务器身份验证。ExtKeyUsageClientAuth
: 建立 TLS 连接时进行客户端验证。ExtKeyUsageCodeSigning
: 对可下载执行的代码签名。ExtKeyUsageEmailProtection
: 安全电子邮件签名,允许发送和接收加密的电子邮件。ExtKeyUsageIPSECEndSystem
: IP 安全终端系统,已弃用。ExtKeyUsageIPSECTunnel
: IP 安全隧道,已弃用。ExtKeyUsageIPSECUser
: IP 安全用户,已弃用。ExtKeyUsageTimeStamping
: 可信时间戳。ExtKeyUsageOCSPSigning
: OCSP 签名。ExtKeyUsageMicrosoftServerGatedCrypto
: 未知。ExtKeyUsageNetscapeServerGatedCrypto
: 未知。ExtKeyUsageMicrosoftCommercialCodeSigning
: 未知。ExtKeyUsageMicrosoftKernelCodeSigning
: 未知。
我们使用这些字段就够了,其他字段缺省即可。可以使用这些参数分别签证生成根证书、中级证书和终端域名证书的签证 CSR。
根证书
var rootCsr = &x509.Certificate{
Version: 3,
SerialNumber: big.NewInt(time.Now().Unix()),
Subject: pkix.Name{
Country: []string{"CN"},
Province: []string{"Shanghai"},
Locality: []string{"Shanghai"},
Organization: []string{"JediLtd"},
OrganizationalUnit: []string{"JediProxy"},
CommonName: "Jedi Root CA",
},
NotBefore: time.Now(),
NotAfter: time.Now().AddDate(10, 0, 0),
BasicConstraintsValid: true,
IsCA: true,
MaxPathLen: 1,
MaxPathLenZero: false,
KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
}
根证书的配置如上,CommonName
叫 Jedi Root CA
,用来区分这是一个根证书,过期时间设置为十年,根证书十年足够了,MaxPathLen
为1,只能签发一级中级CA证书。
KeyUsage
为 KeyUsageCertSign
和 KeyUsageCRLSign
,支持签发和吊销中级证书。这里不需要 ExtKeyUsage
。
中级证书
中级证书的配置基本与根证书基本一致,只是需要改一下 MaxPathLen
为0,过期时间短一些:
var interCsr = &x509.Certificate{
Version: 3,
SerialNumber: big.NewInt(time.Now().Unix()),
Subject: pkix.Name{
Country: []string{"CN"},
Province: []string{"Shanghai"},
Locality: []string{"Shanghai"},
Organization: []string{"JediLtd"},
OrganizationalUnit: []string{"JediProxy"},
CommonName: "Jedi Inter CA",
},
NotBefore: time.Now(),
NotAfter: time.Now().AddDate(1, 0, 0),
BasicConstraintsValid: true,
IsCA: true,
MaxPathLen: 0,
MaxPathLenZero: true,
KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
}
终端证书
终端域名证书的配置需要做一些变更,配置如下:
var csr = &x509.Certificate{
Version: 3,
SerialNumber: big.NewInt(time.Now().Unix()),
Subject: pkix.Name{
Country: []string{"CN"},
Province: []string{"Shanghai"},
Locality: []string{"Shanghai"},
Organization: []string{"JediLtd"},
OrganizationalUnit: []string{"JediProxy"},
CommonName: "foreverz.cn",
},
DNSNames: []string{"foreverz.cn"},
NotBefore: time.Now(),
NotAfter: time.Now().AddDate(1, 0, 0),
BasicConstraintsValid: true,
IsCA: false,
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
}
因为是终端域名证书,所以DNSNames
需要设置为对应的域名,可以使用通配符*
支持所有的三级域名,例如这里可以写成*.foreverz.cn
,也可以使用一个整数签发多个域名。
因为不是CA证书了,所以IsCA
设为false
,也不需要配置MaxPathLen
和MaxPathLenZero
了。
KeyUsage
为 KeyUsageDigitalSignature
和 KeyUsageKeyEncipherment
,可用于身份验证和数据加密传输。ExtKeyUsage
为 ExtKeyUsageServerAuth
可以进行服务端身份验证。
这样我们就配置好了三级证书的签名请求了,这里都是分开写的,大部分代码都是一样的,可以写成一个方法,这里就不扩展了。
证书签名
证书签名可以使用标准库 crypto/x509
的 CreateCertificate
方法来签名。该方法需要以下5个参数:
rand
: 随机数,使用rand.Reader
即可。template
: 证书签名请求,即上面的 CSR。parent
: 父级证书,根证书是自签的,直接用自己的 csr,中级证书用根证书来签名,终端证书使用中级证书签名。pub
: 第一步生成的私钥对应的公钥证书,可以使用key.Public()
获取。priv
: 父级证书私钥。
具体签证方法如下:
rootDer, err := x509.CreateCertificate(rand.Reader, rootCsr, rootCsr, rootKey.Public(), rootKey)
rootCert, err := x509.ParseCertificate(rootDer)
CreateCertificate
返回的是一个 []byte
,是二进制DER编码的证书,可以使用 x509.ParseCertificate
转为 *x509.Certificate
格式。
生成了根证书就可以使用根证书签证中级证书了:
interDer, err := x509.CreateCertificate(rand.Reader, interCsr, rootCert, interKey.Public(), rootKey)
interCert, err := x509.ParseCertificate(interDer)
终端证书的生成与中级证书基本一致:
der, err := x509.CreateCertificate(rand.Reader, csr, interCert, key.Public(), interKey)
cert, err := x509.ParseCertificate(der)
保存 PEM 文件
上面生成的证书是 *x509.Certificate
格式的,我们需要转为 PEM 并存为 .pem
文件到本地才能安装到电脑上,可以通过以下方法进行转换:
签证证书:
certBlock := &pem.Block{
Type: "CERTIFICATE",
Bytes: cert.Raw,
}
pemData := pem.EncodeToMemory(certBlock)
if err = ioutil.WriteFile("xx.cert.pem", pemData, 0644); err != nil {
panic(err)
}
私钥证书:
keyDer, err := x509.MarshalECPrivateKey(key)
keyBlock := &pem.Block{
Type: "EC PRIVATE KEY",
Bytes: keyDer,
}
keyData := := pem.EncodeToMemory(certBlock)
if err = ioutil.WriteFile("xx.key.pem", keyData, 0644); err != nil {
panic(err)
}
从 PEM 文件读取证书
上面我们把证书文件转为了 PEM 文件,那么有时候就会从 PEM 文件读取证书,我们没必要手写文件读取方法,crypto/tls
提供了 LoadX509KeyPair
方法可以帮助我们从文件读取证书,然后稍微做一下转换就行了。
func LoadPair(certFile, keyFile string) (cert *x509.Certificate, err error) {
if len(certFile) == 0 && len(keyFile) == 0 {
return nil, errors.New("cert or key has not provided")
}
// load cert and key by tls.LoadX509KeyPair
tlsCert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return
}
cert, err = x509.ParseCertificate(tlsCert.Certificate[0])
return
}
如上,我们完成了证书的生成、存储和读取等能力,证书相关的处理就结束了。
参考
更多推荐
所有评论(0)