認証・認可システムの設計：セキュリティと利便性を両立するDX基盤

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: payment-service-policy
  namespace: default
spec:
  selector:
    matchLabels:
      app: payment-service
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/order-service"]
    to:
    - operation:
        methods: ["POST"]
        paths: ["/api/payment/*"]

// Node.jsでのAPIアクセス例
const axios = require('axios');
const qs = require('querystring');

// クライアント認証情報
const clientId = 'partner_app_123';
const clientSecret = 'client_secret_456';

// トークン取得
async function getAccessToken() {
  const response = await axios.post('https://auth.dx-media.example/oauth/token',
    qs.stringify({
      grant_type: 'client_credentials',
      client_id: clientId,
      client_secret: clientSecret,
      scope: 'read:orders write:orders'
    }),
    {
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
    }
  );
  
  return response.data.access_token;
}

// APIアクセス
async function callPartnerAPI() {
  const token = await getAccessToken();
  
  return axios.get('https://api.partner.com/v1/data', {
    headers: { 'Authorization': `Bearer ${token}` }
  });
}

# アクセスポリシー（Rego言語）
package app.authz

# デフォルトは拒否
default allow = false

# 以下の条件を満たす場合にアクセスを許可
allow {
    # 認証済みユーザー
    input.user.authenticated == true
    
    # ユーザーの部署が「営業」で、アクセス対象の顧客が担当顧客
    input.user.department == "sales"
    input.resource.type == "customer"
    input.resource.owner == input.user.id
    
    # 現在の時間が営業時間内（9:00-18:00）
    time.date[0] == time.weekday
    time.date[0] != "Saturday"
    time.date[0] != "Sunday"
    time.hour >= 9
    time.hour < 18
}

# 管理者は常にアクセス可能
allow {
    input.user.authenticated == true
    input.user.roles[_] == "administrator"
}

// Reactで実装したログイン状態チェックの例
function App() {
  const [authState, setAuthState] = useState({
    isLoading: true,
    isAuthenticated: false,
    user: null
  });
  
  useEffect(() => {
    // トークンの検証と有効期限チェック
    const checkAuthentication = async () => {
      const token = localStorage.getItem('auth_token');
      
      if (!token) {
        setAuthState({ isLoading: false, isAuthenticated: false, user: null });
        return;
      }
      
      try {
        // トークンの検証（JWTデコードと署名検証）
        const decodedToken = jwtDecode(token);
        
        // 有効期限チェック（10分の猶予を設ける）
        const isExpired = decodedToken.exp < (Date.now() / 1000) - 600;
        
        if (isExpired) {
          // リフレッシュトークンがあれば自動更新を試みる
          const refreshToken = localStorage.getItem('refresh_token');
          if (refreshToken) {
            const newTokens = await refreshAuthentication(refreshToken);
            if (newTokens) {
              localStorage.setItem('auth_token', newTokens.accessToken);
              localStorage.setItem('refresh_token', newTokens.refreshToken);
              setAuthState({
                isLoading: false,
                isAuthenticated: true,
                user: jwtDecode(newTokens.accessToken)
              });
              return;
            }
          }
          
          // 更新できなければログアウト
          handleLogout();
        } else {
          // 有効なトークン
          setAuthState({
            isLoading: false,
            isAuthenticated: true,
            user: decodedToken
          });
        }
      } catch (error) {
        console.error('Authentication error:', error);
        handleLogout();
      }
    };
    
    checkAuthentication();
  }, []);
  
  // 以下略...
}

// WebAuthnによるパスワードレス認証の登録例
async function registerWebAuthnCredential(username) {
  // サーバーから登録オプションを取得
  const response = await fetch('/webauthn/registration-options', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ username })
  });
  
  const options = await response.json();
  
  // バイナリデータに変換
  options.challenge = base64URLToBuffer(options.challenge);
  options.user.id = base64URLToBuffer(options.user.id);
  if (options.excludeCredentials) {
    options.excludeCredentials.forEach(cred => {
      cred.id = base64URLToBuffer(cred.id);
    });
  }
  
  // ブラウザのWebAuthn APIを呼び出し
  const credential = await navigator.credentials.create({
    publicKey: options
  });
  
  // レスポンスをサーバーに送信
  const attestation = {
    id: credential.id,
    rawId: bufferToBase64URL(credential.rawId),
    response: {
      clientDataJSON: bufferToBase64URL(credential.response.clientDataJSON),
      attestationObject: bufferToBase64URL(credential.response.attestationObject)
    },
    type: credential.type
  };
  
  // サーバーに登録完了を通知
  await fetch('/webauthn/register', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(attestation)
  });
  
  return true;
}

// Express.jsミドルウェアでの監査ログ
function auditLogMiddleware(req, res, next) {
  // 元のend関数を保存
  const originalEnd = res.end;
  
  // レスポンス完了時の処理を追加
  res.end = function(...args) {
    // APIリクエスト情報
    const auditData = {
      timestamp: new Date().toISOString(),
      userId: req.user ? req.user.id : 'anonymous',
      action: req.method,
      resource: req.originalUrl,
      ipAddress: req.ip,
      userAgent: req.headers['user-agent'],
      statusCode: res.statusCode,
      requestBody: maskSensitiveData(req.body),
      responseTime: Date.now() - req.startTime
    };
    
    // ログの保存（非同期）
    saveAuditLog(auditData).catch(err => {
      console.error('Failed to save audit log:', err);
    });
    
    // 元の関数を呼び出し
    return originalEnd.apply(res, args);
  };
  
  req.startTime = Date.now();
  next();
}

// センシティブデータのマスキング
function maskSensitiveData(data) {
  if (!data) return data;
  
  const masked = { ...data };
  
  // センシティブフィールドをマスク
  const sensitiveFields = ['password', 'creditCard', 'ssn'];
  sensitiveFields.forEach(field => {
    if (masked[field]) {
      masked[field] = '********';
    }
  });
  
  return masked;
}

// ログの保存
async function saveAuditLog(logData) {
  // データベースやログサービスに保存
  await db.collection('audit_logs').insertOne(logData);
  
  // 重要なイベントなら監視システムに通知
  if (isSecurityCriticalEvent(logData)) {
    await notifySecurityTeam(logData);
  }
}