通过Go语言创建CA与签发证书

本篇文章中，将描述如何使用go创建CA，并使用CA签署证书。在使用openssl创建证书时，遵循的步骤是 创建秘钥 > 创建CA > 生成要颁发证书的秘钥 > 使用CA签发证书。这种步骤，那么我们现在就来尝试下。
创建证书的颁发机构

首先，会从将从创建 CA 开始。CA 会被用来签署其他证书

1. // 对证书进行签名
2. ca := &x509.Certificate{
3.         SerialNumber: big.NewInt(2019),
4.         Subject: pkix.Name{
5.         CommonName:    "domain name",
6.                 Organization:  []string{"Company, INC."},
7.                 Country:       []string{"US"},
8.                 Province:      []string{""},
9.                 Locality:      []string{"San Francisco"},
10.                 StreetAddress: []string{"Golden Gate Bridge"},
11.                 PostalCode:    []string{"94016"},
12.         },
13.         NotBefore:             time.Now(),  // 生效时间
14.         NotAfter:              time.Now().AddDate(10, 0, 0), // 过期时间 年月日
15.         IsCA:                  true, // 表示用于CA
16.     // openssl 中的 extendedKeyUsage = clientAuth, serverAuth 字段
17.         ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
18.     // openssl 中的 keyUsage 字段
19.         KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
20.         BasicConstraintsValid: true,
21. }

复制代码

接下来需要对证书生成公钥和私钥

1. caPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
2. if err != nil {
3.         return err
4. }

复制代码

然后生成证书：

1. caBytes, err := x509.CreateCertificate(rand.Reader, ca, ca, &caPrivKey.PublicKey, caPrivKey)
2. if err != nil {
3.         return err
4. }

复制代码

我们看到的证书内容是PEM编码后的，现在caBytes我们有了生成的证书，我们将其进行 PEM 编码以供以后使用：

1. caPEM := new(bytes.Buffer)
2. pem.Encode(caPEM, &pem.Block{
3.         Type:  "CERTIFICATE",
4.         Bytes: caBytes,
5. })
7. caPrivKeyPEM := new(bytes.Buffer)
8. pem.Encode(caPrivKeyPEM, &pem.Block{
9.         Type:  "RSA PRIVATE KEY",
10.         Bytes: x509.MarshalPKCS1PrivateKey(caPrivKey),
11. })

复制代码

创建证书

证书的 x509.Certificate 与CA的 x509.Certificate 属性有稍微不同，需要进行一些修改

1. cert := &x509.Certificate{
2.         SerialNumber: big.NewInt(1658),
3.         Subject: pkix.Name{
4.         CommonName:    "domain name",
5.                 Organization:  []string{"Company, INC."},
6.                 Country:       []string{"US"},
7.                 Province:      []string{""},
8.                 Locality:      []string{"San Francisco"},
9.                 StreetAddress: []string{"Golden Gate Bridge"},
10.                 PostalCode:    []string{"94016"},
11.         },
12.     IPAddresses:  []net.IP{}, // 这里就是openssl配置文件中 subjectAltName 里的 IP:/IP=
13.     DNSNames:     []string{}, // 这里就是openssl配置文件中 subjectAltName 里的 DNS:/DNS=
14.         NotBefore:    time.Now(),
15.         NotAfter:     time.Now().AddDate(10, 0, 0),
16.         SubjectKeyId: []byte{1, 2, 3, 4, 6},
17.     // 这里就是openssl中的extendedKeyUsage
18.         ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
19.         KeyUsage:     x509.KeyUsageDigitalSignature,
20. }

复制代码

注：这里会在证书中特别添加了 DNS 和 IP （这个不是必须的），这个选项的增加代表的我们的证书可以支持多域名

为该证书创建私钥和公钥：

1. certPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
2. if err != nil {
3.         return err
4. }

复制代码

使用CA签署证书

有了上述的内容后，可以创建证书并用CA进行签名

1. certBytes, err := x509.CreateCertificate(rand.Reader, cert, ca, &certPrivKey.PublicKey, caPrivKey)
2. if err != nil {
3.         return err
4. }

复制代码

要保存成证书格式需要做PEM编码

1. certPEM := new(bytes.Buffer)
2. pem.Encode(certPEM, &pem.Block{
3.         Type:  "CERTIFICATE",
4.         Bytes: certBytes,
5. })
7. certPrivKeyPEM := new(bytes.Buffer)
8. pem.Encode(certPrivKeyPEM, &pem.Block{
9.         Type:  "RSA PRIVATE KEY",
10.         Bytes: x509.MarshalPKCS1PrivateKey(certPrivKey),
11. })

复制代码

把上面内容融合为一起

创建一个 ca.go 里面是创建ca和颁发证书的逻辑

1. package main
3. import (
4.         "bytes"
5.         cr "crypto/rand"
6.         "crypto/rsa"
7.         "crypto/x509"
8.         "crypto/x509/pkix"
9.         "encoding/pem"
10.         "math/big"
11.         "math/rand"
12.         "net"
13.         "os"
14.         "time"
15. )
17. type CERT struct {
18.         CERT       []byte
19.         CERTKEY    *rsa.PrivateKey
20.         CERTPEM    *bytes.Buffer
21.         CERTKEYPEM *bytes.Buffer
22.         CSR        *x509.Certificate
23. }
25. func CreateCA(sub *pkix.Name, expire int) (*CERT, error) {
26.         var (
27.                 ca  = new(CERT)
28.                 err error
29.         )
31.         if expire < 1 {
32.                 expire = 1
33.         }
34.         // 为ca生成私钥
35.         ca.CERTKEY, err = rsa.GenerateKey(cr.Reader, 4096)
36.         if err != nil {
37.                 return nil, err
38.         }
40.         // 对证书进行签名
41.         ca.CSR = &x509.Certificate{
42.                 SerialNumber: big.NewInt(rand.Int63n(2000)),
43.                 Subject:      *sub,
44.                 NotBefore:    time.Now(),                       // 生效时间
45.                 NotAfter:     time.Now().AddDate(expire, 0, 0), // 过期时间
46.                 IsCA:         true,                             // 表示用于CA
47.                 // openssl 中的 extendedKeyUsage = clientAuth, serverAuth 字段
48.                 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
49.                 // openssl 中的 keyUsage 字段
50.                 KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
51.                 BasicConstraintsValid: true,
52.         }
53.         // 创建证书
54.         // caBytes 就是生成的证书
55.         ca.CERT, err = x509.CreateCertificate(cr.Reader, ca.CSR, ca.CSR, &ca.CERTKEY.PublicKey, ca.CERTKEY)
56.         if err != nil {
57.                 return nil, err
58.         }
59.         ca.CERTPEM = new(bytes.Buffer)
60.         pem.Encode(ca.CERTPEM, &pem.Block{
61.                 Type:  "CERTIFICATE",
62.                 Bytes: ca.CERT,
63.         })
64.         ca.CERTKEYPEM = new(bytes.Buffer)
65.         pem.Encode(ca.CERTKEYPEM, &pem.Block{
66.                 Type:  "RSA PRIVATE KEY",
67.                 Bytes: x509.MarshalPKCS1PrivateKey(ca.CERTKEY),
68.         })
70.         // 进行PEM编码，编码就是直接cat证书里面内容显示的东西
71.         return ca, nil
72. }
74. func Req(ca *x509.Certificate, sub *pkix.Name, expire int, dns []string, ip []net.IP) (*CERT, error) {
75.         var (
76.                 cert = &CERT{}
77.                 err  error
78.         )
79.         cert.CERTKEY, err = rsa.GenerateKey(cr.Reader, 4096)
80.         if err != nil {
81.                 return nil, err
82.         }
83.         if expire < 1 {
84.                 expire = 1
85.         }
86.         cert.CSR = &x509.Certificate{
87.                 SerialNumber: big.NewInt(rand.Int63n(2000)),
88.                 Subject:      *sub,
89.                 IPAddresses:  ip,
90.                 DNSNames:     dns,
91.                 NotBefore:    time.Now(),
92.                 NotAfter:     time.Now().AddDate(expire, 0, 0),
93.                 SubjectKeyId: []byte{1, 2, 3, 4, 6},
94.                 ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
95.                 KeyUsage:     x509.KeyUsageDigitalSignature,
96.         }
98.         cert.CERT, err = x509.CreateCertificate(cr.Reader, cert.CSR, ca, &cert.CERTKEY.PublicKey, cert.CERTKEY)
99.         if err != nil {
100.                 return nil, err
101.         }
103.         cert.CERTPEM = new(bytes.Buffer)
104.         pem.Encode(cert.CERTPEM, &pem.Block{
105.                 Type:  "CERTIFICATE",
106.                 Bytes: cert.CERT,
107.         })
108.         cert.CERTKEYPEM = new(bytes.Buffer)
109.         pem.Encode(cert.CERTKEYPEM, &pem.Block{
110.                 Type:  "RSA PRIVATE KEY",
111.                 Bytes: x509.MarshalPKCS1PrivateKey(cert.CERTKEY),
112.         })
113.         return cert, nil
114. }
116. func Write(cert *CERT, file string) error {
117.         keyFileName := file + ".key"
118.         certFIleName := file + ".crt"
119.         kf, err := os.Create(keyFileName)
120.         if err != nil {
121.                 return err
122.         }
123.         defer kf.Close()
125.         if _, err := kf.Write(cert.CERTKEYPEM.Bytes()); err != nil {
126.                 return err
127.         }
129.         cf, err := os.Create(certFIleName)
130.         if err != nil {
131.                 return err
132.         }
133.         if _, err := cf.Write(cert.CERTPEM.Bytes()); err != nil {
134.                 return err
135.         }
136.         return nil
137. }

复制代码

如果需要使用的话，可以引用这些函数

1. package main
3. import (
4.         "crypto/x509/pkix"
5.         "log"
6.         "net"
7. )
9. func main() {
10.         subj := &pkix.Name{
11.                 CommonName:    "chinamobile.com",
12.                 Organization:  []string{"Company, INC."},
13.                 Country:       []string{"US"},
14.                 Province:      []string{""},
15.                 Locality:      []string{"San Francisco"},
16.                 StreetAddress: []string{"Golden Gate Bridge"},
17.                 PostalCode:    []string{"94016"},
18.         }
19.         ca, err := CreateCA(subj, 10)
20.         if err != nil {
21.                 log.Panic(err)
22.         }
24.         Write(ca, "./ca")
26.         crt, err := Req(ca.CSR, subj, 10, []string{"test.default.svc", "test"}, []net.IP{})
28.         if err != nil {
29.                 log.Panic(err)
30.         }
32.         Write(crt, "./tls")
33. }

复制代码

遇到的问题

panic: x509: unsupported public key type: rsa.PublicKey
这里是因为 x509.CreateCertificate 的参数 privatekey 需要传入引用变量，而传入的是一个普通变量

注：x509: only RSA and ECDSA public keys supported

一些参数的意思

extendedKeyUsage ：增强型密钥用法(参见"new_oids"字段)：服务器身份验证、客户端身份验证、时间戳。

1. extendedKeyUsage = critical,serverAuth, clientAuth, timeStamping

复制代码

keyUsage ： 密钥用法，防否认(nonRepudiation)、数字签名(digitalSignature)、密钥加密(keyEncipherment)。

1. keyUsage = nonRepudiation, digitalSignature, keyEncipherment

复制代码

Reference
golang ca and signed cert go
package x509

出处：http://lc161616.cnblogs.com/本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 阿里云优惠：点击力享低价墨墨学英语：帮忙点一下
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！