セッション管理の実装パターンとセキュリティ対策

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');
const crypto = require('crypto');

const app = express();

// Redis クライアントの初期化
const redisClient = createClient({
  url: process.env.REDIS_URL || 'redis://localhost:6379'
});
redisClient.connect().catch(console.error);

// セッション設定
app.use(session({
  store: new RedisStore({ 
    client: redisClient,
    prefix: 'sess:'           // セッションキーのプレフィックス
  }),
  name: 'sid',                // Cookie名（デフォルトの'connect.sid'を変更）
  secret: process.env.SESSION_SECRET, // 環境変数から取得
  resave: false,              // 変更がない場合は再保存しない
  saveUninitialized: false,   // 未初期化セッションは保存しない
  cookie: {
    httpOnly: true,           // JavaScriptからアクセス不可
    secure: process.env.NODE_ENV === 'production', // 本番ではHTTPSのみ
    sameSite: 'lax',          // CSRF対策
    maxAge: 30 * 60 * 1000    // 30分
  },
  // セッションID生成関数のカスタマイズ
  genid: () => {
    return crypto.randomBytes(32).toString('hex');
  }
}));

app.listen(3000);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from flask import Flask, session
from flask_session import Session
import redis
import secrets

app = Flask(__name__)

# セッション設定
app.config['SECRET_KEY'] = secrets.token_hex(32)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_PERMANENT'] = True
app.config['PERMANENT_SESSION_LIFETIME'] = 1800  # 30分
app.config['SESSION_REDIS'] = redis.from_url('redis://localhost:6379')
app.config['SESSION_COOKIE_HTTPONLY'] = True
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
app.config['SESSION_COOKIE_NAME'] = 'sid'

Session(app)

@app.route('/login', methods=['POST'])
def login():
    # 認証処理後
    session.clear()  # 既存セッションをクリア
    session['user_id'] = user.id
    session['user_role'] = user.role
    return redirect('/dashboard')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

const crypto = require('crypto');

/**
 * 安全なセッションIDを生成する
 * @param {number} bytes - バイト数（デフォルト32 = 256ビット）
 * @returns {string} 16進数文字列のセッションID
 */
function generateSecureSessionId(bytes = 32) {
  // Node.jsのcrypto.randomBytesはCSPRNGを使用
  return crypto.randomBytes(bytes).toString('hex');
}

// 生成例
const sessionId = generateSecureSessionId();
// 出力例: "a7f3b2c1d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 危険: Math.randomは予測可能
function badSessionId1() {
  return Math.random().toString(36).substring(2);
}

// 危険: タイムスタンプベースは推測可能
function badSessionId2() {
  return Date.now().toString(36) + Math.random().toString(36);
}

// 危険: ユーザー情報を含めると情報漏洩
function badSessionId3(userId) {
  return `user_${userId}_${Date.now()}`;
}

// 危険: 連番は総当たり攻撃に脆弱
let counter = 0;
function badSessionId4() {
  return `sess_${++counter}`;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

const express = require('express');
const session = require('express-session');
const helmet = require('helmet');

const app = express();

// セキュリティヘッダーの設定
app.use(helmet({
  // HSTS（HTTP Strict Transport Security）
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true
  },
  // Content Security Policy
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'"],
    }
  }
}));

// セッション設定（多層防御）
app.use(session({
  name: 'sid',
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false,
  cookie: {
    httpOnly: true,       // XSS対策
    secure: true,         // スニッフィング対策
    sameSite: 'strict',   // CSRF対策
    maxAge: 30 * 60 * 1000,
    path: '/',
    domain: undefined     // オリジンサーバーのみに制限
  }
}));

// IPアドレスとUser-Agentのバインディング（追加防御）
app.use((req, res, next) => {
  if (req.session.user) {
    const currentFingerprint = `${req.ip}:${req.headers['user-agent']}`;
    
    if (!req.session.fingerprint) {
      // 初回アクセス時にフィンガープリントを保存
      req.session.fingerprint = currentFingerprint;
    } else if (req.session.fingerprint !== currentFingerprint) {
      // フィンガープリントの不一致を検出
      console.warn(`セッション異常検出: ${req.session.user}`);
      req.session.destroy();
      return res.status(401).json({ error: 'セッションが無効です' });
    }
  }
  next();
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Express でのセッション再生成実装
app.post('/login', async (req, res) => {
  const { username, password } = req.body;
  
  try {
    // 認証処理
    const user = await authenticateUser(username, password);
    
    if (!user) {
      return res.status(401).json({ error: '認証失敗' });
    }
    
    // 重要: 認証成功後にセッションIDを再生成
    req.session.regenerate((err) => {
      if (err) {
        console.error('セッション再生成エラー:', err);
        return res.status(500).json({ error: 'サーバーエラー' });
      }
      
      // 新しいセッションにユーザー情報を設定
      req.session.user = {
        id: user.id,
        name: user.name,
        role: user.role
      };
      req.session.loginTime = Date.now();
      
      // セッションを保存してからレスポンス
      req.session.save((err) => {
        if (err) {
          return res.status(500).json({ error: 'セッション保存エラー' });
        }
        res.json({ success: true, redirectTo: '/dashboard' });
      });
    });
  } catch (error) {
    console.error('ログインエラー:', error);
    res.status(500).json({ error: 'サーバーエラー' });
  }
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

const express = require('express');
const session = require('express-session');

const app = express();

// タイムアウト設定値
const IDLE_TIMEOUT = 30 * 60 * 1000;      // 30分
const ABSOLUTE_TIMEOUT = 8 * 60 * 60 * 1000; // 8時間
const RENEWAL_INTERVAL = 60 * 60 * 1000;  // 1時間

// セッションタイムアウトミドルウェア
app.use((req, res, next) => {
  if (!req.session.user) {
    return next();
  }
  
  const now = Date.now();
  
  // 絶対タイムアウトチェック
  if (req.session.createdAt && 
      now - req.session.createdAt > ABSOLUTE_TIMEOUT) {
    console.log('絶対タイムアウト:', req.session.user.id);
    return terminateSession(req, res, '絶対タイムアウト');
  }
  
  // アイドルタイムアウトチェック
  if (req.session.lastActivity && 
      now - req.session.lastActivity > IDLE_TIMEOUT) {
    console.log('アイドルタイムアウト:', req.session.user.id);
    return terminateSession(req, res, 'アイドルタイムアウト');
  }
  
  // 更新タイムアウトチェック（セッションID再生成）
  if (req.session.lastRegenerated && 
      now - req.session.lastRegenerated > RENEWAL_INTERVAL) {
    return regenerateSessionId(req, res, next);
  }
  
  // 最終アクティビティ時刻を更新
  req.session.lastActivity = now;
  next();
});

// セッション終了処理
function terminateSession(req, res, reason) {
  const userId = req.session.user?.id;
  req.session.destroy((err) => {
    if (err) {
      console.error('セッション破棄エラー:', err);
    }
    // 監査ログ
    console.log(`セッション終了 - ユーザー: ${userId}, 理由: ${reason}`);
    res.status(401).json({ 
      error: 'セッションが期限切れです',
      reason: reason 
    });
  });
}

// セッションID再生成処理
function regenerateSessionId(req, res, next) {
  const userData = { ...req.session.user };
  const createdAt = req.session.createdAt;
  
  req.session.regenerate((err) => {
    if (err) {
      console.error('セッション再生成エラー:', err);
      return next(err);
    }
    
    req.session.user = userData;
    req.session.createdAt = createdAt;
    req.session.lastRegenerated = Date.now();
    req.session.lastActivity = Date.now();
    
    console.log('セッションID再生成:', userData.id);
    next();
  });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// 権限昇格時のセッション再生成
app.post('/admin/elevate', requireAuth, async (req, res) => {
  const { adminPassword } = req.body;
  
  // 管理者パスワードの確認
  const isValid = await verifyAdminPassword(req.session.user.id, adminPassword);
  
  if (!isValid) {
    return res.status(403).json({ error: '権限昇格に失敗しました' });
  }
  
  // 重要: 権限変更前にセッションIDを再生成
  req.session.regenerate((err) => {
    if (err) {
      return res.status(500).json({ error: 'セッションエラー' });
    }
    
    req.session.user = {
      ...req.session.user,
      role: 'admin',
      elevatedAt: Date.now()
    };
    
    res.json({ success: true, message: '管理者権限を付与しました' });
  });
});

// パスワード変更時の全セッション無効化
app.post('/account/change-password', requireAuth, async (req, res) => {
  const { currentPassword, newPassword } = req.body;
  
  // パスワード変更処理
  await changePassword(req.session.user.id, currentPassword, newPassword);
  
  // 現在のセッション以外をすべて無効化
  await invalidateOtherSessions(req.session.user.id, req.sessionID);
  
  // 現在のセッションも再生成
  req.session.regenerate((err) => {
    if (err) {
      return res.status(500).json({ error: 'セッションエラー' });
    }
    
    req.session.user = { id: req.session.user.id };
    req.session.passwordChangedAt = Date.now();
    
    res.json({ success: true, message: 'パスワードを変更しました' });
  });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Consoleでの確認（開発・テスト環境用）

// HttpOnly Cookieはdocument.cookieに表示されない
console.log(document.cookie);
// 出力: "theme=dark; language=ja"
// ※ sidは表示されない（HttpOnlyが正しく設定されている証拠）

// セッション状態をAPIで確認
fetch('/api/session/status')
  .then(res => res.json())
  .then(data => console.log('セッション状態:', data));

// 期待される出力例:
// {
//   isAuthenticated: true,
//   sessionAge: 1234567,     // ミリ秒
//   idleTime: 123456,        // ミリ秒
//   remainingIdle: 1676544   // ミリ秒
// }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// セッション状態確認エンドポイント（開発環境のみ）
if (process.env.NODE_ENV === 'development') {
  app.get('/api/session/debug', (req, res) => {
    res.json({
      hasSession: !!req.session,
      isAuthenticated: !!req.session?.user,
      sessionId: req.sessionID?.substring(0, 8) + '...', // 一部のみ表示
      user: req.session?.user ? {
        id: req.session.user.id,
        role: req.session.user.role
      } : null,
      createdAt: req.session?.createdAt,
      lastActivity: req.session?.lastActivity,
      cookie: {
        maxAge: req.session?.cookie?.maxAge,
        httpOnly: req.session?.cookie?.httpOnly,
        secure: req.session?.cookie?.secure,
        sameSite: req.session?.cookie?.sameSite
      }
    });
  });
}