Go กับ WebSocket Security - เพิ่มความปลอดภัยให้ระบบของคุณ!

ใน EP นี้ เราจะมาดูวิธีเพิ่มความปลอดภัยให้ WebSocket Cluster ของคุณ ด้วยการใช้ การเข้ารหัส (Encryption) และ การจัดการสิทธิ์ (Authorization) เพื่อป้องกันการโจมตีและรักษาความเป็นส่วนตัวของข้อมูลครับ

ทำไม WebSocket Cluster ต้องมีความปลอดภัย?

1. ป้องกันการดักจับข้อมูล (Eavesdropping) : ข้อมูลที่ส่งผ่าน WebSocket ต้องปลอดภัยจากผู้ไม่หวังดี

2. จำกัดการเข้าถึง (Access Control) : ให้เฉพาะผู้ที่ได้รับอนุญาตเท่านั้นที่สามารถใช้งาน WebSocket ได้

3. ป้องกันการโจมตี DDOS : ลดความเสี่ยงจากการโจมตีที่มุ่งเน้นไปยัง WebSocket Cluster

การเพิ่มความปลอดภัยให้ WebSocket Cluster

1. ใช้ WSS (WebSocket Secure)

WSS คือ WebSocket ที่ทำงานผ่าน TLS (Transport Layer Security) ซึ่งช่วยเข้ารหัสข้อมูลที่ส่งผ่านเครือข่าย

การตั้งค่า NGINX สำหรับ WSS :

server {
    listen 443 ssl;
    server_name yourdomain.com;

    ssl_certificate /path/to/your/certificate.pem;
    ssl_certificate_key /path/to/your/key.pem;

    location /ws/ {
        proxy_pass http://localhost:8080; # ชี้ไปยัง WebSocket Server
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
    }
}

2. เพิ่ม Authentication Token

ก่อนการเชื่อมต่อ WebSocket ให้ตรวจสอบ Token เพื่อยืนยันตัวตนผู้ใช้

ตัวอย่างการตรวจสอบ Token ใน Go :

ในตัวอย่างนี้ :

Middleware authMiddleware ตรวจสอบ Token ก่อนอนุญาตการเชื่อมต่อ

func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        token := r.URL.Query().Get("token")
        if token != "valid-token" { // ตัวอย่างตรวจสอบ Token แบบง่าย
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next(w, r)
    }
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Error upgrading connection:", err)
        return
    }
    defer conn.Close()

    log.Println("Client connected with valid token")
    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            log.Println("Error reading message:", err)
            break
        }
        log.Printf("Received: %s", msg)
    }
}

func main() {
    http.HandleFunc("/ws", authMiddleware(handleConnections))
    log.Println("WebSocket server with token authentication started at :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

3. ใช้ Role-Based Access Control (RBAC)

กำหนดสิทธิ์ผู้ใช้แต่ละประเภท เช่น Admin และ Member เพื่อให้สามารถจำกัดการกระทำได้

ตัวอย่างการใช้ RBAC :

ในตัวอย่างนี้ :

หากผู้ใช้ไม่ได้เป็น Admin จะไม่สามารถดำเนินการบางอย่างได้

func handleConnections(w http.ResponseWriter, r *http.Request) {
    token := r.URL.Query().Get("token")
    role := "member" // สมมติว่าได้ Role จาก Token

    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Error upgrading connection:", err)
        return
    }
    defer conn.Close()

    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            log.Println("Error reading message:", err)
            break
        }

        if string(msg) == "admin-action" && role != "admin" {
            conn.WriteMessage(websocket.TextMessage, []byte("Unauthorized action"))
            continue
        }

        log.Printf("Message from %s: %s", role, msg)
    }
}

4. ป้องกันการโจมตี DDOS ด้วย Rate Limiting

Rate Limiting ช่วยจำกัดจำนวนคำขอที่ผู้ใช้แต่ละคนสามารถส่งได้ในช่วงเวลาที่กำหนด

ตัวอย่างการใช้งาน Rate Limiting :

var rateLimiter = make(map[string]int)

func rateLimitMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        rateLimiter[ip]++

        if rateLimiter[ip] > 10 { // อนุญาต 10 คำขอต่อ 1 นาที
            http.Error(w, "Too many requests", http.StatusTooManyRequests)
            return
        }

        next(w, r)
    }
}

การปรับปรุงเพิ่มเติม

ใช้ JWT (JSON Web Token) : สำหรับการตรวจสอบสิทธิ์แบบปลอดภัย
เข้ารหัสข้อมูลที่สำคัญ : ใช้ AES หรือ RSA สำหรับข้อมูลที่ต้องการความปลอดภัยสูง
Monitor การใช้งาน : ใช้ Prometheus และ Grafana เพื่อตรวจสอบปริมาณการใช้งาน

สรุปง่ายๆ

ใช้ WSS (WebSocket Secure) เพื่อเข้ารหัสการเชื่อมต่อ
ตรวจสอบสิทธิ์ผู้ใช้ด้วย Token หรือ JWT
เพิ่ม Role-Based Access Control (RBAC) เพื่อจัดการสิทธิ์
ป้องกัน DDOS ด้วย Rate Limiting