fixes

app/api/__init__.py

@@ -46,6 +46,16 @@ class EnhancedSanic(Sanic):
             await cache.redis.ping()
             logger.info("Redis cache initialized")
             
+            # Initialize ed25519 cryptographic module
+            try:
+                from app.core.crypto import init_ed25519_manager
+                await init_ed25519_manager()
+                logger.info("Ed25519 cryptographic module initialized")
+            except ImportError:
+                logger.warning("Ed25519 module not available")
+            except Exception as e:
+                logger.error("Failed to initialize ed25519 module", error=str(e))
+            
             # Run custom startup tasks
             for task in self.ctx.startup_tasks:
                 try:
@@ -232,6 +242,9 @@ def register_routes():
     from app.api.routes.storage_routes import storage_bp
     from app.api.routes.blockchain_routes import blockchain_bp
     
+    # Import node communication blueprint
+    from app.api.node_communication import node_bp
+    
     # Импортировать существующие маршруты
     try:
         from app.api.routes._system import bp as system_bp
@@ -248,6 +261,7 @@ def register_routes():
     app.blueprint(content_bp)
     app.blueprint(storage_bp)
     app.blueprint(blockchain_bp)
+    app.blueprint(node_bp)  # Межузловое общение с ed25519
     
     # Register optional blueprints
     if user_bp:

app/api/middleware.py

@@ -1,5 +1,5 @@
 """
-Enhanced API middleware with security, rate limiting, and monitoring
+Enhanced API middleware with security, rate limiting, monitoring and ed25519 signatures
 """
 import asyncio
 import time
@@ -24,6 +24,13 @@ from app.core.logging import request_id_var, user_id_var, operation_var, log_per
 from app.core.models.user import User
 from app.core.models.base import BaseModel
 
+# Ed25519 криптографический модуль
+try:
+    from app.core.crypto import get_ed25519_manager
+    CRYPTO_AVAILABLE = True
+except ImportError:
+    CRYPTO_AVAILABLE = False
+
 logger = structlog.get_logger(__name__)
 
 
@@ -266,6 +273,98 @@ class AuthenticationMiddleware:
         return True
 
 
+class CryptographicMiddleware:
+    """Ed25519 cryptographic middleware for inter-node communication"""
+    
+    @staticmethod
+    async def verify_inter_node_signature(request: Request) -> bool:
+        """Проверить ed25519 подпись для межузлового сообщения"""
+        if not CRYPTO_AVAILABLE:
+            logger.warning("Crypto module not available, skipping signature verification")
+            return True
+        
+        # Проверяем, является ли это межузловым сообщением
+        if not request.headers.get("X-Node-Communication") == "true":
+            return True  # Не межузловое сообщение, пропускаем проверку
+        
+        try:
+            crypto_manager = get_ed25519_manager()
+            
+            # Получаем необходимые заголовки
+            signature = request.headers.get("X-Node-Signature")
+            node_id = request.headers.get("X-Node-ID")
+            public_key = request.headers.get("X-Node-Public-Key")
+            
+            if not all([signature, node_id, public_key]):
+                logger.warning("Missing cryptographic headers in inter-node request")
+                return False
+            
+            # Читаем тело сообщения для проверки подписи
+            if hasattr(request, 'body') and request.body:
+                try:
+                    message_data = json.loads(request.body.decode())
+                    
+                    # Проверяем подпись
+                    is_valid = crypto_manager.verify_signature(
+                        message_data, signature, public_key
+                    )
+                    
+                    if is_valid:
+                        logger.debug(f"Valid signature verified for node {node_id}")
+                        # Сохраняем информацию о ноде в контексте
+                        request.ctx.inter_node_communication = True
+                        request.ctx.source_node_id = node_id
+                        request.ctx.source_public_key = public_key
+                        return True
+                    else:
+                        logger.warning(f"Invalid signature from node {node_id}")
+                        return False
+                        
+                except json.JSONDecodeError:
+                    logger.warning("Invalid JSON in inter-node request")
+                    return False
+            else:
+                logger.warning("Empty body in inter-node request")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Crypto verification error: {e}")
+            return False
+    
+    @staticmethod
+    async def add_inter_node_headers(request: Request, response: HTTPResponse) -> HTTPResponse:
+        """Добавить криптографические заголовки для межузловых ответов"""
+        if not CRYPTO_AVAILABLE:
+            return response
+        
+        # Добавляем заголовки только для межузловых сообщений
+        if hasattr(request.ctx, 'inter_node_communication') and request.ctx.inter_node_communication:
+            try:
+                crypto_manager = get_ed25519_manager()
+                
+                # Добавляем информацию о нашей ноде
+                response.headers.update({
+                    "X-Node-ID": crypto_manager.node_id,
+                    "X-Node-Public-Key": crypto_manager.public_key_hex,
+                    "X-Node-Communication": "true"
+                })
+                
+                # Если есть тело ответа, подписываем его
+                if response.body:
+                    try:
+                        response_data = json.loads(response.body.decode())
+                        signature = crypto_manager.sign_message(response_data)
+                        response.headers["X-Node-Signature"] = signature
+                    except json.JSONDecodeError:
+                        # Не JSON тело, пропускаем подпись
+                        pass
+                        
+            except Exception as e:
+                logger.error(f"Error adding inter-node headers: {e}")
+        
+        return response
+
+
 class RequestContextMiddleware:
     """Request context middleware for tracking and logging"""
     
@@ -338,6 +437,7 @@ security_middleware = SecurityMiddleware()
 rate_limit_middleware = RateLimitMiddleware()
 auth_middleware = AuthenticationMiddleware()
 context_middleware = RequestContextMiddleware()
+crypto_middleware = CryptographicMiddleware()
 
 
 async def request_middleware(request: Request):
@@ -351,6 +451,15 @@ async def request_middleware(request: Request):
     # Add request context
     await context_middleware.add_request_context(request)
     
+    # Cryptographic signature verification for inter-node communication
+    if not await crypto_middleware.verify_inter_node_signature(request):
+        logger.warning("Inter-node signature verification failed")
+        response = json_response({
+            "error": "Invalid cryptographic signature",
+            "message": "Inter-node communication requires valid ed25519 signature"
+        }, status=403)
+        return security_middleware.add_security_headers(response)
+    
     # Security validations
     try:
         security_middleware.validate_request_size(request)
@@ -423,6 +532,9 @@ async def response_middleware(request: Request, response: HTTPResponse):
     # Add security headers
     response = security_middleware.add_security_headers(response)
     
+    # Add cryptographic headers for inter-node communication
+    response = await crypto_middleware.add_inter_node_headers(request, response)
+    
     # Add rate limit headers
     if hasattr(request.ctx, 'rate_limit_info') and request.ctx.rate_limit_info:
         rate_info = request.ctx.rate_limit_info

app/api/node_communication.py

@@ -0,0 +1,378 @@
+"""
+API endpoints для межузлового общения с ed25519 подписями
+"""
+import json
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+from sanic import Blueprint, Request
+from sanic.response import json as json_response
+
+from app.core.crypto import get_ed25519_manager
+from app.core.logging import get_logger
+from app.api.middleware import auth_required, validate_json
+
+logger = get_logger(__name__)
+
+# Blueprint для межузловых коммуникаций
+node_bp = Blueprint("node", url_prefix="/api/node")
+
+
+async def validate_node_request(request: Request) -> Dict[str, Any]:
+    """Валидация межузлового запроса с обязательной проверкой подписи"""
+    # Проверяем наличие обязательных заголовков
+    required_headers = ["X-Node-Communication", "X-Node-ID", "X-Node-Public-Key", "X-Node-Signature"]
+    for header in required_headers:
+        if not request.headers.get(header):
+            raise ValueError(f"Missing required header: {header}")
+    
+    # Проверяем, что это межузловое общение
+    if request.headers.get("X-Node-Communication") != "true":
+        raise ValueError("Not a valid inter-node communication")
+    
+    # Информация о ноде уже проверена в middleware
+    node_id = request.ctx.source_node_id
+    public_key = request.ctx.source_public_key
+    
+    # Получаем данные сообщения
+    if not hasattr(request, 'json') or not request.json:
+        raise ValueError("Empty message body")
+    
+    return {
+        "node_id": node_id,
+        "public_key": public_key,
+        "message": request.json
+    }
+
+
+async def create_node_response(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Создать ответ для межузлового общения с подписью"""
+    crypto_manager = get_ed25519_manager()
+    
+    # Добавляем информацию о нашей ноде
+    response_data = {
+        "success": True,
+        "timestamp": datetime.utcnow().isoformat(),
+        "node_id": crypto_manager.node_id,
+        "data": data
+    }
+    
+    return response_data
+
+
+@node_bp.route("/handshake", methods=["POST"])
+async def node_handshake(request: Request):
+    """
+    Обработка хэндшейка между нодами
+    
+    Ожидаемый формат сообщения:
+    {
+        "action": "handshake",
+        "node_info": {
+            "node_id": "...",
+            "version": "...",
+            "capabilities": [...],
+            "network_info": {...}
+        },
+        "timestamp": "..."
+    }
+    """
+    try:
+        # Валидация межузлового запроса
+        node_data = await validate_node_request(request)
+        message = node_data["message"]
+        source_node_id = node_data["node_id"]
+        
+        logger.info(f"Handshake request from node {source_node_id}")
+        
+        # Проверяем формат сообщения хэндшейка
+        if message.get("action") != "handshake":
+            return json_response({
+                "success": False,
+                "error": "Invalid handshake message format"
+            }, status=400)
+        
+        node_info = message.get("node_info", {})
+        if not node_info.get("node_id") or not node_info.get("version"):
+            return json_response({
+                "success": False,
+                "error": "Missing required node information"
+            }, status=400)
+        
+        # Создаем информацию о нашей ноде для ответа
+        crypto_manager = get_ed25519_manager()
+        our_node_info = {
+            "node_id": crypto_manager.node_id,
+            "version": "3.0.0",  # Версия MY Network
+            "capabilities": [
+                "content_upload",
+                "content_sync",
+                "decentralized_filtering",
+                "ed25519_signatures"
+            ],
+            "network_info": {
+                "public_key": crypto_manager.public_key_hex,
+                "protocol_version": "1.0"
+            }
+        }
+        
+        # Сохраняем информацию о ноде (здесь можно добавить в базу данных)
+        logger.info(f"Successful handshake with node {source_node_id}", 
+                   extra={"peer_node_info": node_info})
+        
+        response_data = await create_node_response({
+            "handshake_accepted": True,
+            "node_info": our_node_info
+        })
+        
+        return json_response(response_data)
+        
+    except ValueError as e:
+        logger.warning(f"Invalid handshake request: {e}")
+        return json_response({
+            "success": False,
+            "error": str(e)
+        }, status=400)
+    
+    except Exception as e:
+        logger.error(f"Handshake error: {e}")
+        return json_response({
+            "success": False,
+            "error": "Internal server error"
+        }, status=500)
+
+
+@node_bp.route("/content/sync", methods=["POST"])
+async def content_sync(request: Request):
+    """
+    Синхронизация контента между нодами
+    
+    Ожидаемый формат сообщения:
+    {
+        "action": "content_sync",
+        "sync_type": "new_content|content_list|content_request",
+        "content_info": {...},
+        "timestamp": "..."
+    }
+    """
+    try:
+        # Валидация межузлового запроса
+        node_data = await validate_node_request(request)
+        message = node_data["message"]
+        source_node_id = node_data["node_id"]
+        
+        logger.info(f"Content sync request from node {source_node_id}")
+        
+        # Проверяем формат сообщения синхронизации
+        if message.get("action") != "content_sync":
+            return json_response({
+                "success": False,
+                "error": "Invalid sync message format"
+            }, status=400)
+        
+        sync_type = message.get("sync_type")
+        content_info = message.get("content_info", {})
+        
+        if sync_type == "new_content":
+            # Обработка нового контента от другой ноды
+            content_hash = content_info.get("hash")
+            if not content_hash:
+                return json_response({
+                    "success": False,
+                    "error": "Missing content hash"
+                }, status=400)
+            
+            # Здесь добавить логику обработки нового контента
+            # через decentralized_filter и content_storage_manager
+            
+            response_data = await create_node_response({
+                "sync_result": "content_accepted",
+                "content_hash": content_hash
+            })
+            
+        elif sync_type == "content_list":
+            # Запрос списка доступного контента
+            # Здесь добавить логику получения списка контента
+            
+            response_data = await create_node_response({
+                "content_list": [],  # Заглушка - добавить реальный список
+                "total_items": 0
+            })
+            
+        elif sync_type == "content_request":
+            # Запрос конкретного контента
+            requested_hash = content_info.get("hash")
+            if not requested_hash:
+                return json_response({
+                    "success": False,
+                    "error": "Missing content hash for request"
+                }, status=400)
+            
+            # Здесь добавить логику поиска и передачи контента
+            
+            response_data = await create_node_response({
+                "content_found": False,  # Заглушка - добавить реальную проверку
+                "content_hash": requested_hash
+            })
+            
+        else:
+            return json_response({
+                "success": False,
+                "error": f"Unknown sync type: {sync_type}"
+            }, status=400)
+        
+        return json_response(response_data)
+        
+    except ValueError as e:
+        logger.warning(f"Invalid sync request: {e}")
+        return json_response({
+            "success": False,
+            "error": str(e)
+        }, status=400)
+    
+    except Exception as e:
+        logger.error(f"Content sync error: {e}")
+        return json_response({
+            "success": False,
+            "error": "Internal server error"
+        }, status=500)
+
+
+@node_bp.route("/network/ping", methods=["POST"])
+async def network_ping(request: Request):
+    """
+    Пинг между нодами для проверки доступности
+    
+    Ожидаемый формат сообщения:
+    {
+        "action": "ping",
+        "timestamp": "...",
+        "data": {...}
+    }
+    """
+    try:
+        # Валидация межузлового запроса
+        node_data = await validate_node_request(request)
+        message = node_data["message"]
+        source_node_id = node_data["node_id"]
+        
+        logger.debug(f"Ping from node {source_node_id}")
+        
+        # Проверяем формат пинга
+        if message.get("action") != "ping":
+            return json_response({
+                "success": False,
+                "error": "Invalid ping message format"
+            }, status=400)
+        
+        # Создаем ответ pong
+        response_data = await create_node_response({
+            "action": "pong",
+            "ping_timestamp": message.get("timestamp"),
+            "response_timestamp": datetime.utcnow().isoformat()
+        })
+        
+        return json_response(response_data)
+        
+    except ValueError as e:
+        logger.warning(f"Invalid ping request: {e}")
+        return json_response({
+            "success": False,
+            "error": str(e)
+        }, status=400)
+    
+    except Exception as e:
+        logger.error(f"Ping error: {e}")
+        return json_response({
+            "success": False,
+            "error": "Internal server error"
+        }, status=500)
+
+
+@node_bp.route("/network/status", methods=["GET"])
+async def network_status(request: Request):
+    """
+    Получение статуса ноды (без обязательной подписи для GET запросов)
+    """
+    try:
+        crypto_manager = get_ed25519_manager()
+        
+        status_data = {
+            "node_id": crypto_manager.node_id,
+            "public_key": crypto_manager.public_key_hex,
+            "version": "3.0.0",
+            "status": "active",
+            "capabilities": [
+                "content_upload",
+                "content_sync", 
+                "decentralized_filtering",
+                "ed25519_signatures"
+            ],
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        return json_response({
+            "success": True,
+            "data": status_data
+        })
+        
+    except Exception as e:
+        logger.error(f"Status error: {e}")
+        return json_response({
+            "success": False,
+            "error": "Internal server error"
+        }, status=500)
+
+
+@node_bp.route("/network/discover", methods=["POST"]) 
+async def network_discover(request: Request):
+    """
+    Обнаружение и обмен информацией о других нодах в сети
+    
+    Ожидаемый формат сообщения:
+    {
+        "action": "discover",
+        "known_nodes": [...],
+        "timestamp": "..."
+    }
+    """
+    try:
+        # Валидация межузлового запроса
+        node_data = await validate_node_request(request)
+        message = node_data["message"]
+        source_node_id = node_data["node_id"]
+        
+        logger.info(f"Discovery request from node {source_node_id}")
+        
+        # Проверяем формат сообщения
+        if message.get("action") != "discover":
+            return json_response({
+                "success": False,
+                "error": "Invalid discovery message format"
+            }, status=400)
+        
+        known_nodes = message.get("known_nodes", [])
+        
+        # Здесь добавить логику обработки информации о известных нодах
+        # и возврат информации о наших известных нодах
+        
+        response_data = await create_node_response({
+            "known_nodes": [],  # Заглушка - добавить реальный список
+            "discovery_timestamp": datetime.utcnow().isoformat()
+        })
+        
+        return json_response(response_data)
+        
+    except ValueError as e:
+        logger.warning(f"Invalid discovery request: {e}")
+        return json_response({
+            "success": False,
+            "error": str(e)
+        }, status=400)
+    
+    except Exception as e:
+        logger.error(f"Discovery error: {e}")
+        return json_response({
+            "success": False,
+            "error": "Internal server error"
+        }, status=500)

app/core/crypto/__init__.py

@@ -0,0 +1,13 @@
+"""
+MY Network v3.0 - Cryptographic Module for uploader-bot
+
+Модуль криптографических операций для защиты inter-node коммуникаций.
+"""
+
+from .ed25519_manager import Ed25519Manager, get_ed25519_manager, init_ed25519_manager
+
+__all__ = [
+    'Ed25519Manager',
+    'get_ed25519_manager', 
+    'init_ed25519_manager'
+]

app/core/crypto/ed25519_manager.py

@@ -0,0 +1,316 @@
+"""
+MY Network v3.0 - Ed25519 Cryptographic Manager for uploader-bot
+
+Модуль для работы с ed25519 ключами и подписями.
+Все inter-node сообщения должны быть подписаны и проверены.
+"""
+
+import os
+import base64
+import json
+import hashlib
+from typing import Dict, Any, Optional, Tuple
+from pathlib import Path
+import logging
+import time
+
+try:
+    import ed25519
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric import ed25519 as crypto_ed25519
+except ImportError as e:
+    logging.error(f"Required cryptographic libraries not found: {e}")
+    raise ImportError("Please install: pip install ed25519 cryptography")
+
+logger = logging.getLogger(__name__)
+
+
+class Ed25519Manager:
+    """Менеджер для ed25519 криптографических операций в uploader-bot"""
+    
+    def __init__(self, private_key_path: Optional[str] = None, public_key_path: Optional[str] = None):
+        """
+        Инициализация Ed25519Manager
+        
+        Args:
+            private_key_path: Путь к приватному ключу
+            public_key_path: Путь к публичному ключу
+        """
+        self.private_key_path = private_key_path or os.getenv('NODE_PRIVATE_KEY_PATH')
+        self.public_key_path = public_key_path or os.getenv('NODE_PUBLIC_KEY_PATH')
+        
+        self._private_key = None
+        self._public_key = None
+        self._node_id = None
+        
+        # Загружаем ключи при инициализации
+        self._load_keys()
+        
+    def _load_keys(self) -> None:
+        """Загрузка ключей из файлов"""
+        try:
+            # Загрузка приватного ключа
+            if self.private_key_path and os.path.exists(self.private_key_path):
+                with open(self.private_key_path, 'rb') as f:
+                    private_key_data = f.read()
+                
+                # Загружаем PEM ключ
+                self._private_key = serialization.load_pem_private_key(
+                    private_key_data, 
+                    password=None
+                )
+                
+                # Получаем публичный ключ из приватного
+                self._public_key = self._private_key.public_key()
+                
+                # Генерируем NODE_ID из публичного ключа
+                self._node_id = self._generate_node_id()
+                
+                logger.info(f"Ed25519 ключи загружены. Node ID: {self._node_id}")
+                
+            else:
+                logger.warning(f"Private key file not found: {self.private_key_path}")
+                
+        except Exception as e:
+            logger.error(f"Error loading Ed25519 keys: {e}")
+            raise
+    
+    def _generate_node_id(self) -> str:
+        """Генерация NODE_ID из публичного ключа"""
+        if not self._public_key:
+            raise ValueError("Public key not loaded")
+        
+        # Получаем raw bytes публичного ключа
+        public_key_bytes = self._public_key.public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw
+        )
+        
+        # Создаем упрощенный base58-подобный NODE_ID
+        # В реальной реализации здесь должен быть полный base58
+        hex_key = public_key_bytes.hex()
+        return f"node-{hex_key[:16]}"
+    
+    @property
+    def node_id(self) -> str:
+        """Получить NODE_ID"""
+        if not self._node_id:
+            raise ValueError("Node ID not generated. Check if keys are loaded.")
+        return self._node_id
+    
+    @property
+    def public_key_hex(self) -> str:
+        """Получить публичный ключ в hex формате"""
+        if not self._public_key:
+            raise ValueError("Public key not loaded")
+        
+        public_key_bytes = self._public_key.public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw
+        )
+        return public_key_bytes.hex()
+    
+    def sign_message(self, message: Dict[str, Any]) -> str:
+        """
+        Подписать сообщение ed25519 ключом
+        
+        Args:
+            message: Словарь с данными для подписи
+            
+        Returns:
+            base64-encoded подпись
+        """
+        if not self._private_key:
+            raise ValueError("Private key not loaded")
+        
+        # Сериализуем сообщение в JSON для подписи
+        message_json = json.dumps(message, sort_keys=True, ensure_ascii=False)
+        message_bytes = message_json.encode('utf-8')
+        
+        # Создаем хеш сообщения для подписи
+        message_hash = hashlib.sha256(message_bytes).digest()
+        
+        # Подписываем хеш
+        signature = self._private_key.sign(message_hash)
+        
+        # Возвращаем подпись в base64
+        return base64.b64encode(signature).decode('ascii')
+    
+    def verify_signature(self, message: Dict[str, Any], signature: str, public_key_hex: str) -> bool:
+        """
+        Проверить подпись сообщения
+        
+        Args:
+            message: Словарь с данными
+            signature: base64-encoded подпись
+            public_key_hex: Публичный ключ в hex формате
+            
+        Returns:
+            True если подпись валидна
+        """
+        try:
+            # Восстанавливаем публичный ключ из hex
+            public_key_bytes = bytes.fromhex(public_key_hex)
+            public_key = crypto_ed25519.Ed25519PublicKey.from_public_bytes(public_key_bytes)
+            
+            # Сериализуем сообщение так же как при подписи
+            message_json = json.dumps(message, sort_keys=True, ensure_ascii=False)
+            message_bytes = message_json.encode('utf-8')
+            message_hash = hashlib.sha256(message_bytes).digest()
+            
+            # Декодируем подпись
+            signature_bytes = base64.b64decode(signature.encode('ascii'))
+            
+            # Проверяем подпись
+            public_key.verify(signature_bytes, message_hash)
+            return True
+            
+        except Exception as e:
+            logger.warning(f"Signature verification failed: {e}")
+            return False
+    
+    def create_signed_message(self, message_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Создать подписанное сообщение для отправки
+        
+        Args:
+            message_type: Тип сообщения (handshake, sync_request, etc.)
+            data: Данные сообщения
+            
+        Returns:
+            Подписанное сообщение
+        """
+        # Основная структура сообщения
+        message = {
+            "type": message_type,
+            "node_id": self.node_id,
+            "public_key": self.public_key_hex,
+            "timestamp": int(time.time()),
+            "data": data
+        }
+        
+        # Подписываем сообщение
+        signature = self.sign_message(message)
+        
+        # Добавляем подпись
+        signed_message = message.copy()
+        signed_message["signature"] = signature
+        
+        return signed_message
+    
+    def verify_incoming_message(self, message: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
+        """
+        Проверить входящее подписанное сообщение
+        
+        Args:
+            message: Входящее сообщение
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        try:
+            # Проверяем обязательные поля
+            required_fields = ["type", "node_id", "public_key", "timestamp", "data", "signature"]
+            for field in required_fields:
+                if field not in message:
+                    return False, f"Missing required field: {field}"
+            
+            # Извлекаем подпись и создаем сообщение без подписи для проверки
+            signature = message.pop("signature")
+            
+            # Проверяем подпись
+            is_valid = self.verify_signature(message, signature, message["public_key"])
+            
+            if not is_valid:
+                return False, "Invalid signature"
+            
+            # Проверяем временную метку (не старше 5 минут)
+            current_time = int(time.time())
+            if abs(current_time - message["timestamp"]) > 300:
+                return False, "Message timestamp too old"
+            
+            return True, None
+            
+        except Exception as e:
+            return False, f"Verification error: {str(e)}"
+    
+    def create_handshake_message(self, target_node_id: str, additional_data: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Создать сообщение для handshake с другой нодой
+        
+        Args:
+            target_node_id: ID целевой ноды
+            additional_data: Дополнительные данные
+            
+        Returns:
+            Подписанное handshake сообщение
+        """
+        handshake_data = {
+            "target_node_id": target_node_id,
+            "protocol_version": "3.0",
+            "node_type": os.getenv("NODE_TYPE", "uploader"),
+            "capabilities": ["upload", "content_streaming", "conversion", "storage"]
+        }
+        
+        if additional_data:
+            handshake_data.update(additional_data)
+        
+        return self.create_signed_message("handshake", handshake_data)
+    
+    def create_upload_message(self, content_hash: str, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Создать подписанное сообщение для загрузки контента
+        
+        Args:
+            content_hash: Хеш контента
+            metadata: Метаданные файла
+            
+        Returns:
+            Подписанное upload сообщение
+        """
+        upload_data = {
+            "content_hash": content_hash,
+            "metadata": metadata,
+            "uploader_node": self.node_id,
+            "upload_timestamp": int(time.time())
+        }
+        
+        return self.create_signed_message("content_upload", upload_data)
+    
+    def create_sync_message(self, content_list: list, operation: str = "announce") -> Dict[str, Any]:
+        """
+        Создать сообщение для синхронизации контента
+        
+        Args:
+            content_list: Список контента для синхронизации
+            operation: Тип операции (announce, request, response)
+            
+        Returns:
+            Подписанное sync сообщение
+        """
+        sync_data = {
+            "operation": operation,
+            "content_list": content_list,
+            "sync_id": hashlib.sha256(
+                (self.node_id + str(int(time.time()))).encode()
+            ).hexdigest()[:16]
+        }
+        
+        return self.create_signed_message("content_sync", sync_data)
+
+
+# Глобальный экземпляр менеджера
+_ed25519_manager = None
+
+def get_ed25519_manager() -> Ed25519Manager:
+    """Получить глобальный экземпляр Ed25519Manager"""
+    global _ed25519_manager
+    if _ed25519_manager is None:
+        _ed25519_manager = Ed25519Manager()
+    return _ed25519_manager
+
+def init_ed25519_manager(private_key_path: str, public_key_path: str) -> Ed25519Manager:
+    """Инициализировать Ed25519Manager с путями к ключам"""
+    global _ed25519_manager
+    _ed25519_manager = Ed25519Manager(private_key_path, public_key_path)
+    return _ed25519_manager

app/core/network/node_client.py

@@ -0,0 +1,486 @@
+"""
+Клиент для межузлового общения с ed25519 подписями
+"""
+import asyncio
+import json
+import aiohttp
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+from urllib.parse import urljoin
+
+from app.core.crypto import get_ed25519_manager
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class NodeClient:
+    """Клиент для подписанного межузлового общения"""
+    
+    def __init__(self, timeout: int = 30):
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self.session: Optional[aiohttp.ClientSession] = None
+        
+    async def __aenter__(self):
+        """Async context manager entry"""
+        self.session = aiohttp.ClientSession(timeout=self.timeout)
+        return self
+        
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        if self.session:
+            await self.session.close()
+            
+    async def _create_signed_request(
+        self, 
+        action: str, 
+        data: Dict[str, Any],
+        target_url: str
+    ) -> Dict[str, Any]:
+        """
+        Создать подписанный запрос для межузлового общения
+        
+        Args:
+            action: Тип действия (handshake, content_sync, ping, etc.)
+            data: Данные сообщения
+            target_url: URL целевой ноды
+            
+        Returns:
+            Заголовки и тело запроса
+        """
+        crypto_manager = get_ed25519_manager()
+        
+        # Создаем сообщение
+        message = {
+            "action": action,
+            "timestamp": datetime.utcnow().isoformat(),
+            **data
+        }
+        
+        # Подписываем сообщение
+        signature = crypto_manager.sign_message(message)
+        
+        # Создаем заголовки
+        headers = {
+            "Content-Type": "application/json",
+            "X-Node-Communication": "true",
+            "X-Node-ID": crypto_manager.node_id,
+            "X-Node-Public-Key": crypto_manager.public_key_hex,
+            "X-Node-Signature": signature
+        }
+        
+        return {
+            "headers": headers,
+            "json": message
+        }
+    
+    async def send_handshake(
+        self, 
+        target_url: str, 
+        our_node_info: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Отправить хэндшейк ноде
+        
+        Args:
+            target_url: URL целевой ноды (например, "http://node.example.com:8000")
+            our_node_info: Информация о нашей ноде
+            
+        Returns:
+            Ответ от ноды или информация об ошибке
+        """
+        endpoint_url = urljoin(target_url, "/api/node/handshake")
+        
+        try:
+            request_data = await self._create_signed_request(
+                "handshake",
+                {"node_info": our_node_info},
+                target_url
+            )
+            
+            logger.info(f"Sending handshake to {target_url}")
+            
+            async with self.session.post(endpoint_url, **request_data) as response:
+                response_data = await response.json()
+                
+                if response.status == 200:
+                    logger.info(f"Handshake successful with {target_url}")
+                    return {
+                        "success": True,
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                else:
+                    logger.warning(f"Handshake failed with {target_url}: {response.status}")
+                    return {
+                        "success": False,
+                        "error": f"HTTP {response.status}",
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                    
+        except asyncio.TimeoutError:
+            logger.warning(f"Handshake timeout with {target_url}")
+            return {
+                "success": False,
+                "error": "timeout",
+                "node_url": target_url
+            }
+        except Exception as e:
+            logger.error(f"Handshake error with {target_url}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "node_url": target_url
+            }
+    
+    async def send_content_sync(
+        self, 
+        target_url: str, 
+        sync_type: str,
+        content_info: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Отправить запрос синхронизации контента
+        
+        Args:
+            target_url: URL целевой ноды
+            sync_type: Тип синхронизации (new_content, content_list, content_request)
+            content_info: Информация о контенте
+            
+        Returns:
+            Ответ от ноды
+        """
+        endpoint_url = urljoin(target_url, "/api/node/content/sync")
+        
+        try:
+            request_data = await self._create_signed_request(
+                "content_sync",
+                {
+                    "sync_type": sync_type,
+                    "content_info": content_info
+                },
+                target_url
+            )
+            
+            logger.info(f"Sending content sync ({sync_type}) to {target_url}")
+            
+            async with self.session.post(endpoint_url, **request_data) as response:
+                response_data = await response.json()
+                
+                if response.status == 200:
+                    logger.debug(f"Content sync successful with {target_url}")
+                    return {
+                        "success": True,
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                else:
+                    logger.warning(f"Content sync failed with {target_url}: {response.status}")
+                    return {
+                        "success": False,
+                        "error": f"HTTP {response.status}",
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                    
+        except Exception as e:
+            logger.error(f"Content sync error with {target_url}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "node_url": target_url
+            }
+    
+    async def send_ping(self, target_url: str) -> Dict[str, Any]:
+        """
+        Отправить пинг ноде
+        
+        Args:
+            target_url: URL целевой ноды
+            
+        Returns:
+            Ответ от ноды (pong)
+        """
+        endpoint_url = urljoin(target_url, "/api/node/network/ping")
+        
+        try:
+            request_data = await self._create_signed_request(
+                "ping",
+                {"data": {"test": True}},
+                target_url
+            )
+            
+            start_time = datetime.utcnow()
+            
+            async with self.session.post(endpoint_url, **request_data) as response:
+                end_time = datetime.utcnow()
+                duration = (end_time - start_time).total_seconds() * 1000  # ms
+                
+                response_data = await response.json()
+                
+                if response.status == 200:
+                    return {
+                        "success": True,
+                        "data": response_data,
+                        "latency_ms": round(duration, 2),
+                        "node_url": target_url
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": f"HTTP {response.status}",
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                    
+        except Exception as e:
+            logger.error(f"Ping error with {target_url}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "node_url": target_url
+            }
+    
+    async def get_node_status(self, target_url: str) -> Dict[str, Any]:
+        """
+        Получить статус ноды (GET запрос без подписи)
+        
+        Args:
+            target_url: URL целевой ноды
+            
+        Returns:
+            Статус ноды
+        """
+        endpoint_url = urljoin(target_url, "/api/node/network/status")
+        
+        try:
+            async with self.session.get(endpoint_url) as response:
+                response_data = await response.json()
+                
+                if response.status == 200:
+                    return {
+                        "success": True,
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": f"HTTP {response.status}",
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                    
+        except Exception as e:
+            logger.error(f"Status request error with {target_url}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "node_url": target_url
+            }
+    
+    async def send_discovery(
+        self, 
+        target_url: str, 
+        known_nodes: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Отправить запрос обнаружения нод
+        
+        Args:
+            target_url: URL целевой ноды
+            known_nodes: Список известных нам нод
+            
+        Returns:
+            Список нод от целевой ноды
+        """
+        endpoint_url = urljoin(target_url, "/api/node/network/discover")
+        
+        try:
+            request_data = await self._create_signed_request(
+                "discover",
+                {"known_nodes": known_nodes},
+                target_url
+            )
+            
+            logger.info(f"Sending discovery request to {target_url}")
+            
+            async with self.session.post(endpoint_url, **request_data) as response:
+                response_data = await response.json()
+                
+                if response.status == 200:
+                    logger.debug(f"Discovery successful with {target_url}")
+                    return {
+                        "success": True,
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                else:
+                    logger.warning(f"Discovery failed with {target_url}: {response.status}")
+                    return {
+                        "success": False,
+                        "error": f"HTTP {response.status}",
+                        "data": response_data,
+                        "node_url": target_url
+                    }
+                    
+        except Exception as e:
+            logger.error(f"Discovery error with {target_url}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "node_url": target_url
+            }
+
+
+class NodeNetworkManager:
+    """Менеджер для работы с сетью нод"""
+    
+    def __init__(self):
+        self.known_nodes: List[str] = []
+        self.active_nodes: List[str] = []
+        
+    async def discover_nodes(self, bootstrap_nodes: List[str]) -> List[str]:
+        """
+        Обнаружить ноды в сети через bootstrap ноды
+        
+        Args:
+            bootstrap_nodes: Список bootstrap нод для начального подключения
+            
+        Returns:
+            Список обнаруженных активных нод
+        """
+        discovered_nodes = set()
+        
+        async with NodeClient() as client:
+            # Получить информацию о нашей ноде
+            crypto_manager = get_ed25519_manager()
+            our_node_info = {
+                "node_id": crypto_manager.node_id,
+                "version": "3.0.0",
+                "capabilities": [
+                    "content_upload",
+                    "content_sync",
+                    "decentralized_filtering", 
+                    "ed25519_signatures"
+                ],
+                "network_info": {
+                    "public_key": crypto_manager.public_key_hex,
+                    "protocol_version": "1.0"
+                }
+            }
+            
+            # Попробовать подключиться к bootstrap нодам
+            for node_url in bootstrap_nodes:
+                try:
+                    # Выполнить хэндшейк
+                    handshake_result = await client.send_handshake(node_url, our_node_info)
+                    
+                    if handshake_result["success"]:
+                        discovered_nodes.add(node_url)
+                        
+                        # Запросить список известных нод
+                        discovery_result = await client.send_discovery(node_url, list(discovered_nodes))
+                        
+                        if discovery_result["success"]:
+                            # Добавить ноды из ответа
+                            known_nodes = discovery_result["data"]["data"]["known_nodes"]
+                            for node_info in known_nodes:
+                                if "url" in node_info:
+                                    discovered_nodes.add(node_info["url"])
+                                    
+                except Exception as e:
+                    logger.warning(f"Failed to discover through {node_url}: {e}")
+        
+        self.known_nodes = list(discovered_nodes)
+        return self.known_nodes
+    
+    async def check_node_health(self, nodes: List[str]) -> Dict[str, Dict[str, Any]]:
+        """
+        Проверить состояние нод
+        
+        Args:
+            nodes: Список нод для проверки
+            
+        Returns:
+            Словарь с результатами проверки для каждой ноды
+        """
+        results = {}
+        
+        async with NodeClient() as client:
+            # Создаем задачи для параллельной проверки
+            tasks = []
+            for node_url in nodes:
+                task = asyncio.create_task(client.send_ping(node_url))
+                tasks.append((node_url, task))
+            
+            # Ждем завершения всех задач
+            for node_url, task in tasks:
+                try:
+                    result = await task
+                    results[node_url] = result
+                except Exception as e:
+                    results[node_url] = {
+                        "success": False,
+                        "error": str(e),
+                        "node_url": node_url
+                    }
+        
+        # Обновляем список активных нод
+        self.active_nodes = [
+            node_url for node_url, result in results.items()
+            if result.get("success", False)
+        ]
+        
+        return results
+    
+    async def broadcast_content(
+        self, 
+        content_info: Dict[str, Any],
+        target_nodes: Optional[List[str]] = None
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Транслировать информацию о новом контенте всем активным нодам
+        
+        Args:
+            content_info: Информация о контенте
+            target_nodes: Список целевых нод (по умолчанию все активные)
+            
+        Returns:
+            Результаты трансляции для каждой ноды
+        """
+        nodes = target_nodes or self.active_nodes
+        results = {}
+        
+        async with NodeClient() as client:
+            # Создаем задачи для параллельной отправки
+            tasks = []
+            for node_url in nodes:
+                task = asyncio.create_task(
+                    client.send_content_sync(node_url, "new_content", content_info)
+                )
+                tasks.append((node_url, task))
+            
+            # Ждем завершения всех задач
+            for node_url, task in tasks:
+                try:
+                    result = await task
+                    results[node_url] = result
+                except Exception as e:
+                    results[node_url] = {
+                        "success": False,
+                        "error": str(e),
+                        "node_url": node_url
+                    }
+        
+        return results
+
+
+# Глобальный экземпляр менеджера сети
+network_manager = NodeNetworkManager()
+
+
+async def get_network_manager() -> NodeNetworkManager:
+    """Получить глобальный экземпляр менеджера сети"""
+    return network_manager