Golang实现grpc单向认证

接着上篇文章写 Golang 简单使用grpc

golang 1.15+版本上，用 gRPC通过TLS实现数据传输加密时，会报错证书的问题：

rpc error: code = Unavailable desc = connection error: desc = "transport: authentication handshake failed: x509: certificate is not valid for any names, but wanted to match www.ximu.info"
是因为用的TLS证书，并没有开启SAN扩展（默认是没有开启SAN扩展）所生成的，导致客户端和服务端无法建立连接。
什么是 SAN？
SAN（Subject Alternative Name）是 SSL 标准 x509 中定义的一个扩展。使用了 SAN 字段的 SSL 证书，可以扩展此证书支持的域名，使得一个证书可以支持多个不同域名的解析。

一、生成CA根证书

1.1 在证书存放文件夹下 新建 ca.conf，写入内容如下：

#req 总的配置
[ req ]
default_bits       = 4096
distinguished_name = req_distinguished_name #使用 req_distinguished_name配置模块

[ req_distinguished_name ]
countryName                 = Country Name (2 letter code)
countryName_default         = CN
stateOrProvinceName         = State or Province Name (full name)
stateOrProvinceName_default = BeiJing
localityName                = Locality Name (eg, city)
localityName_default        = BeiJing
organizationName            = Organization Name (eg, company)
organizationName_default    = ChaoYang
commonName                  = Common Name (e.g. server FQDN or YOUR name)
commonName_max              = 64
commonName_default          = ChaoYang

1.2 生成ca秘钥，得到ca.key

openssl genrsa -out ca.key 4096

1.3 生成ca证书签发请求，得到ca.csr

openssl req -new -sha256 -out ca.csr -key ca.key -config ca.conf

1.4 生成ca根证书，得到ca.crt

openssl x509 -req -days 3650 -in ca.csr -signkey ca.key -out ca.crt

二、 生成服务端证书

2.1 在证书存放文件夹下，新建server.conf，写入内容如下：

#req 总配置
[ req ]
default_bits       = 2048
distinguished_name = req_distinguished_name  #使用 req_distinguished_name配置模块
req_extensions     = req_ext  #使用 req_ext配置模块

[ req_distinguished_name ]
countryName                 = Country Name (2 letter code)
countryName_default         = CN
stateOrProvinceName         = State or Province Name (full name)
stateOrProvinceName_default = BeiJing
localityName                = Locality Name (eg, city)
localityName_default        = BeiJing
organizationName            = Organization Name (eg, company)
organizationName_default    = ChaoYang
commonName                  = Common Name (e.g. server FQDN or YOUR name)
commonName_max              = 64
commonName_default          = chaoyang #这里的Common Name 写主要域名即可(注意：这个域名也要在alt_names的DNS.x里) 此处尤为重要，需要用该服务名字填写到客户端的代码中

[ req_ext ]
subjectAltName = @alt_names #使用 alt_names配置模块

[alt_names]
DNS.1   = localhost
DNS.2   = chaoyang.info
DNS.3   = www.chaoyang.info
IP      = 127.0.0.1

2.2 生成秘钥，得到server.key

openssl genrsa -out server.key 2048

2.3 生成证书签发请求，得到server.csr

openssl req -new -sha256 -out server.csr -key server.key -config server.conf

2.4 用CA证书生成服务端证书，得到server.pem

openssl x509 -req -days 3650 -CA ca.crt -CAkey ca.key -CAcreateserial -in server.csr -out server.pem -extensions req_ext -extfile server.conf

key： 服务器上的私钥文件，用于对发送给客户端数据的加密，以及对从客户端接收到数据的解密。
csr： 证书签名请求文件，用于提交给证书颁发机构（CA）对证书签名。
crt： 由证书颁发机构（CA）签名后的证书，或者是开发者自签名的证书，包含证书持有人的信息，持有人的公钥，以及签署者的签名等信息。
pem： 是基于Base64编码的证书格式，扩展名包括PEM、CRT和CER。

ca.conf和server.conf对比
可以发现ca.conf和server.conf的配置大致相同，这是因为ca.conf生成的是根证书，用户证书需要在根证书的基础上创建.

三、证书的使用（单向认证）

server

package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/grpclog"
	"net"
	"os"
	"rpc-demo/pb/pb" // 引入编译生成的包
)

const (
	// Address gRPC服务地址
	Address = "127.0.0.1:50052"
)

// 定义HelloService并实现约定的接口
type HelloService struct {
	pb.HelloServer
}

// SayHello 实现Hello服务接口
func (h *HelloService) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
	resp := new(pb.HelloResponse)
	resp.Message = fmt.Sprintf("Hello %s.", in.Name)

	return resp, nil
}

func main() {
	listen, err := net.Listen("tcp", Address)
	if err != nil {
		grpclog.Fatalf("Failed to listen: %v", err)
	}
	// 实例化grpc Server
	//s := grpc.NewServer()
	// 证书认证-双向认证 TODO
	// 从证书相关文件中读取和解析信息，得到证书公钥、密钥对
	// 实例化grpc Server, 并开启TLS认证
	//单向 TODO
	creds, err := credentials.NewServerTLSFromFile("../cert/server.pem", "../cert/server.key")
	if err != nil {
		grpclog.Fatalf("Failed to generate credentials %v", err)
	}
	s := grpc.NewServer(grpc.Creds(creds))
	// 注册HelloService
	pb.RegisterHelloServer(s, &HelloService{})
	fmt.Println("Listen on " + Address)
	err = s.Serve(listen)
	if err != nil {
		fmt.Println(err)
	}
}

client

package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/grpclog"
	"os"
	pb "rpc-demo/pb/pb" // 引入proto包
)

const (
	// Address gRPC服务地址
	Address = "127.0.0.1:50052"
)

func main() {
	// 连接
	// TLS连接  记得把server name改成你写的服务器地址
	//单向 TODO
	creds, err := credentials.NewClientTLSFromFile("../cert/server.pem", "localhost")
	if err != nil {
		grpclog.Fatalf("Failed to create TLS credentials %v", err)
	}
	conn, err := grpc.Dial(Address, grpc.WithTransportCredentials(creds))
	//conn, err := grpc.Dial(Address, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		grpclog.Fatalln(err)
	}
	defer conn.Close()

	// 初始化客户端
	c := pb.NewHelloClient(conn)

	// 调用方法
	req := &pb.HelloRequest{Name: "gRPC"}
	res, err := c.SayHello(context.Background(), req)

	if err != nil {
		grpclog.Fatalln(err)
	}

	fmt.Println(res.Message)
}