merge: shared broker and deployment contracts

.gitignore

@@ -4,6 +4,7 @@
 *.iml
 
 backend/target/
+token-mediator/target/
 **/node_modules/
 frontend/dist/
 build/
@@ -11,6 +12,3 @@ e2e/node_modules/
 google-e2e/node_modules/
 frontend/node_modules/
 frontend/dist/
-
-token-mediator/target
-bff/target

README.md

@@ -104,38 +104,21 @@ Keycloak을 잠시 중지하고 export한 뒤 자동으로 다시 올립니다.
 runtime export에는 실제 client secret과 credential hash가 포함될 수 있어
 gitignored `build/keycloak-export/`에 권한 `0600`으로만 저장됩니다.
 
-## AP1: SPA Direct + Resource Server
+## AP2: Token-Mediating Backend
 
-`develop-keycloak-pattern1`은 vanilla JavaScript SPA가 `spa-public` client로
-Authorization Code + PKCE S256 로그인을 수행하는 패턴입니다. access/refresh
-token은 명시적인 in-memory store에만 보관되므로 새로고침하면 사라집니다.
+`develop-keycloak-pattern2`의 Spring confidential client는
+`http://localhost:8082`에서 실행됩니다. 브라우저는 로그인 redirect와
+HttpOnly `AP2_SESSION`만 사용하고, authorization code 교환과
+access/refresh token 보관은 backend가 담당합니다.
 
 ```bash
-./scripts/verify-pattern1.sh
+./scripts/verify-pattern2.sh
 ```
 
-브라우저에서 `http://localhost:8088`을 열어 로그인한 뒤 보호 API를 호출할 수
-있습니다. SPA는 `http://localhost:8081/api/me`를 직접 호출하며 Spring
-Resource Server가 Bearer JWT를 검증합니다.
+`/token/boundary`는 실제 token 값을 반환하지 않고 서버 저장 여부만 보여줍니다.
+`/token/access`는 access token과 만료 메타데이터만 `no-store`로 전달하며,
+refresh token은 반환하지 않습니다. 브라우저는 이 access token으로
+`http://localhost:8081/api/me`를 직접 호출합니다.
 
-Keycloak의 dedicated audience mapper는 `spa-public` access token에
-`keycloak-pattern-api`를 추가합니다. Spring은 signature, `iss`, `exp`뿐
-아니라 이 `aud`도 검사합니다. `verify-pattern1.sh`는 같은 정상 토큰을
-`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`을 반환합니다.
-
-token 저장 위치와 XSS 범위는
-[`docs/ap1-token-storage.md`](docs/ap1-token-storage.md)에 정리했습니다.
-E2E는 Web Storage token이 0개임과 동시에 실행 중 fetch hook이 Bearer
-header를 관찰할 수 있음을 재현합니다.
-
-refresh rotation, 소비된 refresh token 재사용, RP-Initiated Logout,
-revocation과 stateless JWT의 차이는
-[`docs/ap1-refresh-logout.md`](docs/ap1-refresh-logout.md)에 정리했으며 같은
-E2E에서 실제 Keycloak 26.7.0 동작을 검증합니다.
+자세한 token 경계와 실험 항목은
+[`docs/ap2-token-boundary.md`](docs/ap2-token-boundary.md)를 참고하세요.

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

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

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

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

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

@@ -7,7 +7,6 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.http.SessionCreationPolicy;
-import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.cors.CorsConfigurationSource;
@@ -26,28 +25,16 @@ public class SecurityConfig {
             .authorizeHttpRequests(authorize -> authorize
                 .requestMatchers("/actuator/health", "/actuator/health/**", "/api/public")
                 .permitAll()
-                .requestMatchers("/api/admin")
-                .hasRole("admin-role")
                 .anyRequest()
                 .authenticated())
-            .oauth2ResourceServer(oauth2 -> oauth2.jwt(jwt ->
-                jwt.jwtAuthenticationConverter(jwtAuthenticationConverter())))
+            .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
             .build();
     }
 
-    private JwtAuthenticationConverter jwtAuthenticationConverter() {
-        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
-        converter.setJwtGrantedAuthoritiesConverter(new KeycloakRealmRoleConverter());
-        return converter;
-    }
-
     @Bean
     CorsConfigurationSource corsConfigurationSource() {
         CorsConfiguration configuration = new CorsConfiguration();
-        configuration.setAllowedOrigins(List.of(
-            "http://localhost:8088",
-            "http://127.0.0.1:8088"
-        ));
+        configuration.setAllowedOrigins(List.of("http://localhost:8082"));
         configuration.setAllowedMethods(List.of("GET", "OPTIONS"));
         configuration.setAllowedHeaders(List.of("Authorization", "Content-Type"));
 

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

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

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

@@ -1,46 +0,0 @@
-package com.example.keycloakpattern;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.time.Instant;
-import java.util.List;
-import java.util.Map;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.security.oauth2.jwt.Jwt;
-
-class KeycloakRealmRoleConverterTest {
-
-    private final KeycloakRealmRoleConverter converter =
-        new KeycloakRealmRoleConverter();
-
-    @Test
-    void mapsRealmRolesWithExactlyOneRolePrefix() {
-        Jwt jwt = new Jwt(
-            "token",
-            Instant.now(),
-            Instant.now().plusSeconds(60),
-            Map.of("alg", "none"),
-            Map.of("sub", "subject", "realm_access", Map.of(
-                "roles", List.of("admin-role", "user-role")
-            ))
-        );
-
-        assertThat(converter.convert(jwt))
-            .extracting("authority")
-            .containsExactly("ROLE_admin-role", "ROLE_user-role");
-    }
-
-    @Test
-    void missingRealmAccessProducesNoAuthorities() {
-        Jwt jwt = new Jwt(
-            "token",
-            Instant.now(),
-            Instant.now().plusSeconds(60),
-            Map.of("alg", "none"),
-            Map.of("sub", "subject")
-        );
-
-        assertThat(converter.convert(jwt)).isEmpty();
-    }
-}

docker-compose.yml

@@ -88,57 +88,28 @@ services:
       - keycloak-net
     restart: unless-stopped
 
-  app-wrong-audience:
-    profiles:
-      - diagnostics
+  token-mediator:
     build:
-      context: ./backend
+      context: ./token-mediator
     environment:
-      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
-      SECURITY_EXPECTED_AUDIENCE: deliberately-wrong-audience
+      SERVER_PORT: "8082"
+      KEYCLOAK_CLIENT_SECRET: ${TOKEN_MEDIATING_CLIENT_SECRET:?set TOKEN_MEDIATING_CLIENT_SECRET in .env}
     ports:
-      - "127.0.0.1:18081:8081"
+      - "127.0.0.1:8082:8082"
     depends_on:
       keycloak:
         condition: service_healthy
     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-SHELL
-        - wget -q -O - http://127.0.0.1:8081/actuator/health | grep -q '"status":"UP"'
+        - wget -q -O - http://127.0.0.1:8082/actuator/health | grep -q '"status":"UP"'
       interval: 10s
       timeout: 5s
       retries: 12
       start_period: 20s
     networks:
       - keycloak-net
+    restart: unless-stopped
 
   nginx:
     build:

docs/account-linking-spa-ux.md

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

docs/ap1-refresh-logout.md

@@ -1,30 +0,0 @@
-# AP1 refresh rotation and logout
-
-Realm 실행 profile:
-
-- Access Token Lifespan: 300초
-- Revoke Refresh Token: 활성화
-- Refresh Token Max Reuse: 0
-
-`e2e/pattern1.mjs`는 token 원문을 출력하지 않고 다음 순서를 실행한다.
-
-1. browser Authorization Code + PKCE 로그인으로 AT₁/RT₁/ID Token을 받는다.
-2. `signoutRedirect()`가 `id_token_hint`를 포함한 Keycloak logout endpoint를
-   호출하는지 확인한다.
-3. logout 이후 새 authorization 요청에서 로그인 화면이 다시 필요한지
-   확인한다.
-4. 새 RT₁으로 refresh하여 AT₂/RT₂를 받고 RT₂가 RT₁과 다른지 확인한다.
-5. 이미 소비된 RT₁을 재사용해 성공하지 않는지 확인한다.
-6. RT₁ 재사용 뒤 RT₂와 realm session 상태가 어떤 결과를 내는지 status로
-   기록한다. 이 결과를 사전에 family invalidation이라고 단정하지 않는다.
-7. refresh token을 revoke한 뒤 같은 refresh token의 재사용은 실패하지만,
-   이미 발급된 self-contained access JWT는 `exp` 전까지 Resource Server에서
-   계속 `200`인 stateless 함정을 확인한다.
-
-logout은 브라우저 SSO session을 종료하는 흐름이고 token revocation은 특정
-token grant를 폐기하는 흐름이다. 둘은 목적과 endpoint가 다르다.
-
-즉시 access 차단이 필요한 시스템이라면 짧은 access token TTL 외에
-introspection, reference token 또는 별도 deny-list 같은 stateful 검증을
-검토해야 한다. 이 AP1 구현은 JWT의 stateless 검증 특성을 의도적으로
-유지한다.

docs/ap1-token-storage.md

@@ -1,29 +0,0 @@
-# AP1 token storage trade-off
-
-AP1에서는 `access_token`, `refresh_token`, `id_token`을
-`oidc-client-ts`의 명시적인 `InMemoryWebStorage`에만 보관한다.
-`localStorage`와 `sessionStorage`에는 OAuth token을 저장하지 않는다.
-
-full-page authorization redirect를 생존해야 하는 일회성 transaction
-state와 PKCE verifier만 `sessionStorage`를 사용한다. callback 성공 후
-라이브러리가 해당 transaction state를 제거한다.
-
-| 저장 위치 | reload 생존 | JavaScript 접근 | AP1 선택 |
-|---|---:|---:|---:|
-| 메모리 | 아니요 | 실행 중 가능 | 사용 |
-| `sessionStorage` | 같은 탭에서 가능 | 가능 | token 저장 금지 |
-| `localStorage` | 예 | 가능 | token 저장 금지 |
-| HttpOnly cookie | 가능 | raw token 접근 불가 | AP2/AP3의 서버 소유 경계 |
-
-메모리 저장은 XSS를 제거하지 않는다. 악성 스크립트가 실행 중 `fetch`를
-후킹하면 SPA가 붙이는 `Authorization: Bearer ...` 헤더를 관찰할 수 있다.
-다만 persistent storage를 사용하지 않으므로 reload 이후 탈취 가능한 token
-복사본이 남지 않는다.
-
-`e2e/pattern1.mjs`는 다음 두 조건을 동시에 검증한다.
-
-1. access token이 Web Storage 어디에도 존재하지 않는다.
-2. 실행 중 fetch hook은 Bearer token을 관찰할 수 있다.
-
-따라서 결론은 “메모리면 XSS에 안전”이 아니라 “영속 탈취 범위를 줄이지만
-실행 중 XSS에는 여전히 노출”이다.

docs/ap2-token-boundary.md

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

docs/federation-spa-zero-change.md

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

docs/internal-spa-direct-google-federation.md

@@ -1,18 +0,0 @@
-# AP1 internal SPA direct: Google-federated profile
-
-```text
-SPA -> Keycloak -> Google
-SPA <- Keycloak code/token <- Keycloak
-SPA -> Spring API with Keycloak access token
-```
-
-Google은 upstream authentication만 담당한다. SPA와 Resource Server의 trust
-anchor는 계속 Keycloak issuer/JWKS/audience다. 따라서 Spring이 Google
-ID token을 직접 받거나 Google JWKS를 검증하지 않는다.
-
-추가 운영 항목은 Google client secret, exact broker redirect URI, safe First
-Broker Login, `sub` account key, claim mapper다. 로컬에서는 두 번째 Keycloak
-realm이 Google 역할을 하므로 외부 credential 없이 같은 hop을 재현한다.
-
-`verify-internal-spa-google-contract.sh`는 broker 설정과 기존 AP1 SPA의
-zero-change federation E2E를 함께 실행한다.

docs/internal-spa-direct-no-google.md

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

docs/pkce-flow-stages.md

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

docs/refresh-token-rotation.md

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

docs/single-ec2-google-federation.md

@@ -1,20 +0,0 @@
-# Single EC2 with Google federation
-
-local-identity single-EC2 topology에 다음 네 요소가 추가된다.
-
-1. 고정 public HTTPS hostname
-2. trusted TLS/reverse proxy와 Keycloak public hostname
-3. Google OAuth client의 exact broker callback
-4. Keycloak Google IdP secret과 safe First Broker Login policy
-
-학습 profile은 Cloudflare named tunnel을 사용할 수 있어 EC2 inbound에
-Keycloak 8080을 열지 않는다. containerized cloudflared의 origin은
-`127.0.0.1`이 아니라 Compose service DNS의 reverse proxy다.
-
-실제 Google secret은 `.env`/secret store에만 두며 realm export나 Git에
-포함하지 않는다. credential이 없는 CI는 mock OIDC realm으로 broker 계약을
-검증하고, 실제 Google callback은 사용자 소유 credential/domain 환경에서
-별도 실행한다.
-
-`verify-single-ec2-google-profile.sh`는 tunnel, proxy headers, redirect URI,
-broker realm 계약을 묶어 검증한다.

docs/single-ec2-no-google.md

@@ -1,20 +0,0 @@
-# Single EC2, AP1, no Google
-
-한 VM의 Docker Compose에 PostgreSQL, Keycloak, Spring API, nginx SPA를 둔다.
-외부 진입점만 nginx/TLS proxy로 제한하고 Keycloak 8080, API 8081, PostgreSQL은
-loopback 또는 Docker private network에 둔다.
-
-```text
-Internet :443 -> TLS proxy/SPA
-                    |-> Spring API:8081
-Browser ----------->|-> Keycloak:8080 (public auth path만 proxy)
-Keycloak ----------> PostgreSQL:5432
-```
-
-이 profile은 Google credential과 tunnel이 필요 없다. EC2 보안 그룹은 22
-(관리 정책에 따른 제한), 80/443만 열고 container 내부 포트를 공개하지 않는다.
-backup 대상은 PostgreSQL 데이터와 realm/config/secret이며 Keycloak 개발
-모드 `start-dev`는 production에서 사용하지 않는다.
-
-`verify-single-ec2-no-google.sh`는 Compose rendering, loopback binding,
-AP1 local-identity 계약을 확인한다.

docs/spring-role-mapping.md

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

docs/three-leg-trust-chain.md

@@ -1,15 +0,0 @@
-# Three-leg trust chain
-
-| Hop | 발급자/행위자 | 검증자 | 핵심 검증 |
-|---|---|---|---|
-| 1 | Google/mock IdP | Keycloak broker | signature, upstream issuer, client audience, expiry, nonce |
-| 2 | Keycloak | SPA | state, PKCE code binding, Keycloak issuer, token response |
-| 3 | Keycloak access token | Spring Resource Server | Keycloak signature/JWKS, issuer, expiry, API audience, roles |
-
-Keycloak은 upstream ID token을 그대로 SPA에 전달하지 않는다. upstream
-identity를 검증·연결한 뒤 자신의 realm key로 새 token을 발급한다. 그 결과
-backend의 trust store와 issuer 설정은 Google 로그인 여부와 무관하게 하나다.
-
-`verify-three-leg-trust-chain.sh`는 두 realm의 discovery issuer가 서로 다르고,
-Spring 코드가 main Keycloak issuer만 신뢰하는지 확인한다. 실제 hop 전체는
-`verify-federation-spa-zero-change.sh`로 검증한다.

e2e/federation-zero-change.mjs

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

e2e/package.json

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

e2e/pattern1.mjs

@@ -1,210 +0,0 @@
-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;
-const frontendUrl = "http://localhost:8088/";
-const tokenEndpoint =
-  "http://localhost:8080/realms/keycloak-patterns/protocol/openid-connect/token";
-const revokeEndpoint =
-  "http://localhost:8080/realms/keycloak-patterns/protocol/openid-connect/revoke";
-
-assert.ok(password, "E2E_PASSWORD must be set");
-
-async function login(page) {
-  await page.locator("#login").click();
-  await page.waitForURL(/localhost:8080/u);
-  await page.locator("#username").waitFor();
-
-  const tokenResponsePromise = page.waitForResponse((response) =>
-    response.url() === tokenEndpoint
-    && response.request().postData()?.includes("grant_type=authorization_code"),
-  );
-
-  await page.locator("#username").fill(username);
-  await page.locator("#password").fill(password);
-  await page.locator("#kc-login").click();
-
-  const tokenResponse = await tokenResponsePromise;
-  assert.equal(tokenResponse.status(), 200);
-  const tokenSet = await tokenResponse.json();
-  assert.ok(tokenSet.access_token);
-  assert.ok(tokenSet.refresh_token);
-  assert.ok(tokenSet.id_token);
-
-  await page.waitForURL(frontendUrl);
-  await page.locator('[data-authenticated="true"]').waitFor();
-  return tokenSet;
-}
-
-async function postForm(url, values) {
-  return fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams(values),
-  });
-}
-
-async function refresh(refreshToken) {
-  return postForm(tokenEndpoint, {
-    grant_type: "refresh_token",
-    client_id: "spa-public",
-    refresh_token: refreshToken,
-  });
-}
-
-async function callResource(accessToken, url = "http://localhost:8081/api/me") {
-  return fetch(url, {
-    headers: { Authorization: `Bearer ${accessToken}` },
-  });
-}
-
-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(frontendUrl);
-  const firstTokenSet = await login(page);
-
-  assert.equal(authorizationUrl?.searchParams.get("response_type"), "code");
-  assert.equal(authorizationUrl?.searchParams.get("code_challenge_method"), "S256");
-  assert.ok(authorizationUrl?.searchParams.get("code_challenge"));
-
-  await page.evaluate(() => {
-    const originalFetch = window.fetch.bind(window);
-    window.__xssProbe = { authorization: null };
-    window.fetch = (input, init = {}) => {
-      const headers = new Headers(
-        init.headers ?? (input instanceof Request ? input.headers : undefined),
-      );
-      const authorization = headers.get("Authorization");
-      if (authorization) {
-        window.__xssProbe.authorization = authorization;
-      }
-      return originalFetch(input, init);
-    };
-  });
-
-  await page.locator("#call-api").click();
-  await page.waitForFunction(() => {
-    const text = document.querySelector("#result")?.textContent ?? "";
-    return text.includes('"httpStatus": 200');
-  });
-
-  const capturedAuthorization = await page.evaluate(
-    () => window.__xssProbe.authorization,
-  );
-  assert.match(capturedAuthorization, /^Bearer /u);
-  const accessToken = capturedAuthorization.slice("Bearer ".length);
-  assert.equal(accessToken, firstTokenSet.access_token);
-
-  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"));
-
-  const storageSnapshot = await page.evaluate(() => ({
-    localStorage: Object.values(localStorage),
-    sessionStorage: Object.values(sessionStorage),
-  }));
-  assert.equal(JSON.stringify(storageSnapshot).includes(accessToken), false);
-  assert.ok(capturedAuthorization);
-
-  if (process.env.WRONG_AUDIENCE_URL) {
-    assert.equal(
-      (await callResource(accessToken, process.env.WRONG_AUDIENCE_URL)).status,
-      401,
-    );
-  }
-  if (process.env.WRONG_ISSUER_URL) {
-    assert.equal(
-      (await callResource(accessToken, process.env.WRONG_ISSUER_URL)).status,
-      401,
-    );
-  }
-
-  const logoutRequestPromise = page.waitForRequest((request) =>
-    request.url().includes("/protocol/openid-connect/logout"),
-  );
-  await page.locator("#logout").click();
-  const logoutRequest = await logoutRequestPromise;
-  assert.ok(new URL(logoutRequest.url()).searchParams.get("id_token_hint"));
-  await page.waitForURL(frontendUrl);
-  await page.locator('[data-authenticated="false"]').waitFor();
-
-  const secondTokenSet = await login(page);
-  const rotatedResponse = await refresh(secondTokenSet.refresh_token);
-  assert.equal(rotatedResponse.status, 200);
-  const rotated = await rotatedResponse.json();
-  assert.ok(rotated.refresh_token);
-  assert.notEqual(rotated.refresh_token, secondTokenSet.refresh_token);
-
-  const reusedOldResponse = await refresh(secondTokenSet.refresh_token);
-  assert.notEqual(
-    reusedOldResponse.status,
-    200,
-    "a consumed refresh token must not be accepted again",
-  );
-
-  const rotatedAfterReuseResponse = await refresh(rotated.refresh_token);
-  const rotatedAfterReuseStatus = rotatedAfterReuseResponse.status;
-  assert.ok([200, 400, 401].includes(rotatedAfterReuseStatus));
-
-  assert.equal(
-    (await callResource(rotated.access_token)).status,
-    200,
-    "a locally validated access JWT remains usable until exp",
-  );
-
-  await context.clearCookies();
-  await page.reload();
-  await page.locator('[data-authenticated="false"]').waitFor();
-  const thirdTokenSet = await login(page);
-
-  const revokeResponse = await postForm(revokeEndpoint, {
-    token: thirdTokenSet.refresh_token,
-    token_type_hint: "refresh_token",
-    client_id: "spa-public",
-  });
-  assert.equal(revokeResponse.status, 200);
-  assert.notEqual((await refresh(thirdTokenSet.refresh_token)).status, 200);
-  assert.equal(
-    (await callResource(thirdTokenSet.access_token)).status,
-    200,
-    "refresh revoke is not an immediate deny-list for a stateless access JWT",
-  );
-
-  await page.reload();
-  await page.locator('[data-authenticated="false"]').waitFor();
-  assert.equal(
-    await page.evaluate(
-      (token) => JSON.stringify({
-        localStorage: Object.values(localStorage),
-        sessionStorage: Object.values(sessionStorage),
-      }).includes(token),
-      thirdTokenSet.access_token,
-    ),
-    false,
-  );
-
-  console.log(
-    "pattern1 verified: PKCE, aud/iss negatives, memory/XSS boundary, logout, RT rotation/reuse, revoke-vs-stateless JWT"
-      + ` (RT2 after RT1 reuse: ${rotatedAfterReuseStatus})`,
-  );
-} finally {
-  await browser.close();
-}

e2e/pattern2.mjs

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

e2e/role-mapping.mjs

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

frontend/Dockerfile

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

@@ -3,66 +3,31 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="referrer" content="no-referrer">
-  <title>AP1 · SPA Direct + Resource Server</title>
+  <title>Keycloak Authentication Patterns</title>
   <style>
     :root {
       color-scheme: light dark;
       font-family: system-ui, sans-serif;
     }
     body {
-      max-width: 56rem;
-      margin: 6vh auto;
+      max-width: 48rem;
+      margin: 8vh auto;
       padding: 0 1.5rem;
-      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);
+      line-height: 1.6;
     }
     code {
-      padding: 0.1rem 0.3rem;
-    }
-    pre {
-      min-height: 8rem;
-      padding: 1rem;
-      overflow: auto;
-      white-space: pre-wrap;
-    }
-    .notice {
-      border-left: 0.3rem solid #e09f3e;
-      padding-left: 1rem;
+      padding: 0.15rem 0.35rem;
+      border-radius: 0.25rem;
+      background: color-mix(in srgb, CanvasText 10%, Canvas);
     }
   </style>
 </head>
 <body>
-  <main>
-    <h1>AP1 · SPA Direct + Resource Server</h1>
+  <h1>Keycloak Authentication Patterns</h1>
+  <p>공통 Docker Compose baseline이 실행 중입니다.</p>
   <p>
-      바닐라 JavaScript SPA가 <code>spa-public</code> client로 Authorization
-      Code + PKCE를 수행하고, access token을 직접 Spring Resource Server에
-      전달합니다.
+    공개 API는 <code>/api/public</code>, 보호 API는
+    <code>/api/me</code>에서 확인할 수 있습니다.
   </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

@@ -21,7 +21,6 @@ server {
     }
 
     location / {
-        add_header Cache-Control "no-store";
         try_files $uri $uri/ /index.html;
     }
 }

frontend/package-lock.json

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

@@ -1,16 +0,0 @@
-{
-  "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/account-linking.js

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

frontend/src/app.js

@@ -1,131 +0,0 @@
-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));
-
-try {
-  const callbackUser = await finishSigninCallback();
-  renderSession(callbackUser ?? await userManager.getUser());
-} catch (error) {
-  renderSession(null);
-  renderJson({ error: error.message });
-}

frontend/src/pkce.js

@@ -1,26 +0,0 @@
-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/account-linking.test.mjs

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

frontend/test/pkce.test.mjs

@@ -1,18 +0,0 @@
-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);
-});

keycloak/import/keycloak-patterns-realm.json

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

scripts/validate-realm.py

@@ -70,18 +70,6 @@ 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-federation-spa-zero-change.sh

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

scripts/verify-internal-spa-google-contract.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-./scripts/verify-google-broker-config.sh
-./scripts/verify-federation-spa-zero-change.sh
-echo "AP1 Google-federated profile verified"

scripts/verify-internal-spa-no-google-contract.sh

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

scripts/verify-pattern1.sh

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

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

scripts/verify-pkce-flow-stages.sh

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

scripts/verify-refresh-token-rotation-contract.sh

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

scripts/verify-single-ec2-google-profile.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-./scripts/verify-public-tunnel-config.sh
-./scripts/verify-reverse-proxy-headers.sh
-./scripts/verify-google-redirect-uri-policy.sh
-./scripts/verify-google-broker-config.sh
-echo "Single-EC2 Google federation deployment profile verified"

scripts/verify-single-ec2-no-google.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-rendered="$(docker compose config --format json)"
-printf '%s\n' "$rendered" | jq -e '
-  (.services.keycloak.ports[] | .host_ip == "127.0.0.1" and .target == 8080)
-  and
-  (.services.app.ports[] | .host_ip == "127.0.0.1" and .target == 8081)
-  and
-  (.networks["keycloak-net"].driver == "bridge")
-' >/dev/null
-
-./scripts/verify-internal-spa-no-google-contract.sh
-echo "Single-EC2 local-identity topology verified"

scripts/verify-spring-role-mapping.sh

@@ -1,13 +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
-npm --prefix e2e ci
-REGULAR_USER_PASSWORD="$REGULAR_USER_PASSWORD" \
-ADMIN_USER_PASSWORD="$ADMIN_USER_PASSWORD" \
-  npm --prefix e2e run test:role-mapping

scripts/verify-three-leg-trust-chain.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-base="${KEYCLOAK_URL:-http://localhost:8080}"
-main_issuer="$base/realms/keycloak-patterns"
-mock_issuer="$base/realms/mock-google"
-
-test "$(curl -fsS "$main_issuer/.well-known/openid-configuration" | jq -r .issuer)" \
-  = "$main_issuer"
-test "$(curl -fsS "$mock_issuer/.well-known/openid-configuration" | jq -r .issuer)" \
-  = "$mock_issuer"
-
-rg -Fq 'SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_ISSUER_URI:' docker-compose.yml
-if rg -qi 'accounts\\.google\\.com|realms/mock-google' backend/src/main; then
-  echo "backend must trust only the Keycloak issuer, not the upstream IdP" >&2
-  exit 1
-fi
-
-echo "Three-leg trust anchors verified: upstream -> Keycloak -> Resource Server"

token-mediator/.dockerignore

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

token-mediator/Dockerfile

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

token-mediator/pom.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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