计算机网络课设——UDP/TCP/TLS Socket实验

2022年11月整的活儿。我看周围的人去网上去抄一篇C/C++/Java的Socket聊天实验室基本就能很好的把作业交差了，而我则选择用刚学的Go写一个用TLS加密Socket实验室。这几天整理了以下当时的代码，用GPT4生成使用TCP，UDP，TLS的Socker服务，重新温习一下Go语言的的操作。

TCP

tcp_server.go

1
package main // 声明main包
2

3
import ( // 导入需要的包
4
  "bufio" // 带缓冲的IO操作包
5
  "fmt" // 格式化和打印
6
  "net" // 网络操作包
7
  "strings" // 字符串操作包
8
)
9

10
func main() { // 主函数
11

12
  fmt.Println("Starting server...") // 打印启动服务器的信息
13

14
  listener, _ := net.Listen("tcp", ":8080") // 监听8080端口
15

16
  for { // 无限循环 保持服务器运行
17
    conn, _ := listener.Accept() // 接收新的连接
18
    go handleRequest(conn) // 单独的goroutine处理连接
19
  }
20
}
21

22
func handleRequest(conn net.Conn) { // 处理请求的函数
23

24
  defer conn.Close() // 函数结束时关闭连接
25

26
  reader := bufio.NewReader(conn) // 从连接中读取
27
  message, _ := reader.ReadString('\n') // 读取字符串直到\n
28
  message = strings.TrimSpace(message) // 去掉字符串两边的空格
29

30
  fmt.Printf("Received: %s\n", message) // 打印接收到的消息
31

32
  conn.Write([]byte("Message received.\n")) // 响应客户端
33
}

一个简单的TCP Socket Server，不涉及对conn的存储

聊天室需要利用对conn的存储进行实现

UDP

udp_server.go

1
package main // 声明main包
2

3
import (
4
    "fmt" // 格式化和打印输出
5
    "net" // 网络操作包
6
)
7

8
func main() {
9

10
    p := make([]byte, 2048) // 创建一个2048字节的缓冲区
11

12
    addr := net.UDPAddr{
13
        Port: 12345, // 监听端口
14
        IP:   net.ParseIP("127.0.0.1"), // 监听接口
15
    }
16

17
    ser, err := net.ListenUDP("udp", &addr) // 监听UDP端口
18

19
    if err != nil {
20
        fmt.Printf("Some error %v", err) // 如果监听失败,打印错误
21
        return
22
    }
23

24
    for { // 无限循环,持续监听
25

26
        _, remoteaddr, err := ser.ReadFromUDP(p) // 读取一个UDP数据报文
27

28
        fmt.Printf("Read a message from %v %s \n", remoteaddr, p) // 打印客户端地址和内容
29

30
        if err != nil { // 如果读取失败
31
            fmt.Printf("Some error %v", err)
32
            continue
33
        }
34

35
        go sendResponse(ser, remoteaddr) // 开启goroutine回复客户端
36

37
    }
38
}
39

40
func sendResponse(conn *net.UDPConn, addr *net.UDPAddr) {
41

42
    _, err := conn.WriteToUDP([]byte("From server: Hello I got your mesage "), addr) //回复客户端
43

44
    if err != nil {
45
        fmt.Printf("Couldn't send response %v", err) // 如果回复失败,打印错误
46
    }
47

48
}

udp_client.go

1
go run udp_client.go 127.0.0.1:12345

1
package main
2

3
import (
4
  "fmt" // 格式化和打印输出包
5
  "net" // 网络操作包
6
  "os"   // 操作系统功能包
7
)
8

9
func main() {
10

11
  if len(os.Args) != 2 { // 检查命令行参数数量
12
    fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0]) // 打印使用说明
13
    os.Exit(1) // 退出程序
14
  }
15

16
  service := os.Args[1] // 获取服务地址
17

18
  udpAddr, err := net.ResolveUDPAddr("udp4", service) // 解析UDP地址
19
  CheckError(err) // 检查错误
20

21
  conn, err := net.DialUDP("udp", nil, udpAddr) // 拨号UDP服务
22
  CheckError(err) // 检查错误
23

24
  defer conn.Close() // 函数结束时关闭连接
25

26
  _, err = conn.Write([]byte("Hello from client")) // 发送数据
27
  CheckError(err) // 检查错误
28

29
  var buf [512]byte // 创建512字节缓冲区
30
  n, err := conn.Read(buf[0:]) // 读取数据
31
  CheckError(err) // 检查错误
32

33
  fmt.Println(string(buf[0:n])) // 打印接收到的数据
34

35
  os.Exit(0) // 正常退出
36
}
37

38
func CheckError(err error) { // 错误检查函数
39
  if err != nil {
40
    fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
41
    os.Exit(1)
42
  }
43
}

TLS

先用OpenSSL生成公钥和私钥证书

1
# 1. 生成私钥
2
openssl genrsa -out private.key 2048
3

4
# 2. 基于私钥生成证书签名请求(CSR)
5
openssl req -new -key private.key -out cert.csr
6

7
# 3. 生成自签名证书
8
openssl x509 -req -days 365 -in cert.csr -signkey private.key -out cert.crt
9

10
# 4. 查看证书内容
11
openssl x509 -in cert.crt -text -noout

转成pem文件

1
# 私钥
2
openssl pkcs8 -topk8 -inform PEM -in private.key -out private.pem -nocrypt
3

4
# 证书
5
openssl x509 -in cert.crt -out cert.pem -outform PEM

用Claude 2和GPT4都没有生成可用的代码，最后用ChatGPT生成了下面代码

tls_server.go

1
package main
2

3
import (
4
  "crypto/tls"
5
  "fmt"
6
  "io"
7
  "log"
8
  "net"
9
)
10

11
func handleConnection(conn net.Conn) {
12
  defer conn.Close()
13

14
  // 在这里处理连接
15
  buf := make([]byte, 1024)
16
  for {
17
    n, err := conn.Read(buf)
18
    if err != nil {
19
      if err != io.EOF {
20
        fmt.Println("读取错误:", err)
21
      }
22
      break
23
    }
24
    fmt.Printf("收到消息：%s\n", string(buf[:n]))
25
  }
26
}
27

28
func main() {
29
  // 加载服务器证书和私钥
30
  cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
31
  if err != nil {
32
    log.Fatal("加载证书失败：", err)
33
  }
34

35
  // 创建TLS配置
36
  config := &tls.Config{
37
    Certificates: []tls.Certificate{cert},
38
    // Rand:         rand.Reader,
39
  }
40

41
  // 创建监听器
42
  listener, err := tls.Listen("tcp", ":443", config)
43
  if err != nil {
44
    log.Fatal("监听失败：", err)
45
  }
46
  defer listener.Close()
47

48
  fmt.Println("等待客户端连接...")
49

50
  for {
51
    // 接受连接并处理
52
    conn, err := listener.Accept()
53
    if err != nil {
54
      log.Fatal("接受连接失败：", err)
55
    }
56
    fmt.Println("客户端已连接：", conn.RemoteAddr())
57

58
    go handleConnection(conn)
59
  }
60
}

tls_client.go

1
package main
2

3
import (
4
  "crypto/tls"
5
  "fmt"
6
  "log"
7
  "os"
8
  "os/signal"
9
  "syscall"
10
)
11

12
func main() {
13
  // 加载客户端证书和私钥
14
  cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
15
  if err != nil {
16
    log.Fatal("加载证书失败：", err)
17
  }
18

19
  // 创建TLS配置
20
  config := &tls.Config{
21
    Certificates:       []tls.Certificate{cert},
22
    InsecureSkipVerify: true, // 忽略服务器端证书验证（仅用于示例，请勿在生产环境中使用）
23
  }
24

25
  // 连接服务器
26
  conn, err := tls.Dial("tcp", "127.0.0.1:443", config)
27
  if err != nil {
28
    log.Fatal("连接服务器失败：", err)
29
  }
30
  defer conn.Close()
31

32
  fmt.Println("已连接到服务器。可以开始发送消息了。")
33

34
  // 启动信号监听器以便优雅地关闭连接
35
  go func() {
36
    sigCh := make(chan os.Signal, 1)
37
    signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
38
    <-sigCh
39

40
    fmt.Println("收到退出信号。关闭连接...")
41
    conn.Close()
42
  }()
43

44
  // 处理用户输入并发送消息
45
  buf := make([]byte, 1024)
46
  for {
47
    n, err := os.Stdin.Read(buf)
48
    if err != nil {
49
      log.Fatal("读取输入错误：", err)
50
    }
51
    _, err = conn.Write(buf[:n])
52
    if err != nil {
53
      log.Fatal("发送消息失败：", err)
54
    }
55
  }
56
}

抓出来的包不是TLS

但内容确实是加密的

与纯TCP的连接做个对照

但我手头上的最早的网络实验里，Wireshark可以找到TLS的握手包

然后第二天早上在跑一遍ChatGPT写的程序，TLS1.3就被识别出来了

所以这个乌龙应该是Wireshark在IPv6上抓包引起的

Wireshark解密

常规办法：

通过设置WSSLKEYLOGFILE进行导出（仅对浏览器有效）

那就会引出下一个问题：我自己写的程序怎么办？

通过导入私钥的办法解决，这个方法用两个限制条件

必须要有完整的握手包（Client Hello还有Client Key Exchange，因此TLS版本必须小于1.3）
解密套件仅限于TLS_RSA_开头的Suite

对此，需要对服务端和客户端TLS的config做出修改，添加相关限制

1
MinVersion:         tls.VersionTLS12,
2
MaxVersion:         tls.VersionTLS12,
3
CipherSuites: []uint16{
4
    tls.TLS_RSA_WITH_AES_128_CBC_SHA,
5
    tls.TLS_RSA_WITH_AES_256_CBC_SHA,
6
},

满足上述条件即可通过导入私钥抓包

由此可见，就算是服务器丢了私钥，使用TLS1.3的情况下也无法对数据包解密

总结

Sever最终进入死循环，在循环中接收到conn后转移到goroutine中解决

实现聊天室就需要建立连接池，建一个Map或和Array的全局变量把连接添加进去即可。