Broken Authentication in Go (Gin) Guide [Mar 2026] [CVE-2026-4583]

package main

import (
	"net/http"
	"time"
	"sync"
	"strings"
	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v4"
	"github.com/google/uuid"
)

var (
	jwtSecret = []byte("super-secret-key-change-me")
	// In-memory replay store; in production you should use a persistent store like Redis
	usedJTIs = make(map[string]bool)
	mu       sync.Mutex
)

func main() {
	r := gin.Default()

	// Vulnerable pattern: cookie-based session with insecure, replayable token
	r.POST("/login-vuln", loginVuln)
	r.GET("/me-vuln", meVuln)

	// Fixed pattern: JWT-based auth with replay protection
	r.POST("/login-fixed", loginFixed)
	r.GET("/me-fixed", meFixed)

	// Run on localhost:8080; ensure TLS in production
	r.Run(":8080")
}

// Vulnerable: sets a simple cookie that can be captured and replayed
func loginVuln(c *gin.Context) {
	type req struct{ Username string `json:"username"`; Password string `json:"password"` }
	var r req
	if err := c.ShouldBindJSON(&r); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
		return
	}
	// Insecure: a static, reusable token in a non-HttpOnly cookie
	expires := time.Now().Add(4 * time.Hour)
	cookie := &http.Cookie{
		Name:     "session_id",
		Value:    "vuln-token-abc",
		Path:     "/",
		Expires:  expires,
		HttpOnly: false, // not HttpOnly -> can be read by JS; not Secure -> sent over plaintext HTTP
		Secure:   false,
		SameSite: http.SameSiteLaxMode,
	}
	http.SetCookie(c.Writer, cookie)
	c.JSON(http.StatusOK, gin.H{"message": "logged in (vulnerable)"})
}

func meVuln(c *gin.Context) {
	cookie, err := c.Request.Cookie("session_id")
	if err != nil || cookie.Value != "vuln-token-abc" {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
		return
	}
	c.String(http.StatusOK, "Hello, vulnerable user!")
}

// Fixed: issues a short-lived JWT and requires Bearer token; includes replay protection via jti
func loginFixed(c *gin.Context) {
	type req struct{ Username string `json:"username"` }
	var r req
	if err := c.ShouldBindJSON(&r); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
		return
	}
	// Create a short-lived JWT with a unique jti (nonce)
	jti := uuid.New().String()
	claims := jwt.StandardClaims{
		Subject:   r.Username,
		ExpiresAt: time.Now().Add(15 * time.Minute).Unix(),
		IssuedAt:  time.Now().Unix(),
		Id:        jti,
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	tokenString, err := token.SignedString(jwtSecret)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "could not create token"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"token": tokenString})
}

func meFixed(c *gin.Context) {
	auth := c.GetHeader("Authorization")
	if len(auth) < 7 || !strings.HasPrefix(auth, "Bearer ") {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "missing or invalid token"})
		return
	}
	tokenString := strings.TrimPrefix(auth, "Bearer ")
	token, err := jwt.ParseWithClaims(tokenString, &jwt.StandardClaims{}, func(token *jwt.Token) (interface{}, error) {
		return jwtSecret, nil
	})
	if err != nil || !token.Valid {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid token"})
		return
	}
	claims, ok := token.Claims.(*jwt.StandardClaims)
	if !ok {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid claims"})
		return
	}
	if claims.ExpiresAt < time.Now().Unix() {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "token expired"})
		return
	}
	// Replay protection: ensure the same jti is not used twice
	mu.Lock()
	deemed := usedJTIs[claims.Id]
	if deemed {
		mu.Unlock()
		c.JSON(http.StatusUnauthorized, gin.H{"error": "token replay detected"})
		return
	}
	usedJTIs[claims.Id] = true
	mu.Unlock()
	c.String(http.StatusOK, "Hello, %s!", claims.Subject)
}