优点： 算法公开，加密和解密使用不同的钥匙，私钥不需要通过网络进行传输，安全性很高。
缺点： 计算量比较大，加密和解密速度相比对称加密慢很多
- 客户端发送HTTPS请求,请求 SSL 连接
- 采用 HTTPS 协议的服务器必须先申请CA (Certification Authority)证书,颁发证书的同时会产生一个私钥和公钥。私钥由服务端自己保存不可泄漏,公钥则是附带在证书的信息中,可以公开的,证书本身也附带一个证书电子签名,这个签名用来验证证书的完整性和真实性，可以防止证书被篡改。
- 服务器接收到请求后将自身份信息以证书形式发回给客户端,证书包含了网站地址,加密公钥,以及证书的颁发机构等信息
- 客户端接收到响应的证书信息进行校验, 如果证书不是可信机构颁布,或者证书中的域名与实际域名不一致,或者证书已经过期,就会向访问者显示一个警告,由其选择是否还要继续通信。
- 如果证书没有问题,客户端就会从服务器证书中取出服务器的公钥A,然后客户端还会生成一个随机码 KEY,并使用公钥A将其加密。
- 客户端把加密后的随机码 KEY 发送给服务器，作为后面对称加密的密钥。
- 服务器在收到随机码 KEY 之后会使用私钥B将其解密,经过以上这些步骤，客户端和服务器终于建立了安全连接,解决了对称加密的密钥泄露问题，接下来就可以进行通信了
- https是http协议的安全版本,采用SSL/TLS协议进行加密传输
- http默认使用80端口, https默认使用443端口
- 建立连接层面: https因为多了一次TSL加解密的握手校验,没有http性能高
- 在资源消耗与处理上由于多了加解密,比http要慢
- http运行在TCP协议上,https运行在SSL协议上，而SSL实际也是运行在TCP协议上的
- 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中,服务器可以对客户端的一个请求发送多个响应
- 创建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
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
}
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
}
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())
}