Security Hubのアラート通知をJira APIで連携して自動起票してみた

import { Construct } from 'constructs';
import * as securityhub from 'aws-cdk-lib/aws-securityhub';

/**
 * AWS Security Hubを設定するためのコンストラクトクラス
 * このクラスはAWS Security Hubを有効化し、推奨されるセキュリティ標準を適用する
 */
export class SecurityHubConstruct extends Construct {
  public readonly securityHub: securityhub.CfnHub;

  constructor(scope: Construct, id: string) {
    super(scope, id);

    // Security Hubを有効化
    this.securityHub = new securityhub.CfnHub(this, 'SecurityHub', {
      enableDefaultStandards: true,  // AWS Foundations BenchmarkとAWS Foundational Security Best Practicesを適用する
      autoEnableControls: true,      // Security Hubが提供する最新のセキュリティチェックを常に適用する
    });
  }
}

import { Construct } from 'constructs';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as securityhub from 'aws-cdk-lib/aws-securityhub';

interface EventRuleProps {
  lambda: lambda.Function;
  securityHub: securityhub.CfnHub;
}

/**
 * Security Hubの検出結果をLambda関数に転送するためのEventBridge Ruleを設定するコンストラクト
 * このクラスは、特定の条件に一致するSecurity Hubの検出結果をキャプチャし、指定されたLambda関数に転送する
 */
export class EventRuleConstruct extends Construct {
  constructor(scope: Construct, id: string, props: EventRuleProps) {
    super(scope, id);

    /**
     *  Security Hubの検出結果をキャプチャするためのEventBridge Rueを作成
     *  MEDIUM以上の重要度を持つ新しい検出結果のみを対象とする
     */
    const rule = new events.Rule(this, 'SecurityHubFindingsRule', {
      eventPattern: {
        source: ['aws.securityhub'],  // イベントソースをSecurity Hubに設定
        detailType: ['Security Hub Findings - Imported'], // イベントタイプをSecurity Hubのインポートされた検出結果に設定
        detail: {
          findings: {
            Severity: {
              Label: ['MEDIUM', 'HIGH', 'CRITICAL'] // MEDIUM以上の重要度を持つ検出結果を対象とする
            },
            Workflow: {
              Status: ['NEW'] // 新しい検出結果のみを対象とする
            }
          }
        }
      }
    });

    /**
     * 作成したEventBridge RuleのターゲットとしてLambda関数を追加
     * これにより、条件に一致するイベントが発生した時にLambda関数が呼び出される
     */
    rule.addTarget(new targets.LambdaFunction(props.lambda));
  }
}

import { Construct } from 'constructs';
import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
import { SecretValue } from 'aws-cdk-lib';

/**
 * JiraのAPI認証情報をSecrets Managerに保存し、Lambda関数からアクセスできるようにする
 */
export class SecretsConstruct extends Construct {
  public readonly secret: secretsmanager.Secret;

  constructor(scope: Construct, id: string) {
    super(scope, id);

    /** 
     * JiraのAPI認証情報をSecrets Managerに保存
     * 注意: ここではダミーの値を使用している。実際のJiraのURL、ユーザー名、プロジェクトキー、APIトークンはデプロイ後に更新する必要がある
     */
    this.secret = new secretsmanager.Secret(this, 'JiraApiCredentials', {
      secretName: 'jira-security-hub-integration', // Secrets Managerに保存するシークレットの名前
      secretStringValue: SecretValue.unsafePlainText(JSON.stringify({
        JIRA_URL: 'https://example.atlassian.net', // JiraのURL（実際のURLに置き換える必要がある）
        JIRA_USER: 'user@example.com', // Jiraのユーザー名（実際のユーザー名に置き換える必要がある）
        JIRA_PROJECT_KEY: 'example-project', // Jiraのプロジェクトキー（実際のプロジェクトキーに置き換える必要がある）
        JIRA_API_TOKEN: 'dummy-token' // JiraのAPIトークン（実際のトークンに置き換える必要がある）
      }))
    });
  }
}

import { Construct } from 'constructs';
import * as nodejsLambda from 'aws-cdk-lib/aws-lambda-nodejs';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as path from 'path';
import { Duration } from 'aws-cdk-lib';

interface LambdaConstructProps {
  secretsArn: string;
}

/**
 * Security HubのアラートをJiraに転送するためのLambda関数を作成
 */
export class LambdaConstruct extends Construct {
  public readonly function: lambda.Function;

  constructor(scope: Construct, id: string, props: LambdaConstructProps) {
    super(scope, id);

    // NodejsFunction を使用してシンプルに Lambda を定義
    this.function = new nodejsLambda.NodejsFunction(this, 'JiraIntegrationFunction', {
      runtime: lambda.Runtime.NODEJS_22_X,
      entry: path.join(__dirname, '../../src/lambda/jira-integration.ts'),
      handler: 'handler',
      timeout: Duration.seconds(30), // Lambda関数のタイムアウト設定（30秒）
      environment: {
        JIRA_SECRETS_ARN: props.secretsArn  // Secrets ManagerのARNを環境変数として設定
      },
      bundling: {
        externalModules: [], // 外部モジュールの指定（空配列は全ての依存関係をバンドルに含めることを意味する）
        minify: true, // バンドルを最小化
        forceDockerBundling: false, // Dockerを使用したバンドリングを強制しない
      }
    });

    // Secrets Managerへのアクセス権限を付与
    this.function.addToRolePolicy(new iam.PolicyStatement({
      actions: ['secretsmanager:GetSecretValue'],
      resources: [props.secretsArn]
    }));
  }
}

import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';
import axios from 'axios';

// Jira認証情報のためのインターフェース定義
interface JiraSecrets {
  JIRA_URL: string;
  JIRA_USER: string;
  JIRA_API_TOKEN: string;
  JIRA_PROJECT_KEY: string;
}

// Lambda関数のメインハンドラー
export const handler = async (event: any): Promise<any> => {
  try {
    // 受信したイベントからSecurity Hubの検出結果（finding）を抽出
    const finding = event.detail.findings[0];

    // 検出結果から必要な情報を取得
    const description = finding.Description || '説明なし'; // アラートの説明
    const severity = finding.Severity?.Label || 'MEDIUM'; // アラートの重要度

    // Security Hubの検出結果IDからコントロールIDを抽出
    // 例: arn:.../v1.0.0/EC2.1/finding/... から "EC2.1" を取得
    const controlIdMatch = finding.Id?.match(/\/([^/]+)\/finding\//);
    const controlId = controlIdMatch ? controlIdMatch[1] : '不明なコントロール';

    // リソースARNの抽出
    let resourceArn = 'N/A';
    if (finding.Resources && finding.Resources.length > 0) {
      resourceArn = finding.Resources[0].Id || 'N/A';
    }

    // AWS Secrets ManagerからJiraの認証情報を取得
    const secretsClient = new SecretsManagerClient();
    const secretResponse = await secretsClient.send(
      new GetSecretValueCommand({
        SecretId: process.env.JIRA_SECRETS_ARN || '' // 環境変数からシークレットのARNを取得
      })
    );

    // シークレットの値が空の場合はエラーをスロー
    if (!secretResponse.SecretString) {
      throw new Error('シークレットの値が空です');
    }

    // 取得したシークレット文字列をJSONとしてパース
    const secrets: JiraSecrets = JSON.parse(secretResponse.SecretString);

    // 必須のJira認証情報が不足している場合はエラーをスロー
    if (!secrets.JIRA_URL || !secrets.JIRA_USER || !secrets.JIRA_API_TOKEN || !secrets.JIRA_PROJECT_KEY) {
      throw new Error('必要なJira認証情報がシークレットに不足しています');
    }

    // Jira URLの末尾のスラッシュを削除し、一貫性を保つ
    secrets.JIRA_URL = secrets.JIRA_URL.replace(/\/+$/, '');

    // Jiraチケットの作成関数を呼び出し、チケットキーを取得
    const issueKey = await createJiraIssue(secrets, controlId, description, resourceArn, severity);

    // 処理成功時のレスポンス
    return {
      statusCode: 200,
      body: { message: 'チケットが正常に作成されました', issueKey }
    };
  } catch (error: unknown) {
    // エラー発生時の基本的なエラーハンドリング
    if (error instanceof Error) {
      console.error('Jiraチケット作成中にエラーが発生しました:', error.message);
    } else {
      console.error('Jiraチケット作成中に不明なエラーが発生しました。');
    }
    // 汎用的な500エラーを返す
    return {
      statusCode: 500,
      body: { message: 'Jiraチケット作成中にエラーが発生しました' }
    };
  }
};

// Jiraプロジェクトで利用可能な課題タイプを取得する関数
async function getAvailableIssueTypes(secrets: JiraSecrets, headers: any): Promise<any[]> {
  try {
    // Jira APIからプロジェクトのメタデータ（課題タイプ含む）を取得
    const response = await axios.get(
      `${secrets.JIRA_URL}/rest/api/3/issue/createmeta?projectKeys=${secrets.JIRA_PROJECT_KEY}&expand=projects.issuetypes`,
      { headers }
    );

    // 課題タイプが見つかった場合はそれを返す
    if (response.data.projects && response.data.projects.length > 0) {
      return response.data.projects[0].issuetypes || [];
    }

    // 課題タイプが見つからなかった場合は空の配列を返す
    return [];
  } catch (error: unknown) {
    // 課題タイプ取得時のエラーはログに記録するが、処理は続行（フォールバックで対応）
    if (axios.isAxiosError(error)) {
      console.error('課題タイプの取得中にエラーが発生しました:', error.message);
    } else {
      console.error('課題タイプの取得中に不明なエラーが発生しました。');
    }
    return [];
  }
}

// Jiraチケットを作成するメイン関数
async function createJiraIssue(
  secrets: JiraSecrets,
  controlId: string,          // チケットのサマリーに含めるコントロールID
  alertDescription: string,   // チケットの説明に含めるアラート内容
  resourceArn: string,        // チケットの説明に含めるリソースARN
  severity: string            // チケットのサマリーと説明に含める重要度
): Promise<string> {
  try {
    // Jira APIリクエスト用の認証ヘッダーを作成
    const auth = Buffer.from(`${secrets.JIRA_USER}:${secrets.JIRA_API_TOKEN}`).toString('base64');
    const headers = {
      'Content-Type': 'application/json',
      'Authorization': `Basic ${auth}`
    };

    // 利用可能な課題タイプを取得
    const issueTypes = await getAvailableIssueTypes(secrets, headers);

    // Jiraチケットの説明フィールドに含めるコンテンツを定義（ADF形式）
    // 指定されたテンプレートと太文字の形式を適用
    const jiraDescriptionContent = [
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '重要度', marks: [{ type: 'strong' }] }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: severity }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '環境', marks: [{ type: 'strong' }] }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '[ ] 開発環境' }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '[ ] 本番環境' }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: 'リソース', marks: [{ type: 'strong' }] }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: `${resourceArn}` }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '対応内容', marks: [{ type: 'strong' }] }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '[ ] 静観' }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '[ ] リソース修正' }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '[ ] リソース削除' }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: '[ ] アラート抑制' }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: 'アラート内容', marks: [{ type: 'strong' }] }]
      },
      {
        type: 'paragraph',
        content: [{ type: 'text', text: alertDescription }]
      }
    ];

    let issueType; // 使用する課題タイプを格納する変数

    // 利用可能な課題タイプの中から「タスク」または「Task」を検索し、選択する
    const taskType = issueTypes.find(t => t.name === "タスク" || t.name === "Task");

    if (taskType) {
      issueType = taskType;
      console.log(`課題タイプ「${issueType.name}」が選択されました。`);
    } else {
      // 「タスク」が見つからない場合はエラーをスローし、チケット作成を中止
      throw new Error('Jiraプロジェクトで「タスク」課題タイプが見つかりませんでした。');
    }

    // Jira APIを呼び出してチケットを作成
    const createResponse = await axios.post(
      `${secrets.JIRA_URL}/rest/api/3/issue`,
      {
        fields: {
          project: { key: secrets.JIRA_PROJECT_KEY },
          summary: `[Security Hub] ${severity} - ${controlId}`, // サマリーを「[Security Hub] <Severity> - <Control ID>」に変更
          description: {
            type: 'doc',
            version: 1,
            content: jiraDescriptionContent // カスタムテンプレートを使用
          },
          issuetype: { id: issueType.id }, // 課題タイプIDを指定
        }
      },
      { headers }
    );

    const issueKey = createResponse.data.key;
    console.log(`Jiraチケットが正常に作成されました: ${issueKey}`);

    // チケットをアクティブなスプリントに追加（失敗しても処理は続行）
    await addIssueToActiveSprint(secrets, headers, issueKey);

    return issueKey; // 成功したチケットキーを返す

  } catch (error: unknown) {
    // チケット作成処理全体でエラーが発生した場合のハンドリング
    if (axios.isAxiosError(error)) {
      console.error('Jiraチケット作成中にエラーが発生しました（Axiosエラー）:', error.message);
    } else if (error instanceof Error) {
      console.error('Jiraチケット作成中にエラーが発生しました:', error.message);
    } else {
      console.error('Jiraチケット作成中に不明なエラーが発生しました。');
    }
    // Jiraチケット作成失敗を示すエラーをスロー
    throw new Error('Jiraチケットの作成に失敗しました。');
  }
}

// 作成したチケットをアクティブなスプリントに追加する関数
async function addIssueToActiveSprint(secrets: JiraSecrets, headers: any, issueKey: string): Promise<void> {
  try {
    // Jira APIから対象プロジェクトのアクティブなボードを取得
    const boardResponse = await axios.get(
      `${secrets.JIRA_URL}/rest/agile/1.0/board?projectKeyOrId=${secrets.JIRA_PROJECT_KEY}`,
      { headers }
    );

    if (boardResponse.data.values && boardResponse.data.values.length > 0) {
      const boardId = boardResponse.data.values[0].id;

      // 取得したボードIDを使って、アクティブなスプリントを取得
      const sprintResponse = await axios.get(
        `${secrets.JIRA_URL}/rest/agile/1.0/board/${boardId}/sprint?state=active`,
        { headers }
      );

      // アクティブなスプリントが存在する場合、チケットを追加
      if (sprintResponse.data.values && sprintResponse.data.values.length > 0) {
        const sprintId = sprintResponse.data.values[0].id;

        // Jira APIを呼び出し、指定されたチケットをスプリントに追加
        await axios.post(
          `${secrets.JIRA_URL}/rest/agile/1.0/sprint/${sprintId}/issue`,
          { issues: [issueKey] },
          { headers }
        );
        console.log(`チケット ${issueKey} がスプリントに正常に追加されました。`);
      } else {
        console.log('アクティブなスプリントが見つかりませんでした。チケットはスプリントに追加されません。');
      }
    } else {
      console.log(`プロジェクト ${secrets.JIRA_PROJECT_KEY} のボードが見つかりませんでした。チケットはスプリントに追加されません。`);
    }
  } catch (error: unknown) {
    // スプリントへの追加はチケット作成の主要な要件ではないため、エラーが発生してもログに記録するのみ
    if (axios.isAxiosError(error)) {
      console.error('スプリントにチケットを追加中にエラーが発生しました:', error.message);
    } else {
      console.error('スプリントにチケットを追加中に不明なエラーが発生しました。');
    }
  }
}