JWT, autenticación y autorización

// dependencia: io.jsonwebtoken:jjwt (api, impl, jackson) 0.12.x
@Service
public class JwtService {

    // inyectada desde variable de entorno JWT_SECRET (¡nunca en el código!)
    @Value("${jwt.secret}")
    private String secreto;

    private SecretKey clave() {
        return Keys.hmacShaKeyFor(secreto.getBytes(StandardCharsets.UTF_8));
    }

    public String generarAccessToken(Usuario usuario) {
        return Jwts.builder()
            .subject(String.valueOf(usuario.getId()))
            .claim("rol", usuario.getRol().name())      // ADMIN, MESERO, …
            .claim("nombre", usuario.getNombre())
            .issuedAt(new Date())
            .expiration(Date.from(Instant.now().plus(30, ChronoUnit.MINUTES)))
            .signWith(clave())
            .compact();
    }

    /** Devuelve los claims si el token es válido; lanza JwtException si no. */
    public Claims validar(String token) {
        return Jwts.parser()
            .verifyWith(clave())
            .build()
            .parseSignedClaims(token)   // verifica firma Y expiración
            .getPayload();
    }
}

@Component
public class JwtFilter extends OncePerRequestFilter {

    private final JwtService jwtService;
    public JwtFilter(JwtService jwtService) { this.jwtService = jwtService; }

    @Override
    protected void doFilterInternal(HttpServletRequest req,
                                    HttpServletResponse res,
                                    FilterChain chain)
            throws ServletException, IOException {

        String header = req.getHeader("Authorization");
        if (header != null && header.startsWith("Bearer ")) {
            try {
                Claims claims = jwtService.validar(header.substring(7));
                // "presentamos" al usuario ante Spring Security:
                var auth = new UsernamePasswordAuthenticationToken(
                    claims.getSubject(),          // principal = id del usuario
                    null,
                    List.of(new SimpleGrantedAuthority(
                        "ROLE_" + claims.get("rol", String.class))));
                SecurityContextHolder.getContext().setAuthentication(auth);
            } catch (JwtException e) {
                // token inválido o expirado: no autenticamos y la
                // configuración de abajo responderá 401 en rutas protegidas
            }
        }
        chain.doFilter(req, res);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    SecurityFilterChain filtros(HttpSecurity http, JwtFilter jwtFilter)
            throws Exception {
        return http
            .csrf(csrf -> csrf.disable())        // API sin cookies: CSRF no aplica
            .sessionManagement(s ->
                s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers(HttpMethod.POST, "/api/pedidos")
                    .hasAnyRole("MESERO", "ADMIN")
                .requestMatchers("/api/platillos/**").hasRole("ADMIN")
                .requestMatchers("/api/pedidos/*/estado")
                    .hasAnyRole("COCINA", "MESERO", "REPARTIDOR", "ADMIN")
                .anyRequest().authenticated())
            .addFilterBefore(jwtFilter,
                UsernamePasswordAuthenticationFilter.class)
            .build();
    }

    @Bean
    PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); }
}

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    private final UsuarioRepository usuarios;
    private final PasswordEncoder encoder;
    private final JwtService jwt;
    // constructor con los tres…

    public record LoginDTO(@NotBlank String usuario, @NotBlank String password) {}
    public record TokensDTO(String accessToken, String refreshToken) {}

    @PostMapping("/login")
    public TokensDTO login(@Valid @RequestBody LoginDTO dto) {
        Usuario u = usuarios.findByUsuario(dto.usuario())
            .orElseThrow(() -> new CredencialesInvalidasException());

        // comparamos contra el hash BCrypt guardado, jamás texto plano
        if (!encoder.matches(dto.password(), u.getPasswordHash())) {
            throw new CredencialesInvalidasException();   // → 401
        }
        return new TokensDTO(
            jwt.generarAccessToken(u),
            refreshTokenService.emitirYGuardar(u));   // este sí va a la BD
    }
}

// go get github.com/golang-jwt/jwt/v5  github.com/gin-gonic/gin
package auth

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

var secreto = []byte(os.Getenv("JWT_SECRET")) // ¡nunca en el código!

type Claims struct {
    Rol    string `json:"rol"`
    Nombre string `json:"nombre"`
    jwt.RegisteredClaims
}

func GenerarAccessToken(usuarioID int64, rol, nombre string) (string, error) {
    claims := Claims{
        Rol:    rol,
        Nombre: nombre,
        RegisteredClaims: jwt.RegisteredClaims{
            Subject:   fmt.Sprintf("%d", usuarioID),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(30 * time.Minute)),
        },
    }
    return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secreto)
}

// Validar verifica firma y expiración; devuelve los claims si todo está bien.
func Validar(tokenStr string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenStr, &Claims{},
        func(t *jwt.Token) (any, error) { return secreto, nil })
    if err != nil || !token.Valid {
        return nil, fmt.Errorf("token inválido: %w", err)
    }
    return token.Claims.(*Claims), nil
}

// AuthRequired valida el token y guarda los claims en el contexto.
func AuthRequired() gin.HandlerFunc {
    return func(c *gin.Context) {
        header := c.GetHeader("Authorization")
        if !strings.HasPrefix(header, "Bearer ") {
            c.AbortWithStatusJSON(401, gin.H{"error": "falta el token"})
            return
        }
        claims, err := Validar(strings.TrimPrefix(header, "Bearer "))
        if err != nil {
            c.AbortWithStatusJSON(401, gin.H{"error": "token inválido o expirado"})
            return
        }
        c.Set("usuarioID", claims.Subject)  // disponible para los handlers
        c.Set("rol", claims.Rol)
        c.Next()
    }
}

// RequiereRol se apila después de AuthRequired en rutas restringidas.
func RequiereRol(roles ...string) gin.HandlerFunc {
    return func(c *gin.Context) {
        rol := c.GetString("rol")
        if !slices.Contains(roles, rol) {
            c.AbortWithStatusJSON(403, gin.H{"error": "rol sin permiso"})
            return
        }
        c.Next()
    }
}

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

    // rutas públicas
    r.POST("/api/auth/login", auth.Login)
    r.POST("/api/auth/refresh", auth.Refresh)

    // rutas protegidas: el middleware corre antes que cada handler
    api := r.Group("/api", auth.AuthRequired())
    {
        api.POST("/pedidos",
            auth.RequiereRol("MESERO", "ADMIN"), pedidos.Crear)
        api.PATCH("/pedidos/:id/estado",
            auth.RequiereRol("COCINA", "MESERO", "REPARTIDOR", "ADMIN"),
            pedidos.CambiarEstado)
        api.Any("/platillos", auth.RequiereRol("ADMIN"), platillos.Handler)
    }
    r.Run(":8080")
}

// go get golang.org/x/crypto/bcrypt
type LoginDTO struct {
    Usuario  string `json:"usuario" binding:"required"`
    Password string `json:"password" binding:"required"`
}

func Login(c *gin.Context) {
    var dto LoginDTO
    if err := c.ShouldBindJSON(&dto); err != nil {
        c.JSON(400, gin.H{"error": "usuario y password son requeridos"})
        return
    }
    u, err := repositorio.BuscarPorUsuario(dto.Usuario)
    // comparamos contra el hash BCrypt guardado, jamás texto plano.
    // Nota: mismo mensaje si el usuario no existe o la contraseña falla,
    // para no revelar cuáles usuarios existen.
    if err != nil || bcrypt.CompareHashAndPassword(
        []byte(u.PasswordHash), []byte(dto.Password)) != nil {
        c.JSON(401, gin.H{"error": "credenciales inválidas"})
        return
    }
    access, _ := GenerarAccessToken(u.ID, u.Rol, u.Nombre)
    refresh, _ := EmitirYGuardarRefresh(u.ID)  // este sí va a la BD
    c.JSON(200, gin.H{"accessToken": access, "refreshToken": refresh})
}