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による徹底防衛」へ続く

