HMAC-Signed Expiring Tokens (Stateless)

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"strings"
	"time"
)

func sign(secret []byte, data string) string {
	m := hmac.New(sha256.New, secret)
	m.Write([]byte(data))
	return base64.RawURLEncoding.EncodeToString(m.Sum(nil))
}

func mintToken(secret []byte, subject string, ttl time.Duration) (string, error) {
	payload := map[string]any{
		"sub": subject,
		"exp": time.Now().Add(ttl).Unix(),
	}
	b, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}
	body := base64.RawURLEncoding.EncodeToString(b)
	sig := sign(secret, body)
	return body + "." + sig, nil
}

func verifyToken(secret []byte, token string) (string, error) {
	parts := strings.Split(token, ".")
	if len(parts) != 2 {
		return "", errors.New("invalid token format")
	}
	body, sig := parts[0], parts[1]
	want := sign(secret, body)
	if !hmac.Equal([]byte(sig), []byte(want)) {
		return "", errors.New("invalid signature")
	}
	raw, err := base64.RawURLEncoding.DecodeString(body)
	if err != nil {
		return "", err
	}

	var p map[string]any
	if err := json.Unmarshal(raw, &p); err != nil {
		return "", err
	}

	sub, _ := p["sub"].(string)
	expFloat, ok := p["exp"].(float64)
	if !ok {
		return "", errors.New("missing exp")
	}
	if time.Now().Unix() > int64(expFloat) {
		return "", errors.New("token expired")
	}
	if sub == "" {
		return "", errors.New("missing sub")
	}
	return sub, nil
}

func main() {
	secret := []byte("change-me-in-production")

	tok, err := mintToken(secret, "user-123", 2*time.Minute)
	if err != nil {
		log.Fatalf("mint: %v", err)
	}
	fmt.Println("token:", tok)

	sub, err := verifyToken(secret, tok)
	if err != nil {
		log.Fatalf("verify: %v", err)
	}
	fmt.Println("subject:", sub)
}