经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
使用Go实现TLS服务器和客户端的示例
来源：jb51　　时间：2021/12/8 17:01:02　　对本文有异议

传输层安全协议（Transport Layer Security，缩写：TLS），及其前身安全套接层（Secure Sockets Layer，缩写：SSL）是一种安全协议，目的是为互联网通信提供安全及数据完整性保障。

SSL包含记录层（Record Layer）和传输层，记录层协议确定了传输层数据的封装格式。传输层安全协议使用X.509认证，之后利用非对称加密演算来对通信方做身份认证，之后交换对称密钥作为会谈密钥（Session key）。这个会谈密钥是用来将通信两方交换的数据做加密，保证两个应用间通信的保密性和可靠性，使客户与服务器应用之间的通信不被攻击者窃听。

本文并没有提供一个TLS的深度教程，而是提供了两个Go应用TLS的简单例子，用来演示使用Go语言快速开发安全网络传输的程序。

TLS历史

  • 1994年早期，NetScape公司设计了SSL协议（Secure Sockets Layer）的1.0版，但是未发布。
  • 1994年11月，NetScape公司发布SSL 2.0版，很快发现有严重漏洞。
  • 1996年11月，SSL 3.0版问世，得到大规模应用。
  • 1999年1月，互联网标准化组织ISOC接替NetScape公司，发布了SSL的升级版TLS 1.0版。
  • 2006年4月和2008年8月，TLS进行了两次升级，分别为TLS 1.1版和TLS 1.2版。最新的变动是2011年TLS 1.2的修订版。

现在正在制定 tls 1.3。

证书生成

首先我们创建私钥和证书。

服务器端的证书生成

使用了"服务端证书"可以确保服务器不是假冒的。

1、 生成服务器端的私钥

  1. openssl genrsa -out server.key 2048

2、 生成服务器端证书

  1. openssl req -new -x509 -key server.key -out server.pem -days 3650

或者

  1. go run $GOROOT/src/crypto/tls/generate_cert.go --host localhost

客户端的证书生成

除了"服务端证书"，在某些场合中还会涉及到"客户端证书"。所谓的"客户端证书"就是用来证明客户端访问者的身份。
比如在某些金融公司的内网，你的电脑上必须部署"客户端证书"，才能打开重要服务器的页面。
我会在后面的例子中演示"客户端证书"的使用。

3、 生成客户端的私钥

  1. openssl genrsa -out client.key 2048

4、 生成客户端的证书

  1. openssl req -new -x509 -key client.key -out client.pem -days 3650

或者使用下面的脚本：

  1. #!/bin/bash
  2. # call this script with an email address (valid or not).
  3. # like:
  4. # ./makecert.sh demo@random.com
  5. mkdir certs
  6. rm certs/*
  7. echo "make server cert"
  8. openssl req -new -nodes -x509 -out certs/server.pem -keyout certs/server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/emailAddress=$1"
  9. echo "make client cert"
  10. openssl req -new -nodes -x509 -out certs/client.pem -keyout certs/client.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/emailAddress=$1"

Golang 例子

Go Package tls部分实现了 tls 1.2的功能，可以满足我们日常的应用。Package crypto/x509提供了证书管理的相关操作。

服务器证书的使用

本节代码提供了服务器使用证书的例子。下面的代码是服务器的例子：

  1. package main
  2. import (
  3.     "bufio"
  4.     "crypto/tls"
  5.     "log"
  6.     "net"
  7. )
  8. func main() {
  9.     cert, err := tls.LoadX509KeyPair("server.pem", "server.key")
  10.     if err != nil {
  11.         log.Println(err)
  12.         return
  13.     }
  14.     config := &tls.Config{Certificates: []tls.Certificate{cert}}
  15.     ln, err := tls.Listen("tcp", ":443", config)
  16.     if err != nil {
  17.         log.Println(err)
  18.         return
  19.     }
  20.     defer ln.Close()
  21.     for {
  22.         conn, err := ln.Accept()
  23.         if err != nil {
  24.             log.Println(err)
  25.             continue
  26.         }
  27.         go handleConn(conn)
  28.     }
  29. }
  30. func handleConn(conn net.Conn) {
  31.     defer conn.Close()
  32.     r := bufio.NewReader(conn)
  33.     for {
  34.         msg, err := r.ReadString('\n')
  35.         if err != nil {
  36.             log.Println(err)
  37.             return
  38.         }
  39.         println(msg)
  40.         n, err := conn.Write([]byte("world\n"))
  41.         if err != nil {
  42.             log.Println(n, err)
  43.             return
  44.         }
  45.     }
  46. }

首先从上面我们创建的服务器私钥和pem文件中得到证书cert，并且生成一个tls.Config对象。这个对象有多个字段可以设置，本例中我们使用它的默认值。
然后用tls.Listen开始监听客户端的连接，accept后得到一个net.Conn，后续处理和普通的TCP程序一样。
然后，我们看看客户端是如何实现的：

  1. package main
  2. import (
  3.     "crypto/tls"
  4.     "log"
  5. )
  6. func main() {
  7.     conf := &tls.Config{
  8.         InsecureSkipVerify: true,
  9.     }
  10.     conn, err := tls.Dial("tcp", "127.0.0.1:443", conf)
  11.     if err != nil {
  12.         log.Println(err)
  13.         return
  14.     }
  15.     defer conn.Close()
  16.     n, err := conn.Write([]byte("hello\n"))
  17.     if err != nil {
  18.         log.Println(n, err)
  19.         return
  20.     }
  21.     buf := make([]byte, 100)
  22.     n, err = conn.Read(buf)
  23.     if err != nil {
  24.         log.Println(n, err)
  25.         return
  26.     }
  27.     println(string(buf[:n]))
  28. }

InsecureSkipVerify用来控制客户端是否证书和服务器主机名。如果设置为true,则不会校验证书以及证书中的主机名和服务器主机名是否一致。
因为在我们的例子中使用自签名的证书，所以设置它为true,仅仅用于测试目的。

可以看到，整个的程序编写和普通的TCP程序的编写差不太多，只不过初始需要做一些TLS的配置。

你可以go run server.go和go run client.go测试这个例子。

客户端证书的使用
在有的情况下，需要双向认证，服务器也需要验证客户端的真实性。在这种情况下，我们需要服务器和客户端进行一点额外的配置。

服务器端：

  1. package main
  2. import (
  3.     "bufio"
  4.     "crypto/tls"
  5.     "crypto/x509"
  6.     "io/ioutil"
  7.     "log"
  8.     "net"
  9. )
  10. func main() {
  11.     cert, err := tls.LoadX509KeyPair("server.pem", "server.key")
  12.     if err != nil {
  13.         log.Println(err)
  14.         return
  15.     }
  16.     certBytes, err := ioutil.ReadFile("client.pem")
  17.     if err != nil {
  18.         panic("Unable to read cert.pem")
  19.     }
  20.     clientCertPool := x509.NewCertPool()
  21.     ok := clientCertPool.AppendCertsFromPEM(certBytes)
  22.     if !ok {
  23.         panic("failed to parse root certificate")
  24.     }
  25.     config := &tls.Config{
  26.         Certificates: []tls.Certificate{cert},
  27.         ClientAuth:   tls.RequireAndVerifyClientCert,
  28.         ClientCAs:    clientCertPool,
  29.     }
  30.     ln, err := tls.Listen("tcp", ":443", config)
  31.     if err != nil {
  32.         log.Println(err)
  33.         return
  34.     }
  35.     defer ln.Close()
  36.     for {
  37.         conn, err := ln.Accept()
  38.         if err != nil {
  39.             log.Println(err)
  40.             continue
  41.         }
  42.         go handleConn(conn)
  43.     }
  44. }
  45. func handleConn(conn net.Conn) {
  46.     defer conn.Close()
  47.     r := bufio.NewReader(conn)
  48.     for {
  49.         msg, err := r.ReadString('\n')
  50.         if err != nil {
  51.             log.Println(err)
  52.             return
  53.         }
  54.         println(msg)
  55.         n, err := conn.Write([]byte("world\n"))
  56.         if err != nil {
  57.             log.Println(n, err)
  58.             return
  59.         }
  60.     }
  61. }

因为需要验证客户端，我们需要额外配置下面两个字段：

  1. ClientAuth: tls.RequireAndVerifyClientCert,
  2. ClientCAs: clientCertPool,

然后客户端也配置这个clientCertPool:

  1. package main
  2. import (
  3.     "crypto/tls"
  4.     "crypto/x509"
  5.     "io/ioutil"
  6.     "log"
  7. )
  8. func main() {
  9.     cert, err := tls.LoadX509KeyPair("client.pem", "client.key")
  10.     if err != nil {
  11.         log.Println(err)
  12.         return
  13.     }
  14.     certBytes, err := ioutil.ReadFile("client.pem")
  15.     if err != nil {
  16.         panic("Unable to read cert.pem")
  17.     }
  18.     clientCertPool := x509.NewCertPool()
  19.     ok := clientCertPool.AppendCertsFromPEM(certBytes)
  20.     if !ok {
  21.         panic("failed to parse root certificate")
  22.     }
  23.     conf := &tls.Config{
  24.         RootCAs:            clientCertPool,
  25.         Certificates:       []tls.Certificate{cert},
  26.         InsecureSkipVerify: true,
  27.     }
  28.     conn, err := tls.Dial("tcp", "127.0.0.1:443", conf)
  29.     if err != nil {
  30.         log.Println(err)
  31.         return
  32.     }
  33.     defer conn.Close()
  34.     n, err := conn.Write([]byte("hello\n"))
  35.     if err != nil {
  36.         log.Println(n, err)
  37.         return
  38.     }
  39.     buf := make([]byte, 100)
  40.     n, err = conn.Read(buf)
  41.     if err != nil {
  42.         log.Println(n, err)
  43.         return
  44.     }
  45.     println(string(buf[:n]))
  46. }

运行这两个代码go run server2.go和go run client2.go,可以看到两者可以正常的通讯，如果用前面的客户端go run client.go，不能正常通讯，因为前面的客户端并没有提供客户端证书。

更正 使用自定义的CA的例子可以参考 https://github.com/golang/net/tree/master/http2/h2demo

  1. Make CA:
  2. $ openssl genrsa -out rootCA.key 2048
  3. $ openssl req -x509 -new -nodes -key rootCA.key -days 1024 -out rootCA.pem
  4. ... install that to Firefox
  5. Make cert:
  6. $ openssl genrsa -out server.key 2048
  7. $ openssl req -new -key server.key -out server.csr
  8. $ openssl x509 -req -in server.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out server.crt -days 500

到此这篇关于使用Go实现TLS服务器和客户端的示例的文章就介绍到这了,更多相关Go TLS服务器和客户端内容请搜索w3xue以前的文章或继续浏览下面的相关文章希望大家以后多多支持w3xue！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang 模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号