网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go语言实现双向TLS认证的REST Service

2020-06-10 02:58:20 admin 587

用go语言开发一个REST Service例子，实现服务器和客户端双向认证

# 服务器端代码如下

package main
    
    import (
        "fmt"
        "log"
        "flag"
        "net/http"
        "io/ioutil"
        "crypto/tls"
        "crypto/x509"
        "encoding/json"
        "github.com/gorilla/mux"
    )
    
    var (
        port       int
        hostname   string 
        caroots    string
        keyfile    string
        signcert   string
    )
    
    func init() {
        flag.IntVar(&port,          "port",     8080,       "The host port on which the REST server will listen")
        flag.StringVar(&hostname,   "hostname", "0.0.0.0",  "The host name on which the REST server will listen")
        flag.StringVar(&caroots,    "caroot",   "",         "Path to file containing PEM-encoded trusted certificate(s) for clients")
        flag.StringVar(&keyfile,    "key",      "",         "Path to file containing PEM-encoded key file for service")
        flag.StringVar(&signcert,   "signcert", "",         "Path to file containing PEM-encoded sign certificate for service")
    }
    
    func startServer(address string, caroots string, keyfile string, signcert string, router *mux.Router) {
        pool := x509.NewCertPool()
    
        caCrt, err := ioutil.ReadFile(caroots)
        if err != nil {
            log.Fatalln("ReadFile err:", err)
        }
        pool.AppendCertsFromPEM(caCrt)
    
        s := &http.Server{
                Addr:    address,
                Handler: router,
                TLSConfig: &tls.Config{
                    MinVersion: tls.VersionTLS12,
                    ClientCAs:  pool,
                    ClientAuth: tls.RequireAndVerifyClientCert,
                },
        }
        err = s.ListenAndServeTLS(signcert, keyfile)
        if err != nil {
            log.Fatalln("ListenAndServeTLS err:", err)
        }
    }
    
    func SayHello(w http.ResponseWriter, r *http.Request) {
        log.Println("Entry SayHello")
        res := map[string]string {"hello": "world"}
    
        b, err := json.Marshal(res)
        if err == nil {
            w.WriteHeader(http.StatusOK)
            w.Header().Set("Content-Type", "application/json")
            w.Write(b)
        }
    
        log.Println("Exit SayHello")
    }
    
    func main() {
        flag.Parse()
    
        router := mux.NewRouter().StrictSlash(true)
        router.HandleFunc("/service/hello", SayHello).Methods("GET")
    
        var address = fmt.Sprintf("%s:%d", hostname, port)
        fmt.Println("Server listen on", address)
        startServer(address, caroots, keyfile, signcert, router)
        
        fmt.Println("Exit main")
    }

其中TLS配置项ClientAuth:
tls.RequireAndVerifyClientCert表明需要对客户端认证，也就是要完成服务器和客户端的双向认证。

# 生成服务端证书

* 生成服务端私钥  
`$ openssl genrsa -out server.key 2048`  
或者  
`$ openssl genrsa -des3 -out server.key 2048`  
此时需要用户输入密码，然后每次用到私钥的时候都需要再次输入密码。  
注意这个私钥非常重要，通常需要安全保存并且把读写权限改成600

* 生成服务端证书请求文件  
`$ openssl req -new -key server.key -out server.csr -subj
"/C=CN/ST=BJ/L=beijing/O=myorganization/OU=mygroup/CN=myname"`

注意这一步生成的是证书请求文件，不是证书文件，下面才会生成证书文件。

# 生成客户端端证书

这个过程和生成服务端证书一样

* 生成客户端私钥  
`$ openssl genrsa -out client.key 2048`

* 生成客户证书请求文件  
`$ openssl req -new -key client.key -out client.csr -subj
"/C=CN/ST=BJ/L=beijing/O=myorganization/OU=mygroup/CN=myname"`

# 生成服务器和客户端经过签名的证书

证书请求文件csr生成以后，需要将其发送给CA认证机构进行签发以生成真正的证书文件，当然在我们例子里，我们使用OpenSSL对该证书进行自签发。

* 生成根证书私钥  
`$ openssl genrsa -out ca.key 2048`

* 生成根证书请求文件  
`$ openssl req -new -key ca.key -out ca.csr -subj
"/C=CN/ST=BJ/L=beijing/O=myorganization/OU=mygroup/CN=myname"`

* 生成自签名的根证书文件  
`$ openssl x509 -req -days 365 -sha1 -extensions v3_ca -signkey ca.key -in
ca.csr -out ca.cer`

* 利用已签名根证书生成服务端证书和客户端证书  
** 生成服务端证书  
`$ openssl x509 -req -days 365 -sha1 -extensions v3_req -CA ca.cer -CAkey
ca.key -CAcreateserial -in server.csr -out server.cer`  
** 生成客户端证书  
`$ openssl x509 -req -days 365 -sha1 -extensions v3_req -CA ca.cer -CAkey
ca.key -CAcreateserial -in client.csr -out client.cer`

注意，关于extensions参数值v3_ca/v3_req的含义请参考openssl.cnf配置文件

$ locate openssl.cnf
    $ vim /etc/pki/tls/openssl.cnf
    
    [ v3_req ]
        basicConstraints = CA:FALSE
    ...
    [ v3_ca ]
        basicConstraints = CA:true

其中最重要的区别是，标识这是不是一个CA证书。

# 编译运行服务端程序

$ go build main.go
    $ ./main -caroot ./ca.cer -key ./server.key -signcert ./server.cer
    Server listen on 0.0.0.0:8080

# 运行客户端程序

$ curl --cacert ./ca.cer --key ./client.key --cert ./client.cer https://localhost:8080/service/hello
    curl: (60) Peer's certificate has an invalid signature.
    More details here: http://curl.haxx.se/docs/sslcerts.html
    
    curl performs SSL certificate verification by default, using a "bundle"
     of Certificate Authority (CA) public keys (CA certs). If the default
     bundle file isn't adequate, you can specify an alternate file
     using the --cacert option.
    If this HTTPS server uses a certificate signed by a CA represented in
     the bundle, the certificate verification probably failed due to a
     problem with the certificate (it might be expired, or the name might
     not match the domain name in the URL).
    If you'd like to turn off curl's verification of the certificate, use
     the -k (or --insecure) option.

很遗憾，你应该看到上面的错误信息，再查看服务端的日志：  
`2017/09/27 22:42:49 http: TLS handshake error from [::1]:56168: remote error:
tls: bad certificate`

提示证书无效，原因是我们的证书里Commone Name这个字段填的值是myname，而当前服务器运行的域名是localhost，他们不匹配，Common
Name是要授予证书的服务器域名或主机名。

我们修改修改服务器端证书，重新生成：

$ openssl req -new -key server.key -out server.csr -subj "/C=CN/ST=BJ/L=beijing/O=myorganization/OU=mygroup/CN=localhost"
    $ openssl x509 -req -days 365 -sha1 -extensions v3_req -CA ca.cer -CAkey ca.key -CAcreateserial -in server.csr -out server.cer

再运行，看看是不是想要的结果：  
(注意，根证书和客户端证书不需要重新生成)

$ curl --cacert ./ca.cer --key ./client.key --cert ./client.cer https://localhost:8080/service/hello
    {"hello":"world"}

这就是我们想要的结果。  
同理，如果使用真实机器主机名或者域名，例如主机名saturn，则

$ openssl req -new -key server.key -out server.csr -subj "/C=CN/ST=BJ/L=beijing/O=myorganization/OU=mygroup/CN=saturn"
    $ openssl x509 -req -days 365 -sha1 -extensions v3_req -CA ca.cer -CAkey ca.key -CAcreateserial -in server.csr -out server.cer
    $ curl --cacert ./ca.cer --key ./client.key --cert ./client.cer https://saturn:8080/service/hello
    {"hello":"world"}

查看证书内容

$ openssl x509 -in server.cer -text -noout 2>&1| head -n 15 
    Certificate:
        Data:
            Version: 1 (0x0)
            Serial Number: 15163366668719918823 (0xd26f19a5700c8ee7)
        Signature Algorithm: sha1WithRSAEncryption
            Issuer: C=CN, ST=BJ, L=beijing, O=myorganization, OU=mygroup, CN=myname
            Validity
                Not Before: Sep 27 14:44:07 2017 GMT
                Not After : Sep 27 14:44:07 2018 GMT
            Subject: C=CN, ST=BJ, L=beijing, O=myorganization, OU=mygroup, CN=localhost
            Subject Public Key Info:
                Public Key Algorithm: rsaEncryption
                    Public-Key: (2048 bit)
                    Modulus:
                        00:9e:f0:05:0f:1f:4d:43:36:65:86:36:5e:80:bb:

里面表示了当前证书信息，以及签发者的信息。

# 总结

每个节点(不管是客户端还是服务端)都有一个证书文件和key文件，他们用来互相加密解密；因为证书里面包含public key，key文件里面包含private
key；他们构成一对密钥对，是互为加解密的。

根证书是所有节点公用的，不管是客户端还是服务端，都要先注册根证书(通常这个过程是注册到操作系统信任的根证书数据库里面，在咱们这个例子里面没有这么做，因为这是一个临时的根证书，只在服务端和客户端命令行中指定了一下)，以示这个根证书是可信的，
然后当需要验证对方的证书时，因为待验证的证书是通过这个根证书签名的，我们信任根证书，所以推导出也可以信任对方的证书。

所以如果需要实现双向认证，那么每一端都需要三个文件

* {node}.cer: PEM certificate  
己方证书文件，将会被发给对方，让对方认证

* {node}..key: PEM RSA private key  
己方private key文件，用来解密经己方证书(因为包含己方public key)加密的内容，这个加密过程一般是由对方实施的。

* ca.cer: PEM certificate  
根证书文件，用来验证对方发过来的证书文件，所有由同一个根证书签名的证书都应该能验证通过。

转载文章，原文链接： go语言实现双向TLS认证的REST Service

关键字词go TLS

分享到：

上一篇：go语言函数变参

下一篇：go语言读取当前文件名行号和函数名

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go语言实现双向TLS认证的REST Service

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go语言实现双向TLS认证的REST Service

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。