feat: add validated Traefik ForwardAuth alternative

# Conflicts:
#	.env.example

.env.example

@@ -10,6 +10,8 @@ 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
+OAUTH2_PROXY_COOKIE_SECRET=generate-a-base64-encoded-32-byte-secret
+INTERNAL_AUTH_TOKEN=generate-a-long-random-edge-to-backend-token
 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

.gitignore

@@ -4,6 +4,8 @@
 *.iml
 
 backend/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`으로만 저장됩니다.
+
+## AP4: oauth2-proxy Edge Forward Auth
+
+`develop-keycloak-pattern4`는 oauth2-proxy와 Nginx `auth_request`가
+인증을 edge에서 강제하는 패턴입니다.
+
+```bash
+./scripts/verify-pattern4.sh
+```
+
+첫 feature에서는 oauth2-proxy를 `http://localhost:4180`에 직접 노출해
+OIDC redirect/PKCE/callback과 forwarded-user를 분리 확인합니다. 두 번째
+feature부터 `http://localhost:8088` Nginx가 단일 진입점이며, 내부
+`auth_request`는 브라우저 요청을 login 302로, API 요청을 JSON 401로
+구분합니다. 최종 feature에서는 backend와 oauth2-proxy의 호스트 노출을
+제거하고 Nginx 헤더 덮어쓰기와 내부 토큰 검증으로 spoofing을 막습니다.
+자세한 내용은
+[`docs/ap4-edge-forward-auth.md`](docs/ap4-edge-forward-auth.md)를
+참고하세요.

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

@@ -0,0 +1,59 @@
+package com.example.keycloakpattern;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import jakarta.servlet.http.HttpServletRequest;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class EdgeIdentityController {
+
+    private final byte[] internalAuthToken;
+
+    EdgeIdentityController(@Value("${edge.internal-auth-token}") String internalAuthToken) {
+        if (!hasText(internalAuthToken)) {
+            throw new IllegalStateException("edge.internal-auth-token must be configured");
+        }
+        this.internalAuthToken = internalAuthToken.getBytes(StandardCharsets.UTF_8);
+    }
+
+    @GetMapping("/edge/me")
+    ResponseEntity<Map<String, Object>> currentUser(HttpServletRequest request) {
+        String authRequestUser = request.getHeader("X-Auth-Request-User");
+        if (!hasText(authRequestUser) || !hasValidInternalToken(request)) {
+            return ResponseEntity.status(401).body(Map.of(
+                "error",
+                "trusted edge authentication is required"
+            ));
+        }
+
+        Map<String, Object> response = new LinkedHashMap<>();
+        response.put("pattern", "AP4-edge-forward-auth");
+        response.put("user", authRequestUser);
+        response.put("email", request.getHeader("X-Auth-Request-Email"));
+        response.put("identityHeader", "X-Auth-Request-User");
+        return ResponseEntity.ok(response);
+    }
+
+    private boolean hasValidInternalToken(HttpServletRequest request) {
+        String suppliedToken = request.getHeader("X-Internal-Auth-Token");
+        if (!hasText(suppliedToken)) {
+            return false;
+        }
+        return MessageDigest.isEqual(
+            internalAuthToken,
+            suppliedToken.getBytes(StandardCharsets.UTF_8)
+        );
+    }
+
+    private static boolean hasText(String value) {
+        return value != null && !value.isBlank();
+    }
+}

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

@@ -17,7 +17,12 @@ public class SecurityConfig {
             .sessionManagement(session ->
                 session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
             .authorizeHttpRequests(authorize -> authorize
-                .requestMatchers("/actuator/health", "/actuator/health/**", "/api/public")
+                .requestMatchers(
+                    "/actuator/health",
+                    "/actuator/health/**",
+                    "/api/public",
+                    "/edge/**"
+                )
                 .permitAll()
                 .anyRequest()
                 .authenticated())

backend/src/main/resources/application.yml

@@ -1,6 +1,9 @@
 server:
   port: ${SERVER_PORT:8081}
 
+edge:
+  internal-auth-token: ${EDGE_INTERNAL_AUTH_TOKEN:}
+
 spring:
   application:
     name: keycloak-pattern-api

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

@@ -11,7 +11,7 @@ import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMock
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.web.servlet.MockMvc;
 
-@SpringBootTest
+@SpringBootTest(properties = "edge.internal-auth-token=test-internal-edge-token")
 @AutoConfigureMockMvc
 class ApiSecurityTest {
 
@@ -40,4 +40,36 @@ class ApiSecurityTest {
             .andExpect(jsonPath("$.subject").value("test-subject"))
             .andExpect(jsonPath("$.username").value("regular-user"));
     }
+
+    @Test
+    void edgeEndpointRejectsMissingTrustedHeaders() throws Exception {
+        mockMvc.perform(get("/edge/me"))
+            .andExpect(status().isUnauthorized());
+    }
+
+    @Test
+    void edgeEndpointRejectsForgedIdentityWithoutInternalToken() throws Exception {
+        mockMvc.perform(get("/edge/me")
+                .header("X-Auth-Request-User", "spoofed-admin"))
+            .andExpect(status().isUnauthorized());
+    }
+
+    @Test
+    void edgeEndpointRejectsWrongInternalToken() throws Exception {
+        mockMvc.perform(get("/edge/me")
+                .header("X-Auth-Request-User", "spoofed-admin")
+                .header("X-Internal-Auth-Token", "wrong-token"))
+            .andExpect(status().isUnauthorized());
+    }
+
+    @Test
+    void edgeEndpointAcceptsIdentityFromTrustedEdge() throws Exception {
+        mockMvc.perform(get("/edge/me")
+                .header("X-Auth-Request-User", "regular-user")
+                .header("X-Auth-Request-Email", "regular-user@example.test")
+                .header("X-Internal-Auth-Token", "test-internal-edge-token"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.user").value("regular-user"))
+            .andExpect(jsonPath("$.identityHeader").value("X-Auth-Request-User"));
+    }
 }

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/traefik/dynamic.yml

@@ -0,0 +1,35 @@
+http:
+  routers:
+    oauth:
+      entryPoints:
+        - web
+      rule: PathPrefix(`/oauth2/`)
+      service: oauth2-proxy
+      priority: 100
+    application:
+      entryPoints:
+        - web
+      rule: PathPrefix(`/`)
+      middlewares:
+        - keycloak-forward-auth
+      service: application
+
+  middlewares:
+    keycloak-forward-auth:
+      forwardAuth:
+        address: http://oauth2-proxy:4180/oauth2/auth
+        trustForwardHeader: false
+        authResponseHeaders:
+          - X-Auth-Request-User
+          - X-Auth-Request-Email
+          - Set-Cookie
+
+  services:
+    oauth2-proxy:
+      loadBalancer:
+        servers:
+          - url: http://oauth2-proxy:4180
+    application:
+      loadBalancer:
+        servers:
+          - url: http://app:8081

deploy/traefik/traefik.yml

@@ -0,0 +1,14 @@
+entryPoints:
+  web:
+    address: ":8080"
+
+providers:
+  file:
+    filename: /etc/traefik/dynamic.yml
+    watch: false
+
+api:
+  dashboard: false
+
+log:
+  level: INFO

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

@@ -71,8 +71,9 @@ services:
       SERVER_PORT: "8081"
       SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI: http://localhost:8080/realms/keycloak-patterns
       SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI: http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/certs
-    ports:
+      EDGE_INTERNAL_AUTH_TOKEN: ${INTERNAL_AUTH_TOKEN:?set INTERNAL_AUTH_TOKEN in .env}
-      - "127.0.0.1:8081:8081"
+    expose:
+      - "8081"
     depends_on:
       keycloak:
         condition: service_healthy
@@ -88,13 +89,68 @@ services:
       - keycloak-net
     restart: unless-stopped
 
+  oauth2-proxy:
+    image: quay.io/oauth2-proxy/oauth2-proxy:v7.15.2
+    command:
+      - --http-address=0.0.0.0:4180
+      - --provider=keycloak-oidc
+      - --oidc-issuer-url=http://localhost:8080/realms/keycloak-patterns
+      - --skip-oidc-discovery=true
+      - --login-url=http://localhost:8080/realms/keycloak-patterns/protocol/openid-connect/auth
+      - --redeem-url=http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/token
+      - --oidc-jwks-url=http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/certs
+      - --profile-url=http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/userinfo
+      - --validate-url=http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/userinfo
+      - --redirect-url=http://localhost:8088/oauth2/callback
+      - --upstream=http://app:8081
+      - --email-domain=*
+      - --scope=openid profile email
+      - --code-challenge-method=S256
+      - --reverse-proxy=true
+      - --trusted-proxy-ip=172.30.40.10/32
+      - --cookie-name=AP4_SESSION
+      - --cookie-secure=false
+      - --cookie-samesite=lax
+      - --cookie-expire=1h
+      - --session-cookie-minimal=true
+      - --skip-provider-button=true
+      - --set-xauthrequest=true
+      - --pass-user-headers=true
+      - --whitelist-domain=localhost:8088
+      - --whitelist-domain=localhost:8080
+    environment:
+      OAUTH2_PROXY_CLIENT_ID: edge-proxy
+      OAUTH2_PROXY_CLIENT_SECRET: ${EDGE_PROXY_CLIENT_SECRET:?set EDGE_PROXY_CLIENT_SECRET in .env}
+      OAUTH2_PROXY_COOKIE_SECRET: ${OAUTH2_PROXY_COOKIE_SECRET:?set OAUTH2_PROXY_COOKIE_SECRET in .env}
+    expose:
+      - "4180"
+    depends_on:
+      keycloak:
+        condition: service_healthy
+      app:
+        condition: service_healthy
+    healthcheck:
+      test:
+        - CMD
+        - /bin/oauth2-proxy
+        - --version
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 5s
+    networks:
+      - keycloak-net
+    restart: unless-stopped
+
   nginx:
     build:
       context: ./frontend
+    environment:
+      INTERNAL_AUTH_TOKEN: ${INTERNAL_AUTH_TOKEN:?set INTERNAL_AUTH_TOKEN in .env}
     ports:
       - "127.0.0.1:${NGINX_PORT:-8088}:80"
     depends_on:
-      app:
+      oauth2-proxy:
         condition: service_healthy
     healthcheck:
       test:
@@ -104,7 +160,8 @@ services:
       timeout: 5s
       retries: 12
     networks:
-      - keycloak-net
+      keycloak-net:
+        ipv4_address: 172.30.40.10
     restart: unless-stopped
 
 volumes:
@@ -114,3 +171,6 @@ volumes:
 networks:
   keycloak-net:
     driver: bridge
+    ipam:
+      config:
+        - subnet: 172.30.40.0/24

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/ap4-edge-forward-auth.md

@@ -0,0 +1,70 @@
+# AP4 · oauth2-proxy Edge Forward Auth
+
+## 첫 단계: oauth2-proxy 자체 OIDC 흐름
+
+`feature/keycloak-oauth2-proxy-oidc-flow`에서는 oauth2-proxy를
+`http://localhost:4180`에 직접 노출해 구성 요소를 분리해서 확인합니다.
+
+1. `/edge/me` 미인증 요청이 Keycloak로 redirect됩니다.
+2. oauth2-proxy는 confidential `edge-proxy` client와 PKCE S256을 사용합니다.
+3. callback에서 code/token 교환과 ID/access token 검증은 서버끼리
+   수행합니다.
+4. 브라우저에는 HttpOnly `AP4_SESSION` cookie만 남습니다.
+5. oauth2-proxy가 backend 요청에 `X-Forwarded-User`를 붙여 200을 받습니다.
+
+Keycloak이 발급하는 issuer는 브라우저 기준
+`http://localhost:8080/realms/keycloak-patterns`입니다. 컨테이너 내부의
+`localhost`는 oauth2-proxy 자신이므로 discovery endpoint에 도달할 수
+없습니다. 그래서 이 로컬 Compose 구성은 issuer 검증값은 외부 URL로
+유지하되, login URL은 브라우저용 외부 주소, token/JWKS/userinfo는
+`http://keycloak:8080` 내부 주소로 각각 명시합니다.
+
+HTTP 로컬 시연이라 `cookie-secure=false`를 사용합니다. 운영 HTTPS에서는
+반드시 secure cookie로 되돌려야 합니다.
+
+## 다음 단계의 보안 전제
+
+이 첫 feature의 backend는 전달된 사용자 헤더를 신뢰하며 8081도
+loopback에 publish되어 있습니다. 따라서 로컬에서 직접
+`X-Forwarded-User: spoofed-admin`을 보내면 우회가 재현됩니다. 이후
+Nginx `auth_request` 통합을 거쳐 최종 feature에서 backend no-publish와
+내부 shared-secret 검증을 함께 적용합니다.
+
+## 두 번째 단계: Nginx `auth_request`
+
+`feature/keycloak-nginx-auth-request-integration`부터 외부 진입점은
+`http://localhost:8088` Nginx 하나입니다. oauth2-proxy의 4180 포트는
+Compose 네트워크에만 expose됩니다.
+
+- Nginx의 정확 일치 `location = /oauth2/auth`는 `internal`이라 외부에서
+  직접 호출할 수 없습니다.
+- 인증 서브리퀘스트에는 본문을 보내지 않고 `Content-Length`도
+  비웁니다.
+- 일반 브라우저 요청의 401은 `/oauth2/start` 302로 변환합니다.
+- API 요청 `/api/edge`는 redirect하지 않고 JSON 401을 반환합니다.
+- 인증 성공 시 oauth2-proxy의 `X-Auth-Request-User`와 email만 backend로
+  전달합니다.
+
+Nginx 컨테이너 IP를 전용 Compose subnet에서 고정하고 oauth2-proxy의
+trusted proxy를 그 단일 IP로 제한합니다. 다만 이 단계에서는 backend
+8081이 로컬 호스트에 열려 있어 신뢰 헤더를 직접 위조할 수 있습니다.
+그 재현 조건은 마지막 feature에서 제거합니다.
+
+## 마지막 단계: 신뢰 경계와 헤더 스푸핑 방어
+
+`feature/keycloak-header-spoofing-defense`에서는 신뢰 경계를 실제
+네트워크와 application 양쪽에서 강제합니다.
+
+1. backend 8081과 oauth2-proxy 4180은 host에 publish하지 않습니다.
+   브라우저가 접근 가능한 application 포트는 Nginx 8088뿐입니다.
+2. Nginx는 client가 보낸 `X-Auth-Request-User`, email, 내부 토큰을
+   그대로 전달하지 않고 oauth2-proxy 결과와 server-side 토큰으로
+   항상 덮어씁니다.
+3. backend는 `X-Auth-Request-User`와 `X-Internal-Auth-Token`이 모두
+   유효할 때만 edge identity를 받아들이며 token은 constant-time으로
+   비교합니다.
+
+shared token은 방어 심층화 수단입니다. 운영에서는 Secret Manager나
+orchestrator secret으로 주입하고 주기적으로 교체해야 합니다. 서비스
+간 mTLS 또는 service mesh identity를 사용할 수 있다면 단순 shared
+token보다 강한 workload identity로 대체하는 편이 좋습니다.

docs/edge-forwardauth-google-federation.md

@@ -0,0 +1,26 @@
+# AP4 edge forward-auth with Google federation
+
+Google federation은 AP4의 edge contract를 바꾸지 않는다.
+
+```text
+Browser -> nginx -> oauth2-proxy -> Keycloak -> Google
+Browser <- AP4_SESSION <- oauth2-proxy <- Keycloak
+nginx -> trusted identity headers -> upstream app
+```
+
+oauth2-proxy가 신뢰하는 issuer는 Google이 아니라 Keycloak이다. Google ID
+token은 Keycloak broker 경계 안에서 검증되고, oauth2-proxy는 Keycloak
+authorization code/token과 session cookie만 다룬다. upstream 앱도
+broker 여부와 무관하게 동일한 trusted headers를 받는다.
+
+`verify-edge-google-federation.sh`는 mock Google 로그인, confidential
+server-side token 교환(브라우저에 token 요청 없음), 미검증 broker email 거부,
+Keycloak email verification 완료 후 HttpOnly edge cookie와 brokered
+subject/email header를 실제 컨테이너와 브라우저로 검증한다. minimal session의
+`X-Auth-Request-User`는 표시용 username이 아니라 Keycloak의 안정적인 local
+subject UUID이며, 화면 이름이 필요하면 별도 허용 header를 명시한다.
+
+brokered token/claims가 client-side session cookie의 4KB 한계를 넘지 않도록
+oauth2-proxy에는 `session-cookie-minimal=true`를 적용한다. AP4 upstream은
+token forwarding이 아니라 trusted identity headers만 사용하므로 cookie에
+access/refresh/ID token을 보관할 필요가 없다.

docs/edge-forwardauth-no-google.md

@@ -0,0 +1,20 @@
+# AP4 edge forward-auth: local identity profile
+
+nginx의 `auth_request`가 oauth2-proxy `/oauth2/auth`를 호출하고, 미인증
+브라우저만 Keycloak로 redirect한다. oauth2-proxy는 confidential
+`edge-proxy` client로 code를 교환하며 browser에는 HttpOnly session cookie만
+남긴다.
+
+Google이 없어도 이 경계는 완전히 동작한다. 사용자는 Keycloak local
+credential로 로그인하고 upstream 애플리케이션은 OAuth/OIDC를 몰라도 된다.
+
+보안 경계:
+
+- backend와 oauth2-proxy 포트를 host에 publish하지 않는다.
+- 외부에서 받은 identity header를 nginx가 제거·덮어쓴다.
+- backend는 trusted nginx가 주입하는 별도 internal token도 확인한다.
+- 브라우저가 직접 호출한 `/oauth2/auth`는 공개하지 않는다.
+
+`verify-edge-no-google-profile.sh`는 Compose와 nginx 계약을 검사하고,
+`verify-pattern4.sh`는 실제 local-user 브라우저 흐름과 spoofing 방어를
+검증한다.

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

docs/traefik-forwardauth-alternative.md

@@ -0,0 +1,22 @@
+# Traefik ForwardAuth alternative
+
+Traefik의 `forwardAuth` middleware는 nginx `auth_request`와 같은 정책 지점을
+제공한다. 예제는 `/oauth2/auth`를 oauth2-proxy에 위임하고 성공 응답의
+허용된 identity headers만 application request로 복사한다.
+
+중요한 차이:
+
+- ForwardAuth 자체는 OIDC client나 session manager가 아니다. 이 예제에서도
+  oauth2-proxy가 code 교환과 cookie를 담당한다.
+- `trustForwardHeader=false`로 외부 forwarded header를 신뢰하지 않는다.
+- `/oauth2/` router는 callback/start 경로를 oauth2-proxy에 연결해야 한다.
+- nginx의 `error_page 401 -> /oauth2/start`와 같은 로그인 redirect UX는
+  Traefik errors middleware 또는 oauth2-proxy의 forward-auth redirect
+  profile을 추가로 설계해야 한다.
+- Docker socket label discovery 대신 file provider를 사용해 socket 노출을
+  피했다. Kubernetes에서는 Middleware/IngressRoute CRD라는 vendor-specific
+  운영 객체가 추가된다.
+
+이 repository의 실제 AP4 baseline은 학습 가시성이 높은 nginx 조합을
+유지한다. `verify-traefik-forwardauth-config.sh`는 대안 파일을 Traefik
+binary로 로드하고 즉시 발생하는 provider/config 오류가 없는지 확인한다.

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,13 @@
+{
+  "name": "keycloak-pattern-e2e",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "test:pattern4": "node pattern4.mjs",
+    "test:pattern4-google": "node pattern4-google.mjs"
+  },
+  "devDependencies": {
+    "playwright-core": "1.62.0"
+  }
+}

e2e/pattern4-google.mjs

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const password = process.env.MOCK_GOOGLE_USER_PASSWORD;
+const adminUsername = process.env.KC_BOOTSTRAP_ADMIN_USERNAME;
+const adminPassword = process.env.KC_BOOTSTRAP_ADMIN_PASSWORD;
+assert.ok(password && adminUsername && adminPassword);
+
+async function verifyBrokeredEmail() {
+  const tokenResponse = await fetch(
+    "http://localhost:8080/realms/master/protocol/openid-connect/token",
+    {
+      method: "POST",
+      body: new URLSearchParams({
+        client_id: "admin-cli",
+        grant_type: "password",
+        username: adminUsername,
+        password: adminPassword,
+      }),
+    },
+  );
+  assert.equal(tokenResponse.status, 200);
+  const token = (await tokenResponse.json()).access_token;
+  const headers = { Authorization: `Bearer ${token}` };
+  const usersResponse = await fetch(
+    "http://localhost:8080/admin/realms/keycloak-patterns/users"
+      + "?email=broker-new-user%40example.test&exact=true",
+    { headers },
+  );
+  assert.equal(usersResponse.status, 200);
+  const users = await usersResponse.json();
+  assert.equal(users.length, 1);
+  const userResponse = await fetch(
+    `http://localhost:8080/admin/realms/keycloak-patterns/users/${users[0].id}`,
+    { headers },
+  );
+  const user = await userResponse.json();
+  assert.equal(user.emailVerified, false);
+  const updateResponse = await fetch(
+    `http://localhost:8080/admin/realms/keycloak-patterns/users/${user.id}`,
+    {
+      method: "PUT",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify({ ...user, emailVerified: true }),
+    },
+  );
+  assert.equal(updateResponse.status, 204);
+}
+
+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 browserRequests = [];
+  page.on("request", (request) => browserRequests.push(request.url()));
+
+  await page.goto("http://localhost:8088/");
+  await page.waitForURL(/localhost:8080/u);
+  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();
+  await page.waitForURL(/\/oauth2\/callback/u);
+  assert.match(await page.locator("body").innerText(), /Internal Server Error/u);
+
+  await verifyBrokeredEmail();
+  await page.goto(
+    "http://localhost:8088/oauth2/start"
+      + "?rd=http%3A%2F%2Flocalhost%3A8088%2F",
+  );
+  await page.waitForURL("http://localhost:8088/");
+
+  const identity = JSON.parse(await page.locator("body").innerText());
+  assert.equal(identity.pattern, "AP4-edge-forward-auth");
+  assert.match(identity.user, /^[0-9a-f-]{36}$/u);
+  assert.equal(identity.email, "broker-new-user@example.test");
+  assert.equal(
+    browserRequests.some((url) =>
+      url.includes("/protocol/openid-connect/token"),
+    ),
+    false,
+  );
+
+  const session = (await context.cookies()).find(
+    (cookie) => cookie.name === "AP4_SESSION",
+  );
+  assert.ok(session?.httpOnly);
+  console.log(
+    "AP4 Google federation verified: unverified email rejected, verified identity -> edge session -> trusted headers",
+  );
+} finally {
+  await browser.close();
+}

e2e/pattern4.mjs

@@ -0,0 +1,138 @@
+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");
+
+const edgeBaseUrl = "http://localhost:8088";
+const edgeEntryUrl = `${edgeBaseUrl}/`;
+
+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() === edgeEntryUrl) {
+      return;
+    }
+    if (attempt === 1) {
+      await page.goto(`${edgeBaseUrl}/oauth2/start?rd=${encodeURIComponent(edgeEntryUrl)}`);
+      await page.waitForURL(/localhost:8080/u);
+    }
+  }
+  throw new Error(`Keycloak login did not return to AP4: ${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();
+  const browserRequests = [];
+  page.on("request", (request) =>
+    browserRequests.push({ method: request.method(), url: request.url() }),
+  );
+
+  const edgeResponsePromise = page.waitForResponse(
+    (response) =>
+      response.url() === edgeEntryUrl &&
+      response.status() === 302,
+  );
+  const authorizationRequestPromise = page.waitForRequest((request) =>
+    request.url().includes(
+      "/protocol/openid-connect/auth?approval_prompt=",
+    ),
+  );
+  await page.goto(edgeEntryUrl);
+  const unauthenticatedEdgeResponse = await edgeResponsePromise;
+  assert.equal(unauthenticatedEdgeResponse.status(), 302);
+
+  const authorizationRequest = await authorizationRequestPromise;
+  const authorizationUrl = new URL(authorizationRequest.url());
+  assert.equal(authorizationUrl.searchParams.get("client_id"), "edge-proxy");
+  assert.equal(authorizationUrl.searchParams.get("code_challenge_method"), "S256");
+  assert.ok(authorizationUrl.searchParams.get("code_challenge"));
+
+  await page.waitForURL(/localhost:8080/u);
+  await completeKeycloakLogin(page);
+  const edgeIdentity = JSON.parse(await page.locator("body").innerText());
+  assert.equal(edgeIdentity.pattern, "AP4-edge-forward-auth");
+  assert.ok(edgeIdentity.user);
+  assert.equal(edgeIdentity.identityHeader, "X-Auth-Request-User");
+
+  const callbackRequest = browserRequests.find(({ url }) =>
+    url.startsWith(`${edgeBaseUrl}/oauth2/callback?`),
+  );
+  assert.ok(callbackRequest);
+  assert.equal(callbackRequest.method, "GET");
+  assert.equal(
+    browserRequests.some(({ url }) =>
+      url.includes("/protocol/openid-connect/token"),
+    ),
+    false,
+    "the confidential token exchange must be server-to-server",
+  );
+
+  const cookies = await context.cookies(edgeEntryUrl);
+  const sessionCookie = cookies.find((cookie) => cookie.name === "AP4_SESSION");
+  assert.ok(sessionCookie);
+  assert.equal(sessionCookie.httpOnly, true);
+  assert.equal(sessionCookie.sameSite, "Lax");
+  assert.equal(sessionCookie.secure, false);
+
+  const storage = await page.evaluate(() => ({
+    localStorage: Object.values(localStorage),
+    sessionStorage: Object.values(sessionStorage),
+    readableCookies: document.cookie,
+  }));
+  assert.deepEqual(storage.localStorage, []);
+  assert.deepEqual(storage.sessionStorage, []);
+  assert.equal(storage.readableCookies.includes("AP4_SESSION"), false);
+
+  const spoofAttempt = await page.evaluate(async () => {
+    const response = await fetch("/", {
+      headers: {
+        "X-Auth-Request-User": "spoofed-admin",
+        "X-Auth-Request-Email": "spoofed-admin@example.test",
+        "X-Internal-Auth-Token": "attacker-controlled-token",
+      },
+    });
+    return { status: response.status, body: await response.json() };
+  });
+  assert.equal(spoofAttempt.status, 200);
+  assert.equal(spoofAttempt.body.user, edgeIdentity.user);
+  assert.notEqual(spoofAttempt.body.user, "spoofed-admin");
+
+  const externalAuthSubrequest = await fetch(`${edgeBaseUrl}/oauth2/auth`);
+  assert.equal(externalAuthSubrequest.status, 404);
+
+  const apiResponse = await fetch(`${edgeBaseUrl}/api/edge`, {
+    redirect: "manual",
+  });
+  assert.equal(apiResponse.status, 401);
+  assert.equal(apiResponse.headers.get("location"), null);
+
+  await assert.rejects(
+    fetch("http://localhost:4180/ping"),
+    "oauth2-proxy must not be published on the host",
+  );
+
+  await assert.rejects(
+    fetch("http://localhost:8081/edge/me"),
+    "backend must not be published on the host",
+  );
+
+  console.log(
+    "pattern4 hardened edge verified: auth_request, no backend publish, spoofed headers overwritten",
+  );
+} finally {
+  await browser.close();
+}

frontend/Dockerfile

@@ -1,4 +1,4 @@
 FROM nginx:1.29-alpine
 
-COPY nginx.conf /etc/nginx/conf.d/default.conf
+COPY default.conf.template /etc/nginx/templates/default.conf.template
 COPY index.html /usr/share/nginx/html/index.html

frontend/default.conf.template

@@ -0,0 +1,75 @@
+server {
+    listen 80;
+    server_name _;
+
+    large_client_header_buffers 4 16k;
+
+    location = /health {
+        access_log off;
+        default_type text/plain;
+        return 200 "ok\n";
+    }
+
+    location = /oauth2/auth {
+        internal;
+        proxy_pass http://oauth2-proxy:4180;
+        proxy_pass_request_body off;
+        proxy_set_header Content-Length "";
+        proxy_set_header X-Original-URL $scheme://$http_host$request_uri;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Host $http_host;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Uri $request_uri;
+    }
+
+    location /oauth2/ {
+        proxy_pass http://oauth2-proxy:4180;
+        proxy_http_version 1.1;
+        proxy_set_header Host $http_host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Host $http_host;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Auth-Request-Redirect $scheme://$http_host$request_uri;
+    }
+
+    location = /api/edge {
+        auth_request /oauth2/auth;
+        error_page 401 = @api_unauthorized;
+
+        auth_request_set $auth_user $upstream_http_x_auth_request_user;
+        auth_request_set $auth_email $upstream_http_x_auth_request_email;
+        auth_request_set $auth_cookie $upstream_http_set_cookie;
+        add_header Set-Cookie $auth_cookie always;
+
+        proxy_pass http://app:8081/edge/me;
+        proxy_set_header X-Auth-Request-User $auth_user;
+        proxy_set_header X-Auth-Request-Email $auth_email;
+        proxy_set_header X-Internal-Auth-Token "${INTERNAL_AUTH_TOKEN}";
+    }
+
+    location / {
+        auth_request /oauth2/auth;
+        error_page 401 = @oauth2_signin;
+
+        auth_request_set $auth_user $upstream_http_x_auth_request_user;
+        auth_request_set $auth_email $upstream_http_x_auth_request_email;
+        auth_request_set $auth_cookie $upstream_http_set_cookie;
+        add_header Set-Cookie $auth_cookie always;
+
+        proxy_pass http://app:8081/edge/me;
+        proxy_set_header X-Auth-Request-User $auth_user;
+        proxy_set_header X-Auth-Request-Email $auth_email;
+        proxy_set_header X-Internal-Auth-Token "${INTERNAL_AUTH_TOKEN}";
+    }
+
+    location @oauth2_signin {
+        return 302 $scheme://$http_host/oauth2/start?rd=$scheme://$http_host$request_uri;
+    }
+
+    location @api_unauthorized {
+        default_type application/json;
+        return 401 '{"error":"authentication required"}';
+    }
+}

frontend/nginx.conf

@@ -1,26 +0,0 @@
-server {
-    listen 80;
-    server_name _;
-
-    root /usr/share/nginx/html;
-    index index.html;
-
-    location = /health {
-        access_log off;
-        default_type text/plain;
-        return 200 "ok\n";
-    }
-
-    location /api/ {
-        proxy_pass http://app:8081;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-
-    location / {
-        try_files $uri $uri/ /index.html;
-    }
-}

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/package.json

@@ -4,7 +4,10 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "test:first-broker": "node first-broker-login.mjs"
+    "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"
       }
     ]
   },
@@ -116,10 +120,11 @@
       "serviceAccountsEnabled": false,
       "frontchannelLogout": true,
       "redirectUris": [
-        "http://localhost:4180/oauth2/callback"
+        "http://localhost:8088/oauth2/callback"
       ],
       "webOrigins": [],
       "attributes": {
+        "pkce.code.challenge.method": "S256",
         "post.logout.redirect.uris": "http://localhost:8088/*"
       }
     }
@@ -154,6 +159,78 @@
       }
     }
   ],
+  "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

@@ -25,7 +25,37 @@
       "redirectUris": [
         "http://localhost:8080/realms/keycloak-patterns/broker/mock-google/endpoint"
       ],
-      "webOrigins": []
+      "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": [
@@ -51,14 +81,6 @@
       "emailVerified": false,
       "firstName": "Broker",
       "lastName": "Collision",
-      "attributes": {
-        "hd": [
-          "example.test"
-        ],
-        "picture": [
-          "https://images.example.test/mock-collision-user.png"
-        ]
-      },
       "credentials": [
         {
           "type": "password",

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

@@ -15,6 +15,8 @@ set +a
 : "${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}"
 
@@ -76,6 +78,77 @@ else
   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/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-edge-google-federation.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env sh
+set -eu
+
+set -a
+. ./.env
+set +a
+
+docker compose down --volumes --remove-orphans
+docker compose up --build -d --wait
+./scripts/set-first-broker-login-mode.sh secure
+npm --prefix e2e ci
+MOCK_GOOGLE_USER_PASSWORD="$MOCK_GOOGLE_USER_PASSWORD" \
+KC_BOOTSTRAP_ADMIN_USERNAME="$KC_BOOTSTRAP_ADMIN_USERNAME" \
+KC_BOOTSTRAP_ADMIN_PASSWORD="$KC_BOOTSTRAP_ADMIN_PASSWORD" \
+  npm --prefix e2e run test:pattern4-google

scripts/verify-edge-no-google-profile.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env sh
+set -eu
+
+rendered="$(docker compose config --format json)"
+printf '%s\n' "$rendered" | jq -e '
+  (.services["oauth2-proxy"].command | index("--provider=keycloak-oidc") != null)
+  and
+  (.services["oauth2-proxy"].command | index("--code-challenge-method=S256") != null)
+  and
+  (.services.app.ports == null)
+  and
+  (.services["oauth2-proxy"].ports == null)
+' >/dev/null
+
+rg -Fq 'auth_request /oauth2/auth;' frontend/default.conf.template
+rg -Fq 'proxy_set_header X-Auth-Request-User $auth_user;' \
+  frontend/default.conf.template
+echo "AP4 local-identity edge profile verified"

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-pattern4.sh

@@ -0,0 +1,41 @@
+#!/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
+
+docker compose exec -T nginx nginx -V 2>&1 |
+  grep -q -- '--with-http_auth_request_module'
+docker compose exec -T nginx nginx -T 2>&1 |
+  grep -q 'proxy_pass_request_body off'
+
+app_container_id="$(docker compose ps -q app)"
+published_app_port="$(docker inspect "$app_container_id" \
+  --format '{{with (index .NetworkSettings.Ports "8081/tcp")}}{{json .}}{{end}}')"
+if [ -n "$published_app_port" ]; then
+  echo "backend port 8081 must not be published on the host" >&2
+  exit 1
+fi
+
+if docker compose exec -T nginx wget -q -O /dev/null \
+  --header 'X-Auth-Request-User: spoofed-admin' \
+  http://app:8081/edge/me 2>/dev/null; then
+  echo "backend accepted a forged identity without the internal token" >&2
+  exit 1
+fi
+
+npm --prefix e2e ci
+E2E_USERNAME=regular-user \
+E2E_PASSWORD="$REGULAR_USER_PASSWORD" \
+  npm --prefix e2e run test:pattern4
+
+echo "AP4 hardened Nginx auth_request edge flow 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"

scripts/verify-traefik-forwardauth-config.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env sh
+set -eu
+
+config_dir="$PWD/deploy/traefik"
+output_file="$(mktemp)"
+cleanup() {
+  rm -f "$output_file"
+}
+trap cleanup EXIT
+
+status=0
+timeout 4 docker run --rm \
+  -v "$config_dir:/etc/traefik:ro" \
+  traefik:v3.5.3 \
+  --configFile=/etc/traefik/traefik.yml >"$output_file" 2>&1 || status=$?
+
+if [ "$status" -ne 0 ] && [ "$status" -ne 124 ]; then
+  cat "$output_file" >&2
+  exit "$status"
+fi
+if rg -qi 'error|failed' "$output_file"; then
+  cat "$output_file" >&2
+  exit 1
+fi
+
+grep -q 'trustForwardHeader: false' deploy/traefik/dynamic.yml
+grep -q 'X-Auth-Request-User' deploy/traefik/dynamic.yml
+echo "Traefik file provider and ForwardAuth configuration verified"