JWT токены для API: полное руководство

// create-jwt.js
const jwt = require('jsonwebtoken');

// Секретный ключ (в продакшене храните в переменных окружения)
const SECRET_KEY = 'your-secret-key';

// Создание JWT токена
function createToken(user) {
  const payload = {
    sub: user.id,
    name: user.name,
    email: user.email,
    role: user.role,
    iat: Math.floor(Date.now() / 1000), // Текущее время
    exp: Math.floor(Date.now() / 1000) + (60 * 60) // Истекает через 1 час
  };

  const token = jwt.sign(payload, SECRET_KEY, {
    algorithm: 'HS256',
    expiresIn: '1h'
  });

  return token;
}

// Пример использования
const user = {
  id: '1234567890',
  name: 'John Doe',
  email: 'john@example.com',
  role: 'user'
};

const token = createToken(user);
console.log('JWT Token:', token);

// Результат:
// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZW1haWwiOiJqb2huQGV4YW1wbGUuY29tIiwicm9sZSI6InVzZXIiLCJpYXQiOjE1MTYyMzkwMjIsImV4cCI6MTUxNjI0MjYyMn0.xxx

# create_jwt.py
import jwt
import datetime

SECRET_KEY = 'your-secret-key'

def create_token(user):
    payload = {
        'sub': user['id'],
        'name': user['name'],
        'email': user['email'],
        'role': user['role'],
        'iat': datetime.datetime.utcnow(),
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
    }
    
    token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
    return token

# Пример использования
user = {
    'id': '1234567890',
    'name': 'John Doe',
    'email': 'john@example.com',
    'role': 'user'
}

token = create_token(user)
print(f'JWT Token: {token}')

// create_jwt.php
<?php
require 'vendor/autoload.php';

use Firebase\JWT\JWT;
use Firebase\JWT\Key;

$secretKey = 'your-secret-key';

function createToken($user) {
    global $secretKey;
    
    $payload = [
        'sub' => $user['id'],
        'name' => $user['name'],
        'email' => $user['email'],
        'role' => $user['role'],
        'iat' => time(),
        'exp' => time() + (60 * 60) // 1 час
    ];
    
    $token = JWT::encode($payload, $secretKey, 'HS256');
    return $token;
}

// Пример использования
$user = [
    'id' => '1234567890',
    'name' => 'John Doe',
    'email' => 'john@example.com',
    'role' => 'user'
];

$token = createToken($user);
echo "JWT Token: " . $token;
?>

// validate-jwt.js
const jwt = require('jsonwebtoken');
const express = require('express');
const app = express();

const SECRET_KEY = 'your-secret-key';

// Middleware для проверки JWT
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

  if (!token) {
    return res.status(401).json({ error: 'Токен не предоставлен' });
  }

  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) {
      if (err.name === 'TokenExpiredError') {
        return res.status(401).json({ error: 'Токен истек' });
      }
      if (err.name === 'JsonWebTokenError') {
        return res.status(401).json({ error: 'Недействительный токен' });
      }
      return res.status(403).json({ error: 'Ошибка проверки токена' });
    }

    req.user = decoded; // Добавляем информацию о пользователе в запрос
    next();
  });
}

// Защищенный endpoint
app.get('/api/user', authenticateToken, (req, res) => {
  res.json({
    message: 'Доступ разрешен',
    user: req.user
  });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

# validate_jwt.py
from flask import Flask, request, jsonify
import jwt
from functools import wraps

app = Flask(__name__)
SECRET_KEY = 'your-secret-key'

def token_required(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        token = None
        
        if 'Authorization' in request.headers:
            auth_header = request.headers['Authorization']
            try:
                token = auth_header.split(' ')[1]  # Bearer TOKEN
            except IndexError:
                return jsonify({'error': 'Неверный формат токена'}), 401
        
        if not token:
            return jsonify({'error': 'Токен не предоставлен'}), 401
        
        try:
            decoded = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
            request.user = decoded
        except jwt.ExpiredSignatureError:
            return jsonify({'error': 'Токен истек'}), 401
        except jwt.InvalidTokenError:
            return jsonify({'error': 'Недействительный токен'}), 401
        
        return f(*args, **kwargs)
    
    return decorated

@app.route('/api/user', methods=['GET'])
@token_required
def get_user():
    return jsonify({
        'message': 'Доступ разрешен',
        'user': request.user
    })

if __name__ == '__main__':
    app.run(port=5000)

// refresh-tokens.js
const jwt = require('jsonwebtoken');
const crypto = require('crypto');

const ACCESS_TOKEN_SECRET = 'access-secret-key';
const REFRESH_TOKEN_SECRET = 'refresh-secret-key';

// Создание пары токенов
function createTokenPair(user) {
  // Access Token (короткоживущий)
  const accessToken = jwt.sign(
    {
      sub: user.id,
      name: user.name,
      role: user.role
    },
    ACCESS_TOKEN_SECRET,
    { expiresIn: '15m' }
  );

  // Refresh Token (долгоживущий)
  const refreshToken = jwt.sign(
    {
      sub: user.id,
      type: 'refresh'
    },
    REFRESH_TOKEN_SECRET,
    { expiresIn: '7d' }
  );

  return { accessToken, refreshToken };
}

// Обновление access token
function refreshAccessToken(refreshToken) {
  try {
    // Проверяем refresh token
    const decoded = jwt.verify(refreshToken, REFRESH_TOKEN_SECRET);
    
    // Проверяем, что токен не в черном списке (в реальном приложении)
    // if (await isTokenBlacklisted(refreshToken)) {
    //   throw new Error('Токен отозван');
    // }
    
    // Создаем новый access token
    const user = { id: decoded.sub };
    const newAccessToken = jwt.sign(
      {
        sub: user.id,
        name: user.name,
        role: user.role
      },
      ACCESS_TOKEN_SECRET,
      { expiresIn: '15m' }
    );
    
    return newAccessToken;
  } catch (error) {
    throw new Error('Недействительный refresh token');
  }
}

// Пример использования
app.post('/api/auth/refresh', async (req, res) => {
  const { refreshToken } = req.body;
  
  if (!refreshToken) {
    return res.status(401).json({ error: 'Refresh token не предоставлен' });
  }
  
  try {
    const newAccessToken = refreshAccessToken(refreshToken);
    res.json({ accessToken: newAccessToken });
  } catch (error) {
    res.status(401).json({ error: error.message });
  }
});

// jwt.go
package main

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

var secretKey = []byte("your-secret-key")

type Claims struct {
    UserID string `json:"sub"`
    Name   string `json:"name"`
    Role   string `json:"role"`
    jwt.RegisteredClaims
}

func CreateToken(userID, name, role string) (string, error) {
    claims := Claims{
        UserID: userID,
        Name:   name,
        Role:   role,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(1 * time.Hour)),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(secretKey)
}

func ValidateToken(tokenString string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
        return secretKey, nil
    })

    if err != nil {
        return nil, err
    }

    if claims, ok := token.Claims.(*Claims); ok && token.Valid {
        return claims, nil
    }

    return nil, fmt.Errorf("недействительный токен")
}

// JwtUtil.java
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import java.security.Key;
import java.util.Date;

public class JwtUtil {
    private static final String SECRET_KEY = "your-secret-key-which-must-be-at-least-256-bits";
    private static final Key key = Keys.hmacShaKeyFor(SECRET_KEY.getBytes());
    
    public static String createToken(String userId, String name, String role) {
        return Jwts.builder()
            .setSubject(userId)
            .claim("name", name)
            .claim("role", role)
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1 час
            .signWith(key, SignatureAlgorithm.HS256)
            .compact();
    }
    
    public static Claims validateToken(String token) {
        return Jwts.parserBuilder()
            .setSigningKey(key)
            .build()
            .parseClaimsJws(token)
            .getBody();
    }
}

// Безопасная валидация JWT
const jwt = require('jsonwebtoken');

function validateToken(token) {
  // ВАЖНО: Всегда явно указывайте алгоритм
  const decoded = jwt.verify(token, SECRET_KEY, {
    algorithms: ['HS256'] // Явно указываем алгоритм
  });
  
  // Проверяем все необходимые claims
  if (!decoded.exp || decoded.exp < Math.floor(Date.now() / 1000)) {
    throw new Error('Токен истек');
  }
  
  if (!decoded.sub) {
    throw new Error('Отсутствует subject');
  }
  
  return decoded;
}

// НЕПРАВИЛЬНО - уязвимо к algorithm confusion
function unsafeValidateToken(token) {
  // Не указывает алгоритм - уязвимо!
  return jwt.verify(token, SECRET_KEY);
}