公开接口防盗:防止数据接口被滥用的6种实战方案

const crypto = require('crypto');

/**
 * 生成签名（和 Go 版本逻辑完全一致）
 * @param {Object} params - 参数对象
 * @param {string} secret - 密钥
 * @returns {string} sha256 签名字符串
 */
function generateSign(params, secret) {
    // 1. 获取参数 key 并排序
    const keys = Object.keys(params).sort();

    // 2. 拼接排序后的参数
    let str = '';
    for (const key of keys) {
        str += `${key}=${params[key]}&`;
    }

    // 3. 拼接密钥
    str += `key=${secret}`;

    // 4. sha256 加密
    return crypto.createHash('sha256').update(str).digest('hex');
}

/**
 * 验证签名
 * @param {Object} params - 参数对象
 * @param {string} sign - 待验证的签名
 * @param {string} secret - 密钥
 * @returns {boolean} 验证结果
 */
function verifySign(params, sign, secret) {
    const expectedSign = generateSign(params, secret);
    return sign === expectedSign;
}

// 导出给外部使用
module.exports = {
    generateSign,
    verifySign
};

const {
    generateSign,
    verifySign
} = require('./sign');

// 测试参数
const params = {
    username: 'test',
    age: '18',
    timestamp: '1712345678'
};
const secret = 'mySecretKey123';

// 生成签名
const sign = generateSign(params, secret);
console.log('生成签名:', sign);

// 验证签名
const isValid = verifySign(params, sign, secret);
console.log('验证结果:', isValid); // true

func handleRequest(w http.ResponseWriter， r *http.Request) {
    // 提取参数
    params := map[string]string{
        "userId": r.FormValue("userId")，
        "type":   r.FormValue("type")，
        "ts":     r.FormValue("ts")，
    }
    sign := r.FormValue("sign")

    // 验证时间戳(防重放攻击)
    ts， _ := strconv.ParseInt(params["ts"]， 10， 64)
    if time.Now().Unix()-ts > 300 { // 5分钟过期
        http.Error(w， "request expired"， http.StatusForbidden)
        return
    }

    // 验证签名
    if !verifySign(params， sign， "your-secret-key") {
        http.Error(w， "invalid signature"， http.StatusForbidden)
        return
    }

    // 处理业务逻辑
    // ...
}

import (
    "github.com/golang-jwt/jwt/v5"
    "time"
)

var jwtSecret = []byte("your-jwt-secret")

// 生成 Token
func generateToken(userId string) (string， error) {
    claims := jwt.MapClaims{
        "userId": userId，
        "exp":    time.Now().Add(time.Hour * 24).Unix()， // 24小时过期
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256， claims)
    return token.SignedString(jwtSecret)
}

// 验证 Token
func verifyToken(tokenString string) (*jwt.MapClaims， error) {
    token， err := jwt.Parse(tokenString， func(token *jwt.Token) (interface{}， error) {
        return jwtSecret， nil
    })
    if err != nil {
        return nil， err
    }

    if claims， ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return &claims， nil
    }
    return nil， fmt.Errorf("invalid token")
}

// 中间件:校验 Token
func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter， r *http.Request) {
        tokenString := r.Header.Get("Authorization")
        if tokenString == "" {
            http.Error(w， "missing token"， http.StatusUnauthorized)
            return
        }

        // 去掉 "Bearer " 前缀
        tokenString = strings.TrimPrefix(tokenString， "Bearer ")

        claims， err := verifyToken(tokenString)
        if err != nil {
            http.Error(w， "invalid token"， http.StatusUnauthorized)
            return
        }

        // 把用户信息存到上下文(可选)
        // ctx := context.WithValue(r.Context()， "userId"， (*claims)["userId"])
        // r = r.WithContext(ctx)

        next(w， r)
    }
}

import (
    "context"
    "github.com/redis/go-redis/v9"
    "time"
)

var rdb = redis.NewClient(&redis.Options{
    Addr: "localhost:6379"，
})

// IP 限流:每分钟最多 100 次
func rateLimitByIP(ip string) bool {
    ctx := context.Background()
    key := fmt.Sprintf("rate_limit:ip:%s"， ip)

    count， err := rdb.Incr(ctx， key).Result()
    if err != nil {
        return false
    }

    if count == 1 {
        rdb.Expire(ctx， key， time.Minute)
    }

    return count <= 100
}

// 限流中间件
func rateLimitMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter， r *http.Request) {
        ip := r.RemoteAddr
        if !rateLimitByIP(ip) {
            http.Error(w， "rate limit exceeded"， http.StatusTooManyRequests)
            return
        }
        next(w， r)
    }
}

// 服务端定期轮换密钥
var currentSecret = "secret-v1"
var secretVersion = 1

// 前端先请求当前密钥版本
func getSecretVersion(w http.ResponseWriter， r *http.Request) {
    w.Header().Set("Content-Type"， "application/json")
    fmt.Fprintf(w， `{"version": %d}`， secretVersion)
}

// 根据版本返回对应密钥(这个接口要做 Token 鉴权)
func getSecret(w http.ResponseWriter， r *http.Request) {
    version := r.URL.Query().Get("version")
    // 这里可以从数据库读取历史密钥，支持旧版本客户端
    w.Header().Set("Content-Type"， "application/json")
    fmt.Fprintf(w， `{"secret": "%s"}`， currentSecret)
}

func corsMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter， r *http.Request) {
        // 只允许你自己的域名
        w.Header().Set("Access-Control-Allow-Origin"， "https://yoursite.com")
        w.Header().Set("Access-Control-Allow-Methods"， "GET， POST")
        w.Header().Set("Access-Control-Allow-Headers"， "Content-Type， Authorization")

        // 处理预检请求
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }

        next(w， r)
    }
}