Версия 0.0.2

2025-06-09 14:43:25 +05:00 · 2025-06-09 14:43:25 +05:00 · 7b9c998224
commit 7b9c998224
530 changed files with 424916 additions and 0 deletions
--- a/SRV/.gitignore
+++ b/SRV/.gitignore
@ -0,0 +1,8 @@
+.venv
+.idea
+__pycache__
+.gigaide
+.vscode
+.wheels
+.vendor
+.python3-deb
--- a/SRV/README.md
+++ b/SRV/README.md
--- a/SRV/init.py
+++ b/SRV/init.py
--- a/SRV/api/init.py
+++ b/SRV/api/init.py
--- a/SRV/api/router.py
+++ b/SRV/api/router.py
@ -0,0 +1,10 @@
+from fastapi import APIRouter
+from api.v1 import ufw, websocket, ip, network, auth
+
+router = APIRouter()
+
+router.include_router(ufw.router, prefix="/ufw", tags=["UFW"])
+router.include_router(websocket.router, tags=["WebSocket"])
+router.include_router(ip.router, prefix="/ip", tags=["IP"])
+router.include_router(network.router, prefix="/network", tags=["Network"])
+router.include_router(auth.router, prefix="/auth", tags=["Auth"])
--- a/SRV/api/v1/init.py
+++ b/SRV/api/v1/init.py
--- a/SRV/api/v1/auth.py
+++ b/SRV/api/v1/auth.py
@ -0,0 +1,114 @@
+# api/v1/auth.py
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.security import OAuth2PasswordBearer
+from services.auth_service import AuthService
+from models.auth import UserCreate, UserLogin, UserResponse, Token
+from storage.json_storage import JsonStorage
+import logging
+import os
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+auth_service = AuthService()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
+
+
+@router.post("/register", response_model=UserResponse)
+async def register(user: UserCreate):
+    """Регистрирует нового пользователя"""
+    try:
+        db_user = auth_service.register(user)
+        logger.info(f"Пользователь {user.username} успешно зарегистрирован")
+        return db_user
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Ошибка в register: {type(e).__name__} - {str(e)}")
+        raise HTTPException(status_code=500, detail="Не удалось зарегистрировать пользователя")
+
+
+@router.post("/login", response_model=Token)
+async def login(user: UserLogin, request: Request):
+    """Авторизует пользователя и создаёт сессию"""
+    try:
+        client_id = request.client.host
+        logger.debug(f"Попытка авторизации для client_id {client_id}")
+        result = auth_service.login(user, client_id)
+        logger.info(f"Успешная авторизация для client_id {client_id}, session_id: {result['session_id']}")
+        return result
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Ошибка в login: {type(e).__name__} - {str(e)}")
+        raise HTTPException(status_code=500, detail="Не удалось авторизовать пользователя")
+
+
+@router.get("/me")
+async def get_current_user(request: Request):
+    """Возвращает данные текущего пользователя и токен"""
+    try:
+        client_id = request.client.host
+        logger.debug(f"Запрос /me для client_id {client_id}")
+        result = auth_service.get_user_by_session(client_id)
+        return {
+            "user": result["user"],
+            "access_token": result["access_token"],
+            "token_type": "bearer"
+        }
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Ошибка в get_current_user: {type(e).__name__} - {str(e)}")
+        raise HTTPException(status_code=500, detail="Не удалось получить данные пользователя")
+
+
+@router.get("/logout")
+async def logout(request: Request):
+    """Выход из системы, удаление сессии"""
+    try:
+        client_id = request.client.host
+        logger.debug(f"Запрос logout для client_id {client_id}")
+        return auth_service.logout(client_id)
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Ошибка в logout: {type(e).__name__} - {str(e)}")
+        raise HTTPException(status_code=500, detail="Не удалось выйти из системы")
+
+
+@router.get("/check_json")
+async def check_users_file():
+    """Проверяет, существует ли файл users.json и содержит ли он пользователей"""
+    try:
+        file_path = "/etc/gonets/users.json"
+        storage = JsonStorage(file_path=file_path)
+
+        if not os.path.exists(file_path):
+            logger.info(f"Файл {file_path} не существует")
+            return {
+                "exists": False,
+                "has_users": False,
+                "message": "Файл users.json не существует"
+            }
+
+        data = storage._read_data()
+        has_users = len(data.get("users", [])) > 0
+        if has_users:
+            logger.info(f"Файл {file_path} существует и содержит пользователей")
+            return {
+                "exists": True,
+                "has_users": True,
+                "message": "Файл users.json существует и содержит пользователей"
+            }
+        else:
+            logger.info(f"Файл {file_path} существует, но не содержит пользователей")
+            return {
+                "exists": True,
+                "has_users": False,
+                "message": "Файл users.json существует, но не содержит пользователей"
+            }
+    except Exception as e:
+        logger.error(f"Ошибка при проверке файла users.json: {type(e).__name__} - {str(e)}")
+        raise HTTPException(status_code=500, detail="Ошибка при проверке файла")
--- a/SRV/api/v1/firewalld.py
+++ b/SRV/api/v1/firewalld.py
@ -0,0 +1,449 @@
+from typing import List
+
+from fastapi import APIRouter, Body, HTTPException, Path, status
+from pydantic import BaseModel, Field
+
+from models.firewalld import (
+    FirewallPort,
+    FirewallService,
+    FirewallSource,
+    FirewallTarget,
+    FirewallZone,
+)
+from services.firewalld_service import FirewalldService
+
+router = APIRouter()
+firewalld = FirewalldService()
+
+
+class ErrorResponse(BaseModel):
+    """Standard error response model"""
+
+    detail: str = Field(..., description="Error description")
+
+
+class SuccessResponse(BaseModel):
+    """Standard success response model"""
+
+    message: str = Field(..., description="Success message")
+
+
+@router.get(
+    "/zones",
+    response_model=List[str],
+    responses={500: {"model": ErrorResponse}},
+    summary="Get all available zones",
+)
+async def get_zones() -> List[str]:
+    """
+    Retrieve all available firewalld zones.
+
+    Returns:
+        List[str]: List of zone names
+    """
+    try:
+        return firewalld.get_zones()
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get zones: {str(e)}",
+        )
+
+
+@router.get(
+    "/zones/default",
+    response_model=str,
+    responses={500: {"model": ErrorResponse}},
+    summary="Get default zone",
+)
+async def get_default_zone() -> str:
+    """
+    Get the current default zone.
+
+    Returns:
+        str: Name of the default zone
+    """
+    try:
+        return firewalld.get_default_zone()
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get default zone: {str(e)}",
+        )
+
+
+@router.put(
+    "/zones/default/{zone}",
+    response_model=SuccessResponse,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Set default zone",
+)
+async def set_default_zone(
+    zone: str = Path(..., description="Zone name to set as default"),
+) -> SuccessResponse:
+    """
+    Set the default zone.
+
+    Args:
+        zone (str): Name of the zone to set as default
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.set_default_zone(zone)
+        return SuccessResponse(message=f"Default zone set to {zone}")
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Zone '{zone}' not found"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to set default zone: {str(e)}",
+        )
+
+
+@router.get(
+    "/zones/{zone}",
+    response_model=FirewallZone,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Get zone configuration",
+)
+async def get_zone(zone: str = Path(..., description="Zone name")) -> FirewallZone:
+    """
+    Get detailed configuration for a specific zone.
+
+    Args:
+        zone (str): Name of the zone
+
+    Returns:
+        FirewallZone: Zone configuration details
+    """
+    try:
+        zone_info = firewalld.get_zone_settings(zone)
+        return FirewallZone(
+            name=zone,
+            target=FirewallTarget.DEFAULT,
+            interfaces=[],
+            **zone_info
+        )
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Zone '{zone}' not found"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get zone settings: {str(e)}",
+        )
+
+
+@router.get(
+    "/zones/{zone}/services",
+    response_model=List[str],
+    responses={500: {"model": ErrorResponse}},
+    summary="Get services in zone",
+)
+async def get_services(zone: str = Path(..., description="Zone name")) -> List[str]:
+    """
+    Get all services in a zone.
+
+    Args:
+        zone (str): Name of the zone
+
+    Returns:
+        List[str]: List of service names
+    """
+    try:
+        return firewalld.get_services(zone)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get services: {str(e)}",
+        )
+
+
+@router.post(
+    "/zones/{zone}/services",
+    response_model=SuccessResponse,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Add service to zone",
+)
+async def add_service(
+    zone: str = Path(..., description="Zone name"),
+    rule: FirewallService = Body(..., description="Service configuration"),
+) -> SuccessResponse:
+    """
+    Add a service to a zone.
+
+    Args:
+        zone (str): Name of the zone
+        rule (FirewallService): Service configuration including service name and optional timeout
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.add_service(zone, rule.name, rule.timeout)
+        return SuccessResponse(message=f"Service {rule.name} added to zone {zone}")
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Zone '{zone}' not found"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add service: {str(e)}",
+        )
+
+
+@router.delete(
+    "/zones/{zone}/services/{service}",
+    response_model=SuccessResponse,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Remove service from zone",
+)
+async def remove_service(
+    zone: str = Path(..., description="Zone name"),
+    service: str = Path(..., description="Service name"),
+) -> SuccessResponse:
+    """
+    Remove a service from a zone.
+
+    Args:
+        zone (str): Name of the zone
+        service (str): Name of the service
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.remove_service(zone, service)
+        return SuccessResponse(message=f"Service {service} removed from zone {zone}")
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Zone '{zone}' or service '{service}' not found",
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to remove service: {str(e)}",
+        )
+
+
+@router.get(
+    "/zones/{zone}/ports",
+    response_model=List[str],
+    responses={500: {"model": ErrorResponse}},
+    summary="Get ports in zone",
+)
+async def get_ports(zone: str = Path(..., description="Zone name")) -> List[str]:
+    """
+    Get all ports in a zone.
+
+    Args:
+        zone (str): Name of the zone
+
+    Returns:
+        List[str]: List of port configurations
+    """
+    try:
+        return firewalld.get_ports(zone)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get ports: {str(e)}",
+        )
+
+
+@router.post(
+    "/zones/{zone}/ports",
+    response_model=SuccessResponse,
+    responses={
+        400: {"model": ErrorResponse},
+        404: {"model": ErrorResponse},
+        500: {"model": ErrorResponse},
+    },
+    summary="Add port to zone",
+)
+async def add_port(
+    zone: str = Path(..., description="Zone name"),
+    rule: FirewallPort = Body(..., description="Port configuration"),
+) -> SuccessResponse:
+    """
+    Add a port to a zone.
+
+    Args:
+        zone (str): Name of the zone
+        rule (FirewallPort): Port configuration including port number, protocol and optional timeout
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.add_port(zone, rule.port, rule.protocol.value, rule.timeout)
+        return SuccessResponse(
+            message=f"Port {rule.port}/{rule.protocol.value} added to zone {zone}"
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add port: {str(e)}",
+        )
+
+
+@router.delete(
+    "/zones/{zone}/ports",
+    response_model=SuccessResponse,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Remove port from zone",
+)
+async def remove_port(
+    zone: str = Path(..., description="Zone name"),
+    rule: FirewallPort = Body(..., description="Port configuration"),
+) -> SuccessResponse:
+    """
+    Remove a port from a zone.
+
+    Args:
+        zone (str): Name of the zone
+        rule (FirewallPort): Port configuration including port number and protocol
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.remove_port(zone, rule.port, rule.protocol.value)
+        return SuccessResponse(
+            message=f"Port {rule.port}/{rule.protocol.value} removed from zone {zone}"
+        )
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Zone '{zone}' not found"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to remove port: {str(e)}",
+        )
+
+
+@router.get(
+    "/zones/{zone}/sources",
+    response_model=List[str],
+    responses={500: {"model": ErrorResponse}},
+    summary="Get sources in zone",
+)
+async def get_sources(zone: str = Path(..., description="Zone name")) -> List[str]:
+    """
+    Get all sources in a zone.
+
+    Args:
+        zone (str): Name of the zone
+
+    Returns:
+        List[str]: List of source addresses
+    """
+    try:
+        return firewalld.get_sources(zone)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get sources: {str(e)}",
+        )
+
+
+@router.post(
+    "/zones/{zone}/sources",
+    response_model=SuccessResponse,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Add source to zone",
+)
+async def add_source(
+    zone: str = Path(..., description="Zone name"),
+    rule: FirewallSource = Body(..., description="Source configuration"),
+) -> SuccessResponse:
+    """
+    Add a source to a zone.
+
+    Args:
+        zone (str): Name of the zone
+        rule (FirewallSource): Source configuration including source address
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.add_source(zone, rule.address)
+        return SuccessResponse(message=f"Source {rule.address} added to zone {zone}")
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"Zone '{zone}' not found"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add source: {str(e)}",
+        )
+
+
+@router.delete(
+    "/zones/{zone}/sources/{source}",
+    response_model=SuccessResponse,
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+    summary="Remove source from zone",
+)
+async def remove_source(
+    zone: str = Path(..., description="Zone name"),
+    source: str = Path(..., description="Source address"),
+) -> SuccessResponse:
+    """
+    Remove a source from a zone.
+
+    Args:
+        zone (str): Name of the zone
+        source (str): Source address
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.remove_source(zone, source)
+        return SuccessResponse(message=f"Source {source} removed from zone {zone}")
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Zone '{zone}' or source '{source}' not found",
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to remove source: {str(e)}",
+        )
+
+
+@router.post(
+    "/reload",
+    response_model=SuccessResponse,
+    responses={500: {"model": ErrorResponse}},
+    summary="Reload firewall rules",
+)
+async def reload_firewall() -> SuccessResponse:
+    """
+    Reload firewall rules.
+
+    Returns:
+        SuccessResponse: Success confirmation message
+    """
+    try:
+        firewalld.reload()
+        return SuccessResponse(message="Firewall rules reloaded successfully")
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to reload firewall rules: {str(e)}",
+        )
--- a/SRV/api/v1/ip.py
+++ b/SRV/api/v1/ip.py
@ -0,0 +1,37 @@
+from typing import Dict, Any
+from fastapi import APIRouter, Body, HTTPException
+from services.ip_service import IPService
+
+router = APIRouter()
+ip_service = IPService()
+
+@router.post("/check_ip")
+async def check_ip_config(data: Dict[str, Any] = Body(...)):
+    """ Проверяет доступность IP-адреса """
+    try:
+        result = await ip_service.check_ip_config(data)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Ошибка проверки IP конфигурации: {str(e)}")
+
+@router.post("/apply_ip")
+async def apply_ip_config(data: Dict[str, Any] = Body(...)):
+    """ Применяет проверенные IP-настройки """
+    try:
+        await ip_service.apply_ip_config(data)
+        return {"success": True, "message": f"Настройки сетевого профиля для {data['connection_id']} применены"}
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Ошибка проверки IP конфигурации: {str(e)}")
+
+@router.post("/save_ip")
+async def save_ip_config(data: Dict[str, Any] = Body(...)):
+    """ Применяет проверенные IP-настройки (Нужен для того, чтобы откатить настройки сетевого профиля обратно) """
+    try:
+        await ip_service.apply_ip_config(data)
+        return {"success": True, "message": f"Настройки сетевого профиля для {data['connection_id']} применены"}
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Ошибка проверки IP конфигурации: {str(e)}")
--- a/SRV/api/v1/network.py
+++ b/SRV/api/v1/network.py
@ -0,0 +1,128 @@
+from fastapi import APIRouter, Body, HTTPException
+import logging
+from typing import Dict, Tuple, List, Union
+
+from services.network_service import NetworkService
+from models.network import NetworkInterfacesContainer, Activation, Deactivation, NetworkInterface, WiFiDevice
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+network_service = NetworkService()
+
+
+class ContainerPositionManager:
+    """
+    Класс для управления позициями и состоянием контейнеров
+    """
+
+    def __init__(self):
+        self.positions: Dict[str, Dict[str, Union[int, bool]]] = {
+            'activation': {'x': 0, 'y': 0, 'isOpen': False},
+            'deactivation': {'x': 0, 'y': 0, 'isOpen': False}
+        }
+
+    def get_position_and_state(self, container_name: str) -> Tuple[int, int, bool]:
+        container = self.positions.get(container_name)
+        if not container:
+            raise ValueError(f"Неверное имя контейнера: {container_name}")
+        return container['x'], container['y'], container['isOpen']
+
+    def update_position(self, container_id: int, x: int, y: int, isOpen: bool) -> None:
+        container_name = 'activation' if container_id == 1 else 'deactivation'
+        self.positions[container_name] = {'x': x, 'y': y, 'isOpen': isOpen}
+
+
+container_manager = ContainerPositionManager()
+
+
+async def get_network_data() -> Dict[str, Dict]:
+    """
+    Возвращает текущие сетевые данные в виде словаря
+    """
+    logger.debug("Вызов get_network_data()")
+    try:
+        network_data = await network_service.get_network_interfaces_container()
+
+        activation_interfaces, deactivation_interfaces = _split_interfaces(network_data.interfaces)
+
+        activation_x, activation_y, activation_is_open = container_manager.get_position_and_state('activation')
+        deactivation_x, deactivation_y, deactivation_is_open = container_manager.get_position_and_state('deactivation')
+
+        activation = Activation(
+            id=1,
+            interfaces=activation_interfaces,
+            container_x=activation_x,
+            container_y=activation_y,
+            isOpen=activation_is_open
+        )
+        deactivation = Deactivation(
+            id=2,
+            interfaces=deactivation_interfaces,
+            container_x=deactivation_x,
+            container_y=deactivation_y,
+            isOpen=deactivation_is_open
+        )
+
+        return {
+            "activation": activation.model_dump(),
+            "deactivation": deactivation.model_dump()
+        }
+    except Exception as e:
+        logger.error(f"Ошибка в get_network_data: {e}")
+        raise HTTPException(status_code=500, detail="Не удалось получить сетевые данные")
+
+
+def _split_interfaces(interfaces: List[Union[NetworkInterface, WiFiDevice]]) -> Tuple[
+    List[Union[NetworkInterface, WiFiDevice]], List[Union[NetworkInterface, WiFiDevice]]]:
+    """
+    Разделяет интерфейсы на активные и неактивные
+    """
+    activation_interfaces = []
+    deactivation_interfaces = []
+    for interface in interfaces:
+        if interface.device_state == '100':
+            activation_interfaces.append(interface)
+        else:
+            deactivation_interfaces.append(interface)
+    return activation_interfaces, deactivation_interfaces
+
+
+@router.post("/update_container_position")
+async def update_container_position(data: Dict[str, Union[int, bool]] = Body(...)):
+    """
+    Обновляет позицию и состояние контейнера
+    """
+    try:
+
+        required_keys = ["container_id", "container_x", "container_y", "isOpen"]
+        if not all(key in data for key in required_keys):
+            raise ValueError("Отсутствуют обязательные поля: container_id, container_x, container_y, isOpen")
+
+        container_id = data["container_id"]
+        container_x = data["container_x"]
+        container_y = data["container_y"]
+        is_open = data["isOpen"]
+
+        # Проверка типов
+        if not isinstance(container_id, int) or not isinstance(container_x, int) or not isinstance(container_y,
+                                                                                                   int) or not isinstance(
+                is_open, bool):
+            raise ValueError("Неверный тип данных в запросе")
+
+        container_manager.update_position(container_id, container_x, container_y, is_open)
+        return {"success": True, "message": "Позиция и состояние контейнера обновлены"}
+    except Exception as e:
+        logger.error(f"Ошибка обновления позиции контейнера: {e}")
+        raise HTTPException(status_code=400, detail=f"Не удалось обновить положение контейнера: {str(e)}")
+
+
+@router.get("/get_hostname")
+async def get_hostname():
+    try:
+        hostname_info = await network_service.get_hostname()
+        return hostname_info
+    except Exception as e:
+        logger.error(f"Ошибка в get_hostname: {e}")
+        raise HTTPException(status_code=500, detail="Не удалось получить имя хоста")
--- a/SRV/api/v1/ufw.py
+++ b/SRV/api/v1/ufw.py
@ -0,0 +1,133 @@
+from fastapi import APIRouter, HTTPException
+from services.ufw_service import UFWService
+from models.ufw import UFWRulesResponse, UFWStatus, UFWRule
+from typing import List
+from pydantic import BaseModel, Field
+
+router = APIRouter()
+
+class RuleNumbers(BaseModel):
+    numbers: List[int] = Field(..., description="Список номеров правил для удаления")
+
+@router.get("/rules", response_model=UFWRulesResponse)
+async def get_ufw_rules():
+    """
+    Получает все правила UFW с помощью сервиса UFWService и возвращает их в формате JSON.
+    """
+    ufw_service = UFWService()
+    try:
+        return ufw_service.get_ufw_rules()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+@router.get("/status", response_model=UFWStatus)
+async def get_ufw_status():
+    """
+    Получает текущий статус UFW.
+    """
+    ufw_service = UFWService()
+    try:
+        return ufw_service.get_ufw_status()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+@router.post("/enable")
+async def enable_ufw():
+    """
+    Включает UFW.
+    """
+    ufw_service = UFWService()
+    try:
+        success = ufw_service.enable_ufw()
+        if success:
+            return {"status": "success", "message": "UFW успешно включен"}
+        else:
+            raise HTTPException(status_code=500, detail="Не удалось включить UFW")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+@router.post("/disable")
+async def disable_ufw():
+    """
+    Выключает UFW.
+    """
+    ufw_service = UFWService()
+    try:
+        success = ufw_service.disable_ufw()
+        if success:
+            return {"status": "success", "message": "UFW успешно выключен"}
+        else:
+            raise HTTPException(status_code=500, detail="Не удалось выключить UFW")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+@router.post("/rules/in")
+async def add_ufw_in_rules(rules: List[UFWRule]):
+    """
+    Добавляет входящие (in) правила UFW.
+    """
+    ufw_service = UFWService()
+    try:
+        # Проверяем статус UFW
+        status = ufw_service.get_ufw_status()
+        if not status.enabled:
+            raise HTTPException(
+                status_code=400,
+                detail="UFW отключен. Включите UFW перед добавлением правил."
+            )
+            
+        result = ufw_service.add_rules(rules)
+        if result["success"]:
+            successful_rules = len([r for r in result["results"] if r["success"]])
+            total_rules = len(result["results"])
+            return {
+                "status": "success",
+                "message": f"Добавлено {successful_rules} из {total_rules} правил",
+                "details": result
+            }
+        else:
+            raise HTTPException(status_code=500, detail=result.get("error", "Не удалось добавить правила"))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+@router.post("/rules/out")
+async def add_ufw_out_rules(rules: List[UFWRule]):
+    """
+    Добавляет исходящие (out) правила UFW.
+    """
+    ufw_service = UFWService()
+    try:
+        # Проверяем статус UFW
+        status = ufw_service.get_ufw_status()
+        if not status.enabled:
+            raise HTTPException(
+                status_code=400,
+                detail="UFW отключен. Включите UFW перед добавлением правил."
+            )
+            
+        success = ufw_service.add_ufw_out_rules(rules)
+        if success:
+            return {"status": "success", "message": "Исходящие правила UFW успешно добавлены"}
+        else:
+            raise HTTPException(status_code=500, detail="Не удалось добавить исходящие правила UFW")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+@router.delete("/rules")
+async def delete_ufw_rules(rule_numbers: RuleNumbers):
+    """
+    Удаляет правила UFW по их номерам.
+    """
+    ufw_service = UFWService()
+    try:
+        result = ufw_service.delete_rules(rule_numbers.numbers)
+        if result["success"]:
+            return {
+                "status": "success",
+                "message": f"Удалено {result['successful']} из {result['total']} правил",
+                "details": result
+            }
+        else:
+            raise HTTPException(status_code=500, detail=result["error"])
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
--- a/SRV/api/v1/websocket.py
+++ b/SRV/api/v1/websocket.py
@ -0,0 +1,90 @@
+import asyncio
+import logging
+from typing import Set
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from starlette.websockets import WebSocketState
+
+from .network import update_container_position, get_network_data
+
+router = APIRouter()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class WebSocketManager:
+    """
+    Класс для управления подключениями к WebSocket-серверу
+    """
+    def __init__(self):
+        """ Инициализация менеджера подключений к WebSocket-серверу """
+        self.active_connections: Set[WebSocket] = set()
+
+    async def connect(self, websocket: WebSocket):
+        """ Подключение клиента к WebSocket-серверу """
+        await websocket.accept()
+        self.active_connections.add(websocket)
+
+    def disconnect(self, websocket: WebSocket):
+        """ Отключение клиента от WebSocket-серверу """
+        self.active_connections.remove(websocket)
+
+    async def broadcast(self, message: dict):
+        """ Трансляция сообщений всем подключенным клиентам """
+        for connection in list(self.active_connections):
+            try:
+                if connection.client_state == WebSocketState.CONNECTED:
+                    await connection.send_json(message)
+            except WebSocketDisconnect:
+                self.disconnect(connection)
+            except Exception as e:
+                logger.error(f"Сообщение об ошибке трансляции: {e}")
+                self.disconnect(connection)
+
+manager = WebSocketManager()
+
+@router.websocket("/api/v1")
+async def websocket_endpoint(websocket: WebSocket):
+    """ Обработчик WebSocket-соединения """
+    await manager.connect(websocket)
+    try:
+        while True:
+            data = await websocket.receive_json()
+            logger.info(f"Полученные данные: {data}")
+
+            if all(key in data for key in ["container_id", "container_x", "container_y"]):
+                await update_container_position(data)
+
+            network_data = await get_network_data()
+            logger.info(f"Текущие сетевые данные: {network_data}")
+
+            await manager.broadcast(network_data)
+            await asyncio.sleep(2)
+    except WebSocketDisconnect:
+        logger.info("Клиент отключен")
+    except Exception as e:
+        logger.error(f"Ошибка в websocket_endpoint:{e}")
+    finally:
+        manager.disconnect(websocket)
+        if websocket.client_state != WebSocketState.DISCONNECTED:
+            await websocket.close()
+
+@router.on_event("startup")
+async def startup_event():
+    """ Запуск таска для трансляции сетевых данных """
+    asyncio.create_task(broadcast_data())
+
+async def broadcast_data():
+    """ Таск для трансляции сетевых данных """
+    while True:
+        try:
+            network_data = await get_network_data()
+            if "activation" not in network_data:
+                logger.error("Ошибка: Ключ 'activation' отсутствует в полученных данных сети")
+                await asyncio.sleep(2)
+                continue
+
+            await manager.broadcast(network_data)
+        except Exception as e:
+            logger.error(f"Ошибка в broadcast_data:{e}")
+        await asyncio.sleep(2)
--- a/SRV/config/cors.py
+++ b/SRV/config/cors.py
@ -0,0 +1,29 @@
+from fastapi import FastAPI
+from starlette.middleware.cors import CORSMiddleware
+
+
+class CORSMiddlewareConfig:
+    """
+    Класс для настройки CORS политики в FastAPI
+    """
+    def __init__(self, app: FastAPI) -> None:
+        """ Инициализируем приложение FastAPI и список допустимых CORS-оригинов """
+        self.app = app
+        self.origins = [
+            "http://localhost.tiangolo.com",
+            "https://localhost.tiangolo.com",
+            "http://localhost",
+            "http://localhost:8080",
+            "http://localhost:5174",
+            "http://localhost:5173",
+        ]
+
+    def add_cors_middleware(self) -> None:
+        """ Добавляем CORS в приложение FastAPI """
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=self.origins,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
--- a/SRV/config/init_config.py
+++ b/SRV/config/init_config.py
@ -0,0 +1,35 @@
+# init_config.py
+import configparser
+import os
+import secrets
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def init_config():
+    """Создаёт конфигурационный файл с SECRET_KEY"""
+    config_path = "/etc/gonets/config.ini"
+    config_dir = os.path.dirname(config_path)
+
+    if os.path.exists(config_path):
+        logger.info(f"Конфигурационный файл {config_path} уже существует, пропускаем инициализацию")
+        return
+
+    try:
+        secret_key = secrets.token_urlsafe(32)
+        os.makedirs(config_dir, exist_ok=True)
+        config = configparser.ConfigParser()
+        config["JWT"] = {
+            "secret_key": secret_key
+        }
+        with open(config_path, "w") as config_file:
+            config.write(config_file)
+        os.chmod(config_path, 0o600)
+        logger.info(f"Создан конфигурационный файл {config_path}")
+    except Exception as e:
+        logger.error(f"Ошибка при создании конфигурационного файла: {type(e).__name__} - {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    init_config()
--- a/SRV/core/init.py
+++ b/SRV/core/init.py
--- a/SRV/core/cli_executor.py
+++ b/SRV/core/cli_executor.py
@ -0,0 +1,25 @@
+import subprocess
+from typing import Tuple
+
+class CLIExecutor:
+    """
+    Класс для выполнения CLI-команд
+    """
+    @staticmethod
+    def run(command: list) -> Tuple[int, str]:
+        """
+        Выполняет команду в системе и возвращает код и вывод.
+
+        Args:
+            command (list): Список аргументов команды для выполнения.
+
+        Returns:
+            tuple: Код возврата и вывод команды.
+        """
+        result = subprocess.run(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False  # Не вызываем исключение при ошибке
+        )
+        return result.returncode, result.stdout.decode('utf-8')
--- a/SRV/docs/firewalld.md
+++ b/SRV/docs/firewalld.md
@ -0,0 +1,276 @@
+# Документация API FirewallD
+
+## Общее описание
+API предоставляет интерфейс для управления межсетевым экраном FirewallD в Linux системах. API построено на основе взаимодействия с FirewallD через D-Bus интерфейс.
+
+## Внутренняя архитектура
+
+### 1. Уровни взаимодействия
+```
+[HTTP API] -> [FastAPI Router] -> [FirewallD Service] -> [D-Bus] -> [FirewallD]
+```
+
+### 2. Компоненты системы
+
+#### 2.1 D-Bus интерфейс
+FirewallD предоставляет D-Bus интерфейс `org.fedoraproject.FirewallD1` для управления. Наш сервис подключается к системной шине D-Bus и взаимодействует с FirewallD через этот интерфейс.
+
+Основные методы D-Bus:
+- `getZones()` - получение списка зон
+- `getDefaultZone()` - получение зоны по умолчанию
+- `addService()` - добавление сервиса
+- `removeService()` - удаление сервиса
+и т.д.
+
+#### 2.2 Модели данных
+В `models/firewalld.py` определены Pydantic модели для валидации данных:
+
+##### FirewallZone
+Используется для представления зоны файрвола:
+```python
+class FirewallZone(BaseModel):
+    name: str
+    target: Optional[str] = None
+    services: List[str] = Field(default_factory=list)
+    ports: List[str] = Field(default_factory=list)
+    sources: List[str] = Field(default_factory=list)
+    interfaces: List[str] = Field(default_factory=list)
+```
+Применяется при получении настроек зоны через API.
+
+##### FirewallService
+Модель для конфигурации сервиса:
+```python
+class FirewallService(BaseModel):
+    name: str
+    ports: List[str] = Field(default_factory=list)
+    protocols: List[str] = Field(default_factory=list)
+    modules: List[str] = Field(default_factory=list)
+```
+Используется при добавлении новых сервисов через API.
+
+##### FirewallPort
+Модель для конфигурации порта с валидацией протокола:
+```python
+class FirewallPort(BaseModel):
+    port: int
+    protocol: Optional[str] = Field(default=None)
+    timeout: Optional[int] = 0
+```
+Применяется в API endpoint POST /api/v1/firewalld/zones/{zone}/ports для валидации входных данных.
+
+##### FirewallSource
+Модель для конфигурации источника с валидацией IP-адреса:
+```python
+class FirewallSource(BaseModel):
+    address: str = Field(..., pattern=r'^(?:[0-9]{1,3}\.){3}[0-9]{1,3}(?:/[0-9]{1,2})?$')
+    zone: Optional[str] = None
+```
+Используется в API endpoint POST /api/v1/firewalld/zones/{zone}/sources для валидации IP-адресов.
+
+##### FirewallRule
+Обобщенная модель правила файрвола:
+```python
+class FirewallRule(BaseModel):
+    zone: str
+    source: Optional[FirewallSource] = None
+    port: Optional[FirewallPort] = None
+    service: Optional[str] = None
+```
+Используется для комплексных операций с правилами.
+
+В API (`api/v1/firewalld.py`) определены дополнительные модели для запросов:
+
+##### PortRule
+```python
+class PortRule(BaseModel):
+    port: int
+    protocol: str
+    timeout: Optional[int] = 0
+```
+Используется для валидации входных данных при добавлении портов.
+
+##### ServiceRule
+```python
+class ServiceRule(BaseModel):
+    service: str
+    timeout: Optional[int] = 0
+```
+Используется для валидации входных данных при добавлении сервисов.
+
+##### SourceRule
+```python
+class SourceRule(BaseModel):
+    source: str
+```
+Используется для валидации входных данных при добавлении источников.
+
+Все модели используют Pydantic для:
+- Валидации входных данных
+- Автоматической конвертации типов
+- Генерации OpenAPI документации
+- Проверки бизнес-правил (например, валидация протокола в FirewallPort)
+
+#### 2.3 Сервисный слой
+`FirewallService` в `services/firewalld_service.py` обеспечивает:
+- Подключение к D-Bus
+- Обработку ошибок
+- Преобразование данных между API и D-Bus форматами
+
+## API Endpoints
+
+### Управление зонами
+
+#### GET /api/v1/firewalld/zones
+Получение списка всех доступных зон.
+
+**Ответ:**
+```json
+[
+    "public",
+    "internal",
+    "external",
+    ...
+]
+```
+
+**Внутренняя работа:**
+1. Запрос поступает в FastAPI router
+2. Router вызывает `FirewallService.get_zones()`
+3. Сервис делает вызов `getZones()` через D-Bus
+4. Результат преобразуется в JSON и возвращается клиенту
+
+#### GET /api/v1/firewalld/zones/default
+Получение зоны по умолчанию.
+
+**Ответ:**
+```json
+{
+    "name": "public"
+}
+```
+
+**Внутренняя работа:**
+1. Вызов `FirewallService.get_default_zone()`
+2. D-Bus запрос `getDefaultZone()`
+3. Преобразование результата
+
+#### PUT /api/v1/firewalld/zones/default/{zone}
+Установка зоны по умолчанию.
+
+**Параметры:**
+- `zone`: имя зоны
+
+**Внутренняя работа:**
+1. Валидация имени зоны
+2. Вызов `FirewallService.set_default_zone()`
+3. D-Bus запрос `setDefaultZone()`
+
+### Управление сервисами
+
+#### GET /api/v1/firewalld/zones/{zone}/services
+Получение списка сервисов в зоне.
+
+**Ответ:**
+```json
+{
+    "services": ["http", "https", "ssh"]
+}
+```
+
+**Внутренняя работа:**
+1. Проверка существования зоны
+2. Вызов `FirewallService.get_services()`
+3. D-Bus запрос `getServices()`
+
+#### POST /api/v1/firewalld/zones/{zone}/services
+Добавление сервиса в зону.
+
+**Тело запроса:**
+```json
+{
+    "service": "http",
+    "timeout": 0
+}
+```
+
+**Внутренняя работа:**
+1. Валидация данных через Pydantic модель
+2. Вызов `FirewallService.add_service()`
+3. D-Bus запрос `addService()`
+
+#### DELETE /api/v1/firewalld/zones/{zone}/services/{service}
+Удаление сервиса из зоны.
+
+**Внутренняя работа:**
+1. Проверка существования сервиса
+2. Вызов `FirewallService.remove_service()`
+3. D-Bus запрос `removeService()`
+
+### Управление портами
+
+#### GET /api/v1/firewalld/zones/{zone}/ports
+Получение списка портов в зоне.
+
+**Ответ:**
+```json
+{
+    "ports": ["80/tcp", "443/tcp"]
+}
+```
+
+#### POST /api/v1/firewalld/zones/{zone}/ports
+Добавление порта в зону.
+
+**Тело запроса:**
+```json
+{
+    "port": 80,
+    "protocol": "tcp",
+    "timeout": 0
+}
+```
+
+#### DELETE /api/v1/firewalld/zones/{zone}/ports
+Удаление порта из зоны.
+
+### Управление источниками
+
+#### GET /api/v1/firewalld/zones/{zone}/sources
+Получение списка источников в зоне.
+
+#### POST /api/v1/firewalld/zones/{zone}/sources
+Добавление источника в зону.
+
+#### DELETE /api/v1/firewalld/zones/{zone}/sources/{source}
+Удаление источника из зоны.
+
+## Обработка ошибок
+
+API возвращает следующие коды ошибок:
+- 400: Неверный запрос (например, неверный формат данных)
+- 404: Ресурс не найден (зона, сервис и т.д.)
+- 500: Внутренняя ошибка сервера
+
+При ошибке D-Bus или FirewallD, ошибка логируется и возвращается соответствующий HTTP код.
+
+## Возможные улучшения
+
+1. **Безопасность:**
+   - Добавить аутентификацию
+   - Добавить rate limiting
+   - Логирование действий
+
+2. **Функциональность:**
+   - Добавить поддержку rich rules
+   - Управление ICMP правилами
+   - Управление forward портами
+
+3. **Производительность:**
+   - Кэширование часто запрашиваемых данных
+   - Batch операции для множественных изменений
+
+4. **Надёжность:**
+   - Retry механизм для D-Bus операций
+   - Более детальная обработка ошибок
+   - Валидация состояния FirewallD
--- a/SRV/docs/network.md
+++ b/SRV/docs/network.md
--- a/SRV/docs/ufw.md
+++ b/SRV/docs/ufw.md
@ -0,0 +1,208 @@
+# UFW API Documentation
+
+## Overview
+
+API для управления файрволом UFW (Uncomplicated Firewall) в Linux. Позволяет добавлять, удалять и просматривать правила межсетевого экрана.
+
+## Архитектура
+
+### Модели данных
+
+#### Protocol (Протокол)
+```python
+class Protocol(str, Enum):
+    TCP = "tcp"    # Только TCP протокол
+    UDP = "udp"    # Только UDP протокол
+    BOTH = "both"  # Оба протокола (TCP и UDP)
+```
+
+При указании `BOTH`, система автоматически создает правила для обоих протоколов, используя `proto tcp/udp` в команде UFW.
+
+#### Action (Действие)
+```python
+class Action(str, Enum):
+    ALLOW = "allow"   # Разрешить трафик
+    DENY = "deny"     # Запретить трафик без уведомления
+    REJECT = "reject" # Запретить трафик с уведомлением отправителю
+```
+
+#### Direction (Направление)
+```python
+class Direction(str, Enum):
+    IN = "in"     # Входящий трафик
+    OUT = "out"   # Исходящий трафик
+```
+
+#### UFWRule (Правило UFW)
+```python
+class UFWRule(BaseModel):
+    action: Action           # Действие (allow/deny/reject)
+    direction: Direction     # Направление трафика (in/out)
+    from_ip: str            # IP-адрес источника
+    to_ip: str              # IP-адрес назначения
+    port: Union[int, str]   # Порт или диапазон портов
+    protocol: Protocol      # Протокол
+    comment: Optional[str]  # Комментарий к правилу
+```
+
+Модель выполняет следующие проверки:
+1. Валидация IP адресов:
+   - Проверяет корректность IPv4/IPv6 адресов
+   - Поддерживает CIDR нотацию
+   - Проверяет совместимость версий IP (IPv4/IPv6)
+
+2. Валидация портов:
+   - Одиночный порт: число от 1 до 65535
+   - Диапазон портов: строка вида "3000:4000"
+   - Проверяет корректность диапазона (start <= end)
+
+## API Endpoints
+
+### Получение правил
+
+#### GET /ufw/rules
+Получает список всех правил UFW.
+
+**Response:**
+```json
+{
+    "enabled": true,
+    "rules": [
+        {
+            "action": "allow",
+            "direction": "in",
+            "from_ip": "0.0.0.0/0",
+            "to_ip": "0.0.0.0/0",
+            "port": 80,
+            "protocol": "tcp",
+            "comment": "Allow HTTP"
+        }
+    ]
+}
+```
+
+### Добавление правил
+
+#### POST /ufw/rules/in
+Добавляет входящие правила UFW.
+
+**Request:**
+```json
+{
+    "rules": [
+        {
+            "action": "allow",
+            "from_ip": "0.0.0.0/0",
+            "to_ip": "0.0.0.0/0",
+            "port": 80,
+            "protocol": "tcp",
+            "comment": "Allow HTTP"
+        }
+    ]
+}
+```
+
+**Response:**
+```json
+{
+    "status": "success",
+    "message": "Входящие правила UFW успешно добавлены"
+}
+```
+
+#### POST /ufw/rules/out
+Добавляет исходящие правила UFW.
+
+**Request:**
+```json
+{
+    "rules": [
+        {
+            "action": "allow",
+            "from_ip": "192.168.1.0/24",
+            "to_ip": "0.0.0.0/0",
+            "port": 443,
+            "protocol": "tcp",
+            "comment": "Allow HTTPS outbound"
+        }
+    ]
+}
+```
+
+**Response:**
+```json
+{
+    "status": "success",
+    "message": "Исходящие правила UFW успешно добавлены"
+}
+```
+
+### Удаление правил
+
+#### DELETE /ufw/rules
+Удаляет правила UFW по их номерам.
+
+**Request:**
+```json
+{
+    "numbers": [1, 2, 3]
+}
+```
+
+**Response:**
+```json
+{
+    "status": "success",
+    "message": "Правила UFW успешно удалены"
+}
+```
+
+### Управление состоянием
+
+#### POST /ufw/enable
+Включает UFW.
+
+**Response:**
+```json
+{
+    "status": "success",
+    "message": "UFW успешно включен"
+}
+```
+
+#### POST /ufw/disable
+Выключает UFW.
+
+**Response:**
+```json
+{
+    "status": "success",
+    "message": "UFW успешно выключен"
+}
+```
+
+## Обработка ошибок
+
+### HTTP Status Codes
+
+1. Успешные операции (200):
+   - Получение списка правил
+   - Успешное добавление/удаление правил
+   - Включение/выключение UFW
+
+2. Ошибки клиента (400):
+   - UFW отключен при попытке добавления правил
+   - Некорректный IP адрес или CIDR
+   - Неверный номер порта или диапазон
+   - Несовместимые версии IP (IPv4/IPv6)
+   - Неверные значения enum (action/protocol/direction)
+
+3. Ошибки сервера (500):
+   - Ошибки выполнения команд UFW
+   - Внутренние ошибки сервера
+
+### Формат ошибок
+```json
+{
+    "detail": "Описание ошибки"
+}
--- a/SRV/gonets.service
+++ b/SRV/gonets.service
@ -0,0 +1,14 @@
+[Unit]
+Description=GONETS FastAPI Service
+After=network.target
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/usr/share/gonets
+ExecStart=/usr/bin/python3 /usr/share/gonets/SRV/main.py
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
--- a/SRV/main.py
+++ b/SRV/main.py
@ -0,0 +1,22 @@
+from fastapi import FastAPI
+import uvicorn
+from api.router import router
+from config.cors import CORSMiddlewareConfig
+from services.network_service import NetworkService
+
+app = FastAPI(
+    title="GONETS",
+    description="Панель для управления системными сервисами Linux",
+    version="0.0.2",
+)
+
+cors_config = CORSMiddlewareConfig(app)
+cors_config.add_cors_middleware()
+
+app.include_router(router)
+
+network_service = NetworkService()
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host='0.0.0.0', port=8001, reload=True, ssl_keyfile="/etc/gonets/certs/gonets.key", ssl_certfile="/etc/gonets/certs/gonets.crt")
+    #uvicorn.run("main:app", host='0.0.0.0', port=8001, reload=True)
--- a/SRV/models/init.py
+++ b/SRV/models/init.py
--- a/SRV/models/auth.py
+++ b/SRV/models/auth.py
@ -0,0 +1,23 @@
+# models.py
+from pydantic import BaseModel
+from typing import Optional
+
+class UserCreate(BaseModel):
+    username: str
+    password: str
+    is_admin: bool = False
+
+class UserLogin(BaseModel):
+    username: str
+    password: str
+
+class UserResponse(BaseModel):
+    id: int
+    username: str
+    is_admin: bool
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+    session_id: Optional[str] = None
+    user: Optional[UserResponse] = None
--- a/SRV/models/firewalld.py
+++ b/SRV/models/firewalld.py
@ -0,0 +1,115 @@
+from enum import Enum
+from typing import Annotated, List, Optional
+
+from pydantic import BaseModel, Field, field_validator
+from pydantic.types import StringConstraints
+
+
+class FirewallTarget(str, Enum):
+    """Firewall zone target types"""
+
+    ACCEPT = "ACCEPT"
+    REJECT = "REJECT"
+    DROP = "DROP"
+    DEFAULT = "default"
+
+
+class Protocol(str, Enum):
+    """Network protocols supported by firewalld"""
+
+    TCP = "tcp"
+    UDP = "udp"
+
+
+class FirewallZone(BaseModel):
+    """Represents a firewalld zone configuration"""
+
+    name: Annotated[str, StringConstraints(min_length=1)] = Field(
+        ..., description="Name of the zone"
+    )
+    target: Optional[FirewallTarget] = Field(
+        default=FirewallTarget.DEFAULT, description="Zone target type"
+    )
+    services: List[str] = Field(
+        default_factory=list, description="List of enabled services"
+    )
+    ports: List[str] = Field(default_factory=list, description="List of enabled ports")
+    sources: List[str] = Field(
+        default_factory=list, description="List of source addresses"
+    )
+    interfaces: List[str] = Field(
+        default_factory=list, description="List of network interfaces"
+    )
+
+
+class FirewallService(BaseModel):
+    """Represents a firewalld service configuration"""
+
+    name: Annotated[str, StringConstraints(min_length=1)] = Field(
+        ..., description="Name of the service"
+    )
+    ports: List[str] = Field(
+        default_factory=list, description="List of ports used by the service"
+    )
+    protocols: List[str] = Field(
+        default_factory=list, description="List of protocols used by the service"
+    )
+    modules: List[str] = Field(
+        default_factory=list,
+        description="List of kernel modules required by the service",
+    )
+    timeout: Optional[int] = Field(
+        default=0, ge=0, description="Timeout in seconds (0 for permanent)"
+    )
+
+
+class FirewallPort(BaseModel):
+    """Represents a firewalld port configuration"""
+
+    port: int = Field(..., ge=1, le=65535, description="Port number (1-65535)")
+    protocol: Protocol = Field(..., description="Network protocol (tcp/udp)")
+    timeout: Optional[int] = Field(
+        default=0, ge=0, description="Timeout in seconds (0 for permanent)"
+    )
+
+    def __str__(self) -> str:
+        return f"{self.port}/{self.protocol.value}"
+
+
+class FirewallSource(BaseModel):
+    """Represents a firewalld source configuration"""
+
+    address: Annotated[
+        str,
+        StringConstraints(pattern=r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}(?:/[0-9]{1,2})?$"),
+    ] = Field(..., description="IP address or network in CIDR notation")
+    zone: Optional[str] = Field(default=None, description="Zone name for the source")
+
+    @field_validator("address")
+    def validate_ip_address(cls, v):
+        # Validate IP address octets
+        ip = v.split("/")[0]
+        octets = ip.split(".")
+        if not all(0 <= int(octet) <= 255 for octet in octets):
+            raise ValueError("Invalid IP address octets")
+
+        # Validate CIDR if present
+        if "/" in v:
+            cidr = int(v.split("/")[1])
+            if not 0 <= cidr <= 32:
+                raise ValueError("CIDR must be between 0 and 32")
+        return v
+
+
+class FirewallRule(BaseModel):
+    """Represents a complete firewalld rule"""
+
+    zone: str = Field(..., description="Zone name")
+    source: Optional[FirewallSource] = Field(
+        default=None, description="Source configuration"
+    )
+    port: Optional[FirewallPort] = Field(default=None, description="Port configuration")
+    service: Optional[str] = Field(default=None, description="Service name")
+    timeout: Optional[int] = Field(
+        default=0, ge=0, description="Rule timeout in seconds"
+    )
--- a/SRV/models/network.py
+++ b/SRV/models/network.py
@ -0,0 +1,70 @@
+from typing import List, Optional, Union
+from pydantic import BaseModel
+
+
+# Класс для маршрутов IPv4
+class IPv4Route(BaseModel):
+    destination: str
+    prefix: int
+    next_hop: str
+    metric: int
+
+# Класс для маршрутов IPv6
+class IPv6Route(BaseModel):
+    destination: str
+    prefix: int
+    next_hop: str
+    metric: int
+
+# Класс для индивидуальной конфигурации IP
+class IndividualIPConfig(BaseModel):
+    address: str
+    routes: List[Union[IPv4Route, IPv6Route]]
+    method: Optional[str]
+    gateway: str
+    dns: List[str]
+
+# Класс для конфигурации IP
+class IPConfig(BaseModel):
+    configurations: List[IndividualIPConfig]
+
+# Класс для сетевого интерфейса
+class NetworkInterface(BaseModel):
+    name: str
+    type: str
+    mac_address: str
+    device_state: str
+    active_connection: str
+    device_mtu: str
+    ipv4: IPConfig
+    ipv6: IPConfig
+    container_x: int = 0
+    container_y: int = 0
+
+# Класс для WiFi устройства
+class WiFiDevice(NetworkInterface):
+    ssid: Optional[str] = None
+    bssid: Optional[str] = None
+    bitrate: Optional[int] = None
+    strength: Optional[int] = None
+    frequency: Optional[float] = None
+    mode: Union[str, int] = None
+
+class NetworkInterfacesContainer(BaseModel):
+    interfaces: List[Union[NetworkInterface, WiFiDevice]]
+    container_x: int
+    container_y: int
+
+class Activation(BaseModel):
+    id: int
+    interfaces: List[Union[NetworkInterface, WiFiDevice]]
+    container_x: int
+    container_y: int
+    isOpen: bool = True
+
+class Deactivation(BaseModel):
+    id: int
+    interfaces: List[Union[NetworkInterface, WiFiDevice]]
+    container_x: int
+    container_y: int
+    isOpen: bool = True
--- a/SRV/models/ufw.py
+++ b/SRV/models/ufw.py
@ -0,0 +1,263 @@
+from typing import List, Optional, Annotated, Union
+from enum import Enum
+from pydantic import BaseModel, Field, validator
+import ipaddress
+
+
+class Protocol(str, Enum):
+    """
+    Enum для сетевых протоколов UFW.
+    """
+    TCP = "tcp"
+    UDP = "udp"
+    BOTH = "both"
+
+    @property
+    def protocols(self) -> List[str]:
+        """Возвращает список протоколов для использования в команде UFW."""
+        return ["tcp", "udp"] if self == Protocol.BOTH else [self.value]
+
+
+class Action(str, Enum):
+    """
+    Enum для действий UFW.
+    
+    Attributes:
+        ALLOW: Разрешить трафик
+        DENY: Запретить трафик без уведомления
+        REJECT: Запретить трафик с уведомлением отправителю
+    """
+    ALLOW = "allow"
+    DENY = "deny"
+    REJECT = "reject"
+
+
+class Direction(str, Enum):
+    """
+    Enum для направления трафика UFW.
+    
+    Attributes:
+        IN: Входящий трафик
+        OUT: Исходящий трафик
+    """
+    IN = "in"
+    OUT = "out"
+
+
+class UFWRule(BaseModel):
+    """Модель правила UFW"""
+    action: Action
+    direction: Direction
+    from_ip: str
+    to_ip: str
+    port: Union[int, str]
+    protocol: Protocol
+    comment: Optional[str] = None
+
+    @validator("port")
+    def validate_port(cls, v):
+        """
+        Проверяет корректность порта или диапазона портов.
+        
+        Args:
+            v: Порт (число) или диапазон портов (строка вида "3000:3999")
+            
+        Returns:
+            Union[int, str]: Валидированное значение порта
+            
+        Raises:
+            ValueError: Если порт или диапазон портов некорректен
+        """
+        if isinstance(v, int):
+            if not (1 <= v <= 65535):
+                raise ValueError(f"Порт должен быть в диапазоне 1-65535, получено: {v}")
+            return v
+        elif isinstance(v, str):
+            try:
+                start, end = map(int, v.split(':'))
+                if not (1 <= start <= end <= 65535):
+                    raise ValueError
+                return v
+            except (ValueError, TypeError):
+                raise ValueError(f"Некорректный диапазон портов: {v}. Формат: start:end, где 1 <= start <= end <= 65535")
+        else:
+            raise ValueError(f"Порт должен быть числом или строкой с диапазоном, получено: {type(v)}")
+
+    @validator("from_ip", "to_ip")
+    def validate_ip(cls, v):
+        """Проверяет корректность IP адреса"""
+        try:
+            # Пробуем создать объект IP-сети, что автоматически проверит корректность адреса
+            ipaddress.ip_network(v, strict=False)
+            return v
+        except ValueError:
+            raise ValueError(f"Некорректный IP адрес или подсеть: {v}")
+
+    @validator("to_ip")
+    def validate_ip_version_compatibility(cls, v, values):
+        """Проверяет совместимость версий IP адресов"""
+        if "from_ip" not in values:
+            return v
+            
+        # Определяем версии IP
+        from_ip = ipaddress.ip_network(values["from_ip"], strict=False)
+        to_ip = ipaddress.ip_network(v, strict=False)
+        
+        if isinstance(from_ip, ipaddress.IPv6Network) != isinstance(to_ip, ipaddress.IPv6Network):
+            raise ValueError("Несовместимые версии IP: нельзя смешивать IPv4 и IPv6 в одном правиле")
+            
+        return v
+
+    @validator("action", pre=True)
+    def validate_action(cls, v):
+        """Приводит значение action к нижнему регистру перед валидацией"""
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
+    @validator("protocol", pre=True)
+    def validate_protocol(cls, v):
+        """Приводит значение protocol к нижнему регистру перед валидацией"""
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
+    def to_ufw_command(self) -> str:
+        """Преобразует правило в команду UFW."""
+        cmd_parts = ["ufw"]
+        
+        # Добавляем действие
+        cmd_parts.append(self.action.value)
+        
+        # Добавляем направление
+        cmd_parts.append(self.direction.value)
+        
+        # Добавляем from с IP
+        cmd_parts.extend(["from", self.from_ip])
+        
+        # Добавляем to с IP
+        cmd_parts.extend(["to", self.to_ip])
+        
+        # Добавляем порт и протокол
+        port_str = str(self.port)  # Работает как с числами, так и с диапазонами
+        cmd_parts.extend(["port", port_str])
+        
+        # Добавляем протокол
+        proto = self.protocol.value
+        if proto == "both":
+            cmd_parts.append("proto tcp/udp")
+        else:
+            cmd_parts.extend(["proto", proto])
+        
+        # Добавляем комментарий если есть
+        if self.comment:
+            cmd_parts.extend(["comment", f"'{self.comment}'"])
+        
+        return " ".join(cmd_parts)
+
+    @classmethod
+    def from_ufw_output(cls, line: str) -> "UFWRule":
+        """
+        Создает экземпляр UFWRule из строки вывода команды 'ufw status numbered'.
+        
+        Args:
+            line: Строка вывода UFW (например, "[1] 80/tcp ALLOW IN 192.168.1.0/24 # Web Server")
+            
+        Returns:
+            UFWRule: Новый экземпляр правила
+        """
+        import re
+
+        # Регулярное выражение для разбора строки правила UFW
+        pattern = r"""^\s*
+            \[\s*(?P<number>\d+)\s*\]\s*
+            (?P<port>\d+(?::\d+)?)/(?P<protocol>tcp(?:/udp)?|udp)\s+
+            (?P<action>ALLOW|DENY|REJECT)\s+(?P<direction>IN|OUT)\s+
+            (?P<from_ip>[\w\d\./]+|\bAnywhere\b)
+            (?:\s+\(v6\))?
+            (?:\s+\((?:out|in)\))?
+            \s*
+            (?:\#\s*(?P<comment>.*?))?
+            \s*$
+        """
+        
+        match = re.match(pattern, line, re.VERBOSE | re.IGNORECASE)
+        if not match:
+            raise ValueError(f"Невозможно разобрать строку правила UFW: {line}")
+            
+        groups = match.groupdict()
+        
+        # Преобразуем протокол в enum
+        proto_str = groups['protocol'].lower()
+        protocol = Protocol.BOTH if proto_str == "tcp/udp" else \
+                  Protocol.UDP if proto_str == "udp" else Protocol.TCP
+        
+        # Преобразуем действие в enum (игнорируем регистр)
+        action_str = groups['action'].lower()
+        action = Action.ALLOW if action_str == "allow" else \
+                Action.DENY if action_str == "deny" else Action.REJECT
+                
+        # Преобразуем направление в enum
+        direction_str = groups['direction'].lower()
+        direction = Direction.IN if direction_str == "in" else Direction.OUT
+        
+        # Обрабатываем IP адреса
+        from_ip = groups['from_ip'].strip()
+        if from_ip.lower() == "anywhere":
+            from_ip = "0.0.0.0/0"
+            
+        # Для исходящих правил меняем местами from и to
+        to_ip = "0.0.0.0/0"  # По умолчанию anywhere
+        
+        # Обрабатываем порт
+        port = groups['port']
+        if ':' in port:
+            # Оставляем как строку для диапазона
+            port = port.strip()
+        else:
+            # Преобразуем в число для одиночного порта
+            port = int(port)
+        
+        # Обрабатываем комментарий
+        comment = groups.get('comment', '').strip() if groups.get('comment') else None
+        
+        return cls(
+            action=action,
+            direction=direction,
+            from_ip=from_ip,
+            to_ip=to_ip,
+            port=port,
+            protocol=protocol,
+            comment=comment
+        )
+
+
+class UFWRulesResponse(BaseModel):
+    """
+    Модель для представления списка правил UFW.
+    
+    Attributes:
+        enabled: Включен ли UFW
+        rules: Список правил UFW
+        total_rules: Общее количество правил
+    """
+    enabled: bool = Field(..., description="Включен ли UFW")
+    rules: List[UFWRule] = Field(default_factory=list, description="Список правил UFW")
+    
+    @property
+    def total_rules(self) -> int:
+        """Возвращает общее количество правил."""
+        return len(self.rules)
+
+
+class UFWStatus(BaseModel):
+    """
+    Модель для представления статуса UFW.
+    
+    Attributes:
+        enabled: Включен ли UFW
+        message: Сообщение о статусе
+        last_checked: Время последней проверки статуса
+    """
+    enabled: bool = Field(..., description="Включен ли UFW")
+    message: str = Field(..., description="Сообщение о статусе")
--- a/SRV/poetry.lock
+++ b/SRV/poetry.lock
--- a/SRV/pyproject.toml
+++ b/SRV/pyproject.toml
@ -0,0 +1,43 @@
+[tool.poetry]
+name = "GONETS"
+version = "0.1.0"
+description = "API для управления системными сервисами Linux"
+authors = ["Sergey Galanskiy <merelden.77@gmail.com>", "Vladimir Shalimow <vova@texnico.ru>"]
+readme = "README.md"
+packages = [
+    {include = "api"},
+    {include = "config"},
+    {include = "models"},
+    {include = "services"},
+    {include = "core"},
+    {include = "tests"},
+    {include = "storage"},
+]
+
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pydbus = "^0.6.0"
+fastapi = {extras = ["standard"], version = "^0.115.11"}
+pydantic = "^2.10.3"
+pygobject = "^3.50.0"
+sdbus-networkmanager = "^2.0.0"
+uvicorn = "^0.32.1"
+websockets = "^14.1"
+uuid = "^1.30"
+scapy = "^2.6.1"
+netifaces = "^0.11.0"
+netaddr = "^1.3.0"
+dbus-python = "^1.3.2"
+python-pam = "^2.0.2"
+six = "^1.17.0"
+python-jose = {extras = ["cryptography"], version = "^3.4.0"}
+storage = "^0.0.4.3"
+passlib = {extras = ["bcrypt"], version = "^1.7.4"}
+python-multipart = "^0.0.20"
+bcrypt = "^4.3.0"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
--- a/SRV/services/init.py
+++ b/SRV/services/init.py
--- a/SRV/services/arp_service.py
+++ b/SRV/services/arp_service.py
@ -0,0 +1,59 @@
+from scapy.layers.l2 import ARP, Ether
+from scapy.sendrecv import srp
+import netifaces
+from netaddr import IPNetwork
+
+class NetworkScanner:
+    """Иницилазицая сетевого сканера"""
+    def __init__(self, interface=None):
+        """Инициализация параметров интерфейсов """
+        self.interface = interface or netifaces.gateways()['default'][netifaces.AF_INET][1]
+        self.ip_info = netifaces.ifaddresses(self.interface).get(netifaces.AF_INET, [])
+        self.networks = [IPNetwork(f"{ip['addr']}/{ip['netmask']}") for ip in self.ip_info]
+        self.local_mac = netifaces.ifaddresses(self.interface)[netifaces.AF_LINK][0]['addr']
+
+    def _create_arp_packet(self, target_ip):
+        """Создание пакета ARP для отправки"""
+        arp = ARP(pdst=target_ip)
+        ether = Ether(dst="ff:ff:ff:ff:ff:ff")
+        return ether/arp
+
+    def scan_network(self, attempts=3, timeout=2):
+        """Подготовка к сканированию сети"""
+        all_clients = []
+
+        for network in self.networks:
+            target_ip = f"{network.network}/{network.prefixlen}"
+            packet = self._create_arp_packet(target_ip)
+            clients = []
+
+            for _ in range(attempts):
+                result = srp(packet, timeout=timeout, iface=self.interface, verbose=0)[0]
+                for _, received in result:
+                    client = {'ip': received.psrc, 'mac': received.hwsrc}
+                    if client not in clients:  # Избегаем дублирования клиентов
+                        clients.append(client)
+
+            all_clients.extend(clients)
+
+        # Добавляет все локальные IP-адреса интерфейса как клиенты
+        for ip_info in self.ip_info:
+            local_client = {'ip': ip_info['addr'], 'mac': self.local_mac}
+            if local_client not in all_clients:
+                all_clients.append(local_client)
+
+        # Удаление дубликатов
+        unique_clients = {tuple(client.items()) for client in all_clients}
+        return [dict(client) for client in unique_clients]
+
+    def print_clients(self, clients):
+        """Лист адресов клиентов"""
+        print("Доступные устройства в сети:")
+        print("IP" + " "*18+"MAC")
+        for client in sorted(clients, key=lambda x: x['ip']):
+            print(f"{client['ip']:<16}    {client['mac']}")
+
+if __name__ == "__main__":
+    scanner = NetworkScanner()
+    clients = scanner.scan_network()
+    scanner.print_clients(clients)
--- a/SRV/services/auth_service.py
+++ b/SRV/services/auth_service.py
@ -0,0 +1,129 @@
+# services/auth_service.py
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+from fastapi import HTTPException, Depends, Request
+from fastapi.security import OAuth2PasswordBearer
+from models.auth import UserCreate, UserLogin, UserResponse, Token
+from storage.json_storage import JsonStorage
+from storage.session_storage import SessionStorage
+from typing import Optional
+import configparser
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+config = configparser.ConfigParser()
+config_path = "/etc/gonets/config.ini"
+if not os.path.exists(config_path):
+    raise RuntimeError(f"Конфигурационный файл {config_path} не найден")
+config.read(config_path)
+SECRET_KEY = config["JWT"]["secret_key"]
+
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
+
+class AuthService:
+    """Сервис для регистрации, авторизации и управления сессиями"""
+    def __init__(self):
+        self.storage = JsonStorage()
+        self.session_storage = SessionStorage()
+
+    def create_access_token(self, data: dict) -> str:
+        """Создаёт токен"""
+        to_encode = data.copy()
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+        to_encode.update({"exp": expire})
+        encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+        return encoded_jwt
+
+    def verify_token(self, token: str) -> Optional[dict]:
+        """Проверяет токен"""
+        try:
+            payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+            username: str = payload.get("sub")
+            if username is None:
+                return None
+            return {"username": username}
+        except JWTError:
+            return None
+
+    def register(self, user: UserCreate) -> UserResponse:
+        """Регистрирует нового пользователя"""
+        try:
+            db_user = self.storage.create_user(user)
+            return db_user
+        except ValueError as e:
+            logger.error(f"Ошибка при регистрации пользователя {user.username}: {str(e)}")
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            logger.error(f"Ошибка при регистрации пользователя {user.username}: {type(e).__name__} - {str(e)}")
+            raise HTTPException(status_code=500, detail="Ошибка регистрации")
+
+    def login(self, user: UserLogin, client_id: str) -> dict:
+        """Авторизует пользователя, создаёт сессию и возвращает токен"""
+        try:
+            db_user = self.storage.get_user_by_username(user.username)
+            if not db_user:
+                logger.error(f"Пользователь {user.username} не найден")
+                raise HTTPException(status_code=401, detail="Неверный логин или пароль")
+            if not self.storage.verify_password(user.password, db_user["password_hash"]):
+                logger.error(f"Неверный пароль для пользователя {user.username}")
+                raise HTTPException(status_code=401, detail="Неверный логин или пароль")
+            access_token = self.create_access_token(data={"sub": user.username})
+            session_id = self.session_storage.create_session(user.username, access_token, client_id)
+            logger.info(f"Пользователь {user.username} успешно авторизован")
+            return {
+                "access_token": access_token,
+                "token_type": "bearer",
+                "session_id": session_id,
+                "user": UserResponse(id=db_user["id"], username=db_user["username"], is_admin=db_user["is_admin"])
+            }
+        except Exception as e:
+            logger.error(f"Ошибка при авторизации пользователя {user.username}: {type(e).__name__} - {str(e)}")
+            raise HTTPException(status_code=500, detail="Ошибка авторизации")
+
+    def get_current_user(self, token: str = Depends(oauth2_scheme)) -> UserResponse:
+        """Получает текущего пользователя по токену"""
+        credentials = self.verify_token(token)
+        if not credentials:
+            logger.error("Неверный или истёкший токен")
+            raise HTTPException(status_code=401, detail="Неверный токен")
+        username = credentials["username"]
+        db_user = self.storage.get_user_by_username(username)
+        if not db_user:
+            logger.error(f"Пользователь {username} не найден")
+            raise HTTPException(status_code=401, detail="Пользователь не найден")
+        return UserResponse(id=db_user["id"], username=db_user["username"], is_admin=db_user["is_admin"])
+
+    def get_user_by_session(self, client_id: str) -> dict:
+        """Получает пользователя и токен по client_id"""
+        session = self.session_storage.get_latest_session(client_id)
+        if not session:
+            logger.error(f"Сессия для client_id {client_id} не найдена или истекла")
+            raise HTTPException(status_code=401, detail="Сессия недействительна")
+        username = session["username"]
+        token = session["token"]
+        db_user = self.storage.get_user_by_username(username)
+        if not db_user:
+            logger.error(f"Пользователь {username} не найден")
+            raise HTTPException(status_code=401, detail="Пользователь не найден")
+        return {
+            "user": UserResponse(id=db_user["id"], username=db_user["username"], is_admin=db_user["is_admin"]),
+            "access_token": token
+        }
+
+    def logout(self, client_id: str):
+        """Выполняет выход из системы, удаляя последнюю сессию для client_id"""
+        try:
+            session = self.session_storage.get_latest_session(client_id)
+            if session:
+                self.session_storage.delete_session(session["session_id"])
+            logger.info(f"Пользователь успешно вышел из системы для client_id {client_id}")
+            return {"message": "Успешный выход из системы"}
+        except Exception as e:
+            logger.error(f"Ошибка при выходе из системы: {type(e).__name__} - {str(e)}")
+            raise HTTPException(status_code=500, detail="Ошибка при выходе из системы")
--- a/SRV/services/firewalld_service.py
+++ b/SRV/services/firewalld_service.py
@ -0,0 +1,143 @@
+from re import DEBUG
+from typing import Dict, List, Optional
+
+from pydbus import SystemBus
+
+DEBUG = True
+
+
+class FirewalldService:
+    def __init__(self):
+        self.bus = SystemBus()
+        self.proxy = self.bus.get(
+            "org.fedoraproject.FirewallD1", "/org/fedoraproject/FirewallD1"
+        )
+
+    def get_zones(self) -> List[str]:
+        """Get list of all zones."""
+        try:
+            return self.proxy.getZones()
+        except Exception as e:
+            raise Exception(f"Failed to get zones: {str(e)}")
+
+    def get_default_zone(self) -> str:
+        """Get the default zone."""
+        try:
+            return self.proxy.getDefaultZone()
+        except Exception as e:
+            raise Exception(f"Failed to get default zone: {str(e)}")
+
+    def set_default_zone(self, zone: str) -> None:
+        """Set the default zone."""
+        try:
+            self.proxy.setDefaultZone(zone)
+        except Exception as e:
+            raise Exception(f"Failed to set default zone to {zone}: {str(e)}")
+
+    def add_service(self, zone: str, service: str, timeout: Optional[int] = 0) -> None:
+        """Add a service to a zone."""
+        try:
+            self.proxy.addService(zone, service, timeout)
+        except Exception as e:
+            raise Exception(f"Failed to add service {service} to zone {zone}: {str(e)}")
+
+    def remove_service(self, zone: str, service: str) -> None:
+        """Remove a service from a zone."""
+        try:
+            self.proxy.removeService(zone, service)
+        except Exception as e:
+            raise Exception(
+                f"Failed to remove service {service} from zone {zone}: {str(e)}"
+            )
+
+    def get_services(self, zone: str) -> List[str]:
+        """Get list of services in a zone."""
+        try:
+            return self.proxy.getServices(zone)
+        except Exception as e:
+            raise Exception(f"Failed to get services for zone {zone}: {str(e)}")
+
+    def add_port(
+        self, zone: str, port: int, protocol: str, timeout: Optional[int] = 0
+    ) -> None:
+        """Add a port to a zone."""
+        try:
+            if DEBUG:
+                print(f"Adding port {port}/{protocol} to zone {zone}")
+                print(f"Timeout: {timeout}")
+            # Get the zone interface
+            zone_proxy = self.bus.get(
+                "org.fedoraproject.FirewallD1",
+                "/org/fedoraproject/FirewallD1"
+            )
+            zone_iface = zone_proxy['org.fedoraproject.FirewallD1.zone']
+            # Convert port to string
+            port_str = str(port)
+            # Convert timeout to integer
+            timeout_int = int(timeout) if timeout is not None else 0
+            # Call addPort with the correct signature (sssi)
+            zone_iface.addPort(zone, port_str, protocol, timeout_int)
+        except Exception as e:
+            raise Exception(
+                f"Failed to add port {port}/{protocol} to zone {zone}: {str(e)}"
+            )
+
+    def remove_port(self, zone: str, port: int, protocol: str) -> None:
+        """Remove a port from a zone."""
+        try:
+            port_str = f"{port}/{protocol}"
+            self.proxy.removePort(zone, port_str)
+        except Exception as e:
+            raise Exception(
+                f"Failed to remove port {port}/{protocol} from zone {zone}: {str(e)}"
+            )
+
+    def get_ports(self, zone: str) -> List[str]:
+        """Get list of ports in a zone."""
+        try:
+            ports = self.proxy.getPorts(zone)
+            # Convert port list items to strings in format "port/protocol"
+            return [f"{port[0]}/{port[1]}" for port in ports]
+        except Exception as e:
+            raise Exception(f"Failed to get ports for zone {zone}: {str(e)}")
+
+    def add_source(self, zone: str, source: str) -> None:
+        """Add a source to a zone."""
+        try:
+            self.proxy.addSource(zone, source)
+        except Exception as e:
+            raise Exception(f"Failed to add source {source} to zone {zone}: {str(e)}")
+
+    def remove_source(self, zone: str, source: str) -> None:
+        """Remove a source from a zone."""
+        try:
+            self.proxy.removeSource(zone, source)
+        except Exception as e:
+            raise Exception(
+                f"Failed to remove source {source} from zone {zone}: {str(e)}"
+            )
+
+    def get_sources(self, zone: str) -> List[str]:
+        """Get list of sources in a zone."""
+        try:
+            return self.proxy.getSources(zone)
+        except Exception as e:
+            raise Exception(f"Failed to get sources for zone {zone}: {str(e)}")
+
+    def reload(self) -> None:
+        """Reload firewall rules."""
+        try:
+            self.proxy.reload()
+        except Exception as e:
+            raise Exception(f"Failed to reload firewall rules: {str(e)}")
+
+    def get_zone_settings(self, zone: str) -> Dict:
+        """Get all settings for a zone."""
+        try:
+            return {
+                "services": self.get_services(zone),
+                "ports": self.get_ports(zone),
+                "sources": self.get_sources(zone),
+            }
+        except Exception as e:
+            raise Exception(f"Failed to get zone settings for {zone}: {str(e)}")
--- a/SRV/services/ip_service.py
+++ b/SRV/services/ip_service.py
@ -0,0 +1,112 @@
+from sdbus_async.networkmanager import NetworkManager, NetworkManagerSettings, NetworkConnectionSettings, NetworkDeviceGeneric, ActiveConnection
+import asyncio
+from sdbus_async.networkmanager.settings import ConnectionProfile
+from typing import Dict, Any
+import sdbus
+from services.arp_service import NetworkScanner
+
+class IPService:
+    """
+    Сервис проверки доступности IP-адреса и применения настроек сети
+    """
+    def __init__(self):
+        self.arp_scanner = NetworkScanner()
+        self.bus = sdbus.sd_bus_open_system()
+        sdbus.set_default_bus(self.bus)
+
+    def _reset_bus(self):
+        """ Перезапускает соединение с системной шиной D-Bus """
+        new_bus = sdbus.sd_bus_open_system()
+        sdbus.set_default_bus(new_bus)
+        if hasattr(self, 'bus') and self.bus is not None:
+            self.bus = None
+        self.bus = new_bus
+
+    async def check_ip_config(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """ Проверяет доступность IP-адреса перед его применением """
+        self._reset_bus()
+        clients = self.arp_scanner.scan_network()
+        new_ip = args["ipv4_updates"]["ipv4.address-data"][0]["address"]
+        if any(client['ip'] == new_ip for client in clients):
+            return {"available": False, "message": f"IP address {new_ip} уже занят."}
+        return {"available": True, "message": "Network profile settings are available for use."}
+
+    async def apply_ip_config(self, args: Dict[str, Any]) -> None:
+        """ Применяет проверенные настройки IP """
+        self._reset_bus()
+        nm = NetworkManager(self.bus)
+        settings = NetworkManagerSettings(self.bus)
+        connection_paths = await settings.get_connections_by_id(args["connection_id"])
+
+        if not connection_paths:
+            raise ValueError(f"Подключение {args['connection_id']} не найдено")
+
+        connection = NetworkConnectionSettings(connection_paths[0], self.bus)
+        profile = await connection.get_profile()
+        settings_dict = profile.to_settings_dict()
+
+        # Обновляем настройки IPv4
+        for key_path, value in args["ipv4_updates"].items():
+            section, *props = key_path.split('.')
+            current = settings_dict[section]
+            for prop in props[:-1]:
+                current = current.setdefault(prop, {})
+            current[props[-1]] = value
+
+        new_profile = ConnectionProfile.from_settings_dict(settings_dict)
+        await connection.update(new_profile.to_dbus())
+        print(f"Обновлены настройки для {args['connection_id']}:")
+
+        # Проверяем interface-name
+        interface_name = settings_dict['connection'].get('interface-name')
+        if not interface_name:
+            # Ищем устройство, связанное с connection_id через активное соединение
+            devices = await nm.get_devices()
+            for device_path in devices:
+                device = NetworkDeviceGeneric(device_path, self.bus)
+                active_connection = await device.active_connection
+                if active_connection != '/':
+                    active_conn = ActiveConnection(active_connection, self.bus)
+                    conn_path = await active_conn.connection  # Путь к настройкам соединения
+                    if conn_path != '/':
+                        conn_settings = NetworkConnectionSettings(conn_path, self.bus)
+                        active_profile = await conn_settings.get_profile()
+                        if active_profile.to_settings_dict()['connection']['id'] == args["connection_id"]:
+                            interface_name = await device.interface
+                            settings_dict['connection']['interface-name'] = interface_name
+                            new_profile = ConnectionProfile.from_settings_dict(settings_dict)
+                            await connection.update(new_profile.to_dbus())
+                            print(f"Добавлен interface-name: {interface_name} для {args['connection_id']}")
+                            break
+
+        if not interface_name:
+            # Если не нашли активное соединение, пробуем получить интерфейс из настроек устройства
+            devices = await nm.get_devices()
+            for device_path in devices:
+                device = NetworkDeviceGeneric(device_path, self.bus)
+                applied_connection = await device.get_applied_connection()
+                connection_settings = applied_connection[0]
+                conn_id = connection_settings.get('connection', {}).get('id', ('s', ''))[1]
+                if conn_id == args["connection_id"]:
+                    interface_name = await device.interface
+                    settings_dict['connection']['interface-name'] = interface_name
+                    new_profile = ConnectionProfile.from_settings_dict(settings_dict)
+                    await connection.update(new_profile.to_dbus())
+                    print(f"Добавлен interface-name: {interface_name} для {args['connection_id']}")
+                    break
+
+        if not interface_name:
+            raise ValueError(f"Не удалось определить interface-name для {args['connection_id']}")
+
+        # Переподключаем устройство
+        devices = await nm.get_devices()
+        for device_path in devices:
+            device = NetworkDeviceGeneric(device_path, self.bus)
+            if await device.interface == interface_name:
+                await device.disconnect()
+                print(f"Отключён от {interface_name}")
+                await nm.activate_connection(connection=connection_paths[0], device=device_path)
+                print(f"Переподключён к {args['connection_id']}")
+                return
+
+        raise RuntimeError(f"Устройство для интерфейса {interface_name} не найдено")
--- a/SRV/services/network_service.py
+++ b/SRV/services/network_service.py
@ -0,0 +1,200 @@
+from typing import List, Dict, Tuple, Union, Optional
+from sdbus_async.networkmanager import (
+    NetworkManager, 
+    NetworkDeviceGeneric, 
+    IPv4Config, 
+    IPv6Config, 
+    NetworkManagerSettings, 
+    NetworkDeviceWireless, 
+    AccessPoint, 
+    DeviceType
+)
+from sdbus import sd_bus_open_system
+from models.network import (
+    NetworkInterface, 
+    IPv4Route, 
+    IPv6Route, 
+    IPConfig, 
+    IndividualIPConfig, 
+    NetworkInterfacesContainer, 
+    WiFiDevice
+)
+import subprocess
+
+class NetworkService:
+    """Сервис для взаимодействия с NetworkManager через D-Bus"""
+
+    def __init__(self):
+        self.system_bus = sd_bus_open_system()
+        self.nm = NetworkManager(self.system_bus)
+        self.nm_settings = NetworkManagerSettings(self.system_bus)
+
+    async def get_ip_method(self, device: NetworkDeviceGeneric, ip_type: str) -> str:
+        """Получает метод IP для устройства"""
+        try:
+            config = await device.get_applied_connection()
+            settings = config[0].get(ip_type, {})
+            return str(settings.get("method", ('s', 'unknown'))[1])
+        except Exception:
+            return 'unknown'
+
+    async def get_connection_name(self, device: NetworkDeviceGeneric) -> str:
+        """Извлекает имя соединения (GENERAL.CONNECTION) для устройства"""
+        try:
+            applied_connection = await device.get_applied_connection()
+            connection_settings = applied_connection[0]
+            connection_info = connection_settings.get('connection', {})
+            return str(connection_info.get('id', ('s', 'unknown'))[1])
+        except Exception as e:
+            # print(f"Ошибка при получении соединения для устройства {await device.interface}: {e}")
+            # срёт ошибки дл отключенных интерфейсов
+            # добавить потом условия для отключенных интерфейсов
+            return 'unknown'
+
+    async def get_ip_config(self, device: NetworkDeviceGeneric, ip_version: str) -> List[IndividualIPConfig]:
+        """Получает конфигурацию IP для устройства"""
+        configs = []
+        device_ip = await getattr(device, f'ip{ip_version}_config')
+        if device_ip != '/':
+            ip_config = globals()[f'IPv{ip_version}Config'](device_ip, self.system_bus)
+            address_data = await ip_config.address_data
+            for address in address_data:
+                config = IndividualIPConfig(
+                    address=str(address['address'][1]),
+                    routes=[
+                        globals()[f'IPv{ip_version}Route'](
+                            destination=route.get('dest', ('s', '0.0.0.0' if ip_version == '4' else '::'))[1],
+                            prefix=route.get('prefix', ('u', 0))[1],
+                            next_hop=route.get('next-hop', ('s', '0.0.0.0' if ip_version == '4' else '::'))[1],
+                            metric=route.get('metric', ('u', 0))[1]
+                        ) for route in await ip_config.route_data
+                    ],
+                    method=await self.get_ip_method(device, f'ipv{ip_version}'),
+                    gateway=str(await ip_config.gateway),
+                    dns=[str(ns['address'][1]) if ip_version == '4' else str(ns) for ns in await getattr(ip_config, 'nameserver_data' if ip_version == '4' else 'nameservers')]
+                )
+                configs.append(config)
+        return configs
+
+    async def get_wifi_info(self, wifi_device: NetworkDeviceWireless) -> Dict[str, Optional[Union[str, int]]]:
+        """Получает информацию о Wi-Fi устройстве"""
+        active_ap = await wifi_device.active_access_point
+        wifi_info = {
+            'ssid': None,
+            'bssid': None,
+            'bitrate': await wifi_device.bitrate,
+            'strength': None,
+            'frequency': None,
+            'mode': None
+        }
+        if active_ap != '/':
+            ap = AccessPoint(active_ap, self.system_bus)
+            wifi_info.update({
+                'ssid': await ap.ssid,
+                'bssid': await ap.hw_address,
+                'strength': await ap.strength,
+                'frequency': await ap.frequency,
+                'mode': await ap.mode
+            })
+        return wifi_info
+
+    async def get_network_interfaces(self, initial_positions: Dict[str, Tuple[int, int]] = None) -> List[Union[NetworkInterface, WiFiDevice]]:
+        """Получает список сетевых интерфейсов"""
+        devices_paths = await self.nm.get_devices()
+        network_interfaces = []
+        initial_positions = initial_positions or {}
+
+        for device_path in devices_paths:
+            generic_device = NetworkDeviceGeneric(device_path, self.system_bus)
+            interface_name = str(await generic_device.interface)
+            device_type = DeviceType(await generic_device.device_type).name
+
+            if device_type == 'LOOPBACK':
+                continue
+
+            device_state = str(await generic_device.state)
+            if device_state == '10':
+                continue
+
+            common_data = {
+                'name': interface_name,
+                'type': device_type,
+                'device_state': device_state,
+                'active_connection': await self.get_connection_name(generic_device),
+                'mac_address': str(await generic_device.hw_address),
+                'device_mtu': str(await generic_device.mtu),
+                'ipv4': IPConfig(configurations=await self.get_ip_config(generic_device, '4')),
+                'ipv6': IPConfig(configurations=await self.get_ip_config(generic_device, '6')),
+                'x': initial_positions.get(interface_name, (100, 100))[0],
+                'y': initial_positions.get(interface_name, (100, 100))[1],
+            }
+
+            if device_type == "WIFI":
+                wifi_device = NetworkDeviceWireless(device_path, self.system_bus)
+                wifi_info = await self.get_wifi_info(wifi_device)
+                network_interfaces.append(WiFiDevice(**common_data, **wifi_info))
+            else:
+                network_interfaces.append(NetworkInterface(**common_data))
+
+        return network_interfaces
+
+    async def get_hostname(self) -> Dict[str, str]:
+        """Возвращает имя хоста из команды hostname в формате JSON"""
+        try:
+            result = subprocess.run(['hostname'], capture_output=True, text=True, check=True)
+            hostname = result.stdout.strip()
+            return {"hostname": hostname}
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to execute hostname: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Error processing hostname output: {e}")
+
+    async def get_interfaces_by_state(self, state: str, initial_positions: Dict[str, Tuple[int, int]] = None) -> List[NetworkInterface]:
+        """
+        Получает список интерфейсов по состоянию
+        """
+        all_interfaces = await self.get_network_interfaces(initial_positions)
+        return [interface for interface in all_interfaces if interface.device_state == state]
+
+    async def get_interfaces_container(self, state: Optional[str] = None, initial_positions: Dict[str, Tuple[int, int]] = None, container_x: int = 0, container_y: int = 0) -> NetworkInterfacesContainer:
+        """ Получает объект, содержащий список интерфейсов и координаты контейнера """
+        if state:
+            interfaces = await self.get_interfaces_by_state(state, initial_positions)
+        else:
+            interfaces = await self.get_network_interfaces(initial_positions)
+        return NetworkInterfacesContainer(
+            interfaces=interfaces,
+            container_x=container_x,
+            container_y=container_y
+        )
+
+    async def get_network_interfaces_container(self, initial_positions: Optional[Dict[str, Tuple[int, int]]] = None, ) -> NetworkInterfacesContainer:
+        """ Получает контейнер с сетевыми интерфейсами и координатами контейнера """
+        interfaces = await self.get_network_interfaces(initial_positions)
+        return NetworkInterfacesContainer(
+            interfaces=interfaces,
+            container_x=0,
+            container_y=0
+        )
+
+    async def get_activated_interfaces(self, initial_positions: Dict[str, Tuple[int, int]] = None) -> List[NetworkInterface]:
+        """ Получает список активных сетевых интерфейсов """
+        return await self.get_interfaces_by_state('100', initial_positions)
+
+    async def get_deactivated_interfaces(self, initial_positions: Dict[str, Tuple[int, int]] = None) -> List[NetworkInterface]:
+        """ Получает список неактивных сетевых интерфейсов """
+        all_interfaces = await self.get_network_interfaces(initial_positions)
+        return [interface for interface in all_interfaces if interface.device_state != '100']
+
+    async def get_activated_interfaces_container(self, initial_positions: Dict[str, Tuple[int, int]] = None, container_x: int = 0, container_y: int = 0) -> NetworkInterfacesContainer:
+        """ Получает объект, содержащий список активных интерфейсов и координаты контейнера """
+        return await self.get_interfaces_container('100', initial_positions, container_x, container_y)
+
+    async def get_deactivated_interfaces_container(self, initial_positions: Dict[str, Tuple[int, int]] = None, container_x: int = 0, container_y: int = 0) -> NetworkInterfacesContainer:
+        """ Получает объект, содержащий список неактивных интерфейсов и координаты контейнера """
+        interfaces = await self.get_deactivated_interfaces(initial_positions)
+        return NetworkInterfacesContainer(
+            interfaces=interfaces,
+            container_x=container_x,
+            container_y=container_y
+        )
--- a/SRV/services/ufw_service.py
+++ b/SRV/services/ufw_service.py
@ -0,0 +1,393 @@
+import ipaddress
+import subprocess
+from typing import List, Union
+
+from models.ufw import Direction, Protocol, UFWRule, UFWRulesResponse, UFWStatus
+
+DEBUG = True
+
+
+class UFWService:
+    """
+    Сервис для взаимодействия с утилитой UFW (Uncomplicated Firewall) в Linux.
+    Позволяет получить список правил UFW и управлять ими.
+    """
+
+    def _run_command(self, command: str) -> str:
+        """
+        Выполняет команду в системе и возвращает ее вывод.
+
+        Args:
+            command (str): Команда для выполнения в системе.
+
+        Returns:
+            str: Вывод команды.
+        """
+        try:
+            if DEBUG:
+                print(f"Running command: {command}")
+
+            # Используем shell=True для корректной обработки аргументов с пробелами
+            result = subprocess.run(
+                f"sudo {command}",
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+
+            if DEBUG:
+                print(f"Command output: {result.stdout}")
+                print(f"Command error: {result.stderr}")
+
+            if result.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    result.returncode, command, result.stdout, result.stderr
+                )
+
+            return result.stdout
+
+        except subprocess.CalledProcessError as e:
+            if DEBUG:
+                print(f"Command failed with return code {e.returncode}")
+                print(f"Error output: {e.stderr}")
+            raise Exception(f"Command failed: {e.stderr}")
+
+    def _get_port_range_args(self, port: Union[int, str]) -> List[str]:
+        """
+        Преобразует порт или диапазон портов в аргументы команды UFW.
+
+        Args:
+            port: Порт (число) или диапазон портов (строка вида "3000:3999")
+
+        Returns:
+            List[str]: Список аргументов для UFW
+        """
+        if isinstance(port, int):
+            return [str(port)]
+        elif isinstance(port, str) and ":" in port:
+            # Диапазон портов уже в нужном формате
+            return [port]
+        else:
+            raise ValueError(f"Некорректный формат порта: {port}")
+
+    def get_ufw_rules(self) -> UFWRulesResponse:
+        """
+        Получает список правил UFW.
+
+        Returns:
+            UFWRulesResponse: Объект, содержащий статус UFW и список правил
+        """
+        # Check UFW status
+        status_result = self._run_command("ufw status numbered")
+        lines = status_result.splitlines()
+
+        if not lines:
+            return UFWRulesResponse(enabled=False, rules=[])
+
+        first_line = lines[0]
+        is_enabled = "Status: active" in first_line
+
+        if not is_enabled:
+            return UFWRulesResponse(enabled=False, rules=[])
+
+        rules = []
+        # Skip header lines
+        for line in lines[4:]:  # Skip Status and header lines
+            if not line.strip() or not line.startswith("["):
+                continue
+
+            try:
+                rule = UFWRule.from_ufw_output(line)
+                rules.append(rule)
+            except Exception as e:
+                if DEBUG:
+                    print(f"Ошибка парсинга правила: {line}, ошибка: {str(e)}")
+                continue
+
+        return UFWRulesResponse(enabled=is_enabled, rules=rules)
+
+    def get_ufw_status(self) -> UFWStatus:
+        """
+        Проверяет статус UFW.
+
+        Returns:
+            UFWStatus: Объект с информацией о статусе UFW
+        """
+        try:
+            status_result = self._run_command("ufw status")
+            first_line = (
+                status_result.splitlines()[0] if status_result.splitlines() else ""
+            )
+            is_enabled = "Status: active" in first_line
+
+            message = "UFW активен" if is_enabled else "UFW неактивен"
+
+            if DEBUG:
+                print(f"Результат статуса: {status_result}")
+                print(f"Включен: {is_enabled}")
+
+            return UFWStatus(enabled=is_enabled, message=message)
+        except Exception as e:
+            if DEBUG:
+                print(f"Ошибка при проверке статуса UFW: {e}")
+            return UFWStatus(
+                enabled=False,
+                message=f"Ошибка при проверке статуса: {str(e)}",
+            )
+
+    def enable_ufw(self) -> bool:
+        """
+        Включает UFW.
+
+        Returns:
+            bool: True если успешно включен, False в противном случае
+        """
+        try:
+            self._run_command("ufw enable")
+            return True
+        except Exception as e:
+            if DEBUG:
+                print(f"Ошибка при включении UFW: {e}")
+            return False
+
+    def disable_ufw(self) -> bool:
+        """
+        Выключает UFW.
+
+        Returns:
+            bool: True если успешно выключен, False в противном случае
+        """
+        try:
+            self._run_command("ufw disable")
+            return True
+        except Exception as e:
+            if DEBUG:
+                print(f"Ошибка при выключении UFW: {e}")
+            return False
+
+    def add_rules_base(self, rules: List[UFWRule], direction: str = "") -> bool:
+        """
+        Базовый метод для добавления правил UFW.
+
+        Args:
+            rules: Список правил для добавления
+            direction: Направление трафика ("in" или "out")
+
+        Returns:
+            bool: True если все правила были успешно добавлены, False в противном случае
+        """
+        try:
+            for rule in rules:
+                # Устанавливаем направление правила
+                rule.direction = Direction.IN if direction == "in" else Direction.OUT
+
+                # Формируем базовую команду
+                command = f"ufw {rule.action.value}"
+
+                # Добавляем направление
+                command += f" {rule.direction.value}"
+
+                # Добавляем from IP если он указан
+                if rule.from_ip and rule.from_ip != "any":
+                    command += f" from {rule.from_ip}"
+                else:
+                    command += " from any"
+
+                # Добавляем to IP если он указан
+                if rule.to_ip and rule.to_ip != "any":
+                    command += f" to {rule.to_ip}"
+                else:
+                    command += " to any"
+
+                # Добавляем порт если он указан
+                if rule.port:
+                    command += f" port {rule.port}"
+
+                # Добавляем протокол
+                if rule.protocol != Protocol.BOTH:
+                    command += f" proto {rule.protocol.value}"
+
+                # Добавляем комментарий если он есть
+                if rule.comment:
+                    command += f" comment '{rule.comment}'"
+
+                self._run_command(command)
+
+            return True
+        except Exception as e:
+            if DEBUG:
+                print(f"Error adding UFW rules: {str(e)}")
+            return False
+
+    def add_ufw_in_rules(self, rules: List[UFWRule]) -> bool:
+        """
+        Добавляет входящие (in) правила UFW.
+
+        Args:
+            rules (List[UFWRule]): Список правил для добавления
+
+        Returns:
+            bool: True если все правила были успешно добавлены, False в противном случае
+        """
+        return self.add_rules_base(rules, "in")
+
+    def add_ufw_out_rules(self, rules: List[UFWRule]) -> bool:
+        """
+        Добавляет исходящие (out) правила UFW.
+
+        Args:
+            rules (List[UFWRule]): Список правил для добавления
+
+        Returns:
+            bool: True если все правила были успешно добавлены, False в противном случае
+        """
+        return self.add_rules_base(rules, "out")
+
+    def add_rules(self, rules: List[UFWRule]) -> dict:
+        """
+        Добавляет правила UFW.
+
+        Args:
+            rules: Список правил для добавления
+
+        Returns:
+            dict: Результат добавления правил
+        """
+        results = []
+
+        for rule in rules:
+            try:
+                # Определяем версию IP
+                from_ip = ipaddress.ip_network(rule.from_ip, strict=False)
+                is_ipv6 = isinstance(from_ip, ipaddress.IPv6Network)
+
+                # Получаем список протоколов
+                protocols = rule.protocol.protocols
+                print(f"Обработка правила для протоколов: {protocols}")
+
+                for proto in protocols:
+                    # Формируем базовую команду
+                    command = f"ufw {rule.action.value}"
+
+                    # Добавляем IP адреса
+                    command += f" from {rule.from_ip}"
+                    if rule.to_ip:
+                        command += f" to {rule.to_ip}"
+
+                    # Добавляем порт и протокол
+                    port_args = self._get_port_range_args(rule.port)
+                    command += f" port {' '.join(port_args)} proto {proto}"
+
+                    # Добавляем флаг IPv6 если нужно
+                    if is_ipv6:
+                        command += " v6"
+
+                    # Добавляем комментарий если есть
+                    if rule.comment:
+                        command += f" comment '{rule.comment}'"
+
+                    print(f"Подготовлена команда: {command}")
+
+                    # Выполняем команду
+                    try:
+                        output = self._run_command(command)
+                        results.append({"success": True, "message": output})
+                    except Exception as e:
+                        error_msg = f"Ошибка выполнения команды: {str(e)}"
+                        print(error_msg)
+                        results.append({"success": False, "message": error_msg})
+
+            except Exception as e:
+                error_msg = f"Ошибка при добавлении правила: {str(e)}"
+                print(error_msg)
+                results.append({"success": False, "message": error_msg})
+
+        # Выводим результаты
+        print("\nРезультаты добавления правил:")
+        for result in results:
+            status = "Успешно" if result["success"] else "Ошибка"
+            print(f"  - {status}: {result['message']}")
+
+        return {"success": True, "results": results}
+
+    def delete_rules(self, rule_numbers: List[int]) -> dict:
+        """
+        Удаляет правила UFW по их номерам.
+
+        Args:
+            rule_numbers (List[int]): Список номеров правил для удаления
+
+        Returns:
+            dict: Результат операции удаления
+        """
+        try:
+            # Проверяем существование правил
+            status_result = self._run_command("ufw status numbered")
+            lines = status_result.splitlines()
+
+            # Пропускаем заголовок (первые 4 строки)
+            rules = []
+            for line in lines[4:]:  # Skip header lines
+                if not line.strip() or not line.startswith("["):
+                    continue
+
+                try:
+                    # Извлекаем номер правила из строки [N]
+                    rule_num = int(line[1 : line.index("]")])
+                    rules.append(rule_num)
+                except (ValueError, IndexError):
+                    continue
+
+            if DEBUG:
+                print(f"Найдены правила: {rules}")
+
+            results = []
+            # Сортируем номера в обратном порядке, чтобы удаление происходило с конца
+            # Это предотвратит смещение номеров при удалении
+            for rule_number in sorted(rule_numbers, reverse=True):
+                try:
+                    # Проверяем существует ли правило с таким номером
+                    if rule_number not in rules:
+                        results.append(
+                            {
+                                "number": rule_number,
+                                "success": False,
+                                "error": f"Правило с номером {rule_number} не найдено",
+                            }
+                        )
+                        continue
+
+                    # Удаляем правило
+                    self._run_command(f"ufw --force delete {rule_number}")
+
+                    results.append(
+                        {
+                            "number": rule_number,
+                            "success": True,
+                            "message": f"Правило {rule_number} успешно удалено",
+                        }
+                    )
+
+                except Exception as e:
+                    if DEBUG:
+                        print(f"Ошибка при удалении правила {rule_number}: {e}")
+                    results.append(
+                        {"number": rule_number, "success": False, "error": str(e)}
+                    )
+
+            # Подсчитываем статистику
+            total = len(rule_numbers)
+            successful = len([r for r in results if r["success"]])
+
+            return {
+                "success": True,
+                "total": total,
+                "successful": successful,
+                "results": results,
+            }
+
+        except Exception as e:
+            if DEBUG:
+                print(f"Ошибка при удалении правил: {e}")
+            return {"success": False, "error": str(e), "results": []}
--- a/SRV/storage/init.py
+++ b/SRV/storage/init.py
--- a/SRV/storage/json_storage.py
+++ b/SRV/storage/json_storage.py
@ -0,0 +1,101 @@
+# storage/json_storage.py
+import json
+import os
+import logging
+from passlib.context import CryptContext
+from typing import Optional
+from models.auth import UserCreate, UserResponse
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class JsonStorage:
+    """Хранилище пользователей в JSON-файле"""
+
+    def __init__(self, file_path: str = "/etc/gonets/users.json"):
+        self.file_path = file_path
+        self.pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+        self._ensure_file_exists()
+
+    def _ensure_file_exists(self):
+        """Создаёт JSON-файл, если он не существует"""
+        try:
+            logger.info(f"Проверка существования файла {self.file_path}")
+            if not os.path.exists(self.file_path):
+                logger.info(f"Создание директории {os.path.dirname(self.file_path)}")
+                os.makedirs(os.path.dirname(self.file_path), exist_ok=True)
+                logger.info(f"Создание файла {self.file_path}")
+                with open(self.file_path, "w") as f:
+                    json.dump({"users": [], "next_id": 1}, f)
+                os.chmod(self.file_path, 0o600)
+                logger.info(f"Создан файл {self.file_path}")
+            else:
+                logger.info(f"Файл {self.file_path} уже существует")
+        except Exception as e:
+            logger.error(f"Ошибка при создании файла {self.file_path}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def _read_data(self) -> dict:
+        """Читает данные из JSON-файла"""
+        try:
+            with open(self.file_path, "r") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            logger.info(f"Файл {self.file_path} не существует, возвращаем пустую структуру")
+            return {"users": [], "next_id": 1}
+        except Exception as e:
+            logger.error(f"Ошибка при чтении файла {self.file_path}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def _write_data(self, data: dict):
+        """Записывает данные в JSON файл"""
+        try:
+            with open(self.file_path, "w") as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            logger.error(f"Ошибка при записи файла {self.file_path}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def create_user(self, user: UserCreate) -> UserResponse:
+        """Создаёт нового пользователя"""
+        try:
+            data = self._read_data()
+            users = data["users"]
+            next_id = data["next_id"]
+            if any(u["username"] == user.username for u in users):
+                logger.error(f"Пользователь {user.username} уже существует")
+                raise ValueError("Пользователь уже существует")
+            password_hash = self.pwd_context.hash(user.password)
+            new_user = {
+                "id": next_id,
+                "username": user.username,
+                "password_hash": password_hash,
+                "is_admin": user.is_admin
+            }
+            users.append(new_user)
+            data["next_id"] = next_id + 1
+            self._write_data(data)
+            logger.info(f"Пользователь {user.username} успешно зарегистрирован")
+            return UserResponse(id=new_user["id"], username=new_user["username"], is_admin=new_user["is_admin"])
+        except Exception as e:
+            logger.error(f"Ошибка при создании пользователя {user.username}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def get_user_by_username(self, username: str) -> Optional[dict]:
+        """Получает пользователя по имени"""
+        try:
+            if not os.path.exists(self.file_path):
+                logger.info(f"Файл {self.file_path} не существует, пользователь {username} не найден")
+                return None
+            data = self._read_data()
+            for user in data["users"]:
+                if user["username"] == username:
+                    return user
+            return None
+        except Exception as e:
+            logger.error(f"Ошибка при получении пользователя {username}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def verify_password(self, plain_password: str, hashed_password: str) -> bool:
+        """Проверяет пароль"""
+        return self.pwd_context.verify(plain_password, hashed_password)
--- a/SRV/storage/session_storage.py
+++ b/SRV/storage/session_storage.py
@ -0,0 +1,141 @@
+# storage/session_storage.py
+import json
+import os
+import uuid
+import logging
+from typing import Optional, Dict
+from datetime import datetime, timedelta
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SessionStorage:
+    def __init__(self, file_path: str = "/etc/gonets/sessions.json"):
+        self.file_path = file_path
+        self._ensure_file_exists()
+
+    def _ensure_file_exists(self):
+        try:
+            logger.info(f"Проверка существования файла {self.file_path}")
+            if not os.path.exists(self.file_path):
+                logger.info(f"Создание директории {os.path.dirname(self.file_path)}")
+                os.makedirs(os.path.dirname(self.file_path), exist_ok=True)
+                logger.info(f"Создание файла {self.file_path}")
+                with open(self.file_path, "w") as f:
+                    json.dump({"sessions": {}}, f)
+                os.chmod(self.file_path, 0o600)
+                logger.info(f"Создан файл {self.file_path}")
+            else:
+                logger.info(f"Файл {self.file_path} уже существует")
+        except Exception as e:
+            logger.error(f"Ошибка при создании файла {self.file_path}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def _read_data(self) -> Dict:
+        try:
+            with open(self.file_path, "r") as f:
+                return json.load(f)
+        except Exception as e:
+            logger.error(f"Ошибка при чтении файла {self.file_path}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def _write_data(self, data: Dict):
+        try:
+            with open(self.file_path, "w") as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            logger.error(f"Ошибка при записи файла {self.file_path}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def create_session(self, username: str, token: str, client_id: str) -> str:
+        """Создаёт новую сессию и возвращает session_id"""
+        try:
+            self.clean_expired_sessions()
+            data = self._read_data()
+            session_id = str(uuid.uuid4())
+            created_at = datetime.utcnow().isoformat()
+            expiry = (datetime.utcnow() + timedelta(minutes=30)).isoformat()
+            data["sessions"][session_id] = {
+                "username": username,
+                "token": token,
+                "client_id": client_id,
+                "created_at": created_at,
+                "expiry": expiry
+            }
+            self._write_data(data)
+            logger.info(f"Сессия создана для пользователя {username} с session_id {session_id}")
+            return session_id
+        except Exception as e:
+            logger.error(f"Ошибка при создании сессии для {username}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def get_latest_session(self, client_id: str) -> Optional[Dict]:
+        """Получает последнюю активную сессию для client_id"""
+        try:
+            self.clean_expired_sessions()
+            data = self._read_data()
+            latest_session = None
+            latest_time = None
+            for session_id, session in data["sessions"].items():
+                if session["client_id"] == client_id:
+                    expiry = datetime.fromisoformat(session["expiry"])
+                    if datetime.utcnow() > expiry:
+                        logger.info(f"Сессия {session_id} истекла")
+                        del data["sessions"][session_id]
+                        continue
+                    created_at = datetime.fromisoformat(session["created_at"])
+                    if latest_time is None or created_at > latest_time:
+                        latest_time = created_at
+                        latest_session = session
+                        latest_session["session_id"] = session_id
+            if latest_session:
+                logger.info(f"Найдена сессия для client_id {client_id}")
+                return latest_session
+            logger.info(f"Сессия для client_id {client_id} не найдена")
+            self._write_data(data)
+            return None
+        except Exception as e:
+            logger.error(f"Ошибка при получении сессии для client_id {client_id}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def delete_session(self, session_id: str):
+        """Удаляет сессию по session_id"""
+        try:
+            self.clean_expired_sessions()
+            data = self._read_data()
+            if session_id in data["sessions"]:
+                del data["sessions"][session_id]
+                self._write_data(data)
+                logger.info(f"Сессия с session_id {session_id} удалена")
+        except Exception as e:
+            logger.error(f"Ошибка при удалении сессии {session_id}: {type(e).__name__} - {str(e)}")
+            raise
+
+    def clean_expired_sessions(self):
+        """Удаляет все истекшие сессии из хранилища"""
+        try:
+            data = self._read_data()
+            expired_sessions = []
+            current_time = datetime.utcnow()
+
+            # Находим истекшие сессии
+            for session_id, session in list(data["sessions"].items()):
+                expiry = datetime.fromisoformat(session["expiry"])
+                if current_time > expiry:
+                    expired_sessions.append(session_id)
+
+            # Удаляем истекшие сессии
+            for session_id in expired_sessions:
+                del data["sessions"][session_id]
+                logger.info(f"Удалена истекшая сессия с session_id {session_id}")
+
+            # Записываем обновлённые данные
+            if expired_sessions:
+                self._write_data(data)
+                logger.info(f"Удалено {len(expired_sessions)} истекших сессий")
+            else:
+                logger.debug("Истекшие сессии не найдены")
+
+        except Exception as e:
+            logger.error(f"Ошибка при очистке истекших сессий: {type(e).__name__} - {str(e)}")
+            raise