Cognito で AdminInitiateAuth を使ったときの SSO を試してみた

ClientServerSide:
  Type: AWS::Cognito::UserPoolClient
  Properties:
    ExplicitAuthFlows:
      - ALLOW_ADMIN_USER_PASSWORD_AUTH
      - ALLOW_REFRESH_TOKEN_AUTH
    AllowedOAuthFlowsUserPoolClient: false

検証環境/
├─ cognito-sso-verification.yaml   … CloudFormation テンプレート
├─ package.json
├─ env.example.sh   … 環境変数を CloudFormation の出力から取ってくるスクリプト
├─ a-app.js         … A システム（AdminInitiateAuth でログイン、ポート 3001）
└─ b-app.js         … B システム（マネージドログインでログイン、ポート 3000）

mkdir cognito-sso-test && cd cognito-sso-test
# ここに cognito-sso-verification.yaml / package.json / env.example.sh / a-app.js / b-app.js を保存する
ls
# a-app.js  b-app.js  env.example.sh  package.json  cognito-sso-verification.yaml

npm install

aws cloudformation deploy \
  --template-file cognito-sso-verification.yaml \
  --stack-name cognito-sso-verification \
  --capabilities CAPABILITY_IAM \
  --region ap-northeast-1 \
  --parameter-overrides \
      DomainPrefix=sso-verify-<任意の文字列> \
      TestUserEmail=test@example.com \
      TestUserPassword='<パスワード>'

cp env.example.sh env.local.sh
source ./env.local.sh

# ターミナル 1：B システム
PORT=3000 node b-app.js
# B システム : http://localhost:3000
#   issuer       : https://cognito-idp.ap-northeast-1.amazonaws.com/ap-northeast-1_xxxxxxxxx
#   redirect_uri : http://localhost:3000/callback

# ターミナル 2：A システム
PORT=3001 node a-app.js
# A システム : http://localhost:3001
#   認証方式: AdminInitiateAuth（サーバーサイド） / Cognito ドメインは踏まない

aws logs tail "$(aws cloudformation describe-stacks --stack-name cognito-sso-verification --region ap-northeast-1 \
  --query "Stacks[0].Outputs[?OutputKey=='TriggerLogGroup'].OutputValue" --output text)" \
  --region ap-northeast-1 --since 10m --filter-pattern TRIGGER_FIRED

aws cloudformation delete-stack --stack-name cognito-sso-verification --region ap-northeast-1

AWSTemplateFormatVersion: '2010-09-09'
Description: >
  Cognito OIDC SSO 検証環境(API 方式版).
  A システムは AdminInitiateAuth でサーバーからログインし、B システムはマネージドログインを使う。
  A システムでログインしたあと、B システムにログイン画面なしで入れるかを確かめる。

Parameters:

  DomainPrefix:
    Type: String
    Description: Cognito プレフィックスドメイン(全リージョンで一意)
    AllowedPattern: '^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$'

  TestUserEmail:
    Type: String
    Description: 検証用ユーザーのメールアドレス(サインイン ID になる)
    AllowedPattern: '^[^@]+@[^@]+\.[^@]+$'

  TestUserPassword:
    Type: String
    NoEcho: true
    Description: 検証用ユーザーのパスワード(12文字以上・大文字・小文字・数字・記号を各1文字以上)
    MinLength: 12

  TestUserName:
    Type: String
    Default: 検証 太郎
    Description: 検証用ユーザーの表示名(name 属性)

  CallbackUrl:
    Type: String
    Default: http://localhost:3000/callback
    Description: B システムのコールバック URL

Resources:

  # --------------------------------------------------------------------------
  # Lambda トリガー(発火の可視化用)
  # --------------------------------------------------------------------------

  TriggerLoggerRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

  TriggerLoggerFunction:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: python3.12
      Handler: index.handler
      Role: !GetAtt TriggerLoggerRole.Arn
      Timeout: 5
      Code:
        ZipFile: |
          import json

          def handler(event, context):
              print("TRIGGER_FIRED " + json.dumps({
                  "triggerSource": event.get("triggerSource", ""),
                  "clientId": (event.get("callerContext") or {}).get("clientId"),
                  "userName": event.get("userName"),
              }, ensure_ascii=False))
              return event

  # SourceArn に UserPool を指定すると循環参照になるため SourceAccount のみで許可する
  TriggerLoggerPermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !GetAtt TriggerLoggerFunction.Arn
      Action: lambda:InvokeFunction
      Principal: cognito-idp.amazonaws.com
      SourceAccount: !Ref AWS::AccountId

  # --------------------------------------------------------------------------
  # ユーザープールとドメイン
  # --------------------------------------------------------------------------

  UserPool:
    Type: AWS::Cognito::UserPool
    Properties:
      UserPoolName: !Sub '${AWS::StackName}-user-pool'
      UsernameAttributes:
        - email
      AutoVerifiedAttributes:
        - email
      AdminCreateUserConfig:
        AllowAdminCreateUserOnly: true
      MfaConfiguration: 'OFF'
      Schema:
        - Name: email
          AttributeDataType: String
          Required: true
          Mutable: true
      Policies:
        PasswordPolicy:
          MinimumLength: 12
          RequireUppercase: true
          RequireLowercase: true
          RequireNumbers: true
          RequireSymbols: true
          TemporaryPasswordValidityDays: 7
      LambdaConfig:
        PreAuthentication: !GetAtt TriggerLoggerFunction.Arn
        PostAuthentication: !GetAtt TriggerLoggerFunction.Arn
        PreTokenGeneration: !GetAtt TriggerLoggerFunction.Arn
    DependsOn: TriggerLoggerPermission

  # ManagedLoginVersion を省略するとクラシックのホストされた UI(1)になる。
  # prompt=none はマネージドログイン(2)でのみ使える
  UserPoolDomain:
    Type: AWS::Cognito::UserPoolDomain
    Properties:
      UserPoolId: !Ref UserPool
      Domain: !Ref DomainPrefix
      ManagedLoginVersion: 2

  # CFn / SDK で作った App Client にはブランディングが自動で作られないため明示的に作る
  OidcClientBranding:
    Type: AWS::Cognito::ManagedLoginBranding
    DependsOn: UserPoolDomain
    Properties:
      UserPoolId: !Ref UserPool
      ClientId: !Ref ClientOidc
      UseCognitoProvidedValues: true

  # --------------------------------------------------------------------------
  # App Client A: A システム(AdminInitiateAuth でログインする既存アプリ役)
  # --------------------------------------------------------------------------

  ClientServerSide:
    Type: AWS::Cognito::UserPoolClient
    Properties:
      ClientName: !Sub '${AWS::StackName}-a-system'
      UserPoolId: !Ref UserPool
      GenerateSecret: true
      ExplicitAuthFlows:
        - ALLOW_ADMIN_USER_PASSWORD_AUTH
        - ALLOW_REFRESH_TOKEN_AUTH
      # マネージドログインを使わないため OAuth は無効にする
      AllowedOAuthFlowsUserPoolClient: false

  # --------------------------------------------------------------------------
  # App Client B: B システム(SaaS 役。マネージドログインでログインする)
  # --------------------------------------------------------------------------

  ClientOidc:
    Type: AWS::Cognito::UserPoolClient
    Properties:
      ClientName: !Sub '${AWS::StackName}-b-system'
      UserPoolId: !Ref UserPool
      GenerateSecret: true
      AllowedOAuthFlowsUserPoolClient: true
      AllowedOAuthFlows:
        - code
      AllowedOAuthScopes:
        - openid
        - email
        - profile
      CallbackURLs:
        - !Ref CallbackUrl
      LogoutURLs:
        - !Ref CallbackUrl
      SupportedIdentityProviders:
        - COGNITO
      # name を入れないと、profile スコープを要求しても ID Token に name が載らない
      ReadAttributes:
        - email
        - email_verified
        - name

  # --------------------------------------------------------------------------
  # 検証用ユーザーの作成(カスタムリソース)
  # --------------------------------------------------------------------------

  TestUserRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: manage-test-user
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - cognito-idp:AdminCreateUser
                  - cognito-idp:AdminSetUserPassword
                  - cognito-idp:AdminUpdateUserAttributes
                  - cognito-idp:AdminDeleteUser
                Resource: !GetAtt UserPool.Arn

  TestUserFunction:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: python3.12
      Handler: index.handler
      Role: !GetAtt TestUserRole.Arn
      Timeout: 30
      Code:
        ZipFile: |
          import boto3
          import cfnresponse

          idp = boto3.client('cognito-idp')

          def handler(event, context):
              props = event.get('ResourceProperties', {})
              pool = props.get('UserPoolId')
              email = props.get('Email')
              password = props.get('Password')
              name = props.get('Name') or ''
              attrs = [
                  {'Name': 'email', 'Value': email},
                  {'Name': 'email_verified', 'Value': 'true'},
              ]
              if name:
                  attrs.append({'Name': 'name', 'Value': name})
              try:
                  if event['RequestType'] in ('Create', 'Update'):
                      try:
                          idp.admin_create_user(
                              UserPoolId=pool,
                              Username=email,
                              UserAttributes=attrs,
                              MessageAction='SUPPRESS',
                          )
                      except idp.exceptions.UsernameExistsException:
                          idp.admin_update_user_attributes(
                              UserPoolId=pool, Username=email, UserAttributes=attrs
                          )
                      idp.admin_set_user_password(
                          UserPoolId=pool,
                          Username=email,
                          Password=password,
                          Permanent=True,
                      )
                  elif event['RequestType'] == 'Delete':
                      try:
                          idp.admin_delete_user(UserPoolId=pool, Username=email)
                      except idp.exceptions.UserNotFoundException:
                          pass
                  cfnresponse.send(event, context, cfnresponse.SUCCESS, {}, email)
              except Exception as e:
                  print('ERROR: %s' % e)
                  status = cfnresponse.SUCCESS if event['RequestType'] == 'Delete' else cfnresponse.FAILED
                  cfnresponse.send(event, context, status, {'Error': str(e)}, email)

  TestUser:
    Type: AWS::CloudFormation::CustomResource
    Properties:
      ServiceToken: !GetAtt TestUserFunction.Arn
      UserPoolId: !Ref UserPool
      Email: !Ref TestUserEmail
      Password: !Ref TestUserPassword
      Name: !Ref TestUserName

Outputs:

  UserPoolId:
    Value: !Ref UserPool

  ManagedLoginDomain:
    Value: !Sub 'https://${DomainPrefix}.auth.${AWS::Region}.amazoncognito.com'

  ClientIdServerSide:
    Value: !Ref ClientServerSide

  ClientIdOidc:
    Value: !Ref ClientOidc

  TriggerLogGroup:
    Value: !Sub '/aws/lambda/${TriggerLoggerFunction}'

{
  "name": "cognito-sso-verification",
  "version": "1.0.0",
  "description": "Cognito の OIDC SSO 検証用。A システム（サーバーサイド認証）と B システム（OIDC RP）の最小アプリ",
  "private": true,
  "type": "commonjs",
  "engines": {
    "node": ">=18"
  },
  "scripts": {
    "a": "node a-app.js",
    "b": "node b-app.js"
  },
  "dependencies": {
    "@aws-sdk/client-cognito-identity-provider": "^3.700.0",
    "express": "^4.21.2"
  }
}

# 検証環境の環境変数テンプレート
#   cp env.example.sh env.local.sh してから source する
#   env.local.sh にはクライアントシークレットが入るため、共有しないこと

STACK=cognito-sso-verification
out() { aws cloudformation describe-stacks --stack-name "$STACK" \
  --query "Stacks[0].Outputs[?OutputKey=='$1'].OutputValue" --output text; }
secret() { aws cognito-idp describe-user-pool-client \
  --user-pool-id "$USER_POOL_ID" --client-id "$1" \
  --query 'UserPoolClient.ClientSecret' --output text; }

export AWS_REGION=ap-northeast-1
export USER_POOL_ID=$(out UserPoolId)
export COGNITO_DOMAIN=$(out ManagedLoginDomain)
export A_CLIENT_ID=$(out ClientIdServerSide)
export B_CLIENT_ID=$(out ClientIdOidc)
export A_CLIENT_SECRET=$(secret "$A_CLIENT_ID")
export B_CLIENT_SECRET=$(secret "$B_CLIENT_ID")

echo "UserPool : $USER_POOL_ID"
echo "Domain   : $COGNITO_DOMAIN"
echo "A client: $A_CLIENT_ID"
echo "B client: $B_CLIENT_ID"

/**
 * A システム : サーバーサイド認証（AdminInitiateAuth）でログインする Web アプリ
 *
 *   - ログイン画面は自作
 *   - 認証は AdminInitiateAuth（サーバーサイド API）で行う
 *   - ログイン状態は A システム独自の Cookie で保持する
 *   - ブラウザは Cognito のドメインを一度も訪れない
 *
 * 起動: PORT=3001 node a-app.js
 */

const crypto = require('crypto');
const express = require('express');
const {
  CognitoIdentityProviderClient,
  AdminInitiateAuthCommand,
} = require('@aws-sdk/client-cognito-identity-provider');

const {
  AWS_REGION = 'ap-northeast-1',
  USER_POOL_ID,
  A_CLIENT_ID,
  A_CLIENT_SECRET,
  B_URL = 'http://localhost:3000',
  PORT = 3001,
} = process.env;

for (const [k, v] of Object.entries({ USER_POOL_ID, A_CLIENT_ID })) {
  if (!v) {
    console.error(`環境変数 ${k} が未設定です。先に source ./env.local.sh を実行してください。`);
    process.exit(1);
  }
}

const idp = new CognitoIdentityProviderClient({ region: AWS_REGION });

/** App Client にシークレットがある場合に必要な SECRET_HASH を算出する */
function secretHash(username) {
  if (!A_CLIENT_SECRET) return undefined;
  return crypto
    .createHmac('sha256', A_CLIENT_SECRET)
    .update(username + A_CLIENT_ID)
    .digest('base64');
}

/** JWT のペイロード部だけを取り出す（検証はしない。表示用） */
function decodeJwtPayload(jwt) {
  const [, payload] = jwt.split('.');
  return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
}

// 自前のサーバーサイドセッション（検証用途のためメモリ保持）
const sessions = new Map();

const app = express();
app.use(express.urlencoded({ extended: false }));

/** リクエストから自前セッションを取り出す */
function currentSession(req) {
  const m = /(?:^|;\s*)a_session=([^;]+)/.exec(req.headers.cookie || '');
  return m ? sessions.get(m[1]) : undefined;
}

const page = (body) => `<!doctype html>
<meta charset="utf-8">
<title>A システム（サーバーサイド認証）</title>
<style>
  body { font-family: system-ui, sans-serif; max-width: 760px; margin: 40px auto; padding: 0 16px; line-height: 1.7; }
  .tag { display: inline-block; background: #0b7285; color: #fff; padding: 2px 10px; border-radius: 4px; font-size: 13px; }
  pre { background: #f1f3f5; padding: 12px; border-radius: 6px; overflow-x: auto; font-size: 13px; }
  .note { background: #fff3bf; padding: 12px; border-radius: 6px; }
  a.btn { display: inline-block; background: #0b7285; color: #fff; padding: 10px 18px; border-radius: 6px; text-decoration: none; }
  input { padding: 8px; width: 320px; margin-bottom: 8px; }
  button { padding: 8px 20px; }
</style>
<p><span class="tag">A システム</span> サーバーサイド認証（AdminInitiateAuth）</p>
${body}`;

app.get('/', (req, res) => {
  const s = currentSession(req);

  if (!s) {
    return res.send(
      page(`
      <h1>ログイン</h1>
      <p>自作のログイン画面です。認証は <code>AdminInitiateAuth</code> でサーバーサイドから行います。</p>
      <form method="POST" action="/login">
        <div><input name="email" type="email" placeholder="メールアドレス" required></div>
        <div><input name="password" type="password" placeholder="パスワード" required></div>
        <button type="submit">ログイン</button>
      </form>
      <div class="note">
        この画面でログインしても、ブラウザは Cognito のドメインを訪れません。<br>
        そのため <b>Cognito のログイン済みセッションは作られません</b>。
      </div>
    `)
    );
  }

  return res.send(
    page(`
    <h1>ログイン済み</h1>
    <p>A システム独自のセッションでログイン状態を保持しています。</p>
    <h2>ID Token の claim</h2>
    <pre>${JSON.stringify(s.idTokenClaims, null, 2)}</pre>
    <h2>検証: ここから B システムへ移動する</h2>
    <p><a class="btn" href="${B_URL}">B システムへ →</a></p>
    <div class="note">
      <b>期待される結果:</b> Cognito のログイン画面が表示される（＝ SSO が成立しない）。<br>
      開発者ツールの Network タブで、<code>/oauth2/authorize</code> のリクエストに
      ログイン済みの <code>cognito</code> Cookie が無いことも確認してください。
    </div>
    <p><a href="/logout">A システムからログアウト</a></p>
  `)
  );
});

app.post('/login', async (req, res) => {
  const { email, password } = req.body;
  try {
    const out = await idp.send(
      new AdminInitiateAuthCommand({
        UserPoolId: USER_POOL_ID,
        ClientId: A_CLIENT_ID,
        AuthFlow: 'ADMIN_USER_PASSWORD_AUTH',
        AuthParameters: {
          USERNAME: email,
          PASSWORD: password,
          ...(secretHash(email) ? { SECRET_HASH: secretHash(email) } : {}),
        },
      })
    );

    // 【重要】レスポンスは JSON でトークンが返るだけ。Set-Cookie は発生しない。
    const result = out.AuthenticationResult;
    if (!result) {
      return res.status(400).send(
        page(`<h1>追加のチャレンジが必要です</h1><pre>${JSON.stringify(out, null, 2)}</pre>`)
      );
    }

    const sid = crypto.randomUUID();
    sessions.set(sid, { idTokenClaims: decodeJwtPayload(result.IdToken) });

    // A システム独自のセッション Cookie（Cognito とは無関係）
    res.setHeader('Set-Cookie', `a_session=${sid}; HttpOnly; Path=/; SameSite=Lax`);
    return res.redirect('/');
  } catch (e) {
    return res
      .status(401)
      .send(page(`<h1>ログイン失敗</h1><pre>${e.name}: ${e.message}</pre><p><a href="/">戻る</a></p>`));
  }
});

app.get('/logout', (req, res) => {
  const m = /(?:^|;\s*)a_session=([^;]+)/.exec(req.headers.cookie || '');
  if (m) sessions.delete(m[1]);
  res.setHeader('Set-Cookie', 'a_session=; Max-Age=0; Path=/');
  res.redirect('/');
});

app.listen(PORT, () => {
  console.log(`A システム : http://localhost:${PORT}`);
  console.log(`  認証方式: AdminInitiateAuth（サーバーサイド） / Cognito ドメインは踏まない`);
});

/**
 * B システム : OIDC RP（SaaS 役）
 *
 * SaaS の OIDC SSO と同じ流れでログインする。
 *   1. 未認証なら Cognito の /oauth2/authorize へ「ブラウザを」リダイレクトする
 *   2. コールバックで認可コードを受け取り、state を照合する
 *   3. トークンエンドポイントへ「サーバー間で」直接リクエストし、code を交換する
 *   4. ID Token の claim でユーザーを識別する
 *
 * ※ 本来 RP は JWKS から公開鍵を取得して署名を検証します。
 *    本アプリは claim の中身を見ることが目的のため、署名検証は省略しています。
 *    検証環境専用であり、そのまま本番利用しないでください。
 *
 * 起動: PORT=3000 node b-app.js
 */

const crypto = require('crypto');
const express = require('express');

const {
  AWS_REGION = 'ap-northeast-1',
  USER_POOL_ID,
  COGNITO_DOMAIN, // 例: https://xxxx.auth.ap-northeast-1.amazoncognito.com
  B_CLIENT_ID,
  B_CLIENT_SECRET,
  A_URL = 'http://localhost:3001',
  PORT = 3000,
} = process.env;

for (const [k, v] of Object.entries({ USER_POOL_ID, COGNITO_DOMAIN, B_CLIENT_ID })) {
  if (!v) {
    console.error(`環境変数 ${k} が未設定です。先に source ./env.local.sh を実行してください。`);
    process.exit(1);
  }
}

const REDIRECT_URI = `http://localhost:${PORT}/callback`;
const ISSUER = `https://cognito-idp.${AWS_REGION}.amazonaws.com/${USER_POOL_ID}`;

function decodeJwtPayload(jwt) {
  const [, payload] = jwt.split('.');
  return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
}

// B システムのセッションと、認可リクエストの一時状態（検証用途のためメモリ保持）
const sessions = new Map();
const pending = new Map();

const app = express();

function currentSession(req) {
  const m = /(?:^|;\s*)b_session=([^;]+)/.exec(req.headers.cookie || '');
  return m ? sessions.get(m[1]) : undefined;
}

const page = (body) => `<!doctype html>
<meta charset="utf-8">
<title>B システム（OIDC RP）</title>
<style>
  body { font-family: system-ui, sans-serif; max-width: 760px; margin: 40px auto; padding: 0 16px; line-height: 1.7; }
  .tag { display: inline-block; background: #862e9c; color: #fff; padding: 2px 10px; border-radius: 4px; font-size: 13px; }
  pre { background: #f1f3f5; padding: 12px; border-radius: 6px; overflow-x: auto; font-size: 13px; }
  .note { background: #fff3bf; padding: 12px; border-radius: 6px; }
  .err { background: #ffe3e3; padding: 12px; border-radius: 6px; }
  a.btn { display: inline-block; background: #862e9c; color: #fff; padding: 10px 18px; border-radius: 6px; text-decoration: none; margin-right: 8px; }
</style>
<p><span class="tag">B システム</span> OIDC RP（SaaS 役）</p>
${body}`;

/** 認可リクエスト URL を組み立てる */
function buildAuthorizeUrl({ state, nonce, prompt }) {
  const p = new URLSearchParams({
    response_type: 'code',
    client_id: B_CLIENT_ID,
    redirect_uri: REDIRECT_URI,
    scope: 'openid email profile',
    state,
    nonce,
  });
  if (prompt) p.set('prompt', prompt);
  return `${COGNITO_DOMAIN}/oauth2/authorize?${p.toString()}`;
}

app.get('/', (req, res) => {
  const s = currentSession(req);

  if (!s) {
    return res.send(
      page(`
      <h1>未認証です</h1>
      <p>B システム側から認証を開始します（SP-initiated）。</p>
      <p>
        <a class="btn" href="/login">サインイン（通常）</a>
        <a class="btn" href="/login?prompt=none">サイレント認証（prompt=none）</a>
      </p>
      <div class="note">
        <b>通常:</b> Cognito にログイン済みでなければログイン画面が出ます。<br>
        <b>prompt=none:</b> ログイン済みでなければ <code>error=login_required</code> が返ります（画面は出ません）。
      </div>
      <p><a href="${A_URL}">← A システムへ</a></p>
    `)
    );
  }

  return res.send(
    page(`
    <h1>ログイン済み（B システムのセッション確立）</h1>
    <h2>ID Token の claim</h2>
    <pre>${JSON.stringify(s.idTokenClaims, null, 2)}</pre>
    <div class="note">
      <b>確認ポイント:</b> <code>name</code> が含まれているか。<br>
      App Client の読み取り許可に <code>name</code> が無い場合、
      <code>profile</code> スコープを要求しても claim は入りません。
    </div>
    <h2>再検証</h2>
    <p>B システムのセッションだけ破棄すると、Cognito のセッションの有無を再確認できます。</p>
    <p>
      <a class="btn" href="/logout-b">B システムのセッションのみ破棄</a>
      <a href="${A_URL}">A システムへ</a>
    </p>
  `)
  );
});

app.get('/login', (req, res) => {
  const state = crypto.randomUUID();
  const nonce = crypto.randomUUID();
  pending.set(state, { nonce, at: Date.now() });

  const url = buildAuthorizeUrl({ state, nonce, prompt: req.query.prompt });
  console.log(`[B システム] → 302 ${url}`);

  // ブラウザ経由のフロントチャネル
  res.redirect(url);
});

app.get('/callback', async (req, res) => {
  const { code, state, error, error_description: desc } = req.query;

  if (error) {
    return res.status(400).send(
      page(`
      <h1>認可エラー</h1>
      <div class="err">
        <p><b>error:</b> <code>${error}</code></p>
        ${desc ? `<p><b>error_description:</b> ${desc}</p>` : ''}
      </div>
      <div class="note">
        <code>login_required</code> が返った場合、<b>Cognito にログイン済みのセッションが無い</b>ことを意味します。
        <code>prompt=none</code> ではサイレント認証できません。
      </div>
      <p><a href="/">戻る</a></p>
    `)
    );
  }

  const p = pending.get(state);
  if (!p) {
    return res.status(400).send(page(`<h1>state が不正です</h1><p><a href="/">戻る</a></p>`));
  }
  pending.delete(state);

  // ここだけがサーバー間の直接通信（バックチャネル）
  const body = new URLSearchParams({
    grant_type: 'authorization_code',
    client_id: B_CLIENT_ID,
    code,
    redirect_uri: REDIRECT_URI,
  });
  const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
  if (B_CLIENT_SECRET) {
    const basic = Buffer.from(`${B_CLIENT_ID}:${B_CLIENT_SECRET}`).toString('base64');
    headers.Authorization = `Basic ${basic}`;
  }

  const tokenRes = await fetch(`${COGNITO_DOMAIN}/oauth2/token`, {
    method: 'POST',
    headers,
    body,
  });
  const tokens = await tokenRes.json();

  if (!tokenRes.ok) {
    return res
      .status(400)
      .send(page(`<h1>トークン交換に失敗</h1><pre>${JSON.stringify(tokens, null, 2)}</pre>`));
  }

  const claims = decodeJwtPayload(tokens.id_token);
  if (claims.nonce !== p.nonce) {
    return res.status(400).send(page(`<h1>nonce が一致しません</h1>`));
  }
  if (claims.iss !== ISSUER) {
    return res
      .status(400)
      .send(page(`<h1>iss が一致しません</h1><pre>expected: ${ISSUER}\nactual:   ${claims.iss}</pre>`));
  }

  const sid = crypto.randomUUID();
  sessions.set(sid, { idTokenClaims: claims });
  res.setHeader('Set-Cookie', `b_session=${sid}; HttpOnly; Path=/; SameSite=Lax`);
  res.redirect('/');
});

app.get('/logout-b', (req, res) => {
  const m = /(?:^|;\s*)b_session=([^;]+)/.exec(req.headers.cookie || '');
  if (m) sessions.delete(m[1]);
  res.setHeader('Set-Cookie', 'b_session=; Max-Age=0; Path=/');
  res.redirect('/');
});

app.listen(PORT, () => {
  console.log(`B システム : http://localhost:${PORT}`);
  console.log(`  issuer       : ${ISSUER}`);
  console.log(`  redirect_uri : ${REDIRECT_URI}`);
});