ゼロトラストセキュリティとは

🔒 ゼロトラストセキュリティとは

ゼロトラストセキュリティの概念と実装方法を詳しく解説します。

🎯 なぜゼロトラストセキュリティが必要なのか

❌ 従来のセキュリティモデルの問題点

❌ 問題のある実装:

従来のセキュリティモデル（境界防御）
┌─────────────────────────────────┐
│  信頼できるネットワーク（内部）  │
│  ┌───────────────────────────┐ │
│  │ すべてのリソースにアクセス │ │
│  └───────────────────────────┘ │
└─────────────────────────────────┘
         │
         │ ファイアウォール
         │
┌─────────────────────────────────┐
│  信頼できないネットワーク（外部）│
└─────────────────────────────────┘

// 問題点:
// 1. 内部ネットワークは信頼されている
// 2. 一度内部に入れば、すべてのリソースにアクセス可能
// 3. 内部からの攻撃に対応できない

❌ 問題点:

1. ⚠️ 内部ネットワークの信頼: 内部ネットワークは信頼されていると仮定
2. ⚠️ 境界防御の限界: ファイアウォールだけでは不十分
3. 🔥 内部脅威: 内部からの攻撃に対応できない
4. ⚠️ モバイル・リモートワーク: 境界が曖昧になっている

⚠️ 影響:

• 🔥 内部からの攻撃に対応できない
• ❌ モバイル・リモートワークに対応できない
• 🔥 データ漏洩のリスクが高い

ゼロトラストセキュリティによる解決

改善された実装:

ゼロトラストセキュリティモデル
┌─────────────────────────────────┐
│  すべてのリクエストを検証        │
│  ┌───────────────────────────┐ │
│  │ 1. 認証（誰か）           │ │
│  │ 2. 認可（何ができるか）   │ │
│  │ 3. デバイスの検証         │ │
│  │ 4. ネットワークの検証     │ │
│  │ 5. 継続的な検証           │ │
│  └───────────────────────────┘ │
└─────────────────────────────────┘

メリット:

• すべてのリクエストを検証: 内部・外部を問わず検証
• 最小権限の原則: 必要な権限のみを付与
• 継続的な検証: セッション中も継続的に検証
• モバイル・リモートワーク対応: 場所を問わず検証

ゼロトラストセキュリティの原則

1. 明示的な検証（Verify Explicitly）

実装例:

// すべてのリクエストを明示的に検証
class ZeroTrustMiddleware {
  async verifyRequest(req: Request): Promise<boolean> {
    // 1. 認証の検証
    const token = req.headers['authorization'];
    if (!token) {
      return false;
    }

    const user = await this.verifyToken(token);
    if (!user) {
      return false;
    }

    // 2. デバイスの検証
    const deviceId = req.headers['x-device-id'];
    const device = await this.verifyDevice(deviceId, user.id);
    if (!device || !device.isTrusted) {
      return false;
    }

    // 3. ネットワークの検証
    const ipAddress = req.ip;
    const network = await this.verifyNetwork(ipAddress, user.id);
    if (!network || !network.isTrusted) {
      return false;
    }

    // 4. 認可の検証
    const hasPermission = await this.verifyPermission(user.id, req.path, req.method);
    if (!hasPermission) {
      return false;
    }

    return true;
  }
}

2. 最小権限のアクセス（Use Least Privilege Access）

実装例:

// 最小権限の原則を適用
class AccessControl {
  async checkPermission(userId: string, resource: string, action: string): Promise<boolean> {
    // ユーザーのロールを取得
    const roles = await this.getUserRoles(userId);

    // リソースのアクセス制御リストを取得
    const acl = await this.getResourceACL(resource);

    // 最小権限を確認
    for (const role of roles) {
      const permissions = acl[role];
      if (permissions && permissions.includes(action)) {
        return true;
      }
    }

    return false;
  }

  // 時間ベースのアクセス制御
  async checkTimeBasedAccess(userId: string): Promise<boolean> {
    const user = await this.getUser(userId);
    const now = new Date();
    const currentHour = now.getHours();

    // 業務時間外のアクセスを制限
    if (currentHour < 9 || currentHour > 18) {
      return false;
    }

    return true;
  }
}

3. 侵害を想定する（Assume Breach）

実装例:

// 侵害を想定した設計
class BreachAssumption {
  // セグメンテーション: ネットワークを分離
  async segmentNetwork(userId: string, resource: string): Promise<void> {
    // ユーザーごとにネットワークを分離
    const userNetwork = await this.getUserNetwork(userId);
    const resourceNetwork = await this.getResourceNetwork(resource);

    // ネットワーク間の通信を制限
    if (userNetwork.id !== resourceNetwork.id) {
      throw new Error('Network segmentation violation');
    }
  }

  // 暗号化: データを暗号化
  async encryptData(data: string, userId: string): Promise<string> {
    // ユーザー固有のキーで暗号化
    const userKey = await this.getUserEncryptionKey(userId);
    return await this.encrypt(data, userKey);
  }

  // 監視: 異常な行動を検出
  async monitorBehavior(userId: string, action: string): Promise<void> {
    // 異常な行動パターンを検出
    const behavior = await this.analyzeBehavior(userId, action);
    if (behavior.isAnomalous) {
      await this.alertSecurityTeam(userId, behavior);
      await this.revokeAccess(userId);
    }
  }
}

ゼロトラストセキュリティの実装

1. 多要素認証（MFA）

実装例:

class MultiFactorAuthentication {
  async authenticate(userId: string, password: string, mfaCode: string): Promise<boolean> {
    // 1. パスワード認証
    const user = await this.verifyPassword(userId, password);
    if (!user) {
      return false;
    }

    // 2. MFA認証
    const mfaValid = await this.verifyMFA(userId, mfaCode);
    if (!mfaValid) {
      return false;
    }

    // 3. デバイス認証
    const deviceValid = await this.verifyDevice(userId);
    if (!deviceValid) {
      return false;
    }

    return true;
  }

  async verifyMFA(userId: string, code: string): Promise<boolean> {
    // TOTP（Time-based One-Time Password）の検証
    const secret = await this.getMFASecret(userId);
    const totp = require('totp-generator');
    const expectedCode = totp(secret);

    return code === expectedCode;
  }
}

2. デバイス信頼性の検証

実装例:

class DeviceTrust {
  async verifyDevice(deviceId: string, userId: string): Promise<boolean> {
    const device = await this.getDevice(deviceId);

    // 1. デバイスの登録確認
    if (!device || device.userId !== userId) {
      return false;
    }

    // 2. デバイスの状態確認
    if (!device.isActive) {
      return false;
    }

    // 3. デバイスのセキュリティ状態確認
    if (!device.isCompliant) {
      return false;
    }

    // 4. デバイスの場所確認
    const location = await this.getDeviceLocation(deviceId);
    if (!this.isTrustedLocation(location)) {
      return false;
    }

    return true;
  }

  async isTrustedLocation(location: { lat: number; lon: number }): Promise<boolean> {
    // 信頼できる場所のリスト
    const trustedLocations = [
      { lat: 35.6762, lon: 139.6503, radius: 1000 }, // 東京オフィス
      { lat: 40.7128, lon: -74.0060, radius: 1000 }, // ニューヨークオフィス
    ];

    for (const trusted of trustedLocations) {
      const distance = this.calculateDistance(location, trusted);
      if (distance <= trusted.radius) {
        return true;
      }
    }

    return false;
  }
}

3. 継続的な検証

実装例:

class ContinuousVerification {
  async verifySession(sessionId: string): Promise<boolean> {
    const session = await this.getSession(sessionId);

    // 1. セッションの有効性確認
    if (!session || session.isExpired) {
      return false;
    }

    // 2. ユーザーの状態確認
    const user = await this.getUser(session.userId);
    if (!user || !user.isActive) {
      return false;
    }

    // 3. デバイスの状態確認
    const device = await this.getDevice(session.deviceId);
    if (!device || !device.isTrusted) {
      return false;
    }

    // 4. 行動分析
    const behavior = await this.analyzeBehavior(session.userId);
    if (behavior.isAnomalous) {
      await this.revokeSession(sessionId);
      return false;
    }

    return true;
  }

  async analyzeBehavior(userId: string): Promise<{ isAnomalous: boolean }> {
    // ユーザーの行動パターンを分析
    const recentActions = await this.getRecentActions(userId);
    const normalPattern = await this.getNormalPattern(userId);

    // 異常な行動パターンを検出
    const isAnomalous = this.detectAnomaly(recentActions, normalPattern);

    return { isAnomalous };
  }
}

まとめ

ゼロトラストセキュリティのポイント：

• なぜ必要か: 従来の境界防御モデルの限界、内部脅威への対応
• 原則: 明示的な検証、最小権限のアクセス、侵害を想定
• 実装: 多要素認証、デバイス信頼性の検証、継続的な検証

適切なゼロトラストセキュリティの実装により、より安全なシステムを構築できます。