go 进阶 https与http2

最新推荐文章于 2024-05-17 14:01:25 发布

苹果香蕉西红柿

最新推荐文章于 2024-05-17 14:01:25 发布

阅读量272

点赞数

分类专栏： # 七. Go http标准库原理相关文章标签： https golang ssl

本文链接：https://blog.csdn.net/qq_29799655/article/details/128469655

版权

七. Go http标准库原理相关专栏收录该内容

11 篇文章 2 订阅

订阅专栏

一. 复习 https 与 http2

https 是什么

什么是HTTPS: 安全的超文本传输协议,可以看为HTTP的加强安全版本,HTTPS 是基于 HTTP 的，也是用 TCP 作为底层协议，并额外使用 SSL/TLS 协议用作加密和安全认证,可以理解成HTTPS = HTTP + SSL/TLS。默认端口号是 443
什么是SSL/TLS协议: SSL 指安全套接字协议,核心要素是非对称加密(非对称加密采用公钥,私钥,在通信时,通过公钥加密,通过私钥解密)

优点：算法公开，加密和解密使用不同的钥匙，私钥不需要通过网络进行传输，安全性很高。
缺点：计算量比较大，加密和解密速度相比对称加密慢很多

https 原理是什么

HTTPS 协议就是基于 SSL 的 HTTP 协议，HTTPS 使用与 HTTP 不同的端口（HTTP80 ，HTTPS443）提供了身份验证与加密通信方法，被广泛用于互联网上安全敏感的通信

客户端发送HTTPS请求,请求 SSL 连接
采用 HTTPS 协议的服务器必须先申请CA (Certification Authority)证书,颁发证书的同时会产生一个私钥和公钥。私钥由服务端自己保存不可泄漏,公钥则是附带在证书的信息中,可以公开的,证书本身也附带一个证书电子签名,这个签名用来验证证书的完整性和真实性，可以防止证书被篡改。
服务器接收到请求后将自身份信息以证书形式发回给客户端,证书包含了网站地址,加密公钥,以及证书的颁发机构等信息
客户端接收到响应的证书信息进行校验, 如果证书不是可信机构颁布,或者证书中的域名与实际域名不一致,或者证书已经过期,就会向访问者显示一个警告,由其选择是否还要继续通信。
如果证书没有问题,客户端就会从服务器证书中取出服务器的公钥A,然后客户端还会生成一个随机码 KEY,并使用公钥A将其加密。
客户端把加密后的随机码 KEY 发送给服务器，作为后面对称加密的密钥。
服务器在收到随机码 KEY 之后会使用私钥B将其解密,经过以上这些步骤，客户端和服务器终于建立了安全连接,解决了对称加密的密钥泄露问题，接下来就可以进行通信了

http 与https的区别

https是http协议的安全版本,采用SSL/TLS协议进行加密传输
http默认使用80端口, https默认使用443端口
建立连接层面: https因为多了一次TSL加解密的握手校验,没有http性能高
在资源消耗与处理上由于多了加解密,比http要慢
http运行在TCP协议上,https运行在SSL协议上，而SSL实际也是运行在TCP协议上的

http2 与http1.x区别

以前默认使用http1.x进行通信,后续可能要升级为http2,与http1.x不同是

http1.x 基于文本进行解析,文本的表现形式有多样性,需要考虑多种场景必,http2基于二进制格式解析只认 0 和 1 的组合,实现方便且健壮
http2支持多路复用,即连接共享,多个请求可以同时在一个连接上并行执行(一个request对应一个id，这样一个连接上可以有多个request，每个连接的request可以随机的混杂在一起，接收方可以根据request的 id将request再归属到各自不同的服务端请求里面), 而http1.1的长连是串行化执行多个请求,而且并发请求的数量比http1.1大了好几个数量级。
首部压缩: http1.1不支持header数据压缩,http2.0使用 HPACK 算法对 header 的数据进行压缩,数据体积小,传输快
服务器推送: 在客户端请求之前发送数据的机制,在 http2中,服务器可以对客户端的一个请求发送多个响应

注意点使用http2必须启用https(浏览器强制要求)

二. golang https http2 基础示例

创建一个假的证书与私钥

创建ca私钥: “openssl genrsa -out ca.key 2048”
创建ca证书: “openssl req -x509 -new -nodes -key ca.key -subj “/CN=example1.com” -days 5000 -out ca.crt”
创建服务器私钥(默认由CA签发): openssl genrsa -out server.key 2048
基于服务器私钥创建服务器证书前面请求(简称csr, example1.com代表你的域名): openssl req -new -key server.key -subj “/CN=example1.com” -out server.csr
基于上面生成的两个文件加上ca证书生成服务器证书(days代表有效期): openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 5000

例如此处执行完毕创建了相关证书,其中server.crt是服务器证书,server.key是服务器秘钥
编写读取证书文件代码,也就是上方的testdata.go中

package testdata

import (
	"path/filepath"
	"runtime"
)

// basepath is the root directory of this package.
var basepath string

func init() {
	_, currentFile, _, _ := runtime.Caller(0)
	basepath = filepath.Dir(currentFile)
}

// Path returns the absolute path the given relative file or directory path,
// relative to the google.golang.org/grpc/testdata directory in the user's GOPATH.
// If rel is already absolute, it is returned unmodified.
func Path(rel string) string {
	if filepath.IsAbs(rel) {
		return rel
	}

	return filepath.Join(basepath, rel)
}

编写服务接口

import (
	"fmt"
	"github.com/e421083458/gateway_demo/demo/proxy/reverse_proxy_https/testdata"
	"golang.org/x/net/http2"
	"io"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

//1.编写启动服务上下文结构体
type RealServer struct {
	Addr string
}

//2.编写启动服务Run方法
func (r *RealServer) Run() {
	log.Println("Starting httpserver at " + r.Addr)
	//1.创建路由器
	mux := http.NewServeMux()
	//2.注册路由
	mux.HandleFunc("/", r.HelloHandler)
	mux.HandleFunc("/base/error", r.ErrorHandler)
	//3.封装server
	server := &http.Server{
		Addr:         "127.0.0.1:3003",
		WriteTimeout: time.Second * 3,
		Handler:      mux,
	}

	//4.监听地址启动服务
	go func() {
		//4.1重点:配置http升级为http2
		http2.ConfigureServer(server, &http2.Server{})
		//4.2读取服务器证书
		serverCrt := testdata.Path("server.crt")
		//4.3读取服务器私钥
		serverKey := testdata.Path("server.key")

		//4.4调用http.Server的ListenAndServeTLS()方法,传入证书与私钥,设置当前服务支持https
		log.Fatal(server.ListenAndServeTLS(serverCrt, serverKey))
	}()
}

//3.编写路由接口
func (r *RealServer) HelloHandler(w http.ResponseWriter, req *http.Request) {
	upath := fmt.Sprintf("http://%s%s\n", r.Addr, req.URL.Path)
	io.WriteString(w, upath)
}

func (r *RealServer) ErrorHandler(w http.ResponseWriter, req *http.Request) {
	upath := "error handler"
	w.WriteHeader(500)
	io.WriteString(w, upath)
}

//4.main方法启动服务
func main() {
	rs1 := &RealServer{Addr: "127.0.0.1:3003"}
	//启动服务业务函数执行
	rs1.Run()
	//监听关闭信号
	quit := make(chan os.Signal)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
}

httputil.ReverseProxy 代理到https

封装httputil.ReverseProxy时,设置支持https,然后通过httputil.ReverseProxy将请求代理到目标服务器

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"github.com/e421083458/gateway_demo/demo/proxy/reverse_proxy_https/testdata"
	"golang.org/x/net/http2"
	"io/ioutil"
	"math/rand"
	"net"
	"net/http"
	"net/http/httputil"
	"net/url"
	"strings"
	"time"
)

// 1.创建连接池(在连接池中设置ca证书)
var transport = &http.Transport{
	DialContext: (&net.Dialer{
		Timeout:   30 * time.Second, //连接超时
		KeepAlive: 30 * time.Second, //长连接超时时间
	}).DialContext,
	//是否开启tls验证如果开启,下方就要设置ca证书(如果不需要tls可以注释掉,并且也不需要ca证书)
	TLSClientConfig:       &tls.Config{InsecureSkipVerify: true},
	TLSClientConfig: func() *tls.Config {
		//读取ca证书
		caCertPath := testdata.Path("ca.crt")
		caCrt, _ := ioutil.ReadFile(caCertPath)
		pool := x509.NewCertPool()
		pool.AppendCertsFromPEM(caCrt)
		return &tls.Config{RootCAs: pool}
	}(),
	MaxIdleConns:          100,              //最大空闲连接
	IdleConnTimeout:       90 * time.Second, //空闲超时时间
	TLSHandshakeTimeout:   10 * time.Second, //tls握手超时时间
	ExpectContinueTimeout: 1 * time.Second,  //100-continue 超时时间
}

// 获取httputil.ReverseProxy,通过httputil.ReverseProxy进行代理,将请求转发到目标服务
func NewMultipleHostsReverseProxy(targets []*url.URL) *httputil.ReverseProxy {
	//请求协调者
	director := func(req *http.Request) {
		//目标地址
		targetIndex := rand.Intn(len(targets))
		target := targets[targetIndex]
		targetQuery := target.RawQuery
		fmt.Println("target.Scheme")
		fmt.Println(target.Scheme)
		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host
		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
		if targetQuery == "" || req.URL.RawQuery == "" {
			req.URL.RawQuery = targetQuery + req.URL.RawQuery
		} else {
			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
		}
		if _, ok := req.Header["User-Agent"]; !ok {
			req.Header.Set("User-Agent", "user-agent")
		}
	}
	//调用http2.ConfigureTransport()配置http升级为http2,传递设置了ca证书的连接池
	http2.ConfigureTransport(transport)
	return &httputil.ReverseProxy{Director: director, Transport: transport}
}

func singleJoiningSlash(a, b string) string {
	aslash := strings.HasSuffix(a, "/")
	bslash := strings.HasPrefix(b, "/")
	switch {
	case aslash && bslash:
		return a + b[1:]
	case !aslash && !bslash:
		return a + "/" + b
	}
	return a + b
}

main方法启动服务,注意也要设置支持http2

import (
	"github.com/e421083458/gateway_demo/demo/proxy/reverse_proxy_https/testdata"
	"golang.org/x/net/http2"
	"log"
	"net/http"
	"net/url"
	"time"
)

var addr = "example1.com:3002"

func main() {
	//1.目标服务地址
	rs1 := "https://example1.com:3003"
	url1, err1 := url.Parse(rs1)
	if err1 != nil {
		log.Println(err1)
	}
	urls := []*url.URL{url1}

	//2.获取代理httputil.ReverseProxy
	proxy := NewMultipleHostsReverseProxy(urls)
	log.Println("Starting httpserver at " + addr)

	//2.创建路由器
	mux := http.NewServeMux()

	//4.注册路由,通过httputil.ReverseProxy进行代理
	mux.Handle("/", proxy)
	//5.设置server
	server := &http.Server{
		Addr:         addr,
		WriteTimeout: time.Second * 3, //设置3秒的写超时
		Handler:      mux,
	}
	//6.设置支持http2
	http2.ConfigureServer(server, &http2.Server{})
	//7.读取证书,秘钥,监听指定端口开启服务
	log.Fatal(server.ListenAndServeTLS(testdata.Path("server.crt"), testdata.Path("server.key")))
	log.Fatal(server.ListenAndServe())
}