Spring Security ਅਤੇ JWT ਨਾਲ authentication ਅਤੇ authorization ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

IT Interview Practice · Accepted Answer

Spring Security ਇੱਕ servlet **filter chain** ਹੈ ਜੋ ਤੁਹਾਡੇ controller ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਹਰ request ਨੂੰ intercept ਕਰਦੀ ਹੈ। **Authentication** ਦਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ "ਤੁਸੀਂ ਕੌਣ ਹੋ?"; **authorization** ਦਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ "ਕੀ ਤੁਹਾਨੂੰ ਇਹ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਹੈ?"। stateless REST APIs ਲਈ, ਆਮ ਪਹੁੰਚ server-side sessions ਦੀ ਥਾਂ **JWT** (JSON Web Token) ਹੈ।

## JWT flow

```text
POST /login (user+pass) ──▶ AuthController verifies ──▶ signs JWT ──▶ returns token
                                                                          │
Client stores it, then sends on every call:                              ▼
GET /api/orders  Authorization: Bearer <jwt> ──▶ JwtFilter validates ──▶ controller
```

Token ਨੂੰ server ਦੁਆਰਾ sign ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਬਾਅਦ ਦੀਆਂ requests 'ਤੇ ਇੱਕ filter ਇਸਨੂੰ *ਇੱਕ database lookup ਤੋਂ ਬਿਨਾਂ* verify ਕਰ ਸਕਦਾ ਹੈ — ਇਹੀ ਗੱਲ ਇਸਨੂੰ stateless ਅਤੇ horizontally scalable ਬਣਾਉਂਦੀ ਹੈ।

## Filter chain ਨੂੰ configure ਕਰਨਾ

```java
@Configuration
@EnableMethodSecurity // enables @PreAuthorize on methods
public class SecurityConfig {

@Bean
    SecurityFilterChain chain(HttpSecurity http) throws Exception {
        http
          .csrf(csrf -> csrf.disable())                 // stateless API: no CSRF cookie
          .sessionManagement(s -> s.sessionCreationPolicy(STATELESS))
          .authorizeHttpRequests(auth -> auth
              .requestMatchers("/login").permitAll()    // open endpoint
              .requestMatchers("/api/admin/**").hasRole("ADMIN") // role check
              .anyRequest().authenticated())            // everything else needs a token
          .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}
```

## Method-level authorization

```java
@PreAuthorize("hasRole('ADMIN') or #userId == authentication.name")
public UserDto get(@PathVariable String userId) { /* ... */ }
```

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Auth ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ security incidents ਹੁੰਦੀਆਂ ਹਨ, ਇਸ ਲਈ interviewer ਸਹੀ ਪ੍ਰਵਿਰਤੀਆਂ ਸੁਣਦੇ ਹਨ: **BCrypt ਨਾਲ passwords hash ਕਰੋ** (ਕਦੇ ਵੀ plaintext ਸਟੋਰ ਨਾ ਕਰੋ), JWTs ਨੂੰ refresh tokens ਨਾਲ short-lived ਰੱਖੋ, ਅਤੇ scalability ਲਈ stateless tokens ਨੂੰ ਤਰਜੀਹ ਦਿਓ ਪਰ trade-off ਜਾਣੋ — ਤੁਸੀਂ ਇੱਕ denylist ਤੋਂ ਬਿਨਾਂ ਇੱਕ JWT ਨੂੰ ਤੁਰੰਤ revoke ਨਹੀਂ ਕਰ ਸਕਦੇ। ਇਹ ਜਾਣਨਾ ਕਿ token APIs ਲਈ CSRF *ਕਿਉਂ* disable ਹੁੰਦੀ ਹੈ, ਅਸਲ ਸਮਝ ਦਿਖਾਉਂਦਾ ਹੈ, copy-paste config ਨਹੀਂ।

JWT flow

Filter chain ਨੂੰ configure ਕਰਨਾ

Method-level authorization

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ