docs: define AP1 local identity profile

.env.example

@@ -10,8 +10,15 @@ POSTGRES_PASSWORD=change-me-postgres-password
 TOKEN_MEDIATING_CLIENT_SECRET=change-me-token-mediating-client-secret
 BFF_CLIENT_SECRET=change-me-bff-client-secret
 EDGE_PROXY_CLIENT_SECRET=change-me-edge-proxy-client-secret
+MOCK_GOOGLE_BROKER_CLIENT_SECRET=change-me-mock-google-broker-client-secret
 ADMIN_USER_PASSWORD=change-me-admin-user-password
 REGULAR_USER_PASSWORD=change-me-regular-user-password
+MOCK_GOOGLE_USER_PASSWORD=change-me-mock-google-user-password
+
+# Optional real-Google profile. These are consumed only by
+# scripts/configure-google-idp.sh and must never be committed with real values.
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
 
 # Port 80 is the single-EC2 target. 8088 avoids common local port conflicts.
 NGINX_PORT=8088

.gitignore

@@ -7,3 +7,7 @@ backend/target/
 **/node_modules/
 frontend/dist/
 build/
+e2e/node_modules/
+google-e2e/node_modules/
+frontend/node_modules/
+frontend/dist/

README.md

@@ -1,5 +1,12 @@
 # Keycloak Authentication Patterns
 
+The 39-branch implementation registry is documented in
+[`docs/keycloak-branch-index.md`](docs/keycloak-branch-index.md).
+
+Google brokering has a credential-free local OIDC harness and an opt-in
+real-Google profile described in
+[`docs/google-idp-brokering.md`](docs/google-idp-brokering.md).
+
 Keycloak을 중심으로 네 가지 브라우저 인증 통합 패턴을 같은 로컬
 인프라에서 비교하는 학습 프로젝트입니다.
 

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

@@ -27,4 +27,9 @@ public class ApiController {
         response.put("audience", jwt.getAudience());
         return response;
     }
+
+    @GetMapping("/admin")
+    public Map<String, String> adminEndpoint() {
+        return Map.of("status", "ok", "authorization", "admin-role");
+    }
 }

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

@@ -0,0 +1,28 @@
+package com.example.keycloakpattern;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.oauth2.jwt.Jwt;
+
+final class KeycloakRealmRoleConverter
+    implements Converter<Jwt, Collection<GrantedAuthority>> {
+
+    @Override
+    public Collection<GrantedAuthority> convert(Jwt jwt) {
+        Map<String, Object> realmAccess = jwt.getClaimAsMap("realm_access");
+        if (realmAccess == null || !(realmAccess.get("roles") instanceof Collection<?> roles)) {
+            return List.of();
+        }
+        return roles.stream()
+            .filter(String.class::isInstance)
+            .map(String.class::cast)
+            .map(role -> new SimpleGrantedAuthority("ROLE_" + role))
+            .map(GrantedAuthority.class::cast)
+            .toList();
+    }
+}

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

@@ -7,6 +7,7 @@ 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.oauth2.server.resource.authentication.JwtAuthenticationConverter;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.cors.CorsConfigurationSource;
@@ -25,12 +26,21 @@ public class SecurityConfig {
             .authorizeHttpRequests(authorize -> authorize
                 .requestMatchers("/actuator/health", "/actuator/health/**", "/api/public")
                 .permitAll()
+                .requestMatchers("/api/admin")
+                .hasRole("admin-role")
                 .anyRequest()
                 .authenticated())
-            .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
+            .oauth2ResourceServer(oauth2 -> oauth2.jwt(jwt ->
+                jwt.jwtAuthenticationConverter(jwtAuthenticationConverter())))
             .build();
     }
 
+    private JwtAuthenticationConverter jwtAuthenticationConverter() {
+        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
+        converter.setJwtGrantedAuthoritiesConverter(new KeycloakRealmRoleConverter());
+        return converter;
+    }
+
     @Bean
     CorsConfigurationSource corsConfigurationSource() {
         CorsConfiguration configuration = new CorsConfiguration();

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

@@ -10,6 +10,7 @@ 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.test.web.servlet.MockMvc;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
 
 @SpringBootTest
 @AutoConfigureMockMvc
@@ -40,4 +41,19 @@ class ApiSecurityTest {
             .andExpect(jsonPath("$.subject").value("test-subject"))
             .andExpect(jsonPath("$.username").value("regular-user"));
     }
+
+    @Test
+    void regularUserCannotCallAdminEndpoint() throws Exception {
+        mockMvc.perform(get("/api/admin").with(jwt()
+                .authorities(new SimpleGrantedAuthority("ROLE_user-role"))))
+            .andExpect(status().isForbidden());
+    }
+
+    @Test
+    void adminRoleCanCallAdminEndpoint() throws Exception {
+        mockMvc.perform(get("/api/admin").with(jwt()
+                .authorities(new SimpleGrantedAuthority("ROLE_admin-role"))))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.authorization").value("admin-role"));
+    }
 }

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

@@ -0,0 +1,46 @@
+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.jwt.Jwt;
+
+class KeycloakRealmRoleConverterTest {
+
+    private final KeycloakRealmRoleConverter converter =
+        new KeycloakRealmRoleConverter();
+
+    @Test
+    void mapsRealmRolesWithExactlyOneRolePrefix() {
+        Jwt jwt = new Jwt(
+            "token",
+            Instant.now(),
+            Instant.now().plusSeconds(60),
+            Map.of("alg", "none"),
+            Map.of("sub", "subject", "realm_access", Map.of(
+                "roles", List.of("admin-role", "user-role")
+            ))
+        );
+
+        assertThat(converter.convert(jwt))
+            .extracting("authority")
+            .containsExactly("ROLE_admin-role", "ROLE_user-role");
+    }
+
+    @Test
+    void missingRealmAccessProducesNoAuthorities() {
+        Jwt jwt = new Jwt(
+            "token",
+            Instant.now(),
+            Instant.now().plusSeconds(60),
+            Map.of("alg", "none"),
+            Map.of("sub", "subject")
+        );
+
+        assertThat(converter.convert(jwt)).isEmpty();
+    }
+}

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

@@ -38,8 +38,10 @@ services:
       TOKEN_MEDIATING_CLIENT_SECRET: ${TOKEN_MEDIATING_CLIENT_SECRET:?set TOKEN_MEDIATING_CLIENT_SECRET in .env}
       BFF_CLIENT_SECRET: ${BFF_CLIENT_SECRET:?set BFF_CLIENT_SECRET in .env}
       EDGE_PROXY_CLIENT_SECRET: ${EDGE_PROXY_CLIENT_SECRET:?set EDGE_PROXY_CLIENT_SECRET in .env}
+      MOCK_GOOGLE_BROKER_CLIENT_SECRET: ${MOCK_GOOGLE_BROKER_CLIENT_SECRET:?set MOCK_GOOGLE_BROKER_CLIENT_SECRET in .env}
       ADMIN_USER_PASSWORD: ${ADMIN_USER_PASSWORD:?set ADMIN_USER_PASSWORD in .env}
       REGULAR_USER_PASSWORD: ${REGULAR_USER_PASSWORD:?set REGULAR_USER_PASSWORD in .env}
+      MOCK_GOOGLE_USER_PASSWORD: ${MOCK_GOOGLE_USER_PASSWORD:?set MOCK_GOOGLE_USER_PASSWORD in .env}
     ports:
       - "127.0.0.1:8080:8080"
     volumes:

docs/account-linking-spa-ux.md

@@ -0,0 +1,18 @@
+# Account linking UX for the SPA
+
+두 흐름을 구분한다.
+
+- 로그인 도중 email collision: Keycloak의 안전한 First Broker Login flow가
+  기존 계정 인증을 요구한다.
+- 로그인한 사용자가 설정 화면에서 “Google 연결”: Client-Initiated Account
+  Linking URL을 만들어 Keycloak로 redirect한다.
+
+`createAccountLinkUrl`은 현재 token의 `session_state`, `azp`(issued-for),
+provider와 nonce를 SHA-256 서명 재료로 사용한다. SPA는 연결 성공 후
+Account Console 또는 별도 backend read model을 통해 연결 상태를 새로
+조회해야 하며 email만 보고 “연결됨”을 표시하면 안 된다.
+
+Unlink는 사용자가 다른 로그인 수단을 갖고 있는지 먼저 안내하고, Keycloak이
+마지막 federated identity 제거를 거부하면 해당 오류를 그대로 성공처럼
+처리하지 않는다. production First Broker Login에는 자동 기존-user linking을
+넣지 않는다.

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/federation-spa-zero-change.md

@@ -0,0 +1,16 @@
+# Google federation without an AP1 application fork
+
+SPA는 Google SDK나 Google token endpoint를 알지 않는다. 기존 `spa-public`
+client로 Keycloak authorization endpoint를 호출하고, Keycloak 로그인
+화면에서 mock Google을 선택해도 callback, PKCE 교환, access token audience,
+Spring API 호출은 로컬 사용자 로그인과 동일하다.
+
+달라지는 곳은 Keycloak 앞단뿐이다.
+
+```text
+SPA -> Keycloak -> Google/mock OIDC
+SPA <- Keycloak access token <- Keycloak
+```
+
+`verify-federation-spa-zero-change.sh`는 기존 SPA 로그인 버튼에서 broker를
+선택하고, 변경 없는 callback과 `/api/me`가 200인지 실제 브라우저로 검증한다.

docs/first-broker-login-security.md

@@ -0,0 +1,27 @@
+# First Broker Login security
+
+Keycloak 26.7.0's built-in `first broker login` flow does **not** silently
+auto-link by email. It contains:
+
+- `Create User If Unique`
+- `Handle Existing Account`
+- `Confirm link existing account`
+- email verification or re-authentication ownership proof
+
+`Automatically set existing user` is an explicit, dangerous opt-in. The local
+acceptance harness copies the built-in flow, enables AutoLink, disables the
+ownership-proof branch, and signs in through a controllable OIDC account whose
+email collides with `regular-user`. It verifies that the external identity is
+attached without proof. The harness then assigns the original built-in flow,
+repeats the login, observes the existing-account confirmation page, and verifies
+that no federated identity was attached.
+
+Run after the stack is healthy:
+
+```bash
+./scripts/verify-first-broker-login.sh
+```
+
+The vulnerable flow remains only as a disabled learning artifact. The
+`mock-google` provider is always returned to the secure built-in flow at the end
+of the verification.

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-claim-mapping.md

@@ -0,0 +1,23 @@
+# Google claim and identity mapping
+
+The broker uses the upstream OIDC `sub` as the stable federated identity key.
+Email is a mutable profile attribute and is never the external identity key.
+
+The default mapping policy is:
+
+| Upstream claim | Keycloak target |
+|---|---|
+| `sub` | stable username `${ALIAS}.${CLAIM.sub}` and federated identity ID |
+| `email` | email |
+| `given_name` | first name |
+| `family_name` | last name |
+| `picture` | custom `picture` attribute |
+| `hd` | custom `hd` attribute |
+
+The Identity Provider uses `syncMode=IMPORT`: profile values are imported on
+first login and later local edits are not overwritten on every login. `FORCE`
+is an explicit alternative when upstream freshness is more important.
+
+`./scripts/verify-google-claim-mapping.sh` signs in through the controllable
+OIDC realm and verifies the resulting Keycloak user, custom attributes, stable
+subject-derived username, and federated identity record.

docs/google-claim-to-role.md

@@ -0,0 +1,18 @@
+# Google claim-to-role mapping
+
+`hd=example.test`인 upstream OIDC identity에는 Keycloak realm role
+`employee-role`을 부여한다. 매핑 키는 email이 아니라 Google subject이며,
+role 조건에 쓰는 `hd` claim은 mock provider와 실제 Google provider에서 같은
+계약을 사용한다.
+
+Realm import는 `oidc-role-idp-mapper`를 선언한다. 실제 Google 설정 스크립트도
+같은 mapper를 upsert한다. 따라서 재실행해도 mapper가 중복되지 않는다.
+
+검증:
+
+```sh
+./scripts/verify-google-claim-to-role.sh
+```
+
+검증기는 mock Google 로그인, Authorization Code + PKCE 교환, 최종 Keycloak
+access token의 `realm_access.roles`를 차례로 확인한다.

docs/google-idp-brokering.md

@@ -0,0 +1,28 @@
+# Google IdP brokering
+
+Keycloak is the only issuer trusted by AP1–AP4. Google is an upstream Identity
+Provider; applications do not receive or validate a Google token.
+
+## Two verification profiles
+
+The default local profile imports a second Keycloak realm named `mock-google`.
+It acts as a controllable OIDC provider and allows tests to choose claims such
+as a duplicate email, `email_verified=false`, `hd`, and `picture`. This is the
+safe way to reproduce an unsafe email auto-link without impersonating a real
+Google account.
+
+The real-Google profile is configured explicitly:
+
+1. Create a Google OAuth **Web application**.
+2. Register the exact redirect URI printed by
+   `./scripts/configure-google-idp.sh`.
+3. Put `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` in ignored `.env`.
+4. Start the stack and run the configuration script.
+
+The script writes `providerId=google`, `trustEmail=false`, minimal
+`openid profile email` scopes, and `syncMode=IMPORT` through the Keycloak Admin
+API. Credentials are never written to the realm export or repository.
+
+Google requires a public HTTPS redirect for non-local deployments. Local mock
+verification proves the Keycloak brokering boundary; a real Google login is a
+separate credentialed acceptance profile.

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/internal-spa-direct-no-google.md

@@ -0,0 +1,17 @@
+# AP1 internal SPA direct: local identity profile
+
+```text
+Browser SPA --Authorization Code + PKCE--> Keycloak
+Browser SPA --Bearer access token-------> Spring Resource Server
+```
+
+이 profile은 Keycloak 로컬 사용자만으로 동작한다. Google client ID/secret,
+public domain, broker callback이 없어도 AP1의 login, refresh, logout,
+audience/issuer 검증과 RBAC를 모두 학습할 수 있다.
+
+`mock-google` provider가 realm에 함께 존재해도 로컬 로그인은 provider
+availability에 의존하지 않는다. 실제로 federation 없는 배포를 만들 때는
+해당 IdP를 disabled로 두거나 realm overlay에서 제거한다.
+
+빠른 계약 검증은 `verify-internal-spa-no-google-contract.sh`, 실제 브라우저
+흐름은 `verify-pattern1.sh`가 담당한다.

docs/keycloak-branch-index.md

@@ -0,0 +1,29 @@
+# Keycloak branch implementation index
+
+The source inventory contains 39 `feature-keycloak-*.md` branch notes. This
+repository preserves one local Git feature branch for every note and merges it
+with `--no-ff` into either the common `develop` baseline or one of the four
+authentication-pattern branches.
+
+| Target | Meaning |
+|---|---|
+| `common` | Shared realm, federation, deployment, or governance contract. Merge into `develop`, then propagate to AP1–AP4. |
+| `ap1` | Browser-based OAuth client: vanilla SPA, Authorization Code + PKCE, Resource Server. |
+| `ap2` | Token-mediating confidential backend: browser receives access token only. |
+| `ap3` | BFF: backend owns every OAuth token and browser owns only a session cookie. |
+| `ap4` | Edge forward-auth: oauth2-proxy/Nginx owns login and backend trusts an isolated identity header. |
+
+The machine-readable registry is
+[`keycloak-branch-manifest.tsv`](keycloak-branch-manifest.tsv). Run:
+
+```bash
+./scripts/audit-keycloak-branches.sh
+```
+
+The audit succeeds only when all 39 note names have matching local feature
+branches and each feature tip is reachable from its declared target branch.
+
+Google credentials are never committed. The default local acceptance harness
+uses a second Keycloak realm as a controllable OIDC provider so claim mapping
+and unsafe-linking failure paths can be reproduced. A real Google login remains
+an explicit credentialed/public-HTTPS verification profile.

docs/keycloak-branch-manifest.tsv

@@ -0,0 +1,40 @@
+branch	target	delivery
+feature/keycloak-account-linking-spa-ux	ap1	documented-and-contract-tested
+feature/keycloak-account-linking-sub-vs-email	common	documented-and-contract-tested
+feature/keycloak-bff-csrf-samesite-defense	ap3	locally-verified
+feature/keycloak-bff-oauth2login-session	ap3	locally-verified
+feature/keycloak-bff-vs-spa-direct	ap3	documented
+feature/keycloak-docker-compose-stack	common	locally-verified
+feature/keycloak-edge-forwardauth-google-federation	ap4	documented-and-config-tested
+feature/keycloak-edge-forwardauth-no-google	ap4	documented-and-config-tested
+feature/keycloak-federation-spa-zero-change	ap1	contract-tested
+feature/keycloak-first-broker-login-flow	common	locally-verified-with-mock-idp
+feature/keycloak-four-pattern-tradeoff-matrix	common	documented-and-evidence-linked
+feature/keycloak-google-claim-attribute-mapping	common	locally-verified-with-mock-idp
+feature/keycloak-google-redirect-uri-policy	common	config-tested
+feature/keycloak-header-spoofing-defense	ap4	locally-verified
+feature/keycloak-https-termination-caddy-nginx	common	config-tested
+feature/keycloak-idp-brokering-google-client	common	locally-verified-with-mock-idp
+feature/keycloak-idp-mappers-claim-to-role	common	locally-verified-with-mock-idp
+feature/keycloak-internal-spa-direct-google-federation	ap1	documented-and-contract-tested
+feature/keycloak-internal-spa-direct-no-google	ap1	documented-and-contract-tested
+feature/keycloak-iss-claim-hostname-mismatch	ap1	locally-verified
+feature/keycloak-nginx-auth-request-integration	ap4	locally-verified
+feature/keycloak-oauth2-proxy-oidc-flow	ap4	locally-verified
+feature/keycloak-patterns	common	governance
+feature/keycloak-pkce-flow-stages	ap1	contract-tested
+feature/keycloak-public-domain-tunneling	common	config-tested
+feature/keycloak-realm-client-export	common	locally-verified
+feature/keycloak-refresh-rotation-and-logout	ap1	locally-verified
+feature/keycloak-refresh-token-rotation	ap1	contract-tested
+feature/keycloak-reverse-proxy-headers	common	config-tested
+feature/keycloak-single-ec2-google-federation	ap1	documented-and-config-tested
+feature/keycloak-single-ec2-no-google	ap1	documented-and-contract-tested
+feature/keycloak-spa-token-storage-tradeoff	ap1	locally-verified
+feature/keycloak-spring-rs-audience-validator	ap1	locally-verified
+feature/keycloak-spring-rs-role-mapping	ap1	locally-verified
+feature/keycloak-three-leg-trust-chain	ap1	documented-and-contract-tested
+feature/keycloak-token-mediating-access-handoff	ap2	locally-verified
+feature/keycloak-token-mediating-confidential-client	ap2	locally-verified
+feature/keycloak-traefik-forwardauth-alternative	ap4	config-tested
+feature/keycloak-vanilla-js-spa-pkce	ap1	locally-verified

docs/pkce-flow-stages.md

@@ -0,0 +1,15 @@
+# Authorization Code + PKCE stages
+
+1. SPA가 매 로그인마다 고엔트로피 `code_verifier`를 생성한다.
+2. SHA-256과 Base64URL로 `code_challenge`를 만든다.
+3. authorization request에는 challenge와 `S256`만 전송한다.
+4. redirect의 code와 저장해 둔 state를 대조한다.
+5. token request에 원래 verifier를 보내 code를 교환한다.
+6. verifier/state/code는 한 번 사용한 뒤 메모리에서 제거한다.
+
+Keycloak client는 public client이며 implicit와 password grant를 끄고 S256을
+강제한다. PKCE는 악성 redirect endpoint가 code만 가로챘을 때의 교환을 막지만,
+SPA 실행 컨텍스트를 장악한 XSS 자체를 막지는 않는다.
+
+`verify-pkce-flow-stages.sh`는 Web Crypto 단위 테스트, realm client 계약,
+authorization/token 요청의 필드를 함께 검사한다.

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/refresh-token-rotation.md

@@ -0,0 +1,16 @@
+# Refresh token rotation contract
+
+Realm 설정은 refresh token revoke를 활성화하고 재사용 허용 횟수를 0으로 둔다.
+SPA는 새 token set을 받은 즉시 이전 refresh token을 폐기한다.
+
+실제 AP1 E2E는 다음을 구분한다.
+
+- RT1로 refresh하면 RT2가 새로 발급된다.
+- 이미 소비한 RT1 재사용은 성공하면 안 된다.
+- 재사용 탐지 후 RT2까지 무효화할지는 Keycloak realm 정책과 동시 요청
+  상황에 따라 관찰한다.
+- refresh token revoke 이후 refresh는 실패한다.
+- 이미 발급된 stateless access JWT는 `exp`까지 유효할 수 있다.
+
+`verify-refresh-token-rotation-contract.sh`는 realm과 E2E assertions의 계약을
+빠르게 확인한다. 실제 token 수명주기 재현은 `verify-pattern1.sh`가 수행한다.

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 구문을
+검증한다.

docs/spring-role-mapping.md

@@ -0,0 +1,16 @@
+# Keycloak realm roles to Spring authorization
+
+`realm_access.roles`의 각 문자열을 `ROLE_` prefix가 붙은 Spring authority로
+변환한다. `/api/admin`은 `hasRole("admin-role")` 계약이므로 최종 authority는
+`ROLE_admin-role`이다. `hasRole("ROLE_admin-role")`로 쓰면 prefix가 중복된다.
+
+검증은 세 층으로 구성된다.
+
+- converter 단위 테스트: role claim과 claim 부재
+- MockMvc: regular 403, admin 200
+- 실제 Authorization Code + PKCE login: Keycloak token의 realm role을
+  Spring Resource Server가 변환해 regular 403/admin 200을 반환
+
+```sh
+./scripts/verify-spring-role-mapping.sh
+```

e2e/federation-zero-change.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const password = process.env.MOCK_GOOGLE_USER_PASSWORD;
+assert.ok(password);
+
+const browser = await chromium.launch({
+  executablePath: process.env.CHROME_BIN ?? "/usr/bin/google-chrome",
+  headless: true,
+  args: ["--no-sandbox"],
+});
+
+try {
+  const page = await browser.newPage();
+  const tokenResponse = page.waitForResponse((response) =>
+    response.url().includes("/protocol/openid-connect/token")
+    && response.request().postData()?.includes("grant_type=authorization_code"),
+  );
+
+  await page.goto("http://localhost:8088/");
+  await page.locator("#login").click();
+  await page.locator('a[href*="/broker/mock-google/login"]').click();
+  await page.waitForURL(/\/realms\/mock-google\//u);
+  await page.locator("#username").fill("mock-new-user");
+  await page.locator("#password").fill(password);
+  await page.locator("#kc-login").click();
+
+  const response = await tokenResponse;
+  assert.equal(response.status(), 200);
+  const token = (await response.json()).access_token;
+  const payload = JSON.parse(
+    Buffer.from(token.split(".")[1], "base64url").toString(),
+  );
+  assert.match(payload.preferred_username, /^mock-google\./u);
+  assert.ok(payload.aud.includes("keycloak-pattern-api"));
+
+  await page.waitForURL("http://localhost:8088/");
+  await page.locator('[data-authenticated="true"]').waitFor();
+  await page.locator("#call-api").click();
+  await page.waitForFunction(() =>
+    document.querySelector("#result")?.textContent.includes('"httpStatus": 200'),
+  );
+  console.log("Google federation verified with the unchanged AP1 SPA/API contract");
+} finally {
+  await browser.close();
+}

e2e/package.json

@@ -4,7 +4,9 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test:pattern1": "node pattern1.mjs"
+    "test:pattern1": "node pattern1.mjs",
+    "test:role-mapping": "node role-mapping.mjs",
+    "test:federation-zero-change": "node federation-zero-change.mjs"
   },
   "devDependencies": {
     "playwright-core": "1.62.0"

e2e/role-mapping.mjs

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const keycloakUrl = "http://localhost:8080";
+const frontendUrl = "http://localhost:8088/";
+
+async function accessToken(browser, username, password) {
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  await page.goto(frontendUrl);
+  const tokenResponse = page.waitForResponse((response) =>
+    response.url().includes("/protocol/openid-connect/token")
+    && response.request().postData()?.includes("grant_type=authorization_code"),
+  );
+  await page.locator("#login").click();
+  await page.locator("#username").fill(username);
+  await page.locator("#password").fill(password);
+  await page.locator("#kc-login").click();
+  const response = await tokenResponse;
+  assert.equal(response.status(), 200);
+  const token = (await response.json()).access_token;
+  await context.close();
+  return token;
+}
+
+async function adminStatus(token) {
+  return (
+    await fetch("http://localhost:8081/api/admin", {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+  ).status;
+}
+
+const regularPassword = process.env.REGULAR_USER_PASSWORD;
+const adminPassword = process.env.ADMIN_USER_PASSWORD;
+assert.ok(regularPassword && adminPassword);
+
+const browser = await chromium.launch({
+  executablePath: process.env.CHROME_BIN ?? "/usr/bin/google-chrome",
+  headless: true,
+  args: ["--no-sandbox"],
+});
+
+try {
+  const regularToken = await accessToken(
+    browser,
+    "regular-user",
+    regularPassword,
+  );
+  const regularPayload = JSON.parse(
+    Buffer.from(regularToken.split(".")[1], "base64url").toString(),
+  );
+  assert.ok(regularPayload.realm_access.roles.includes("user-role"));
+  assert.equal(await adminStatus(regularToken), 403);
+
+  const adminToken = await accessToken(browser, "admin-user", adminPassword);
+  const adminPayload = JSON.parse(
+    Buffer.from(adminToken.split(".")[1], "base64url").toString(),
+  );
+  assert.ok(adminPayload.realm_access.roles.includes("admin-role"));
+  assert.equal(await adminStatus(adminToken), 200);
+  console.log("Spring RBAC verified: realm role -> ROLE_ authority -> 403/200");
+} finally {
+  await browser.close();
+}

frontend/src/account-linking.js

@@ -0,0 +1,38 @@
+function base64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary)
+    .replaceAll("+", "-")
+    .replaceAll("/", "_")
+    .replaceAll("=", "");
+}
+
+export async function createAccountLinkUrl({
+  keycloakBaseUrl,
+  realm,
+  provider,
+  clientId,
+  redirectUri,
+  sessionState,
+  issuedFor,
+  nonce = crypto.randomUUID(),
+  cryptoApi = crypto,
+}) {
+  const material = `${nonce}${sessionState}${issuedFor}${provider}`;
+  const digest = await cryptoApi.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(material),
+  );
+  const url = new URL(
+    `${keycloakBaseUrl}/realms/${realm}/broker/${provider}/link`,
+  );
+  url.search = new URLSearchParams({
+    nonce,
+    hash: base64Url(new Uint8Array(digest)),
+    client_id: clientId,
+    redirect_uri: redirectUri,
+  });
+  return url;
+}

frontend/test/account-linking.test.mjs

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+const { createAccountLinkUrl } = await import("../src/account-linking.js");
+
+test("creates a signed client-initiated account-link URL", async () => {
+  const url = await createAccountLinkUrl({
+    keycloakBaseUrl: "https://auth.example.test",
+    realm: "keycloak-patterns",
+    provider: "google",
+    clientId: "spa-public",
+    redirectUri: "https://app.example.test/settings/identity",
+    sessionState: "session-state",
+    issuedFor: "spa-public",
+    nonce: "fixed-nonce",
+  });
+
+  assert.equal(
+    url.pathname,
+    "/realms/keycloak-patterns/broker/google/link",
+  );
+  assert.equal(url.searchParams.get("client_id"), "spa-public");
+  assert.equal(url.searchParams.get("nonce"), "fixed-nonce");
+  assert.match(url.searchParams.get("hash"), /^[A-Za-z0-9_-]{43}$/u);
+});

google-e2e/claim-mapping.mjs

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const keycloakUrl = 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(
+    `${keycloakUrl}/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 usersByEmail(token) {
+  const response = await fetch(
+    `${keycloakUrl}/admin/realms/keycloak-patterns/users?email=${encodeURIComponent(
+      "broker-new-user@example.test",
+    )}&exact=true`,
+    { headers: { Authorization: `Bearer ${token}` } },
+  );
+  assert.equal(response.status, 200);
+  return response.json();
+}
+
+async function userById(token, userId) {
+  const response = await fetch(
+    `${keycloakUrl}/admin/realms/keycloak-patterns/users/${userId}`,
+    { headers: { Authorization: `Bearer ${token}` } },
+  );
+  assert.equal(response.status, 200);
+  return response.json();
+}
+
+async function removePreviousUser(token) {
+  for (const user of await usersByEmail(token)) {
+    const response = await fetch(
+      `${keycloakUrl}/admin/realms/keycloak-patterns/users/${user.id}`,
+      {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${token}` },
+      },
+    );
+    assert.equal(response.status, 204);
+  }
+}
+
+async function brokerLogin(page) {
+  const url = new URL(
+    `${keycloakUrl}/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);
+}
+
+const token = await adminToken();
+await removePreviousUser(token);
+
+const browser = await chromium.launch({
+  executablePath: process.env.CHROME_BIN ?? "/usr/bin/google-chrome",
+  headless: true,
+  args: ["--no-sandbox"],
+});
+
+try {
+  const page = await browser.newPage();
+  await brokerLogin(page);
+
+  const users = await usersByEmail(token);
+  assert.equal(users.length, 1);
+  const user = await userById(token, users[0].id);
+  assert.match(user.username, /^mock-google\.[0-9a-f-]+$/u);
+  assert.equal(user.firstName, "Broker");
+  assert.equal(user.lastName, "New");
+  assert.deepEqual(user.attributes.picture, [
+    "https://images.example.test/mock-user.png",
+  ]);
+  assert.deepEqual(user.attributes.hd, ["example.test"]);
+
+  const identitiesResponse = await fetch(
+    `${keycloakUrl}/admin/realms/keycloak-patterns/users/${user.id}/federated-identity`,
+    { headers: { Authorization: `Bearer ${token}` } },
+  );
+  assert.equal(identitiesResponse.status, 200);
+  const identities = await identitiesResponse.json();
+  assert.equal(identities.length, 1);
+  assert.equal(identities[0].identityProvider, "mock-google");
+  assert.ok(identities[0].userId);
+
+  console.log(
+    "Google claim mapping verified: stable sub username, profile attributes, federated identity",
+  );
+} finally {
+  await browser.close();
+}

google-e2e/claim-to-role.mjs

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { createHash, randomBytes } from "node:crypto";
+import { chromium } from "playwright-core";
+
+const keycloakUrl = process.env.KEYCLOAK_URL ?? "http://localhost:8080";
+const password = process.env.MOCK_GOOGLE_USER_PASSWORD;
+assert.ok(password);
+
+const verifier = randomBytes(48).toString("base64url");
+const challenge = createHash("sha256").update(verifier).digest("base64url");
+const redirectUri = "http://localhost:8088/";
+
+const browser = await chromium.launch({
+  executablePath: process.env.CHROME_BIN ?? "/usr/bin/google-chrome",
+  headless: true,
+  args: ["--no-sandbox"],
+});
+
+try {
+  const page = await browser.newPage();
+  const authorizationUrl = new URL(
+    `${keycloakUrl}/realms/keycloak-patterns/protocol/openid-connect/auth`,
+  );
+  authorizationUrl.search = new URLSearchParams({
+    client_id: "spa-public",
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: "openid profile email",
+    state: crypto.randomUUID(),
+    nonce: crypto.randomUUID(),
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    kc_idp_hint: "mock-google",
+    prompt: "login",
+  });
+
+  await page.goto(authorizationUrl.toString());
+  await page.waitForURL(/\/realms\/mock-google\//u);
+  await page.locator("#username").fill("mock-new-user");
+  await page.locator("#password").fill(password);
+  await page.locator("#kc-login").click();
+  await page.waitForURL(/localhost:8088\/\?.*code=/u);
+
+  const code = new URL(page.url()).searchParams.get("code");
+  assert.ok(code);
+  const response = await fetch(
+    `${keycloakUrl}/realms/keycloak-patterns/protocol/openid-connect/token`,
+    {
+      method: "POST",
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        client_id: "spa-public",
+        redirect_uri: redirectUri,
+        code,
+        code_verifier: verifier,
+      }),
+    },
+  );
+  assert.equal(response.status, 200);
+  const tokens = await response.json();
+  const payload = JSON.parse(
+    Buffer.from(tokens.access_token.split(".")[1], "base64url").toString(),
+  );
+  assert.ok(payload.realm_access.roles.includes("employee-role"));
+  console.log("Claim-to-role verified: hd=example.test -> employee-role");
+} finally {
+  await browser.close();
+}

google-e2e/first-broker-login.mjs

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const expectation = process.env.FIRST_BROKER_EXPECTATION;
+assert.ok(
+  expectation === "vulnerable" || expectation === "secure",
+  "FIRST_BROKER_EXPECTATION must be vulnerable or secure",
+);
+
+const keycloakUrl = 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 body = new URLSearchParams({
+    client_id: "admin-cli",
+    grant_type: "password",
+    username: adminUsername,
+    password: adminPassword,
+  });
+  const response = await fetch(
+    `${keycloakUrl}/realms/master/protocol/openid-connect/token`,
+    { method: "POST", body },
+  );
+  assert.equal(response.status, 200);
+  return (await response.json()).access_token;
+}
+
+async function regularUser(token) {
+  const response = await fetch(
+    `${keycloakUrl}/admin/realms/keycloak-patterns/users?username=regular-user&exact=true`,
+    { headers: { Authorization: `Bearer ${token}` } },
+  );
+  assert.equal(response.status, 200);
+  const users = await response.json();
+  assert.equal(users.length, 1);
+  return users[0];
+}
+
+async function federatedIdentities(token, userId) {
+  const response = await fetch(
+    `${keycloakUrl}/admin/realms/keycloak-patterns/users/${userId}/federated-identity`,
+    { headers: { Authorization: `Bearer ${token}` } },
+  );
+  assert.equal(response.status, 200);
+  return response.json();
+}
+
+async function removeMockLink(token, userId) {
+  const identities = await federatedIdentities(token, userId);
+  if (identities.some(({ identityProvider }) => identityProvider === "mock-google")) {
+    const response = await fetch(
+      `${keycloakUrl}/admin/realms/keycloak-patterns/users/${userId}/federated-identity/mock-google`,
+      {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${token}` },
+      },
+    );
+    assert.equal(response.status, 204);
+  }
+}
+
+const token = await adminToken();
+const user = await regularUser(token);
+await removeMockLink(token, user.id);
+
+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();
+  const authorizationUrl = new URL(
+    `${keycloakUrl}/realms/keycloak-patterns/protocol/openid-connect/auth`,
+  );
+  authorizationUrl.search = new URLSearchParams({
+    client_id: "spa-public",
+    redirect_uri: "http://localhost:8088/",
+    response_type: "code",
+    scope: "openid profile email",
+    state: `first-broker-${expectation}`,
+    nonce: `nonce-${expectation}`,
+    code_challenge: "K2qUEfBl-nQvF2gB4dNxC2zYVwZc1CVnZb5CsX2L7fI",
+    code_challenge_method: "S256",
+    kc_idp_hint: "mock-google",
+  });
+
+  await page.goto(authorizationUrl.toString());
+  await page.waitForURL(/\/realms\/mock-google\//u);
+  await page.locator("#username").fill("mock-collision-user");
+  await page.locator("#password").fill(mockPassword);
+  await page.locator("#kc-login").click();
+  await page.waitForLoadState("domcontentloaded");
+
+  if (expectation === "vulnerable") {
+    await page.waitForURL(/localhost:8088\/\?.*code=/u);
+    const identities = await federatedIdentities(token, user.id);
+    assert.equal(
+      identities.some(({ identityProvider }) => identityProvider === "mock-google"),
+      true,
+      "unsafe AutoLink should attach the attacker-controlled identity",
+    );
+    await removeMockLink(token, user.id);
+  } else {
+    assert.match(page.url(), /\/realms\/keycloak-patterns\//u);
+    const body = (await page.locator("body").innerText()).toLowerCase();
+    assert.match(body, /account already exists|link existing account|existing account/u);
+    const identities = await federatedIdentities(token, user.id);
+    assert.equal(
+      identities.some(({ identityProvider }) => identityProvider === "mock-google"),
+      false,
+      "Confirm Link must not attach the identity without ownership proof",
+    );
+  }
+
+  console.log(`first broker login ${expectation} case verified`);
+} finally {
+  await browser.close();
+}

google-e2e/package-lock.json

@@ -0,0 +1,27 @@
+{
+  "name": "keycloak-google-broker-e2e",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "keycloak-google-broker-e2e",
+      "version": "1.0.0",
+      "dependencies": {
+        "playwright-core": "1.55.1"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.55.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.55.1.tgz",
+      "integrity": "sha512-Z6Mh9mkwX+zxSlHqdr5AOcJnfp+xUWLCt9uKV18fhzA8eyxUd8NUWzAjxUh55RZKSYwDGX0cfaySdhZJGMoJ+w==",
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

google-e2e/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "keycloak-google-broker-e2e",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "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: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

@@ -24,6 +24,10 @@
       {
         "name": "user-role",
         "description": "Regular authenticated user role"
+      },
+      {
+        "name": "employee-role",
+        "description": "Assigned to brokered identities whose hosted-domain claim is example.test"
       }
     ]
   },
@@ -139,6 +143,108 @@
       }
     }
   ],
+  "identityProviders": [
+    {
+      "alias": "mock-google",
+      "displayName": "Mock Google (local verification)",
+      "providerId": "oidc",
+      "enabled": true,
+      "updateProfileFirstLoginMode": "off",
+      "trustEmail": false,
+      "storeToken": false,
+      "addReadTokenRoleOnCreate": false,
+      "authenticateByDefault": false,
+      "linkOnly": false,
+      "firstBrokerLoginFlowAlias": "first broker login",
+      "config": {
+        "clientId": "mock-google-broker",
+        "clientSecret": "${MOCK_GOOGLE_BROKER_CLIENT_SECRET}",
+        "authorizationUrl": "http://localhost:8080/realms/mock-google/protocol/openid-connect/auth",
+        "tokenUrl": "http://keycloak:8080/realms/mock-google/protocol/openid-connect/token",
+        "userInfoUrl": "http://keycloak:8080/realms/mock-google/protocol/openid-connect/userinfo",
+        "issuer": "http://localhost:8080/realms/mock-google",
+        "jwksUrl": "http://keycloak:8080/realms/mock-google/protocol/openid-connect/certs",
+        "useJwksUrl": "true",
+        "validateSignature": "true",
+        "defaultScope": "openid profile email",
+        "syncMode": "IMPORT",
+        "pkceEnabled": "true",
+        "pkceMethod": "S256"
+      }
+    }
+  ],
+  "identityProviderMappers": [
+    {
+      "name": "mock-google-stable-username",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-username-idp-mapper",
+      "config": {
+        "template": "${ALIAS}.${CLAIM.sub}",
+        "target": "LOCAL"
+      }
+    },
+    {
+      "name": "mock-google-email",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-user-attribute-idp-mapper",
+      "config": {
+        "syncMode": "INHERIT",
+        "claim": "email",
+        "user.attribute": "email"
+      }
+    },
+    {
+      "name": "mock-google-given-name",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-user-attribute-idp-mapper",
+      "config": {
+        "syncMode": "INHERIT",
+        "claim": "given_name",
+        "user.attribute": "firstName"
+      }
+    },
+    {
+      "name": "mock-google-family-name",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-user-attribute-idp-mapper",
+      "config": {
+        "syncMode": "INHERIT",
+        "claim": "family_name",
+        "user.attribute": "lastName"
+      }
+    },
+    {
+      "name": "mock-google-picture",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-user-attribute-idp-mapper",
+      "config": {
+        "syncMode": "INHERIT",
+        "claim": "picture",
+        "user.attribute": "picture"
+      }
+    },
+    {
+      "name": "mock-google-hosted-domain",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-user-attribute-idp-mapper",
+      "config": {
+        "syncMode": "INHERIT",
+        "claim": "hd",
+        "user.attribute": "hd"
+      }
+    },
+    {
+      "name": "mock-google-example-domain-role",
+      "identityProviderAlias": "mock-google",
+      "identityProviderMapper": "oidc-role-idp-mapper",
+      "config": {
+        "syncMode": "INHERIT",
+        "claim": "hd",
+        "claim.value": "example.test",
+        "role": "employee-role"
+      }
+    }
+  ],
   "users": [
     {
       "username": "admin-user",

keycloak/import/mock-google-realm.json

@@ -0,0 +1,93 @@
+{
+  "realm": "mock-google",
+  "displayName": "Controllable Google OIDC Test Provider",
+  "enabled": true,
+  "sslRequired": "external",
+  "registrationAllowed": false,
+  "resetPasswordAllowed": false,
+  "editUsernameAllowed": false,
+  "loginWithEmailAllowed": true,
+  "duplicateEmailsAllowed": false,
+  "bruteForceProtected": true,
+  "clients": [
+    {
+      "clientId": "mock-google-broker",
+      "name": "Main Realm Identity Broker",
+      "enabled": true,
+      "protocol": "openid-connect",
+      "publicClient": false,
+      "clientAuthenticatorType": "client-secret",
+      "secret": "${MOCK_GOOGLE_BROKER_CLIENT_SECRET}",
+      "standardFlowEnabled": true,
+      "implicitFlowEnabled": false,
+      "directAccessGrantsEnabled": false,
+      "serviceAccountsEnabled": false,
+      "redirectUris": [
+        "http://localhost:8080/realms/keycloak-patterns/broker/mock-google/endpoint"
+      ],
+      "webOrigins": [],
+      "protocolMappers": [
+        {
+          "name": "hosted-domain",
+          "protocol": "openid-connect",
+          "protocolMapper": "oidc-hardcoded-claim-mapper",
+          "consentRequired": false,
+          "config": {
+            "claim.name": "hd",
+            "claim.value": "example.test",
+            "jsonType.label": "String",
+            "id.token.claim": "true",
+            "access.token.claim": "true",
+            "userinfo.token.claim": "true"
+          }
+        },
+        {
+          "name": "picture",
+          "protocol": "openid-connect",
+          "protocolMapper": "oidc-hardcoded-claim-mapper",
+          "consentRequired": false,
+          "config": {
+            "claim.name": "picture",
+            "claim.value": "https://images.example.test/mock-user.png",
+            "jsonType.label": "String",
+            "id.token.claim": "true",
+            "access.token.claim": "true",
+            "userinfo.token.claim": "true"
+          }
+        }
+      ]
+    }
+  ],
+  "users": [
+    {
+      "username": "mock-new-user",
+      "enabled": true,
+      "email": "broker-new-user@example.test",
+      "emailVerified": true,
+      "firstName": "Broker",
+      "lastName": "New",
+      "credentials": [
+        {
+          "type": "password",
+          "value": "${MOCK_GOOGLE_USER_PASSWORD}",
+          "temporary": false
+        }
+      ]
+    },
+    {
+      "username": "mock-collision-user",
+      "enabled": true,
+      "email": "regular-user@example.test",
+      "emailVerified": false,
+      "firstName": "Broker",
+      "lastName": "Collision",
+      "credentials": [
+        {
+          "type": "password",
+          "value": "${MOCK_GOOGLE_USER_PASSWORD}",
+          "temporary": false
+        }
+      ]
+    }
+  ]
+}

scripts/audit-keycloak-branches.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env sh
+set -eu
+
+manifest="${1:-docs/keycloak-branch-manifest.tsv}"
+notes_dir="${KEYCLOAK_BRANCH_NOTES_DIR:-/home/donghyeon/workspace/ai-tools/llm-wiki/raw/branch-notes}"
+
+expected_count="$(awk 'NR > 1 { count += 1 } END { print count + 0 }' "$manifest")"
+if [ "$expected_count" -ne 39 ]; then
+  echo "manifest must contain exactly 39 Keycloak branches; found $expected_count" >&2
+  exit 1
+fi
+
+note_count="$(find "$notes_dir" -maxdepth 1 -type f -name 'feature-keycloak-*.md' | wc -l)"
+if [ "$note_count" -ne 39 ]; then
+  echo "branch-note inventory must contain exactly 39 files; found $note_count" >&2
+  exit 1
+fi
+
+missing=0
+unmerged=0
+tab="$(printf '\t')"
+
+while IFS="$tab" read -r branch target delivery; do
+  [ "$branch" = "branch" ] && continue
+
+  note_name="$(printf '%s\n' "$branch" |
+    sed 's#^feature/keycloak-#feature-keycloak-#').md"
+  if [ ! -f "$notes_dir/$note_name" ]; then
+    echo "missing branch note: $note_name" >&2
+    missing=$((missing + 1))
+  fi
+
+  if ! git show-ref --verify --quiet "refs/heads/$branch"; then
+    echo "missing local branch: $branch" >&2
+    missing=$((missing + 1))
+    continue
+  fi
+
+  case "$target" in
+    common) target_branch="develop" ;;
+    ap1) target_branch="develop-keycloak-pattern1" ;;
+    ap2) target_branch="develop-keycloak-pattern2" ;;
+    ap3) target_branch="develop-keycloak-pattern3" ;;
+    ap4) target_branch="develop-keycloak-pattern4" ;;
+    *)
+      echo "unknown target '$target' for $branch ($delivery)" >&2
+      exit 1
+      ;;
+  esac
+
+  if ! git merge-base --is-ancestor "$branch" "$target_branch"; then
+    echo "feature tip is not merged: $branch -> $target_branch" >&2
+    unmerged=$((unmerged + 1))
+  fi
+done < "$manifest"
+
+if [ "$missing" -ne 0 ] || [ "$unmerged" -ne 0 ]; then
+  echo "Keycloak branch audit failed: missing=$missing unmerged=$unmerged" >&2
+  exit 1
+fi
+
+echo "Keycloak branch audit passed: 39/39 branches exist and are merged"

scripts/configure-broker-user-profile.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+keycloak_url="${KEYCLOAK_URL:-http://localhost:8080}"
+realm="${KEYCLOAK_REALM:-keycloak-patterns}"
+profile_url="$keycloak_url/admin/realms/$realm/users/profile"
+
+admin_token="$(
+  curl -fsS \
+    -d client_id=admin-cli \
+    -d grant_type=password \
+    -d "username=$KC_BOOTSTRAP_ADMIN_USERNAME" \
+    -d "password=$KC_BOOTSTRAP_ADMIN_PASSWORD" \
+    "$keycloak_url/realms/master/protocol/openid-connect/token" |
+    jq -er .access_token
+)"
+
+profile="$(curl -fsS -H "Authorization: Bearer $admin_token" "$profile_url")"
+updated_profile="$(
+  printf '%s' "$profile" |
+    jq '
+      def broker_attribute($name; $label): {
+        name: $name,
+        displayName: $label,
+        validations: {length: {max: 2048}},
+        permissions: {
+          view: ["admin", "user"],
+          edit: ["admin"]
+        },
+        multivalued: false,
+        group: "user-metadata"
+      };
+      if any(.attributes[]; .name == "picture") then .
+      else .attributes += [broker_attribute("picture"; "Profile picture URL")]
+      end |
+      if any(.attributes[]; .name == "hd") then .
+      else .attributes += [broker_attribute("hd"; "Hosted domain")]
+      end
+    '
+)"
+
+printf '%s' "$updated_profile" |
+  curl -fsS -X PUT \
+    -H "Authorization: Bearer $admin_token" \
+    -H "Content-Type: application/json" \
+    --data @- \
+    "$profile_url"
+
+echo "Broker user-profile attributes configured for realm '$realm'"

scripts/configure-google-idp.sh

@@ -0,0 +1,154 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+: "${KC_BOOTSTRAP_ADMIN_USERNAME:?set KC_BOOTSTRAP_ADMIN_USERNAME in .env}"
+: "${KC_BOOTSTRAP_ADMIN_PASSWORD:?set KC_BOOTSTRAP_ADMIN_PASSWORD in .env}"
+: "${GOOGLE_CLIENT_ID:?set GOOGLE_CLIENT_ID in .env}"
+: "${GOOGLE_CLIENT_SECRET:?set GOOGLE_CLIENT_SECRET in .env}"
+
+./scripts/configure-broker-user-profile.sh
+
+keycloak_url="${KEYCLOAK_URL:-http://localhost:8080}"
+realm="${KEYCLOAK_REALM:-keycloak-patterns}"
+
+admin_token="$(
+  curl -fsS \
+    -d client_id=admin-cli \
+    -d grant_type=password \
+    -d "username=$KC_BOOTSTRAP_ADMIN_USERNAME" \
+    -d "password=$KC_BOOTSTRAP_ADMIN_PASSWORD" \
+    "$keycloak_url/realms/master/protocol/openid-connect/token" |
+    jq -er .access_token
+)"
+
+payload="$(
+  jq -n \
+    --arg client_id "$GOOGLE_CLIENT_ID" \
+    --arg client_secret "$GOOGLE_CLIENT_SECRET" \
+    '{
+      alias: "google",
+      displayName: "Sign in with Google",
+      providerId: "google",
+      enabled: true,
+      updateProfileFirstLoginMode: "off",
+      trustEmail: false,
+      storeToken: false,
+      addReadTokenRoleOnCreate: false,
+      authenticateByDefault: false,
+      linkOnly: false,
+      firstBrokerLoginFlowAlias: "first broker login",
+      config: {
+        clientId: $client_id,
+        clientSecret: $client_secret,
+        defaultScope: "openid profile email",
+        syncMode: "IMPORT"
+      }
+    }'
+)"
+
+endpoint="$keycloak_url/admin/realms/$realm/identity-provider/instances"
+status="$(
+  curl -sS -o /dev/null -w '%{http_code}' \
+    -H "Authorization: Bearer $admin_token" \
+    "$endpoint/google"
+)"
+
+if [ "$status" = "200" ]; then
+  curl -fsS -X PUT \
+    -H "Authorization: Bearer $admin_token" \
+    -H "Content-Type: application/json" \
+    --data "$payload" \
+    "$endpoint/google"
+  action="updated"
+else
+  curl -fsS -X POST \
+    -H "Authorization: Bearer $admin_token" \
+    -H "Content-Type: application/json" \
+    --data "$payload" \
+    "$endpoint"
+  action="created"
+fi
+
+mapper_endpoint="$endpoint/google/mappers"
+upsert_mapper() {
+  mapper_name="$1"
+  mapper_type="$2"
+  mapper_config="$3"
+  mapper_id="$(
+    curl -fsS \
+      -H "Authorization: Bearer $admin_token" \
+      "$mapper_endpoint" |
+      jq -r --arg name "$mapper_name" '
+        .[] | select(.name == $name) | .id
+      ' |
+      head -1
+  )"
+  mapper_payload="$(
+    jq -n \
+      --arg name "$mapper_name" \
+      --arg alias "google" \
+      --arg mapper "$mapper_type" \
+      --argjson config "$mapper_config" \
+      '{
+        name: $name,
+        identityProviderAlias: $alias,
+        identityProviderMapper: $mapper,
+        config: $config
+      }'
+  )"
+  if [ -n "$mapper_id" ]; then
+    curl -fsS -X PUT \
+      -H "Authorization: Bearer $admin_token" \
+      -H "Content-Type: application/json" \
+      --data "$mapper_payload" \
+      "$mapper_endpoint/$mapper_id"
+  else
+    curl -fsS -X POST \
+      -H "Authorization: Bearer $admin_token" \
+      -H "Content-Type: application/json" \
+      --data "$mapper_payload" \
+      "$mapper_endpoint"
+  fi
+}
+
+upsert_mapper \
+  "google-stable-username" \
+  "oidc-username-idp-mapper" \
+  '{"template":"${ALIAS}.${CLAIM.sub}","target":"LOCAL"}'
+upsert_mapper \
+  "google-email" \
+  "oidc-user-attribute-idp-mapper" \
+  '{"syncMode":"INHERIT","claim":"email","user.attribute":"email"}'
+upsert_mapper \
+  "google-given-name" \
+  "oidc-user-attribute-idp-mapper" \
+  '{"syncMode":"INHERIT","claim":"given_name","user.attribute":"firstName"}'
+upsert_mapper \
+  "google-family-name" \
+  "oidc-user-attribute-idp-mapper" \
+  '{"syncMode":"INHERIT","claim":"family_name","user.attribute":"lastName"}'
+upsert_mapper \
+  "google-picture" \
+  "oidc-user-attribute-idp-mapper" \
+  '{"syncMode":"INHERIT","claim":"picture","user.attribute":"picture"}'
+upsert_mapper \
+  "google-hosted-domain" \
+  "oidc-user-attribute-idp-mapper" \
+  '{"syncMode":"INHERIT","claim":"hd","user.attribute":"hd"}'
+upsert_mapper \
+  "google-example-domain-role" \
+  "oidc-role-idp-mapper" \
+  '{"syncMode":"INHERIT","claim":"hd","claim.value":"example.test","role":"employee-role"}'
+
+echo "Google Identity Provider $action for realm '$realm'"
+echo "Register this exact Google redirect URI:"
+echo "$keycloak_url/realms/$realm/broker/google/endpoint"

scripts/set-first-broker-login-mode.sh

@@ -0,0 +1,178 @@
+#!/usr/bin/env sh
+set -eu
+
+mode="${1:-}"
+case "$mode" in
+  vulnerable|secure) ;;
+  *)
+    echo "usage: $0 vulnerable|secure" >&2
+    exit 1
+    ;;
+esac
+
+if [ ! -f .env ]; then
+  echo "missing .env" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+keycloak_url="${KEYCLOAK_URL:-http://localhost:8080}"
+realm="${KEYCLOAK_REALM:-keycloak-patterns}"
+admin_base="$keycloak_url/admin/realms/$realm"
+vulnerable_flow="vulnerable first broker login"
+idp_url="$admin_base/identity-provider/instances/mock-google"
+
+admin_token="$(
+  curl -fsS \
+    -d client_id=admin-cli \
+    -d grant_type=password \
+    -d "username=$KC_BOOTSTRAP_ADMIN_USERNAME" \
+    -d "password=$KC_BOOTSTRAP_ADMIN_PASSWORD" \
+    "$keycloak_url/realms/master/protocol/openid-connect/token" |
+    jq -er .access_token
+)"
+
+auth_header="Authorization: Bearer $admin_token"
+encode() {
+  jq -rn --arg value "$1" '$value | @uri'
+}
+
+flows="$(curl -fsS -H "$auth_header" "$admin_base/authentication/flows")"
+flow_id="$(
+  printf '%s' "$flows" |
+    jq -r --arg alias "$vulnerable_flow" '
+      .[] | select(.alias == $alias) | .id
+    ' |
+    head -1
+)"
+
+if [ -n "$flow_id" ]; then
+  existing_executions="$(
+    curl -fsS -H "$auth_header" \
+      "$admin_base/authentication/flows/$(encode "$vulnerable_flow")/executions"
+  )"
+  if printf '%s' "$existing_executions" | jq -e '
+    any(.[]; .authenticationFlow == true)
+  ' >/dev/null; then
+    idp_before_delete="$(curl -fsS -H "$auth_header" "$idp_url")"
+    printf '%s' "$idp_before_delete" |
+      jq '.firstBrokerLoginFlowAlias = "first broker login"' |
+      curl -fsS -X PUT \
+        -H "$auth_header" \
+        -H "Content-Type: application/json" \
+        --data @- \
+        "$idp_url"
+    curl -fsS -X DELETE \
+      -H "$auth_header" \
+      "$admin_base/authentication/flows/$flow_id"
+    flow_id=""
+  fi
+fi
+
+if [ -z "$flow_id" ]; then
+  curl -fsS -X POST \
+    -H "$auth_header" \
+    -H "Content-Type: application/json" \
+    --data "$(
+      jq -n --arg alias "$vulnerable_flow" '{
+        alias: $alias,
+        description: "INSECURE LEARNING FLOW - automatic email linking",
+        providerId: "basic-flow",
+        topLevel: true,
+        builtIn: false
+      }'
+    )" \
+    "$admin_base/authentication/flows"
+fi
+
+executions_url="$admin_base/authentication/flows/$(encode "$vulnerable_flow")/executions"
+executions="$(curl -fsS -H "$auth_header" "$executions_url")"
+create_user_id="$(
+  printf '%s' "$executions" |
+    jq -r '.[] | select(.providerId == "idp-create-user-if-unique") | .id' |
+    head -1
+)"
+if [ -z "$create_user_id" ]; then
+  curl -fsS -X POST \
+    -H "$auth_header" \
+    -H "Content-Type: application/json" \
+    --data '{"provider":"idp-create-user-if-unique"}' \
+    "$admin_base/authentication/flows/$(encode "$vulnerable_flow")/executions/execution"
+  executions="$(curl -fsS -H "$auth_header" "$executions_url")"
+  create_user_id="$(
+    printf '%s' "$executions" |
+      jq -r '.[] | select(.providerId == "idp-create-user-if-unique") | .id' |
+      head -1
+  )"
+fi
+
+auto_link_id="$(
+  printf '%s' "$executions" |
+    jq -r '.[] | select(.providerId == "idp-auto-link") | .id' |
+    head -1
+)"
+
+if [ -z "$auto_link_id" ]; then
+  curl -fsS -X POST \
+    -H "$auth_header" \
+    -H "Content-Type: application/json" \
+    --data '{"provider":"idp-auto-link"}' \
+    "$admin_base/authentication/flows/$(encode "$vulnerable_flow")/executions/execution"
+  executions="$(curl -fsS -H "$auth_header" "$executions_url")"
+  auto_link_id="$(
+    printf '%s' "$executions" |
+      jq -r '.[] | select(.providerId == "idp-auto-link") | .id' |
+      head -1
+  )"
+fi
+
+if [ "$mode" = "vulnerable" ]; then
+  curl -fsS -X PUT \
+    -H "$auth_header" \
+    -H "Content-Type: application/json" \
+    --data "$(jq -n --arg id "$create_user_id" '{id: $id, requirement: "ALTERNATIVE"}')" \
+    "$executions_url"
+  curl -fsS -X PUT \
+    -H "$auth_header" \
+    -H "Content-Type: application/json" \
+    --data "$(jq -n --arg id "$auto_link_id" '{id: $id, requirement: "ALTERNATIVE"}')" \
+    "$executions_url"
+  selected_flow="$vulnerable_flow"
+else
+  selected_flow="first broker login"
+fi
+
+idp="$(curl -fsS -H "$auth_header" "$idp_url")"
+printf '%s' "$idp" |
+  jq --arg flow "$selected_flow" '.firstBrokerLoginFlowAlias = $flow' |
+  curl -fsS -X PUT \
+    -H "$auth_header" \
+    -H "Content-Type: application/json" \
+    --data @- \
+    "$idp_url"
+
+assigned="$(
+  curl -fsS -H "$auth_header" "$idp_url" |
+    jq -r .firstBrokerLoginFlowAlias
+)"
+test "$assigned" = "$selected_flow"
+
+if [ "$mode" = "secure" ]; then
+  secure_executions="$(
+    curl -fsS -H "$auth_header" \
+      "$admin_base/authentication/flows/$(encode "first broker login")/executions"
+  )"
+  printf '%s' "$secure_executions" | jq -e '
+    any(.[];
+      .providerId == "idp-confirm-link" and .requirement == "REQUIRED"
+    ) and
+    (any(.[];
+      .providerId == "idp-auto-link" and .requirement != "DISABLED"
+    ) | not)
+  ' >/dev/null
+fi
+
+echo "mock-google First Broker Login mode: $mode ($selected_flow)"

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-federation-spa-zero-change.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env sh
+set -eu
+
+set -a
+. ./.env
+set +a
+
+./scripts/set-first-broker-login-mode.sh secure
+npm --prefix e2e ci
+MOCK_GOOGLE_USER_PASSWORD="$MOCK_GOOGLE_USER_PASSWORD" \
+  npm --prefix e2e run test:federation-zero-change

scripts/verify-first-broker-login.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+restore_secure_flow() {
+  ./scripts/set-first-broker-login-mode.sh secure >/dev/null 2>&1 || true
+}
+trap restore_secure_flow 0 1 2 15
+
+npm --prefix google-e2e ci
+
+./scripts/set-first-broker-login-mode.sh vulnerable
+FIRST_BROKER_EXPECTATION=vulnerable \
+  npm --prefix google-e2e run test:first-broker
+
+./scripts/set-first-broker-login-mode.sh secure
+FIRST_BROKER_EXPECTATION=secure \
+  npm --prefix google-e2e run test:first-broker
+
+trap - 0 1 2 15
+echo "First Broker Login verified: unsafe AutoLink reproduced, Confirm Link restored"

scripts/verify-google-broker-config.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+keycloak_url="${KEYCLOAK_URL:-http://localhost:8080}"
+
+admin_token="$(
+  curl -fsS \
+    -d client_id=admin-cli \
+    -d grant_type=password \
+    -d "username=$KC_BOOTSTRAP_ADMIN_USERNAME" \
+    -d "password=$KC_BOOTSTRAP_ADMIN_PASSWORD" \
+    "$keycloak_url/realms/master/protocol/openid-connect/token" |
+    jq -er .access_token
+)"
+
+idp="$(
+  curl -fsS \
+    -H "Authorization: Bearer $admin_token" \
+    "$keycloak_url/admin/realms/keycloak-patterns/identity-provider/instances/mock-google"
+)"
+
+printf '%s' "$idp" | jq -e '
+  .providerId == "oidc" and
+  .enabled == true and
+  .trustEmail == false and
+  .config.clientId == "mock-google-broker" and
+  .config.defaultScope == "openid profile email" and
+  .config.syncMode == "IMPORT" and
+  .config.validateSignature == "true"
+' >/dev/null
+
+client="$(
+  curl -fsS \
+    -H "Authorization: Bearer $admin_token" \
+    "$keycloak_url/admin/realms/mock-google/clients?clientId=mock-google-broker"
+)"
+
+printf '%s' "$client" | jq -e '
+  length == 1 and
+  .[0].publicClient == false and
+  (.[0].redirectUris | index(
+    "http://localhost:8080/realms/keycloak-patterns/broker/mock-google/endpoint"
+  )) != null
+' >/dev/null
+
+location="$(
+  curl -sS -D - -o /dev/null \
+    "$keycloak_url/realms/keycloak-patterns/protocol/openid-connect/auth?client_id=spa-public&redirect_uri=http%3A%2F%2Flocalhost%3A8088%2F&response_type=code&scope=openid&code_challenge=K2qUEfBl-nQvF2gB4dNxC2zYVwZc1CVnZb5CsX2L7fI&code_challenge_method=S256&kc_idp_hint=mock-google" |
+    awk 'BEGIN { IGNORECASE=1 } /^Location:/ { print $2 }' |
+    tr -d '\r'
+)"
+
+case "$location" in
+  "$keycloak_url/realms/keycloak-patterns/broker/mock-google/login"*) ;;
+  *)
+    echo "broker did not redirect to the controllable OIDC provider: $location" >&2
+    exit 1
+    ;;
+esac
+
+echo "Google broker contract verified with the local mock OIDC realm"

scripts/verify-google-claim-mapping.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+./scripts/configure-broker-user-profile.sh
+./scripts/set-first-broker-login-mode.sh secure
+npm --prefix google-e2e ci
+npm --prefix google-e2e run test:claim-mapping

scripts/verify-google-claim-to-role.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env sh
+set -eu
+
+set -a
+. ./.env
+set +a
+
+./scripts/configure-broker-user-profile.sh >/dev/null
+./scripts/set-first-broker-login-mode.sh secure
+
+docker compose exec -T keycloak \
+  /opt/keycloak/bin/kcadm.sh create roles -r keycloak-patterns \
+  -s name=employee-role \
+  -s 'description=Assigned from the upstream hd claim' >/dev/null 2>&1 || true
+
+cd google-e2e
+npm install --ignore-scripts
+npm run test:claim-to-role

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-internal-spa-no-google-contract.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env sh
+set -eu
+
+jq -e '
+  (.clients[] | select(.clientId == "spa-public")
+    | .publicClient == true
+      and .attributes["pkce.code.challenge.method"] == "S256")
+  and
+  ([.users[].username] | index("regular-user") != null)
+' keycloak/import/keycloak-patterns-realm.json >/dev/null
+
+npm --prefix frontend test
+echo "AP1 local-identity profile verified without a Google dependency"

scripts/verify-pkce-flow-stages.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env sh
+set -eu
+
+npm --prefix frontend ci
+npm --prefix frontend test
+
+jq -e '
+  .clients[]
+  | select(.clientId == "spa-public")
+  | .publicClient == true
+    and .standardFlowEnabled == true
+    and .implicitFlowEnabled == false
+    and .directAccessGrantsEnabled == false
+    and .attributes["pkce.code.challenge.method"] == "S256"
+' keycloak/import/keycloak-patterns-realm.json >/dev/null
+
+rg -q 'response_type: "code"' frontend/src/app.js
+rg -q 'new InMemoryWebStorage' frontend/src/app.js
+rg -Fq 'cryptoApi.subtle.digest(' frontend/src/pkce.js
+rg -Fq '"SHA-256"' frontend/src/pkce.js
+echo "PKCE stages verified: verifier -> S256 challenge -> code -> verifier exchange"

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-refresh-token-rotation-contract.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+set -eu
+
+jq -e '
+  .revokeRefreshToken == true
+  and .refreshTokenMaxReuse == 0
+  and .accessTokenLifespan <= 300
+' keycloak/import/keycloak-patterns-realm.json >/dev/null
+
+rg -Fq 'assert.notEqual(rotated.refresh_token, secondTokenSet.refresh_token)' \
+  e2e/pattern1.mjs
+rg -Fq 'a consumed refresh token must not be accepted again' e2e/pattern1.mjs
+rg -Fq 'refresh revoke is not an immediate deny-list' e2e/pattern1.mjs
+
+echo "Refresh rotation/reuse/revocation contract verified"
+echo "Run ./scripts/verify-pattern1.sh for the destructive live-token E2E"

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"

scripts/verify-spring-role-mapping.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env sh
+set -eu
+
+set -a
+. ./.env
+set +a
+
+docker compose down --volumes --remove-orphans
+docker compose up --build -d --wait
+npm --prefix e2e ci
+REGULAR_USER_PASSWORD="$REGULAR_USER_PASSWORD" \
+ADMIN_USER_PASSWORD="$ADMIN_USER_PASSWORD" \
+  npm --prefix e2e run test:role-mapping