Что такое авторизация с физической стороны?

Авторизация с физической стороны (Physical Authorization)

Авторизация с физической стороны — это система контроля доступа к физическим ресурсам (зданиям, помещениям, серверным комнатам). Для разработчика, работающего в компании, это означает различные способы подтверждения личности при входе в офис, серверную или другие защищённые помещения.

Основные концепты

Физическая авторизация включает:

1. Аутентификация — подтверждение личности (кто ты?)
2. Авторизация — определение прав доступа (что ты можешь делать?)

Виды физической идентификации

1. Карточные системы (Badge/ID Card)

Самый распространённый метод в офисах:

Карточка с RFID чипом → Считыватель → Контроллер доступа → Замок

• Преимущества: удобство, простота, быстро
• Недостатки: карточку можно потерять, украсть, передать
• Уровни доступа: разные карточки для разных помещений

2. Биометрия

Опаснее карточек, так как биометрические данные невозможно потерять:

# Пример биометрической системы (концептуально)
class BiometricAuth:
    def verify_fingerprint(self, user_id: int, fingerprint_data: bytes) -> bool:
        """Проверяет отпечаток пальца"""
        stored = self.database.get_fingerprint(user_id)
        similarity = self.compare(fingerprint_data, stored)
        return similarity > 0.95  # Порог совпадения
    
    def verify_face(self, user_id: int, face_image: np.ndarray) -> bool:
        """Проверяет лицо через AI"""
        stored = self.database.get_face_encoding(user_id)
        distance = np.linalg.norm(face_image - stored)
        return distance < 0.6  # Порог расстояния
    
    def verify_iris(self, user_id: int, iris_pattern: bytes) -> bool:
        """Проверяет радужную оболочку глаза"""
        stored = self.database.get_iris_pattern(user_id)
        return self.hamming_distance(iris_pattern, stored) < 32

Виды биометрии:

• Отпечатки пальцев — самая надёжная
• Распознавание лица — 3D сканеры, AI
• Сетчатка/Радужная оболочка глаза — самая дорогая
• Голос — менее надёжна

3. Пин-коды и пароли

Менее безопасно, но используется:

class PINAuth:
    def verify_pin(self, user_id: int, pin: str) -> bool:
        stored_pin = self.database.get_hashed_pin(user_id)
        # Никогда не сравниваем в открытом виде!
        return self.hash_pin(pin) == stored_pin

4. Комбинированные методы (Multi-factor)

Самый безопасный подход:

class MultiFactorAuth:
    def grant_access(self, user_id: int, factors: dict) -> bool:
        """
        Требует несколько факторов:
        - Карточка
        - Биометрия
        - Пин-код
        """
        checks = [
            self.verify_card(user_id, factors.get('card_id')),
            self.verify_fingerprint(user_id, factors.get('fingerprint')),
            self.verify_pin(user_id, factors.get('pin'))
        ]
        return all(checks)  # Все должны быть успешны

Логирование доступа (Access Logs)

Критически важный аспект — регистрация всех попыток доступа:

from datetime import datetime
from dataclasses import dataclass
from enum import Enum

class AccessStatus(Enum):
    GRANTED = "GRANTED"
    DENIED = "DENIED"
    ATTEMPT_DENIED = "ATTEMPT_DENIED"  # Странные попытки

@dataclass
class AccessLog:
    user_id: int
    location: str  # Какое помещение
    timestamp: datetime
    status: AccessStatus
    method: str  # card, biometric, pin
    device_id: str  # Какой считыватель
    additional_info: dict  # Для отладки

class AccessLogService:
    def log_access(self, log: AccessLog):
        """Записывает попытку доступа"""
        self.database.insert(log)
        
        # Проверяем аномалии
        if self.is_suspicious(log):
            self.alert_security(log)
    
    def is_suspicious(self, log: AccessLog) -> bool:
        """Обнаруживает подозрительную активность"""
        # Попытка доступа в необычное время
        if log.timestamp.hour not in range(6, 22):
            return True
        
        # Несколько отказов подряд
        recent_logs = self.get_recent_logs(log.user_id, minutes=5)
        denied_count = sum(1 for l in recent_logs if l.status == AccessStatus.DENIED)
        if denied_count > 3:
            return True
        
        return False

Иерархия доступа

Разные уровни доступа для разных сотрудников:

from enum import IntEnum

class AccessLevel(IntEnum):
    PUBLIC = 1        # Общие помещения
    EMPLOYEE = 2      # Офисные помещения
    IT = 3            # Комната ИТ
    SERVER_ROOM = 4   # Серверная (максимум)

class AccessControl:
    def can_access(self, user: dict, location: str) -> bool:
        """
        Проверяет, может ли пользователь войти в помещение
        """
        required_level = self.get_required_level(location)
        user_level = user.get('access_level')
        
        return user_level >= required_level

# Примеры
user_developer = {'id': 1, 'access_level': AccessLevel.IT}
user_intern = {'id': 2, 'access_level': AccessLevel.EMPLOYEE}

access = AccessControl()

# Разработчик может войти в серверную
access.can_access(user_developer, 'server_room')  # True

# Стажер не может
access.can_access(user_intern, 'server_room')  # False

Управление ключами и доступом (Key Management)

Для разработчиков, работающих с системами:

from typing import Optional
from datetime import datetime, timedelta

class KeyCard:
    def __init__(self, card_id: str, user_id: int, level: int):
        self.card_id = card_id
        self.user_id = user_id
        self.access_level = level
        self.created_at = datetime.now()
        self.active = True
        self.last_used = None
    
    def revoke(self):
        """Отозвать карточку (при увольнении)"""
        self.active = False
        self.revoked_at = datetime.now()
    
    def is_valid(self) -> bool:
        """Проверить, активна ли карточка"""
        return self.active

class CardIssuer:
    def issue_card(self, user_id: int, access_level: int) -> KeyCard:
        """Выдать новую карточку"""
        card = KeyCard(f"CARD_{user_id}_{datetime.now().timestamp()}", user_id, access_level)
        self.database.save(card)
        return card
    
    def revoke_card(self, card_id: str):
        """Отозвать карточку при увольнении"""
        card = self.database.get(card_id)
        card.revoke()
        self.database.update(card)
        self.log_event(f"Card {card_id} revoked")

Интеграция с IT системами

Физическая авторизация часто связана с IT системами:

class IntegratedAccessSystem:
    def user_onboarding(self, employee: dict):
        """Процесс подключения нового сотрудника"""
        # 1. Создаём в системе
        user_id = self.hr_system.create_user(employee)
        
        # 2. Выдаём карточку
        card = self.physical_access.issue_card(user_id, access_level=2)
        
        # 3. Выдаём ноутбук
        laptop = self.it_system.provision_device(user_id)
        
        # 4. Добавляем в группы безопасности
        self.network.add_to_group(user_id, 'employees')
        
        return {
            'card_id': card.card_id,
            'device': laptop.serial,
            'email': employee['email']
        }
    
    def user_offboarding(self, user_id: int):
        """Процесс удаления уходящего сотрудника"""
        # 1. Отзываем карточку
        self.physical_access.revoke_user_cards(user_id)
        
        # 2. Деактивируем IT доступ
        self.it_system.disable_user(user_id)
        
        # 3. Блокируем в сети
        self.network.remove_from_all_groups(user_id)
        
        # 4. Регистрируем событие
        self.log_event(f"User {user_id} offboarded")

Безопасность и аудит

Критические практики:

class SecurityAudit:
    def check_access_anomalies(self):
        """Проверяет подозрительные паттерны"""
        # Доступ вне рабочего времени
        after_hours = self.get_logs(after_hours=True)
        
        # Доступ в выходной день
        weekend_access = self.get_logs(day_type='weekend')
        
        # Несколько отказов подряд
        suspicious_users = self.find_repeated_denials(threshold=5)
        
        # Использование чужой карточки
        impossible_locations = self.find_impossible_moves(seconds=60)
        
        if suspicious_users or impossible_locations:
            self.alert_security_team()
    
    def generate_access_report(self, user_id: int, period_days: int = 30):
        """Генерирует отчёт по доступу"""
        logs = self.get_logs(user_id, last_n_days=period_days)
        return {
            'total_accesses': len(logs),
            'locations_visited': set(l.location for l in logs),
            'access_times': [l.timestamp for l in logs],
            'denied_attempts': sum(1 for l in logs if l.status == AccessStatus.DENIED)
        }

Связь с регуляциями

Часто подпадает под:

• GDPR — личные данные
• HIPAA — медицинские данные
• SOC 2 — безопасность
• ISO 27001 — управление информационной безопасностью

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