В чем разница между аутентификации и авторизации?

# Аутентификация vs Авторизация

Это две разные концепции безопасности, часто путаемые между собой. Но они решают разные задачи и идут одна за другой.

Определения

Аутентификация (Authentication)

Аутентификация — это процесс ПРОВЕРКИ ЛИЧНОСТИ пользователя. Ответ на вопрос: "Ты кто?"

// Пример аутентификации
public class AuthenticationExample {
    // 1. Пользователь вводит email и пароль
    public ResponseEntity<TokenResponse> login(
            @RequestBody LoginRequest request) {
        String email = request.getEmail();      // alice@example.com
        String password = request.getPassword(); // pass123
        
        // 2. Система проверяет credentials
        User user = userService.findByEmail(email);
        if (user == null) {
            throw new AuthenticationException("User not found");
        }
        
        // 3. Проверяем пароль
        if (!passwordEncoder.matches(password, user.getPassword())) {
            throw new AuthenticationException("Invalid password");
        }
        
        // 4. Аутентификация успешна — выдаём токен
        String token = jwtProvider.generateToken(user.getId());
        return ResponseEntity.ok(new TokenResponse(token));
    }
}

Процесс:

Pользователь отправляет credentials (email + password)
          ↓
Система проверяет есть ли такой пользователь
          ↓
Система проверяет пароль (хеш с salt)
          ↓
Если всё правильно → выдаём токен (JWT или session)

Авторизация (Authorization)

Авторизация — это процесс ПРОВЕРКИ ПРАВ доступа. Ответ на вопрос: "Что ты можешь делать?"

// Пример авторизации
@RestController
@RequestMapping("/api/admin")
public class AdminController {
    @GetMapping("/users")
    @PreAuthorize("hasRole(ADMIN)")  // ← авторизация
    public List<User> getAllUsers() {
        // Только админы могут получить всех пользователей
        return userService.findAll();
    }
    
    @DeleteMapping("/users/{id}")
    @PreAuthorize("hasRole(ADMIN)")  // ← авторизация
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        // Только админы могут удалять
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

// Spring Security проверит роль
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/api/admin/**").hasRole("ADMIN")  // авторизация
            .antMatchers("/api/user/**").hasRole("USER")
            .anyRequest().authenticated();
    }
}

Процесс:

Пользователь отправляет запрос с токеном (уже аутентифицирован)
          ↓
Система проверяет токен (действителен ли)
          ↓
Система проверяет РОЛИ и ПРАВА пользователя
          ↓
Если права есть → разрешаем доступ
Если прав нет → 403 Forbidden

Сравнение

Порядок проверок

1. АУТЕНТИФИКАЦИЯ → 401 Unauthorized
   ↓ (успех)
2. АВТОРИЗАЦИЯ → 403 Forbidden
   ↓ (успех)
3. Доступ разрешён → 200 OK

Примеры HTTP статусов

// 401 Unauthorized — проблема с аутентификацией
GET /api/admin/users HTTP/1.1
// Ответ: 401 (нет токена или токен невалидный)

GET /api/admin/users HTTP/1.1
Authorization: Bearer invalid-token
// Ответ: 401 (токен невалидный)

// 403 Forbidden — проблема с авторизацией
GET /api/admin/users HTTP/1.1
Authorization: Bearer valid-user-token
// Ответ: 403 (пользователь не админ)

Spring Security — интеграция

@RestController
public class ResourceController {
    @GetMapping("/public")
    public ResponseEntity<String> publicResource() {
        // Доступен всем (без аутентификации)
        return ResponseEntity.ok("Public data");
    }
    
    @GetMapping("/user")
    @PreAuthorize("isAuthenticated()")  // ← аутентификация
    public ResponseEntity<String> userResource() {
        // Доступен только аутентифицированным пользователям
        return ResponseEntity.ok("User data");
    }
    
    @GetMapping("/admin")
    @PreAuthorize("hasRole(ADMIN)")  // ← авторизация
    public ResponseEntity<String> adminResource() {
        // Доступен только админам
        return ResponseEntity.ok("Admin data");
    }
    
    @GetMapping("/manager")
    @PreAuthorize("hasAnyRole(ADMIN, MANAGER)")  // ← авторизация
    public ResponseEntity<String> managerResource() {
        // Доступен админам и менеджерам
        return ResponseEntity.ok("Manager data");
    }
}

Реальный пример

// Сценарий: Боб хочет удалить заказ

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @DeleteMapping("/{id}")
    @PreAuthorize("isAuthenticated() and hasRole(ADMIN)") 
    public ResponseEntity<Void> deleteOrder(@PathVariable Long id) {
        orderService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

// 1. Боб пытается удалить заказ БЕЗ токена
// DELETE /api/orders/123
// Ответ: 401 Unauthorized
// Причина: АУТЕНТИФИКАЦИЯ FAILED (нет токена)

// 2. Боб отправляет запрос с токеном обычного пользователя
// DELETE /api/orders/123
// Authorization: Bearer user-token
// Ответ: 403 Forbidden
// Причина: АВТОРИЗАЦИЯ FAILED (нет роли ADMIN)

// 3. Боб отправляет запрос с токеном админа
// DELETE /api/orders/123
// Authorization: Bearer admin-token
// Ответ: 204 No Content
// Причина: ОБЕ проверки пройдены (аутентификация OK, авторизация OK)

Механизмы аутентификации

// 1. Basic Auth (email + пароль)
curl -u alice@example.com:password http://api.example.com/data

// 2. JWT (JSON Web Token)
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

// 3. OAuth 2.0 (третьи сервис, type Google, GitHub)
Authorization: Bearer google-oauth-token

// 4. Session (cookie)
Cookie: JSESSIONID=ABC123

// 5. API Key
X-API-Key: secret-key-123

Механизмы авторизации

// 1. Role-based (RBAC)
@PreAuthorize("hasRole(ADMIN)")  // есть роль

// 2. Permission-based (PBAC)
@PreAuthorize("hasAuthority(DELETE_USER)")  // есть пермишн

// 3. Attribute-based (ABAC)
@PreAuthorize("#userId == authentication.principal.id")  // для себя

// 4. Custom
@PreAuthorize("@customSecurityService.hasAccess(#resourceId)")

Практический пример — полная цепочка

@RestController
@RequestMapping("/api/v1/users")
public class UserAPI {
    @PostMapping("/login")
    public ResponseEntity<TokenResponse> login(
            @RequestBody LoginRequest request) {
        // АУТЕНТИФИКАЦИЯ
        User user = authenticateUser(request.getEmail(), request.getPassword());
        String token = jwtProvider.generateToken(user);
        return ResponseEntity.ok(new TokenResponse(token));
    }
    
    @GetMapping("/{id}")
    @PreAuthorize("isAuthenticated() and #id == authentication.principal.id")
    public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
        // АУТЕНТИФИКАЦИЯ: проверяем токен ✓
        // АВТОРИЗАЦИЯ: только свои данные ✓
        User user = userService.findById(id);
        return ResponseEntity.ok(new UserDTO(user));
    }
    
    @DeleteMapping("/{id}")
    @PreAuthorize("isAuthenticated() and hasRole(ADMIN)")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        // АУТЕНТИФИКАЦИЯ: проверяем токен ✓
        // АВТОРИЗАЦИЯ: только админы ✓
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

Итоги

Аутентификация:

• Проверка личности (ты кто?)
• Паспорт, пароль, 2FA
• Результат: токен или session
• Ошибка: 401 Unauthorized

Авторизация:

• Проверка прав (что ты можешь?)
• Роли, пермишены, атрибуты
• Результат: разрешение или запрет
• Ошибка: 403 Forbidden

Правило: аутентификация ВСЕГДА идёт первой. Авторизация проверяется только после успешной аутентификации.