Что такое авторизация?

Что такое авторизация

Авторизация (Authorization) — это процесс определения прав и привилегий пользователя после его успешной идентификации. Она отвечает на вопрос: «Что пользователь может делать?». Важно не путать авторизацию с аутентификацией — это разные понятия.

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

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

• Процесс подтверждения личности пользователя
• Ответ на вопрос: «Кто вы?»
• Проверка учётных данных (логин, пароль, биометрия)
• Происходит ДО авторизации

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

• Процесс предоставления прав на действия
• Ответ на вопрос: «Что вы можете делать?»
• Проверка прав доступа к ресурсам
• Происходит ПОСЛЕ аутентификации

# Пример: аутентификация и авторизация
from flask import Flask, request
from functools import wraps

app = Flask(__name__)

# Аутентификация — проверка пароля
def authenticate_user(username, password):
    user = User.query.filter_by(username=username).first()
    if user and user.check_password(password):
        return user
    return None

# Авторизация — проверка прав
def require_admin(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        user = get_current_user()
        if user and user.role == 'admin':
            return f(*args, **kwargs)
        return {'error': 'Access denied'}, 403
    return decorated_function

@app.route('/admin/users')
@require_admin
def admin_panel():
    return {'data': 'admin data'}

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

Role-Based Access Control (RBAC)

Пользователям присваиваются роли (администратор, модератор, пользователь), каждой роли соответствуют определённые права.

from django.contrib.auth.models import User, Group, Permission
from django.contrib.auth.decorators import user_passes_test

# Создание ролей
admin_group = Group.objects.create(name='Admin')
user_group = Group.objects.create(name='User')

# Добавление прав к роли
from django.contrib.auth.models import Permission
admin_group.permissions.add(Permission.objects.get(codename='delete_user'))
admin_group.permissions.add(Permission.objects.get(codename='edit_user'))

# Проверка роли
def is_admin(user):
    return user.groups.filter(name='Admin').exists()

@user_passes_test(is_admin)
def delete_user(request, user_id):
    User.objects.get(id=user_id).delete()
    return {'status': 'deleted'}

Attribute-Based Access Control (ABAC)

Решение о доступе принимается на основе атрибутов пользователя, ресурса, действия и окружения.

from typing import Dict, Any

def check_access(user: Dict[str, Any], resource: Dict[str, Any]) -> bool:
    """
    Проверка доступа на основе атрибутов
    """
    # Атрибуты пользователя
    user_role = user.get('role')
    user_department = user.get('department')
    
    # Атрибуты ресурса
    resource_type = resource.get('type')
    resource_department = resource.get('department')
    resource_classification = resource.get('classification')
    
    # Логика доступа
    if user_role == 'admin':
        return True
    
    if user_role == 'manager' and resource_type == 'report':
        return user_department == resource_department
    
    if resource_classification == 'public':
        return True
    
    return False

# Использование
user = {'role': 'manager', 'department': 'sales'}
resource = {'type': 'report', 'department': 'sales', 'classification': 'private'}

if check_access(user, resource):
    print("Доступ разрешён")
else:
    print("Доступ запрещён")

Access Control List (ACL)

Для каждого ресурса определяется список того, кто имеет доступ и какие действия может совершать.

from datetime import datetime

class ACL:
    def __init__(self):
        self.rules = {}  # resource_id -> {user_id: [permissions]}
    
    def grant_permission(self, resource_id: str, user_id: str, permission: str):
        """Предоставить право доступа"""
        if resource_id not in self.rules:
            self.rules[resource_id] = {}
        
        if user_id not in self.rules[resource_id]:
            self.rules[resource_id][user_id] = []
        
        if permission not in self.rules[resource_id][user_id]:
            self.rules[resource_id][user_id].append(permission)
    
    def check_permission(self, resource_id: str, user_id: str, permission: str) -> bool:
        """Проверить право доступа"""
        if resource_id not in self.rules:
            return False
        
        if user_id not in self.rules[resource_id]:
            return False
        
        return permission in self.rules[resource_id][user_id]

# Использование
acl = ACL()
acl.grant_permission('document_1', 'user_1', 'read')
acl.grant_permission('document_1', 'user_1', 'write')
acl.grant_permission('document_1', 'user_2', 'read')

print(acl.check_permission('document_1', 'user_1', 'write'))  # True
print(acl.check_permission('document_1', 'user_2', 'write'))  # False

Реализация авторизации в FastAPI

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthCredentials
import jwt

app = FastAPI()
security = HTTPBearer()

SECRET_KEY = "your-secret-key"

def verify_token(credentials: HTTPAuthCredentials = Depends(security)):
    """Аутентификация через JWT"""
    try:
        payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=['HS256'])
        user_id = payload.get('sub')
        return user_id
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

def require_role(required_role: str):
    """Авторизация по роли"""
    async def check_role(user_id: str = Depends(verify_token)):
        user = get_user(user_id)  # Получить пользователя
        if user.role != required_role:
            raise HTTPException(status_code=403, detail="Insufficient permissions")
        return user
    return check_role

# Использование
@app.delete('/users/{user_id}')
async def delete_user(user_id: str, admin: User = Depends(require_role('admin'))):
    User.objects.get(id=user_id).delete()
    return {'status': 'deleted'}

Лучшие практики

Принцип наименьших привилегий (Principle of Least Privilege)

• Пользователи получают только необходимые права
• Права должны быть максимально специфичными
• Регулярно проверять и удалять ненужные права

# ❌ Плохо — слишком много прав
user.role = 'admin'  # Доступ ко всему

# ✅ Хорошо — специфичные права
user.permissions = ['read_documents', 'create_comments']

Разделение обязанностей (Separation of Duties)

• Критические операции требуют нескольких утверждений
• Разные люди отвечают за разные действия

Регулярный аудит

• Логирование всех операций авторизации
• Мониторинг попыток несанкционированного доступа
• Регулярная проверка прав пользователей

Авторизация в реальных приложениях

В реальных приложениях авторизация часто реализуется через комбинацию:

• Middleware для проверки прав на уровне приложения
• Permissions в ORM моделях
• Policy классы для сложной логики
• Audit logs для отслеживания действий

Авторизация — критически важный компонент безопасности приложения, требующий тщательного проектирования и реализации.