【Node.js実戦習得】第17回:ステートレスな認証の主役!JWT(JSON Web Token)によるセキュアな認可システム

社員ブログ

1. セッション認証 vs JWT 認証!なぜモダン API では JWT が好まれるのか?

酒本先輩!

第16回ではサーバー側で状態を保持する『セッション認証』を学びました。

でも、世の中のモダンな Web API や SPA(Single Page Application)、スマホアプリだと JWT(JSON Web Token)を使った認証をよく見かけます。

セッション認証と何が違うんですか?

いい観察力ね!

決定的な違いは 『サーバー側に状態を保持するか(ステートフル)、しないか(ステートレス)』 よ。

 

第16回のセッション認証は、サーバーのメモリや Redis にセッション ID とユーザー情報の紐付けを保存していたわね。これは『ステートフル(状態保持)』な方式よ。

 

一方の JWT は、トークン自体の中にユーザー情報や有効期限が入っていて、それが秘密鍵で署名されているの。

サーバーは DB やメモリを参照しなくても、届いたトークンの署名(Signature)を検証するだけで『このトークンは本物だ』と判断できるの。

これが『ステートレス(状態非保持)』な認証よ!

【セッション認証(ステートフル)】
クライアント - [ sid=xxx ] -> サーバー - [ DB/Redis等で sid 検索 ] -> ユーザー判定

【JWT 認証(ステートレス)】
クライアント - [ Bearer eyJhbG... ] -> サーバー - [ 秘密鍵で署名検証のみ ] -> ユーザー判定(DB照会不要!1)

比較まとめ

  • 状態の保持
    • セッション認証:ステートフル(DB / メモリ / Redis 等に保存)
    • JWT 認証:ステートレス(サーバー側での保存不要)
  • 拡張性(Scalability)
    • セッション認証:サーバー複数台構成時に Redis 等の共有セッションストアが必須
    • JWT 認証:どのサーバーでも同じ秘密鍵さえ持っていれば検証可能(水平拡張が容易)
  • トークンの無効化
    • セッション認証:サーバー側のセッション削除で即座に無効化可能
    • JWT 認証:有効期限内は単体での即時無効化が困難(ブラックリスト等が必要)
  • 主な用途
    • セッション認証:従来の SSR(Server Side Rendering)Web アプリ
    • JWT 認証:SPA、モバイルアプリ、マイクロサービス間連携

じゃあ、第16回で作ったセッションの仕組みはどうなるんですか?

今回から認証方式を JWT に切り替えるわ。

セッションと JWT を同時に動かすと、どちらで認証しているのか分からなくなるから、第16回の express-session 関連(パッケージ・src/config/session.ts・src/types/express-session.d.ts・SESSION_SECRET)は片付けるわよ。

ユーザー登録、パスワードのハッシュ化、Repository / Service の構成はそのまま使えるわ。」

2. JWT の構造解剖(Header / Payload / Signature)と改ざん検知

JWT の実体は、ドット(.)で区切られた 3 つの Base64URL エンコード文字列よ。

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 . eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ . SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
└───────┬────────┘   └─────────────────┬─────────────────┘   └─────────┬──────────┘
            ① Header                                                  ② Payload                                                  ③ Signature
  • Header(ヘッダー): アルゴリズム(例: HS256)やトークンのタイプを指定。
  • Payload(ペイロード): ユーザー ID、ロール、発行日時(iat)、有効期限(exp)などのデータ(クレーム)を格納。※Base64 でデコードできるため、パスワードなどの機密情報は絶対に入れてはいけない!
  • Signature(署名): Header + Payload + 秘密鍵(Secret Key)を使って生成されたハッシュ値。トークンのデータが 1 文字でも改ざんされると、署名の検証が失敗する仕組み。

3. セキュリティ設計:Access Token と Refresh Token の役割分離

先輩、ステートレスってことは、もし JWT が悪意のある第三者に盗まれたら、有効期限が切れるまで不正利用され放題になっちゃいませんか…?

素晴らしい指摘!

まさにそこが JWT 最大の弱点なの。

そのリスクを最小化するために実務で使われるのが 『Access Token / Refresh Token の 2 トークン体制』 よ!

【Access Token と Refresh Token の使い分け】
・Access Token:
 有効期限が超短期間(例: 15分)。
 API へのリクエスト毎に送信。
 (フロントエンドのメモリ上に保持。localStorage には置かない)
・Refresh Token:
 有効期限が長期間(例: 7日〜14日)。
 Access Token が切れた際の再発行専用。
 (HttpOnly Cookie で保管し、JavaScript からは読めないようにする)
【トークン再発行フロー】
1. クライアント - [ Access Token (期限切れ) ] -> サーバー -> 401 Unauthorized
2. クライアント - [ Refresh Token (Cookie) ] -> サーバー -> 新しい Access Token を発行

Refresh Token は盗まれても大丈夫なんですか?

Cookie に HttpOnly を付ければ JavaScript から読めないから、XSS で盗まれにくくなるわ。

さらに Cookie の送信先を /api/auth だけに絞れば、カート API などには送られなくなるの。

 

ただし、今回作るのは学習用のシンプルな実装よ。
実務では Refresh Token をハッシュ化して DB に保存し、使うたびに新しいものへ入れ替える(ローテーション)ことで、盗まれたトークンを無効化できるようにするわ。

 

4. 実践コード:JWT 発行・検証ユーティリティと認可(Authorization)ミドルウェア

まずは第16回のセッション関連を片付けて、JWT の操作に必要なパッケージをインストールしましょう!

1. セッションの片付けとパッケージのインストール

# 第16回のセッション関連を削除
npm uninstall express-session @types/express-session
rm src/config/session.ts src/types/express-session.d.ts

# JWT と、Refresh Token Cookie を読むための cookie-parser をインストール
npm install jsonwebtoken cookie-parser
npm install -D @types/jsonwebtoken @types/cookie-parser
# .env
JWT_SECRET="32文字以上のランダムな文字列(例: openssl rand -hex 32 の出力)"
JWT_REFRESH_SECRET="別の32文字以上のランダムな文字列"

2. JWT 設定と ユーティリティの実装

シークレットが未設定のまま、推測しやすい既定値で動き続けることがないよう、process.env を読み、未設定なら起動時にエラーにします。
(第20回で、これを Zod による起動時検証に置き換えます。)

// src/config/jwt.config.ts

// 環境変数は呼び出し時に読む(import 順序に依存せず .env の読み込み後に評価されるようにする)
const requireEnv = (name: string): string => {
  const value = process.env[name];
  if (!value) {
    throw new Error(`${name} が .env に設定されていません。`);
  }
  return value;
};

export const jwtConfig = {
  accessSecret: () => requireEnv('JWT_SECRET'),
  refreshSecret: () => requireEnv('JWT_REFRESH_SECRET'),
  accessExpiresIn: '15m', // Access Token: 15分
  refreshExpiresIn: '7d', // Refresh Token: 7日
  refreshMaxAgeMs: 7 * 24 * 60 * 60 * 1000, // Refresh Token Cookie の有効期限(ミリ秒)
} as const;
// src/utils/jwt.util.ts
import jwt from 'jsonwebtoken';
import { jwtConfig } from '../config/jwt.config.js';

// Access Token に載せる情報(機密情報は絶対に入れない)
export interface AccessTokenPayload {
  userId: number;
  email: string;
}

// Refresh Token に載せる情報(再発行に必要な最小限)
export interface RefreshTokenPayload {
  userId: number;
}

// 署名アルゴリズムを固定して、alg 差し替え攻撃を防ぐ
const ALGORITHM = 'HS256';

export const generateAccessToken = (payload: AccessTokenPayload): string => {
  return jwt.sign(payload, jwtConfig.accessSecret(), {
    algorithm: ALGORITHM,
    expiresIn: jwtConfig.accessExpiresIn,
  });
};

export const generateRefreshToken = (payload: RefreshTokenPayload): string => {
  return jwt.sign(payload, jwtConfig.refreshSecret(), {
    algorithm: ALGORITHM,
    expiresIn: jwtConfig.refreshExpiresIn,
  });
};

/**
 * Access Token の検証・デコード(署名不正・期限切れ・形式不正は例外を投げる)
 */
export const verifyAccessToken = (token: string): AccessTokenPayload => {
  const decoded = jwt.verify(token, jwtConfig.accessSecret(), { algorithms: [ALGORITHM] });
  if (typeof decoded === 'string' || typeof decoded.userId !== 'number' || typeof decoded.email !== 'string') {
    throw new Error('Invalid token payload');
  }
  return { userId: decoded.userId, email: decoded.email };
};

export const verifyRefreshToken = (token: string): RefreshTokenPayload => {
  const decoded = jwt.verify(token, jwtConfig.refreshSecret(), { algorithms: [ALGORITHM] });
  if (typeof decoded === 'string' || typeof decoded.userId !== 'number') {
    throw new Error('Invalid token payload');
  }
  return { userId: decoded.userId };
};

jwt.verify には algorithms: [‘HS256’] を必ず指定します。
指定しないと、攻撃者が alg: none(署名なし)のトークンを送ってくる攻撃(alg 差し替え攻撃)の余地を残してしまいます。

3. 認可ミドルウェアの実装(src/middlewares/auth.middleware.ts)

リクエストヘッダーの Authorization: Bearer <TOKEN> から JWT を取り出し、検証するミドルウェアを作成します。
認証済みユーザー情報を req.user に載せるため、Express の Request 型も拡張します。

// src/types/express.d.ts
import type { AccessTokenPayload } from '../utils/jwt.util.js';

// Express の Request 型を拡張し、認証済みユーザー情報を保持できるようにする
declare global {
  namespace Express {
    interface Request {
      user?: AccessTokenPayload;
    }
  }
}

export {};
// src/middlewares/auth.middleware.ts
import { Request, Response, NextFunction } from 'express';
import { verifyAccessToken } from '../utils/jwt.util.js';
import { UnauthorizedError } from '../errors/app.error.js';

export const authenticateJWT = (req: Request, res: Response, next: NextFunction): void => {
  const authHeader = req.headers.authorization;

  // Authorization: Bearer <TOKEN> 形式か確認
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return next(new UnauthorizedError('認証トークンが提供されていません'));
  }

  const token = authHeader.slice('Bearer '.length);

  try {
    // トークンの検証とデコード
    req.user = verifyAccessToken(token); // 後続のハンドラーで参照できるようにセット
    next();
  } catch {
    next(new UnauthorizedError('無効または期限切れのトークンです'));
  }
};

4. Service・Controller の更新(ログインで JWT を発行する)

AuthService.login が Access Token と Refresh Token を返すようにし、新たに refreshAccessToken を追加します。

// src/services/auth.service.ts
import { IUserRepository } from '../repositories/interfaces/user.repository.interface.js';
import { User } from '../types/user.type.js';
import { hashPassword, comparePassword } from '../utils/password.util.js';
import { generateAccessToken, generateRefreshToken } from '../utils/jwt.util.js';
import { UnauthorizedError } from '../errors/app.error.js';

export interface LoginResult {
  user: User;
  accessToken: string;
  refreshToken: string;
}

export class AuthService {
  constructor(private readonly userRepository: IUserRepository) {}

  register = async (input: { email: string; password: string; name: string }): Promise<User> => {
    const passwordHash = await hashPassword(input.password);
    // 重複チェックは DB の一意制約に任せる(Repository が P2002 を ConflictError に変換)
    return await this.userRepository.create({
      email: input.email,
      name: input.name,
      passwordHash,
    });
  };

  login = async (email: string, password: string): Promise<LoginResult> => {
    const credentials = await this.userRepository.findCredentialsByEmail(email);
    // ユーザー不在とパスワード不一致を同じメッセージにして、アカウントの有無を悟らせない
    const message = 'メールアドレスまたはパスワードが正しくありません';

    if (!credentials) {
      throw new UnauthorizedError(message);
    }
    const isValid = await comparePassword(password, credentials.passwordHash);
    if (!isValid) {
      throw new UnauthorizedError(message);
    }

    const user: User = { id: credentials.id, email: credentials.email, name: credentials.name };
    return {
      user,
      accessToken: generateAccessToken({ userId: user.id, email: user.email }),
      refreshToken: generateRefreshToken({ userId: user.id }),
    };
  };

  // Refresh Token が有効なユーザーに、新しい Access Token を発行する
  refreshAccessToken = async (userId: number): Promise<string> => {
    const user = await this.userRepository.findById(userId);
    if (!user) {
      throw new UnauthorizedError('ユーザーが存在しません');
    }
    return generateAccessToken({ userId: user.id, email: user.email });
  };

  getProfile = async (userId: number): Promise<User> => {
    const user = await this.userRepository.findById(userId);
    if (!user) {
      throw new UnauthorizedError('ユーザーが存在しません');
    }
    return user;
  };
}

Controller では、Access Token はレスポンスの JSON で返し、Refresh Token は HttpOnly Cookie にセットします。
/refresh は Cookie の Refresh Token を検証して、新しい Access Token を返します。

// src/controllers/auth.controller.ts
import { CookieOptions, Request, Response } from 'express';
import { AuthService } from '../services/auth.service.js';
import { verifyRefreshToken } from '../utils/jwt.util.js';
import { jwtConfig } from '../config/jwt.config.js';
import { UnauthorizedError } from '../errors/app.error.js';

const REFRESH_COOKIE_NAME = 'refreshToken';

// Refresh Token は HttpOnly Cookie で保管し、JavaScript からは読めないようにする
const refreshCookieOptions = (): CookieOptions => ({
  httpOnly: true,
  secure: process.env.NODE_ENV === 'production',
  sameSite: 'lax',
  path: '/api/auth', // 認証 API にだけ Cookie を送る
});

export class AuthController {
  constructor(private readonly authService: AuthService) {}

  register = async (req: Request, res: Response): Promise<void> => {
    const { email, password, name } = req.body;
    const user = await this.authService.register({ email, password, name });
    res.status(201).json(user);
  };

  login = async (req: Request, res: Response): Promise<void> => {
    const { email, password } = req.body;
    const { user, accessToken, refreshToken } = await this.authService.login(email, password);

    res.cookie(REFRESH_COOKIE_NAME, refreshToken, {
      ...refreshCookieOptions(),
      maxAge: jwtConfig.refreshMaxAgeMs,
    });
    res.status(200).json({
      message: 'ログインに成功しました',
      accessToken,
      user,
    });
  };

  // Access Token の再発行(Refresh Token Cookie を検証)
  refresh = async (req: Request, res: Response): Promise<void> => {
    const token: string | undefined = req.cookies?.[REFRESH_COOKIE_NAME];
    if (!token) {
      throw new UnauthorizedError('Refresh Token が提供されていません');
    }

    let userId: number;
    try {
      userId = verifyRefreshToken(token).userId;
    } catch {
      throw new UnauthorizedError('無効または期限切れの Refresh Token です');
    }

    const accessToken = await this.authService.refreshAccessToken(userId);
    res.json({ accessToken });
  };

  logout = async (req: Request, res: Response): Promise<void> => {
    res.clearCookie(REFRESH_COOKIE_NAME, refreshCookieOptions());
    res.status(204).send();
  };

  // ログイン中のユーザー情報(authenticateJWT 通過後に呼ばれる)
  me = async (req: Request, res: Response): Promise<void> => {
    const user = await this.authService.getProfile(req.user!.userId);
    res.json(user);
  };
}

5. ルーティングと保護されたルート(カート操作 API)

認証 API のルートに /refresh・/logout・/me を追加します。

// src/routes/auth.route.ts
import { Router } from 'express';
import { prisma } from '../config/database.js';
import { PrismaUserRepository } from '../repositories/prisma/prisma-user.repository.js';
import { AuthService } from '../services/auth.service.js';
import { AuthController } from '../controllers/auth.controller.js';
import { validateRequest } from '../middlewares/validate.middleware.js';
import { authenticateJWT } from '../middlewares/auth.middleware.js';
import { registerSchema, loginSchema } from '../schemas/auth.schema.js';

// 依存関係の組み立て(DI)
const userRepository = new PrismaUserRepository(prisma);
const authService = new AuthService(userRepository);
const authController = new AuthController(authService);

const router = Router();

router.post('/register', validateRequest({ body: registerSchema }), authController.register);
router.post('/login', validateRequest({ body: loginSchema }), authController.login);
router.post('/refresh', authController.refresh);
router.post('/logout', authController.logout);
router.get('/me', authenticateJWT, authController.me);

export default router;

カート API は router.use(authenticateJWT) で全ルートを一括保護します。
第15回で整えた ID バリデーションや DELETE /items(カート全消去)のルートはそのまま残します。

// src/routes/cart.route.ts
import { Router } from 'express';
import { prisma } from '../config/database.js';
import { PrismaCartRepository } from '../repositories/prisma/prisma-cart.repository.js';
import { CartService } from '../services/cart.service.js';
import { CartController } from '../controllers/cart.controller.js';
import { validateRequest } from '../middlewares/validate.middleware.js';
import { authenticateJWT } from '../middlewares/auth.middleware.js';
import {
  createCartItemSchema,
  updateCartItemSchema,
  cartItemIdParamSchema,
} from '../schemas/cart.schema.js';

// 依存関係の組み立て(DI)
const cartRepository = new PrismaCartRepository(prisma);
const cartService = new CartService(cartRepository);
const cartController = new CartController(cartService);

const router = Router();

// カート API の全ルートに JWT 認証ミドルウェアを適用
router.use(authenticateJWT);

router.get('/items', cartController.getSummary);
router.post('/items', validateRequest({ body: createCartItemSchema }), cartController.createItem);
router.patch(
  '/items/:id',
  validateRequest({ params: cartItemIdParamSchema, body: updateCartItemSchema }),
  cartController.updateQuantity
);
router.delete('/items/:id', validateRequest({ params: cartItemIdParamSchema }), cartController.deleteItem);
router.delete('/items', cartController.clearCart);

export default router;

最後に src/app.ts から Session を外し、cookie-parser を組み込みます。

// src/app.ts
import 'dotenv/config';
import express, { Application, Request, Response } from 'express';
import cookieParser from 'cookie-parser';
import authRouter from './routes/auth.route.js';
import cartRouter from './routes/cart.route.js';
import { errorHandler } from './middlewares/error.middleware.js';

const app: Application = express();
const PORT = 3000;

app.use(express.json());
app.use(cookieParser()); // Refresh Token Cookie を req.cookies で読めるようにする

app.use('/api/auth', authRouter);
app.use('/api/cart', cartRouter);

app.get('/health', (req: Request, res: Response) => {
  res.status(200).json({ status: 'UP', timestamp: new Date().toISOString() });
});

app.use((req: Request, res: Response) => {
  res.status(404).json({
    error: 'NOT_FOUND',
    message: '要求されたエンドポイントが存在しません。',
  });
});

app.use(errorHandler);

if (process.env.NODE_ENV !== 'test') {
  app.listen(PORT, () => {
    console.log(`[Server] App running on http://localhost:${PORT}`);
  });
}

export default app;

注意:

今回の実装では、カートはまだ「全ユーザー共通」の1つです(Cart テーブルに userId がないため)。
JWT で「ログインしている人だけ」がカートを操作できるようになりましたが、「ユーザーごとのカート」にするには Cart に userId を持たせる設計変更が必要です。
これは発展課題としておきます。

5. curl による動作確認:トークンなし拒否・JWT 認証成功・期限切れ検証

事前に、第15回のシード(npx prisma db seed)で初期データを入れ、第16回と同じユーザー(kumaki@example.com)を登録しておきます。

1. トークンなしで保護された API にアクセス(401 Unauthorized)

curl -i http://localhost:3000/api/cart/items

実行結果:

HTTP/1.1 401 Unauthorized
Content-Type: application/json; charset=utf-8

{
  "error": "UNAUTHORIZED",
  "message": "認証トークンが提供されていません"
}

2. ログインして JWT(Access Token)を取得する

curl -i -c cookies.txt -X POST http://localhost:3000/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email": "kumaki@example.com", "password": "MySecretPassword123"}'

実行結果(レスポンス。トークンは長いので … で省略しています):

HTTP/1.1 200 OK
Set-Cookie: refreshToken=eyJhbGciOiJIUz...; Max-Age=604800; Path=/api/auth; Expires=Mon, 19 Oct 2026 05:52:10 GMT; HttpOnly; SameSite=Lax
Content-Type: application/json; charset=utf-8

{
  "message": "ログインに成功しました",
  "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "user": {
    "id": 1,
    "email": "kumaki@example.com",
    "name": "熊木"
  }
}

Access Token は JSON のボディで、Refresh Token は HttpOnly の Cookie で返ってきていますね。

Path=/api/auth で、送信先もちゃんと絞られています!

Access Token の中身は、Base64URL をデコードするだけで誰でも読めます(署名がなくても読めるのが JWT です)。

{"alg": "HS256", "typ": "JWT"}
{"userId": 1, "email": "kumaki@example.com", "iat": 1791784330, "exp": 1791785230}

iat は発行時刻、exp は有効期限(どちらも UNIX 時間・秒)で、exp – iat = 900 秒、つまり 15 分です。
パスワードなどの機密情報を入れてはいけない理由がよく分かりますね。

3. Authorization ヘッダーに JWT を付与してアクセス(200 OK)

このトークン、すごく長いですね…。
毎回 curl に貼り付けるのは大変そうです。

だから、ターミナルの 変数 に一度入れておくの。

手順はこうよ。

1. 先ほどのログイン結果から、”accessToken”:” の後ろにある eyJ で始まる長い文字列 を、次の ” の手前までコピーします(前後の ” は含めません)。

2. 同じターミナルで、コピーした文字列を TOKEN=” と ” の間に貼り付けて Enter を押します。
= の前後にスペースを入れないのがポイントです。

TOKEN="ここにコピーした accessToken を貼り付ける"

3. 入ったか確認します。eyJ… が表示されれば OK です。

    echo $TOKEN

    4. $TOKEN を使ってアクセスします。

    curl -i http://localhost:3000/api/cart/items \
      -H "Authorization: Bearer $TOKEN"

    補足:
    コピー&貼り付けが面倒なら、ログインとトークンの保存を1行で済ませることもできます(Node.js で JSON から accessToken だけを取り出しています)。

    TOKEN=$(curl -s -X POST http://localhost:3000/api/auth/login -H "Content-Type: application/json" -d '{"email": "kumaki@example.com", "password": "MySecretPassword123"}' | node -pe "JSON.parse(require('fs').readFileSync(0, 'utf8')).accessToken")

    うまくいかないとき:
    “認証トークンが提供されていません” が返ってきたら、$TOKEN が空のままです。変数はそのターミナルの中だけで有効なので、別のターミナルやタブで設定した場合や、ターミナルを開き直した場合は消えています。
    echo $TOKEN で確認して、もう一度設定してください。
    また、Access Token の有効期限は 15 分なので、時間が経って “無効または期限切れのトークンです” になったら、ログインからやり直してください。

    実行結果:

    HTTP/1.1 200 OK
    Content-Type: application/json; charset=utf-8
    
    {
      "items": [
        {
          "id": 1,
          "productName": "HHKB Professional HYBRID Type-S",
          "price": 36850,
          "quantity": 1
        },
        {
          "id": 2,
          "productName": "Dell UltraSharp 27インチ 4Kモニター",
          "price": 64800,
          "quantity": 2
        },
        {
          "id": 3,
          "productName": "Anker USB-C Hub 7-in-1",
          "price": 6990,
          "quantity": 1
        }
      ],
      "totalCount": 4,
      "totalPrice": 173440
    }

    4. 不正なトークン・期限切れトークン(401 Unauthorized)

    でたらめなトークンはもちろん、署名が正しくても期限切れ(exp が過去)のトークンは拒否されます。
    期限切れトークンは、expiresIn に負の値を渡して作ります。

    # 不正なトークン
    curl -i http://localhost:3000/api/cart/items -H "Authorization: Bearer abc.def.ghi"
    
    # 期限切れトークンを生成してアクセス
    EXPIRED=$(node --env-file=.env -e "console.log(require('jsonwebtoken').sign({userId:1,email:'kumaki@example.com'}, process.env.JWT_SECRET, {expiresIn:-10}))")
    curl -i http://localhost:3000/api/cart/items -H "Authorization: Bearer $EXPIRED"

    実行結果(どちらも同じ):

    HTTP/1.1 401 Unauthorized
    Content-Type: application/json; charset=utf-8
    
    {
      "error": "UNAUTHORIZED",
      "message": "無効または期限切れのトークンです"
    }

    5. Refresh Token で Access Token を再発行する

    Access Token が切れたら、保存した Cookie(Refresh Token)を送って、新しい Access Token をもらいます。

    curl -i -b cookies.txt -X POST http://localhost:3000/api/auth/refresh
    HTTP/1.1 200 OK
    Content-Type: application/json; charset=utf-8
    
    {
      "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
    }

    Cookie なしで呼ぶと 401 です。

    curl -i -X POST http://localhost:3000/api/auth/refresh
    HTTP/1.1 401 Unauthorized
    Content-Type: application/json; charset=utf-8
    
    {
      "error": "UNAUTHORIZED",
      "message": "Refresh Token が提供されていません"
    }

    6. ログアウト(Refresh Token Cookie の削除)

    curl -i -b cookies.txt -c cookies.txt -X POST http://localhost:3000/api/auth/logout
    HTTP/1.1 204 No Content
    Set-Cookie: refreshToken=; Path=/api/auth; Expires=Thu, 01 Jan 1970 00:00:00 GMT; HttpOnly; SameSite=Lax

    すごいです!
    Authorization: Bearer ヘッダーを付けないリクエストは一発で弾かれました!
    一度ログインして JWT を取得すれば、サーバー側でセッションを保存していなくても安全に API を利用できますね!

    ひとつだけ補足。
    ログアウトで Cookie を消しても、すでに発行済みの Access Token は有効期限(15分)まで使えてしまうわ。
    これがステートレス認証の宿命で、だから Access Token の有効期限を短くしているの。

    本日のまとめ

    • ステートレス認証の強み:
      JWT はトークン内に署名情報を持つため、サーバー側でセッションデータを保存・参照することなく、計算(検証)のみで認証が完了する。
      第16回のセッション認証からは切り替え、express-session 関連は削除する。
    • JWT の 3 構造とセキュリティ注意点:
      Header / Payload / Signature から構成され、Payload は誰でもデコード可能なため機密情報を格納してはならない。
      改ざんは Signature 検証によって検知される。
      検証時は algorithms を固定する。
    • Access / Refresh Token による多層防衛:
      短時間の Access Token と、HttpOnly Cookie に保管する長時間の Refresh Token を別々のシークレットで発行し、トークン漏洩時の被害を最小限に抑える。
    • 認可ミドルウェア:
      Authorization: Bearer ヘッダーを検証する authenticateJWT を router.use で適用し、カート API 全体を保護する。

    次回:第18回「Webの脅威からサーバーを守る!Helmet、CORS、Rate-Limitによる徹底防衛」へ続く

    タイトルとURLをコピーしました