网络通信协议

互联网的核心是一系列协议，总称为”互联网协议”（Internet Protocol Suite），正是这一些协议规定了电脑如何连接和组网。
主要协议分为：

Socket 接口抽象层
TCP/UDP
HTTP1.1/HTTP2/QUIC(HTTP3) 超文本传输协议

Socket 抽象层

应用程序通常通过“套接字”向网络发出请求或者应答网络请求。

一种通用的面向流的网络接口，主要操作：

建立、接受连接
读写、关闭、超时
获取地址、端口

TCP 可靠连接，面向连接的协议

TCP/IP 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议。

服务端流程：

监听端口
接收客户端请求建立连接
创建 goroutine 处理连接

客户端流程：

建立与服务端的连接
进行数据收发
关闭连接

UDP 不可靠连接，允许广播或多播

UDP 协议（User Datagram Protocol）中文名称是用户数据报协议，是 OSI（Open System Interconnection，开放式系统互联）参考模型中一种无连接的传输层协议。

一个简单的传输层协议：

不需要建立连接
不可靠的、没有时序的通信
数据报是有长度（65535-20=65515）
支持多播和广播
低延迟，实时性比较好
应用于用于视频直播、游戏同步

HTTP 超文本传输协议

HTTP(HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议，它详细规定了浏览器和万维网服务器之间互相通信的规则，通过因特网传送万维网文档的数据传送协议。

请求报文：

Method: HEAD/GET/POST/PUT/DELETE
Accept：text/html、application/json
Content-Type: application/json、application/x-www-form-urlencoded
请求正文

GET / HTTP/1.1
Host: www.google.com
Content-Type: text/html
Connection: keep-alive

GET / HTTP/1.1

Host: www.google.com

Content-Type: text/html

Connection: keep-alive

响应报文：

状态行(200/400/500)
响应头(Response Header)
响应正文

HTTP/1.1 200 OK

Content-Length: 3059
Server: GWS/2.0
Content-Type: text/html
Connection: keep-alive

<html>...

HTTP/1.1 200 OK

Content-Length: 3059

Server: GWS/2.0

Content-Type: text/html

Connection: keep-alive

<html>...

gRPC 基于 HTTP2 协议扩展

HTTP2 如何提升网络速度

HTTP/1.1 为网络效率做了几点优化：

增加了持久连接，每个请求进行串行请求。
浏览器为每个域名最多同时维护 6 个 TCP 持久连接。
使用 CDN 的实现域名分片机制。

HTTP/2 的多路复用：

请求数据二进制分帧层处理之后，会转换成请求 ID 编号的帧，通过协议栈将这些帧发送给服务器。
服务器接收到所有帧之后，会将所有相同 ID 的帧合并为一条完整的请求信息。
然后服务器处理该条请求，并将处理的响应行、响应头和响应体分别发送至二进制分帧层。
同样，二进制分帧层会将这些响应数据转换为一个个带有请求 ID 编号的帧，经过协议栈发送给浏览器。
浏览器接收到响应帧之后，会根据 ID 编号将帧的数据提交给对应的请求。

所以，HTTP2 通过引入二进制分帧层，就实现了 HTTP 的多路复用。

HTTPS 超文本传输安全协议

HTTPS；常称为HTTP over TLS、HTTP over SSL或HTTP Secure）是一种通过计算机网络进行安全通信的传输协议。

SSL 1.0、2.0 和 3.0： SSL（Secure Sockets Layer）是网景公司（Netscape）设计的主要用于Web的安全传输协议，这种协议在Web上获得了广泛的应用。
TLS 1.0：IETF将SSL标准化，即 RFC 2246 ，并将其称为 TLS（Transport Layer Security）。
TLS 1.1：添加对CBC攻击的保护、支持IANA登记的参数。
TLS 1.2：增加 SHA-2 密码散列函数、增加 AEAD 加密算法，如 GCM 模式、添加 TLS 扩展定义和 AES 密码组合。
TLS 1.3：较 TLS 1.2 速度更快，性能更好、更加安全。

SSL/TLS 重要概念

SSL/TLS 协议提供主要的作用有：

认证用户和服务器，确保数据发送到正确的客户端和服务器。
加密数据以防止数据中途被窃取。
维护数据的完整性，确保数据在传输过程中不被改变。

哈希算法：

CA 用自己的私钥对指纹签名，浏览器通过内置 CA 跟证书公钥进行解密，如果解密成功就确定证书是 CA 颁发的。

对称加密：

指的就是加、解密使用的同是一串密钥，所以被称做对称加密。对称加密只有一个密钥作为私钥。

非对称加密：

指的是加、解密使用不同的密钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。

CA 证书机构：

CA 是负责签发证书、认证证书、管理已颁发证书的机关；
通常内置在操作系统，或者浏览器中，防止篡改。

TLS 1.2 如何解决安全问题？

要解决的问题：

防窃听（eavesdropping），对应加密（Confidentiality）
防篡改（tampering），对应完整性校验（Integrity）
防伪造（forgery），对应认证过程（Authentication）

如何保证公钥不被篡改？

解决方法：将公钥放在数字证书中。只要证书是可信的，公钥就是可信的。

公钥加密计算量太大，如何减少耗用的时间？

解决方法：每一次对话（session），客户端和服务器端都生成一个“对话密钥”（session key），用它来加密信息。由于“对话密钥”是对称加密，所以运算速度非常快，而服务器公钥只用于加密“对话密钥”本身，这样就减少了加密运算的消耗时间。

因此，SSL/TLS协议的基本过程：

客户端向服务器端索要证书，并通过签名验证公钥。
双方协商生成“对话密钥”，加密类型、随机串（非对称加密）。
双方采用“对话密钥”进行加密通信（对称加密）。

TLS 1.3 Faster & More Secure

TLS 1.3 与之前的协议有较大差异，主要在于：

RSA 密钥交换被废弃，引入新的密钥协商机制 PSK。
支持 0-RTT 数据传输，复用 PSK 无握手时间。
废弃若干加密组件，SHA1、MD5 等 hash 算法。
不再允许压缩加密报文，不允许重协商，不发 Change Cipher 了。

密钥协商机制：

RSA 是常用且简单的一个交换密钥的算法，即客户端决定密钥后，用服务器的公钥加密传输给对方，这样通信双方就都有了后续通信的密钥。
Diffie–Hellman（DH）是另一种交换密钥的算法，客户端和服务器都生成一对公私钥，然后将公钥发送给对方，双方得到对方的公钥后，用数字签名确保公钥没有被篡改，然后与自己的私钥结合，就可以计算得出相同的密钥。

为了保证前向安全，TLS 1.3 中移除了 RSA 算法，Diffie–Hellman 是唯一的密钥交换算法。

Go 网络编程基础

基础概念

Socket：数据传输
Encoding：内容编码
Session：连接会话状态
C/S模式：通过客户端实现双端通信
B/S模式：通过浏览器即可完成数据的传输

简单例子:

通过TCP/UDP实现网络通信

网络轮询器：

多路复用模型
多路复用模块
文件描述符
Goroutine 唤醒

TCP 简单用例

// client.go

func main() {
    listen, err := net.Listen("tcp", "127.0.0.1:10000")
    if err != nil {
        log.Fatalf("listen error: %v\n", err)
    }
    for {
        conn, err := listen.Accept()
        if err != nil {
            log.Printf("accept error: %v\n", err)
            continue
        }
        // 开始goroutine监听连接
        go handleConn(conn)
    }
}

// serve.go
func handleConn(conn net.Conn) {
    defer conn.Close()
    // 读写缓冲区
    rd := bufio.NewReader(conn)
    wr := bufio.NewWriter(conn)
    for {
        line, _, err := rd.ReadLine()
        if err != nil {
            log.Printf("read error: %v\n", err)
            return
        }
        wr.WriteString("hello ")
        wr.Write(line)
        wr.Flush() // 一次性syscall
    }
}

// client.go

func main() {

listen, err := net.Listen("tcp", "127.0.0.1:10000")

if err != nil {

log.Fatalf("listen error: %v\n", err)

}

for {

conn, err := listen.Accept()

if err != nil {

log.Printf("accept error: %v\n", err)

continue

}

// 开始goroutine监听连接

go handleConn(conn)

}

// serve.go

func handleConn(conn net.Conn) {

defer conn.Close()

// 读写缓冲区

rd := bufio.NewReader(conn)

wr := bufio.NewWriter(conn)

for {

line, _, err := rd.ReadLine()

if err != nil {

log.Printf("read error: %v\n", err)

return

}

wr.WriteString("hello ")

wr.Write(line)

wr.Flush() // 一次性syscall

}

UDP 简单用例

func main() {
    listen, err := net.ListenUDP("udp", &net.UDPAddr{Port: 20000})
    if err != nil {
        log.Fatalf("listen error: %v\n", err)
    }
    defer listen.Close()
    for {
        var buf [1024]byte
        n, addr, err := listen.ReadFromUDP(buf[:])
        if err != nil {
            log.Printf("read udp error: %v\n", err)
            continue
        }
        data := append([]byte("hello "), buf[:n]...)
        listen.WriteToUDP(data, addr)
    }
}

func main() {

listen, err := net.ListenUDP("udp", &net.UDPAddr{Port: 20000})

if err != nil {

log.Fatalf("listen error: %v\n", err)

}

defer listen.Close()

for {

var buf [1024]byte

n, addr, err := listen.ReadFromUDP(buf[:])

if err != nil {

log.Printf("read udp error: %v\n", err)

continue

}

data := append([]byte("hello "), buf[:n]...)

listen.WriteToUDP(data, addr)

}

HTTP 简单用例

// serve.go

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
        if req.URL.Path != "/" {
            http.NotFound(w, req)
            return
        }
        fmt.Fprintf(w, "Welcome to the home page!")
    })
    s := &http.Server{
        Addr:           ":8080",
        Handler:        mux,
        ReadTimeout:    1 * time.Second,
        WriteTimeout:   1 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }
    log.Fatal(s.ListenAndServe())
}

// client.go
func main() {
    tr := &http.Transport{
        MaxIdleConns:       10,
        IdleConnTimeout:    30 * time.Second,
        DisableCompression: true,
    }
    client := &http.Client{Transport: tr, Timeout: 1 * time.Second}
    resp, err := client.Get("http://127.0.0.1:8080/")
    if err != nil {
        return
    }
    defer resp.Body.Close()
    fmt.Println(ioutil.ReadAll(resp.Body))
}

// serve.go

func main() {

mux := http.NewServeMux()

mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {

if req.URL.Path != "/" {

http.NotFound(w, req)

return

}

fmt.Fprintf(w, "Welcome to the home page!")

})

s := &http.Server{

Addr: ":8080",

Handler: mux,

ReadTimeout: 1 * time.Second,

WriteTimeout: 1 * time.Second,

MaxHeaderBytes: 1 << 20,

}

log.Fatal(s.ListenAndServe())

}

// client.go

func main() {

tr := &http.Transport{

MaxIdleConns: 10,

IdleConnTimeout: 30 * time.Second,

DisableCompression: true,

}

client := &http.Client{Transport: tr, Timeout: 1 * time.Second}

resp, err := client.Get("http://127.0.0.1:8080/")

if err != nil {

return

}

defer resp.Body.Close()

fmt.Println(ioutil.ReadAll(resp.Body))

}

I/O模型

Linux下主要的IO模型分为:

Blocking IO – 阻塞I O
Nonblocking IO – 非阻塞IO
IO multiplexing – IO 多路复用
Signal-driven IO – 信号驱动式IO（异步阻塞）
Asynchronous IO – 异步IO

同步：调用端会一直等待服务端响应，直到返回结果。
阻塞：服务端返回结果之前，客户端线程会被挂起，此时线程不可被 CPU 调度，线程暂停运行。
非阻塞：在服务端返回前，函数不会阻塞调用端线程，而会立刻返回。
异步：调用端发起调用之后不会立刻返回，不会等待服务端响应，直到产生一个信号或执行一个基于线程的回调函数来完成这次 I/O 处理过程。

I/O多路复用

Go 语言在采用 I/O 多路复用模型处理 I/O 操作，但是他没有选择最常见的系统调用 select，例如在 Linux 上使用 Epoll。虽然 select 也可以提供 I/O 多路复用的能力，但是使用它有比较多的限制：

监听能力有限 — 最多只能监听 1024 个文件描述符；
内存拷贝开销大 — 需要维护一个较大的数据结构存储文件描述符，该结构需要拷贝到内核中；
时间复杂度 𝑂(𝑛) — 返回准备就绪的事件个数后，需要遍历所有的文件描述符；

I/O 多路复用：进程阻塞于 select，等待多个 IO 中的任一个变为可读，select 调用返回，通知相应 IO 可以读。它可以支持单线程响应多个请求这种模式。

多路复用模块

为了提高 I/O 多路复用的性能
不同的操作系统也都实现了自己的 I/O 多路复用函数，例如：epoll、kqueue 和 evport 等
Go 语言为了提高在不同操作系统上的 I/O 操作性能，使用平台特定的函数实现了多个版本的网络轮询模块：

src/runtime/netpoll_epoll.go
src/runtime/netpoll_kqueue.go
src/runtime/netpoll_solaris.go
src/runtime/netpoll_windows.go
src/runtime/netpoll_aix.go
src/runtime/netpoll_fake.go

老陈是一个普通的文艺二逼青年

For The Dream

Go语言进阶（二十三）Go网络编程

网络通信协议

Socket 抽象层

TCP 可靠连接，面向连接的协议

UDP 不可靠连接，允许广播或多播

HTTP 超文本传输协议

gRPC 基于 HTTP2 协议扩展

HTTP2 如何提升网络速度

HTTPS 超文本传输安全协议

SSL/TLS 重要概念

TLS 1.2 如何解决安全问题？

TLS 1.3 Faster & More Secure

Go 网络编程基础

基础概念

TCP 简单用例

UDP 简单用例

HTTP 简单用例

I/O模型

I/O多路复用

多路复用模块