elo-node 0.4.6__tar.gz → 0.4.8__tar.gz

{elo_node-0.4.6 → elo_node-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elo-node
-Version: 0.4.6
+Version: 0.4.8
 Summary: Elo — malha P2P de mensagens para agentes de IA. Zero infraestrutura.
 Author: Elo Contributors
 License: MIT

{elo_node-0.4.6 → elo_node-0.4.8}/elo/__init__.py

@@ -26,4 +26,4 @@ __all__ = [
     "Node", "Task", "Result", "Event", "NodeInfo", "Capabilities",
     "EphemeralIdentity", "generate_and_save_identity", "load_identity",
 ]
-__version__ = "0.4.6"
+__version__ = "0.4.8"

{elo_node-0.4.6 → elo_node-0.4.8}/elo/node.py

@@ -78,7 +78,7 @@ class Node:
         peers: list[str] | None = None,
         tracker: str = "public",
         allowlist: list[str] | None = None,
-        version: str = "0.4.6",
+        version: str = "0.4.8",
         identity: EphemeralIdentity | None = None,
         verify_peers: bool = True,
         heartbeat_interval_s: int = 30,
@@ -116,6 +116,14 @@ class Node:
         self._pubkey_cache: dict[str, tuple[Any, float]] = {}
         self._cache_ttl_s = heartbeat_interval_s * 5
 
+        # Rate limiting
+        self._msg_count: dict[str, tuple[int, float]] = {}  # peer_addr → (count, window_start)
+        self._hello_count: dict[str, float] = {}             # peer_addr → last_hello_timestamp
+
+        # Cache de query_ids para prevenir broadcast loop
+        self._seen_queries: dict[str, float] = {}
+        self._seen_query_ttl = 60  # segundos
+
     # ── propriedades ──────────────────────────────────────────
 
     @property
@@ -232,19 +240,24 @@ class Node:
         task_dict.pop("signature", None)
         task_dict["signature"] = self._identity.sign(task_dict)
 
-        # Tenta encontrar peer
-        peer = target_node if target_node and target_node in self._tcp.peer_addresses else None
-        if not peer:
+        # Tenta encontrar peer — matcha node_id contra addresses no formato "prefix@ip:port"
+        peer = None
+        if target_node:
+            for addr in self._tcp.peer_addresses:
+                if addr.startswith(target_node[:12] + "@"):
+                    peer = addr
+                    break
+            if not peer:
+                # Bug fix: target_node especificado mas offline —
+                # NÃO fazer find_peer_for(capability) que acharia o tracker.
+                # Vai direto pra relay-via-tracker.
+                return await self.send_task_via_tracker(
+                    "", target_node, capability, payload, ttl_s=ttl_s
+                )
+        else:
             peer = self._routing.find_peer_for(capability)
-
-        # Se não encontrou, faz QUERY broadcast
-        if not peer:
-            peer = await self._query_capability(capability, ttl=5, timeout=5)
-            if peer:
-                hello = hello_msg(self._node_id, self._tracker.get_public_caps(),
-                                  list(self._routing.local_interests),
-                                  self._tracker.visibility, self._version)
-                peer = await self._tcp.connect_to_peer(peer, hello_payload=hello)
+            if not peer:
+                peer = await self._query_capability(capability, ttl=5, timeout=5)
 
         if peer:
             try:
@@ -253,10 +266,6 @@ class Node:
             except Exception as e:
                 return Result.make_error(task_id, "SEND_ERROR", str(e))
 
-        # Bug 2: Fallback via tracker antes de desistir
-        if not peer:
-            return await self.send_task_via_tracker("", target_node, capability, payload, ttl_s=ttl_s)
-
         return Result.make_error(task_id, "NO_PEER", f"No peer for: {capability}")
 
     async def send_task_async(self, target_node: str, capability: str,
@@ -343,7 +352,7 @@ class Node:
         discovered: dict[str, dict[str, Any]] = {}
 
         # Broadcast QUERY for any capability
-        await self._tcp.broadcast(query_msg("", query_id, ttl=3))
+        await self._tcp.broadcast(query_msg("", query_id, ttl=3, origin=self._node_id))
 
         try:
             await asyncio.wait_for(event.wait(), timeout=timeout)
@@ -413,6 +422,27 @@ class Node:
     async def _handle_message(self, peer_addr: str, msg: dict[str, Any]) -> None:
         msg_type = msg.get("type", "")
 
+        # ── Rate limiting ───────────────────────────────────────
+        now = time.monotonic()
+        # HELLO: max 1 per minute per peer
+        if msg_type == MessageType.HELLO:
+            last_hello = self._hello_count.get(peer_addr, 0.0)
+            if now - last_hello < 60:
+                logger.warning("[elo] rate limit: HELLO flood from %s", peer_addr[:20])
+                return
+            self._hello_count[peer_addr] = now
+
+        # General: max 100 messages per 60s window per peer
+        count, win_start = self._msg_count.get(peer_addr, (0, now))
+        if now - win_start > 60:
+            count, win_start = 0, now
+        count += 1
+        self._msg_count[peer_addr] = (count, win_start)
+        if count > 100:
+            logger.warning("[elo] rate limit: %d msgs in 60s from %s — dropping", count, peer_addr[:20])
+            return
+        # ── Fim rate limiting ───────────────────────────────────
+
         if msg_type == MessageType.HELLO:
             await self._on_hello(peer_addr, msg)
         elif msg_type == MessageType.HELLO_ACK:
@@ -467,6 +497,22 @@ class Node:
         capability = msg.get("capability", "")
         query_id = msg.get("id", "")
         ttl = msg.get("ttl", 5)
+        origin = msg.get("origin", "")
+
+        # Previne broadcast loop: não reencaminha se origin == self
+        if origin and origin == self._node_id:
+            return
+
+        # Previne duplicatas: cache de query_ids recentes
+        now = time.time()
+        # Limpa entradas expiradas
+        expired = [qid for qid, ts in self._seen_queries.items() if now - ts > self._seen_query_ttl]
+        for qid in expired:
+            self._seen_queries.pop(qid, None)
+        if query_id in self._seen_queries:
+            return
+        self._seen_queries[query_id] = now
+
         nodes: list[dict[str, Any]] = []
 
         # Modelo BitTorrent: tracker retorna SEMPRE todos os peers conhecidos,
@@ -490,7 +536,9 @@ class Node:
             except Exception:
                 pass
         elif ttl > 1:
-            await self._tcp.broadcast(query_msg(capability, query_id, ttl=ttl - 1), exclude={peer_addr})
+            # Propaga origin: usa a existente ou define self como origin
+            origin = origin or self._node_id
+            await self._tcp.broadcast(query_msg(capability, query_id, ttl=ttl - 1, origin=origin), exclude={peer_addr})
 
     async def _on_query_resp(self, peer_addr: str, msg: dict) -> None:
         query_id = msg.get("id", "")
@@ -543,6 +591,9 @@ class Node:
                 result_payload = {"message": "no handler registered"}
 
             result = result_msg(task_id, "success", payload=result_payload)
+            # Assina resultado para garantir autenticidade
+            result_no_sig = {k: v for k, v in result.items() if k != "signature"}
+            result["signature"] = self._identity.sign(result_no_sig)
             await self._tcp.send_to(peer_addr, result)
 
         except Exception as e:
@@ -556,6 +607,21 @@ class Node:
 
     async def _on_result(self, peer_addr: str, msg: dict) -> None:
         task_id = msg.get("id", "")
+
+        # Verifica assinatura do resultado se verify_peers estiver ativo
+        if self._verify_peers and msg.get("signature"):
+            result_no_sig = {k: v for k, v in msg.items() if k != "signature"}
+            # Extrai caller_id do pending_result (já que o caller original sabe quem enviou)
+            # O peer que enviou é conhecido via peer_addr — extraímos node_id do prefixo
+            peer_node_id = peer_addr.split("@")[0] if "@" in peer_addr else ""
+            if peer_node_id:
+                caller_pub = await self._get_caller_pubkey(peer_node_id)
+                if caller_pub:
+                    from elo.security import verify_signature
+                    if not verify_signature(caller_pub, result_no_sig, msg["signature"]):
+                        logger.warning("[elo] bad signature on result from %s", peer_node_id[:12])
+                        return  # descarta resultado com assinatura inválida
+
         future = self._pending_results.get(task_id)
         if future and not future.done():
             status = msg.get("status", "error")

{elo_node-0.4.6 → elo_node-0.4.8}/elo/transport/protocol.py

@@ -103,13 +103,16 @@ def hello_ack_msg(node_id: str, caps: dict, interests: list[str],
     return msg
 
 
-def query_msg(capability: str, query_id: str, ttl: int = 5) -> dict:
-    return {
+def query_msg(capability: str, query_id: str, ttl: int = 5, origin: str = "") -> dict:
+    msg: dict[str, Any] = {
         "type": MessageType.QUERY,
         "capability": capability,
         "id": query_id,
         "ttl": ttl,
     }
+    if origin:
+        msg["origin"] = origin
+    return msg
 
 
 def query_resp_msg(query_id: str, nodes: list[dict]) -> dict:
@@ -144,7 +147,7 @@ def task_msg(task_id: str, target: str, caller: str, capability: str,
 
 
 def result_msg(task_id: str, status: str, payload: dict | None = None,
-               error: dict | None = None) -> dict:
+               error: dict | None = None, signature: str = "") -> dict:
     msg = {
         "type": MessageType.RESULT,
         "id": task_id,
@@ -155,6 +158,8 @@ def result_msg(task_id: str, status: str, payload: dict | None = None,
         msg["payload"] = payload
     if error is not None:
         msg["error"] = error
+    if signature:
+        msg["signature"] = signature
     return msg
 
 

{elo_node-0.4.6 → elo_node-0.4.8}/elo_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elo-node
-Version: 0.4.6
+Version: 0.4.8
 Summary: Elo — malha P2P de mensagens para agentes de IA. Zero infraestrutura.
 Author: Elo Contributors
 License: MIT

{elo_node-0.4.6 → elo_node-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "elo-node"
-version = "0.4.6"
+version = "0.4.8"
 description = "Elo — malha P2P de mensagens para agentes de IA. Zero infraestrutura."
 readme = "README.md"
 license = {text = "MIT"}

{elo_node-0.4.6 → elo_node-0.4.8}/tests/test_unit.py

@@ -136,7 +136,7 @@ class TestNodeConstruction:
         node = Node("test-node")
         assert node._name == "test-node"
         assert node._port == 7878
-        assert node._version == "0.4.6"
+        assert node._version == "0.4.8"
         assert node.connected is False
         assert node.node_id is not None
         assert len(node.node_id) > 20
@@ -148,6 +148,19 @@ class TestNodeConstruction:
         assert node._port == 9000
         assert node.tracker_visibility == "private"
 
+    @pytest.mark.asyncio
+    async def test_send_task_to_offline_target_returns_error(self):
+        """send_task with offline target_node must return error, not route to tracker."""
+        node = Node("test-a", port=0)
+        await node.connect()
+        await node.register(agents=["echo"])
+
+        # Target node_id that won't match any connected peer address
+        result = await node.send_task("nonexistent-node-id-42", "echo", {"msg": "hello"})
+
+        assert result.status == "error"
+        await node.disconnect()
+
 
 # ── TestNodeLifecycle ──────────────────────────────────────