merge: shared broker and deployment contracts

.gitignore

@@ -4,6 +4,9 @@
 *.iml
 
 backend/target/
+token-mediator/target/
+**/node_modules/
+frontend/dist/
 build/
 e2e/node_modules/
 google-e2e/node_modules/

README.md

@@ -103,3 +103,22 @@ Keycloak을 잠시 중지하고 export한 뒤 자동으로 다시 올립니다.
 
 runtime export에는 실제 client secret과 credential hash가 포함될 수 있어
 gitignored `build/keycloak-export/`에 권한 `0600`으로만 저장됩니다.
+
+## AP2: Token-Mediating Backend
+
+`develop-keycloak-pattern2`의 Spring confidential client는
+`http://localhost:8082`에서 실행됩니다. 브라우저는 로그인 redirect와
+HttpOnly `AP2_SESSION`만 사용하고, authorization code 교환과
+access/refresh token 보관은 backend가 담당합니다.
+
+```bash
+./scripts/verify-pattern2.sh
+```
+
+`/token/boundary`는 실제 token 값을 반환하지 않고 서버 저장 여부만 보여줍니다.
+`/token/access`는 access token과 만료 메타데이터만 `no-store`로 전달하며,
+refresh token은 반환하지 않습니다. 브라우저는 이 access token으로
+`http://localhost:8081/api/me`를 직접 호출합니다.
+
+자세한 token 경계와 실험 항목은
+[`docs/ap2-token-boundary.md`](docs/ap2-token-boundary.md)를 참고하세요.

backend/src/main/java/com/example/keycloakpattern/AudienceValidator.java

@@ -0,0 +1,29 @@
+package com.example.keycloakpattern;
+
+import org.springframework.security.oauth2.core.OAuth2Error;
+import org.springframework.security.oauth2.core.OAuth2TokenValidator;
+import org.springframework.security.oauth2.core.OAuth2TokenValidatorResult;
+import org.springframework.security.oauth2.jwt.Jwt;
+
+final class AudienceValidator implements OAuth2TokenValidator<Jwt> {
+
+    private static final OAuth2Error MISSING_AUDIENCE = new OAuth2Error(
+        "invalid_token",
+        "The required resource audience is missing",
+        null
+    );
+
+    private final String expectedAudience;
+
+    AudienceValidator(String expectedAudience) {
+        this.expectedAudience = expectedAudience;
+    }
+
+    @Override
+    public OAuth2TokenValidatorResult validate(Jwt jwt) {
+        if (jwt.getAudience().contains(expectedAudience)) {
+            return OAuth2TokenValidatorResult.success();
+        }
+        return OAuth2TokenValidatorResult.failure(MISSING_AUDIENCE);
+    }
+}

backend/src/main/java/com/example/keycloakpattern/JwtDecoderConfig.java

@@ -0,0 +1,31 @@
+package com.example.keycloakpattern;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.oauth2.core.DelegatingOAuth2TokenValidator;
+import org.springframework.security.oauth2.core.OAuth2TokenValidator;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.security.oauth2.jwt.JwtDecoder;
+import org.springframework.security.oauth2.jwt.JwtValidators;
+import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
+
+@Configuration
+public class JwtDecoderConfig {
+
+    @Bean
+    JwtDecoder jwtDecoder(
+        @Value("${spring.security.oauth2.resourceserver.jwt.issuer-uri}") String issuer,
+        @Value("${spring.security.oauth2.resourceserver.jwt.jwk-set-uri}") String jwkSetUri,
+        @Value("${security.expected-audience}") String expectedAudience
+    ) {
+        NimbusJwtDecoder decoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
+        OAuth2TokenValidator<Jwt> issuerAndTimestamp =
+            JwtValidators.createDefaultWithIssuer(issuer);
+        OAuth2TokenValidator<Jwt> audience = new AudienceValidator(expectedAudience);
+        decoder.setJwtValidator(
+            new DelegatingOAuth2TokenValidator<>(issuerAndTimestamp, audience)
+        );
+        return decoder;
+    }
+}

backend/src/main/java/com/example/keycloakpattern/SecurityConfig.java

@@ -1,11 +1,16 @@
 package com.example.keycloakpattern;
 
+import java.util.List;
+
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.http.SessionCreationPolicy;
 import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
 
 @Configuration
 public class SecurityConfig {
@@ -13,6 +18,7 @@ public class SecurityConfig {
     @Bean
     SecurityFilterChain apiSecurity(HttpSecurity http) throws Exception {
         return http
+            .cors(Customizer.withDefaults())
             .csrf(csrf -> csrf.disable())
             .sessionManagement(session ->
                 session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
@@ -24,4 +30,16 @@ public class SecurityConfig {
             .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
             .build();
     }
+
+    @Bean
+    CorsConfigurationSource corsConfigurationSource() {
+        CorsConfiguration configuration = new CorsConfiguration();
+        configuration.setAllowedOrigins(List.of("http://localhost:8082"));
+        configuration.setAllowedMethods(List.of("GET", "OPTIONS"));
+        configuration.setAllowedHeaders(List.of("Authorization", "Content-Type"));
+
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/api/**", configuration);
+        return source;
+    }
 }

backend/src/main/resources/application.yml

@@ -11,6 +11,9 @@ spring:
           issuer-uri: ${SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI:http://localhost:8080/realms/keycloak-patterns}
           jwk-set-uri: ${SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI:http://localhost:8080/realms/keycloak-patterns/protocol/openid-connect/certs}
 
+security:
+  expected-audience: ${SECURITY_EXPECTED_AUDIENCE:keycloak-pattern-api}
+
 management:
   endpoint:
     health:

backend/src/test/java/com/example/keycloakpattern/AudienceValidatorTest.java

@@ -0,0 +1,49 @@
+package com.example.keycloakpattern;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.security.oauth2.core.OAuth2TokenValidatorResult;
+import org.springframework.security.oauth2.jwt.Jwt;
+
+class AudienceValidatorTest {
+
+    private final AudienceValidator validator =
+        new AudienceValidator("keycloak-pattern-api");
+
+    @Test
+    void acceptsRequiredAudience() {
+        OAuth2TokenValidatorResult result = validator.validate(jwtWithAudience(
+            List.of("account", "keycloak-pattern-api")
+        ));
+
+        assertThat(result.hasErrors()).isFalse();
+    }
+
+    @Test
+    void rejectsForeignAudience() {
+        OAuth2TokenValidatorResult result = validator.validate(jwtWithAudience(
+            List.of("another-resource")
+        ));
+
+        assertThat(result.hasErrors()).isTrue();
+        assertThat(result.getErrors())
+            .extracting(error -> error.getErrorCode())
+            .containsExactly("invalid_token");
+    }
+
+    private Jwt jwtWithAudience(List<String> audience) {
+        Instant now = Instant.now();
+        return new Jwt(
+            "test-token",
+            now,
+            now.plusSeconds(300),
+            Map.of("alg", "none"),
+            Map.of("sub", "test-subject", "aud", audience)
+        );
+    }
+}

deploy/reverse-proxy/keycloak.env.example

@@ -0,0 +1,6 @@
+# Keycloak receives HTTP only from the trusted reverse proxy.
+KC_HTTP_ENABLED=true
+KC_PROXY_HEADERS=xforwarded
+KC_HOSTNAME=https://auth.example.test
+KC_HOSTNAME_STRICT=true
+

deploy/reverse-proxy/nginx-keycloak.conf

@@ -0,0 +1,14 @@
+server {
+    listen 8080;
+    server_name auth.example.test;
+
+    location / {
+        proxy_pass http://keycloak:8080;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Forwarded-Host $host;
+        proxy_set_header X-Forwarded-Port 443;
+        proxy_set_header X-Forwarded-Proto https;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+}

deploy/tls/Caddyfile

@@ -0,0 +1,10 @@
+auth.example.test {
+	tls /etc/tls/tls.crt /etc/tls/tls.key
+
+	reverse_proxy keycloak:8080 {
+		header_up Host {host}
+		header_up X-Forwarded-Host {host}
+		header_up X-Forwarded-Port 443
+		header_up X-Forwarded-Proto https
+	}
+}

deploy/tls/nginx.conf

@@ -0,0 +1,21 @@
+events {}
+
+http {
+    server {
+        listen 443 ssl;
+        server_name auth.example.test;
+
+        ssl_certificate /etc/tls/tls.crt;
+        ssl_certificate_key /etc/tls/tls.key;
+        ssl_protocols TLSv1.2 TLSv1.3;
+
+        location / {
+            proxy_pass http://keycloak:8080;
+            proxy_set_header Host $host;
+            proxy_set_header X-Forwarded-Host $host;
+            proxy_set_header X-Forwarded-Port 443;
+            proxy_set_header X-Forwarded-Proto https;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        }
+    }
+}

deploy/tunnel/cloudflared-config.yml

@@ -0,0 +1,7 @@
+tunnel: 00000000-0000-0000-0000-000000000000
+credentials-file: /etc/cloudflared/00000000-0000-0000-0000-000000000000.json
+
+ingress:
+  - hostname: auth.example.test
+    service: http://reverse-proxy:8080
+  - service: http_status:404

docker-compose.yml

@@ -88,6 +88,29 @@ services:
       - keycloak-net
     restart: unless-stopped
 
+  token-mediator:
+    build:
+      context: ./token-mediator
+    environment:
+      SERVER_PORT: "8082"
+      KEYCLOAK_CLIENT_SECRET: ${TOKEN_MEDIATING_CLIENT_SECRET:?set TOKEN_MEDIATING_CLIENT_SECRET in .env}
+    ports:
+      - "127.0.0.1:8082:8082"
+    depends_on:
+      keycloak:
+        condition: service_healthy
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - wget -q -O - http://127.0.0.1:8082/actuator/health | grep -q '"status":"UP"'
+      interval: 10s
+      timeout: 5s
+      retries: 12
+      start_period: 20s
+    networks:
+      - keycloak-net
+    restart: unless-stopped
+
   nginx:
     build:
       context: ./frontend

docs/account-linking-sub-vs-email.md

@@ -0,0 +1,18 @@
+# Federated account key: `sub`, not email
+
+외부 IdP의 email은 표시·연락 속성이지 계정 식별자나 자동 연결 증명이 아니다.
+Keycloak의 federated identity는 provider alias와 provider user ID(`sub`)를
+로컬 사용자에 연결한다.
+
+정책:
+
+- 신규 identity의 email이 기존 로컬 계정과 충돌하면 기존 계정의 인증을 다시
+  요구하는 기본 First Broker Login flow를 사용한다.
+- `Automatically Set Existing User`를 production flow에 넣지 않는다.
+- upstream email 변경은 같은 `sub`의 계정 귀속을 바꾸지 않는다.
+- 마지막 로그인 수단을 unlink하는 UI에서는 먼저 다른 인증 수단을 등록하도록
+  안내한다.
+
+`verify-account-linking-sub-vs-email.sh`는 mock IdP 사용자의 email을 실제로
+변경하고 다시 로그인한다. 로컬 사용자 ID가 유지되고 federated `userId`가
+upstream `sub`와 같은지 확인한 후 원래 email을 복구한다.

docs/ap2-token-boundary.md

@@ -0,0 +1,38 @@
+# AP2 · Token-Mediating Backend
+
+## 책임 경계
+
+1. 브라우저는 Spring backend의 `/oauth2/authorization/keycloak`로 로그인을
+   시작합니다.
+2. Keycloak은 authorization code를 Spring callback으로 전달합니다.
+3. confidential client인 Spring backend가 client secret을 사용해 code를
+   교환하고 access/refresh token을 `OAuth2AuthorizedClientService`에
+   보관합니다.
+4. 브라우저가 `/token/access`를 호출하면 backend는 현재 access token,
+   token type, 만료 시각만 `Cache-Control: no-store`로 반환합니다.
+5. 브라우저는 전달받은 access token을 메모리에서만 사용해 Resource
+   Server를 직접 호출합니다.
+
+refresh token은 브라우저 응답, Web Storage, cookie에 전달되지 않습니다.
+access token이 만료되면 `OAuth2AuthorizedClientManager`가 서버에 보관된
+refresh token으로 갱신한 뒤 새 access token만 전달할 수 있습니다.
+
+## 확인할 보안 속성
+
+- Keycloak client는 `client_secret_basic`을 사용하는 confidential client입니다.
+- Resource Server는 서명, issuer, timestamp와 함께
+  `aud=keycloak-pattern-api`를 검증합니다.
+- CORS는 AP2 UI origin인 `http://localhost:8082`의 `GET`만 허용합니다.
+- access-token 응답에는 `refresh_token` 필드가 없고 `no-store`가 적용됩니다.
+- 브라우저 cookie에는 HttpOnly, SameSite=Lax인 `AP2_SESSION` 식별자만
+  저장됩니다. 실제 OAuth token은 session cookie 안에 들어가지 않습니다.
+
+## 실행
+
+```bash
+./scripts/verify-pattern2.sh
+```
+
+검증은 실제 Keycloak 로그인 후 서버 token 보관 여부, access-only 응답의
+필드 집합과 audience, 브라우저의 직접 Resource Server 호출, Web Storage
+비사용을 확인합니다.

docs/four-pattern-tradeoff-matrix.md

@@ -0,0 +1,37 @@
+# Four Keycloak integration patterns
+
+| 축 | AP1 SPA direct | AP2 token mediator | AP3 BFF | AP4 edge auth |
+|---|---|---|---|---|
+| OAuth client | public | confidential | confidential | confidential proxy |
+| browser 보유물 | access/refresh token | 짧은 handoff code 또는 app token | HttpOnly session cookie | proxy session cookie |
+| OAuth code 교환 | browser + PKCE | mediator backend | BFF | oauth2-proxy |
+| API bearer 검증 | Spring resource server | mediator/downstream API | BFF 내부 또는 downstream | edge가 인증 후 trusted header |
+| server session | 없음 | handoff 상태만 짧게 | 필수 | proxy cookie/session |
+| XSS token 탈취면 | 가장 큼 | 축소 | browser token 제거 | browser token 제거 |
+| CSRF 주의 | token endpoint/refresh 설계 | app cookie 사용 시 | 필수 방어 | proxy cookie 사용 시 |
+| 수평 확장 상태 | 단순 | handoff store 공유 가능 | session store 필요 | proxy 설정에 따름 |
+| 주 학습 포인트 | PKCE/JWT/RS | token 경계·one-time handoff | oauth2Login/session/CSRF | auth_request/header trust |
+
+## 선택 기준
+
+- 브라우저에서 OAuth와 token 수명주기를 직접 학습하려면 AP1.
+- 브라우저에 upstream token을 주지 않되 API 호출은 bearer 중심으로 유지하려면
+  AP2.
+- token을 browser에서 완전히 제거하고 애플리케이션 단위 인가·세션을
+  중앙화하려면 AP3.
+- 기존 upstream을 수정하기 어렵고 경계에서 일괄 인증하려면 AP4.
+
+Google federation은 다섯 번째 인증 패턴이 아니다. 네 패턴 모두 최종적으로
+Keycloak token/session을 소비하며, Google은 Keycloak 앞의 upstream IdP
+hop으로 추가된다.
+
+## 이 repository의 실행 증거
+
+- AP1: PKCE SPA, issuer/audience, token storage, refresh/logout 검증
+- AP2: confidential client와 one-time access handoff 검증
+- AP3: `oauth2Login` session과 CSRF/SameSite 검증
+- AP4: oauth2-proxy, nginx `auth_request`, spoofed header 제거 검증
+- 공통: local mock Google brokering, First Broker Login, claim/role mapping 검증
+
+각 근거 브랜치와 병합 여부는 `keycloak-branch-manifest.tsv` 및
+`audit-keycloak-branches.sh`로 추적한다.

docs/google-redirect-uri-policy.md

@@ -0,0 +1,24 @@
+# Google redirect URI policy
+
+Google에 등록하는 redirect URI는 애플리케이션 SPA callback이 아니라 Keycloak
+broker endpoint다.
+
+```text
+https://auth.example.test/realms/keycloak-patterns/broker/google/endpoint
+```
+
+규칙:
+
+- production URI는 HTTPS와 고정된 public Keycloak origin을 사용한다.
+- wildcard, path prefix, 임시 tunnel hostname을 production OAuth client에
+  등록하지 않는다.
+- 개발·스테이징·운영은 Google OAuth client를 분리한다.
+- reverse proxy가 있더라도 Google이 보는 URI와 Keycloak이 생성하는 URI가
+  byte-for-byte 같아야 한다.
+- `configure-google-idp.sh`가 출력하는 URI를 Google Console의 Authorized
+  redirect URI와 대조한다.
+
+```sh
+PUBLIC_KEYCLOAK_URL=https://auth.example.test \
+  ./scripts/verify-google-redirect-uri-policy.sh
+```

docs/https-termination.md

@@ -0,0 +1,20 @@
+# HTTPS termination: nginx or Caddy
+
+두 예제 모두 public `443`에서 TLS를 종료하고 private Docker network의
+`keycloak:8080`으로 전달한다. Keycloak 쪽 설정은
+`deploy/reverse-proxy/keycloak.env.example`의 hostname/proxy contract를
+같이 사용한다.
+
+- nginx: 인증서 배포·갱신을 운영자가 담당할 때 적합하다.
+- Caddy: ACME를 통한 인증서 수명주기를 proxy가 담당하게 할 때 간단하다.
+- 둘을 동시에 production entry point로 띄우지 않는다.
+- 인증서와 private key는 repository 또는 image에 포함하지 않는다.
+- HTTP challenge/redirect 및 방화벽의 80/443 허용은 배포 환경에서 별도로
+  결정한다.
+
+검증 스크립트는 임시 자체 서명 인증서를 만들고 두 vendor image에서 설정을
+각각 validate한 뒤 임시 파일을 제거한다.
+
+```sh
+./scripts/verify-https-termination-config.sh
+```

docs/public-domain-tunneling.md

@@ -0,0 +1,21 @@
+# Public HTTPS domain for broker callbacks
+
+Google brokering을 반복 테스트할 때는 Cloudflare **named tunnel + 관리
+도메인**을 기본 profile로 사용한다. `trycloudflare.com` quick tunnel과
+임의 ngrok URL은 일회성 데모용이며 고정 callback으로 간주하지 않는다.
+
+설정 순서:
+
+1. `cloudflared tunnel login`
+2. `cloudflared tunnel create keycloak-patterns`
+3. 예제 config의 tunnel UUID와 credentials path를 실제 값으로 교체
+4. `cloudflared tunnel route dns keycloak-patterns auth.example.test`
+5. `cloudflared tunnel run keycloak-patterns`
+6. Keycloak `KC_HOSTNAME`과 Google redirect URI를 같은 public host로 설정
+
+컨테이너 안의 `127.0.0.1`은 cloudflared 컨테이너 자신이므로 origin에는
+`reverse-proxy:8080` 같은 Compose service DNS를 사용한다. 마지막 catch-all
+ingress는 알 수 없는 hostname을 404로 끝낸다.
+
+실 tunnel 생성과 DNS 변경에는 사용자 소유 계정·도메인이 필요하므로 자동
+검증은 ingress 파일의 구조까지만 수행한다.

docs/reverse-proxy-headers.md

@@ -0,0 +1,15 @@
+# Reverse proxy headers
+
+TLS를 reverse proxy에서 종료하면 Keycloak은 브라우저가 사용한 외부 origin을
+정확히 알아야 한다. 배포 예제는 다음 계약을 함께 적용한다.
+
+- nginx는 `Host`, `X-Forwarded-Host`, `X-Forwarded-Port`,
+  `X-Forwarded-Proto`, `X-Forwarded-For`를 덮어쓴다.
+- Keycloak은 `KC_PROXY_HEADERS=xforwarded`로 그 헤더 형식을 명시한다.
+- `KC_HOSTNAME`은 외부 HTTPS URL로 고정하고 strict hostname 검증을 켠다.
+- Keycloak의 8080 포트는 public으로 publish하지 않고 proxy network에서만
+  접근시킨다. 신뢰되지 않은 클라이언트가 forwarded header를 직접 넣을 수
+  있으면 안 된다.
+
+`scripts/verify-reverse-proxy-headers.sh`는 양쪽 설정의 짝과 nginx 구문을
+검증한다.

e2e/package-lock.json

@@ -0,0 +1,28 @@
+{
+  "name": "keycloak-pattern-e2e",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "keycloak-pattern-e2e",
+      "version": "1.0.0",
+      "devDependencies": {
+        "playwright-core": "1.62.0"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.62.0",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.62.0.tgz",
+      "integrity": "sha512-nsNRyq0r2zsG8AcRHWknc9QRA5XCueC7gWMrs+Gx2tlZn9hcl8zudfh00lhJPY1DE7NmZ6bDsT9g2yey8mXljA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    }
+  }
+}

e2e/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "keycloak-pattern-e2e",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "test:pattern2": "node pattern2.mjs"
+  },
+  "devDependencies": {
+    "playwright-core": "1.62.0"
+  }
+}

e2e/pattern2.mjs

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const password = process.env.E2E_PASSWORD;
+assert.ok(password, "E2E_PASSWORD must be set");
+
+async function completeKeycloakLogin(page) {
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    await page.locator("#username").fill(
+      process.env.E2E_USERNAME ?? "regular-user",
+    );
+    await page.locator("#password").fill(password);
+    await page.locator("#kc-login").click();
+    await page.waitForLoadState("domcontentloaded");
+
+    if (page.url() === "http://localhost:8082/") {
+      return;
+    }
+    if (attempt === 1) {
+      await page.goto(
+        "http://localhost:8082/oauth2/authorization/keycloak",
+      );
+      await page.waitForURL(/localhost:8080/u);
+    }
+  }
+  throw new Error(`Keycloak login did not return to AP2: ${page.url()}`);
+}
+
+const browser = await chromium.launch({
+  executablePath: process.env.CHROME_BIN ?? "/usr/bin/google-chrome",
+  headless: true,
+  args: ["--no-sandbox"],
+});
+
+try {
+  const context = await browser.newContext();
+  const page = await context.newPage();
+
+  await page.goto("http://localhost:8082");
+  await page.locator("#login").click();
+  await page.waitForURL(/localhost:8080/u);
+  await completeKeycloakLogin(page);
+
+  const boundaryResponsePromise = page.waitForResponse((response) =>
+    response.url().endsWith("/token/boundary"),
+  );
+  await page.locator("#inspect").click();
+  const boundaryResponse = await boundaryResponsePromise;
+  assert.equal(boundaryResponse.status(), 200);
+  const boundary = await boundaryResponse.json();
+
+  assert.equal(boundary.accessTokenStored, true);
+  assert.equal(boundary.refreshTokenStored, true);
+  assert.equal(boundary.browserReceivesRefreshToken, false);
+  assert.equal(JSON.stringify(boundary).includes("refresh_token"), false);
+
+  const accessResponsePromise = page.waitForResponse((response) =>
+    response.url().endsWith("/token/access"),
+  );
+  const resourceResponsePromise = page.waitForResponse(
+    (response) =>
+      response.url() === "http://localhost:8081/api/me" &&
+      response.request().method() === "GET",
+  );
+  await page.locator("#call-api").click();
+
+  const accessResponse = await accessResponsePromise;
+  assert.equal(accessResponse.status(), 200);
+  assert.match(accessResponse.headers()["cache-control"], /no-store/u);
+  const accessHandoff = await accessResponse.json();
+  assert.deepEqual(
+    Object.keys(accessHandoff).sort(),
+    ["access_token", "expires_at", "token_type"],
+  );
+  assert.equal(accessHandoff.token_type, "Bearer");
+  assert.equal(typeof accessHandoff.access_token, "string");
+  assert.ok(accessHandoff.access_token.length > 100);
+  assert.equal(JSON.stringify(accessHandoff).includes("refresh_token"), false);
+
+  const [, payload] = accessHandoff.access_token.split(".");
+  const claims = JSON.parse(
+    Buffer.from(payload, "base64url").toString("utf8"),
+  );
+  const audience = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+  assert.ok(audience.includes("keycloak-pattern-api"));
+
+  const resourceResponse = await resourceResponsePromise;
+  assert.equal(resourceResponse.status(), 200);
+  const resource = await resourceResponse.json();
+  assert.equal(resource.username, "regular-user");
+  assert.ok(resource.audience.includes("keycloak-pattern-api"));
+  await page.locator("#result").getByText('"resourceApiStatus": 200').waitFor();
+
+  const cookies = await context.cookies("http://localhost:8082/");
+  const sessionCookie = cookies.find((cookie) => cookie.name === "AP2_SESSION");
+  assert.ok(sessionCookie);
+  assert.equal(sessionCookie.httpOnly, true);
+  assert.equal(sessionCookie.sameSite, "Lax");
+
+  const storage = await page.evaluate(() => ({
+    localStorage: Object.values(localStorage),
+    sessionStorage: Object.values(sessionStorage),
+  }));
+  assert.equal(JSON.stringify(storage).includes("refresh_token"), false);
+  assert.equal(
+    JSON.stringify(storage).includes(accessHandoff.access_token),
+    false,
+  );
+
+  console.log(
+    "pattern2 verified: server refresh custody, access-only handoff, direct browser resource call",
+  );
+} finally {
+  await browser.close();
+}

google-e2e/package.json

@@ -6,7 +6,8 @@
   "scripts": {
     "test:first-broker": "node first-broker-login.mjs",
     "test:claim-mapping": "node claim-mapping.mjs",
-    "test:claim-to-role": "node claim-to-role.mjs"
+    "test:claim-to-role": "node claim-to-role.mjs",
+    "test:sub-vs-email": "node sub-vs-email.mjs"
   },
   "dependencies": {
     "playwright-core": "1.55.1"

google-e2e/sub-vs-email.mjs

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const baseUrl = process.env.KEYCLOAK_URL ?? "http://localhost:8080";
+const adminUsername = process.env.KC_BOOTSTRAP_ADMIN_USERNAME;
+const adminPassword = process.env.KC_BOOTSTRAP_ADMIN_PASSWORD;
+const mockPassword = process.env.MOCK_GOOGLE_USER_PASSWORD;
+assert.ok(adminUsername && adminPassword && mockPassword);
+
+async function adminToken() {
+  const response = await fetch(
+    `${baseUrl}/realms/master/protocol/openid-connect/token`,
+    {
+      method: "POST",
+      body: new URLSearchParams({
+        client_id: "admin-cli",
+        grant_type: "password",
+        username: adminUsername,
+        password: adminPassword,
+      }),
+    },
+  );
+  assert.equal(response.status, 200);
+  return (await response.json()).access_token;
+}
+
+async function adminJson(token, path, init = {}) {
+  const response = await fetch(`${baseUrl}/admin/realms/${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...(init.body ? { "Content-Type": "application/json" } : {}),
+    },
+  });
+  assert.ok(response.ok, `${init.method ?? "GET"} ${path}: ${response.status}`);
+  return response.status === 204 ? undefined : response.json();
+}
+
+async function users(token, realm, query) {
+  return adminJson(token, `${realm}/users?${new URLSearchParams(query)}`);
+}
+
+async function brokerLogin(browser) {
+  const page = await browser.newPage();
+  const url = new URL(
+    `${baseUrl}/realms/keycloak-patterns/protocol/openid-connect/auth`,
+  );
+  url.search = new URLSearchParams({
+    client_id: "spa-public",
+    redirect_uri: "http://localhost:8088/",
+    response_type: "code",
+    scope: "openid profile email",
+    state: crypto.randomUUID(),
+    nonce: crypto.randomUUID(),
+    code_challenge: "K2qUEfBl-nQvF2gB4dNxC2zYVwZc1CVnZb5CsX2L7fI",
+    code_challenge_method: "S256",
+    kc_idp_hint: "mock-google",
+    prompt: "login",
+  });
+  await page.goto(url.toString());
+  await page.waitForURL(/\/realms\/mock-google\//u);
+  await page.locator("#username").fill("mock-new-user");
+  await page.locator("#password").fill(mockPassword);
+  await page.locator("#kc-login").click();
+  await page.waitForURL(/localhost:8088\/\?.*code=/u);
+  await page.close();
+}
+
+const token = await adminToken();
+const mockUsers = await users(token, "mock-google", {
+  username: "mock-new-user",
+  exact: "true",
+});
+assert.equal(mockUsers.length, 1);
+const mockUser = await adminJson(
+  token,
+  `mock-google/users/${mockUsers[0].id}`,
+);
+const originalEmail = mockUser.email;
+const changedEmail = "broker-renamed-user@example.test";
+
+for (const existing of await users(token, "keycloak-patterns", {
+  username: `mock-google.${mockUser.id}`,
+  exact: "true",
+})) {
+  await adminJson(token, `keycloak-patterns/users/${existing.id}`, {
+    method: "DELETE",
+  });
+}
+
+const browser = await chromium.launch({
+  executablePath: process.env.CHROME_BIN ?? "/usr/bin/google-chrome",
+  headless: true,
+  args: ["--no-sandbox"],
+});
+
+try {
+  await brokerLogin(browser);
+  const before = await users(token, "keycloak-patterns", {
+    username: `mock-google.${mockUser.id}`,
+    exact: "true",
+  });
+  assert.equal(before.length, 1);
+  const localUserId = before[0].id;
+  const identities = await adminJson(
+    token,
+    `keycloak-patterns/users/${localUserId}/federated-identity`,
+  );
+  assert.equal(identities[0].userId, mockUser.id);
+
+  await adminJson(token, `mock-google/users/${mockUser.id}`, {
+    method: "PUT",
+    body: JSON.stringify({ ...mockUser, email: changedEmail }),
+  });
+  await brokerLogin(browser);
+
+  const after = await users(token, "keycloak-patterns", {
+    username: `mock-google.${mockUser.id}`,
+    exact: "true",
+  });
+  assert.equal(after.length, 1);
+  assert.equal(after[0].id, localUserId);
+  console.log(
+    "Federated identity verified: provider sub stayed linked while upstream email changed",
+  );
+} finally {
+  await adminJson(token, `mock-google/users/${mockUser.id}`, {
+    method: "PUT",
+    body: JSON.stringify({ ...mockUser, email: originalEmail }),
+  });
+  await browser.close();
+}

keycloak/import/keycloak-patterns-realm.json

@@ -79,7 +79,22 @@
       ],
       "attributes": {
         "post.logout.redirect.uris": "http://localhost:8082/*"
+      },
+      "protocolMappers": [
+        {
+          "name": "keycloak-pattern-api-audience",
+          "protocol": "openid-connect",
+          "protocolMapper": "oidc-audience-mapper",
+          "consentRequired": false,
+          "config": {
+            "included.custom.audience": "keycloak-pattern-api",
+            "id.token.claim": "false",
+            "access.token.claim": "true",
+            "userinfo.token.claim": "false",
+            "introspection.token.claim": "true"
           }
+        }
+      ]
     },
     {
       "clientId": "bff-confidential",

scripts/verify-account-linking-sub-vs-email.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env sh
+set -eu
+
+set -a
+. ./.env
+set +a
+
+./scripts/set-first-broker-login-mode.sh secure
+cd google-e2e
+npm install --ignore-scripts
+npm run test:sub-vs-email

scripts/verify-google-redirect-uri-policy.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env sh
+set -eu
+
+realm="${KEYCLOAK_REALM:-keycloak-patterns}"
+public_keycloak_url="${PUBLIC_KEYCLOAK_URL:-https://auth.example.test}"
+expected="$public_keycloak_url/realms/$realm/broker/google/endpoint"
+
+case "$public_keycloak_url" in
+  https://*) ;;
+  *)
+    echo "PUBLIC_KEYCLOAK_URL must use https outside the local mock environment" >&2
+    exit 1
+    ;;
+esac
+
+case "$public_keycloak_url" in
+  *\** | */)
+    echo "PUBLIC_KEYCLOAK_URL must be an exact origin without wildcard/trailing slash" >&2
+    exit 1
+    ;;
+esac
+
+test "$expected" = "https://auth.example.test/realms/keycloak-patterns/broker/google/endpoint"
+echo "Google redirect URI policy verified: $expected"

scripts/verify-https-termination-config.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env sh
+set -eu
+
+test_dir="$(mktemp -d)"
+cleanup() {
+  rm -rf "$test_dir"
+}
+trap cleanup EXIT
+
+openssl req -x509 -newkey rsa:2048 -nodes -days 1 \
+  -subj "/CN=auth.example.test" \
+  -keyout "$test_dir/tls.key" \
+  -out "$test_dir/tls.crt" >/dev/null 2>&1
+
+docker run --rm \
+  --add-host keycloak:127.0.0.1 \
+  -v "$PWD/deploy/tls/nginx.conf:/etc/nginx/nginx.conf:ro" \
+  -v "$test_dir:/etc/tls:ro" \
+  nginx:1.29-alpine nginx -t
+
+docker run --rm \
+  --add-host keycloak:127.0.0.1 \
+  -v "$PWD/deploy/tls/Caddyfile:/etc/caddy/Caddyfile:ro" \
+  -v "$test_dir:/etc/tls:ro" \
+  caddy:2.10.2-alpine caddy validate --config /etc/caddy/Caddyfile
+
+echo "nginx and Caddy HTTPS termination configurations verified"

scripts/verify-pattern2.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env; copy .env.example and set development values" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+docker compose down --volumes --remove-orphans
+docker compose up --build -d --wait
+
+npm --prefix e2e ci
+E2E_USERNAME=regular-user \
+E2E_PASSWORD="$REGULAR_USER_PASSWORD" \
+  npm --prefix e2e run test:pattern2
+
+echo "AP2 confidential client boundary verified"

scripts/verify-public-tunnel-config.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env sh
+set -eu
+
+config=deploy/tunnel/cloudflared-config.yml
+grep -q '^tunnel: [0-9a-f-]*$' "$config"
+grep -q '^  - hostname: auth.example.test$' "$config"
+grep -q '^    service: http://reverse-proxy:8080$' "$config"
+grep -q '^  - service: http_status:404$' "$config"
+
+docker run --rm \
+  -v "$PWD/$config:/etc/cloudflared/config.yml:ro" \
+  cloudflare/cloudflared:2025.6.1 \
+  tunnel --config /etc/cloudflared/config.yml ingress validate
+
+echo "Cloudflare named-tunnel ingress configuration verified"

scripts/verify-reverse-proxy-headers.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env sh
+set -eu
+
+config=deploy/reverse-proxy/nginx-keycloak.conf
+env_file=deploy/reverse-proxy/keycloak.env.example
+
+grep -q 'proxy_set_header X-Forwarded-Host' "$config"
+grep -q 'proxy_set_header X-Forwarded-Port 443' "$config"
+grep -q 'proxy_set_header X-Forwarded-Proto https' "$config"
+grep -q '^KC_PROXY_HEADERS=xforwarded$' "$env_file"
+grep -q '^KC_HOSTNAME=https://' "$env_file"
+
+docker run --rm \
+  --add-host keycloak:127.0.0.1 \
+  -v "$PWD/$config:/etc/nginx/conf.d/default.conf:ro" \
+  nginx:1.29-alpine nginx -t
+
+echo "Reverse-proxy header and Keycloak hostname contracts verified"

token-mediator/.dockerignore

@@ -0,0 +1 @@
+target/

token-mediator/Dockerfile

@@ -0,0 +1,17 @@
+FROM maven:3.9.11-eclipse-temurin-21-alpine AS build
+
+WORKDIR /workspace
+COPY pom.xml .
+RUN mvn --batch-mode dependency:go-offline
+COPY src src
+RUN mvn --batch-mode verify
+
+FROM eclipse-temurin:21-jre-alpine
+
+RUN addgroup -S spring && adduser -S spring -G spring
+WORKDIR /app
+COPY --from=build /workspace/target/keycloak-token-mediator.jar app.jar
+USER spring:spring
+
+EXPOSE 8082
+ENTRYPOINT ["java", "-jar", "/app/app.jar"]

token-mediator/pom.xml

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.5.16</version>
+        <relativePath/>
+    </parent>
+
+    <groupId>com.example</groupId>
+    <artifactId>keycloak-token-mediator</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>keycloak-token-mediator</name>
+
+    <properties>
+        <java.version>21</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-oauth2-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>keycloak-token-mediator</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

token-mediator/src/main/java/com/example/keycloakpattern/mediator/AccessTokenController.java

@@ -0,0 +1,56 @@
+package com.example.keycloakpattern.mediator;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.springframework.http.CacheControl;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.oauth2.client.OAuth2AuthorizeRequest;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.core.OAuth2AccessToken;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+
+import static org.springframework.http.HttpStatus.UNAUTHORIZED;
+
+@RestController
+public class AccessTokenController {
+
+    private final OAuth2AuthorizedClientManager authorizedClientManager;
+
+    public AccessTokenController(OAuth2AuthorizedClientManager authorizedClientManager) {
+        this.authorizedClientManager = authorizedClientManager;
+    }
+
+    @GetMapping("/token/access")
+    ResponseEntity<Map<String, Object>> accessToken(Authentication authentication) {
+        OAuth2AuthorizeRequest request = OAuth2AuthorizeRequest
+            .withClientRegistrationId("keycloak")
+            .principal(authentication)
+            .build();
+        OAuth2AuthorizedClient client = authorizedClientManager.authorize(request);
+        if (client == null || client.getAccessToken() == null) {
+            throw new ResponseStatusException(
+                UNAUTHORIZED,
+                "No authorized Keycloak client is available"
+            );
+        }
+
+        OAuth2AccessToken token = client.getAccessToken();
+        Map<String, Object> response = new LinkedHashMap<>();
+        response.put("access_token", token.getTokenValue());
+        response.put("token_type", token.getTokenType().getValue());
+        response.put(
+            "expires_at",
+            token.getExpiresAt() == null ? null : token.getExpiresAt().toString()
+        );
+
+        return ResponseEntity.ok()
+            .cacheControl(CacheControl.noStore())
+            .header("Pragma", "no-cache")
+            .body(response);
+    }
+}

token-mediator/src/main/java/com/example/keycloakpattern/mediator/SecurityConfig.java

@@ -0,0 +1,55 @@
+package com.example.keycloakpattern.mediator;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.oauth2.client.AuthorizedClientServiceOAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientProvider;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientProviderBuilder;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
+import org.springframework.security.web.SecurityFilterChain;
+
+@Configuration
+public class SecurityConfig {
+
+    @Bean
+    SecurityFilterChain mediatorSecurity(HttpSecurity http) throws Exception {
+        return http
+            .authorizeHttpRequests(authorize -> authorize
+                .requestMatchers(
+                    "/",
+                    "/index.html",
+                    "/app.js",
+                    "/favicon.ico",
+                    "/actuator/health",
+                    "/actuator/health/**"
+                )
+                .permitAll()
+                .anyRequest()
+                .authenticated())
+            .oauth2Login(oauth2 -> oauth2.defaultSuccessUrl("/", true))
+            .build();
+    }
+
+    @Bean
+    OAuth2AuthorizedClientManager authorizedClientManager(
+        ClientRegistrationRepository clientRegistrationRepository,
+        OAuth2AuthorizedClientService authorizedClientService
+    ) {
+        OAuth2AuthorizedClientProvider authorizedClientProvider =
+            OAuth2AuthorizedClientProviderBuilder.builder()
+                .authorizationCode()
+                .refreshToken()
+                .build();
+
+        AuthorizedClientServiceOAuth2AuthorizedClientManager manager =
+            new AuthorizedClientServiceOAuth2AuthorizedClientManager(
+                clientRegistrationRepository,
+                authorizedClientService
+            );
+        manager.setAuthorizedClientProvider(authorizedClientProvider);
+        return manager;
+    }
+}

token-mediator/src/main/java/com/example/keycloakpattern/mediator/TokenBoundaryController.java

@@ -0,0 +1,44 @@
+package com.example.keycloakpattern.mediator;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.springframework.http.CacheControl;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class TokenBoundaryController {
+
+    private final OAuth2AuthorizedClientService authorizedClientService;
+
+    public TokenBoundaryController(
+        OAuth2AuthorizedClientService authorizedClientService
+    ) {
+        this.authorizedClientService = authorizedClientService;
+    }
+
+    @GetMapping("/token/boundary")
+    ResponseEntity<Map<String, Object>> tokenBoundary(Authentication authentication) {
+        OAuth2AuthorizedClient client = authorizedClientService.loadAuthorizedClient(
+            "keycloak",
+            authentication.getName()
+        );
+
+        Map<String, Object> response = new LinkedHashMap<>();
+        response.put("pattern", "AP2-token-mediating-backend");
+        response.put("principal", authentication.getName());
+        response.put("accessTokenStored", client != null && client.getAccessToken() != null);
+        response.put("refreshTokenStored", client != null && client.getRefreshToken() != null);
+        response.put("browserReceivesRefreshToken", false);
+
+        return ResponseEntity.ok()
+            .cacheControl(CacheControl.noStore())
+            .header("Pragma", "no-cache")
+            .body(response);
+    }
+}

token-mediator/src/main/java/com/example/keycloakpattern/mediator/TokenMediatorApplication.java

@@ -0,0 +1,12 @@
+package com.example.keycloakpattern.mediator;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class TokenMediatorApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(TokenMediatorApplication.class, args);
+    }
+}

token-mediator/src/main/resources/application.yml

@@ -0,0 +1,44 @@
+server:
+  port: ${SERVER_PORT:8082}
+  servlet:
+    session:
+      cookie:
+        name: AP2_SESSION
+        http-only: true
+        same-site: lax
+
+spring:
+  application:
+    name: keycloak-token-mediator
+  security:
+    oauth2:
+      client:
+        registration:
+          keycloak:
+            provider: keycloak
+            client-id: token-mediating-confidential
+            client-secret: ${KEYCLOAK_CLIENT_SECRET}
+            client-authentication-method: client_secret_basic
+            authorization-grant-type: authorization_code
+            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
+            scope:
+              - openid
+              - profile
+              - email
+        provider:
+          keycloak:
+            authorization-uri: http://localhost:8080/realms/keycloak-patterns/protocol/openid-connect/auth
+            token-uri: http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/token
+            jwk-set-uri: http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/certs
+            user-info-uri: http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/userinfo
+            user-name-attribute: preferred_username
+
+management:
+  endpoint:
+    health:
+      probes:
+        enabled: true
+  endpoints:
+    web:
+      exposure:
+        include: health,info

token-mediator/src/main/resources/static/app.js

@@ -0,0 +1,50 @@
+const result = document.querySelector("#result");
+
+function render(value) {
+  result.textContent = JSON.stringify(value, null, 2);
+}
+
+document.querySelector("#login").addEventListener("click", () => {
+  window.location.assign("/oauth2/authorization/keycloak");
+});
+
+document.querySelector("#inspect").addEventListener("click", async () => {
+  const response = await fetch("/token/boundary", {
+    headers: { Accept: "application/json" },
+  });
+  if (response.redirected || response.status === 401) {
+    window.location.assign("/oauth2/authorization/keycloak");
+    return;
+  }
+  render(await response.json());
+});
+
+document.querySelector("#call-api").addEventListener("click", async () => {
+  const tokenResponse = await fetch("/token/access", {
+    headers: { Accept: "application/json" },
+  });
+  if (tokenResponse.redirected || tokenResponse.status === 401) {
+    window.location.assign("/oauth2/authorization/keycloak");
+    return;
+  }
+  if (!tokenResponse.ok) {
+    render({ tokenEndpointStatus: tokenResponse.status });
+    return;
+  }
+
+  const { access_token: accessToken, expires_at: expiresAt } =
+    await tokenResponse.json();
+  const apiResponse = await fetch("http://localhost:8081/api/me", {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+  render({
+    accessTokenHeldInMemoryOnly: true,
+    refreshTokenReceived: false,
+    accessTokenExpiresAt: expiresAt,
+    resourceApiStatus: apiResponse.status,
+    resource: await apiResponse.json(),
+  });
+});

token-mediator/src/main/resources/static/index.html

@@ -0,0 +1,30 @@
+<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>AP2 · Token-Mediating Backend</title>
+  <style>
+    :root { color-scheme: light dark; font-family: system-ui, sans-serif; }
+    body { max-width: 52rem; margin: 6vh auto; padding: 0 1.5rem; line-height: 1.6; }
+    button { margin-right: 0.5rem; padding: 0.6rem 0.9rem; cursor: pointer; }
+    pre { min-height: 8rem; padding: 1rem; border-radius: 0.4rem;
+      background: color-mix(in srgb, CanvasText 9%, Canvas); white-space: pre-wrap; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>AP2 · Token-Mediating Backend</h1>
+    <p>
+      confidential backend가 authorization code를 token으로 교환합니다.
+      refresh token은 서버의 <code>OAuth2AuthorizedClientService</code>에만
+      보관됩니다.
+    </p>
+    <button id="login" type="button">Keycloak 로그인</button>
+    <button id="inspect" type="button">서버 token 경계 확인</button>
+    <button id="call-api" type="button">access token으로 API 직접 호출</button>
+    <pre id="result" aria-live="polite"></pre>
+  </main>
+  <script type="module" src="/app.js"></script>
+</body>
+</html>

token-mediator/src/test/java/com/example/keycloakpattern/mediator/TokenBoundaryControllerTest.java

@@ -0,0 +1,84 @@
+package com.example.keycloakpattern.mediator;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.oidcLogin;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.time.Instant;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.oauth2.client.OAuth2AuthorizeRequest;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.core.OAuth2AccessToken;
+import org.springframework.security.oauth2.core.OAuth2RefreshToken;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.web.servlet.MockMvc;
+
+@SpringBootTest(properties = "KEYCLOAK_CLIENT_SECRET=test-only-secret")
+@AutoConfigureMockMvc
+class TokenBoundaryControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockitoBean
+    private OAuth2AuthorizedClientService authorizedClientService;
+
+    @MockitoBean
+    private OAuth2AuthorizedClientManager authorizedClientManager;
+
+    @Test
+    void reportsServerSideTokensWithoutReturningTheirValues() throws Exception {
+        OAuth2AuthorizedClient client = mock(OAuth2AuthorizedClient.class);
+        when(client.getAccessToken()).thenReturn(mock(OAuth2AccessToken.class));
+        when(client.getRefreshToken()).thenReturn(mock(OAuth2RefreshToken.class));
+        when(authorizedClientService.loadAuthorizedClient("keycloak", "test-subject"))
+            .thenReturn(client);
+
+        mockMvc.perform(get("/token/boundary").with(oidcLogin()
+                .idToken(token -> token.subject("test-subject"))))
+            .andExpect(status().isOk())
+            .andExpect(header().string("Cache-Control", "no-store"))
+            .andExpect(jsonPath("$.accessTokenStored").value(true))
+            .andExpect(jsonPath("$.refreshTokenStored").value(true))
+            .andExpect(jsonPath("$.browserReceivesRefreshToken").value(false))
+            .andExpect(jsonPath("$.access_token").doesNotExist())
+            .andExpect(jsonPath("$.refresh_token").doesNotExist());
+    }
+
+    @Test
+    void handsOffAccessTokenOnlyAndMarksResponseNoStore() throws Exception {
+        Instant issuedAt = Instant.parse("2026-07-25T00:00:00Z");
+        OAuth2AccessToken accessToken = new OAuth2AccessToken(
+            OAuth2AccessToken.TokenType.BEARER,
+            "test-access-token",
+            issuedAt,
+            issuedAt.plusSeconds(300)
+        );
+        OAuth2AuthorizedClient client = mock(OAuth2AuthorizedClient.class);
+        when(client.getAccessToken()).thenReturn(accessToken);
+        when(authorizedClientManager.authorize(any(OAuth2AuthorizeRequest.class)))
+            .thenReturn(client);
+
+        mockMvc.perform(get("/token/access").with(oidcLogin()
+                .idToken(token -> token.subject("test-subject"))))
+            .andExpect(status().isOk())
+            .andExpect(header().string("Cache-Control", "no-store"))
+            .andExpect(header().string("Pragma", "no-cache"))
+            .andExpect(jsonPath("$.length()").value(3))
+            .andExpect(jsonPath("$.access_token").value("test-access-token"))
+            .andExpect(jsonPath("$.token_type").value("Bearer"))
+            .andExpect(jsonPath("$.expires_at").value("2026-07-25T00:05:00Z"))
+            .andExpect(jsonPath("$.refresh_token").doesNotExist());
+    }
+}