2022年11月整的活儿。我看周围的人去网上去抄一篇C/C++/Java的Socket聊天实验室基本就能很好的把作业交差了，而我则选择用刚学的Go写一个用TLS加密Socket实验室。这几天整理了以下当时的代码，用GPT4生成使用TCP，UDP，TLS的Socker服务，重新温习一下Go语言的的操作。
TCP
tcp_server.go
package main // 声明main包
import ( // 导入需要的包
"bufio" // 带缓冲的IO操作包
"fmt" // 格式化和打印
"net" // 网络操作包
"strings" // 字符串操作包
)
func main() { // 主函数
fmt.Println("Starting server...") // 打印启动服务器的信息
listener, _ := net.Listen("tcp", ":8080") // 监听8080端口
for { // 无限循环 保持服务器运行
conn, _ := listener.Accept() // 接收新的连接
go handleRequest(conn) // 单独的goroutine处理连接
}
}
func handleRequest(conn net.Conn) { // 处理请求的函数
defer conn.Close() // 函数结束时关闭连接
reader := bufio.NewReader(conn) // 从连接中读取
message, _ := reader.ReadString('\n') // 读取字符串直到\n
message = strings.TrimSpace(message) // 去掉字符串两边的空格
fmt.Printf("Received: %s\n", message) // 打印接收到的消息
conn.Write([]byte("Message received.\n")) // 响应客户端
}
一个简单的TCP Socket Server，不涉及对conn的存储
聊天室需要利用对conn的存储进行实现
UDP
udp_server.go
package main // 声明main包
import (
"fmt" // 格式化和打印输出
"net" // 网络操作包
)
func main() {
p := make([]byte, 2048) // 创建一个2048字节的缓冲区
addr := net.UDPAddr{
Port: 12345, // 监听端口
IP: net.ParseIP("127.0.0.1"), // 监听接口
}
ser, err := net.ListenUDP("udp", &addr) // 监听UDP端口
if err != nil {
fmt.Printf("Some error %v", err) // 如果监听失败,打印错误
return
}
for { // 无限循环,持续监听
_, remoteaddr, err := ser.ReadFromUDP(p) // 读取一个UDP数据报文
fmt.Printf("Read a message from %v %s \n", remoteaddr, p) // 打印客户端地址和内容
if err != nil { // 如果读取失败
fmt.Printf("Some error %v", err)
continue
}
go sendResponse(ser, remoteaddr) // 开启goroutine回复客户端
}
}
func sendResponse(conn *net.UDPConn, addr *net.UDPAddr) {
_, err := conn.WriteToUDP([]byte("From server: Hello I got your mesage "), addr) //回复客户端
if err != nil {
fmt.Printf("Couldn't send response %v", err) // 如果回复失败,打印错误
}
}
udp_client.go
go run udp_client.go 127.0.0.1:12345
package main
import (
"fmt" // 格式化和打印输出包
"net" // 网络操作包
"os" // 操作系统功能包
)
func main() {
if len(os.Args) != 2 { // 检查命令行参数数量
fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0]) // 打印使用说明
os.Exit(1) // 退出程序
}
service := os.Args[1] // 获取服务地址
udpAddr, err := net.ResolveUDPAddr("udp4", service) // 解析UDP地址
CheckError(err) // 检查错误
conn, err := net.DialUDP("udp", nil, udpAddr) // 拨号UDP服务
CheckError(err) // 检查错误
defer conn.Close() // 函数结束时关闭连接
_, err = conn.Write([]byte("Hello from client")) // 发送数据
CheckError(err) // 检查错误
var buf [512]byte // 创建512字节缓冲区
n, err := conn.Read(buf[0:]) // 读取数据
CheckError(err) // 检查错误
fmt.Println(string(buf[0:n])) // 打印接收到的数据
os.Exit(0) // 正常退出
}
func CheckError(err error) { // 错误检查函数
if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
os.Exit(1)
}
}
TLS
先用OpenSSL生成公钥和私钥证书
# 1. 生成私钥
openssl genrsa -out private.key 2048
# 2. 基于私钥生成证书签名请求(CSR)
openssl req -new -key private.key -out cert.csr
# 3. 生成自签名证书
openssl x509 -req -days 365 -in cert.csr -signkey private.key -out cert.crt
# 4. 查看证书内容
openssl x509 -in cert.crt -text -noout
转成pem文件
# 私钥
openssl pkcs8 -topk8 -inform PEM -in private.key -out private.pem -nocrypt
# 证书
openssl x509 -in cert.crt -out cert.pem -outform PEM
用Claude 2和GPT4都没有生成可用的代码，最后用ChatGPT生成了下面代码
tls_server.go
package main
import (
"crypto/tls"
"fmt"
"io"
"log"
"net"
)
func handleConnection(conn net.Conn) {
defer conn.Close()
// 在这里处理连接
buf := make([]byte, 1024)
for {
n, err := conn.Read(buf)
if err != nil {
if err != io.EOF {
fmt.Println("读取错误:", err)
}
break
}
fmt.Printf("收到消息：%s\n", string(buf[:n]))
}
}
func main() {
// 加载服务器证书和私钥
cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
if err != nil {
log.Fatal("加载证书失败：", err)
}
// 创建TLS配置
config := &tls.Config{
Certificates: []tls.Certificate{cert},
// Rand: rand.Reader,
}
// 创建监听器
listener, err := tls.Listen("tcp", ":443", config)
if err != nil {
log.Fatal("监听失败：", err)
}
defer listener.Close()
fmt.Println("等待客户端连接...")
for {
// 接受连接并处理
conn, err := listener.Accept()
if err != nil {
log.Fatal("接受连接失败：", err)
}
fmt.Println("客户端已连接：", conn.RemoteAddr())
go handleConnection(conn)
}
}
tls_client.go
package main
import (
"crypto/tls"
"fmt"
"log"
"os"
"os/signal"
"syscall"
)
func main() {
// 加载客户端证书和私钥
cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
if err != nil {
log.Fatal("加载证书失败：", err)
}
// 创建TLS配置
config := &tls.Config{
Certificates: []tls.Certificate{cert},
InsecureSkipVerify: true, // 忽略服务器端证书验证（仅用于示例，请勿在生产环境中使用）
}
// 连接服务器
conn, err := tls.Dial("tcp", "127.0.0.1:443", config)
if err != nil {
log.Fatal("连接服务器失败：", err)
}
defer conn.Close()
fmt.Println("已连接到服务器。可以开始发送消息了。")
// 启动信号监听器以便优雅地关闭连接
go func() {
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
<-sigCh
fmt.Println("收到退出信号。关闭连接...")
conn.Close()
}()
// 处理用户输入并发送消息
buf := make([]byte, 1024)
for {
n, err := os.Stdin.Read(buf)
if err != nil {
log.Fatal("读取输入错误：", err)
}
_, err = conn.Write(buf[:n])
if err != nil {
log.Fatal("发送消息失败：", err)
}
}
}
抓出来的包不是TLS
但内容确实是加密的
与纯TCP的连接做个对照
但我手头上的最早的网络实验里，Wireshark可以找到TLS的握手包
然后第二天早上在跑一遍ChatGPT写的程序，TLS1.3就被识别出来了
所以这个乌龙应该是Wireshark在IPv6上抓包引起的
Wireshark解密
常规办法：
通过设置WSSLKEYLOGFILE进行导出（仅对浏览器有效）
那就会引出下一个问题：我自己写的程序怎么办？
通过导入私钥的办法解决，这个方法用两个限制条件
- 必须要有完整的握手包（Client Hello还有Client Key Exchange，因此TLS版本必须小于1.3）
- 解密套件仅限于TLS_RSA_开头的Suite
对此，需要对服务端和客户端TLS的config做出修改，添加相关限制
MinVersion: tls.VersionTLS12,
MaxVersion: tls.VersionTLS12,
CipherSuites: []uint16{
tls.TLS_RSA_WITH_AES_128_CBC_SHA,
tls.TLS_RSA_WITH_AES_256_CBC_SHA,
},
满足上述条件即可通过导入私钥抓包
由此可见，就算是服务器丢了私钥，使用TLS1.3的情况下也无法对数据包解密
总结
Sever最终进入死循环，在循环中接收到conn后转移到goroutine中解决
实现聊天室就需要建立连接池，建一个Map或和Array的全局变量把连接添加进去即可。
