test(ap1): reproduce issuer mismatch

.env.example

@@ -10,17 +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
-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,7 +7,3 @@ backend/target/
 **/node_modules/
 frontend/dist/
 build/
-e2e/node_modules/
-google-e2e/node_modules/
-frontend/node_modules/
-frontend/dist/

README.md

@@ -1,12 +1,5 @@
 # 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을 중심으로 네 가지 브라우저 인증 통합 패턴을 같은 로컬
 인프라에서 비교하는 학습 프로젝트입니다.
 
@@ -104,21 +97,28 @@ Keycloak을 잠시 중지하고 export한 뒤 자동으로 다시 올립니다.
 runtime export에는 실제 client secret과 credential hash가 포함될 수 있어
 gitignored `build/keycloak-export/`에 권한 `0600`으로만 저장됩니다.
 
-## AP4: oauth2-proxy Edge Forward Auth
+## AP1: SPA Direct + Resource Server
 
-`develop-keycloak-pattern4`는 oauth2-proxy와 Nginx `auth_request`가
+`develop-keycloak-pattern1`은 vanilla JavaScript SPA가 `spa-public` client로
-인증을 edge에서 강제하는 패턴입니다.
+Authorization Code + PKCE S256 로그인을 수행하는 패턴입니다. access/refresh
+token은 명시적인 in-memory store에만 보관되므로 새로고침하면 사라집니다.
 
 ```bash
-./scripts/verify-pattern4.sh
+./scripts/verify-pattern1.sh
 ```
 
-첫 feature에서는 oauth2-proxy를 `http://localhost:4180`에 직접 노출해
+브라우저에서 `http://localhost:8088`을 열어 로그인한 뒤 보호 API를 호출할 수
-OIDC redirect/PKCE/callback과 forwarded-user를 분리 확인합니다. 두 번째
+있습니다. SPA는 `http://localhost:8081/api/me`를 직접 호출하며 Spring
-feature부터 `http://localhost:8088` Nginx가 단일 진입점이며, 내부
+Resource Server가 Bearer JWT를 검증합니다.
-`auth_request`는 브라우저 요청을 login 302로, API 요청을 JSON 401로
+
-구분합니다. 최종 feature에서는 backend와 oauth2-proxy의 호스트 노출을
+Keycloak의 dedicated audience mapper는 `spa-public` access token에
-제거하고 Nginx 헤더 덮어쓰기와 내부 토큰 검증으로 spoofing을 막습니다.
+`keycloak-pattern-api`를 추가합니다. Spring은 signature, `iss`, `exp`뿐
-자세한 내용은
+아니라 이 `aud`도 검사합니다. `verify-pattern1.sh`는 같은 정상 토큰을
-[`docs/ap4-edge-forward-auth.md`](docs/ap4-edge-forward-auth.md)를
+`deliberately-wrong-audience`를 기대하는 진단 인스턴스에도 제출해 `401`을
-참고하세요.
+확인합니다.
+
+Keycloak은 `KC_HOSTNAME=http://localhost:8080`을 기준으로 token의 `iss`를
+발급합니다. 정상 Resource Server는 이 외부 issuer 문자열을 검증하되 JWKS는
+Docker 내부의 `http://keycloak:8080`에서 가져옵니다. 진단 인스턴스는 일부러
+`http://wrong-issuer.invalid`를 기대하도록 구성되어, 서명과 audience가
+정상이더라도 issuer mismatch로 `401`을 반환합니다.

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

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

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

@@ -1,59 +0,0 @@
-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/JwtDecoderConfig.java

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

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

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

backend/src/main/resources/application.yml

@@ -1,9 +1,6 @@
 server:
   port: ${SERVER_PORT:8081}
 
-edge:
-  internal-auth-token: ${EDGE_INTERNAL_AUTH_TOKEN:}
-
 spring:
   application:
     name: keycloak-pattern-api
@@ -14,6 +11,9 @@ spring:
           issuer-uri: ${SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI:http://localhost:8080/realms/keycloak-patterns}
           jwk-set-uri: ${SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI:http://localhost:8080/realms/keycloak-patterns/protocol/openid-connect/certs}
 
+security:
+  expected-audience: ${SECURITY_EXPECTED_AUDIENCE:keycloak-pattern-api}
+
 management:
   endpoint:
     health:

backend/src/test/java/com/example/keycloakpattern/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(properties = "edge.internal-auth-token=test-internal-edge-token")
+@SpringBootTest
 @AutoConfigureMockMvc
 class ApiSecurityTest {
 
@@ -40,36 +40,4 @@ 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"));
-    }
 }

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

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

deploy/reverse-proxy/keycloak.env.example

@@ -1,6 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

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

deploy/tunnel/cloudflared-config.yml

@@ -1,7 +0,0 @@
-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,10 +38,8 @@ 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:
@@ -71,9 +69,8 @@ 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
-      EDGE_INTERNAL_AUTH_TOKEN: ${INTERNAL_AUTH_TOKEN:?set INTERNAL_AUTH_TOKEN in .env}
+    ports:
-    expose:
+      - "127.0.0.1:8081:8081"
-      - "8081"
     depends_on:
       keycloak:
         condition: service_healthy
@@ -89,68 +86,65 @@ services:
       - keycloak-net
     restart: unless-stopped
 
-  oauth2-proxy:
+  app-wrong-audience:
-    image: quay.io/oauth2-proxy/oauth2-proxy:v7.15.2
+    profiles:
-    command:
+      - diagnostics
-      - --http-address=0.0.0.0:4180
+    build:
-      - --provider=keycloak-oidc
+      context: ./backend
-      - --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
+      SERVER_PORT: "8081"
-      OAUTH2_PROXY_CLIENT_SECRET: ${EDGE_PROXY_CLIENT_SECRET:?set EDGE_PROXY_CLIENT_SECRET in .env}
+      SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI: http://localhost:8080/realms/keycloak-patterns
-      OAUTH2_PROXY_COOKIE_SECRET: ${OAUTH2_PROXY_COOKIE_SECRET:?set OAUTH2_PROXY_COOKIE_SECRET in .env}
+      SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI: http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/certs
-    expose:
+      SECURITY_EXPECTED_AUDIENCE: deliberately-wrong-audience
-      - "4180"
+    ports:
+      - "127.0.0.1:18081:8081"
     depends_on:
       keycloak:
         condition: service_healthy
-      app:
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - wget -q -O - http://127.0.0.1:8081/actuator/health | grep -q '"status":"UP"'
+      interval: 10s
+      timeout: 5s
+      retries: 12
+      start_period: 20s
+    networks:
+      - keycloak-net
+
+  app-wrong-issuer:
+    profiles:
+      - diagnostics
+    build:
+      context: ./backend
+    environment:
+      SERVER_PORT: "8081"
+      SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI: http://wrong-issuer.invalid/realms/keycloak-patterns
+      SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI: http://keycloak:8080/realms/keycloak-patterns/protocol/openid-connect/certs
+      SECURITY_EXPECTED_AUDIENCE: keycloak-pattern-api
+    ports:
+      - "127.0.0.1:18082:8081"
+    depends_on:
+      keycloak:
         condition: service_healthy
     healthcheck:
       test:
-        - CMD
+        - CMD-SHELL
-        - /bin/oauth2-proxy
+        - wget -q -O - http://127.0.0.1:8081/actuator/health | grep -q '"status":"UP"'
-        - --version
       interval: 10s
       timeout: 5s
-      retries: 3
+      retries: 12
-      start_period: 5s
+      start_period: 20s
     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:
-      oauth2-proxy:
+      app:
         condition: service_healthy
     healthcheck:
       test:
@@ -160,8 +154,7 @@ services:
       timeout: 5s
       retries: 12
     networks:
-      keycloak-net:
+      - keycloak-net
-        ipv4_address: 172.30.40.10
     restart: unless-stopped
 
 volumes:
@@ -171,6 +164,3 @@ volumes:
 networks:
   keycloak-net:
     driver: bridge
-    ipam:
-      config:
-        - subnet: 172.30.40.0/24

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

@@ -1,18 +0,0 @@
-# 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

@@ -1,70 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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/first-broker-login-security.md

@@ -1,27 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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/keycloak-branch-index.md

@@ -1,29 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-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/public-domain-tunneling.md

@@ -1,21 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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.json

@@ -4,8 +4,7 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test:pattern4": "node pattern4.mjs",
+    "test:pattern1": "node pattern1.mjs"
-    "test:pattern4-google": "node pattern4-google.mjs"
   },
   "devDependencies": {
     "playwright-core": "1.62.0"

e2e/pattern1.mjs

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { chromium } from "playwright-core";
+
+const username = process.env.E2E_USERNAME ?? "regular-user";
+const password = process.env.E2E_PASSWORD;
+
+assert.ok(password, "E2E_PASSWORD must be set");
+
+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();
+  let authorizationUrl;
+
+  page.on("request", (request) => {
+    if (request.url().includes("/protocol/openid-connect/auth")) {
+      authorizationUrl = new URL(request.url());
+    }
+  });
+
+  await page.goto("http://localhost:8088");
+  await page.locator("#login").click();
+  await page.waitForURL(/localhost:8080/u);
+  await page.locator("#username").fill(username);
+  await page.locator("#password").fill(password);
+  await page.locator("#kc-login").click();
+  await page.waitForURL("http://localhost:8088/");
+  await page.locator('[data-authenticated="true"]').waitFor();
+
+  assert.equal(authorizationUrl?.searchParams.get("response_type"), "code");
+  assert.equal(authorizationUrl?.searchParams.get("code_challenge_method"), "S256");
+  assert.ok(authorizationUrl?.searchParams.get("code_challenge"));
+
+  const accessToken = await page.evaluate(() => window.__pattern1.getAccessToken());
+  assert.ok(accessToken, "access token must exist in browser memory");
+  const payload = JSON.parse(
+    Buffer.from(accessToken.split(".")[1], "base64url").toString("utf8"),
+  );
+  const audiences = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
+  assert.ok(
+    audiences.includes("keycloak-pattern-api"),
+    "access token must target keycloak-pattern-api",
+  );
+
+  const storageSnapshot = await page.evaluate(() => ({
+    localStorage: Object.values(localStorage),
+    sessionStorage: Object.values(sessionStorage),
+  }));
+  assert.equal(
+    JSON.stringify(storageSnapshot).includes(accessToken),
+    false,
+    "access token must not be persisted in Web Storage",
+  );
+
+  await page.locator("#call-api").click();
+  await page.waitForFunction(() => {
+    const text = document.querySelector("#result")?.textContent ?? "";
+    return text.includes('"httpStatus": 200');
+  });
+
+  if (process.env.WRONG_AUDIENCE_URL) {
+    const response = await fetch(process.env.WRONG_AUDIENCE_URL, {
+      headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    assert.equal(
+      response.status,
+      401,
+      "the same signed token must fail when the Resource Server expects another audience",
+    );
+  }
+
+  if (process.env.WRONG_ISSUER_URL) {
+    const response = await fetch(process.env.WRONG_ISSUER_URL, {
+      headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    assert.equal(
+      response.status,
+      401,
+      "the same signed token must fail when the Resource Server expects another issuer",
+    );
+  }
+
+  await page.reload();
+  await page.locator('[data-authenticated="false"]').waitFor();
+  assert.equal(
+    await page.evaluate(() => window.__pattern1.getAccessToken()),
+    null,
+    "reload must clear the memory-only token",
+  );
+
+  console.log(
+    "pattern1 browser verified: code+PKCE S256, audience/issuer negatives 401, Web Storage token 0, reload clears token",
+  );
+} finally {
+  await browser.close();
+}

e2e/pattern4-google.mjs

@@ -1,99 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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,16 @@
+FROM node:24-alpine AS build
+
+WORKDIR /workspace
+
+COPY package.json package-lock.json ./
+RUN npm ci
+
+COPY src ./src
+COPY test ./test
+RUN npm test && npm run build
+
 FROM nginx:1.29-alpine
 
-COPY default.conf.template /etc/nginx/templates/default.conf.template
+COPY nginx.conf /etc/nginx/conf.d/default.conf
 COPY index.html /usr/share/nginx/html/index.html
+COPY --from=build /workspace/dist/app.js /usr/share/nginx/html/app.js

frontend/default.conf.template

@@ -1,75 +0,0 @@
-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/index.html

@@ -3,31 +3,66 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Keycloak Authentication Patterns</title>
+  <meta name="referrer" content="no-referrer">
+  <title>AP1 · SPA Direct + Resource Server</title>
   <style>
     :root {
       color-scheme: light dark;
       font-family: system-ui, sans-serif;
     }
     body {
-      max-width: 48rem;
+      max-width: 56rem;
-      margin: 8vh auto;
+      margin: 6vh auto;
       padding: 0 1.5rem;
-      line-height: 1.6;
+      line-height: 1.55;
+    }
+    button {
+      margin: 0 0.5rem 0.5rem 0;
+      padding: 0.6rem 0.9rem;
+      cursor: pointer;
+    }
+    code, pre {
+      border-radius: 0.35rem;
+      background: color-mix(in srgb, CanvasText 9%, Canvas);
     }
     code {
-      padding: 0.15rem 0.35rem;
+      padding: 0.1rem 0.3rem;
-      border-radius: 0.25rem;
+    }
-      background: color-mix(in srgb, CanvasText 10%, Canvas);
+    pre {
+      min-height: 8rem;
+      padding: 1rem;
+      overflow: auto;
+      white-space: pre-wrap;
+    }
+    .notice {
+      border-left: 0.3rem solid #e09f3e;
+      padding-left: 1rem;
     }
   </style>
 </head>
 <body>
-  <h1>Keycloak Authentication Patterns</h1>
+  <main>
-  <p>공통 Docker Compose baseline이 실행 중입니다.</p>
+    <h1>AP1 · SPA Direct + Resource Server</h1>
-  <p>
+    <p>
-    공개 API는 <code>/api/public</code>, 보호 API는
+      바닐라 JavaScript SPA가 <code>spa-public</code> client로 Authorization
-    <code>/api/me</code>에서 확인할 수 있습니다.
+      Code + PKCE를 수행하고, access token을 직접 Spring Resource Server에
-  </p>
+      전달합니다.
+    </p>
+    <p class="notice">
+      access/refresh token은 메모리에만 존재합니다. 새로고침하면 사라지는 것이
+      이 패턴의 의도된 보안 경계입니다.
+    </p>
+
+    <section>
+      <button id="login" type="button">Keycloak 로그인</button>
+      <button id="call-api" type="button" disabled>보호 API 호출</button>
+      <button id="pkce-demo" type="button">수동 PKCE 생성</button>
+      <button id="logout" type="button" disabled>로그아웃</button>
+    </section>
+
+    <p id="session-state" data-authenticated="false">세션 확인 중…</p>
+    <pre id="result" aria-live="polite"></pre>
+  </main>
+  <script type="module" src="/app.js"></script>
 </body>
 </html>

frontend/nginx.conf

@@ -0,0 +1,27 @@
+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 / {
+        add_header Cache-Control "no-store";
+        try_files $uri $uri/ /index.html;
+    }
+}

frontend/package-lock.json

@@ -0,0 +1,523 @@
+{
+  "name": "keycloak-pattern1-spa",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "keycloak-pattern1-spa",
+      "version": "1.0.0",
+      "dependencies": {
+        "oidc-client-ts": "3.5.0"
+      },
+      "devDependencies": {
+        "esbuild": "0.28.1"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
+      "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
+      "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
+      "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
+      "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
+      "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
+      "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
+      "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
+      "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
+      "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
+      "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
+      "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
+      "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
+      "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
+      "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
+      "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
+      "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
+      "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
+      "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
+      "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
+      "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+      "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.28.1",
+        "@esbuild/android-arm": "0.28.1",
+        "@esbuild/android-arm64": "0.28.1",
+        "@esbuild/android-x64": "0.28.1",
+        "@esbuild/darwin-arm64": "0.28.1",
+        "@esbuild/darwin-x64": "0.28.1",
+        "@esbuild/freebsd-arm64": "0.28.1",
+        "@esbuild/freebsd-x64": "0.28.1",
+        "@esbuild/linux-arm": "0.28.1",
+        "@esbuild/linux-arm64": "0.28.1",
+        "@esbuild/linux-ia32": "0.28.1",
+        "@esbuild/linux-loong64": "0.28.1",
+        "@esbuild/linux-mips64el": "0.28.1",
+        "@esbuild/linux-ppc64": "0.28.1",
+        "@esbuild/linux-riscv64": "0.28.1",
+        "@esbuild/linux-s390x": "0.28.1",
+        "@esbuild/linux-x64": "0.28.1",
+        "@esbuild/netbsd-arm64": "0.28.1",
+        "@esbuild/netbsd-x64": "0.28.1",
+        "@esbuild/openbsd-arm64": "0.28.1",
+        "@esbuild/openbsd-x64": "0.28.1",
+        "@esbuild/openharmony-arm64": "0.28.1",
+        "@esbuild/sunos-x64": "0.28.1",
+        "@esbuild/win32-arm64": "0.28.1",
+        "@esbuild/win32-ia32": "0.28.1",
+        "@esbuild/win32-x64": "0.28.1"
+      }
+    },
+    "node_modules/jwt-decode": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jwt-decode/-/jwt-decode-4.0.0.tgz",
+      "integrity": "sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/oidc-client-ts": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/oidc-client-ts/-/oidc-client-ts-3.5.0.tgz",
+      "integrity": "sha512-l2q8l9CTCTOlbX+AnK4p3M+4CEpKpyQhle6blQkdFhm0IsBqsxm15bYaSa11G7pWdsYr6epdsRZxJpCyCRbT8A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "jwt-decode": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "keycloak-pattern1-spa",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build": "esbuild src/app.js --bundle --format=esm --outfile=dist/app.js --minify --sourcemap",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "oidc-client-ts": "3.5.0"
+  },
+  "devDependencies": {
+    "esbuild": "0.28.1"
+  }
+}

frontend/src/app.js

@@ -0,0 +1,138 @@
+import {
+  InMemoryWebStorage,
+  UserManager,
+  WebStorageStateStore,
+} from "oidc-client-ts";
+
+import { createPkcePair } from "./pkce.js";
+
+const authority = "http://localhost:8080/realms/keycloak-patterns";
+const backendBaseUrl = "http://localhost:8081";
+
+const userManager = new UserManager({
+  authority,
+  client_id: "spa-public",
+  redirect_uri: "http://localhost:8088/callback.html",
+  post_logout_redirect_uri: "http://localhost:8088/",
+  response_type: "code",
+  scope: "openid profile email",
+  automaticSilentRenew: true,
+  monitorSession: false,
+  loadUserInfo: false,
+  userStore: new WebStorageStateStore({
+    store: new InMemoryWebStorage(),
+  }),
+  stateStore: new WebStorageStateStore({
+    store: window.sessionStorage,
+  }),
+});
+
+const loginButton = document.querySelector("#login");
+const logoutButton = document.querySelector("#logout");
+const apiButton = document.querySelector("#call-api");
+const pkceButton = document.querySelector("#pkce-demo");
+const sessionState = document.querySelector("#session-state");
+const result = document.querySelector("#result");
+
+let currentUser = null;
+
+function renderJson(value) {
+  result.textContent = JSON.stringify(value, null, 2);
+}
+
+function tokenMetadata(user) {
+  return {
+    subject: user.profile.sub,
+    username: user.profile.preferred_username,
+    expiresAt: new Date(user.expires_at * 1000).toISOString(),
+    accessTokenHeldBy: "browser memory",
+    refreshTokenHeldBy: user.refresh_token ? "browser memory" : "not issued",
+  };
+}
+
+function renderSession(user) {
+  currentUser = user;
+  const authenticated = Boolean(user && !user.expired);
+  sessionState.dataset.authenticated = String(authenticated);
+  sessionState.textContent = authenticated
+    ? `${user.profile.preferred_username} 로그인됨 · token은 메모리에만 보관`
+    : "로그인되지 않음 · 브라우저 저장소에 token 없음";
+  loginButton.disabled = authenticated;
+  logoutButton.disabled = !authenticated;
+  apiButton.disabled = !authenticated;
+
+  if (authenticated) {
+    renderJson(tokenMetadata(user));
+  }
+}
+
+async function finishSigninCallback() {
+  const params = new URLSearchParams(window.location.search);
+  const isCallback = window.location.pathname === "/callback.html"
+    && (params.has("code") || params.has("error"));
+
+  if (!isCallback) {
+    return null;
+  }
+
+  const user = await userManager.signinRedirectCallback();
+  window.history.replaceState({}, document.title, "/");
+  return user;
+}
+
+async function callProtectedApi() {
+  if (!currentUser || currentUser.expired) {
+    throw new Error("로그인이 필요합니다.");
+  }
+
+  const response = await fetch(`${backendBaseUrl}/api/me`, {
+    headers: {
+      Authorization: `Bearer ${currentUser.access_token}`,
+    },
+  });
+  const body = await response.json();
+  renderJson({
+    httpStatus: response.status,
+    resourceServerResponse: body,
+    tokenBoundary: tokenMetadata(currentUser),
+  });
+
+  if (!response.ok) {
+    throw new Error(`보호 API가 ${response.status}를 반환했습니다.`);
+  }
+}
+
+loginButton.addEventListener("click", () => userManager.signinRedirect());
+logoutButton.addEventListener("click", () => userManager.signoutRedirect());
+apiButton.addEventListener("click", () => {
+  callProtectedApi().catch((error) => renderJson({ error: error.message }));
+});
+pkceButton.addEventListener("click", () => {
+  createPkcePair()
+    .then(({ verifier, challenge, method }) => renderJson({
+      method,
+      verifierLength: verifier.length,
+      challengeLength: challenge.length,
+      note: "실제 로그인에서는 oidc-client-ts가 같은 S256 단계를 수행합니다.",
+    }))
+    .catch((error) => renderJson({ error: error.message }));
+});
+
+userManager.events.addUserLoaded(renderSession);
+userManager.events.addUserUnloaded(() => renderSession(null));
+userManager.events.addAccessTokenExpired(() => renderSession(null));
+
+window.__pattern1 = {
+  getAccessToken: () => currentUser?.access_token ?? null,
+  getRefreshToken: () => currentUser?.refresh_token ?? null,
+  getIdToken: () => currentUser?.id_token ?? null,
+  callProtectedApi,
+};
+
+try {
+  const callbackUser = await finishSigninCallback();
+  renderSession(callbackUser ?? await userManager.getUser());
+} catch (error) {
+  renderSession(null);
+  renderJson({ error: error.message });
+}

frontend/src/pkce.js

@@ -0,0 +1,26 @@
+function base64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary)
+    .replaceAll("+", "-")
+    .replaceAll("/", "_")
+    .replace(/=+$/u, "");
+}
+
+export async function createPkcePair(cryptoApi = globalThis.crypto) {
+  const verifierBytes = new Uint8Array(32);
+  cryptoApi.getRandomValues(verifierBytes);
+  const verifier = base64Url(verifierBytes);
+  const digest = await cryptoApi.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(verifier),
+  );
+
+  return {
+    verifier,
+    challenge: base64Url(new Uint8Array(digest)),
+    method: "S256",
+  };
+}

frontend/test/pkce.test.mjs

@@ -0,0 +1,18 @@
+import assert from "node:assert/strict";
+import { webcrypto } from "node:crypto";
+import test from "node:test";
+
+globalThis.btoa = (value) => Buffer.from(value, "binary").toString("base64");
+
+const { createPkcePair } = await import("../src/pkce.js");
+
+test("manual PKCE helper creates an RFC 7636 S256 pair", async () => {
+  const pair = await createPkcePair(webcrypto);
+
+  assert.equal(pair.method, "S256");
+  assert.equal(pair.verifier.length, 43);
+  assert.equal(pair.challenge.length, 43);
+  assert.match(pair.verifier, /^[A-Za-z0-9_-]+$/u);
+  assert.match(pair.challenge, /^[A-Za-z0-9_-]+$/u);
+  assert.notEqual(pair.verifier, pair.challenge);
+});

google-e2e/claim-mapping.mjs

@@ -1,123 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,132 +0,0 @@
-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,10 +24,6 @@
       {
         "name": "user-role",
         "description": "Regular authenticated user role"
-      },
-      {
-        "name": "employee-role",
-        "description": "Assigned to brokered identities whose hosted-domain claim is example.test"
       }
     ]
   },
@@ -55,7 +51,22 @@
       "attributes": {
         "pkce.code.challenge.method": "S256",
         "post.logout.redirect.uris": "http://localhost:8088/*##http://127.0.0.1:8088/*"
-      }
+      },
+      "protocolMappers": [
+        {
+          "name": "keycloak-pattern-api-audience",
+          "protocol": "openid-connect",
+          "protocolMapper": "oidc-audience-mapper",
+          "consentRequired": false,
+          "config": {
+            "included.custom.audience": "keycloak-pattern-api",
+            "id.token.claim": "false",
+            "access.token.claim": "true",
+            "userinfo.token.claim": "false",
+            "introspection.token.claim": "true"
+          }
+        }
+      ]
     },
     {
       "clientId": "token-mediating-confidential",
@@ -120,117 +131,14 @@
       "serviceAccountsEnabled": false,
       "frontchannelLogout": true,
       "redirectUris": [
-        "http://localhost:8088/oauth2/callback"
+        "http://localhost:4180/oauth2/callback"
       ],
       "webOrigins": [],
       "attributes": {
-        "pkce.code.challenge.method": "S256",
         "post.logout.redirect.uris": "http://localhost:8088/*"
       }
     }
   ],
-  "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

@@ -1,93 +0,0 @@
-{
-  "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

@@ -1,62 +0,0 @@
-#!/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

@@ -1,58 +0,0 @@
-#!/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

@@ -1,154 +0,0 @@
-#!/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

@@ -1,178 +0,0 @@
-#!/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/validate-realm.py

@@ -70,6 +70,18 @@ def validate(path: Path, runtime: bool) -> None:
         spa.get("attributes", {}).get("pkce.code.challenge.method") == "S256",
         "spa-public must enforce PKCE S256",
     )
+    audience_mappers = [
+        mapper
+        for mapper in spa.get("protocolMappers", [])
+        if mapper.get("protocolMapper") == "oidc-audience-mapper"
+    ]
+    if not runtime:
+        require(len(audience_mappers) == 1, "spa-public must declare one audience mapper")
+        require(
+            audience_mappers[0].get("config", {}).get("included.custom.audience")
+            == "keycloak-pattern-api",
+            "spa-public access token must target keycloak-pattern-api",
+        )
 
     for client_id, placeholder in CONFIDENTIAL_CLIENTS.items():
         client = clients[client_id]

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

@@ -1,11 +0,0 @@
-#!/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

@@ -1,15 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-#!/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-first-broker-login.sh

@@ -1,29 +0,0 @@
-#!/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

@@ -1,70 +0,0 @@
-#!/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

@@ -1,16 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-#!/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

@@ -1,24 +0,0 @@
-#!/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

@@ -1,27 +0,0 @@
-#!/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-pattern1.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ ! -f .env ]; then
+  echo "missing .env; copy .env.example and set local-only values" >&2
+  exit 1
+fi
+
+set -a
+. ./.env
+set +a
+
+docker compose down --volumes --remove-orphans
+docker compose up --build -d --wait
+docker compose --profile diagnostics up -d --wait \
+  app-wrong-audience \
+  app-wrong-issuer
+
+npm --prefix e2e ci
+E2E_USERNAME=regular-user \
+E2E_PASSWORD="$REGULAR_USER_PASSWORD" \
+WRONG_AUDIENCE_URL=http://localhost:18081/api/me \
+WRONG_ISSUER_URL=http://localhost:18082/api/me \
+  npm --prefix e2e run test:pattern1
+
+echo "AP1 verified end to end"

scripts/verify-pattern4.sh

@@ -1,41 +0,0 @@
-#!/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

@@ -1,15 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-#!/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

@@ -1,28 +0,0 @@
-#!/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"