Workload Identity Federation

GitHub Actions・Google Cloud Run・AWS Lambda などの外部ワークロードが発行する短命トークンを使って、 静的なアクセストークンなしで CRISIS API にアクセスする仕組みです。 シークレットをリポジトリや環境変数に保存する必要がなくなります。

概要

従来の認証では、静的なアクセストークンを Secret Manager などのシークレット管理サービスに保存し、CI/CD から取得して利用していました。 静的トークンは一度漏洩すると無期限に悪用される可能性があります。

CI/CD ワークロード
  ─── 静的トークン（無期限）を Secret Manager 等から取得
  ──────────────────────────▶ CRISIS API

CI/CD ワークロード
  ─── IdP から短命トークンを自動取得
  ─── Token Exchange で CRISIS トークンを取得
  ──────────────────────────▶ CRISIS API

仕組み

CRISIS は受け取った外部トークンの内容を Federated Credential の設定値と照合し、 すべての条件を満たした場合に対応するサービスアカウントのアクセストークンを発行します。

検証フロー

CRISIS は受け取った OIDC JWT に対して、以下の条件をすべて検証します。

条件を満たさない場合に返るエラーの詳細はエラーレスポンスを参照してください。

セットアップ

1. サービスアカウントの作成

CRISIS の管理画面または API でサービスアカウントを作成します。 WIF を使うサービスアカウントは、従来の静的アクセストークンとの共存も可能です。 すでに適切なサービスアカウントがある場合は、この手順をスキップできます。

2. Federated Credential の作成

サービスアカウントに Federated Credential を登録します。 これにより、指定した外部 IdP が認証するワークロードが、そのサービスアカウントとして認証できるようになります。

GitHub Actions の場合

POST /organizations/{organizationId}/service_accounts/{serviceAccountId}/federated_credentials

{
  "display_name": "GitHub Actions (my-org/my-repo)",
  "issuer_url": "https://token.actions.githubusercontent.com",
  "subject_filter": "repo:my-org/my-repo:ref:refs/heads/main",
  "audience": "https://crisis.jp",
  "status": "ACTIVE"
}

AWS の場合

AWS IAM Outbound Identity Federation（GetWebIdentityToken API）を使用します。 AWS STS がワークロードの IAM ID をアサートする OIDC JWT を発行します。

POST /organizations/{organizationId}/service_accounts/{serviceAccountId}/federated_credentials

{
  "display_name": "AWS Lambda (crisis-integration)",
  "issuer_url": "https://<uuid>.tokens.sts.global.api.aws",
  "subject_filter": "arn:aws:iam::123456789012:role/crisis-integration-role",
  "audience": "https://crisis.jp",
  "status": "ACTIVE"
}

issuer_url には AWS アカウント固有の STS 発行者 URL を指定します。 IAM コンソールの「アカウント設定」または CLI で確認できます（詳細は使用例: AWS Lambdaを参照）。 subject_filter にはワークロードの IAM ロール ARN（GetWebIdentityToken が発行する JWT の sub クレーム）を指定します。

フィールド

attribute_condition について

sub 以外のクレームで追加の制約をかけたい場合に使用します。 構文は expr-lang に準拠した式言語をサポートしています。

利用可能な演算子

例

// 単一条件: issuer が一致すること
"attribute_condition": "iss == \"https://token.actions.githubusercontent.com\""

// 複合条件: issuer と ref ブランチの両方を検証
"attribute_condition": "iss == \"https://token.actions.githubusercontent.com\" && ref == \"refs/heads/main\""

// 部分一致: email がドメインで終わること
"attribute_condition": "email endsWith \"@example.com\""

例（AWS STS トークン）

AWS STS GetWebIdentityToken が発行する JWT には、標準クレーム（sub = IAM ロール ARN）に加えて、 https://sts.amazonaws.com/ ネームスペースのクレームが含まれます。 これらを attribute_condition で参照できます:

// 特定の AWS アカウントのみ許可
"attribute_condition": "[\"https://sts.amazonaws.com/\"][\"aws_account\"] == \"123456789012\""

// 複数アカウントを許可
"attribute_condition": "[\"https://sts.amazonaws.com/\"][\"aws_account\"] in [\"123456789012\", \"987654321098\"]"

// IAM ロール ARN のプレフィックスで制約
"attribute_condition": "sub startsWith \"arn:aws:iam::123456789012:role/\""

利用できるクレーム名は IdP ごとに異なります。GitHub Actions の場合は OIDC トークンの仕様 を参照してください。

作成レスポンスに含まれる id が credentialId です。 トークン交換時のエンドポイント URL に使用します。

トークン交換

外部 IdP から取得した OIDC JWT を提示し、CRISIS アクセストークンと交換します。 エンドポイントは RFC 8693（OAuth 2.0 Token Exchange）に準拠しています。

エンドポイント

POST https://auth.crisis.jp/workload-identity/{credentialId}/token
Content-Type: application/x-www-form-urlencoded

リクエストパラメータ（form-urlencoded）

レスポンス

{
  "access_token": "<CRISIS アクセストークン>",
  "issued_token_type": "urn:ietf:params:oauth:token-type:access_token",
  "token_type": "Bearer",
  "expires_in": 3600
}

取得した access_token を Bearer トークンとして通常どおり CRISIS API に渡します。 有効期限は 1 時間（3600 秒） で、トークン交換エンドポイントは認証不要・レート制限の対象です。

使用例: GitHub Actions

GitHub Actions の OIDC トークンを使って CRISIS API を呼び出す例です。 リポジトリにシークレットを一切設定する必要がありません。

Federated Credential の設定

{
  "display_name": "GitHub Actions (my-org/my-repo main branch)",
  "issuer_url": "https://token.actions.githubusercontent.com",
  "subject_filter": "repo:my-org/my-repo:ref:refs/heads/main",
  "audience": "https://crisis.jp"
}

subject_filter の値は GitHub の OIDC トークン仕様 に基づきます。

attribute_condition の推奨設定

subject_filter に加えて、repository_owner クレームで組織を制約することを推奨します。 これにより、万が一 subject_filter のワイルドカードが広すぎる場合でも、 信頼する組織外のリポジトリからのトークン交換を防止できます。

// リポジトリオーナー（組織）を制約
"attribute_condition": "repository_owner == \"my-org\""

// 組織 + 特定の環境に制約
"attribute_condition": "repository_owner == \"my-org\" && environment == \"production\""

ワークフロー例

name: Deploy

on:
  push:
    branches: [main]

permissions:
  id-token: write   # OIDC トークンの取得に必要
  contents: read

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Get OIDC token and exchange for CRISIS token
        run: |
          # GitHub Actions から OIDC JWT を取得
          OIDC_JWT=$(curl -sSfL \
            -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
            -H "Accept: application/json; api-version=2.0" \
            "${ACTIONS_ID_TOKEN_REQUEST_URL}&audience=https://crisis.jp" \
            | jq -r '.value')

          # CRISIS Token Exchange
          CRISIS_TOKEN=$(curl -sSf \
            -X POST \
            -H "Content-Type: application/x-www-form-urlencoded" \
            --data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:token-exchange" \
            --data-urlencode "subject_token=${OIDC_JWT}" \
            --data-urlencode "subject_token_type=urn:ietf:params:oauth:token-type:jwt" \
            "https://auth.crisis.jp/workload-identity/${{ vars.CRISIS_CREDENTIAL_ID }}/token" \
            | jq -r '.access_token')
          echo "::add-mask::${CRISIS_TOKEN}"

          # 同一ステップ内で API を呼び出し、トークンを外部に渡さない
          curl -sSf \
            -H "Authorization: Bearer ${CRISIS_TOKEN}" \
            https://api.crisis.jp/v1/organizations/${{ vars.CRISIS_ORG_ID }}/incidents

設定すべき Variables

使用例: Google Cloud

Google Cloud のサービスアカウントが発行する ID Token を使う例です。 Cloud Run などのマネージド環境で、Metadata Server からトークンを取得できます。

Federated Credential の設定

{
  "display_name": "Google Cloud Run (my-service)",
  "issuer_url": "https://accounts.google.com",
  "subject_filter": "123456789012345678901",
  "audience": "https://crisis.jp"
}

subject_filter には Google Cloud サービスアカウントの Unique ID（21 桁前後の数字）を指定します。 Google Cloud Console の「IAM と管理 → サービスアカウント」で対象サービスアカウントの詳細画面を開き、 「一意の ID」欄に表示される値です。

attribute_condition の推奨設定

サービスアカウントが削除・再作成された場合、sub（Unique ID）は変わりますが、 同じメールアドレスが再利用される可能性があります。 逆に sub のみでの制約では、意図したサービスアカウントであることの可読性が低くなります。 email クレームを attribute_condition で併用することで、 より明確かつ安全な制約が可能です。

// email クレームでサービスアカウントを明示的に検証
"attribute_condition": "email == \"my-service@my-project.iam.gserviceaccount.com\""

// email ドメインでプロジェクト内の全 SA を許可
"attribute_condition": "email endsWith \"@my-project.iam.gserviceaccount.com\""

アクセストークンの取得

# Cloud Run 上のサービスから実行する場合
# CRISIS_CREDENTIAL_ID は環境変数として事前に設定しておく
# format=full を付けると email クレームがトークンに含まれる
GOOGLE_TOKEN=$(curl -sSf \
  -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://crisis.jp&format=full")

CRISIS_TOKEN=$(curl -sSf \
  -X POST \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:token-exchange" \
  --data-urlencode "subject_token=${GOOGLE_TOKEN}" \
  --data-urlencode "subject_token_type=urn:ietf:params:oauth:token-type:jwt" \
  "https://auth.crisis.jp/workload-identity/${CRISIS_CREDENTIAL_ID}/token" \
  | jq -r '.access_token')

使用例: Azure

Azure のマネージド ID（Managed Identity）が発行する OIDC トークンを使って CRISIS API を呼び出す例です。 CRISIS のシークレットを Azure に保存する必要はありません。

Federated Credential の設定

{
  "display_name": "Azure Functions (crisis-integration)",
  "issuer_url": "https://login.microsoftonline.com/{tenant-id}/v2.0",
  "subject_filter": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "audience": "api://crisis-wif"
}

issuer_url には Azure AD テナントの OIDC 発行者 URL を指定します。 subject_filter には Managed Identity の Object ID（Principal ID） を指定します。 Azure Portal の「マネージド ID」画面で確認できます。

attribute_condition の例

// Object ID（sub）で制約する場合は subject_filter で十分だが、
// テナント ID でも二重に検証したい場合:
"attribute_condition": "tid == \"your-tenant-id\""

// 複数のマネージド ID を許可する場合:
"attribute_condition": "oid in [\"object-id-1\", \"object-id-2\"]"

Azure Functions の例（Python）

import json
import os
import urllib.request
import urllib.parse

import azure.functions as func
from azure.identity import ManagedIdentityCredential

CREDENTIAL_ID = os.environ["CRISIS_CREDENTIAL_ID"]
AUDIENCE = os.environ.get("CRISIS_AUDIENCE", "api://crisis-wif")


def main(req: func.HttpRequest) -> func.HttpResponse:
    # Step 1: Managed Identity から OIDC トークンを取得
    credential = ManagedIdentityCredential()
    azure_token = credential.get_token(AUDIENCE).token

    # Step 2: CRISIS Token Exchange
    crisis_token = exchange_token(CREDENTIAL_ID, azure_token)

    # Step 3: CRISIS API を呼び出す
    api_req = urllib.request.Request(
        "https://api.crisis.jp/v1/organizations/YOUR_ORG_ID/incidents",
        headers={"Authorization": f"Bearer {crisis_token}"},
    )
    with urllib.request.urlopen(api_req) as resp:
        data = json.loads(resp.read())

    return func.HttpResponse(json.dumps(data), mimetype="application/json")


def exchange_token(credential_id: str, subject_token: str) -> str:
    """CRISIS Token Exchange エンドポイントを呼び出す"""
    data = urllib.parse.urlencode({
        "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
        "subject_token": subject_token,
        "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
    }).encode()

    req = urllib.request.Request(
        f"https://auth.crisis.jp/workload-identity/{credential_id}/token",
        data=data,
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        method="POST",
    )
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read())["access_token"]

Azure Functions の例（Node.js）

import { app } from "@azure/functions";
import { ManagedIdentityCredential } from "@azure/identity";

const CREDENTIAL_ID = process.env.CRISIS_CREDENTIAL_ID;
const AUDIENCE = process.env.CRISIS_AUDIENCE || "api://crisis-wif";

app.http("crisisProxy", {
  methods: ["GET"],
  handler: async (request, context) => {
    // Step 1: Managed Identity から OIDC トークンを取得
    const credential = new ManagedIdentityCredential();
    const { token: azureToken } = await credential.getToken(AUDIENCE);

    // Step 2: CRISIS Token Exchange
    const body = new URLSearchParams({
      grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
      subject_token: azureToken,
      subject_token_type: "urn:ietf:params:oauth:token-type:jwt",
    });

    const tokenRes = await fetch(
      `https://auth.crisis.jp/workload-identity/${CREDENTIAL_ID}/token`,
      { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body }
    );
    const { access_token } = await tokenRes.json();

    // Step 3: CRISIS API を呼び出す
    const apiRes = await fetch(
      "https://api.crisis.jp/v1/organizations/YOUR_ORG_ID/incidents",
      { headers: { Authorization: `Bearer ${access_token}` } }
    );
    return { jsonBody: await apiRes.json() };
  },
});

AKS (Azure Kubernetes Service) の例

AKS Workload Identity を使う場合、Pod に自動マウントされる Projected Service Account Token を利用します。 Azure Workload Identity webhook がトークンファイルのパスを環境変数で注入します。

# AKS Pod 内のシェルスクリプト例

# Azure Workload Identity が注入する環境変数:
#   AZURE_FEDERATED_TOKEN_FILE — トークンファイルのパス
#   AZURE_AUTHORITY_HOST — https://login.microsoftonline.com/
#   AZURE_TENANT_ID — テナント ID
#   AZURE_CLIENT_ID — マネージド ID のクライアント ID

# Projected SA Token を読み取り（audience は Azure AD 向け）、
# Azure AD から ID Token を取得し、CRISIS に交換する

# azure-identity SDK を使う場合は自動的にファイルから読み取る
# 手動で行う場合:
AZURE_TOKEN=$(cat "$AZURE_FEDERATED_TOKEN_FILE")

# Azure AD にトークン交換して ID Token を取得
AZURE_ID_TOKEN=$(curl -sSf -X POST \
  "${AZURE_AUTHORITY_HOST}${AZURE_TENANT_ID}/oauth2/v2.0/token" \
  -d "client_id=${AZURE_CLIENT_ID}" \
  -d "scope=api://crisis-wif/.default" \
  -d "client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer" \
  -d "client_assertion=${AZURE_TOKEN}" \
  -d "grant_type=client_credentials" \
  | jq -r '.access_token')

# CRISIS Token Exchange
CRISIS_TOKEN=$(curl -sSf -X POST \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:token-exchange" \
  --data-urlencode "subject_token=${AZURE_ID_TOKEN}" \
  --data-urlencode "subject_token_type=urn:ietf:params:oauth:token-type:jwt" \
  "https://auth.crisis.jp/workload-identity/${CRISIS_CREDENTIAL_ID}/token" \
  | jq -r '.access_token')

curl -H "Authorization: Bearer ${CRISIS_TOKEN}" \
  https://api.crisis.jp/v1/organizations/${CRISIS_ORG_ID}/incidents

必要なアプリケーション設定

Azure 側の前提条件

使用例: AWS Lambda

AWS Lambda 関数から CRISIS API を呼び出す例です。 AWS IAM Outbound Identity Federation（GetWebIdentityToken API）で OIDC JWT を取得し、 他のプロバイダーと同じトークン交換フローで CRISIS アクセストークンを取得します。 CRISIS のシークレットを AWS に保存する必要はありません。

AWS 側の前提条件

aws iam enable-outbound-web-identity-federation

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["sts:GetWebIdentityToken"],
      "Resource": "*"
    }
  ]
}

aws iam get-outbound-web-identity-federation-info \
  --query 'IssuerUrl' --output text

Federated Credential の設定

{
  "display_name": "AWS Lambda (crisis-integration)",
  "issuer_url": "https://<uuid>.tokens.sts.global.api.aws",
  "subject_filter": "arn:aws:iam::123456789012:role/crisis-integration-role",
  "audience": "https://crisis.jp"
}

issuer_url には上記で確認した AWS アカウント固有の STS 発行者 URL を指定します。 subject_filter には Lambda 実行ロールの IAM ロール ARN を指定します （GetWebIdentityToken が発行する JWT の sub クレーム）。

Lambda 関数の例（Python）

import json
import os
import urllib.request
import urllib.parse

import boto3

CREDENTIAL_ID = os.environ["CRISIS_CREDENTIAL_ID"]
REGION = os.environ.get("AWS_REGION", "us-east-1")


def lambda_handler(event, context):
    # Step 1: STS から OIDC JWT を取得
    sts = boto3.client("sts", region_name=REGION)
    resp = sts.get_web_identity_token(
        Audience=["https://crisis.jp"],
        SigningAlgorithm="RS256",
        DurationSeconds=900,
    )
    subject_token = resp["WebIdentityToken"]

    # Step 2: CRISIS Token Exchange
    crisis_token = exchange_token(CREDENTIAL_ID, subject_token)

    # Step 3: CRISIS API を呼び出す
    req = urllib.request.Request(
        "https://api.crisis.jp/v1/organizations/YOUR_ORG_ID/incidents",
        headers={"Authorization": f"Bearer {crisis_token}"},
    )
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read())


def exchange_token(credential_id: str, subject_token: str) -> str:
    """CRISIS Token Exchange エンドポイントを呼び出す"""
    data = urllib.parse.urlencode({
        "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
        "subject_token": subject_token,
        "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
    }).encode()

    req = urllib.request.Request(
        f"https://auth.crisis.jp/workload-identity/{credential_id}/token",
        data=data,
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        method="POST",
    )
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read())["access_token"]

Lambda 関数の例（Node.js）

import { STSClient, GetWebIdentityTokenCommand } from "@aws-sdk/client-sts";

const CREDENTIAL_ID = process.env.CRISIS_CREDENTIAL_ID;
const REGION = process.env.AWS_REGION || "us-east-1";

export async function handler(event) {
  // Step 1: STS から OIDC JWT を取得
  const sts = new STSClient({ region: REGION });
  const { WebIdentityToken } = await sts.send(
    new GetWebIdentityTokenCommand({
      Audience: ["https://crisis.jp"],
      SigningAlgorithm: "RS256",
      DurationSeconds: 900,
    })
  );

  // Step 2: CRISIS Token Exchange
  const body = new URLSearchParams({
    grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
    subject_token: WebIdentityToken,
    subject_token_type: "urn:ietf:params:oauth:token-type:jwt",
  });

  const tokenRes = await fetch(
    `https://auth.crisis.jp/workload-identity/${CREDENTIAL_ID}/token`,
    { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body }
  );
  const { access_token } = await tokenRes.json();

  // Step 3: CRISIS API を呼び出す
  const apiRes = await fetch(
    "https://api.crisis.jp/v1/organizations/YOUR_ORG_ID/incidents",
    { headers: { Authorization: `Bearer ${access_token}` } }
  );
  return await apiRes.json();
}

必要な Lambda 環境変数

IAM ロールのポリシー

Lambda の実行ロールには sts:GetWebIdentityToken の呼び出し権限が必要です。 Audience 条件キーで許可する audience を制限することを推奨します。

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["sts:GetWebIdentityToken"],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "sts:Audience": "https://crisis.jp"
        }
      }
    }
  ]
}

エラーレスポンス

トークン交換が失敗した場合、RFC 6749 §5.2 に準拠した JSON 形式でエラーが返ります。 error フィールドの値で失敗理由を判別できます。

{
  "error": "invalid_token",
  "error_description": "Token verification failed"
}

セキュリティのベストプラクティス

次のステップ