Spring Boot, Keycloak и RBAC/ABAC

// Пример конфигурации LDAP-федерации в Keycloak через Admin REST API
LDAPUserStorageProviderRepresentation ldapConfig = new LDAPUserStorageProviderRepresentation();
ldapConfig.setPriority(1);
ldapConfig.setImportEnabled(true);
ldapConfig.setEditMode(UserStorageProvider.EditMode.WRITABLE);
ldapConfig.setConnectionUrl("ldap://ldap.company.org");
ldapConfig.setUsersDn("ou=Users,dc=company,dc=org");
// и другие параметры...
 
// Создание федерации через REST API
adminClient.realm("my-realm").userStorage().create(ldapConfig);

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/api/public/[B]").permitAll()
                .antMatchers("/api/user/[/B]").hasRole("USER")
                .antMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer()
                .jwt();
        return http.build();
    }
    
    // Конвертер для преобразования ролей из JWT-токена в формат Spring Security
    @Bean
    public JwtAuthenticationConverter jwtAuthenticationConverter() {
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(jwt -> {
            Map<String, Object> realmAccess = jwt.getClaimAsMap("realm_access");
            if (realmAccess == null || !realmAccess.containsKey("roles")) {
                return Collections.emptyList();
            }
            
            List<String> roles = (List<String>) realmAccess.get("roles");
            return roles.stream()
                    .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                    .collect(Collectors.toList());
        });
        return converter;
    }
}

public class BiometricAuthenticator implements Authenticator {
    @Override
    public void authenticate(AuthenticationFlowContext context) {
        // Получение данных от клиента
        String biometricData = context.getHttpRequest().getDecodedFormParameters().getFirst("biometricData");
        
        // Вызов внешнего API для проверки
        if (BiometricService.verify(biometricData, getUserFromContext(context))) {
            context.success();
        } else {
            context.failure(AuthenticationFlowError.INVALID_CREDENTIALS);
        }
    }
    
    // Другие методы реализации интерфейса...
}

// Программное создание роли через Admin API
RoleRepresentation roleRepresentation = new RoleRepresentation();
roleRepresentation.setName("sales-manager");
roleRepresentation.setDescription("Может управлять продажами и видеть отчеты");
roleRepresentation.setComposite(false); // Простая роль, не композитная
 
keycloak.realm("my-company").roles().create(roleRepresentation);

// Создание композитной роли
RoleRepresentation financeDepartmentRole = new RoleRepresentation();
financeDepartmentRole.setName("finance-department");
financeDepartmentRole.setComposite(true);
 
// Сначала создаем роль
keycloak.realm("my-company").roles().create(financeDepartmentRole);
 
// Теперь добавляем дочерние роли
List<RoleRepresentation> compositeRoles = new ArrayList<>();
compositeRoles.add(keycloak.realm("my-company").roles().get("view-reports").toRepresentation());
compositeRoles.add(keycloak.realm("my-company").roles().get("manage-expenses").toRepresentation());
compositeRoles.add(keycloak.realm("my-company").roles().get("approve-payments").toRepresentation());
 
keycloak.realm("my-company").rolesById().addComposites(
    financeDepartmentRole.getId(), compositeRoles);

// Настройка временной роли через атрибуты
Map<String, List<String>> attributes = new HashMap<>();
attributes.put("expiration_date", List.of("2025-12-31"));
 
UserRepresentation user = new UserRepresentation();
user.setUsername("temp-contractor");
// ... другие поля пользователя
 
// Сохраняем атрибут с датой истечения
user.setAttributes(attributes);
 
// И конечно, назначаем нужные роли
List<String> realmRoles = List.of("project-viewer");
user.setRealmRoles(realmRoles);
 
keycloak.realm("my-company").users().create(user);

@Component
public class ExpiringRoleConverter extends JwtAuthenticationConverter {
    
    @Override
    protected Collection<GrantedAuthority> extractAuthorities(Jwt jwt) {
        Collection<GrantedAuthority> authorities = super.extractAuthorities(jwt);
        Map<String, Object> attributes = jwt.getClaims();
        
        // Проверяем атрибуты ролей на срок действия
        if (attributes.containsKey("role_attributes")) {
            Map<String, Object> roleAttrs = (Map<String, Object>) attributes.get("role_attributes");
            
            // Фильтруем истекшие роли
            return authorities.stream()
                .filter(authority -> !isRoleExpired(authority.getAuthority(), roleAttrs))
                .collect(Collectors.toList());
        }
        
        return authorities;
    }
    
    private boolean isRoleExpired(String role, Map<String, Object> roleAttributes) {
        if (roleAttributes.containsKey(role + "_expiration")) {
            String expirationDate = (String) roleAttributes.get(role + "_expiration");
            return LocalDate.parse(expirationDate).isBefore(LocalDate.now());
        }
        return false;
    }
}

// Создание группы и подгруппы с ролями
GroupRepresentation engineering = new GroupRepresentation();
engineering.setName("Engineering");
engineering.setAttributes(Map.of("department", List.of("tech")));
 
// Добавляем инженерные роли
// ...
 
GroupRepresentation devOps = new GroupRepresentation();
devOps.setName("DevOps");
// DevOps наследует все роли Engineering, плюс свои уникальные

@Configuration
@EnableMethodSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.oauth2ResourceServer()
            .jwt()
            .jwtAuthenticationConverter(jwtAuthenticationConverter());
            
        http.authorizeRequests()
            .antMatchers("/api/public/[B]").permitAll()
            .antMatchers("/api/reports/[/B]").hasRole("REPORT_VIEWER")
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .antMatchers(HttpMethod.POST, "/api/orders").hasAnyRole("ORDER_CREATOR", "SALES_MANAGER")
            .antMatchers(HttpMethod.DELETE, "/api/orders/{id}").hasRole("ORDER_MANAGER")
            .anyRequest().authenticated();
            
        return http.build();
    }
    
    private JwtAuthenticationConverter jwtAuthenticationConverter() {
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(jwt -> {
            Map<String, Object> realmAccess = jwt.getClaimAsMap("realm_access");
            if (realmAccess == null || !realmAccess.containsKey("roles")) {
                return Collections.emptyList();
            }
            
            return ((List<String>) realmAccess.get("roles")).stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                .collect(Collectors.toList());
        });
        
        return converter;
    }
}

// Установка атрибутов пользователя через Admin API
Map<String, List<String>> attributes = new HashMap<>();
attributes.put("department", List.of("sales"));
attributes.put("region", List.of("north"));
attributes.put("clearance_level", List.of("confidential"));
 
UserRepresentation user = keycloak.realm("my-company").users().get(userId).toRepresentation();
user.setAttributes(attributes);
keycloak.realm("my-company").users().get(userId).update(user);

// Создание Protocol Mapper для добавления атрибута в токен
ProtocolMapperRepresentation mapper = new ProtocolMapperRepresentation();
mapper.setName("department-mapper");
mapper.setProtocol("openid-connect");
mapper.setProtocolMapper("oidc-usermodel-attribute-mapper");
 
// Настройка маппера
Map<String, String> config = new HashMap<>();
config.put("user.attribute", "department");
config.put("claim.name", "department");
config.put("jsonType.label", "String");
config.put("id.token.claim", "true");
config.put("access.token.claim", "true");
mapper.setConfig(config);
 
// Добавление маппера к клиенту
keycloak.realm("my-company").clients().get(clientId).getProtocolMappers().createMapper(mapper);

public class ExternalAttributeProvider implements UserStorageProvider {
    @Override
    public UserModel getUserById(String id, RealmModel realm) {
        UserModel user = delegate.getUserById(id, realm);
        if (user != null) {
            // Запрос к внешнему API
            Map<String, String> externalAttrs = externalService.getUserAttributes(user.getUsername());
            
            // Обновление атрибутов в Keycloak
            for (Map.Entry<String, String> attr : externalAttrs.entrySet()) {
                user.setAttribute(attr.getKey(), Collections.singletonList(attr.getValue()));
            }
        }
        return user;
    }
    // Другие методы интерфейса...
}

public class ExternalAttributeAuthenticator implements Authenticator {
    @Override
    public void authenticate(AuthenticationFlowContext context) {
        AuthenticationSessionModel authSession = context.getAuthenticationSession();
        UserModel user = context.getUser();
        
        // Запрашиваем атрибуты в реальном времени
        Map<String, String> attrs = externalService.getAttributes(user.getUsername());
        
        // Добавляем их во временное хранилище сессии
        for (Map.Entry<String, String> attr : attrs.entrySet()) {
            authSession.setUserSessionNote("ext_" + attr.getKey(), attr.getValue());
        }
        
        // Продолжаем аутентификацию
        context.success();
    }
    // Другие методы...
}

@Component
public class AttributeBasedPermissionEvaluator implements PermissionEvaluator {
    
    @Override
    public boolean hasPermission(Authentication auth, Object targetDomainObject, Object permission) {
        Jwt jwt = (Jwt) auth.getPrincipal();
        
        // Получаем атрибуты пользователя из JWT
        String userDepartment = jwt.getClaimAsString("department");
        String userRegion = jwt.getClaimAsString("region");
        
        // Получаем атрибуты ресурса
        if (targetDomainObject instanceof Document) {
            Document doc = (Document) targetDomainObject;
            
            // Проверка на основе атрибутов
            if ("VIEW".equals(permission)) {
                // Проверка департамента
                if (!doc.getDepartment().equals(userDepartment)) {
                    return false;
                }
                
                // Проверка региона
                if (!doc.getRegion().equals(userRegion)) {
                    return false;
                }
                
                // Проверка времени доступа для секретных документов
                if ("SECRET".equals(doc.getClassification())) {
                    // Проверяем, рабочее ли время
                    LocalTime now = LocalTime.now();
                    return now.isAfter(LocalTime.of(9, 0)) && 
                           now.isBefore(LocalTime.of(18, 0));
                }
                
                return true;
            }
        }
        
        return false;
    }
    
    @Override
    public boolean hasPermission(Authentication auth, Serializable targetId, 
                                String targetType, Object permission) {
        // Реализация для случая, когда у нас есть только ID ресурса
        // ...
        return false;
    }
}

@GetMapping("/documents/{id}")
@PreAuthorize("hasPermission(#id, 'Document', 'VIEW')")
public ResponseEntity<Document> getDocument(@PathVariable("id") Long id) {
    // Логика получения документа
}

@GetMapping("/documents")
@PreAuthorize("hasRole('DOC_VIEWER') && hasPermission(returnObject, 'VIEW')")
public List<Document> getDocuments() {
    // Получаем все документы
    List<Document> allDocs = documentService.findAll();
    
    // Permission Evaluator применит атрибутное фильтрование
    return allDocs;
}

docker run -p 8080:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin \
  quay.io/keycloak/keycloak:latest start-dev

@Configuration
@EnableMethodSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .cors(Customizer.withDefaults())
            .csrf(csrf -> csrf.disable())  // В API с токенами CSRF не нужен
            .sessionManagement(session -> 
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/api/public/[B]").permitAll()
                .requestMatchers("/api/user/[/B]").hasRole("USER")
                .requestMatchers("/api/admin/[B]").hasRole("ADMIN")
                .requestMatchers("/api/manager/[/B]").hasRole("MANAGER")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthConverter())));
        
        return http.build();
    }
    
    @Bean
    public JwtAuthenticationConverter jwtAuthConverter() {
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        
        // Кастомный конвертер для извлечения ролей из токена
        converter.setJwtGrantedAuthoritiesConverter(jwt -> {
            Map<String, Object> realmAccess = jwt.getClaimAsMap("realm_access");
            if (realmAccess == null || !realmAccess.containsKey("roles")) {
                return Collections.emptyList();
            }
            
            List<String> roles = (List<String>) realmAccess.get("roles");
            return roles.stream()
                    .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
                    .collect(Collectors.toList());
        });
        
        return converter;
    }
    
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowedOrigins(List.of("http://localhost:3000")); // Ваш фронтенд
        config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE"));
        config.setAllowedHeaders(List.of("*"));
        config.setAllowCredentials(true);
        
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return source;
    }
}

@RestController
@RequestMapping("/api")
public class DemoController {
 
    @GetMapping("/public/hello")
    public String publicEndpoint() {
        return "Это публичный эндпоинт, доступен всем!";
    }
    
    @GetMapping("/user/profile")
    public Map<String, Object> userProfile(@AuthenticationPrincipal Jwt jwt) {
        return Map.of(
            "sub", jwt.getSubject(),
            "name", jwt.getClaimAsString("name"),
            "email", jwt.getClaimAsString("email"),
            "roles", jwt.getClaimAsMap("realm_access")
        );
    }
    
    @GetMapping("/admin/settings")
    public Map<String, String> adminSettings() {
        return Map.of(
            "setting1", "значение1",
            "setting2", "значение2",
            "adminOnly", "секретная информация"
        );
    }
    
    @GetMapping("/manager/reports")
    public List<String> managerReports() {
        return List.of("Отчет за Q1", "Отчет за Q2", "Прогноз на год");
    }
}

@GetMapping("/documents/{id}")
@PreAuthorize("hasRole('USER') and @documentSecurityService.hasAccess(#id, authentication)")
public DocumentDto getDocument(@PathVariable Long id) {
    return documentService.findById(id);
}

@Service
public class DocumentSecurityService {
 
    public boolean hasAccess(Long documentId, Authentication authentication) {
        Jwt jwt = (Jwt) authentication.getPrincipal();
        
        // Проверяем атрибуты пользователя из токена
        String userDepartment = jwt.getClaimAsString("department");
        
        // Получаем документ и его атрибуты
        Document doc = documentRepository.findById(documentId).orElse(null);
        if (doc == null) return false;
        
        // Проверяем соответствие департамента
        return doc.getDepartment().equals(userDepartment);
    }
}

@RestController
@RequestMapping("/auth")
public class AuthController {
 
    @Value("${app.keycloak.client-id}")
    private String clientId;
    
    @Value("${app.keycloak.client-secret}")
    private String clientSecret;
    
    @Value("${app.keycloak.token-uri}")
    private String tokenUri;
 
    @PostMapping("/refresh")
    public ResponseEntity<Map<String, String>> refreshToken(@RequestBody RefreshTokenRequest request) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        
        MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
        map.add("grant_type", "refresh_token");
        map.add("client_id", clientId);
        map.add("client_secret", clientSecret);
        map.add("refresh_token", request.getRefreshToken());
        
        HttpEntity<MultiValueMap<String, String>> entity = new HttpEntity<>(map, headers);
        
        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity<Map> response = restTemplate.exchange(
            tokenUri,
            HttpMethod.POST,
            entity,
            Map.class
        );
        
        return ResponseEntity.ok(response.getBody());
    }
}

script
// Пример на React с axios
axios.interceptors.response.use(
  response => response,
  async error => {
    const originalRequest = error.config;
    
    // Если получили 401 и еще не пытались обновить токен
    if (error.response.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true;
      
      try {
        // Обновляем токен
        const response = await axios.post('/auth/refresh', {
          refreshToken: localStorage.getItem('refresh_token')
        });
        
        // Сохраняем новые токены
        localStorage.setItem('access_token', response.data.access_token);
        localStorage.setItem('refresh_token', response.data.refresh_token);
        
        // Повторяем запрос с новым токеном
        originalRequest.headers['Authorization'] = 'Bearer ' + response.data.access_token;
        return axios(originalRequest);
      } catch (refreshError) {
        // Если обновить не удалось - редиректим на логин
        window.location = '/login';
        return Promise.reject(refreshError);
      }
    }
    
    return Promise.reject(error);
  }
);

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    
    // Разрешенные домены
    config.setAllowedOrigins(Arrays.asList(
        "http://localhost:3000",
        "https://your-production-domain.com"
    ));
    
    // Разрешенные методы
    config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
    
    // Разрешенные заголовки
    config.setAllowedHeaders(Arrays.asList(
        "Authorization", 
        "Content-Type", 
        "X-Requested-With"
    ));
    
    // Разрешаем отправлять куки и заголовки авторизации
    config.setAllowCredentials(true);
    
    // Кешируем предполетный ответ на 1 час
    config.setMaxAge(3600L);
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);
    return source;
}

@RestController
@RequestMapping("/api/test")
public class CorsTestController {
    
    @GetMapping("/cors")
    public Map<String, String> testCors(HttpServletRequest request) {
        return Map.of(
            "origin", Optional.ofNullable(request.getHeader("Origin")).orElse("не указан"),
            "method", request.getMethod(),
            "status", "OK"
        );
    }
    
    @PostMapping("/cors")
    public Map<String, String> testCorsPost(@RequestBody(required = false) Map<String, Object> body) {
        return Map.of(
            "received", body != null ? body.toString() : "пустой запрос",
            "status", "OK"
        );
    }
}

@Override
public UserModel getUserByUsername(String username, RealmModel realm) {
    // Проверяем локальный кэш
    if (cache.containsKey(username)) {
        return cache.get(username);
    }
    
    // Если нет в кэше, запрашиваем из основного хранилища
    UserEntity entity = userRepository.findByUsername(username);
    if (entity == null) return null;
    
    // Создаем модель пользователя и кэшируем
    UserModel user = createUserModel(entity, realm);
    cache.put(username, user);
    
    return user;
}

@Override
public void onEvent(AdminEvent event, boolean includeRepresentation) {
    // Вместо синхронной обработки - отправляем в очередь
    kafkaTemplate.send("keycloak-audit", new KeycloakAuditEvent(event));
}

@GetMapping("/debug/auth-info")
public Map<String, Object> debugAuthInfo(@AuthenticationPrincipal Jwt jwt) {
    Map<String, Object> info = new HashMap<>();
    info.put("token_claims", jwt.getClaims());
    info.put("authorities", SecurityContextHolder.getContext()
        .getAuthentication().getAuthorities().stream()
        .map(GrantedAuthority::getAuthority)
        .collect(Collectors.toList()));
    info.put("request_url", request.getRequestURL().toString());
    return info;
}

public class LegacyPasswordHashProvider implements PasswordHashProvider {
    
    @Override
    public boolean verify(String password, PasswordHashInput hashInput) {
        String storedHash = hashInput.getHashedPassword();
        
        // Определяем, старый ли это формат
        if (isLegacyHash(storedHash)) {
            // Проверяем по старому алгоритму
            return legacyHasher.verify(password, storedHash);
        }
        
        // Иначе используем стандартную проверку
        return defaultProvider.verify(password, hashInput);
    }
    
    @Override
    public String encode(String password, int iterations) {
        // Всегда кодируем новые пароли в новом формате
        return defaultProvider.encode(password, iterations);
    }
    
    // Другие методы интерфейса...
}

@Service
public class TokenCacheService {
    private final Cache<String, UserTokenSet> tokenCache;
    
    // Конструктор, инициализирующий кеш
    
    public UserTokenSet getTokens(String userId) {
        return tokenCache.get(userId, key -> {
            // Если нет в кеше - запрашиваем из Keycloak
            return keycloakClient.getUserTokens(userId);
        });
    }
    
    // Методы для обновления и инвалидации кеша
}

spring-boot-keycloak-demo
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com.securitydemo
│   │   │       ├── config           # Конфигурации Spring и Keycloak
│   │   │       ├── controller       # REST-контроллеры
│   │   │       ├── dto              # Data Transfer Objects
│   │   │       ├── model            # Модели данных
│   │   │       ├── repository       # Репозитории для доступа к данным
│   │   │       ├── security         # Кастомные компоненты безопасности
│   │   │       ├── service          # Бизнес-логика 
│   │   │       └── Application.java # Точка входа
│   │   └── resources
│   │       ├── application.yml      # Основная конфигурация
│   │       └── data.sql             # Скрипт для инициализации БД
│   └── test                         # Тесты
└── pom.xml                          # Зависимости Maven

package com.securitydemo;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

package com.securitydemo.config;
 
import com.securitydemo.security.JwtAuthenticationConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
 
import java.util.Arrays;
import java.util.List;
 
@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {
 
    private final JwtAuthenticationConverter jwtAuthenticationConverter;
    
    public SecurityConfig(JwtAuthenticationConverter jwtAuthenticationConverter) {
        this.jwtAuthenticationConverter = jwtAuthenticationConverter;
    }
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .cors(cors -> cors.configurationSource(corsConfigurationSource()))
            .csrf(csrf -> csrf.disable())
            .sessionManagement(session -> 
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/public/**", "/h2-console/**").permitAll()
                .requestMatchers(HttpMethod.GET, "/documents").hasAnyRole("USER", "ADMIN")
                .requestMatchers(HttpMethod.POST, "/documents").hasAnyRole("EDITOR", "ADMIN")
                .requestMatchers(HttpMethod.PUT, "/documents/**").hasAnyRole("EDITOR", "ADMIN")
                .requestMatchers(HttpMethod.DELETE, "/documents/[B]").hasRole("ADMIN")
                .requestMatchers("/admin/[/B]").hasRole("ADMIN")
                .requestMatchers("/debug/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter)));
                
        // Для доступа к консоли H2 (не использовать в продакшене!)
        http.headers(headers -> headers.frameOptions(frameOptions -> frameOptions.disable()));
        
        return http.build();
    }
    
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(List.of("http://localhost:3000"));
        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
        configuration.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type", "X-Requested-With"));
        configuration.setExposedHeaders(List.of("Content-Disposition"));
        configuration.setAllowCredentials(true);
        configuration.setMaxAge(3600L);
        
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

package com.securitydemo.security;
 
import org.springframework.core.convert.converter.Converter;
import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
import org.springframework.stereotype.Component;
 
import java.util.*;
import java.util.stream.Collectors;
 
@Component
public class JwtAuthenticationConverter implements Converter<Jwt, AbstractAuthenticationToken> {
 
    @Override
    public AbstractAuthenticationToken convert(Jwt jwt) {
        Collection<SimpleGrantedAuthority> authorities = extractAuthorities(jwt);
        return new JwtAuthenticationToken(jwt, authorities);
    }
    
    private Collection<SimpleGrantedAuthority> extractAuthorities(Jwt jwt) {
        Map<String, Object> realmAccess = jwt.getClaimAsMap("realm_access");
        if (realmAccess == null || !realmAccess.containsKey("roles")) {
            return Collections.emptyList();
        }
        
        List<String> roles = (List<String>) realmAccess.get("roles");
        Collection<SimpleGrantedAuthority> authorities = new ArrayList<>();
        
        // Добавляем стандартные роли с префиксом ROLE_
        roles.stream()
            .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))
            .forEach(authorities::add);
            
        // Извлекаем дополнительные атрибуты для ABAC
        Map<String, Object> resourceAccess = jwt.getClaimAsMap("resource_access");
        if (resourceAccess != null && resourceAccess.containsKey("document-app")) {
            Map<String, Object> clientAccess = (Map<String, Object>) resourceAccess.get("document-app");
            if (clientAccess != null && clientAccess.containsKey("roles")) {
                List<String> clientRoles = (List<String>) clientAccess.get("roles");
                clientRoles.stream()
                    .map(role -> new SimpleGrantedAuthority("CLIENT_" + role.toUpperCase()))
                    .forEach(authorities::add);
            }
        }
        
        // Добавляем атрибуты для ABAC
        String department = jwt.getClaimAsString("department");
        if (department != null) {
            authorities.add(new SimpleGrantedAuthority("DEPARTMENT_" + department.toUpperCase()));
        }
        
        return authorities;
    }
}

package com.securitydemo.model;
 
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import java.time.LocalDateTime;
 
@Entity
@Table(name = "documents")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Document {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String title;
    
    @Column(length = 2000)
    private String content;
    
    @Column(nullable = false)
    private String department;
    
    @Column(nullable = false)
    private String classification; // PUBLIC, CONFIDENTIAL, SECRET
    
    @Column(nullable = false)
    private String createdBy;
    
    @Column(nullable = false)
    private LocalDateTime createdAt;
    
    @Column
    private LocalDateTime modifiedAt;
    
    @Column
    private String modifiedBy;
}

package com.securitydemo.dto;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import java.time.LocalDateTime;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DocumentDto {
    private Long id;
    private String title;
    private String content;
    private String department;
    private String classification;
    private String createdBy;
    private LocalDateTime createdAt;
    private LocalDateTime modifiedAt;
    private String modifiedBy;
}

package com.securitydemo.repository;
 
import com.securitydemo.model.Document;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
 
import java.util.List;
 
@Repository
public interface DocumentRepository extends JpaRepository<Document, Long> {
    
    List<Document> findByDepartment(String department);
    
    List<Document> findByClassification(String classification);
    
    List<Document> findByDepartmentAndClassification(String department, String classification);
    
    @Query("SELECT d FROM Document d WHERE d.department = :department AND " +
           "(:classification = 'PUBLIC' OR d.classification = :classification)")
    List<Document> findByDepartmentAndAccessibleClassification(String department, String classification);
}

package com.securitydemo.security;
 
import com.securitydemo.model.Document;
import com.securitydemo.repository.DocumentRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.stereotype.Service;
 
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
 
@Service
@Slf4j
public class DocumentSecurityService {
 
    private final DocumentRepository documentRepository;
    
    public DocumentSecurityService(DocumentRepository documentRepository) {
        this.documentRepository = documentRepository;
    }
    
    public boolean hasReadAccess(Long documentId, Authentication authentication) {
        Document doc = documentRepository.findById(documentId).orElse(null);
        if (doc == null) return false;
        
        Jwt jwt = (Jwt) authentication.getPrincipal();
        return hasReadAccess(doc, jwt);
    }
    
    public boolean hasReadAccess(Document doc, Jwt jwt) {
        // Проверка на админа - может читать любой документ
        List<String> roles = getRolesFromToken(jwt);
        if (roles.contains("ADMIN")) return true;
        
        // Получаем атрибуты пользователя
        String userDepartment = jwt.getClaimAsString("department");
        String userClearance = jwt.getClaimAsString("clearance_level");
        
        // Департамент должен совпадать
        if (!doc.getDepartment().equals(userDepartment)) {
            log.debug("Доступ запрещен: департаменты не совпадают");
            return false;
        }
        
        // Проверка уровня доступа
        if ("PUBLIC".equals(doc.getClassification())) {
            // Публичные документы доступны всем сотрудникам департамента
            return true;
        } else if ("CONFIDENTIAL".equals(doc.getClassification())) {
            // Конфиденциальные документы требуют соответствующего уровня доступа
            if (userClearance == null || !"CONFIDENTIAL".equals(userClearance) && !"SECRET".equals(userClearance)) {
                log.debug("Доступ запрещен: недостаточный уровень доступа для конфиденциального документа");
                return false;
            }
        } else if ("SECRET".equals(doc.getClassification())) {
            // Секретные документы требуют уровня SECRET и только в рабочее время
            if (userClearance == null || !"SECRET".equals(userClearance)) {
                log.debug("Доступ запрещен: недостаточный уровень доступа для секретного документа");
                return false;
            }
            
            // Проверка рабочего времени (9:00 - 18:00)
            LocalTime now = LocalTime.now();
            if (now.isBefore(LocalTime.of(9, 0)) || now.isAfter(LocalTime.of(18, 0))) {
                log.debug("Доступ запрещен: попытка доступа к секретному документу вне рабочего времени");
                return false;
            }
        }
        
        return true;
    }
    
    public boolean hasWriteAccess(Long documentId, Authentication authentication) {
        Document doc = documentRepository.findById(documentId).orElse(null);
        if (doc == null) return false;
        
        Jwt jwt = (Jwt) authentication.getPrincipal();
        
        // Проверка на админа и редактора
        List<String> roles = getRolesFromToken(jwt);
        if (roles.contains("ADMIN")) return true;
        if (!roles.contains("EDITOR")) return false;
        
        // Редакторы могут изменять только документы своего департамента
        String userDepartment = jwt.getClaimAsString("department");
        return doc.getDepartment().equals(userDepartment);
    }
    
    public boolean hasDeleteAccess(Long documentId, Authentication authentication) {
        // Только админы могут удалять документы
        Jwt jwt = (Jwt) authentication.getPrincipal();
        List<String> roles = getRolesFromToken(jwt);
        return roles.contains("ADMIN");
    }
    
    private List<String> getRolesFromToken(Jwt jwt) {
        try {
            return (List<String>) ((Map<String, Object>) jwt.getClaims()
                .get("realm_access")).get("roles");
        } catch (Exception e) {
            log.error("Ошибка при извлечении ролей: {}", e.getMessage());
            return List.of();
        }
    }
}

package com.securitydemo.service;
 
import com.securitydemo.dto.DocumentDto;
import com.securitydemo.model.Document;
import com.securitydemo.repository.DocumentRepository;
import com.securitydemo.security.DocumentSecurityService;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;
 
@Service
public class DocumentService {
 
    private final DocumentRepository documentRepository;
    private final DocumentSecurityService securityService;
    
    public DocumentService(DocumentRepository documentRepository, 
                          DocumentSecurityService securityService) {
        this.documentRepository = documentRepository;
        this.securityService = securityService;
    }
    
    public List<DocumentDto> getAllDocuments() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        Jwt jwt = (Jwt) auth.getPrincipal();
        
        // Получаем департамент пользователя
        String userDepartment = jwt.getClaimAsString("department");
        
        // Получаем все документы департамента
        List<Document> documents = documentRepository.findByDepartment(userDepartment);
        
        // Фильтруем по ABAC-правилам
        return documents.stream()
                .filter(doc -> securityService.hasReadAccess(doc, jwt))
                .map(this::convertToDto)
                .collect(Collectors.toList());
    }
    
    public DocumentDto getDocumentById(Long id) {
        Document document = documentRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Документ не найден"));
        
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (!securityService.hasReadAccess(id, auth)) {
            throw new RuntimeException("Доступ запрещен");
        }
        
        return convertToDto(document);
    }
    
    @Transactional
    public DocumentDto createDocument(DocumentDto documentDto) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        Jwt jwt = (Jwt) auth.getPrincipal();
        
        Document document = new Document();
        document.setTitle(documentDto.getTitle());
        document.setContent(documentDto.getContent());
        
        // Устанавливаем департамент пользователя
        String userDepartment = jwt.getClaimAsString("department");
        document.setDepartment(userDepartment);
        
        // Устанавливаем классификацию
        document.setClassification(documentDto.getClassification());
        
        // Метаданные
        document.setCreatedBy(jwt.getSubject());
        document.setCreatedAt(LocalDateTime.now());
        
        Document saved = documentRepository.save(document);
        return convertToDto(saved);
    }
    
    @Transactional
    public DocumentDto updateDocument(Long id, DocumentDto documentDto) {
        Document document = documentRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Документ не найден"));
        
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (!securityService.hasWriteAccess(id, auth)) {
            throw new RuntimeException("Доступ запрещен");
        }
        
        Jwt jwt = (Jwt) auth.getPrincipal();
        
        document.setTitle(documentDto.getTitle());
        document.setContent(documentDto.getContent());
        // Нельзя менять департамент документа
        document.setClassification(documentDto.getClassification());
        document.setModifiedBy(jwt.getSubject());
        document.setModifiedAt(LocalDateTime.now());
        
        Document updated = documentRepository.save(document);
        return convertToDto(updated);
    }
    
    @Transactional
    public void deleteDocument(Long id) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (!securityService.hasDeleteAccess(id, auth)) {
            throw new RuntimeException("Доступ запрещен");
        }
        
        documentRepository.deleteById(id);
    }
    
    private DocumentDto convertToDto(Document document) {
        DocumentDto dto = new DocumentDto();
        dto.setId(document.getId());
        dto.setTitle(document.getTitle());
        dto.setContent(document.getContent());
        dto.setDepartment(document.getDepartment());
        dto.setClassification(document.getClassification());
        dto.setCreatedBy(document.getCreatedBy());
        dto.setCreatedAt(document.getCreatedAt());
        dto.setModifiedAt(document.getModifiedAt());
        dto.setModifiedBy(document.getModifiedBy());
        return dto;
    }
}

package com.securitydemo.controller;
 
import com.securitydemo.dto.DocumentDto;
import com.securitydemo.service.DocumentService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;
import java.util.Map;
 
@RestController
@RequestMapping("/documents")
public class DocumentController {
 
    private final DocumentService documentService;
    
    public DocumentController(DocumentService documentService) {
        this.documentService = documentService;
    }
    
    @GetMapping
    public ResponseEntity<List<DocumentDto>> getAllDocuments() {
        return ResponseEntity.ok(documentService.getAllDocuments());
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<DocumentDto> getDocumentById(@PathVariable Long id) {
        return ResponseEntity.ok(documentService.getDocumentById(id));
    }
    
    @PostMapping
    @PreAuthorize("hasAnyRole('EDITOR', 'ADMIN')")
    public ResponseEntity<DocumentDto> createDocument(@RequestBody DocumentDto documentDto) {
        DocumentDto created = documentService.createDocument(documentDto);
        return ResponseEntity.status(HttpStatus.CREATED).body(created);
    }
    
    @PutMapping("/{id}")
    @PreAuthorize("hasAnyRole('EDITOR', 'ADMIN')")
    public ResponseEntity<DocumentDto> updateDocument(@PathVariable Long id, 
                                                    @RequestBody DocumentDto documentDto) {
        return ResponseEntity.ok(documentService.updateDocument(id, documentDto));
    }
    
    @DeleteMapping("/{id}")
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity<Void> deleteDocument(@PathVariable Long id) {
        documentService.deleteDocument(id);
        return ResponseEntity.noContent().build();
    }
}

package com.securitydemo.controller;
 
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
 
@RestController
@RequestMapping("/debug")
public class DebugController {
 
    @GetMapping("/auth-info")
    public Map<String, Object> getAuthInfo() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        Jwt jwt = (Jwt) auth.getPrincipal();
        
        Map<String, Object> info = new HashMap<>();
        info.put("token_claims", jwt.getClaims());
        info.put("authorities", auth.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));
                
        return info;
    }
}

   docker run -p 8080:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin \
   quay.io/keycloak/keycloak:latest start-dev

   mvn spring-boot:run

   curl -X POST http://localhost:8080/realms/document-realm/protocol/openid-connect/token \
   -H "Content-Type: application/x-www-form-urlencoded" \
   -d "grant_type=password" \
   -d "client_id=document-app" \
   -d "client_secret=your-client-secret-here" \
   -d "username=user1" \
   -d "password=password"

   curl -X GET http://localhost:8081/api/documents \
   -H "Authorization: Bearer YOUR_TOKEN_HERE"