// Tạo một khóa bí mật an toàn
node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"

# .env file
JWT_SECRET=khóa_bí_mật_64_ký_tự_của_bạn
JWT_EXPIRES_IN=24h
JWT_ALGORITHM=HS256

// authService.js (phương pháp Khóa Bí mật)
import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET;
const JWT_ALGORITHM = 'HS256';

class AuthService {
  // Tạo token
  generateToken(user) {
    return jwt.sign(
      { 
        sub: user.id,
        username: user.username,
        iat: Math.floor(Date.now() / 1000)
      },
      JWT_SECRET,
      { 
        expiresIn: process.env.JWT_EXPIRES_IN || '24h',
        algorithm: JWT_ALGORITHM 
      }
    );
  }

  // Xác thực token
  verifyToken(token) {
    return jwt.verify(token, JWT_SECRET, { algorithms: [JWT_ALGORITHM] });
  }
}

// Ví dụ: Tạo một token JWT (phía máy chủ)
const authService = new AuthService();

const user = {
  id: "user123",
  username: "john_doe"
};

const token = authService.generateToken(user);
console.log("Token đã tạo:", token);

# Sử dụng curl
curl -X POST http://localhost:8000/translate \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"text": "Xin chào thế giới"}'

# Sử dụng trình tạo khóa đã cung cấp
npm run generate-keys

# Hoặc thủ công với OpenSSL
openssl genrsa -out jwt-private.key 2048
openssl rsa -in jwt-private.key -pubout -out jwt-public.key

# .env file
JWT_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
-----END PUBLIC KEY-----"
JWT_ALGORITHM=RS256

// authService.js (phương pháp Khóa Công khai)
import jwt from 'jsonwebtoken';

const JWT_PUBLIC_KEY = process.env.JWT_PUBLIC_KEY;
const JWT_ALGORITHM = process.env.JWT_ALGORITHM || 'RS256';

class AuthService {
  constructor() {
    this.jwtPublicKey = this.loadPublicKey();
  }

  loadPublicKey() {
    if (process.env.JWT_PUBLIC_KEY) {
      return process.env.JWT_PUBLIC_KEY.replace(/\\n/g, '\n');
    }
    console.warn('⚠️ Cảnh báo: Không tìm thấy khóa công khai JWT!');
    return null;
  }

  // Chỉ xác thực token (không tạo trên máy chủ)
  verifyToken(token) {
    return new Promise((resolve, reject) => {
      jwt.verify(token, this.jwtPublicKey, { algorithms: [this.jwtAlgorithm] }, (err, decoded) => {
        if (err) reject(err);
        else resolve(decoded);
      });
    });
  }
}

// external-token-generator.js
import jwt from 'jsonwebtoken';
import fs from 'fs';

const privateKey = fs.readFileSync('./jwt-private.key', 'utf8');

function generateToken(user) {
  const payload = {
    sub: user.id,
    username: user.username,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + (24 * 60 * 60) // 24 giờ
  };

  return jwt.sign(payload, privateKey, { algorithm: 'RS256' });
}

// Ví dụ sử dụng
const user = { id: "user123", username: "john_doe" };
const token = generateToken(user);
console.log("Token đã tạo:", token);

# external_token_generator.py
import jwt
import time
from cryptography.hazmat.primitives import serialization

# Tải khóa riêng
with open('./jwt-private.key', 'rb') as f:
    private_key = serialization.load_pem_private_key(
        f.read(),
        password=None
    )

def generate_token(user_id, username):
    payload = {
        'sub': user_id,
        'username': username,
        'iat': int(time.time()),
        'exp': int(time.time()) + (24 * 60 * 60)  # 24 giờ
    }

    return jwt.encode(payload, private_key, algorithm='RS256')

# Ví dụ sử dụng
token = generate_token("user123", "john_doe")
print(f"Token đã tạo: {token}")

# Kiểm tra trạng thái xác thực
curl http://localhost:8000/auth/status

# Xác thực token của bạn
curl -X GET http://localhost:8000/auth/verify \
  -H "Authorization: Bearer <token>"

# Thực hiện yêu cầu dịch thuật
curl -X POST http://localhost:8000/translate \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"text": "Xin chào thế giới"}'

# Chạy bộ kiểm tra với token của bạn
JWT_TOKEN="token_của_bạn" npm run test-auth

# Kiểm tra client
JWT_TOKEN="token_của_bạn" node jwt-client.js

# Thêm vào .gitignore
echo "jwt-private.key" >> .gitignore
echo ".env" >> .gitignore

# Đặt quyền tệp phù hợp
chmod 600 jwt-private.key  # Khóa riêng - chỉ chủ sở hữu đọc/ghi
chmod 644 jwt-public.key   # Khóa công khai - có thể đọc bởi người khác

{
  "sub": "định_danh_người_dùng_unqiue",
  "username": "tên_dễ_đọc", 
  "iat": 1642000000,
  "exp": 1642086400,
  "roles": ["user", "translator"],
  "permissions": ["read", "translate"]
}

// Kiểm tra thời gian hết hạn token trước khi thực hiện yêu cầu
function isTokenExpired(token) {
  try {
    const decoded = jwt.decode(token);
    return decoded.exp < Date.now() / 1000;
  } catch (error) {
    return true;
  }
}

// Logic tự động làm mới
if (isTokenExpired(currentToken)) {
  currentToken = await generateNewToken();
}

# Giải pháp: Đặt khóa công khai trong môi trường
export JWT_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----..."

# Kiểm tra sự không tương thích thuật toán
# Đảm bảo token của bạn được ký bằng RS256 cho phương pháp khóa công khai/khóa riêng
# Đảm bảo token của bạn được ký bằng HS256 cho phương pháp khóa bí mật

// Kiểm tra thời gian hết hạn token
const decoded = jwt.decode(token);
console.log('Token hết hạn vào lúc:', new Date(decoded.exp * 1000));

# Đảm bảo bạn đang sử dụng khóa riêng đúng cho việc ký
# Xác nhận khóa công khai khớp với khóa riêng đã sử dụng để ký
openssl rsa -in jwt-private.key -pubout | diff - jwt-public.key

# Bật ghi log gỡ lỗi
DEBUG=jwt* npm start

# Kiểm tra chi tiết token mà không cần xác thực
node -e "console.log(JSON.stringify(require('jsonwebtoken').decode('token_của_bạn'), null, 2))"

# Kiểm tra sức khỏe (không yêu cầu xác thực)
curl http://localhost:8000/health

# Trạng thái xác thực
curl http://localhost:8000/auth/status

# Xác thực token
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8000/auth/verify