Spring Security: filter chain, authentication va authorization qanday ishlaydi
Bu sahifa Spring Security qanday ishlashini chuqur tushuntiradi: soʻrov filter chainʼdan qanday oʻtadi, login paytida nima boʻladi, foydalanuvchi keyingi soʻrovlarda qanday taniladi, JWT va OAuth2 tokenʼlari qanday tekshiriladi va ruxsat qayerda hal qilinadi. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.
Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi. Misollar Spring Boot 3.x va Spring Security 6.x uchun yozilgan, Spring Security 7 (Spring Boot 4) da oʻzgargan joylar alohida aytilgan. Filter va interceptor farqi, proxy va soʻrovning `DispatcherServlet`gacha boʻlgan yoʻli Spring Core va Boot qoʻllanmasida tushuntirilgan — bu yerda ular faqat eslatiladi.
Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.
1Authentication, authorization va birinchi sozlama
Har bir himoyalangan soʻrovda Spring Security ikki savolga javob beradi. Birinchisi — authentication: soʻrovni kim yubordi? Parol, session cookie yoki token tekshiriladi va natijada Authentication obyekti paydo boʻladi: unda principal — foydalanuvchining oʻzi — va uning authorityʼlari bor. Ikkinchisi — authorization: shu foydalanuvchiga bu amalga ruxsat bormi? Bu savol authentication tugagandan keyin, uning natijasiga qarab hal qilinadi.
| Jihat | Authentication | Authorization |
|---|---|---|
| Savol | kim bu? | bunga ruxsat bormi? |
| Nimani tekshiradi | parol, session cookie, token imzosi | role, authority, scope, obyekt egasi |
| Natija | SecurityContextdagi Authentication | ruxsat yoki AccessDeniedException |
| Oʻtmasa | odatda 401 yoki login sahifasiga redirect | 403 |
| Springʼda kim qiladi | authentication filterʼlari va AuthenticationManager | AuthorizationFilter va method security |
Parol bazada ochiq holda ham, shifrlangan holda ham saqlanmaydi — faqat hash. Hash bir tomonlama: undan parolni qaytarib olib boʻlmaydi, login paytida esa kiritilgan parol qayta hash qilinadi va solishtiriladi. Lekin har qanday hash yaramaydi: SHA-256 juda tez, oʻgʻirlangan bazadagi hashʼlarni GPU sekundiga milliardlab taxmin bilan tekshiradi. Parol uchun ataylab sekin, salt qoʻshadigan algoritm kerak — BCrypt, scrypt, Argon2 yoki PBKDF2. Springʼda bu ishni PasswordEncoder qiladi.
spring-boot-starter-security qoʻshilishi bilan Spring Boot default sozlamani yoqadi: hamma endpoint authentication talab qiladi, form login va HTTP Basic ishlaydi, user nomli foydalanuvchi va ishga tushishda logga yoziladigan tasodifiy parol yaratiladi. Bu faqat boshlash uchun. Oʻzingizning SecurityFilterChain beanʼingiz paydo boʻlishi bilan Boot oʻz zanjirini qoʻymaydi, UserDetailsService yoki boshqa authentication beanʼi (masalan, JwtDecoder) boʻlsa — user ham yaratilmaydi.
Spring Security 6 da sozlama — bitta yoki bir nechta SecurityFilterChain beanʼi. U HttpSecurity builder orqali lambda DSL bilan yoziladi: har bir imkoniyat (authorizeHttpRequests, formLogin, csrf, oauth2ResourceServer) oʻz lambdaʼsini oladi. Spring Bootʼda @EnableWebSecurity ixtiyoriy — Boot uni oʻzi qoʻshadi, lekin yozib qoʻyish zarar qilmaydi:
@Configuration
@EnableWebSecurity
class SecurityConfig {
@Bean
SecurityFilterChain web(HttpSecurity http)
throws Exception {
http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/", "/about",
"/actuator/health").permitAll()
.requestMatchers(HttpMethod.GET,
"/products/**").permitAll()
.requestMatchers("/admin/**")
.hasRole("ADMIN")
.anyRequest().authenticated())
.formLogin(Customizer.withDefaults())
.logout(Customizer.withDefaults());
return http.build();
}
@Bean
PasswordEncoder passwordEncoder() {
return PasswordEncoderFactories
.createDelegatingPasswordEncoder();
}
}Qoidalar yuqoridan pastga tekshiriladi va birinchi mos kelgani qoʻllanadi: aniqroq qoidalar tepada, anyRequest() esa eng oxirida turadi. Undan keyin qoida qoʻshib boʻlmaydi — Spring Security buni ishga tushishda xato deb hisoblaydi. Internetdagi koʻp misollar hali 5.x uslubida yozilgan, shuning uchun nima oʻzgarganini bilish foydali:
| Spring Security 5.x | Spring Security 6.x | Spring Security 7 |
|---|---|---|
WebSecurityConfigurerAdapterdan meros olish | SecurityFilterChain beanʼi; adapter 5.7 da deprecated boʻlgan, 6.0 da olib tashlangan | xuddi 6.x dagidek |
authorizeRequests | authorizeHttpRequests, authorizeRequests — deprecated | authorizeRequests olib tashlangan |
antMatchers, mvcMatchers | requestMatchers (eskilari 6.0 da olib tashlangan) | requestMatchers ichida PathPatternRequestMatcher; AntPathRequestMatcher va MvcRequestMatcher olib tashlangan |
.and() bilan zanjir | lambda DSL; .and() va lambdaʼsiz metodlar 6.1 dan deprecated | .and() olib tashlangan |
@EnableGlobalMethodSecurity | @EnableMethodSecurity, eskisi — deprecated | eskisi faqat alohida spring-security-access moduli bilan ishlaydi |
Tushunganingizni tekshiring
Authentication va authorization farqi nima?Javob
Authentication foydalanuvchi kim ekanini aniqlaydi: parol, cookie yoki tokenni tekshiradi. Authorization esa aniqlangan foydalanuvchiga shu amalga ruxsat bor-yoʻqligini hal qiladi. Tartib doim shu: kim ekani nomaʼlum boʻlsa, ruxsat haqida gapirib boʻlmaydi.
Springʼda authentication natijasi — Authentication obyekti. Unda principal (form login bilan odatda UserDetails, JWT bilan — Jwt), credentials — odatda parol, muvaffaqiyatli logindan keyin u default holatda oʻchiriladi — va authorityʼlar roʻyxati bor. Bu obyekt SecurityContextga qoʻyiladi va soʻrov tugaguncha shu yerda turadi.
Authorization shu authorityʼlarga qaraydi: URL darajasida AuthorizationFilter, metod darajasida @PreAuthorize. Authority — oddiy satr: ROLE_ADMIN, SCOPE_orders:read yoki orders:refund. Spring Security uning maʼnosini bilmaydi, faqat qoidadagi satr bilan solishtiradi.
HTTP status kodlari ham shu ikki bosqichga mos: 401 — kim ekani aniqlanmadi (token yoʻq yoki yaroqsiz), 403 — kimligi aniq, lekin ruxsat yoʻq. 401 ning nomi Unauthorized boʻlsa ham, maʼnosi aslida «unauthenticated».
Parol nega hash qilib saqlanadi va nega oddiy SHA-256 emas, BCrypt?Javob
Baza oʻgʻirlansa, parollarning oʻzi emas, faqat hashʼlari chiqib ketishi uchun. Hash bir tomonlama, lekin taxminlarni hash qilib solishtirish mumkin: SHA-256 bunga juda tez, BCrypt esa ataylab sekin va har bir parolga alohida salt qoʻshadi. Springʼda buni PasswordEncoder qiladi.
Salt — har bir parol uchun tasodifiy yaratiladigan qiymat, u hash bilan birga saqlanadi. Salt tufayli bir xil parollarning hashʼi har xil chiqadi va oldindan hisoblangan rainbow tableʼlar ishlamaydi. BCrypt saltʼni oʻzi yaratadi va natija satriga yozib qoʻyadi: $2a$10$, keyin salt va hash.
Work factor — hisoblash qanchalik ogʻirligi. BCryptʼda bu strength: $2a$10$ dagi 10 — 2¹⁰ raund degani, bittaga oshirish vaqtni ikki baravar koʻpaytiradi. BCryptPasswordEncoder default holatda 10 ni ishlatadi; Spring hujjatlari strengthʼni oʻz serveringizda bitta tekshiruv taxminan bir sekund oladigan qilib sozlashni tavsiya qiladi. Argon2 xotirani ham koʻp talab qiladi, shuning uchun uni GPU bilan buzish yanada qiyin.
PasswordEncoderFactories.createDelegatingPasswordEncoder() qaytaradigan DelegatingPasswordEncoder yangi parollarni BCrypt bilan hash qiladi va natija oldiga algoritm nomini yozadi: {bcrypt}$2a$10$…. Prefiks tufayli bazada eski va yangi algoritm hashʼlari aralash tura oladi: tekshiruv prefiks boʻyicha kerakli encoderʼni tanlaydi, keyinchalik algoritmni almashtirish ham mumkin boʻladi.
@Service
class RegistrationService {
private final UserRepository users;
private final PasswordEncoder encoder;
RegistrationService(UserRepository users,
PasswordEncoder encoder) {
this.users = users;
this.encoder = encoder;
}
void register(String email, String rawPassword) {
// "{bcrypt}$2a$10$..." koʻrinishida saqlanadi
String hash = encoder.encode(rawPassword);
users.save(new AppUser(email, hash));
}
}Spring Security 6 da sozlama qanday yoziladi va WebSecurityConfigurerAdapter oʻrniga nima keldi?Javob
SecurityFilterChain beanʼi: HttpSecurity lambda DSL bilan sozlanadi va http.build() qaytariladi. WebSecurityConfigurerAdapter 5.7 da deprecated boʻlgan va 6.0 da olib tashlangan; UserDetailsService, PasswordEncoder kabi qismlar ham endi alohida beanʼlar.
Eski usulda klass adapterʼdan meros olib, configure(HttpSecurity) va configure(AuthenticationManagerBuilder) metodlarini override qilardi. Meros orqali sozlash bir nechta konfiguratsiyani birlashtirishni qiyinlashtirardi va Springʼning «har bir qism — bean» uslubiga mos kelmasdi. Endi filter chain ham, UserDetailsService ham, kerak boʻlsa AuthenticationManager ham — oddiy beanʼlar, ularni bir-biriga inject qilish va testda almashtirish mumkin.
authorizeHttpRequests qoidalari yozilgan tartibda tekshiriladi, birinchi mos kelgani qoʻllanadi. requestMatchers HTTP metodni ham qabul qiladi: requestMatchers(HttpMethod.GET, "/products/**"). Oxirgi qoida — anyRequest(): hech bir qoidaga tushmagan soʻrov ochiq qolmasligi uchun u authenticated() yoki denyAll() boʻladi.
permitAll() endpointʼni authenticationʼsiz ochadi, lekin soʻrov baribir filter chainʼdan oʻtadi: security headerʼlar yoziladi, token kelsa — tekshiriladi. WebSecurityCustomizer bilan web.ignoring() esa soʻrovni zanjirdan butunlay chiqaradi; Spring Security buni tavsiya qilmaydi va logda permitAll ishlatishni maslahat beradi.
2Filter chain qanday ishlaydi
Spring Security servlet filterʼlari ustiga qurilgan va DispatcherServletdan oldin ishlaydi — filter va interceptor farqi Spring Core va Boot qoʻllanmasida koʻrilgan. Lekin Spring Security oʻz filterʼlarini servlet containerʼga birma-bir roʻyxatdan oʻtkazmaydi: containerda bitta filter turadi — DelegatingFilterProxy, qolgan hamma narsa Spring beanʼlari ichida.
Nega shunday? Servlet container filterʼlarni ishga tushishda oʻzi roʻyxatdan oʻtkazadi va Spring beanʼlari haqida hech narsa bilmaydi. DelegatingFilterProxy — oddiy servlet filter: u har bir soʻrovni springSecurityFilterChain nomli beanʼga uzatadi, beanʼni esa birinchi kerak boʻlganda qidiradi. Spring Bootʼda bu proxyʼni SecurityFilterAutoConfiguration roʻyxatdan oʻtkazadi. Bean esa FilterChainProxy: u soʻrovga mos SecurityFilterChainni tanlaydi va uning filterʼlarini navbat bilan chaqiradi.
GET /api/orders keldi. Servlet containerda Spring Securityʼdan bitta filter turadi — DelegatingFilterProxy. U soʻrovni springSecurityFilterChain beanʼiga uzatadi.Zanjirdagi filterʼlar qatʼiy tartibda turadi: avval SecurityContext yuklanadi, keyin exploitʼlardan himoya (headerʼlar, CORS, CSRF), keyin authentication, eng oxirida authorization. Roʻyxat yoqilgan imkoniyatlarga qarab oʻzgaradi; eng muhimlari:
| Filter | Vazifasi |
|---|---|
SecurityContextHolderFilter | oldingi soʻrovlarda saqlangan SecurityContextni (masalan, sessiyadan) yuklaydi |
HeaderWriterFilter | security headerʼlarni yozadi: X-Content-Type-Options, X-Frame-Options, Cache-Control, HTTPS boʻlsa — HSTS |
CorsFilter | CORS soʻrovlariga, shu jumladan preflightʼga javob beradi |
CsrfFilter | POST, PUT, DELETE kabi soʻrovlarda CSRF tokenʼni tekshiradi |
LogoutFilter | logout soʻrovida sessiyani va contextʼni tozalaydi |
UsernamePasswordAuthenticationFilter | form login: POST /logindagi username va parolni tekshiradi |
BearerTokenAuthenticationFilter | Authorization: Bearer headerʼidagi tokenni tekshiradi (resource server) |
BasicAuthenticationFilter | HTTP Basic headerʼini tekshiradi |
AnonymousAuthenticationFilter | context boʻsh qolsa, unga anonymous Authentication qoʻyadi |
ExceptionTranslationFilter | keyingi qadamlardan chiqqan security exceptionʼlarni 401 yoki 403 javobga aylantiradi |
AuthorizationFilter | authorizeHttpRequests qoidalarini tekshiradi |
Ilovada bir nechta SecurityFilterChain boʻlishi mumkin. FilterChainProxy ularni @Order boʻyicha koʻrib chiqadi va faqat birinchi mos kelganini ishlatadi. Odatiy holat: /api/** uchun token bilan ishlaydigan stateless zanjir, qolgan sahifalar uchun form login va sessiyali zanjir. securityMatchersiz zanjir hamma soʻrovga mos keladi, shuning uchun u oxirida turadi: Spring Security 6.4 dan boshlab bunday zanjirdan keyin yana zanjir boʻlsa, ilova ishga tushmaydi.
@Bean
@Order(1)
SecurityFilterChain api(HttpSecurity http)
throws Exception {
http
.securityMatcher("/api/**")
.authorizeHttpRequests(auth -> auth
.anyRequest().authenticated())
.oauth2ResourceServer(o -> o
.jwt(Customizer.withDefaults()))
.sessionManagement(s -> s
.sessionCreationPolicy(
SessionCreationPolicy.STATELESS));
return http.build();
}
@Bean
@Order(2)
SecurityFilterChain web(HttpSecurity http)
throws Exception {
http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/", "/about").permitAll()
.anyRequest().authenticated())
.formLogin(Customizer.withDefaults());
return http.build();
}Qaysi filterʼlar ishlayotganini koʻrish uchun logging.level.org.springframework.security=TRACE yoqiladi: ishga tushishda har bir zanjirning filterʼlari roʻyxati, har bir soʻrovda esa qaysi filter nima qilgani logga chiqadi. Security bilan bogʻliq «nega 401?» savollarining koʻpi shu log bilan bir necha daqiqada hal boʻladi.
Tushunganingizni tekshiring
Soʻrov Spring Security filterʼlaridan qanday oʻtadi? DelegatingFilterProxy va FilterChainProxy nima uchun kerak?Javob
Servlet containerda bitta DelegatingFilterProxy turadi va soʻrovni FilterChainProxy beanʼiga uzatadi. FilterChainProxy soʻrovga mos birinchi SecurityFilterChainni tanlaydi va uning filterʼlarini tartib bilan chaqiradi: context yuklash, CSRF, authentication, oxirida authorization.
DelegatingFilterProxy servlet container va Spring context orasidagi koʻprik: container filterʼlarni Spring beanʼlari tayyor boʻlishidan oldin roʻyxatdan oʻtkazadi, proxy esa beanʼni keyinroq topadi. Shu tufayli security filterʼlari oddiy Spring beanʼlari boʻlib, dependency injectionʼdan foydalana oladi.
FilterChainProxy — Spring Securityʼning yagona kirish nuqtasi, debug uchun breakpoint qoʻyiladigan eng yaxshi joy. U yana ikki majburiy ishni qiladi: soʻrov tugagach SecurityContextHolderni tozalaydi — aks holda pooldagi thread keyingi soʻrovga boshqa foydalanuvchining contextʼini olib oʻtardi — va HttpFirewall bilan shubhali URLʼlarni (masalan, .. yoki ; bilan) rad etadi.
Har bir filter chain.doFilter()ni chaqirib soʻrovni keyingisiga oʻtkazadi yoki chaqirmasdan javobni oʻzi yozadi. Masalan, CsrfFilter token mos kelmasa 403 qaytaradi va soʻrov controllerʼga umuman yetmaydi. ExceptionTranslationFilter AuthorizationFilterdan oldin turadi va undan chiqqan exceptionʼni 401 yoki 403 javobga aylantiradi — shuning uchun bu javoblar @ControllerAdvicega yetib bormaydi.
Oʻz filterʼingizni zanjirga qanday qoʻshasiz va qanday xato koʻp uchraydi?Javob
Filter odatda OncePerRequestFilterdan meros oladi va addFilterBefore, addFilterAfter yoki addFilterAt bilan mavjud filterʼga nisbatan joylashtiriladi. Koʻp uchraydigan xato — filterni @Component qilish: Spring Boot uni servlet containerʼga ham alohida roʻyxatdan oʻtkazadi va u security zanjiridan tashqarida, boshqa tartibda ham ishlashi mumkin.
Joyni filter nimaga muhtojligi belgilaydi. Authentication filter — masalan, API kalitni tekshiradigan — LogoutFilterdan keyin, odatda UsernamePasswordAuthenticationFilter yonida turadi. Joriy foydalanuvchini koʻrishi kerak boʻlgan filter (masalan, tenant ruxsatini tekshiradigan) AnonymousAuthenticationFilterdan keyin qoʻyiladi: u paytda authentication tugagan boʻladi.
Filter bean boʻlishi kerak boʻlsa (unga dependency kerak), Spring Bootʼga uni containerda roʻyxatdan oʻtkazmaslik aytiladi: FilterRegistrationBean yaratib, setEnabled(false). Yoki filter bean qilinmaydi va SecurityFilterChain metodida new bilan yaratiladi.
Token yaroqsiz boʻlsa, filter contextʼni boʻsh qoldiradi: himoyalangan endpointʼda AuthorizationFilter soʻrovni rad etadi va ExceptionTranslationFilter uni 401 ga aylantiradi. Exception tashlash bu yerda yaramaydi — filter ExceptionTranslationFilterdan oldin turadi va undan chiqqan exceptionʼni u ushlamaydi. JWT uchun bunday filterni yozish umuman shart emas: oauth2ResourceServer() buni tayyor BearerTokenAuthenticationFilter bilan qiladi.
class ApiKeyFilter extends OncePerRequestFilter {
private final ApiKeyService keys;
ApiKeyFilter(ApiKeyService keys) {
this.keys = keys;
}
@Override
protected void doFilterInternal(
HttpServletRequest req,
HttpServletResponse res,
FilterChain chain)
throws ServletException, IOException {
String key = req.getHeader("X-Api-Key");
if (key != null) {
keys.find(key).ifPresent(client -> {
var ctx = SecurityContextHolder
.createEmptyContext();
ctx.setAuthentication(client.toAuth());
SecurityContextHolder.setContext(ctx);
});
}
chain.doFilter(req, res);
}
}
// SecurityFilterChain metodida
http.addFilterBefore(new ApiKeyFilter(keys),
UsernamePasswordAuthenticationFilter.class);3Login: AuthenticationManagerdan SecurityContextgacha
Login — authenticationʼning bir koʻrinishi: foydalanuvchi username va parol yuboradi, server ularni tekshiradi va natijani keyingi soʻrovlar uchun eslab qoladi. Bu ishda bir nechta komponent qatnashadi, har biri bitta vazifani bajaradi:
| Komponent | Vazifasi |
|---|---|
AuthenticationManager | bitta metod — authenticate(Authentication): tekshirilmagan soʻrovni oladi, tekshirilganini qaytaradi yoki exception tashlaydi |
ProviderManager | AuthenticationManagerning asosiy implementationʼi: soʻrovni shu turdagi tokenni qoʻllab-quvvatlaydigan AuthenticationProviderga beradi |
AuthenticationProvider | bitta usulni tekshiradi: DaoAuthenticationProvider — username va parolni, JwtAuthenticationProvider — JWTʼni |
UserDetailsService | foydalanuvchini username boʻyicha yuklaydi: parol hashʼi, authorityʼlar, account holati |
PasswordEncoder | kiritilgan parolni saqlangan hash bilan solishtiradi |
SecurityContextHolder | joriy soʻrovning SecurityContextini saqlaydi — default holatda ThreadLocalda |
SecurityContextRepository | contextʼni soʻrovlar orasida saqlaydi — default holatda HttpSessionda |
POST /login keldi. UsernamePasswordAuthenticationFilter username va paroldan hali tekshirilmagan UsernamePasswordAuthenticationToken yaratadi va uni AuthenticationManagerga beradi.Spring Bootʼda bularning koʻpini yozish shart emas: bitta UserDetailsService va PasswordEncoder beanʼi boʻlsa, Spring Security ulardan DaoAuthenticationProvider va AuthenticationManagerni oʻzi yigʻadi. Odatda yoziladigan qism — foydalanuvchini bazadan yuklash:
@Service
class DbUserDetails implements UserDetailsService {
private final UserRepository users;
DbUserDetails(UserRepository users) {
this.users = users;
}
@Override
public UserDetails loadUserByUsername(
String email) {
AppUser u = users.findByEmail(email)
.orElseThrow(() ->
new UsernameNotFoundException(email));
return User.withUsername(u.email())
.password(u.passwordHash())
.roles(u.role())
.disabled(!u.active())
.build();
}
}Spring Security 6 dagi muhim oʻzgarish: context endi avtomatik saqlanmaydi. 5.x da SecurityContextPersistenceFilter soʻrov oxirida contextʼni sessiyaga oʻzi yozardi; 6.x dagi SecurityContextHolderFilter uni faqat oʻqiydi. Form login kabi tayyor mexanizmlar saqlashni oʻzi qiladi, lekin loginni oʻz endpointʼingizda yozsangiz, SecurityContextRepository.saveContext()ni oʻzingiz chaqirasiz — aks holda keyingi soʻrovda foydalanuvchi yana anonymous boʻladi. Bunday endpoint permitAll boʻlishi kerak, CSRF yoqilgan boʻlsa, login soʻrovi ham CSRF token bilan keladi:
@RestController
class LoginController {
private final AuthenticationManager manager;
private final SecurityContextRepository repo =
new HttpSessionSecurityContextRepository();
LoginController(AuthenticationManager manager) {
this.manager = manager;
}
@PostMapping("/api/login")
void login(@RequestBody LoginRequest body,
HttpServletRequest req,
HttpServletResponse res) {
Authentication auth = manager.authenticate(
UsernamePasswordAuthenticationToken
.unauthenticated(body.email(),
body.password()));
// session fixation: eski session ID ishlamasin
if (req.getSession(false) != null) {
req.changeSessionId();
}
var ctx = SecurityContextHolder
.createEmptyContext();
ctx.setAuthentication(auth);
SecurityContextHolder.setContext(ctx);
repo.saveContext(ctx, req, res);
}
}
// AuthenticationManager beanʼi oʻzidan-oʻzi chiqmaydi
@Bean
AuthenticationManager authenticationManager(
AuthenticationConfiguration config)
throws Exception {
return config.getAuthenticationManager();
}Tushunganingizni tekshiring
Login paytida nima sodir boʻladi: username va parol qayerda tekshiriladi va natija qayerda saqlanadi?Javob
UsernamePasswordAuthenticationFilter username va paroldan tekshirilmagan UsernamePasswordAuthenticationToken yaratib, AuthenticationManagerga beradi. ProviderManager uni DaoAuthenticationProviderga uzatadi: u UserDetailsServicedan foydalanuvchini yuklaydi va parolni PasswordEncoder bilan solishtiradi. Natija SecurityContextga qoʻyiladi va SecurityContextRepository orqali sessiyada saqlanadi.
ProviderManager providerʼlarni navbat bilan soʻraydi: har biri supports() orqali shu turdagi tokenni tekshira olishini aytadi. Hech biri tekshira olmasa, ProviderManager ota AuthenticationManagerga murojaat qiladi (agar u bor boʻlsa), u ham boʻlmasa — ProviderNotFoundException. Shu tufayli bitta ilovada parol, JWT va boshqa usullar yonma-yon ishlay oladi.
DaoAuthenticationProvider account holatini ham tekshiradi: bloklangan, oʻchirilgan yoki muddati oʻtgan boʻlsa — LockedException, DisabledException va hokazo. Foydalanuvchi topilmasa ham, parol notoʻgʻri boʻlsa ham tashqariga bir xil BadCredentialsException chiqadi, topilmagan foydalanuvchi uchun ham soxta parol tekshiruvi qilinadi — javobdan ham, javob vaqtidan ham qaysi email roʻyxatdan oʻtganini bilib boʻlmasligi uchun. Muvaffaqiyatli authenticationʼdan keyin ProviderManager default holatda Authentication ichidagi parolni oʻchiradi.
Muvaffaqiyatdan keyin filter session IDʼni almashtiradi (session fixationʼdan himoya), yangi SecurityContextni SecurityContextHolderga qoʻyadi va repository orqali sessiyaga saqlaydi. Keyingi soʻrovda SecurityContextHolderFilter uni sessiyadan oʻqiydi — parol qayta tekshirilmaydi. Login oʻz endpointʼingizda boʻlsa, saqlash ham, session IDʼni almashtirish ham sizning zimmangizda.
Kodda joriy foydalanuvchini qanday olasiz va bu maʼlumot qayerdan keladi?Javob
Controllerʼda — @AuthenticationPrincipal yoki Authentication parametri, boshqa joyda — SecurityContextHolder.getContext().getAuthentication(). Contextʼni soʻrov boshida filterʼlar toʻldiradi: sessiyali ilovada SecurityContextHolderFilter uni sessiyadan yuklaydi, token bilan ishlaganda BearerTokenAuthenticationFilter har soʻrovda tokenni tekshirib qoʻyadi.
@AuthenticationPrincipal Authentication.getPrincipal()ni beradi, uning turi authentication usuliga bogʻliq: form login va UserDetailsService bilan — UserDetails, JWT resource serverʼda — Jwt, OAuth2 login bilan — OidcUser yoki OAuth2User. Parametr turi mos kelmasa, xato emas, null keladi: masalan, anonymous soʻrovda principal — "anonymousUser" degan satr.
Context boʻsh qolsa, AnonymousAuthenticationFilter unga AnonymousAuthenticationToken qoʻyadi. Shuning uchun getAuthentication() ochiq endpointʼda ham odatda null emas, anonymous foydalanuvchini qaytaradi va uning isAuthenticated()i true. Foydalanuvchi haqiqatan login qilganini tekshirish uchun token turiga qaraladi yoki AuthenticationTrustResolver ishlatiladi.
Servis qatlamidan SecurityContextHolderga murojaat qilish mumkin, lekin kerakli qiymatni — masalan, foydalanuvchi IDʼsini — controllerʼdan parametr qilib uzatish odatda yaxshiroq: servis HTTPʼga bogʻlanmaydi, testda esa contextʼni sozlash shart boʻlmaydi.
@GetMapping("/me")
ProfileDto me(@AuthenticationPrincipal Jwt jwt) {
return profiles.find(jwt.getSubject());
}
@GetMapping("/orders")
List<OrderDto> myOrders(Authentication auth) {
// JWT bilan getName() — "sub" claim
return orders.findByOwner(auth.getName());
}@Async metodda SecurityContextHolder nega boʻsh chiqadi?Javob
Default holatda SecurityContextHolder contextʼni ThreadLocalda saqlaydi, @Async esa metodni boshqa threadʼda bajaradi — u yerda context yoʻq. Contextʼni uzatish uchun vazifa yuborilayotganda u nusxalanadi: masalan, DelegatingSecurityContextRunnable qaytaradigan TaskDecorator yoki DelegatingSecurityContextAsyncTaskExecutor bilan.
ThreadLocalning sababi oddiy: bitta soʻrov odatda bitta threadʼda ishlaydi va contextʼni har bir metodga parametr qilib uzatish shart boʻlmaydi. FilterChainProxy soʻrov oxirida contextʼni tozalaydi, shuning uchun pooldagi thread keyingi soʻrovga eski foydalanuvchini olib oʻtmaydi.
SecurityContextHolder.MODE_INHERITABLETHREADLOCAL ham bor: yangi thread yaratilganda context unga nusxalanadi. Thread pool bilan bu xavfli — thread bir marta yaratiladi va keyin boshqa vazifalar uchun qayta ishlatiladi, shuning uchun unda uni yaratgan foydalanuvchining contextʼi qolib ketishi mumkin. Toʻgʻri yoʻl — har bir vazifa yuborilayotganda contextʼni nusxalash va vazifa tugagach tozalash; DelegatingSecurityContextRunnable aynan shunday qiladi.
Spring Boot oʻzi yaratadigan task executorʼga TaskDecorator beanʼini qoʻllaydi, shuning uchun bitta bean yetarli. Xuddi shu muammo CompletableFuture.supplyAsync, oʻzingiz yaratgan ExecutorService va virtual threadʼlarda ham bor: context faqat oʻsha threadʼda, uni oʻzingiz uzatasiz.
@Bean
TaskDecorator securityContextDecorator() {
// vazifa yuborilgan paytdagi contextʼni oladi,
// tugagach threadʼni tozalaydi
return DelegatingSecurityContextRunnable::new;
}4Sessiya, token va JWT
Login bir marta boʻladi, lekin keyingi har bir soʻrovda server foydalanuvchini qayta tanishi kerak. Buning ikki asosiy usuli bor. Sessiya: holat serverda. Logindan keyin server sessiya yaratadi va unda SecurityContextni saqlaydi, brauzerga esa faqat session ID — JSESSIONID cookie — beradi. Brauzer bu cookieʼni har soʻrovga oʻzi qoʻshadi.
Token: holat klientda. Server imzolangan token beradi, klient uni har soʻrovda Authorization: Bearer headerʼida yuboradi, server esa tokenni imzo va muddat boʻyicha tekshiradi — bazaga yoki sessiyaga murojaat qilmasdan. Shuning uchun bu usul stateless deyiladi.
| Jihat | Sessiya | Token (JWT) |
|---|---|---|
| Holat qayerda | serverda: xotira, Redis yoki baza | tokenning oʻzida, klientda |
| Har soʻrovda | session ID boʻyicha sessiyani topish | imzo va expni tekshirish, tarmoqqa murojaatsiz |
| Bir nechta server | umumiy session store (Spring Session va Redis) yoki sticky session | qoʻshimcha hech narsa kerak emas — kalit yetarli |
| Logout, bekor qilish | sessiyani oʻchirish — darhol | muddati tugaguncha amal qiladi; bekor qilish uchun qoʻshimcha holat kerak |
| Brauzer oʻzi yuboradimi | ha, cookie — CSRF himoyasi kerak | Authorization headerda — yoʻq; cookieʼda saqlansa — ha |
| Qayerda qulay | server render qiladigan sayt, bitta domendagi SPA | mobil ilova, servislararo chaqiruv, bir nechta API |
JWT — nuqta bilan ajratilgan uch qismli satr: header, payload va signature, har biri Base64URL bilan kodlangan. Header algoritmni (alg) va kalit IDʼsini (kid) aytadi, payload — claimʼlar: sub (kim), iss (kim bergan), aud (kim uchun), exp (qachon tugaydi), iat, scope. Signature header va payloadʼdan kalit bilan hisoblanadi: bitta harf oʻzgarsa ham imzo mos kelmaydi.
header.payload.signature
// header
{ "alg": "RS256", "kid": "k1", "typ": "JWT" }
// payload
{
"iss": "https://auth.shop.uz",
"sub": "42",
"aud": "orders-api",
"exp": 1763123456,
"scope": "orders:read orders:write"
}Payload shifrlanmagan, faqat kodlangan: uni istalgan kishi oʻqiy oladi, imzo faqat oʻzgartirilmaganini kafolatlaydi. Shuning uchun JWTʼga parol yoki shaxsiy maʼlumot qoʻyilmaydi. Imzo ikki xil boʻladi. HS256 — bitta umumiy secret: tokenni bergan ham, tekshirgan ham uni biladi, demak tekshiradigan har bir servis token yasay ham oladi. RS256 yoki ES256 — kalit juftligi: authorization server private key bilan imzolaydi, servislar esa faqat public key bilan tekshiradi. Servislar koʻp boʻlsa, ikkinchisi xavfsizroq.
Stateless token bilan asosiy muammo — uni bekor qilish: server bergan tokenini hech qayerda saqlamaydi. Odatiy yechim — ikki token. Access token qisqa yashaydi (masalan, 5–15 daqiqa) va har soʻrovda yuboriladi. Refresh token uzoq yashaydi, faqat yangi access token olish uchun ishlatiladi va serverda saqlanadi — uni istalgan payt bekor qilish mumkin.
Tushunganingizni tekshiring
Sessiya va token asosidagi authentication farqi nima? Qachon qaysi biri mos?Javob
Sessiyada holat serverda turadi, klientda faqat session ID boʻlgan cookie. Tokenda holat tokenning oʻzida: server uni imzo boʻyicha tekshiradi va hech narsa saqlamaydi. Bitta domendagi veb-ilova uchun sessiya odatda soddaroq va xavfsizroq; mobil ilova, bir nechta servis va API klientlari uchun token qulay.
Sessiya bilan logout oddiy: server sessiyani oʻchiradi va cookie darhol yaroqsiz boʻladi. Kamchiligi — holat: bir nechta server boʻlsa, sessiya hammasiga koʻrinishi kerak. Buning uchun Spring Session sessiyalarni Redis yoki bazada saqlaydi. Sticky session ham ishlaydi, lekin server oʻchsa, undagi foydalanuvchilar tizimdan chiqib ketadi.
Token tekshiruvi tarmoqqa murojaat talab qilmaydi va har qanday serverda ishlaydi — mikroservislar uchun shu muhim. Narxi — bekor qilishning qiyinligi va token klientda qayerda saqlanishi masalasi: brauzerda JavaScript oʻqiy oladigan joydagi token XSS bilan oʻgʻirlanishi mumkin.
Spring Securityʼda sessiya — default: SessionCreationPolicy.IF_REQUIRED, yaʼni sessiya kerak boʻlganda yaratiladi. Resource server tokenni har soʻrovda tekshiradi va contextʼni sessiyaga yozmaydi; sessiya umuman yaratilmasligi kerak boʻlsa, SessionCreationPolicy.STATELESS qoʻyiladi. «JWT — zamonaviy, sessiya — eski» degan qarash notoʻgʻri: brauzer uchun koʻpincha HttpOnly session cookie xavfsizroq tanlov.
JWT bilan stateless authenticationʼning afzalligi va kamchiligi nima? Tokenni qanday bekor qilasiz?Javob
Afzalligi — server hech narsa saqlamaydi va tokenni istalgan instance tarmoqqa murojaatsiz tekshiradi. Kamchiligi — berilgan tokenni muddati tugaguncha bekor qilib boʻlmaydi. Shuning uchun access token qisqa umrli qilinadi, darhol bekor qilish kerak boʻlsa esa serverda biroz holat qoʻshiladi: jti boʻyicha denylist yoki foydalanuvchi boʻyicha token versiyasi.
Parol almashtirildi, account bloklandi yoki token oʻgʻirlandi — server bu tokenni rad etishi kerak, lekin imzo hali ham toʻgʻri. Variantlar: qisqa exp — access token 5–15 daqiqa yashaydi va zarar shu vaqt bilan cheklanadi; denylist — bekor qilingan tokenlarning jtisi Redisʼda token muddati tugaguncha saqlanadi va har soʻrovda tekshiriladi; foydalanuvchi yozuvida token versiyasi yoki «shu vaqtdan oldin berilgan tokenlar yaroqsiz» belgisi.
Ikkinchi va uchinchi variant statelessʼlikni qisman yoʻqotadi: har soʻrovda Redis yoki bazaga murojaat. Lekin bu tekshiruv kichik va tez, butun sessiyani saqlashdan yengilroq. Koʻp tizimlar qisqa access token va bekor qilinadigan refresh token bilan cheklanadi: access tokenning oxirgi bir necha daqiqasi qabul qilinadigan xavf deb hisoblanadi.
Tekshiruvda imzo va expdan tashqari iss (tokenni biz ishonadigan server berganmi) va aud (token aynan shu servis uchunmi) ham tekshiriladi. Algoritm tokenning oʻz headerʼidan emas, server sozlamasidan olinadi: alg: none yoki algoritmni almashtirish hujumlari tokendagi algga ishonishdan kelib chiqadi. Spring Securityʼning NimbusJwtDecoderi imzosiz tokenni qabul qilmaydi; HS256 uchun esa secret kamida 32 bayt boʻlishi kerak — qisqaroq kalitni Nimbus rad etadi.
// spring-security-oauth2-jose dagi JwtEncoder bilan
String accessToken(AppUser user) {
Instant now = Instant.now();
Instant exp = now.plus(Duration.ofMinutes(15));
JwtClaimsSet claims = JwtClaimsSet.builder()
.issuer("https://api.shop.uz")
.subject(user.id().toString())
.audience(List.of("shop-api"))
.issuedAt(now)
.expiresAt(exp)
.id(UUID.randomUUID().toString())
.claim("roles", user.roles())
.build();
JwsHeader header =
JwsHeader.with(MacAlgorithm.HS256).build();
return jwtEncoder.encode(
JwtEncoderParameters.from(header, claims))
.getTokenValue();
}Refresh token qanday ishlaydi va refresh token rotation nima uchun kerak?Javob
Access token muddati tugaganda klient refresh tokenni token endpointʼga yuborib, yangi access token oladi. Rotation boʻlsa, har safar yangi refresh token ham beriladi, eskisi esa yaroqsiz boʻladi. Eski refresh token yana kelsa, bu oʻgʻirlik belgisi: server shu zanjirdagi hamma tokenlarni bekor qiladi.
Refresh token faqat bitta joyga — token endpointʼga — yuboriladi va serverda saqlanadi (hash koʻrinishida, foydalanuvchi va qurilma bilan). Shuning uchun uni bekor qilish oson: logout, parolni almashtirish yoki «hamma qurilmalardan chiqish» — bazadagi yozuvni bekor qilish. Access token esa koʻp joyga boradi, lekin qisqa yashaydi.
Rotationʼsiz oʻgʻirlangan refresh token haftalab ishlaydi va buni hech kim sezmaydi. Rotation bilan har bir refresh token bir martalik: hujumchi va foydalanuvchi bitta tokenni ishlatsa, kimdir birinchi boʻlib uni almashtiradi, ikkinchisi esa ishlatilgan tokenni yuboradi. Server buni reuse deb aniqlaydi va butun token oilasini bekor qiladi — foydalanuvchi qayta login qiladi, hujumchining tokeni ham ishlamay qoladi. OAuth 2.0 xavfsizlik tavsiyalari (RFC 9700) public clientʼlar uchun shuni talab qiladi: rotation yoki tokenni clientʼga bogʻlash.
Amalda uch tuzoq bor. Birinchisi — klientdagi poyga: ikki parallel soʻrov bir vaqtda refresh qilsa, ikkinchisi reuse boʻlib qoladi; shuning uchun klientda refresh bitta joyda, navbat bilan qilinadi yoki serverda qisqa grace period beriladi. Ikkinchisi — serverdagi poyga: «ishlatilganmi?» deb tekshirib, keyin belgilash ikki soʻrov orasida ikkalasini ham oʻtkazib yuboradi. Shuning uchun markUsed shartli boʻladi: UPDATE … SET used = true WHERE id = ? AND used = false; 0 qator yangilansa — bu ham reuse. Uchinchisi — tranzaksiya: reuse aniqlanganda exception tashlanadi va noRollbackFor boʻlmasa, oilani bekor qilish ham u bilan birga rollback boʻlib ketardi.
@Transactional(noRollbackFor = InvalidToken.class)
TokenPair refresh(String presented) {
RefreshToken old = tokens
.findByHash(sha256(presented))
.orElseThrow(InvalidToken::new);
if (old.isExpired() || old.isRevoked()) {
throw new InvalidToken();
}
// UPDATE refresh_token SET used = true
// WHERE id = ? AND used = false
if (tokens.markUsed(old.id()) == 0) {
// allaqachon ishlatilgan: butun oila bekor
tokens.revokeFamily(old.familyId());
throw new InvalidToken();
}
String next = randomToken();
tokens.save(old.successor(sha256(next)));
String access = accessToken(old.user());
return new TokenPair(access, next);
}5OAuth2, OpenID Connect va resource server
Oʻz login va token kodingiz bitta ilova uchun yetarli. Ilovalar va servislar koʻpaygach, authenticationʼni alohida serverga — authorization serverga — berish qulayroq: Keycloak, Auth0, Okta, Google yoki Spring Authorization Server (Spring Security 7 da u Spring Securityʼning bir qismi boʻldi). OAuth2 bu sxemadagi rollarni belgilaydi:
| Rol | Kim | Misol |
|---|---|---|
| Resource owner | maʼlumot egasi — foydalanuvchi | buyurtmalari bor xaridor |
| Client | foydalanuvchi nomidan APIʼni chaqiradigan ilova | veb-sayt, mobil ilova |
| Authorization server | foydalanuvchini tekshiradi va token beradi | Keycloak, Auth0, Google |
| Resource server | access token bilan himoyalangan API | sizning orders-api servisingiz |
OAuth2 aslida authorization protokoli: u clientʼga foydalanuvchi nomidan maʼlum APIʼlarga kirish huquqini — scopeʼlarni — beradi, lekin foydalanuvchi kimligini standart tarzda aytmaydi. OpenID Connect (OIDC) shu boʻshliqni toʻldiradi: openid scope soʻralganda authorization server access token bilan birga ID token ham beradi — clientʼga moʻljallangan, foydalanuvchi haqidagi (sub, email, name) JWT. OIDC yana userinfo endpointʼni va .well-known/openid-configuration discovery hujjatini standartlashtiradi.
Foydalanuvchi ishtirok etadigan asosiy flow — authorization code va PKCE:
1. Client brauzerni authorization serverga yuboradi:
GET /authorize?response_type=code
&client_id=shop-web
&scope=openid+orders:read
&redirect_uri=https://shop.uz/callback
&state=x7f2
&code_challenge=E9Melhoa2Owv...
&code_challenge_method=S256
2. Foydalanuvchi login qiladi va rozilik beradi
3. Brauzer clientʼga qaytadi:
https://shop.uz/callback?code=SplxlO&state=x7f2
4. Client token endpointʼga oʻzi murojaat qiladi:
POST /token
grant_type=authorization_code
&code=SplxlO
&code_verifier=dBjftJeZ4CVP...
5. Javob: access_token, refresh_token, id_tokenPKCE: client har bir login uchun tasodifiy code_verifier yaratadi va authorization serverga faqat uning SHA-256 hashʼini — code_challengeni — yuboradi. Code tokenga almashtirilayotganda asl code_verifier talab qilinadi: code yoʻlda ushlab qolinsa ham (masalan, mobil ilovadagi redirect orqali), verifierʼsiz undan foyda yoʻq. state esa qaytgan javob aynan shu client boshlagan loginga tegishli ekanini tekshiradi.
Spring Securityʼda bu ikki tomonlama. oauth2Login() — ilovangiz client boʻlib, foydalanuvchini authorization server orqali login qiladi:
spring:
security:
oauth2:
client:
registration:
google:
client-id: shop-web
client-secret: ${GOOGLE_CLIENT_SECRET}
scope: openid, profile, email
# SecurityFilterChain ichida:
# http.oauth2Login(Customizer.withDefaults());oauth2ResourceServer() — ilovangiz API boʻlib, kelgan access tokenni tekshiradi. Odatda bir nechta qator yetarli:
spring:
security:
oauth2:
resourceserver:
jwt:
issuer-uri: https://auth.shop.uz
audiences: orders-api
# SecurityFilterChain ichida:
# http.oauth2ResourceServer(o -> o
# .jwt(Customizer.withDefaults()));Resource server tokenni authorization serverga yubormaydi, oʻzi tekshiradi. issuer-uridan u discovery hujjatini oʻqiydi va jwks_urini topadi — authorization serverning public keyʼlari roʻyxati, JWK set. Spring Boot bu ishni birinchi soʻrovgacha kechiktiradi, shuning uchun authorization server oʻchiq boʻlsa ham ilova ishga tushadi. JWK set xotirada cacheʼlanadi (default holatda 5 daqiqa), tokendagi kid boʻyicha kerakli kalit tanlanadi:
Authorization: Bearer eyJ… bilan keldi. BearerTokenAuthenticationFilter tokenni headerʼdan oladi va JwtDecoderga beradi.Tushunganingizni tekshiring
Authorization code flow qanday ishlaydi va PKCE nimadan himoya qiladi?Javob
Client foydalanuvchini authorization serverga yuboradi; u yerda login qilingach, brauzer orqali qisqa umrli code qaytadi. Client bu codeʼni token endpointʼda oʻzi tokenlarga almashtiradi. PKCE codeʼni shu loginni boshlagan clientʼga bogʻlaydi: ushlab qolingan code code_verifiersiz ishlamaydi.
Nega token toʻgʻridan-toʻgʻri qaytarilmaydi? Brauzer orqali qaytgan narsa URLʼda, tarixda va loglarda qolishi mumkin. Code qisqa yashaydi, bir marta ishlatiladi va tokenga faqat client bilan authorization server orasidagi toʻgʻridan-toʻgʻri soʻrovda almashtiriladi — confidential client bu soʻrovda oʻz client secretʼini ham koʻrsatadi. Ilgari SPAʼlar uchun ishlatilgan implicit flow tokenni URLʼda qaytarardi; hozirgi tavsiyalar uni ishlatmaslikni aytadi.
PKCE dastlab secret saqlay olmaydigan public clientʼlar — mobil ilova va SPA — uchun chiqqan, hozir esa hamma clientʼlarga tavsiya qilinadi. Spring Security client sifatida PKCEʼni public client uchun (client-authentication-method: none) oʻzi yoqadi; 6.5 da confidential client uchun requireProofKey sozlamasi qoʻshildi, Spring Security 7 da esa authorization code uchun PKCE default holatda yoqilgan.
oauth2Login() bilan bu flowʼning hamma qadamini Spring qiladi: /oauth2/authorization/{registrationId} loginni boshlaydi, /login/oauth2/code/{registrationId} codeʼni qabul qilib tokenga almashtiradi, ID token tekshiriladi va foydalanuvchi OidcUser principal bilan sessiyaga yoziladi. Ilova uchun natija oddiy sessiyali login boʻlib qoladi.
Servis resource server sifatida JWTʼni qanday tekshiradi? Issuer va audience nima uchun kerak?Javob
BearerTokenAuthenticationFilter tokenni headerʼdan oladi, JwtDecoder esa imzoni JWK setdagi public key bilan, keyin exp, nbf, iss va (sozlangan boʻlsa) audni tekshiradi. Issuer tokenni biz ishonadigan server berganini, audience esa token aynan shu servis uchun berilganini kafolatlaydi.
Spring Boot issuer-uri boʻyicha issni oʻzi tekshiradi, exp va nbfni esa 60 soniyalik clock skew bilan. Audience default holatda tekshirilmaydi: spring.security.oauth2.resourceserver.jwt.audiences berilmasa, oʻsha authorization serverdan boshqa servis uchun olingan token ham qabul qilinadi. Bir nechta API bitta authorization serverni ishlatsa, bu haqiqiy teshik.
Kalitlar almashtirilganda authorization server JWK setga yangi kalitni qoʻshadi va tokenlarni yangi kid bilan imzolay boshlaydi. Resource serverda bunday kid cacheʼda topilmasa, JWK set qayta yuklanadi — qoʻlda hech narsa qilish shart emas. Eski kalit esa u bilan imzolangan tokenlarning muddati tugaguncha JWK setda qoladi.
Tekshiruvdan oʻtmasa — imzo mos emas, muddati oʻtgan, issuer boshqa — javob 401 va WWW-Authenticate: Bearer error="invalid_token" header. Muhim nozik joy: yaroqsiz token permitAll endpointʼda ham 401 oladi, chunki filter tokenni koʻrishi bilan tekshiradi; token umuman boʻlmasa, soʻrov anonymous boʻlib davom etadi.
7CSRF va CORS
CSRF va CORS nomlari oʻxshash va ikkalasi ham boshqa saytdan kelgan soʻrovlar haqida, lekin ular qarama-qarshi ishlarni qiladi. CSRF himoyasi — server tomonidagi toʻsiq: boshqa sayt foydalanuvchi brauzeri orqali uning nomidan amal bajara olmasin. CORS esa toʻsiq emas, ruxsat: brauzerning same-origin policyʼsini boʻshatib, boshqa origindagi JavaScriptʼga javobni oʻqishga ruxsat beradi.
CSRF hujumi: foydalanuvchi bank.uzga login qilgan, brauzerda JSESSIONID cookie bor. U evil.example saytini ochadi, u yerdan bank.uz/transferga yashirin form yuboriladi. Cookie SameSitesiz boʻlsa, brauzer uni soʻrovga oʻzi qoʻshadi — server buni foydalanuvchining oʻz soʻrovi deb hisoblaydi:
bank.uzga login qilgan: brauzerda uning JSESSIONID cookieʼsi bor — Tomcat unga SameSite atributini qoʻymaydi. Keyin u boshqa tabda evil.example sahifasini ochadi.Himoya — CSRF token. Server tasodifiy token yaratadi va uni oʻz sahifasiga beradi: formadagi yashirin _csrf maydonida yoki JavaScript oʻqiydigan cookieʼda. Holatni oʻzgartiradigan har bir soʻrov tokenni headerʼda yoki form maydonida qaytarishi kerak. Boshqa sayt bu tokenni bilmaydi: same-origin policy unga bank.uz sahifasini oʻqishga ruxsat bermaydi, brauzer esa cookieʼni qoʻshsa ham, header yoki form maydonini oʻzi qoʻshmaydi.
Spring Securityʼda CSRF himoyasi default holatda yoqilgan: GET, HEAD, TRACE va OPTIONSdan boshqa hamma soʻrovlar token bilan kelishi kerak. Demak, GET soʻrovlari hech narsani oʻzgartirmasligi shart — aks holda ular himoyadan tashqarida qoladi. Token default holatda sessiyada saqlanadi va faqat kerak boʻlganda yuklanadi; 6.0 dan uning qiymati BREACH hujumiga qarshi har soʻrovda tasodifiy niqoblanadi.
SPA bilan ishlaganda token cookieʼda beriladi — CookieCsrfTokenRepository: cookie XSRF-TOKEN, header X-XSRF-TOKEN — va JavaScript uni headerga qoʻyadi. 6.x da buning uchun ikki narsa sozlanadi. Birinchisi — CookieCsrfTokenRepository.withHttpOnlyFalse(): default cookie HttpOnly, JavaScript uni oʻqiy olmaydi. Ikkinchisi — headerdagi xom tokenni qabul qiladigan handler: default XorCsrfTokenRequestAttributeHandler cookieʼdagi niqoblanmagan qiymatni rad etadi, shuning uchun header kelganda CsrfTokenRequestAttributeHandler ishlatiladi. Token default holatda kechiktirib yuklangani uchun handler uni har soʻrovda yuklab, cookie yozilishini ham taʼminlaydi. Spring hujjatlaridagi namuna:
// Spring Security 6.x: SPA uchun CSRF
http.csrf(csrf -> csrf
.csrfTokenRepository(
CookieCsrfTokenRepository.withHttpOnlyFalse())
.csrfTokenRequestHandler(new SpaCsrfHandler()));
final class SpaCsrfHandler
implements CsrfTokenRequestHandler {
private final CsrfTokenRequestHandler plain =
new CsrfTokenRequestAttributeHandler();
private final CsrfTokenRequestHandler xor =
new XorCsrfTokenRequestAttributeHandler();
@Override
public void handle(HttpServletRequest req,
HttpServletResponse res,
Supplier<CsrfToken> token) {
xor.handle(req, res, token);
// deferred tokenʼni yuklaydi: cookie yoziladi
token.get();
}
@Override
public String resolveCsrfTokenValue(
HttpServletRequest req, CsrfToken token) {
// SPA headerda xom tokenni yuboradi
boolean header = StringUtils.hasText(
req.getHeader(token.getHeaderName()));
return (header ? plain : xor)
.resolveCsrfTokenValue(req, token);
}
}Spring Security 7 da buning hammasi bitta qator: http.csrf(csrf -> csrf.spa()).
CORS. https://shop.uz sahifasidagi JavaScript https://api.shop.uzga soʻrov yuborsa, bu boshqa origin — origin sxema, domen va portdan iborat. Brauzer javobni JavaScriptʼga faqat server Access-Control-Allow-Origin headerʼi bilan ruxsat bergandagina beradi. PUT, DELETE, Content-Type: application/json yoki Authorization headerli soʻrovlardan oldin brauzer preflight — OPTIONS soʻrovi — yuborib, ruxsatni oldindan soʻraydi.
// http.cors() beanʼni aynan shu nom bilan qidiradi
@Bean
UrlBasedCorsConfigurationSource
corsConfigurationSource() {
var cors = new CorsConfiguration();
cors.setAllowedOrigins(List.of("https://shop.uz"));
cors.setAllowedMethods(
List.of("GET", "POST", "PUT", "DELETE"));
cors.setAllowedHeaders(
List.of("Authorization", "Content-Type"));
var source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/api/**", cors);
return source;
}
// SecurityFilterChain ichida; 6.2 dan yuqoridagi
// bean boʻlsa, bu qator ixtiyoriy
http.cors(Customizer.withDefaults());CORS Spring Security zanjirida authenticationʼdan oldin hal qilinishi kerak: preflight soʻrovida cookie ham, token ham yoʻq, u authentication talab qilsa — 401 oladi va brauzer asl soʻrovni umuman yubormaydi. http.cors(...) aynan shuni qiladi: CorsFilter authentication filterʼlaridan oldin qoʻyiladi va sozlamani corsConfigurationSource nomli beandan oladi; bunday bean boʻlmasa va Spring MVC bor boʻlsa — Spring MVCʼning CORS sozlamasidan. 6.2 dan UrlBasedCorsConfigurationSource beanʼi boʻlsa, cors() oʻzi qoʻllanadi, shuning uchun bunday bean bilan http.cors(...) qatori ixtiyoriy.
Tushunganingizni tekshiring
CSRF hujumi qanday ishlaydi va CSRF token uni qanday toʻxtatadi?Javob
SameSite cheklovi boʻlmasa, brauzer cookieʼni soʻrovni qaysi sayt boshlaganidan qatʼi nazar oʻzi qoʻshadi: boshqa sayt foydalanuvchi nomidan POST yuboradi va server uni haqiqiy soʻrov deb oladi. CSRF token — server bergan va cookie orqali emas, header yoki form maydonida qaytishi kerak boʻlgan tasodifiy qiymat. Boshqa sayt uni oʻqiy olmaydi, shuning uchun soxta soʻrov 403 oladi.
Hujum uchun uchta shart kerak: authentication brauzer oʻzi yuboradigan narsaga asoslangan (cookie, HTTP Basic), amal bitta soʻrov bilan bajariladi va soʻrovning hamma parametrlarini hujumchi oldindan biladi. Token uchinchi shartni buzadi: soʻrovda hujumchi bilmaydigan qiymat boʻladi.
SameSite cookie atributi qoʻshimcha himoya: Lax boʻlsa, brauzer cookieʼni boshqa saytdan kelgan POSTga qoʻshmaydi, faqat yuqori darajadagi GET navigatsiyasida qoʻshadi. Chromium asosidagi brauzerlar atributsiz cookieʼni ham Lax deb hisoblaydi (yangi cookie uchun 2 daqiqalik istisno bilan), Firefox va Safari esa yoʻq. Spring Session cookieʼsi default holatda SameSite=Lax, Tomcatʼning JSESSIONIDi esa atributsiz — Spring Bootʼda uni server.servlet.session.cookie.same-site beradi. Shunday boʻlsa ham Spring Security hujjatlari SameSiteni tokenʼning oʻrnini bosuvchi emas, qoʻshimcha qatlam deb tavsiya qiladi: brauzerlar har xil, bir saytning subdomenlari esa bir-biriga «same-site» hisoblanadi.
Login soʻrovi ham himoyalanadi: aks holda hujumchi foydalanuvchini oʻz akkaunti bilan login qildirib, keyin u kiritgan maʼlumotni koʻrib olishi mumkin. Logout ham: CSRF yoqilgan boʻlsa, Spring Securityʼda logout faqat POST bilan ishlaydi.
Stateless REST APIʼga CSRF himoyasi kerakmi?Javob
Token Authorization headerʼida kelsa — odatda kerak emas: brauzer bu headerʼni boshqa saytdan boshlangan soʻrovga oʻzi qoʻshmaydi, shuning uchun CSRF uchun asos yoʻq. Lekin token yoki sessiya cookieʼda boʻlsa, API «stateless» boʻlsa ham CSRF himoyasi kerak.
Mezon — serverda holat bor-yoʻqligi emas, authentication qanday yuborilishi. Cookie, HTTP Basic va client sertifikatini brauzer oʻzi yuboradi; Authorization: Bearerni esa faqat sizning JavaScript kodingiz qoʻshadi. Spring Security hujjatlari ham shuni aytadi: holatini cookieʼda saqlaydigan «stateless» ilova CSRFʼga zaif.
Spring Security bu farqni hisobga oladi: oauth2ResourceServer() yoqilganda Bearer token bilan kelgan soʻrovlar CSRF tekshiruvidan oʻzi chiqariladi. Faqat brauzerdan tashqaridagi klientlar ishlatadigan APIʼda esa CSRFʼni butunlay oʻchirish keng tarqalgan va asosli tanlov — Spring hujjatlari ham shuni tavsiya qiladi.
Xavfli oraliq holat — JWTʼni XSSʼdan himoyalash uchun HttpOnly cookieʼga koʻchirish. XSS bilan oʻgʻirlash xavfi kamayadi, lekin endi brauzer tokenni har soʻrovga oʻzi qoʻshadi — bu yana cookie asosidagi authentication, demak CSRF himoyasi qaytadan kerak.
CORS nima va preflight soʻrov qachon yuboriladi? CORS serverni himoya qiladimi?Javob
CORS — brauzerga boshqa origindagi JavaScriptʼga javobni oʻqishga ruxsat berish usuli. Oddiy boʻlmagan soʻrovlardan (PUT, DELETE, JSON tana, Authorization header) oldin brauzer OPTIONS preflight yuborib, ruxsatni soʻraydi. CORS serverni himoya qilmaydi: u faqat brauzerda ishlaydi, curl yoki boshqa server uni eʼtiborsiz qoldiradi.
Preflightʼda Origin, Access-Control-Request-Method va Access-Control-Request-Headers keladi; server Access-Control-Allow-Origin, Access-Control-Allow-Methods, Access-Control-Allow-Headers (va kerak boʻlsa Access-Control-Max-Age) bilan javob beradi. Javob mos kelmasa, brauzer asl soʻrovni yubormaydi. Preflight cookie va tokensiz keladi, shuning uchun u authenticationʼdan oldin hal qilinadi — aks holda 401 oladi va brauzer konsolida «CORS error» chiqadi, garchi sabab security sozlamasida boʻlsa ham.
Cookie bilan ishlash uchun (fetch bilan credentials: "include") serverda setAllowCredentials(true) va aniq origin kerak: * credentials bilan birga ishlamaydi, Spring bunday sozlamani IllegalArgumentException bilan rad etadi. Koʻp subdomen boʻlsa — setAllowedOriginPatterns(List.of("https://*.shop.uz")).
Spring Securityʼda http.cors(...) CorsFilterni zanjirga authentication filterʼlaridan oldin qoʻyadi. CORS faqat Spring MVCʼda (@CrossOrigin, addCorsMappings) sozlanib, security zanjiriga cors() qoʻshilmasa, preflight security filterʼlarida toʻxtab qolishi mumkin.
8401, 403 va xavfsizlik testlari
Security xatolarining koʻpi controllerʼga yetmasdan, filterʼlarda chiqadi. Ularni javobga ExceptionTranslationFilter aylantiradi: undan keyingi qadamlarda — AuthorizationFilter, controller, method security — AuthenticationException yoki AccessDeniedException chiqsa, u ushlaydi va qaror qiladi:
| Holat | Kim hal qiladi | Default javob |
|---|---|---|
| token yoki sessiya yoʻq, endpoint himoyalangan | AuthorizationFilter → AuthenticationEntryPoint | form login: /loginga redirect; resource server: 401 va WWW-Authenticate: Bearer |
| token yaroqsiz yoki muddati oʻtgan | BearerTokenAuthenticationFilter → resource serverʼning entry pointʼi | 401, error="invalid_token" |
| foydalanuvchi aniq, ruxsat yoʻq | AccessDeniedHandler | 403 |
| CSRF token yoʻq yoki notoʻgʻri | CsrfFilter → AccessDeniedHandler | 403 |
@PreAuthorize rad etdi | exception filterʼlarga koʻtariladi → ExceptionTranslationFilter | 403, anonymous boʻlsa — 401 |
API klientlari uchun javob bir xil formatda boʻlishi kerak: controller xatolari ProblemDetail boʻlsa, security xatolari ham shunday. Buning uchun ikkita kirish nuqtasi sozlanadi — AuthenticationEntryPoint (401) va AccessDeniedHandler (403). Resource serverʼda entry point ikki joyga beriladi: exceptionHandling va oauth2ResourceServer. Spring Boot 4 da Jackson 3: paket tools.jackson.databind, Boot JsonMapper beanʼini beradi:
@Component
class JsonSecurityErrors
implements AuthenticationEntryPoint,
AccessDeniedHandler {
private final ObjectMapper json;
JsonSecurityErrors(ObjectMapper json) {
this.json = json;
}
@Override
public void commence(HttpServletRequest req,
HttpServletResponse res,
AuthenticationException e)
throws IOException {
write(res, HttpStatus.UNAUTHORIZED,
"Avval tizimga kiring");
}
@Override
public void handle(HttpServletRequest req,
HttpServletResponse res,
AccessDeniedException e)
throws IOException {
write(res, HttpStatus.FORBIDDEN,
"Bu amalga ruxsat yoʻq");
}
private void write(HttpServletResponse res,
HttpStatus status, String detail)
throws IOException {
var body = ProblemDetail
.forStatusAndDetail(status, detail);
res.setStatus(status.value());
res.setContentType("application/problem+json");
json.writeValue(res.getOutputStream(), body);
}
}
@Bean
SecurityFilterChain api(HttpSecurity http,
JsonSecurityErrors errors) throws Exception {
http
.authorizeHttpRequests(auth -> auth
.dispatcherTypeMatchers(DispatcherType.ERROR)
.permitAll()
.requestMatchers(HttpMethod.POST,
"/api/orders/*/refund")
.hasRole("SUPPORT")
.anyRequest().authenticated())
.exceptionHandling(e -> e
.authenticationEntryPoint(errors)
.accessDeniedHandler(errors))
.oauth2ResourceServer(o -> o
.authenticationEntryPoint(errors)
.jwt(Customizer.withDefaults()));
return http.build();
}Xavfsizlik qoidalari ham kod: ular testlanmasa, bitta notoʻgʻri permitAll yoki matcherʼlar tartibi butun boʻlimni ochib qoʻyadi. Testlar uchun spring-security-test kerak; MockMvc uchun user(), jwt() va csrf() — SecurityMockMvcRequestPostProcessorsning static metodlari. Asosiy vositalar:
| Vosita | Nima qiladi |
|---|---|
@WithMockUser | test metodi uchun SecurityContextga soxta foydalanuvchi qoʻyadi: default holatda user, parol password, role USER |
@WithUserDetails("ali") | foydalanuvchini sizning UserDetailsServiceingizdan yuklaydi |
with(user("ali").roles("ADMIN")) | MockMvc soʻroviga foydalanuvchi biriktiradi |
with(jwt()) | soxta Jwt bilan authentication: decoder va imzo tekshiruvisiz; soʻrovni CSRF tekshiruvidan ham chiqaradi |
with(csrf()) | soʻrovga toʻgʻri CSRF token qoʻshadi |
Tushunganingizni tekshiring
401 va 403 qachon qaytadi va API uchun ularni bir xil JSON formatda qanday berasiz? Nega @ControllerAdvice bu xatolarni koʻrmaydi?Javob
401 — kim ekani aniqlanmadi, 403 — aniqlandi, lekin ruxsat yoʻq. Filterʼlarda chiqqan security xatolarini ExceptionTranslationFilter javobga aylantiradi: 401 uchun AuthenticationEntryPoint, 403 uchun AccessDeniedHandler chaqiriladi — JSON format shu ikkisida beriladi. @ControllerAdvice DispatcherServlet ichida ishlaydi, bu xatolar esa undan oldin, filterʼlarda chiqadi.
ExceptionTranslationFilter qarori: AuthenticationException boʻlsa yoki foydalanuvchi anonymous boʻlsa — entry point (401 yoki login sahifasiga redirect), aks holda — access denied handler (403). Shuning uchun token yoʻq foydalanuvchiga himoyalangan endpoint 403 emas, 401 qaytaradi.
Resource serverʼda bitta tuzoq bor: yaroqsiz tokenga 401 ni ExceptionTranslationFilter emas, BearerTokenAuthenticationFilterning oʻzi yozadi va oauth2ResourceServer(o -> o.authenticationEntryPoint(...))da berilgan entry pointʼni ishlatadi. Faqat exceptionHandling() sozlansa, token umuman yoʻq soʻrov JSON oladi, muddati oʻtgan token bilan kelgan soʻrov esa — eski formatni.
Method securityʼning xatosini esa @ControllerAdvice koʻradi: @PreAuthorize controller yoki servis metodida, yaʼni DispatcherServlet ichida exception tashlaydi. Adviceʼda Exception uchun umumiy handler boʻlsa, u AccessDeniedExceptionni ham ushlab, 500 qaytaradi — yechim: bu exceptionʼni adviceʼda qayta tashlash yoki unga alohida 403 handler yozish. Yana bir joy — /error: Spring Boot xatoni ERROR dispatch bilan /errorga yuboradi, Spring Security 6 esa bu dispatchʼni ham tekshiradi. Ochiq endpointʼdagi xato anonymous foydalanuvchiga 401 boʻlib qaytmasligi uchun dispatcherTypeMatchers(DispatcherType.ERROR).permitAll() qoʻshiladi.
Xavfsizlik qoidalarini qanday testlaysiz va taqiqlangan soʻrov haqiqatan 403 olishini qanday isbotlaysiz?Javob
@WebMvcTest va MockMvc bilan, foydalanuvchini @WithMockUser yoki with(jwt()) orqali berib. Har bir qoida uchun juft test yoziladi: ruxsati yoʻq foydalanuvchi 403 oladi va servis chaqirilmaydi, ruxsati bor foydalanuvchi esa oʻtadi. Juftlik muhim — u 403 aynan role sababli chiqqanini koʻrsatadi.
@WebMvcTest sizning @Configuration klasslaringizni yuklamaydi. SecurityConfig @Import bilan qoʻshilmasa, testda Spring Bootʼning default zanjiri ishlaydi — hamma narsa authenticated(), CSRF yoqilgan — va testlar sizning qoidalaringizni emas, defaultʼni tekshiradi. Konfiguratsiya ishlatadigan beanʼlar (bu yerda JsonSecurityErrors) ham shu yerda import qilinadi.
Notoʻgʻri sabab bilan oʻtadigan test — eng xavflisi. @WithMockUser va user(...) headerni qoʻshmaydi, contextʼni toʻgʻridan-toʻgʻri toʻldiradi: CSRF yoqilgan zanjirda ular bilan yuborilgan POST CSRF sababli 403 oladi — «ruxsat yoʻq» testi notoʻgʻri sabab bilan oʻtadi, «ruxsat bor» testi yiqiladi, shuning uchun ularga with(csrf()) qoʻshiladi. jwt() va opaqueToken() esa soʻrovni CSRF tekshiruvidan oʻzi chiqaradi — ular bilan csrf() shart emas. user(), jwt(), opaqueToken() va csrf() — SecurityMockMvcRequestPostProcessorsning static metodlari.
Yana bir tuzoq: jwt() authorityʼlarni faqat scope claimʼidan oladi va sizning JwtAuthenticationConverteringizni chaqirmaydi — rollarni authorities(...) bilan oʻzingiz berasiz. Zanjir oauth2ResourceServer().jwt()ni ishlatsa, testda JwtDecoder beanʼi ham kerak: issuer-uri sozlangan boʻlsa, Boot decoder yaratadi, lekin authorization serverga birinchi token kelgunicha murojaat qilmaydi, jwt() esa decoderʼni umuman chaqirmaydi; sozlanmagan boʻlsa, @MockitoBean JwtDecoder qoʻshiladi. @MockitoBean — Spring Boot 3.4 dan, undan oldin @MockBean.
@WebMvcTest(OrderController.class)
@Import({SecurityConfig.class,
JsonSecurityErrors.class})
class OrderSecurityTest {
@Autowired
MockMvc mvc;
@MockitoBean
OrderService orders;
@Test
void anonymousGets401() throws Exception {
mvc.perform(get("/api/orders/1"))
.andExpect(status().isUnauthorized());
}
// jwt() soʻrovni CSRF tekshiruvidan oʻzi
// chiqaradi, csrf() kerak emas
@Test
void userCannotRefund() throws Exception {
mvc.perform(post("/api/orders/1/refund")
.with(jwt().authorities(
role("USER"))))
.andExpect(status().isForbidden());
verifyNoInteractions(orders);
}
@Test
void supportCanRefund() throws Exception {
mvc.perform(post("/api/orders/1/refund")
.with(jwt().authorities(
role("SUPPORT"))))
.andExpect(status().isNoContent());
}
static GrantedAuthority role(String name) {
return new SimpleGrantedAuthority(
"ROLE_" + name);
}
}9Servislar orasida xavfsizlik va tahdidlar
Mikroservislar orasidagi chaqiruvlarda foydalanuvchi har doim ham ishtirok etmaydi, ichki tarmoq esa xavfsiz deb hisoblanmaydi: bitta servis buzilsa, «ichkaridan» kelgan har qanday soʻrovga ishonadigan tizim butunlay ochilib qoladi. Shuning uchun zero trust yondashuvi: har bir servis kelgan soʻrovni oʻzi tekshiradi.
| Usul | Nima isbotlaydi | Qachon |
|---|---|---|
| Client credentials | qaysi servis chaqiryapti — servisning oʻz tokeni, oʻz scopeʼlari bilan | foydalanuvchisiz fon vazifalari, servis nomidan amal |
| Foydalanuvchi tokenini uzatish | qaysi foydalanuvchi nomidan | zanjirdagi servislar bir xil ishonch darajasida va bitta audience ostida |
| Token exchange (RFC 8693) | foydalanuvchi nomidan, lekin keyingi servis uchun alohida, torroq token bilan | audience va scopeʼni toraytirish kerak boʻlganda |
| mTLS | ulanishning ikkala tomoni — sertifikat bilan | transport darajasi; koʻpincha uni service mesh qiladi |
Client credentials bilan servis tokenni oʻzi oladi. Spring Bootʼda bu propertyʼlar va bitta RestClient interceptorʼi bilan yoziladi:
spring:
security:
oauth2:
client:
registration:
payments:
provider: shop-auth
client-id: orders-service
client-secret: ${PAYMENTS_CLIENT_SECRET}
authorization-grant-type: client_credentials
scope: payments:charge
provider:
shop-auth:
issuer-uri: https://auth.shop.uz@Bean
RestClient payments(RestClient.Builder builder,
OAuth2AuthorizedClientManager clients) {
var oauth = new OAuth2ClientHttpRequestInterceptor(
clients);
return builder
.baseUrl("https://payments.internal")
.requestInterceptor(oauth)
.build();
}
// chaqiruv: token olinadi, cacheʼlanadi va yangilanadi
payments.post().uri("/charges")
.attributes(clientRegistrationId("payments"))
.body(charge)
.retrieve()
.toBodilessEntity();mTLS. Oddiy TLSʼda faqat server sertifikat koʻrsatadi, mutual TLSʼda client ham oʻz sertifikatini koʻrsatadi va server uni oʻzi ishonadigan CA boʻyicha tekshiradi. Spring Bootʼda server tomoni server.ssl.client-auth=need bilan yoqiladi, Spring Security esa http.x509(...) bilan sertifikatdagi nomni principalʼga aylantira oladi. Kubernetesʼda bu ishni koʻpincha service mesh (Istio, Linkerd) ilova kodiga tegmasdan qiladi. mTLS kanalni himoyalaydi va qaysi servis ulanganini aytadi, lekin foydalanuvchi kimligini emas — shuning uchun u token bilan birga ishlatiladi.
Token oʻgʻirlanishi. Bearer token — «kimning qoʻlida boʻlsa, oʻsha ishlatadi»: uni olgan har kim muddati tugaguncha foydalanuvchi nomidan ishlaydi. Brauzerda tokenni localStorageda saqlash eng koʻp uchraydigan xato: sahifadagi istalgan JavaScript — XSS orqali kirgan kod yoki buzilgan npm paket ham — uni oʻqib, boshqa joyga yuborishi mumkin.
Secretʼlar — DB paroli, client secret, JWT imzo kaliti, API kalitlar — repoda saqlanmaydi: git tarixi oʻchmaydi va uni koʻp odam koʻradi. Ular environment variable, Kubernetes Secret, Vault yoki cloud secret manager orqali beriladi; Spring Boot ularni oddiy propertyʼlar kabi oʻqiydi (spring.config.import bilan configtree: yoki Spring Cloud Vault). Secret repoga tushib qolsa, uni tarixdan oʻchirish yetmaydi — secretʼning oʻzi almashtiriladi.
Tushunganingizni tekshiring
Servislar bir-birini qanday tekshiradi? Client credentials, foydalanuvchi tokenini uzatish va mTLS qachon ishlatiladi?Javob
Foydalanuvchisiz chaqiruvda servis client credentials flow bilan oʻz tokenini oladi, keyingi servis uni oddiy access token kabi tekshiradi. Foydalanuvchi nomidan chaqiruvda uning tokeni uzatiladi yoki token exchange bilan keyingi servis uchun torroq tokenga almashtiriladi. mTLS ulanish darajasida servislarni bir-biriga tanitadi va tokenni almashtirmaydi, toʻldiradi.
Client credentials — eng oddiy flow: servis client_id va secret (yoki private_key_jwt) bilan token endpointʼdan access token oladi, unda foydalanuvchi yoʻq — token servisning oʻziga berilgan. Token muddati tugaguncha cacheʼlanadi: har chaqiruvda yangi token soʻrash authorization serverni bekorga yuklaydi. Spring Securityʼda buni OAuth2AuthorizedClientManager qiladi, RestClient uchun esa 6.4 dan OAuth2ClientHttpRequestInterceptor bor. HTTP soʻrovidan tashqarida — masalan, scheduled vazifada — AuthorizedClientServiceOAuth2AuthorizedClientManager ishlatiladi.
Foydalanuvchi tokenini keyingi servisga oʻzgarishsiz uzatish oddiy, lekin keng ruxsatli token hamma servislar boʻylab yuradi: bitta servis buzilsa, token boshqalarida ham ishlaydi. Token exchange (RFC 8693, Spring Securityʼda 6.3 dan) foydalanuvchi tokenini keyingi servis uchun alohida audience va kamroq scope bilan yangisiga almashtiradi — har bir servis faqat oʻziga kerak ruxsatni oladi.
«Ichki tarmoq xavfsiz» degan taxmin eng xavflisi: bitta zaif servis yoki notoʻgʻri ochilgan port butun tizimga yoʻl ochadi. Har bir servis oʻzi resource server boʻlib tokenni tekshiradi va aud boʻyicha faqat oʻziga berilgan tokenlarni qabul qiladi; mTLS esa trafikni shifrlaydi va kim ulanganini tasdiqlaydi.
Tokenni oʻgʻirlanishdan qanday himoyalaysiz? Brauzerda uni qayerda saqlash kerak?Javob
localStorage va sessionStorageni sahifadagi har qanday JavaScript oʻqiydi, shuning uchun XSS tokenni olib ketadi. Xavfsizroq yoʻl — tokenni brauzerga umuman bermaslik: BFF — backend for frontend — tokenlarni serverda saqlaydi, brauzer esa faqat HttpOnly, Secure, SameSite session cookie oladi. Qolgan qatlamlar — qisqa umrli access token, refresh token rotation va bekor qilish imkoniyati.
HttpOnly cookieʼni JavaScript oʻqiy olmaydi, shuning uchun XSS tokenni boshqa joyga olib keta olmaydi. Lekin XSS sahifada ishlab turganda foydalanuvchi nomidan soʻrov yubora oladi: HttpOnly oʻgʻirlikni toʻxtatadi, XSSʼning oʻzini emas. XSSʼga qarshi asosiy himoya alohida — chiqishni escape qilish va Content Security Policy.
BFF sxemasida SPA faqat oʻz backendʼi bilan session cookie orqali gaplashadi; backend OAuth2 client boʻlib (oauth2Login()), access va refresh tokenlarni serverda saqlaydi va API chaqiruvlariga oʻzi qoʻshadi. Brauzer ilovalari uchun OAuth 2.0 boʻyicha IETF hujjati — RFC 10017 (BCP 212) — ham bu sxemani eng xavfsiz variant deb koʻrsatadi. Cookie ishlatilgani uchun CSRF himoyasi kerak boʻladi.
Token baribir oʻgʻirlansa, zararni cheklaydigan narsalar: qisqa exp, refresh token rotation va reuse aniqlash, logout va parol almashtirishda refresh tokenlarni bekor qilish. Yana bir qatlam — tokenni clientʼga bogʻlash: DPoP yoki mTLS bilan bogʻlangan tokenni faqat tegishli kalitga ega client ishlata oladi; Spring Security resource server 6.5 dan DPoPʼni qoʻllab-quvvatlaydi.
Brute forceʼdan qanday himoyalanasiz va secretʼlarni qanday saqlab, almashtirasiz?Javob
Brute forceʼga qarshi — login endpointʼida IP va account boʻyicha rate limit, ketma-ket xatolardan keyin sekinlashtirish yoki vaqtincha bloklash va sekin parol hash. Spring Securityʼda tayyor rate limit yoʻq: muvaffaqiyatsiz loginlar AuthenticationFailureBadCredentialsEvent orqali sanaladi, cheklash esa ilovada yoki gateway darajasida qilinadi. Secretʼlar repodan tashqarida — environment, Vault yoki secret manager — saqlanadi va muntazam almashtiriladi.
Faqat account boʻyicha bloklash xavfli: hujumchi ataylab xato parol kiritib, istalgan foydalanuvchini bloklab qoʻyadi. Shuning uchun koʻpincha kombinatsiya ishlatiladi: IP boʻyicha rate limit (Bucket4j, gateway yoki Redis hisoblagichi), account boʻyicha esa bloklash emas, oʻsib boruvchi kechikish yoki CAPTCHA. Credential stuffing — boshqa saytdan sizib chiqqan parollar bilan urinish — ham shu yerda toʻxtaydi; Spring Security 6.3 dan CompromisedPasswordChecker roʻyxatdan oʻtishda sizib chiqqan parolni aniqlay oladi.
Spring Boot AuthenticationEventPublisherni oʻzi yaratadi, shuning uchun muvaffaqiyatsiz loginlarni sanash uchun @EventListener yetarli. UserDetails.isAccountNonLocked() false qaytarsa, DaoAuthenticationProvider loginni LockedException bilan rad etadi — bloklash holati shu orqali beriladi.
Secretʼlarni almashtirish oldindan rejalashtiriladi, aks holda u hech qachon qilinmaydi. JWT imzo kalitlari uchun JWKS buni oʻzi beradi: yangi kalit yangi kid bilan qoʻshiladi, eskisi u bilan imzolangan tokenlar tugaguncha qoladi. DB parollari uchun Vault qisqa muddatli dinamik credentialʼlar bera oladi. Har bir secretʼning egasi va almashtirish tartibi yozib qoʻyilgani maʼqul — secret sizib chiqqanda bu ish soatlar emas, daqiqalar olishi kerak.
@Component
class LoginAttempts {
private final AttemptCounter counter;
LoginAttempts(AttemptCounter counter) {
this.counter = counter;
}
@EventListener
void onFailure(
AuthenticationFailureBadCredentialsEvent e) {
String user = e.getAuthentication().getName();
counter.failed(user);
}
@EventListener
void onSuccess(AuthenticationSuccessEvent e) {
counter.reset(e.getAuthentication().getName());
}
}Tushunganingizni suhbatda sinab koʻring
Mavzuli mock intervyuda «Spring Security»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.