Использование Keycloak со Spring Boot и интеграция Identity Provider

.PHONY: start stop restart logs clean
 
start:
    docker-compose up -d
    @echo "Waiting for Keycloak to start..."
    @until curl -s http://localhost:8080/health/ready > /dev/null; do sleep 2; done
    @echo "Keycloak is ready: http://localhost:8080"
    @echo "Admin Console: http://localhost:8080/admin (admin/admin)"
 
stop:
    docker-compose down
 
restart: stop start
 
logs:
    docker-compose logs -f keycloak
 
clean:
    docker-compose down -v
    docker system prune -f
 
reset: clean start
 
export-realm:
    docker exec keycloak-server /opt/keycloak/bin/kc.sh export \
        --dir /tmp --realm development --users different_files
    docker cp keycloak-server:/tmp/development-realm.json ./realm-export.json
 
test-health:
    curl -s http://localhost:8080/health | jq .
    curl -s http://localhost:8080/health/ready | jq .

@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/", "/public/**", "/health/[B]").permitAll()
                .requestMatchers("/admin/[/B]").hasRole("ADMIN")
                .requestMatchers("/api/**").authenticated()
                .anyRequest().authenticated()
            )
            .oauth2Login(oauth2 -> oauth2
                .loginPage("/oauth2/authorization/keycloak")
                .defaultSuccessUrl("/dashboard", true)
                .failureUrl("/login?error=true")
                .userInfoEndpoint(userInfo -> 
                    userInfo.userAuthoritiesMapper(authoritiesMapper())
                )
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt
                    .jwtAuthenticationConverter(jwtAuthenticationConverter())
                )
            )
            .logout(logout -> logout
                .logoutUrl("/logout")
                .logoutSuccessHandler(oidcLogoutSuccessHandler())
                .invalidateHttpSession(true)
                .clearAuthentication(true)
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
                .maximumSessions(1)
                .maxSessionsPreventsLogin(false)
            );
 
        return http.build();
    }
 
    @Bean
    public GrantedAuthoritiesMapper authoritiesMapper() {
        return authorities -> {
            Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
            
            authorities.forEach(authority -> {
                if (authority instanceof OidcUserAuthority oidcUserAuthority) {
                    mappedAuthorities.addAll(extractKeycloakRoles(oidcUserAuthority.getIdToken()));
                } else if (authority instanceof OAuth2UserAuthority oauth2UserAuthority) {
                    mappedAuthorities.addAll(extractKeycloakRoles(oauth2UserAuthority.getAttributes()));
                }
                mappedAuthorities.add(authority);
            });
            
            return mappedAuthorities;
        };
    }
 
    private Collection<GrantedAuthority> extractKeycloakRoles(OidcIdToken idToken) {
        Map<String, Object> realmAccess = idToken.getClaim("realm_access");
        if (realmAccess != null && realmAccess.get("roles") instanceof List) {
            @SuppressWarnings("unchecked")
            List<String> roles = (List<String>) realmAccess.get("roles");
            return roles.stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                .collect(Collectors.toSet());
        }
        return Collections.emptySet();
    }
 
    private Collection<GrantedAuthority> extractKeycloakRoles(Map<String, Object> attributes) {
        Map<String, Object> realmAccess = (Map<String, Object>) attributes.get("realm_access");
        if (realmAccess != null && realmAccess.get("roles") instanceof List) {
            @SuppressWarnings("unchecked")
            List<String> roles = (List<String>) realmAccess.get("roles");
            return roles.stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                .collect(Collectors.toSet());
        }
        return Collections.emptySet();
    }
 
    @Bean
    public JwtAuthenticationConverter jwtAuthenticationConverter() {
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(jwt -> {
            Map<String, Object> realmAccess = jwt.getClaim("realm_access");
            if (realmAccess != null && realmAccess.get("roles") instanceof List) {
                @SuppressWarnings("unchecked")
                List<String> roles = (List<String>) realmAccess.get("roles");
                return roles.stream()
                    .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                    .collect(Collectors.toSet());
            }
            return Collections.emptySet();
        });
        return converter;
    }
 
    @Bean
    public OidcClientInitiatedLogoutSuccessHandler oidcLogoutSuccessHandler() {
        OidcClientInitiatedLogoutSuccessHandler handler = 
            new OidcClientInitiatedLogoutSuccessHandler(clientRegistrationRepository());
        handler.setPostLogoutRedirectUri("{baseUrl}/");
        return handler;
    }
 
    @Bean
    public ClientRegistrationRepository clientRegistrationRepository() {
        return new InMemoryClientRegistrationRepository(keycloakClientRegistration());
    }
 
    private ClientRegistration keycloakClientRegistration() {
        return ClientRegistrations
            .fromIssuerLocation("http://localhost:8080/realms/development")
            .registrationId("keycloak")
            .clientId("spring-boot-app")
            .clientSecret("your-secret-here")
            .scope("openid", "profile", "email", "roles")
            .build();
    }
}

@Controller
public class DashboardController {
 
    @GetMapping("/")
    public String home() {
        return "index";
    }
 
    @GetMapping("/dashboard")
    public String dashboard(Model model, Authentication authentication) {
        if (authentication instanceof OidcUser oidcUser) {
            model.addAttribute("user", oidcUser);
            model.addAttribute("idToken", oidcUser.getIdToken());
            model.addAttribute("authorities", authentication.getAuthorities());
            
            // Извлечение дополнительных атрибутов
            String department = oidcUser.getAttribute("department");
            String employeeId = oidcUser.getAttribute("employeeId");
            
            model.addAttribute("department", department);
            model.addAttribute("employeeId", employeeId);
        }
        
        return "dashboard";
    }
 
    @GetMapping("/admin")
    @PreAuthorize("hasRole('ADMIN')")
    public String admin(Model model, @AuthenticationPrincipal OidcUser user) {
        model.addAttribute("adminUser", user);
        return "admin";
    }
 
    @ResponseBody
    @GetMapping("/api/userinfo")
    public Map<String, Object> userInfo(JwtAuthenticationToken token) {
        Map<String, Object> userInfo = new HashMap<>();
        userInfo.put("sub", token.getToken().getSubject());
        userInfo.put("preferred_username", token.getToken().getClaimAsString("preferred_username"));
        userInfo.put("email", token.getToken().getClaimAsString("email"));
        userInfo.put("roles", token.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.toList()));
        
        return userInfo;
    }
}

@ControllerAdvice
public class AuthenticationErrorHandler {
 
    @ExceptionHandler(OAuth2AuthenticationException.class)
    public String handleOAuth2Exception(
            OAuth2AuthenticationException ex, 
            RedirectAttributes redirectAttributes) {
        
        String errorCode = ex.getError().getErrorCode();
        String errorMessage = switch (errorCode) {
            case "invalid_grant" -> "Неверное имя пользователя или пароль";
            case "account_not_verified" -> "Аккаунт не подтверждён. Проверьте email";
            case "account_disabled" -> "Аккаунт заблокирован. Обратитесь к администратору";
            default -> "Ошибка входа в систему";
        };
        
        redirectAttributes.addFlashAttribute("error", errorMessage);
        return "redirect:/login?error=true";
    }
 
    @ExceptionHandler(JwtException.class)
    public ResponseEntity<Map<String, String>> handleJwtException(JwtException ex) {
        Map<String, String> error = new HashMap<>();
        error.put("error", "invalid_token");
        error.put("error_description", "Токен недействителен или истёк");
        
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(error);
    }
}

@Configuration
public class CorsConfig {
 
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOriginPatterns(Arrays.asList(
            "http://localhost:*",
            "https://*.example.com"
        ));
        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
        configuration.setAllowedHeaders(Arrays.asList("*"));
        configuration.setAllowCredentials(true);
        configuration.setMaxAge(3600L);
 
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/api/**", configuration);
        source.registerCorsConfiguration("/oauth2/**", configuration);
        
        return source;
    }
}

@SpringBootTest
@TestPropertySource(properties = {
    "spring.security.oauth2.client.provider.keycloak.issuer-uri=http://localhost:8080/realms/development"
})
class SecurityConfigTests {
 
    @Autowired
    private SecurityConfig securityConfig;
 
    @Test
    void shouldMapKeycloakRolesToSpringAuthorities() {
        // Создаём mock ID token с ролями
        Map<String, Object> claims = new HashMap<>();
        Map<String, Object> realmAccess = new HashMap<>();
        realmAccess.put("roles", Arrays.asList("admin", "user"));
        claims.put("realm_access", realmAccess);
        
        OidcIdToken idToken = new OidcIdToken("token", 
            Instant.now(), 
            Instant.now().plusSeconds(3600), 
            claims);
        
        OidcUserAuthority authority = new OidcUserAuthority(idToken);
        Collection<GrantedAuthority> authorities = 
            Arrays.asList(authority);
 
        GrantedAuthoritiesMapper mapper = securityConfig.authoritiesMapper();
        Collection<GrantedAuthority> mappedAuthorities = mapper.mapAuthorities(authorities);
 
        assertThat(mappedAuthorities).anyMatch(auth -> 
            auth.getAuthority().equals("ROLE_ADMIN"));
        assertThat(mappedAuthorities).anyMatch(auth -> 
            auth.getAuthority().equals("ROLE_USER"));
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
class KeycloakIntegrationTest {
 
    @Container
    static KeycloakContainer keycloak = new KeycloakContainer("quay.io/keycloak/keycloak:23.0")
        .withRealmImportFile("test-realm.json");
 
    @Autowired
    private TestRestTemplate restTemplate;
 
    @LocalServerPort
    private int port;
 
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.security.oauth2.client.provider.keycloak.issuer-uri",
            () -> keycloak.getAuthServerUrl() + "/realms/test");
    }
 
    @Test
    void shouldRedirectUnauthenticatedToKeycloak() {
        ResponseEntity<String> response = restTemplate.getForEntity(
            "http://localhost:" + port + "/dashboard", String.class);
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FOUND);
        assertThat(response.getHeaders().getLocation().toString())
            .contains(keycloak.getAuthServerUrl());
    }
 
    @Test
    void shouldAllowAccessAfterAuthentication() throws Exception {
        String accessToken = getAccessToken("testuser", "password");
        
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(accessToken);
        HttpEntity<String> entity = new HttpEntity<>(headers);
 
        ResponseEntity<Map> response = restTemplate.exchange(
            "http://localhost:" + port + "/api/userinfo", 
            HttpMethod.GET, 
            entity, 
            Map.class);
 
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody())
            .containsEntry("preferred_username", "testuser");
    }
 
    private String getAccessToken(String username, String password) throws Exception {
        MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
        params.add("grant_type", "password");
        params.add("client_id", "test-client");
        params.add("username", username);
        params.add("password", password);
 
        ResponseEntity<Map> response = restTemplate.postForEntity(
            keycloak.getAuthServerUrl() + "/realms/test/protocol/openid-connect/token",
            params,
            Map.class);
 
        return (String) response.getBody().get("access_token");
    }
}

@Component
public class KeycloakHealthIndicator implements HealthIndicator {
 
    private final ReactiveOAuth2AuthorizedClientService authorizedClientService;
    private final WebClient webClient;
    private final String keycloakUrl;
 
    public KeycloakHealthIndicator(
            ReactiveOAuth2AuthorizedClientService authorizedClientService,
            @Value("${spring.security.oauth2.client.provider.keycloak.issuer-uri}") String issuerUri) {
        this.authorizedClientService = authorizedClientService;
        this.keycloakUrl = issuerUri;
        this.webClient = WebClient.create();
    }
 
    @Override
    public Health health() {
        try {
            // Проверяём доступность OIDC configuration endpoint
            String configUrl = keycloakUrl + "/.well-known/openid_configuration";
            
            Map<String, Object> config = webClient.get()
                .uri(configUrl)
                .retrieve()
                .bodyToMono(new ParameterizedTypeReference<Map<String, Object>>() {})
                .timeout(Duration.ofSeconds(5))
                .block();
 
            if (config != null && config.containsKey("issuer")) {
                return Health.up()
                    .withDetail("issuer", config.get("issuer"))
                    .withDetail("authorization_endpoint", config.get("authorization_endpoint"))
                    .withDetail("token_endpoint", config.get("token_endpoint"))
                    .build();
            } else {
                return Health.down()
                    .withDetail("error", "Invalid OIDC configuration")
                    .build();
            }
        } catch (Exception ex) {
            return Health.down()
                .withDetail("error", ex.getMessage())
                .withDetail("keycloak_url", keycloakUrl)
                .build();
        }
    }
}

@Configuration
public class JwtConfig {
 
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("jwt-keys");
    }
 
    @Bean
    public NimbusJwtDecoder jwtDecoder(@Value("${spring.security.oauth2.client.provider.keycloak.issuer-uri}") String issuerUri) {
        String jwkSetUri = issuerUri + "/protocol/openid-connect/certs";
        
        NimbusJwtDecoder decoder = NimbusJwtDecoder
            .withJwkSetUri(jwkSetUri)
            .cache(Duration.ofMinutes(15))
            .build();
 
        // Дополнительная валидация claims
        decoder.setJwtValidator(jwtValidator());
        
        return decoder;
    }
 
    @Bean
    public Converter<Jwt, AbstractAuthenticationToken> jwtAuthenticationTokenConverter() {
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(this::extractAuthorities);
        converter.setPrincipalClaimName("preferred_username");
        return converter;
    }
 
    private Collection<GrantedAuthority> extractAuthorities(Jwt jwt) {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        
        // Извлечение realm ролей
        Map<String, Object> realmAccess = jwt.getClaim("realm_access");
        if (realmAccess != null) {
            List<String> roles = (List<String>) realmAccess.get("roles");
            if (roles != null) {
                authorities.addAll(roles.stream()
                    .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                    .collect(Collectors.toList()));
            }
        }
 
        // Извлечение client-specific ролей
        Map<String, Object> resourceAccess = jwt.getClaim("resource_access");
        if (resourceAccess != null) {
            resourceAccess.forEach((clientId, access) -> {
                if (access instanceof Map) {
                    Map<String, Object> clientAccess = (Map<String, Object>) access;
                    List<String> clientRoles = (List<String>) clientAccess.get("roles");
                    if (clientRoles != null) {
                        authorities.addAll(clientRoles.stream()
                            .map(role -> new SimpleGrantedAuthority("CLIENT_" + clientId + "_" + role.toUpperCase()))
                            .collect(Collectors.toList()));
                    }
                }
            });
        }
 
        return authorities;
    }
 
    @Bean
    public Jwt Validator<Jwt> jwtValidator() {
        List<Jwt Validator<Jwt>> validators = new ArrayList<>();
        validators.add(new JwtTimestampValidator(Duration.ofSeconds(60))); // Clock skew tolerance
        validators.add(new JwtIssuerValidator("http://localhost:8080/realms/development"));
        
        return new DelegatingJwtValidator(validators);
    }
}

@Service
public class TokenRefreshService {
 
    private final ReactiveOAuth2AuthorizedClientService authorizedClientService;
    private final ReactiveOAuth2AuthorizedClientManager authorizedClientManager;
 
    @EventListener
    public void handleAuthenticationSuccess(OAuth2LoginAuthenticationToken token) {
        // Планируем обновление токена за 2 минуты до истечения
        if (token.getPrincipal() instanceof OidcUser oidcUser) {
            OidcIdToken idToken = oidcUser.getIdToken();
            Instant expiresAt = idToken.getExpiresAt();
            
            if (expiresAt != null) {
                Duration delay = Duration.between(Instant.now(), expiresAt.minus(Duration.ofMinutes(2)));
                if (delay.isPositive()) {
                    scheduleTokenRefresh(token, delay);
                }
            }
        }
    }
 
    @Async
    public void scheduleTokenRefresh(OAuth2LoginAuthenticationToken token, Duration delay) {
        try {
            Thread.sleep(delay.toMillis());
            refreshTokenIfNeeded(token);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
 
    private void refreshTokenIfNeeded(OAuth2LoginAuthenticationToken token) {
        // Логика обновления через authorizedClientManager
        OAuth2AuthorizedClient authorizedClient = 
            authorizedClientManager.loadAuthorizedClient("keycloak", token.getName());
        
        if (authorizedClient != null && isTokenExpiringSoon(authorizedClient.getAccessToken())) {
            // Принудительное обновление токена
            OAuth2AuthorizedClientManager.RefreshTokenResult result = 
                authorizedClientManager.authorize(OAuth2AuthorizedClientManager.AuthorizeRequest.withClientId("keycloak")
                    .principal(token.getName())
                    .build());
        }
    }
 
    private boolean isTokenExpiringSoon(OAuth2AccessToken accessToken) {
        Instant expiresAt = accessToken.getExpiresAt();
        return expiresAt != null && expiresAt.isBefore(Instant.now().plus(Duration.ofMinutes(5)));
    }
}

@RestController
public class SecurityMetricsController {
 
    private final MeterRegistry meterRegistry;
    private final Counter successfulLogins;
    private final Counter failedLogins;
    private final Timer authenticationDuration;
 
    public SecurityMetricsController(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.successfulLogins = Counter.builder("authentication.success")
            .description("Number of successful authentications")
            .register(meterRegistry);
        this.failedLogins = Counter.builder("authentication.failure")
            .description("Number of failed authentications")
            .register(meterRegistry);
        this.authenticationDuration = Timer.builder("authentication.duration")
            .description("Time taken for authentication")
            .register(meterRegistry);
    }
 
    @EventListener
    public void handleAuthenticationSuccess(AuthenticationSuccessEvent event) {
        successfulLogins.increment(
            Tags.of("type", event.getAuthentication().getClass().getSimpleName())
        );
    }
 
    @EventListener 
    public void handleAuthenticationFailure(AbstractAuthenticationFailureEvent event) {
        failedLogins.increment(
            Tags.of("reason", event.getException().getClass().getSimpleName())
        );
    }
 
    @GetMapping("/actuator/auth-metrics")
    public Map<String, Object> getAuthMetrics() {
        Map<String, Object> metrics = new HashMap<>();
        metrics.put("successful_logins", successfulLogins.count());
        metrics.put("failed_logins", failedLogins.count());
        metrics.put("avg_auth_duration", authenticationDuration.mean(TimeUnit.MILLISECONDS));
        return metrics;
    }
}

@Configuration
public class KeycloakRoleConfig {
 
    @Bean
    public GrantedAuthoritiesMapper keycloakAuthoritiesMapper() {
        return authorities -> {
            Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
            
            authorities.forEach(authority -> {
                if (authority instanceof JwtAuthenticationToken) {
                    JwtAuthenticationToken jwtToken = (JwtAuthenticationToken) authority;
                    Jwt jwt = jwtToken.getToken();
                    
                    // Извлечение realm ролей
                    extractRealmRoles(jwt, mappedAuthorities);
                    
                    // Извлечение client-specific ролей
                    extractClientRoles(jwt, mappedAuthorities);
                    
                    // Извлечение групп пользователя
                    extractUserGroups(jwt, mappedAuthorities);
                }
            });
            
            return mappedAuthorities;
        };
    }
 
    private void extractRealmRoles(Jwt jwt, Set<GrantedAuthority> authorities) {
        Map<String, Object> realmAccess = jwt.getClaim("realm_access");
        if (realmAccess != null) {
            List<String> roles = (List<String>) realmAccess.get("roles");
            if (roles != null) {
                roles.stream()
                    .filter(role -> !role.startsWith("default-") && !role.equals("offline_access"))
                    .forEach(role -> authorities.add(new SimpleGrantedAuthority("REALM_" + role.toUpperCase())));
            }
        }
    }
 
    private void extractClientRoles(Jwt jwt, Set<GrantedAuthority> authorities) {
        Map<String, Object> resourceAccess = jwt.getClaim("resource_access");
        if (resourceAccess != null) {
            resourceAccess.forEach((clientId, access) -> {
                Map<String, Object> clientAccess = (Map<String, Object>) access;
                List<String> clientRoles = (List<String>) clientAccess.get("roles");
                if (clientRoles != null) {
                    clientRoles.forEach(role -> 
                        authorities.add(new SimpleGrantedAuthority("CLIENT_" + clientId + "_" + role.toUpperCase())));
                }
            });
        }
    }
 
    private void extractUserGroups(Jwt jwt, Set<GrantedAuthority> authorities) {
        List<String> groups = jwt.getClaim("groups");
        if (groups != null) {
            groups.forEach(group -> {
                // Преобразуем path группы в authority
                String groupAuthority = group.replaceAll("/", "_").replaceAll("-", "_").toUpperCase();
                authorities.add(new SimpleGrantedAuthority("GROUP_" + groupAuthority));
            });
        }
    }
}

@Component
public class OrganizationClaimMapper {
 
    public Map<String, Object> mapUserClaims(UserModel user, ClientSessionContext clientSession) {
        Map<String, Object> claims = new HashMap<>();
        
        // Определяем организацию пользователя через атрибуты
        String organizationType = user.getFirstAttribute("organization_type");
        String organizationId = user.getFirstAttribute("organization_id");
        String department = user.getFirstAttribute("department");
        String region = user.getFirstAttribute("region");
        
        if (organizationType != null) {
            claims.put("organization", Map.of(
                "type", organizationType,
                "id", organizationId != null ? organizationId : "",
                "department", department != null ? department : "",
                "region", region != null ? region : ""
            ));
        }
        
        // Добавляем иерархические права доступа
        List<String> permissions = calculateUserPermissions(user);
        claims.put("permissions", permissions);
        
        return claims;
    }
 
    private List<String> calculateUserPermissions(UserModel user) {
        List<String> permissions = new ArrayList<>();
        
        // Базовые права для всех пользователей
        permissions.add("profile:read");
        permissions.add("profile:update");
        
        Set<RoleModel> roles = user.getRoleMappingsStream().collect(Collectors.toSet());
        
        for (RoleModel role : roles) {
            switch (role.getName()) {
                case "employee":
                    permissions.addAll(Arrays.asList("documents:read", "reports:read", "api:access"));
                    break;
                case "partner":
                    permissions.addAll(Arrays.asList("partner_api:access", "shared_documents:read"));
                    break;
                case "customer":
                    permissions.addAll(Arrays.asList("customer_portal:access", "support:create"));
                    break;
                case "admin":
                    permissions.addAll(Arrays.asList("*:*"));
                    break;
                case "manager":
                    String department = user.getFirstAttribute("department");
                    if (department != null) {
                        permissions.add("department_" + department.toLowerCase() + ":manage");
                    }
                    break;
            }
        }
        
        return permissions.stream().distinct().collect(Collectors.toList());
    }
}

@Component
public class TenantAwareSecurityService {
 
    public boolean hasAccessToResource(String resourceId, String action) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth instanceof JwtAuthenticationToken jwtToken) {
            Jwt jwt = jwtToken.getToken();
            
            // Извлекаем информацию об организации
            Map<String, Object> organization = jwt.getClaim("organization");
            if (organization == null) {
                return false;
            }
            
            String organizationType = (String) organization.get("type");
            String organizationId = (String) organization.get("id");
            
            // Проверяем права доступа к ресурсу
            return checkResourceAccess(resourceId, action, organizationType, organizationId, jwt);
        }
        return false;
    }
 
    private boolean checkResourceAccess(String resourceId, String action, 
                                      String orgType, String orgId, Jwt jwt) {
        List<String> permissions = jwt.getClaim("permissions");
        if (permissions == null) {
            return false;
        }
        
        // Проверяем wildcard permissions
        if (permissions.contains("*:*") || permissions.contains(resourceId + ":*")) {
            return true;
        }
        
        // Проверяем специфичные права
        String requiredPermission = resourceId + ":" + action;
        if (permissions.contains(requiredPermission)) {
            return true;
        }
        
        // Проверяем организационные ограничения
        return checkOrganizationalAccess(resourceId, orgType, orgId);
    }
 
    private boolean checkOrganizationalAccess(String resourceId, String orgType, String orgId) {
        // Логика проверки доступа на основе организационной принадлежности
        if ("employee".equals(orgType)) {
            return true; // Сотрудники имеют доступ ко всем внутренним ресурсам
        }
        
        if ("partner".equals(orgType)) {
            return resourceId.startsWith("partner_") || resourceId.startsWith("shared_");
        }
        
        if ("customer".equals(orgType)) {
            return resourceId.startsWith("customer_") && resourceId.contains(orgId);
        }
        
        return false;
    }
}

@Component
public class LdapAttributeMapper {
 
    public Map<String, String> mapLdapAttributes(LDAPObject ldapUser) {
        Map<String, String> keycloakAttributes = new HashMap<>();
        
        // Стандартные атрибуты
        keycloakAttributes.put("email", ldapUser.getAttributeAsString("mail"));
        keycloakAttributes.put("firstName", ldapUser.getAttributeAsString("givenName"));
        keycloakAttributes.put("lastName", ldapUser.getAttributeAsString("sn"));
        keycloakAttributes.put("username", ldapUser.getAttributeAsString("sAMAccountName"));
        
        // Организационные атрибуты
        String department = ldapUser.getAttributeAsString("department");
        if (department != null) {
            keycloakAttributes.put("department", department);
            keycloakAttributes.put("organization_type", "employee");
            keycloakAttributes.put("organization_id", "internal");
        }
        
        // Маппинг AD групп на роли Keycloak
        Set<String> adGroups = ldapUser.getAttributeAsSet("memberOf");
        Set<String> keycloakRoles = mapAdGroupsToRoles(adGroups);
        keycloakAttributes.put("roles", String.join(",", keycloakRoles));
        
        return keycloakAttributes;
    }
 
    private Set<String> mapAdGroupsToRoles(Set<String> adGroups) {
        Set<String> roles = new HashSet<>();
        roles.add("employee"); // Базовая роль для всех сотрудников
        
        for (String group : adGroups) {
            if (group.contains("CN=Domain Admins")) {
                roles.add("admin");
            } else if (group.contains("CN=IT Group")) {
                roles.add("it_admin");
            } else if (group.contains("CN=Managers")) {
                roles.add("manager");
            } else if (group.contains("CN=HR Group")) {
                roles.add("hr_spe******t");
            }
            // Паттерны для департаментов
            else if (group.contains("CN=Sales")) {
                roles.add("sales_user");
            } else if (group.contains("CN=Development")) {
                roles.add("developer");
            }
        }
        
        return roles;
    }
}

@Service
public class DynamicIdpService {
 
    private final KeycloakAdmin keycloakAdmin;
 
    public String registerPartnerIdp(PartnerIdpConfig config) throws IdpRegistrationException {
        try {
            // Создаём новый Identity Provider в Keycloak
            IdentityProviderRepresentation idp = new IdentityProviderRepresentation();
            idp.setAlias(config.getAlias());
            idp.setProviderId("saml");
            idp.setEnabled(true);
            idp.setTrustEmail(false);
            idp.setStoreToken(false);
            idp.setLinkOnly(false);
            
            // Настраиваем SAML конфигурацию
            Map<String, String> samlConfig = new HashMap<>();
            samlConfig.put("singleSignOnServiceUrl", config.getSsoUrl());
            samlConfig.put("singleLogoutServiceUrl", config.getSloUrl());
            samlConfig.put("nameIDPolicyFormat", "urn:oasis:names:tc:SAML:2.0:nameid-format:persistent");
            samlConfig.put("principalType", "SUBJECT");
            samlConfig.put("signatureAlgorithm", "RSA_SHA256");
            samlConfig.put("xmlSigKeyInfoKeyNameTransformer", "KEY_ID");
            
            // Добавляем сертификат партнёра для проверки подписей
            if (config.getSigningCertificate() != null) {
                samlConfig.put("signingCertificate", config.getSigningCertificate());
            }
            
            idp.setConfig(samlConfig);
            
            // Создаём IDP в Keycloak
            keycloakAdmin.realm("development").identityProviders().create(idp);
            
            // Настраиваем маппинг атрибутов
            setupAttributeMappers(config.getAlias(), config.getAttributeMapping());
            
            return config.getAlias();
            
        } catch (Exception e) {
            throw new IdpRegistrationException("Failed to register partner IDP: " + e.getMessage(), e);
        }
    }
 
    private void setupAttributeMappers(String idpAlias, Map<String, String> attributeMapping) {
        // Создаём mapper для организационной принадлежности
        IdentityProviderMapperRepresentation orgMapper = new IdentityProviderMapperRepresentation();
        orgMapper.setName("partner-organization");
        orgMapper.setIdentityProviderAlias(idpAlias);
        orgMapper.setIdentityProviderMapper("hardcoded-attribute-idp-mapper");
        
        Map<String, String> orgConfig = new HashMap<>();
        orgConfig.put("attribute", "organization_type");
        orgConfig.put("attribute.value", "partner");
        orgMapper.setConfig(orgConfig);
        
        keycloakAdmin.realm("development")
            .identityProviders()
            .get(idpAlias)
            .addMapper(orgMapper);
            
        // Добавляем custom mappers для специфичных атрибутов партнёра
        attributeMapping.forEach((samlAttribute, keycloakAttribute) -> {
            IdentityProviderMapperRepresentation mapper = createAttributeMapper(
                idpAlias, samlAttribute, keycloakAttribute);
            keycloakAdmin.realm("development")
                .identityProviders()
                .get(idpAlias)
                .addMapper(mapper);
        });
    }
}

@RestController
@RequestMapping("/api/users")
public class FederatedUserController {
 
    private final FederatedUserService federatedUserService;
 
    @GetMapping("/search")
    @PreAuthorize("hasRole('ADMIN') or hasRole('HR_SPE******T')")
    public ResponseEntity<PagedResult<UserSummary>> searchUsers(
            @RequestParam String query,
            @RequestParam(defaultValue = "all") String organizationType,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        
        UserSearchCriteria criteria = UserSearchCriteria.builder()
            .query(query)
            .organizationType(organizationType)
            .page(page)
            .size(size)
            .build();
            
        PagedResult<UserSummary> result = federatedUserService.searchUsers(criteria);
        return ResponseEntity.ok(result);
    }
 
    @PostMapping("/{userId}/roles")
    @PreAuthorize("hasRole('ADMIN') or (hasRole('MANAGER') and @tenantService.canManageUser(#userId))")
    public ResponseEntity<Void> assignRole(
            @PathVariable String userId,
            @RequestBody RoleAssignmentRequest request) {
        
        federatedUserService.assignRole(userId, request.getRoleName(), request.getScope());
        return ResponseEntity.ok().build();
    }
 
    @GetMapping("/{userId}/permissions")
    public ResponseEntity<Set<String>> getUserPermissions(@PathVariable String userId) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        
        // Проверяем, может ли текущий пользователь просматривать права другого пользователя
        if (!canViewUserPermissions(auth, userId)) {
            throw new AccessDeniedException("Cannot view user permissions");
        }
        
        Set<String> permissions = federatedUserService.getUserPermissions(userId);
        return ResponseEntity.ok(permissions);
    }
    
    private boolean canViewUserPermissions(Authentication auth, String targetUserId) {
        // Админы и HR могут смотреть права всех пользователей
        if (auth.getAuthorities().stream().anyMatch(
                a -> a.getAuthority().equals("ROLE_ADMIN") || a.getAuthority().equals("ROLE_HR_SPE******T"))) {
            return true;
        }
        
        // Пользователи могут смотреть только свои права
        JwtAuthenticationToken jwtToken = (JwtAuthenticationToken) auth;
        String currentUserId = jwtToken.getToken().getSubject();
        return currentUserId.equals(targetUserId);
    }
}

@EventListener
public class FederatedAuditListener {
 
    private final AuditLogService auditLogService;
 
    @EventListener
    public void handleLogin(AuthenticationSuccessEvent event) {
        if (event.getAuthentication() instanceof JwtAuthenticationToken jwtToken) {
            Jwt jwt = jwtToken.getToken();
            
            AuditEvent auditEvent = AuditEvent.builder()
                .eventType("USER_LOGIN")
                .userId(jwt.getSubject())
                .username(jwt.getClaimAsString("preferred_username"))
                .organizationType(extractOrganizationType(jwt))
                .identityProvider(jwt.getClaimAsString("idp"))
                .timestamp(Instant.now())
                .clientId(jwt.getClaimAsString("azp"))
                .remoteAddress(getClientIpAddress())
                .userAgent(getUserAgent())
                .build();
                
            auditLogService.logEvent(auditEvent);
        }
    }
 
    private String extractOrganizationType(Jwt jwt) {
        Map<String, Object> organization = jwt.getClaim("organization");
        return organization != null ? (String) organization.get("type") : "unknown";
    }
}

@Component
public class FederationMetricsCollector {
 
    private final MeterRegistry meterRegistry;
    private final Timer federationLoginTimer;
    private final Counter federationLoginCounter;
    private final Gauge federationCacheHitRate;
 
    public FederationMetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.federationLoginTimer = Timer.builder("federation.login.duration")
            .description("Time taken for federated login")
            .register(meterRegistry);
        this.federationLoginCounter = Counter.builder("federation.login.count")
            .description("Number of federated logins")
            .register(meterRegistry);
        this.federationCacheHitRate = Gauge.builder("federation.cache.hit.rate")
            .description("Cache hit rate for federated user data")
            .register(meterRegistry, this, FederationMetricsCollector::calculateCacheHitRate);
    }
 
    @EventListener
    public void handleFederatedLogin(FederatedLoginEvent event) {
        Timer.Sample sample = Timer.start(meterRegistry);
        
        try {
            processFederatedLogin(event);
            federationLoginCounter.increment(
                Tags.of("provider", event.getProviderType(), "status", "success")
            );
        } catch (Exception e) {
            federationLoginCounter.increment(
                Tags.of("provider", event.getProviderType(), "status", "failure")
            );
        } finally {
            sample.stop(federationLoginTimer.withTags(
                Tags.of("provider", event.getProviderType())
            ));
        }
    }
 
    private double calculateCacheHitRate() {
        // Реализация расчёта cache hit rate
        return cacheStatistics.getHitRate();
    }
}

@Configuration
public class RedirectFixConfig {
 
   @Bean
   public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
       return http
           .oauth2Login(oauth2 -> oauth2
               .loginPage("/oauth2/authorization/keycloak")
               .defaultSuccessUrl("/dashboard", true) // Принудительный редирект
               .failureUrl("/login?error=true")
               .authorizationEndpoint(authorization -> 
                   authorization.baseUri("/oauth2/authorization"))
               .redirectionEndpoint(redirection ->
                   redirection.baseUri("/login/oauth2/code/*"))
           )
           .sessionManagement(session -> session
               .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
               .sessionFixation().changeSessionId()
           )
           .build();
   }
 
   @Bean 
   public RequestCache requestCache() {
       HttpSessionRequestCache cache = new HttpSessionRequestCache();
       cache.setMatchingRequestParameterName(null); // Отключаем сохранение параметров
       return cache;
   }
}

@Configuration
public class JwtDecodingConfig {
 
   @Bean
   public JwtDecoder jwtDecoder(@Value("${keycloak.issuer-uri}") String issuerUri) {
       String jwkSetUri = issuerUri + "/protocol/openid-connect/certs";
       
       NimbusJwtDecoder decoder = NimbusJwtDecoder
           .withJwkSetUri(jwkSetUri)
           .cache(Duration.ofMinutes(15)) // Кеширование ключей
           .build();
           
       // Tolerance для различий во времени между серверами  
       decoder.setClockSkew(Duration.ofSeconds(60));
       
       return decoder;
   }
   
   @Bean
   public Converter<Jwt, AbstractAuthenticationToken> jwtConverter() {
       JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
       
       // Кастомная обработка expired токенов
       converter.setJwtGrantedAuthoritiesConverter(jwt -> {
           if (jwt.getExpiresAt().isBefore(Instant.now().minusSeconds(30))) {
               throw new JwtException("Token expired with grace period");
           }
           return extractAuthorities(jwt);
       });
       
       return converter;
   }
}

@Profile("dev-offline") 
@Configuration
public class MockAuthConfig {
 
   @Bean
   @Primary
   public SecurityFilterChain mockSecurityFilterChain(HttpSecurity http) throws Exception {
       return http
           .authorizeHttpRequests(authz -> authz.anyRequest().authenticated())
           .oauth2Login(oauth2 -> oauth2.disable())
           .httpBasic(basic -> basic.disable())
           .sessionManagement(session -> session
               .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
           .addFilterBefore(mockAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
           .build();
   }
   
   @Bean
   public MockAuthenticationFilter mockAuthenticationFilter() {
       return new MockAuthenticationFilter();
   }
}
 
public class MockAuthenticationFilter extends OncePerRequestFilter {
   
   @Override
   protected void doFilterInternal(HttpServletRequest request, 
                                 HttpServletResponse response, 
                                 FilterChain filterChain) throws ServletException, IOException {
       
       String mockUser = request.getParameter("mockUser");
       if (mockUser == null) {
           mockUser = "testuser"; // Дефолтный пользователь
       }
       
       // Создаём mock JWT токен
       Map<String, Object> claims = Map.of(
           "sub", "mock-" + mockUser,
           "preferred_username", mockUser,
           "email", mockUser + "@example.com",
           "realm_access", Map.of("roles", List.of("user", "developer")),
           "exp", Instant.now().plusSeconds(3600).getEpochSecond()
       );
       
       Jwt jwt = new Jwt("mock-token", Instant.now(), Instant.now().plusSeconds(3600), 
                        Map.of("typ", "JWT"), claims);
       
       JwtAuthenticationToken auth = new JwtAuthenticationToken(jwt, extractAuthorities(jwt));
       SecurityContextHolder.getContext().setAuthentication(auth);
       
       filterChain.doFilter(request, response);
   }
}