Feature: Add Go TCP server framework

2026-01-21 23:13:08 +08:00 · 2025-12-19 14:12:29 +01:00
parent 7d2cf647ec
commit 5a33628b92
16 changed files with 2807 additions and 0 deletions
--- a/server/go/.vscode/launch.json
+++ b/server/go/.vscode/launch.json
@@ -0,0 +1,30 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Server",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "${workspaceFolder}/cmd",
+            "cwd": "${workspaceFolder}",
+            "args": [],
+            "env": {},
+            "console": "integratedTerminal"
+        },
+        {
+            "name": "Debug Server",
+            "type": "go",
+            "request": "launch",
+            "mode": "debug",
+            "program": "${workspaceFolder}/cmd",
+            "cwd": "${workspaceFolder}",
+            "args": [
+                "-port=9090"
+            ],
+            "env": {},
+            "console": "integratedTerminal",
+            "buildFlags": "-gcflags='all=-N -l'"
+        }
+    ]
+}
--- a/server/go/README.md
+++ b/server/go/README.md
@@ -0,0 +1,333 @@
+# SimpleRemoter Go TCP Server Framework
+
+基于 Go 语言实现的高性能 TCP 服务端框架，用于替代原有的 C++ IOCP 服务端。
+
+## 项目结构
+
+```
+server/go/
+├── go.mod                    # Go 模块定义
+├── buffer/
+│   └── buffer.go            # 线程安全的动态缓冲区
+├── connection/
+│   ├── context.go           # 连接上下文
+│   ├── errors.go            # 错误定义
+│   └── manager.go           # 连接管理器
+├── protocol/
+│   ├── parser.go            # 协议解析器
+│   ├── codec.go             # 编解码和压缩 (ZSTD)
+│   ├── header.go            # 协议头解密 (8种加密方式)
+│   └── commands.go          # 命令常量和LOGIN_INFOR解析
+├── server/
+│   ├── server.go            # TCP 服务器核心
+│   └── pool.go              # Goroutine 工作池
+├── logger/
+│   └── logger.go            # 日志模块 (基于 zerolog)
+└── cmd/
+    └── main.go              # 程序入口
+```
+
+## 核心特性
+
+- **高并发**: 基于 Goroutine 池管理并发连接
+- **协议兼容**: 支持原有 C++ 客户端的多种协议标识 (Hell/Hello/Shine/Fuck)
+- **协议头解密**: 支持8种协议头加密方式 (V0-V6 + Default)
+- **XOR编码**: 支持 XOREncoder16 数据编码/解码
+- **ZSTD 压缩**: 使用高效的 ZSTD 算法进行数据压缩
+- **GBK编码**: 自动将 Windows 客户端的 GBK 编码转换为 UTF-8
+- **线程安全**: Buffer、连接管理器和 LastActive 均为线程安全设计
+- **优雅关闭**: 支持信号处理和优雅停机，自动释放资源
+- **可配置**: 支持自定义端口、最大连接数、超时时间等
+- **日志系统**: 基于 zerolog，支持文件输出、日志轮转、客户端上下线记录
+
+## 支持的命令
+
+当前已实现以下命令处理：
+
+| 命令 | 值 | 说明 |
+|------|-----|------|
+| TOKEN_AUTH | 100 | 授权请求 |
+| TOKEN_HEARTBEAT | 101 | 心跳包 |
+| TOKEN_LOGIN | 102 | 客户端登录 |
+
+其他命令会被记录为 Debug 日志，可按需扩展。
+
+## 快速开始
+
+### 安装依赖
+
+```bash
+cd server/go
+go mod tidy
+```
+
+### 编译
+
+```bash
+go build -o simpleremoter-server ./cmd
+```
+
+### 运行
+
+```bash
+./simpleremoter-server
+```
+
+服务器默认监听 6543 端口，日志输出到 `logs/server.log`。
+
+## 使用示例
+
+```go
+package main
+
+import (
+    "os"
+    "os/signal"
+    "syscall"
+
+    "github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
+    "github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
+    "github.com/yuanyuanxiang/SimpleRemoter/server/go/protocol"
+    "github.com/yuanyuanxiang/SimpleRemoter/server/go/server"
+)
+
+// 实现 Handler 接口
+type MyHandler struct {
+    log *logger.Logger
+}
+
+func (h *MyHandler) OnConnect(ctx *connection.Context) {
+    h.log.ClientEvent("online", ctx.ID, ctx.GetPeerIP())
+}
+
+func (h *MyHandler) OnDisconnect(ctx *connection.Context) {
+    h.log.ClientEvent("offline", ctx.ID, ctx.GetPeerIP())
+}
+
+func (h *MyHandler) OnReceive(ctx *connection.Context, data []byte) {
+    if len(data) == 0 {
+        return
+    }
+    cmd := data[0]
+    switch cmd {
+    case protocol.TokenLogin:
+        info, _ := protocol.ParseLoginInfo(data)
+        h.log.Info("Client login: %s (%s)", info.PCName, info.OsVerInfo)
+    case protocol.TokenHeartbeat:
+        h.log.Debug("Heartbeat from client %d", ctx.ID)
+    }
+}
+
+func main() {
+    // 配置日志 (控制台 + 文件)
+    logCfg := logger.DefaultConfig()
+    logCfg.File = "logs/server.log"
+    log := logger.New(logCfg)
+
+    // 配置服务器
+    config := server.DefaultConfig()
+    config.Port = 6543
+
+    // 创建并启动服务器
+    srv := server.New(config)
+    srv.SetLogger(log.WithPrefix("Server"))
+    srv.SetHandler(&MyHandler{log: log})
+
+    if err := srv.Start(); err != nil {
+        log.Fatal("启动失败: %v", err)
+    }
+
+    // 等待退出信号
+    sigChan := make(chan os.Signal, 1)
+    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+    <-sigChan
+
+    srv.Stop()
+}
+```
+
+## 配置选项
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| Port | 8080 | 监听端口 |
+| MaxConnections | 10000 | 最大连接数 |
+| MinWorkers | 4 | 最小工作协程数 |
+| MaxWorkers | 100 | 最大工作协程数 |
+| ReadBufferSize | 8192 | 读缓冲区大小 |
+| WriteBufferSize | 8192 | 写缓冲区大小 |
+| KeepAliveTime | 5min | 连接保活时间 |
+| ReadTimeout | 2min | 读超时时间 |
+| WriteTimeout | 30s | 写超时时间 |
+
+## 日志配置
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| Level | Info | 日志级别 (Debug/Info/Warn/Error/Fatal) |
+| Console | true | 是否输出到控制台 |
+| File | "" | 日志文件路径 (空则不写文件) |
+| MaxSize | 100 | 单个日志文件最大 MB |
+| MaxBackups | 3 | 保留的旧日志文件数量 |
+| MaxAge | 30 | 旧日志保留天数 |
+| Compress | true | 是否压缩轮转的日志 |
+
+日志示例输出：
+```json
+{"level":"info","module":"Server","time":"2025-12-19T13:17:32+01:00","message":"Server started on port 6543"}
+{"level":"info","module":"Handler","event":"login","client_id":1,"ip":"192.168.0.92","computer":"DESKTOP-BI6RGEJ","os":"Windows 10","version":"Dec 19 2025","time":"2025-12-19T13:17:32+01:00"}
+{"level":"debug","module":"Handler","time":"2025-12-19T13:17:47+01:00","message":"Heartbeat from client 1 (DESKTOP-BI6RGEJ)"}
+```
+
+## 协议格式
+
+数据包格式与 C++ 版本兼容：
+
+```
+----------+------------+------------+------------------+
+|  Flag    | TotalLen   | OrigLen    |  Compressed Data |
+| (N bytes)| (4 bytes)  | (4 bytes)  |  (variable)      |
+----------+------------+------------+------------------+
+```
+
+### 协议标识
+
+| 标识 | Flag长度 | 压缩方式 | 说明 |
+|------|----------|----------|------|
+| HELL | 8 bytes | ZSTD | 主要协议 |
+| Hello? | 8 bytes | None | 无压缩协议 |
+| Shine | 5 bytes | ZSTD | 备用协议 |
+| <<FUCK>> | 11 bytes | ZSTD | 备用协议 |
+
+### 协议头加密
+
+支持8种加密方式，服务端自动检测并解密：
+- V0 (Default): 动态密钥，4种操作
+- V1: 交替加减
+- V2: 带旋转的异或
+- V3: 带位置的动态密钥
+- V4: 对称的伪随机异或
+- V5: 带位移的动态密钥
+- V6: 带位置的伪随机
+- V7: 纯异或
+
+### LOGIN_INFOR 结构
+
+客户端登录信息结构体 (考虑 C++ 内存对齐)：
+
+| 字段 | 偏移 | 大小 | 说明 |
+|------|------|------|------|
+| bToken | 0 | 1 | 命令标识 (102) |
+| OsVerInfoEx | 1 | 156 | 操作系统版本 |
+| (padding) | 157 | 3 | 对齐填充 |
+| dwCPUMHz | 160 | 4 | CPU 频率 |
+| moduleVersion | 164 | 24 | 模块版本 |
+| szPCName | 188 | 240 | 计算机名 |
+| szMasterID | 428 | 20 | 主控 ID |
+| bWebCamExist | 448 | 4 | 是否有摄像头 |
+| dwSpeed | 452 | 4 | 网速 |
+| szStartTime | 456 | 20 | 启动时间 |
+| szReserved | 476 | 512 | 扩展字段 (用`|`分隔) |
+
+## API 参考
+
+### Server
+
+```go
+// 创建服务器
+srv := server.New(config)
+
+// 设置日志
+srv.SetLogger(log)
+
+// 设置事件处理器
+srv.SetHandler(handler)
+
+// 启动服务器
+srv.Start()
+
+// 停止服务器
+srv.Stop()
+
+// 发送数据到指定连接
+srv.Send(ctx, data)
+
+// 广播数据到所有连接
+srv.Broadcast(data)
+
+// 获取当前连接数
+count := srv.ConnectionCount()
+```
+
+### Connection Context
+
+```go
+// 发送数据
+ctx.Send(data)
+
+// 关闭连接
+ctx.Close()
+
+// 获取客户端 IP
+ip := ctx.GetPeerIP()
+
+// 检查连接状态
+closed := ctx.IsClosed()
+
+// 获取/更新最后活跃时间 (线程安全)
+lastActive := ctx.LastActive()
+ctx.UpdateLastActive()
+duration := ctx.TimeSinceLastActive()
+
+// 设置/获取客户端信息
+ctx.SetInfo(clientInfo)
+info := ctx.GetInfo()
+
+// 设置/获取用户数据
+ctx.SetUserData(myData)
+data := ctx.GetUserData()
+```
+
+### Protocol
+
+```go
+// 解析登录信息
+info, err := protocol.ParseLoginInfo(data)
+if err == nil {
+    fmt.Println(info.PCName)      // 计算机名
+    fmt.Println(info.OsVerInfo)   // 操作系统
+    fmt.Println(info.ModuleVersion) // 版本
+    fmt.Println(info.WebCamExist) // 是否有摄像头
+}
+
+// 获取扩展字段
+reserved := info.ParseReserved()  // 返回 []string
+clientType := info.GetReservedField(0)  // 客户端类型
+cpuCores := info.GetReservedField(2)    // CPU 核数
+filePath := info.GetReservedField(4)    // 文件路径
+publicIP := info.GetReservedField(11)   // 公网 IP
+```
+
+## 与 C++ 版本对比
+
+| 特性 | C++ (IOCP) | Go |
+|------|------------|-----|
+| 并发模型 | IOCP + 线程池 | Goroutine 池 |
+| 压缩算法 | ZSTD | ZSTD |
+| 跨平台 | Windows | 全平台 |
+| 内存管理 | 手动 | GC |
+| 代码复杂度 | 高 | 低 |
+| 协议头解密 | 8种方式 | 8种方式 |
+| XOR编码 | XOREncoder16 | XOREncoder16 |
+| 字符编码 | GBK | GBK -> UTF-8 |
+
+## 依赖
+
+- [github.com/klauspost/compress/zstd](https://github.com/klauspost/compress) - ZSTD 压缩
+- [github.com/rs/zerolog](https://github.com/rs/zerolog) - 高性能日志
+- [gopkg.in/natefinch/lumberjack.v2](https://github.com/natefinch/lumberjack) - 日志轮转
+- [golang.org/x/text](https://pkg.go.dev/golang.org/x/text) - GBK 编码转换
+
+## License
+
+MIT License
--- a/server/go/auth/auth.go
+++ b/server/go/auth/auth.go
@@ -0,0 +1,208 @@
+package auth
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"os"
+	"strings"
+
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
+)
+
+// Config holds authentication configuration
+type Config struct {
+	PwdHash   string // SHA256 hash of the password (64 hex chars)
+	SuperPass string // Super admin password for HMAC verification
+}
+
+// DefaultConfig returns default auth configuration
+func DefaultConfig() *Config {
+	return &Config{
+		PwdHash:   "", // Must be configured
+		SuperPass: "", // Can be set via YAMA_PWD env var
+	}
+}
+
+// Authenticator handles token authentication
+type Authenticator struct {
+	config *Config
+}
+
+// New creates a new Authenticator
+func New(config *Config) *Authenticator {
+	return &Authenticator{config: config}
+}
+
+// AuthResult contains the result of authentication
+type AuthResult struct {
+	Valid    bool
+	Message  string
+	SN       string
+	Passcode string
+}
+
+// Authenticate validates a TOKEN_AUTH request
+// Data format:
+//   - offset 0: TOKEN_AUTH command byte
+//   - offset 1-19: SN (serial number, 19 bytes)
+//   - offset 20-62: Passcode (42 bytes)
+//   - offset 62-70: HMAC signature (uint64, 8 bytes) if len > 64
+func (a *Authenticator) Authenticate(data []byte) *AuthResult {
+	result := &AuthResult{
+		Valid:   false,
+		Message: "未获授权或消息哈希校验失败",
+	}
+
+	// Minimum length check: 1 (token) + 19 (sn) + 1 (at least some passcode)
+	if len(data) <= 20 {
+		return result
+	}
+
+	// Extract SN (bytes 1-19)
+	sn := string(data[1:20])
+	result.SN = sn
+
+	// Extract passcode (bytes 20-62, or until end if shorter)
+	passcodeEnd := 62
+	if len(data) < passcodeEnd {
+		passcodeEnd = len(data)
+	}
+	passcode := string(data[20:passcodeEnd])
+	result.Passcode = passcode
+
+	// Extract HMAC if present (bytes 62-70)
+	var hmacSig uint64
+	if len(data) >= 70 {
+		hmacSig = binary.LittleEndian.Uint64(data[62:70])
+	} else if len(data) > 62 {
+		// Partial HMAC data - safely handle incomplete bytes
+		hmacBytes := make([]byte, 8)
+		copy(hmacBytes, data[62:])
+		hmacSig = binary.LittleEndian.Uint64(hmacBytes)
+	}
+
+	// Split passcode by '-'
+	parts := strings.Split(passcode, "-")
+	if len(parts) != 6 && len(parts) != 7 {
+		return result
+	}
+
+	// Get last 4 parts as subvector
+	subvector := parts[len(parts)-4:]
+
+	// Build password string: v[0] + " - " + v[1] + ": " + PwdHash + (optional: ": " + v[2])
+	password := parts[0] + " - " + parts[1] + ": " + a.config.PwdHash
+	if len(parts) == 7 {
+		password += ": " + parts[2]
+	}
+
+	// Derive key from password and SN
+	finalKey := DeriveKey(password, sn)
+
+	// Get fixed length ID
+	hash256 := strings.Join(subvector, "-")
+	fixedKey := GetFixedLengthID(finalKey)
+
+	// Debug output (can be removed in production)
+	// fmt.Printf("DEBUG: password=%q sn=%q finalKey=%s fixedKey=%s hash256=%s\n", password, sn, finalKey, fixedKey, hash256)
+
+	// Compare
+	if hash256 != fixedKey {
+		return result
+	}
+
+	// Passcode validation successful, now verify HMAC
+	superPass := os.Getenv("YAMA_PWD")
+	if superPass == "" {
+		superPass = a.config.SuperPass
+	}
+
+	if superPass != "" && hmacSig != 0 {
+		verified := VerifyMessage(superPass, []byte(passcode), hmacSig)
+		if verified {
+			result.Valid = true
+			result.Message = "此程序已获授权，请遵守授权协议，感谢合作"
+		}
+		// If HMAC verification fails, valid remains false
+	} else if hmacSig == 0 {
+		// No HMAC provided but passcode is valid - could be older client
+		// Keep as invalid for security
+	}
+
+	return result
+}
+
+// utf8ToGBK converts UTF-8 string to GBK encoded bytes
+func utf8ToGBK(s string) []byte {
+	reader := transform.NewReader(bytes.NewReader([]byte(s)), simplifiedchinese.GBK.NewEncoder())
+	buf := new(bytes.Buffer)
+	buf.ReadFrom(reader)
+	return buf.Bytes()
+}
+
+// BuildResponse builds the 100-byte response for TOKEN_AUTH
+func (a *Authenticator) BuildResponse(result *AuthResult) []byte {
+	resp := make([]byte, 100)
+	if result.Valid {
+		resp[0] = 1
+	}
+	// Message starts at offset 4, convert UTF-8 to GBK for Windows client
+	gbkMsg := utf8ToGBK(result.Message)
+	copy(resp[4:], gbkMsg)
+	return resp
+}
+
+// HashSHA256 computes SHA256 hash and returns hex string
+func HashSHA256(data string) string {
+	h := sha256.New()
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum(nil))
+}
+
+// DeriveKey derives a key from password and hardware ID
+// Format: SHA256(password + " + " + hardwareID)
+func DeriveKey(password, hardwareID string) string {
+	return HashSHA256(password + " + " + hardwareID)
+}
+
+// GetFixedLengthID formats a hash into fixed length ID
+// Format: xxxx-xxxx-xxxx-xxxx (first 16 chars split by -)
+func GetFixedLengthID(hash string) string {
+	if len(hash) < 16 {
+		return hash
+	}
+	return hash[0:4] + "-" + hash[4:8] + "-" + hash[8:12] + "-" + hash[12:16]
+}
+
+// SignMessage computes HMAC-SHA256 and returns first 8 bytes as uint64
+func SignMessage(pwd string, msg []byte) uint64 {
+	h := hmac.New(sha256.New, []byte(pwd))
+	h.Write(msg)
+	hash := h.Sum(nil)
+	return binary.LittleEndian.Uint64(hash[:8])
+}
+
+// VerifyMessage verifies HMAC signature
+func VerifyMessage(pwd string, msg []byte, signature uint64) bool {
+	computed := SignMessage(pwd, msg)
+	return computed == signature
+}
+
+// GenHMAC generates HMAC for password verification
+// This matches the C++ genHMAC function
+func GenHMAC(pwdHash, superPass string) string {
+	key := HashSHA256(superPass)
+	list := []string{"g", "h", "o", "s", "t"}
+	for _, item := range list {
+		key = HashSHA256(key + " - " + item)
+	}
+	result := HashSHA256(pwdHash + " - " + key)
+	if len(result) >= 16 {
+		return result[:16]
+	}
+	return result
+}
--- a/server/go/buffer/buffer.go
+++ b/server/go/buffer/buffer.go
@@ -0,0 +1,185 @@
+package buffer
+
+import (
+	"encoding/binary"
+	"sync"
+)
+
+// Buffer is a thread-safe dynamic buffer for network I/O
+type Buffer struct {
+	data   []byte
+	mu     sync.RWMutex
+	offset int // read offset for lazy compaction
+}
+
+// New creates a new buffer with optional initial capacity
+func New(capacity ...int) *Buffer {
+	cap := 4096
+	if len(capacity) > 0 && capacity[0] > 0 {
+		cap = capacity[0]
+	}
+	return &Buffer{
+		data: make([]byte, 0, cap),
+	}
+}
+
+// Write appends data to the buffer
+func (b *Buffer) Write(p []byte) (int, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.data = append(b.data, p...)
+	return len(p), nil
+}
+
+// WriteUint32 writes a uint32 in little-endian format
+func (b *Buffer) WriteUint32(v uint32) {
+	buf := make([]byte, 4)
+	binary.LittleEndian.PutUint32(buf, v)
+	b.Write(buf)
+}
+
+// Read reads and removes data from the buffer
+func (b *Buffer) Read(n int) []byte {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	available := len(b.data) - b.offset
+	if n > available {
+		n = available
+	}
+	if n <= 0 {
+		return nil
+	}
+
+	result := make([]byte, n)
+	copy(result, b.data[b.offset:b.offset+n])
+	b.offset += n
+
+	// Compact when offset is large enough
+	if b.offset > len(b.data)/2 && b.offset > 1024 {
+		b.compact()
+	}
+
+	return result
+}
+
+// Peek returns data without removing it
+func (b *Buffer) Peek(n int) []byte {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	available := len(b.data) - b.offset
+	if n > available {
+		n = available
+	}
+	if n <= 0 {
+		return nil
+	}
+
+	result := make([]byte, n)
+	copy(result, b.data[b.offset:b.offset+n])
+	return result
+}
+
+// PeekAt returns data at a specific offset without removing it
+func (b *Buffer) PeekAt(offset, n int) []byte {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	start := b.offset + offset
+	if start >= len(b.data) {
+		return nil
+	}
+
+	end := start + n
+	if end > len(b.data) {
+		end = len(b.data)
+	}
+
+	result := make([]byte, end-start)
+	copy(result, b.data[start:end])
+	return result
+}
+
+// Skip removes n bytes from the beginning
+func (b *Buffer) Skip(n int) int {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	available := len(b.data) - b.offset
+	if n > available {
+		n = available
+	}
+	b.offset += n
+
+	// Compact when offset is large enough
+	if b.offset > len(b.data)/2 && b.offset > 1024 {
+		b.compact()
+	}
+
+	return n
+}
+
+// Len returns the length of unread data
+func (b *Buffer) Len() int {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return len(b.data) - b.offset
+}
+
+// Bytes returns all unread data without removing it
+func (b *Buffer) Bytes() []byte {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	n := len(b.data) - b.offset
+	if n <= 0 {
+		return nil
+	}
+
+	result := make([]byte, n)
+	copy(result, b.data[b.offset:])
+	return result
+}
+
+// Clear removes all data from the buffer
+func (b *Buffer) Clear() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.data = b.data[:0]
+	b.offset = 0
+}
+
+// compact moves remaining data to the beginning
+func (b *Buffer) compact() {
+	if b.offset > 0 {
+		remaining := len(b.data) - b.offset
+		copy(b.data[:remaining], b.data[b.offset:])
+		b.data = b.data[:remaining]
+		b.offset = 0
+	}
+}
+
+// GetByte returns a single byte at offset
+func (b *Buffer) GetByte(offset int) byte {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	idx := b.offset + offset
+	if idx >= len(b.data) {
+		return 0
+	}
+	return b.data[idx]
+}
+
+// GetUint32 returns a uint32 at offset in little-endian format
+func (b *Buffer) GetUint32(offset int) uint32 {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	idx := b.offset + offset
+	if idx+4 > len(b.data) {
+		return 0
+	}
+	return binary.LittleEndian.Uint32(b.data[idx : idx+4])
+}
--- a/server/go/cmd/main.go
+++ b/server/go/cmd/main.go
@@ -0,0 +1,268 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/auth"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/protocol"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/server"
+)
+
+// MyHandler implements the server.Handler interface
+type MyHandler struct {
+	log  *logger.Logger
+	auth *auth.Authenticator
+	srv  *server.Server
+}
+
+// OnConnect is called when a client connects
+func (h *MyHandler) OnConnect(ctx *connection.Context) {
+	// Only log connection established, detailed info logged on login
+}
+
+// OnDisconnect is called when a client disconnects
+func (h *MyHandler) OnDisconnect(ctx *connection.Context) {
+	info := ctx.GetInfo()
+	if info.ClientID != "" {
+		h.log.ClientEvent("offline", ctx.ID, ctx.GetPeerIP(),
+			"clientID", info.ClientID,
+			"computer", info.ComputerName,
+		)
+	}
+}
+
+// OnReceive is called when data is received from a client
+func (h *MyHandler) OnReceive(ctx *connection.Context, data []byte) {
+	if len(data) == 0 {
+		return
+	}
+
+	cmd := data[0]
+	// Handle commands
+	switch cmd {
+	case protocol.TokenLogin:
+		h.handleLogin(ctx, data)
+	case protocol.TokenAuth:
+		h.handleAuth(ctx, data)
+	case protocol.TokenHeartbeat:
+		h.handleHeartbeat(ctx, data)
+	default:
+		// Other commands are not implemented yet
+		h.log.Info("Unhandled command %d from client %d", cmd, ctx.ID)
+	}
+}
+
+// handleLogin handles client login (TOKEN_LOGIN = 102)
+func (h *MyHandler) handleLogin(ctx *connection.Context, data []byte) {
+	info, err := protocol.ParseLoginInfo(data)
+	if err != nil {
+		h.log.Error("Failed to parse login info from client %d: %v", ctx.ID, err)
+		return
+	}
+
+	// Use MasterID from login request as ClientID for logging
+	clientID := info.MasterID
+	if clientID == "" {
+		clientID = fmt.Sprintf("conn-%d", ctx.ID)
+	}
+
+	// Store client info
+	reserved := info.ParseReserved()
+	clientInfo := connection.ClientInfo{
+		ClientID:     clientID,
+		ComputerName: info.PCName,
+		OS:           info.OsVerInfo,
+		Version:      info.ModuleVersion,
+		HasCamera:    info.WebCamExist,
+		InstallTime:  info.StartTime,
+	}
+
+	// Parse additional info from reserved field
+	if len(reserved) > 0 {
+		clientInfo.ClientType = info.GetReservedField(0)
+	}
+	if len(reserved) > 2 {
+		clientInfo.CPU = info.GetReservedField(2)
+	}
+	if len(reserved) > 4 {
+		clientInfo.FilePath = info.GetReservedField(4)
+	}
+	if len(reserved) > 11 {
+		clientInfo.IP = info.GetReservedField(11) // Public IP
+	}
+
+	ctx.SetInfo(clientInfo)
+	ctx.IsLoggedIn.Store(true)
+
+	h.log.ClientEvent("online", ctx.ID, ctx.GetPeerIP(),
+		"clientID", clientID,
+		"computer", info.PCName,
+		"os", info.OsVerInfo,
+		"version", info.ModuleVersion,
+		"path", clientInfo.FilePath,
+	)
+}
+
+// handleAuth handles authorization request (TOKEN_AUTH = 100)
+func (h *MyHandler) handleAuth(ctx *connection.Context, data []byte) {
+	result := h.auth.Authenticate(data)
+	info := ctx.GetInfo()
+
+	if result.Valid {
+		h.log.Info("Auth success: clientID=%s computer=%s ip=%s sn=%s passcode=%s",
+			info.ClientID, info.ComputerName, ctx.GetPeerIP(), result.SN, result.Passcode)
+	} else {
+		h.log.Warn("Auth failed: clientID=%s computer=%s ip=%s sn=%s passcode=%s",
+			info.ClientID, info.ComputerName, ctx.GetPeerIP(), result.SN, result.Passcode)
+	}
+
+	// Build and send response
+	resp := h.auth.BuildResponse(result)
+	if err := h.srv.Send(ctx, resp); err != nil {
+		h.log.Error("Failed to send auth response to client %d: %v", ctx.ID, err)
+	}
+}
+
+// handleHeartbeat handles heartbeat from client (TOKEN_HEARTBEAT = 101)
+func (h *MyHandler) handleHeartbeat(ctx *connection.Context, data []byte) {
+
+	// Parse Time from heartbeat request (offset 1, 8 bytes)
+	var hbTime uint64
+	if len(data) >= 9 {
+		hbTime = uint64(data[1]) | uint64(data[2])<<8 | uint64(data[3])<<16 | uint64(data[4])<<24 |
+			uint64(data[5])<<32 | uint64(data[6])<<40 | uint64(data[7])<<48 | uint64(data[8])<<56
+	}
+
+	// Build HeartbeatACK response: CMD_HEARTBEAT_ACK(1) + HeartbeatACK(32)
+	resp := make([]byte, 33)
+	resp[0] = protocol.CommandHeartbeat // CMD_HEARTBEAT_ACK = 216
+	// Time at offset 1 (8 bytes, little-endian)
+	resp[1] = byte(hbTime)
+	resp[2] = byte(hbTime >> 8)
+	resp[3] = byte(hbTime >> 16)
+	resp[4] = byte(hbTime >> 24)
+	resp[5] = byte(hbTime >> 32)
+	resp[6] = byte(hbTime >> 40)
+	resp[7] = byte(hbTime >> 48)
+	resp[8] = byte(hbTime >> 56)
+	// Reserved[24] at offset 9 is already zero
+
+	if err := h.srv.Send(ctx, resp); err != nil {
+		h.log.Error("Failed to send heartbeat ACK to client %d: %v", ctx.ID, err)
+	}
+}
+
+// parsePorts parses a semicolon-separated port string and returns port numbers
+func parsePorts(portStr string) ([]int, error) {
+	var ports []int
+	parts := strings.Split(portStr, ";")
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		port, err := strconv.Atoi(p)
+		if err != nil {
+			return nil, fmt.Errorf("invalid port %q: %v", p, err)
+		}
+		if port < 1 || port > 65535 {
+			return nil, fmt.Errorf("port %d out of range (1-65535)", port)
+		}
+		ports = append(ports, port)
+	}
+	if len(ports) == 0 {
+		return nil, fmt.Errorf("no valid ports specified")
+	}
+	return ports, nil
+}
+
+func main() {
+	// Parse command line flags
+	portStr := flag.String("port", "6543", "Server listen ports (semicolon-separated, e.g. 6543;6544;6545)")
+	flag.StringVar(portStr, "p", "6543", "Server listen ports (shorthand)")
+	noConsole := flag.Bool("no-console", false, "Disable console output (for daemon mode)")
+	flag.Parse()
+
+	// Parse ports
+	ports, err := parsePorts(*portStr)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Create logger with file output
+	logCfg := logger.DefaultConfig()
+	logCfg.Level = logger.LevelDebug
+	logCfg.Console = !*noConsole
+	logCfg.File = "logs/server.log"
+	logCfg.MaxSize = 100   // 100 MB
+	logCfg.MaxBackups = 10 // keep 10 old files
+	logCfg.MaxAge = 30     // 30 days
+	logCfg.Compress = true
+
+	log := logger.New(logCfg)
+
+	// Create auth config
+	authCfg := auth.DefaultConfig()
+	// PwdHash can be set from environment or config file
+	authCfg.PwdHash = os.Getenv("YAMA_PWDHASH")
+	if authCfg.PwdHash == "" {
+		// Default placeholder - should be configured in production
+		authCfg.PwdHash = "61f04dd637a74ee34493fc1025de2c131022536da751c29e3ff4e9024d8eec43"
+	}
+	authCfg.SuperPass = os.Getenv("YAMA_PWD")
+
+	// Create authenticator (shared by all servers)
+	authenticator := auth.New(authCfg)
+
+	// Create servers for each port
+	var servers []*server.Server
+	for _, port := range ports {
+		config := server.DefaultConfig()
+		config.Port = port
+		config.MaxConnections = 9999
+
+		srv := server.New(config)
+		srv.SetLogger(log.WithPrefix(fmt.Sprintf("Server:%d", port)))
+
+		// Create handler for this server
+		handler := &MyHandler{
+			log:  log.WithPrefix(fmt.Sprintf("Handler:%d", port)),
+			auth: authenticator,
+			srv:  srv,
+		}
+		srv.SetHandler(handler)
+
+		servers = append(servers, srv)
+	}
+
+	// Start all servers
+	for _, srv := range servers {
+		if err := srv.Start(); err != nil {
+			log.Fatal("Failed to start server: %v", err)
+		}
+	}
+
+	fmt.Printf("Server started on port(s): %v\n", ports)
+	fmt.Println("Logs are written to: logs/server.log")
+	fmt.Println("Press Ctrl+C to stop...")
+
+	// Wait for interrupt signal
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	<-sigChan
+
+	fmt.Println("\nShutting down...")
+	for _, srv := range servers {
+		srv.Stop()
+	}
+	fmt.Println("Server stopped")
+}
--- a/server/go/connection/context.go
+++ b/server/go/connection/context.go
@@ -0,0 +1,197 @@
+package connection
+
+import (
+	"fmt"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/buffer"
+)
+
+// ClientInfo stores client metadata
+type ClientInfo struct {
+	ClientID     string // Client ID from login (MasterID)
+	IP           string
+	ComputerName string
+	OS           string
+	CPU          string
+	HasCamera    bool
+	Version      string
+	InstallTime  string
+	LoginTime    time.Time
+	ClientType   string
+	FilePath     string
+	GroupName    string
+}
+
+// Context represents a client connection context
+type Context struct {
+	ID         uint64
+	Conn       net.Conn
+	RemoteAddr string
+
+	// Buffers
+	InBuffer  *buffer.Buffer // Received compressed data
+	OutBuffer *buffer.Buffer // Decompressed data for processing
+
+	// Client info
+	Info      ClientInfo
+	IsLoggedIn atomic.Bool
+
+	// Connection state
+	OnlineTime   time.Time
+	lastActiveNs atomic.Int64 // Unix nanoseconds for thread-safe access
+
+	// Protocol state
+	CompressMethod int
+	FlagType       FlagType
+	HeaderLen      int
+	FlagLen        int
+	HeaderEncType  int    // Header encryption type (0-7)
+	HeaderParams   []byte // Header parameters for decoding (flag bytes)
+
+	// User data - for storing dialog/handler references
+	UserData interface{}
+
+	// Internal
+	mu       sync.RWMutex
+	closed   atomic.Bool
+	sendLock sync.Mutex
+	server   *Manager
+}
+
+// FlagType represents the protocol flag type
+type FlagType int
+
+const (
+	FlagUnknown FlagType = iota
+	FlagShine
+	FlagFuck
+	FlagHello
+	FlagHell
+	FlagWinOS
+)
+
+// Compression methods
+const (
+	CompressUnknown = -2
+	CompressZlib    = -1
+	CompressZstd    = 0
+	CompressNone    = 1
+)
+
+// NewContext creates a new connection context
+func NewContext(conn net.Conn, mgr *Manager) *Context {
+	now := time.Now()
+	ctx := &Context{
+		Conn:           conn,
+		RemoteAddr:     conn.RemoteAddr().String(),
+		InBuffer:       buffer.New(8192),
+		OutBuffer:      buffer.New(8192),
+		OnlineTime:     now,
+		CompressMethod: CompressZstd,
+		FlagType:       FlagUnknown,
+		server:         mgr,
+	}
+	ctx.lastActiveNs.Store(now.UnixNano())
+	return ctx
+}
+
+// Send sends data to the client (thread-safe)
+func (c *Context) Send(data []byte) error {
+	if c.closed.Load() {
+		return ErrConnectionClosed
+	}
+
+	c.sendLock.Lock()
+	defer c.sendLock.Unlock()
+
+	_, err := c.Conn.Write(data)
+	if err != nil {
+		return err
+	}
+	c.UpdateLastActive()
+	return nil
+}
+
+// UpdateLastActive updates the last active time (thread-safe)
+func (c *Context) UpdateLastActive() {
+	c.lastActiveNs.Store(time.Now().UnixNano())
+}
+
+// LastActive returns the last active time (thread-safe)
+func (c *Context) LastActive() time.Time {
+	return time.Unix(0, c.lastActiveNs.Load())
+}
+
+// TimeSinceLastActive returns duration since last activity (thread-safe)
+func (c *Context) TimeSinceLastActive() time.Duration {
+	return time.Since(c.LastActive())
+}
+
+// Close closes the connection
+func (c *Context) Close() error {
+	if c.closed.Swap(true) {
+		return nil // Already closed
+	}
+	return c.Conn.Close()
+}
+
+// IsClosed returns whether the connection is closed
+func (c *Context) IsClosed() bool {
+	return c.closed.Load()
+}
+
+// GetPeerIP returns the peer IP address
+func (c *Context) GetPeerIP() string {
+	if host, _, err := net.SplitHostPort(c.RemoteAddr); err == nil {
+		return host
+	}
+	return c.RemoteAddr
+}
+
+// AliveTime returns how long the connection has been alive
+func (c *Context) AliveTime() time.Duration {
+	return time.Since(c.OnlineTime)
+}
+
+// SetInfo sets the client info
+func (c *Context) SetInfo(info ClientInfo) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.Info = info
+}
+
+// GetInfo returns the client info
+func (c *Context) GetInfo() ClientInfo {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.Info
+}
+
+// SetUserData stores user-defined data
+func (c *Context) SetUserData(data interface{}) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.UserData = data
+}
+
+// GetUserData retrieves user-defined data
+func (c *Context) GetUserData() interface{} {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.UserData
+}
+
+// GetClientID returns the client ID for logging
+// If ClientID is set (from login), returns it; otherwise returns connection ID as fallback
+func (c *Context) GetClientID() string {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	if c.Info.ClientID != "" {
+		return c.Info.ClientID
+	}
+	return fmt.Sprintf("conn-%d", c.ID)
+}
--- a/server/go/connection/errors.go
+++ b/server/go/connection/errors.go
@@ -0,0 +1,23 @@
+package connection
+
+import "errors"
+
+var (
+	// ErrConnectionClosed indicates the connection is closed
+	ErrConnectionClosed = errors.New("connection closed")
+
+	// ErrServerClosed indicates the server is shut down
+	ErrServerClosed = errors.New("server closed")
+
+	// ErrMaxConnections indicates max connections reached
+	ErrMaxConnections = errors.New("max connections reached")
+
+	// ErrInvalidPacket indicates an invalid packet
+	ErrInvalidPacket = errors.New("invalid packet")
+
+	// ErrUnsupportedProtocol indicates unsupported protocol
+	ErrUnsupportedProtocol = errors.New("unsupported protocol")
+
+	// ErrDecompressFailed indicates decompression failure
+	ErrDecompressFailed = errors.New("decompression failed")
+)
--- a/server/go/connection/manager.go
+++ b/server/go/connection/manager.go
@@ -0,0 +1,115 @@
+package connection
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// Manager manages all client connections
+type Manager struct {
+	connections sync.Map // map[uint64]*Context
+	count       atomic.Int64
+	maxConns    int
+	idCounter   atomic.Uint64
+
+	// Callbacks
+	onConnect    func(*Context)
+	onDisconnect func(*Context)
+	onReceive    func(*Context, []byte)
+}
+
+// NewManager creates a new connection manager
+func NewManager(maxConns int) *Manager {
+	if maxConns <= 0 {
+		maxConns = 10000
+	}
+	return &Manager{
+		maxConns: maxConns,
+	}
+}
+
+// SetCallbacks sets the callback functions
+func (m *Manager) SetCallbacks(onConnect, onDisconnect func(*Context), onReceive func(*Context, []byte)) {
+	m.onConnect = onConnect
+	m.onDisconnect = onDisconnect
+	m.onReceive = onReceive
+}
+
+// Add adds a new connection
+func (m *Manager) Add(ctx *Context) error {
+	if int(m.count.Load()) >= m.maxConns {
+		return ErrMaxConnections
+	}
+
+	ctx.ID = m.idCounter.Add(1)
+	m.connections.Store(ctx.ID, ctx)
+	m.count.Add(1)
+
+	if m.onConnect != nil {
+		m.onConnect(ctx)
+	}
+
+	return nil
+}
+
+// Remove removes a connection
+func (m *Manager) Remove(ctx *Context) {
+	if _, ok := m.connections.LoadAndDelete(ctx.ID); ok {
+		m.count.Add(-1)
+		if m.onDisconnect != nil {
+			m.onDisconnect(ctx)
+		}
+	}
+}
+
+// Get retrieves a connection by ID
+func (m *Manager) Get(id uint64) *Context {
+	if v, ok := m.connections.Load(id); ok {
+		return v.(*Context)
+	}
+	return nil
+}
+
+// Count returns the current connection count
+func (m *Manager) Count() int {
+	return int(m.count.Load())
+}
+
+// Range iterates over all connections
+func (m *Manager) Range(fn func(*Context) bool) {
+	m.connections.Range(func(key, value interface{}) bool {
+		return fn(value.(*Context))
+	})
+}
+
+// Broadcast sends data to all connections
+func (m *Manager) Broadcast(data []byte) {
+	m.connections.Range(func(key, value interface{}) bool {
+		ctx := value.(*Context)
+		if !ctx.IsClosed() {
+			_ = ctx.Send(data)
+		}
+		return true
+	})
+}
+
+// CloseAll closes all connections
+func (m *Manager) CloseAll() {
+	m.connections.Range(func(key, value interface{}) bool {
+		ctx := value.(*Context)
+		_ = ctx.Close()
+		return true
+	})
+}
+
+// OnReceive calls the receive callback
+func (m *Manager) OnReceive(ctx *Context, data []byte) {
+	if m.onReceive != nil {
+		m.onReceive(ctx, data)
+	}
+}
+
+// UpdateMaxConnections updates the maximum connections limit
+func (m *Manager) UpdateMaxConnections(max int) {
+	m.maxConns = max
+}
--- a/server/go/go.mod
+++ b/server/go/go.mod
@@ -0,0 +1,16 @@
+module github.com/yuanyuanxiang/SimpleRemoter/server/go
+
+go 1.24.5
+
+require (
+	github.com/klauspost/compress v1.18.2
+	github.com/rs/zerolog v1.34.0
+	golang.org/x/text v0.32.0
+	gopkg.in/natefinch/lumberjack.v2 v2.2.1
+)
+
+require (
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	golang.org/x/sys v0.12.0 // indirect
+)
--- a/server/go/go.sum
+++ b/server/go/go.sum
@@ -0,0 +1,21 @@
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
+github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
--- a/server/go/logger/logger.go
+++ b/server/go/logger/logger.go
@@ -0,0 +1,204 @@
+package logger
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/rs/zerolog"
+	"gopkg.in/natefinch/lumberjack.v2"
+)
+
+// Level represents log level
+type Level = zerolog.Level
+
+const (
+	LevelDebug = zerolog.DebugLevel
+	LevelInfo  = zerolog.InfoLevel
+	LevelWarn  = zerolog.WarnLevel
+	LevelError = zerolog.ErrorLevel
+	LevelFatal = zerolog.FatalLevel
+)
+
+// Logger wraps zerolog.Logger
+type Logger struct {
+	zl zerolog.Logger
+}
+
+// Config holds logger configuration
+type Config struct {
+	// Level is the minimum log level
+	Level Level
+	// Console enables console output
+	Console bool
+	// File is the log file path (empty to disable file logging)
+	File string
+	// MaxSize is the max size in MB before rotation
+	MaxSize int
+	// MaxBackups is the max number of old log files to keep
+	MaxBackups int
+	// MaxAge is the max days to keep old log files
+	MaxAge int
+	// Compress enables gzip compression for rotated files
+	Compress bool
+}
+
+// DefaultConfig returns default configuration
+func DefaultConfig() Config {
+	return Config{
+		Level:      LevelInfo,
+		Console:    true,
+		File:       "",
+		MaxSize:    100,
+		MaxBackups: 3,
+		MaxAge:     30,
+		Compress:   true,
+	}
+}
+
+// New creates a new logger with config
+func New(cfg Config) *Logger {
+	var writers []io.Writer
+
+	// Console output with color
+	if cfg.Console {
+		consoleWriter := zerolog.ConsoleWriter{
+			Out:        os.Stdout,
+			TimeFormat: "2006-01-02 15:04:05",
+		}
+		writers = append(writers, consoleWriter)
+	}
+
+	// File output with rotation
+	if cfg.File != "" {
+		// Ensure directory exists
+		dir := filepath.Dir(cfg.File)
+		if dir != "" && dir != "." {
+			_ = os.MkdirAll(dir, 0755)
+		}
+
+		fileWriter := &lumberjack.Logger{
+			Filename:   cfg.File,
+			MaxSize:    cfg.MaxSize,
+			MaxBackups: cfg.MaxBackups,
+			MaxAge:     cfg.MaxAge,
+			Compress:   cfg.Compress,
+			LocalTime:  true,
+		}
+		writers = append(writers, fileWriter)
+	}
+
+	// Combine writers
+	var writer io.Writer
+	if len(writers) == 0 {
+		writer = os.Stdout
+	} else if len(writers) == 1 {
+		writer = writers[0]
+	} else {
+		writer = zerolog.MultiLevelWriter(writers...)
+	}
+
+	// Create logger
+	zl := zerolog.New(writer).
+		Level(cfg.Level).
+		With().
+		Timestamp().
+		Logger()
+
+	return &Logger{zl: zl}
+}
+
+// WithPrefix returns a new logger with a prefix field
+func (l *Logger) WithPrefix(prefix string) *Logger {
+	return &Logger{
+		zl: l.zl.With().Str("module", prefix).Logger(),
+	}
+}
+
+// Debug logs a debug message
+func (l *Logger) Debug(format string, args ...interface{}) {
+	l.zl.Debug().Msgf(format, args...)
+}
+
+// Info logs an info message
+func (l *Logger) Info(format string, args ...interface{}) {
+	l.zl.Info().Msgf(format, args...)
+}
+
+// Warn logs a warning message
+func (l *Logger) Warn(format string, args ...interface{}) {
+	l.zl.Warn().Msgf(format, args...)
+}
+
+// Error logs an error message
+func (l *Logger) Error(format string, args ...interface{}) {
+	l.zl.Error().Msgf(format, args...)
+}
+
+// Fatal logs a fatal message and exits
+func (l *Logger) Fatal(format string, args ...interface{}) {
+	l.zl.Fatal().Msgf(format, args...)
+}
+
+// SetLevel sets the log level
+func (l *Logger) SetLevel(level Level) {
+	l.zl = l.zl.Level(level)
+}
+
+// GetLevel returns the current log level
+func (l *Logger) GetLevel() Level {
+	return l.zl.GetLevel()
+}
+
+// ClientEvent logs client online/offline events
+func (l *Logger) ClientEvent(event string, clientID uint64, ip string, extra ...string) {
+	e := l.zl.Info().
+		Str("event", event).
+		Uint64("client_id", clientID).
+		Str("ip", ip).
+		Time("time", time.Now())
+
+	if len(extra) >= 2 {
+		for i := 0; i+1 < len(extra); i += 2 {
+			e = e.Str(extra[i], extra[i+1])
+		}
+	}
+
+	e.Msg("")
+}
+
+// default global logger
+var defaultLogger = New(DefaultConfig())
+
+// SetDefault sets the default global logger
+func SetDefault(l *Logger) {
+	defaultLogger = l
+}
+
+// Default returns the default global logger
+func Default() *Logger {
+	return defaultLogger
+}
+
+// Package-level convenience functions
+
+func Debug(format string, args ...interface{}) {
+	defaultLogger.Debug(format, args...)
+}
+
+func Info(format string, args ...interface{}) {
+	defaultLogger.Info(format, args...)
+}
+
+func Warn(format string, args ...interface{}) {
+	defaultLogger.Warn(format, args...)
+}
+
+func Error(format string, args ...interface{}) {
+	defaultLogger.Error(format, args...)
+}
+
+func Fatal(format string, args ...interface{}) {
+	defaultLogger.Fatal(format, args...)
+}
--- a/server/go/protocol/codec.go
+++ b/server/go/protocol/codec.go
@@ -0,0 +1,161 @@
+package protocol
+
+import (
+	"github.com/klauspost/compress/zstd"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
+)
+
+// Codec handles encoding/decoding and compression
+type Codec struct {
+	encoder *zstd.Encoder
+	decoder *zstd.Decoder
+}
+
+// NewCodec creates a new codec
+func NewCodec() *Codec {
+	encoder, err := zstd.NewWriter(nil, zstd.WithEncoderLevel(zstd.SpeedDefault))
+	if err != nil {
+		panic("failed to create zstd encoder: " + err.Error())
+	}
+	decoder, err := zstd.NewReader(nil)
+	if err != nil {
+		panic("failed to create zstd decoder: " + err.Error())
+	}
+
+	return &Codec{
+		encoder: encoder,
+		decoder: decoder,
+	}
+}
+
+// Compress compresses data using the appropriate method
+func (c *Codec) Compress(ctx *connection.Context, data []byte) ([]byte, error) {
+	switch ctx.CompressMethod {
+	case connection.CompressNone:
+		return data, nil
+	case connection.CompressZstd:
+		return c.encoder.EncodeAll(data, nil), nil
+	default:
+		// Default to zstd
+		return c.encoder.EncodeAll(data, nil), nil
+	}
+}
+
+// Decompress decompresses data using the appropriate method
+func (c *Codec) Decompress(ctx *connection.Context, data []byte, origLen uint32) ([]byte, error) {
+	switch ctx.CompressMethod {
+	case connection.CompressNone:
+		// No compression, return as-is
+		result := make([]byte, len(data))
+		copy(result, data)
+		return result, nil
+	case connection.CompressZstd:
+		result := make([]byte, 0, origLen)
+		return c.decoder.DecodeAll(data, result)
+	default:
+		// Try zstd by default
+		result := make([]byte, 0, origLen)
+		return c.decoder.DecodeAll(data, result)
+	}
+}
+
+// Encode encodes data after compression (before sending) - Encoder2
+func (c *Codec) Encode(ctx *connection.Context, data []byte) {
+	// This is Encoder2 - applied after compression
+	switch ctx.FlagType {
+	case connection.FlagHello, connection.FlagHell:
+		// XOREncoder16 - needs param from header
+		// For now, skip encoding on send since we need the header params
+	case connection.FlagFuck:
+		// No encoding after compression for FUCK
+	}
+}
+
+// Decode decodes data before decompression (after receiving) - Encoder2
+func (c *Codec) Decode(ctx *connection.Context, data []byte) {
+	// This is Encoder2 - applied before decompression
+	// XOREncoder16 for HELL/HELLO protocols
+	if ctx.FlagType == connection.FlagHell || ctx.FlagType == connection.FlagHello {
+		// Get k1, k2 from stored header params
+		if len(ctx.HeaderParams) >= 8 {
+			k1 := ctx.HeaderParams[6]
+			k2 := ctx.HeaderParams[7]
+			if k1 != 0 || k2 != 0 {
+				xorDecoder16(data, k1, k2)
+			}
+		}
+	}
+}
+
+// EncodeData encodes data before compression - Encoder
+func (c *Codec) EncodeData(ctx *connection.Context, data []byte) {
+	// This is Encoder - applied before compression
+	// Default encoder does nothing
+}
+
+// DecodeData decodes data after decompression - Encoder
+func (c *Codec) DecodeData(ctx *connection.Context, data []byte) {
+	// This is Encoder - applied after decompression
+	// Default encoder does nothing
+}
+
+// xorDecoder16 implements XOREncoder16.decrypt_internal
+func xorDecoder16(data []byte, k1, k2 byte) {
+	if len(data) == 0 {
+		return
+	}
+
+	key := (uint16(k1) << 8) | uint16(k2)
+	dataLen := len(data)
+
+	// Reverse two rounds of pseudo-random swaps
+	for round := 1; round >= 0; round-- {
+		for i := dataLen - 1; i >= 0; i-- {
+			j := int(pseudoRandom(key, i+round*100)) % dataLen
+			data[i], data[j] = data[j], data[i]
+		}
+	}
+
+	// XOR decode
+	for i := 0; i < dataLen; i++ {
+		data[i] ^= (k1 + byte(i*13)) ^ (k2 ^ byte(i<<1))
+	}
+}
+
+// xorEncoder16 implements XOREncoder16.encrypt_internal
+func xorEncoder16(data []byte, k1, k2 byte) {
+	if len(data) == 0 {
+		return
+	}
+
+	key := (uint16(k1) << 8) | uint16(k2)
+	dataLen := len(data)
+
+	// XOR encode
+	for i := 0; i < dataLen; i++ {
+		data[i] ^= (k1 + byte(i*13)) ^ (k2 ^ byte(i<<1))
+	}
+
+	// Two rounds of pseudo-random swaps
+	for round := 0; round < 2; round++ {
+		for i := 0; i < dataLen; i++ {
+			j := int(pseudoRandom(key, i+round*100)) % dataLen
+			data[i], data[j] = data[j], data[i]
+		}
+	}
+}
+
+// pseudoRandom matches the C++ pseudo_random function
+func pseudoRandom(seed uint16, index int) uint16 {
+	return ((seed ^ uint16(index*251+97)) * 733) ^ (seed >> 3)
+}
+
+// Close releases resources
+func (c *Codec) Close() {
+	if c.encoder != nil {
+		c.encoder.Close()
+	}
+	if c.decoder != nil {
+		c.decoder.Close()
+	}
+}
--- a/server/go/protocol/commands.go
+++ b/server/go/protocol/commands.go
@@ -0,0 +1,202 @@
+package protocol
+
+import (
+	"bytes"
+	"encoding/binary"
+	"strings"
+
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
+)
+
+// gbkToUTF8 converts GBK encoded bytes to UTF-8 string
+func gbkToUTF8(data []byte) string {
+	// Find the first null byte and truncate there
+	if idx := bytes.IndexByte(data, 0); idx >= 0 {
+		data = data[:idx]
+	}
+	if len(data) == 0 {
+		return ""
+	}
+
+	// Try to decode as GBK
+	reader := transform.NewReader(bytes.NewReader(data), simplifiedchinese.GBK.NewDecoder())
+	buf := new(bytes.Buffer)
+	_, err := buf.ReadFrom(reader)
+	if err != nil {
+		// If GBK decoding fails, try treating as UTF-8 or ASCII
+		return cleanString(string(data))
+	}
+	return cleanString(buf.String())
+}
+
+// cleanString removes non-printable characters except common whitespace
+func cleanString(s string) string {
+	var result strings.Builder
+	for _, r := range s {
+		if r >= 32 || r == '\t' || r == '\n' || r == '\r' {
+			result.WriteRune(r)
+		}
+	}
+	return strings.TrimSpace(result.String())
+}
+
+// Command tokens - matching the C++ definitions
+const (
+	// Server -> Client commands
+	CommandActived    byte = 0   // COMMAND_ACTIVED
+	CommandBye        byte = 204 // COMMAND_BYE - disconnect
+	CommandHeartbeat  byte = 216 // CMD_HEARTBEAT_ACK
+
+	// Client -> Server tokens
+	TokenAuth      byte = 100 // TOKEN_AUTH - authorization required
+	TokenHeartbeat byte = 101 // TOKEN_HEARTBEAT
+	TokenLogin     byte = 102 // TOKEN_LOGIN - login packet
+)
+
+// LOGIN_INFOR structure size and offsets (matching C++ struct with default alignment)
+// Note: C++ struct uses default alignment (4-byte for uint32/int)
+const (
+	LoginInfoSize = 980 // Total size of LOGIN_INFOR struct (with alignment padding)
+
+	// Field offsets (with alignment padding)
+	OffsetToken         = 0   // 1 byte (unsigned char)
+	OffsetOsVerInfoEx   = 1   // 156 bytes (char[156])
+	// 3 bytes padding here to align dwCPUMHz to 4-byte boundary
+	OffsetCPUMHz        = 160 // 4 bytes (unsigned int) - aligned to 4
+	OffsetModuleVersion = 164 // 24 bytes (char[24])
+	OffsetPCName        = 188 // 240 bytes (char[240])
+	OffsetMasterID      = 428 // 20 bytes (char[20])
+	OffsetWebCamExist   = 448 // 4 bytes (int) - aligned to 4
+	OffsetSpeed         = 452 // 4 bytes (unsigned int)
+	OffsetStartTime     = 456 // 20 bytes (char[20])
+	OffsetReserved      = 476 // 512 bytes (char[512])
+)
+
+// LoginInfo represents client login information
+type LoginInfo struct {
+	Token         byte
+	OsVerInfo     string // OS version info
+	CPUMHz        uint32
+	ModuleVersion string
+	PCName        string // Computer name
+	MasterID      string
+	WebCamExist   bool
+	Speed         uint32
+	StartTime     string
+	Reserved      string // Contains additional info separated by |
+}
+
+// ParseLoginInfo parses LOGIN_INFOR from data
+func ParseLoginInfo(data []byte) (*LoginInfo, error) {
+	if len(data) < 100 { // Minimum size check
+		return nil, ErrInvalidData
+	}
+
+	info := &LoginInfo{
+		Token: data[0],
+	}
+
+	// Parse OS version info (offset 1, 156 bytes)
+	// The C++ client fills this with a readable string like "Windows 10" via getSystemName()
+	if len(data) >= OffsetOsVerInfoEx+156 {
+		info.OsVerInfo = parseOsVersionInfo(data[OffsetOsVerInfoEx : OffsetOsVerInfoEx+156])
+	}
+
+	// Parse CPU MHz (offset 160, 4 bytes)
+	if len(data) >= OffsetCPUMHz+4 {
+		info.CPUMHz = binary.LittleEndian.Uint32(data[OffsetCPUMHz:])
+	}
+
+	// Parse module version (offset 164, 24 bytes)
+	// This contains date string like "Dec 19 2025"
+	if len(data) >= OffsetModuleVersion+24 {
+		info.ModuleVersion = gbkToUTF8(data[OffsetModuleVersion : OffsetModuleVersion+24])
+	}
+
+	// Parse PC name (offset 188, 240 bytes)
+	if len(data) >= OffsetPCName+240 {
+		info.PCName = gbkToUTF8(data[OffsetPCName : OffsetPCName+240])
+	}
+
+	// Parse Master ID (offset 428, 20 bytes)
+	if len(data) >= OffsetMasterID+20 {
+		info.MasterID = gbkToUTF8(data[OffsetMasterID : OffsetMasterID+20])
+	}
+
+	// Parse WebCam exist (offset 448, 4 bytes)
+	if len(data) >= OffsetWebCamExist+4 {
+		info.WebCamExist = binary.LittleEndian.Uint32(data[OffsetWebCamExist:]) != 0
+	}
+
+	// Parse Speed (offset 452, 4 bytes)
+	if len(data) >= OffsetSpeed+4 {
+		info.Speed = binary.LittleEndian.Uint32(data[OffsetSpeed:])
+	}
+
+	// Parse Start time (offset 456, 20 bytes)
+	if len(data) >= OffsetStartTime+20 {
+		info.StartTime = gbkToUTF8(data[OffsetStartTime : OffsetStartTime+20])
+	}
+
+	// Parse Reserved (offset 476, 512 bytes) - contains additional info
+	if len(data) >= OffsetReserved+512 {
+		info.Reserved = gbkToUTF8(data[OffsetReserved : OffsetReserved+512])
+	} else if len(data) > OffsetReserved {
+		info.Reserved = gbkToUTF8(data[OffsetReserved:])
+	}
+
+	return info, nil
+}
+
+// parseOsVersionInfo parses the OS version info field
+// The C++ client fills this with a readable string like "Windows 10" via getSystemName()
+func parseOsVersionInfo(data []byte) string {
+	return gbkToUTF8(data)
+}
+
+// ParseReserved parses the reserved field into a slice of strings
+func (info *LoginInfo) ParseReserved() []string {
+	if info.Reserved == "" {
+		return nil
+	}
+	return strings.Split(info.Reserved, "|")
+}
+
+// GetReservedField returns a specific field from reserved data by index
+// Fields: ClientType(0), SystemBits(1), CPU(2), Memory(3), FilePath(4),
+// Reserved(5), InstallTime(6), InstallInfo(7), ProgramBits(8), ExpiredDate(9),
+// ClientLoc(10), ClientPubIP(11), ExeVersion(12), Username(13), IsAdmin(14)
+func (info *LoginInfo) GetReservedField(index int) string {
+	fields := info.ParseReserved()
+	if index >= 0 && index < len(fields) {
+		return fields[index]
+	}
+	return ""
+}
+
+// Validation structure for TOKEN_AUTH
+type Validation struct {
+	From     string // Start date
+	To       string // End date
+	Admin    string // Admin address
+	Port     int    // Admin port
+	Checksum string // Reserved field
+}
+
+// BuildValidation creates a validation response
+func BuildValidation(days float64, admin string, port int) []byte {
+	// This would build the validation structure
+	// For now, return a simple structure
+	data := make([]byte, 160) // Size of Validation struct
+	data[0] = TokenAuth
+
+	// Fill in fields...
+	// From: 20 bytes
+	// To: 20 bytes
+	// Admin: 100 bytes
+	// Port: 4 bytes
+	// Checksum: 16 bytes
+
+	return data
+}
--- a/server/go/protocol/header.go
+++ b/server/go/protocol/header.go
@@ -0,0 +1,267 @@
+package protocol
+
+// Header encoding/decoding functions
+// Ported from common/header.h and common/encfuncs.h
+
+const (
+	MsgHeader   = "HELL"
+	FlagCompLen = 4
+	FlagLength  = 8
+	HdrLength   = FlagLength + 8 // FLAG_LENGTH + 2 * sizeof(uint32)
+	MinComLen   = 12
+)
+
+// HeaderEncType represents the encryption method used for header
+type HeaderEncType int
+
+const (
+	HeaderEncUnknown HeaderEncType = -1
+	HeaderEncNone    HeaderEncType = 0
+	HeaderEncV0      HeaderEncType = 1
+	HeaderEncV1      HeaderEncType = 2
+	HeaderEncV2      HeaderEncType = 3
+	HeaderEncV3      HeaderEncType = 4
+	HeaderEncV4      HeaderEncType = 5
+	HeaderEncV5      HeaderEncType = 6
+	HeaderEncV6      HeaderEncType = 7
+)
+
+// DecryptFunc is the function signature for header decryption
+type DecryptFunc func(data []byte, key byte)
+
+// defaultDecrypt does nothing (no encryption)
+func defaultDecrypt(data []byte, key byte) {
+	// No-op
+}
+
+// decrypt is the default encryption method (V0)
+func decrypt(data []byte, key byte) {
+	if key == 0 {
+		return
+	}
+	for i := 0; i < len(data); i++ {
+		k := key ^ byte(i*31)
+		value := int(data[i])
+		switch i % 4 {
+		case 0:
+			value -= int(k)
+		case 1:
+			value = value ^ int(k)
+		case 2:
+			value += int(k)
+		case 3:
+			value = ^value ^ int(k)
+		}
+		data[i] = byte(value & 0xFF)
+	}
+}
+
+// decryptV1 - alternating add/subtract
+func decryptV1(data []byte, key byte) {
+	for i := 0; i < len(data); i++ {
+		if i%2 == 0 {
+			data[i] = data[i] - key
+		} else {
+			data[i] = data[i] + key
+		}
+	}
+}
+
+// decryptV2 - XOR with rotation
+func decryptV2(data []byte, key byte) {
+	for i := 0; i < len(data); i++ {
+		if i%2 == 0 {
+			data[i] = (data[i] >> 1) | (data[i] << 7) // rotate right
+		} else {
+			data[i] = (data[i] << 1) | (data[i] >> 7) // rotate left
+		}
+		data[i] ^= key
+	}
+}
+
+// decryptV3 - dynamic key with position
+func decryptV3(data []byte, key byte) {
+	for i := 0; i < len(data); i++ {
+		dynamicKey := key + byte(i%8)
+		switch i % 3 {
+		case 0:
+			data[i] = (data[i] ^ dynamicKey) - dynamicKey
+		case 1:
+			data[i] = (data[i] + dynamicKey) ^ dynamicKey
+		case 2:
+			data[i] = ^data[i] - dynamicKey
+		}
+	}
+}
+
+// decryptV4 - pseudo-random XOR (symmetric)
+func decryptV4(data []byte, key byte) {
+	rand := uint16(key)
+	for i := 0; i < len(data); i++ {
+		rand = (rand*13 + 17) % 256
+		data[i] ^= byte(rand)
+	}
+}
+
+// decryptV5 - dynamic key with bit shift
+func decryptV5(data []byte, key byte) {
+	for i := 0; i < len(data); i++ {
+		dynamicKey := (key + byte(i)) ^ 0x55
+		data[i] = ((data[i] - byte(i%7)) ^ (dynamicKey << 3)) - dynamicKey
+	}
+}
+
+// decryptV6 - pseudo-random with position (symmetric)
+func decryptV6(data []byte, key byte) {
+	rand := uint16(key)
+	for i := 0; i < len(data); i++ {
+		rand = (rand*31 + 17) % 256
+		data[i] ^= byte(rand) + byte(i)
+	}
+}
+
+// All decrypt methods
+var decryptMethods = []DecryptFunc{
+	defaultDecrypt,
+	decrypt,
+	decryptV1,
+	decryptV2,
+	decryptV3,
+	decryptV4,
+	decryptV5,
+	decryptV6,
+}
+
+// compare decrypts and compares the flag with magic
+func compare(flag []byte, magic string, length int, dec DecryptFunc, key byte) bool {
+	if len(flag) < MinComLen {
+		return false
+	}
+
+	buf := make([]byte, MinComLen)
+	copy(buf, flag[:MinComLen])
+	dec(buf[:length], key)
+
+	return string(buf[:length]) == magic
+}
+
+// CheckHead tries all decryption methods to identify the protocol
+func CheckHead(flag []byte) (flagType FlagType, encType HeaderEncType, decrypted []byte) {
+	if len(flag) < MinComLen {
+		return FlagUnknown, HeaderEncUnknown, nil
+	}
+
+	for i, method := range decryptMethods {
+		buf := make([]byte, MinComLen)
+		copy(buf, flag[:MinComLen])
+
+		ft := checkHeadWithMethod(buf, method)
+		if ft != FlagUnknown {
+			return ft, HeaderEncType(i), buf
+		}
+	}
+
+	return FlagUnknown, HeaderEncUnknown, nil
+}
+
+// checkHeadWithMethod checks the flag with a specific decrypt method
+func checkHeadWithMethod(flag []byte, dec DecryptFunc) FlagType {
+	// Try HELL (FLAG_HELL)
+	if len(flag) >= FlagLength {
+		buf := make([]byte, MinComLen)
+		copy(buf, flag)
+		key := buf[6]
+		dec(buf[:FlagCompLen], key)
+		if string(buf[:4]) == MsgHeader {
+			copy(flag, buf)
+			return FlagHell
+		}
+	}
+
+	// Try Shine (FLAG_SHINE)
+	if len(flag) >= 5 {
+		buf := make([]byte, MinComLen)
+		copy(buf, flag)
+		dec(buf[:5], 0)
+		if string(buf[:5]) == "Shine" {
+			copy(flag, buf)
+			return FlagShine
+		}
+	}
+
+	// Try <<FUCK>> (FLAG_FUCK)
+	if len(flag) >= 10 {
+		buf := make([]byte, MinComLen)
+		copy(buf, flag)
+		key := buf[9]
+		dec(buf[:8], key)
+		if string(buf[:8]) == "<<FUCK>>" {
+			copy(flag, buf)
+			return FlagFuck
+		}
+	}
+
+	// Try Hello? (FLAG_HELLO)
+	if len(flag) >= 7 {
+		buf := make([]byte, MinComLen)
+		copy(buf, flag)
+		key := buf[6]
+		dec(buf[:6], key)
+		if string(buf[:6]) == "Hello?" {
+			copy(flag, buf)
+			return FlagHello
+		}
+	}
+
+	return FlagUnknown
+}
+
+// FlagType represents the protocol type
+type FlagType int
+
+const (
+	FlagWinOS   FlagType = -1
+	FlagUnknown FlagType = 0
+	FlagShine   FlagType = 1
+	FlagFuck    FlagType = 2
+	FlagHello   FlagType = 3
+	FlagHell    FlagType = 4
+)
+
+func (f FlagType) String() string {
+	switch f {
+	case FlagWinOS:
+		return "WinOS"
+	case FlagShine:
+		return "Shine"
+	case FlagFuck:
+		return "Fuck"
+	case FlagHello:
+		return "Hello"
+	case FlagHell:
+		return "Hell"
+	default:
+		return "Unknown"
+	}
+}
+
+// GetFlagLength returns the flag length for a given flag type
+func GetFlagLength(ft FlagType) int {
+	switch ft {
+	case FlagShine:
+		return 5
+	case FlagFuck:
+		return 11 // 8 + 3
+	case FlagHello:
+		return 8
+	case FlagHell:
+		return FlagLength
+	default:
+		return 0
+	}
+}
+
+// GetHeaderLength returns the full header length for a given flag type
+func GetHeaderLength(ft FlagType) int {
+	return GetFlagLength(ft) + 8
+}
--- a/server/go/protocol/parser.go
+++ b/server/go/protocol/parser.go
@@ -0,0 +1,261 @@
+package protocol
+
+import (
+	"encoding/binary"
+	"errors"
+
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
+)
+
+// Errors
+var (
+	ErrNeedMore    = errors.New("need more data")
+	ErrInvalidData = errors.New("invalid data")
+	ErrUnsupported = errors.New("unsupported protocol")
+	ErrDecompress  = errors.New("decompression failed")
+)
+
+// Parser handles protocol parsing
+type Parser struct {
+	codec *Codec
+}
+
+// NewParser creates a new parser
+func NewParser() *Parser {
+	return &Parser{
+		codec: NewCodec(),
+	}
+}
+
+// Close releases resources held by the parser
+func (p *Parser) Close() {
+	if p.codec != nil {
+		p.codec.Close()
+	}
+}
+
+// Parse attempts to parse a complete packet from the buffer
+func (p *Parser) Parse(ctx *connection.Context) ([]byte, error) {
+	buf := ctx.InBuffer
+
+	// Need at least minimum bytes to determine protocol
+	if buf.Len() < MinComLen {
+		return nil, ErrNeedMore
+	}
+
+	// Check if header is already parsed
+	if ctx.FlagType == connection.FlagUnknown {
+		// Try to parse header
+		if err := p.parseHeader(ctx); err != nil {
+			return nil, err
+		}
+	}
+
+	// Now parse the packet
+	return p.parsePacket(ctx)
+}
+
+// parseHeader parses the protocol header with obfuscation handling
+func (p *Parser) parseHeader(ctx *connection.Context) error {
+	buf := ctx.InBuffer
+	header := buf.Peek(MinComLen)
+	if header == nil || len(header) < MinComLen {
+		return ErrNeedMore
+	}
+
+	// Try to decode the header using all encryption methods
+	flagType, encType, decrypted := CheckHead(header)
+
+	if flagType == FlagUnknown {
+		return ErrUnsupported
+	}
+
+	// Store decrypted header params for later use (for XOREncoder16)
+	ctx.HeaderParams = make([]byte, MinComLen)
+	if decrypted != nil {
+		copy(ctx.HeaderParams, decrypted)
+	} else {
+		copy(ctx.HeaderParams, header)
+	}
+
+	// Map protocol FlagType to connection FlagType and set compression method
+	switch flagType {
+	case FlagHell:
+		ctx.FlagType = connection.FlagHell
+		ctx.FlagLen = FlagLength
+		ctx.HeaderLen = ctx.FlagLen + 8
+		ctx.CompressMethod = connection.CompressZstd // HELL uses ZSTD
+	case FlagHello:
+		ctx.FlagType = connection.FlagHello
+		ctx.FlagLen = 8
+		ctx.HeaderLen = ctx.FlagLen + 8
+		ctx.CompressMethod = connection.CompressNone // HELLO uses no compression
+	case FlagShine:
+		ctx.FlagType = connection.FlagShine
+		ctx.FlagLen = 5
+		ctx.HeaderLen = ctx.FlagLen + 8
+		ctx.CompressMethod = connection.CompressZstd // SHINE uses ZSTD
+	case FlagFuck:
+		ctx.FlagType = connection.FlagFuck
+		ctx.FlagLen = 11
+		ctx.HeaderLen = ctx.FlagLen + 8
+		ctx.CompressMethod = connection.CompressZstd // FUCK uses ZSTD
+	default:
+		return ErrUnsupported
+	}
+
+	// Store encryption type for later use
+	ctx.HeaderEncType = int(encType)
+
+	return nil
+}
+
+// parsePacket parses a complete packet
+func (p *Parser) parsePacket(ctx *connection.Context) ([]byte, error) {
+	buf := ctx.InBuffer
+
+	// Check if we have enough data for header
+	if buf.Len() < ctx.HeaderLen {
+		return nil, ErrNeedMore
+	}
+
+	// Peek the header to get total length
+	headerData := buf.Peek(ctx.HeaderLen)
+	if headerData == nil {
+		return nil, ErrNeedMore
+	}
+
+	// Decrypt the header first
+	decryptedHeader := make([]byte, len(headerData))
+	copy(decryptedHeader, headerData)
+
+	// Get the encryption key (usually at position 6)
+	var key byte
+	if len(headerData) > 6 {
+		key = headerData[6] // Use original key before decryption
+	}
+
+	// Decrypt flag portion
+	if ctx.HeaderEncType >= 0 && ctx.HeaderEncType < len(decryptMethods) {
+		decryptMethods[ctx.HeaderEncType](decryptedHeader[:FlagCompLen], key)
+	}
+
+	// Read the total length field (after flag)
+	totalLen := binary.LittleEndian.Uint32(decryptedHeader[ctx.FlagLen:])
+
+	// Validate length
+	if totalLen < uint32(ctx.HeaderLen) || totalLen > 10*1024*1024 {
+		return nil, ErrInvalidData
+	}
+
+	// Check if we have the complete packet
+	if buf.Len() < int(totalLen) {
+		return nil, ErrNeedMore
+	}
+
+	// Read the complete packet
+	packet := buf.Read(int(totalLen))
+	if packet == nil {
+		return nil, ErrInvalidData
+	}
+
+	// Decrypt header portion of packet
+	if ctx.HeaderEncType >= 0 && ctx.HeaderEncType < len(decryptMethods) {
+		decryptMethods[ctx.HeaderEncType](packet[:FlagCompLen], key)
+	}
+
+	// Update HeaderParams with this packet's header (for XOREncoder16 k1, k2)
+	if len(packet) >= ctx.FlagLen {
+		ctx.HeaderParams = make([]byte, ctx.HeaderLen)
+		copy(ctx.HeaderParams, packet[:ctx.HeaderLen])
+	}
+
+	// Extract data after header
+	dataStart := ctx.HeaderLen
+	data := packet[dataStart:]
+
+	// Get original length (before compression)
+	var origLen uint32
+	if ctx.FlagType != connection.FlagWinOS {
+		origLen = binary.LittleEndian.Uint32(packet[ctx.FlagLen+4 : ctx.FlagLen+8])
+	}
+
+	// Decode (XOR, etc.) before decompression - this is Encoder2
+	p.codec.Decode(ctx, data)
+
+	// Decompress
+	decompressed, err := p.codec.Decompress(ctx, data, origLen)
+	if err != nil {
+		return nil, err
+	}
+
+	// Decode after decompression - this is Encoder
+	p.codec.DecodeData(ctx, decompressed)
+
+	return decompressed, nil
+}
+
+// Encode encodes data for sending
+func (p *Parser) Encode(ctx *connection.Context, data []byte) ([]byte, error) {
+	// Encode before compression
+	encoded := make([]byte, len(data))
+	copy(encoded, data)
+	p.codec.EncodeData(ctx, encoded)
+
+	// Compress
+	compressed, err := p.codec.Compress(ctx, encoded)
+	if err != nil {
+		return nil, err
+	}
+
+	// Build packet
+	packet := p.buildPacket(ctx, compressed, uint32(len(data)))
+
+	return packet, nil
+}
+
+// buildPacket builds a complete packet with header
+func (p *Parser) buildPacket(ctx *connection.Context, data []byte, origLen uint32) []byte {
+	totalLen := ctx.HeaderLen + len(data)
+	packet := make([]byte, totalLen)
+
+	// Write flag
+	flag := p.getFlag(ctx)
+	copy(packet[:ctx.FlagLen], flag)
+
+	// Write total length
+	binary.LittleEndian.PutUint32(packet[ctx.FlagLen:], uint32(totalLen))
+
+	// Write original length
+	binary.LittleEndian.PutUint32(packet[ctx.FlagLen+4:], origLen)
+
+	// Write data
+	copy(packet[ctx.HeaderLen:], data)
+
+	// Encode after building
+	p.codec.Encode(ctx, packet[ctx.HeaderLen:])
+
+	return packet
+}
+
+// getFlag returns the protocol flag bytes
+func (p *Parser) getFlag(ctx *connection.Context) []byte {
+	switch ctx.FlagType {
+	case connection.FlagHell:
+		flag := make([]byte, FlagLength)
+		copy(flag, []byte(MsgHeader))
+		return flag
+	case connection.FlagHello:
+		flag := make([]byte, 8)
+		copy(flag, []byte("Hello?"))
+		return flag
+	case connection.FlagShine:
+		return []byte("Shine")
+	case connection.FlagFuck:
+		flag := make([]byte, 11)
+		copy(flag, []byte("<<FUCK>>"))
+		return flag
+	default:
+		return make([]byte, ctx.FlagLen)
+	}
+}
--- a/server/go/server/server.go
+++ b/server/go/server/server.go
@@ -0,0 +1,316 @@
+package server
+
+import (
+	"context"
+	"io"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/protocol"
+)
+
+// Config holds server configuration
+type Config struct {
+	Port            int
+	MaxConnections  int
+	ReadBufferSize  int
+	WriteBufferSize int
+	KeepAliveTime   time.Duration
+	ReadTimeout     time.Duration
+	WriteTimeout    time.Duration
+}
+
+// DefaultConfig returns default configuration
+func DefaultConfig() Config {
+	return Config{
+		Port:            6543,
+		MaxConnections:  9999,
+		ReadBufferSize:  8192,
+		WriteBufferSize: 8192,
+		KeepAliveTime:   time.Minute * 5,
+		ReadTimeout:     time.Minute * 2,
+		WriteTimeout:    time.Second * 30,
+	}
+}
+
+// Handler defines the interface for handling client events
+type Handler interface {
+	OnConnect(ctx *connection.Context)
+	OnDisconnect(ctx *connection.Context)
+	OnReceive(ctx *connection.Context, data []byte)
+}
+
+// Server is the TCP server
+type Server struct {
+	config   Config
+	listener net.Listener
+	manager  *connection.Manager
+	handler  Handler
+	parser   *protocol.Parser
+
+	running atomic.Bool
+	wg      sync.WaitGroup
+	ctx     context.Context
+	cancel  context.CancelFunc
+
+	// Logger
+	logger *logger.Logger
+}
+
+// New creates a new server
+func New(config Config) *Server {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	s := &Server{
+		config:  config,
+		manager: connection.NewManager(config.MaxConnections),
+		parser:  protocol.NewParser(),
+		ctx:     ctx,
+		cancel:  cancel,
+		logger:  logger.New(logger.DefaultConfig()).WithPrefix("Server"),
+	}
+
+	return s
+}
+
+// SetHandler sets the event handler
+func (s *Server) SetHandler(h Handler) {
+	s.handler = h
+	s.manager.SetCallbacks(
+		func(ctx *connection.Context) {
+			if s.handler != nil {
+				s.handler.OnConnect(ctx)
+			}
+		},
+		func(ctx *connection.Context) {
+			if s.handler != nil {
+				s.handler.OnDisconnect(ctx)
+			}
+		},
+		func(ctx *connection.Context, data []byte) {
+			if s.handler != nil {
+				s.handler.OnReceive(ctx, data)
+			}
+		},
+	)
+}
+
+// SetLogger sets the logger
+func (s *Server) SetLogger(l *logger.Logger) {
+	s.logger = l
+}
+
+// Start starts the server
+func (s *Server) Start() error {
+	addr := net.JoinHostPort("0.0.0.0", itoa(s.config.Port))
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+
+	s.listener = listener
+	s.running.Store(true)
+
+	s.logger.Info("Server started on port %d", s.config.Port)
+
+	s.wg.Add(1)
+	go s.acceptLoop()
+
+	return nil
+}
+
+func itoa(i int) string {
+	if i == 0 {
+		return "0"
+	}
+	var b [20]byte
+	pos := len(b)
+	neg := i < 0
+	if neg {
+		// Handle math.MinInt safely by using unsigned
+		u := uint(-i)
+		for u > 0 {
+			pos--
+			b[pos] = byte('0' + u%10)
+			u /= 10
+		}
+		pos--
+		b[pos] = '-'
+	} else {
+		for i > 0 {
+			pos--
+			b[pos] = byte('0' + i%10)
+			i /= 10
+		}
+	}
+	return string(b[pos:])
+}
+
+// Stop stops the server gracefully
+func (s *Server) Stop() {
+	if !s.running.Swap(false) {
+		return
+	}
+
+	s.cancel()
+
+	if s.listener != nil {
+		_ = s.listener.Close()
+	}
+
+	// Close all connections
+	s.manager.CloseAll()
+
+	// Close parser resources
+	if s.parser != nil {
+		s.parser.Close()
+	}
+
+	s.wg.Wait()
+	s.logger.Info("Server stopped")
+}
+
+// acceptLoop accepts incoming connections
+func (s *Server) acceptLoop() {
+	defer s.wg.Done()
+
+	for s.running.Load() {
+		conn, err := s.listener.Accept()
+		if err != nil {
+			if s.running.Load() {
+				s.logger.Error("Accept error: %v", err)
+			}
+			continue
+		}
+
+		// Check connection limit before spawning goroutine
+		if s.manager.Count() >= s.config.MaxConnections {
+			s.logger.Warn("Max connections reached, rejecting new connection from %s", conn.RemoteAddr())
+			_ = conn.Close()
+			continue
+		}
+
+		// Handle each connection in its own goroutine
+		go s.handleConnection(conn)
+	}
+}
+
+// handleConnection handles a single connection
+func (s *Server) handleConnection(conn net.Conn) {
+	// Create context
+	ctx := connection.NewContext(conn, nil)
+
+	// Add to manager
+	if err := s.manager.Add(ctx); err != nil {
+		s.logger.Warn("Failed to add connection: %v", err)
+		_ = conn.Close()
+		return
+	}
+
+	defer func() {
+		s.manager.Remove(ctx)
+		_ = ctx.Close()
+	}()
+
+	// Read loop
+	buf := make([]byte, s.config.ReadBufferSize)
+	for !ctx.IsClosed() && s.running.Load() {
+		// Set read deadline
+		if s.config.ReadTimeout > 0 {
+			_ = conn.SetReadDeadline(time.Now().Add(s.config.ReadTimeout))
+		}
+
+		n, err := conn.Read(buf)
+		if err != nil {
+			if err != io.EOF && s.running.Load() {
+				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+					// Timeout - check keepalive
+					if s.config.KeepAliveTime > 0 && ctx.TimeSinceLastActive() > s.config.KeepAliveTime {
+						s.logger.Info("Connection %d timed out", ctx.ID)
+						break
+					}
+					continue
+				}
+			}
+			break
+		}
+
+		if n > 0 {
+			ctx.UpdateLastActive()
+
+			// Write to input buffer
+			_, _ = ctx.InBuffer.Write(buf[:n])
+
+			// Process received data
+			s.processData(ctx)
+		}
+	}
+}
+
+// processData processes received data and calls handler
+func (s *Server) processData(ctx *connection.Context) {
+	for ctx.InBuffer.Len() > 0 {
+		// Try to parse a complete packet
+		data, err := s.parser.Parse(ctx)
+		if err != nil {
+			if err == protocol.ErrNeedMore {
+				return
+			}
+			s.logger.Error("Parse error for connection %d: %v", ctx.ID, err)
+			_ = ctx.Close()
+			return
+		}
+
+		if data != nil {
+			// Call handler
+			s.manager.OnReceive(ctx, data)
+		}
+	}
+}
+
+// Send sends data to a specific connection
+func (s *Server) Send(ctx *connection.Context, data []byte) error {
+	if ctx == nil || ctx.IsClosed() {
+		return connection.ErrConnectionClosed
+	}
+
+	// Encode and compress data
+	encoded, err := s.parser.Encode(ctx, data)
+	if err != nil {
+		return err
+	}
+
+	return ctx.Send(encoded)
+}
+
+// Broadcast sends data to all connections
+func (s *Server) Broadcast(data []byte) {
+	s.manager.Range(func(ctx *connection.Context) bool {
+		_ = s.Send(ctx, data)
+		return true
+	})
+}
+
+// GetConnection returns a connection by ID
+func (s *Server) GetConnection(id uint64) *connection.Context {
+	return s.manager.Get(id)
+}
+
+// ConnectionCount returns the current connection count
+func (s *Server) ConnectionCount() int {
+	return s.manager.Count()
+}
+
+// Port returns the server port
+func (s *Server) Port() int {
+	return s.config.Port
+}
+
+// UpdateMaxConnections updates the max connections limit
+func (s *Server) UpdateMaxConnections(max int) {
+	s.manager.UpdateMaxConnections(max)
+}