feat: E2E encrypted Tor channel messages (ChaCha20-Poly1305)

Messages between federated nodes are now end-to-end encrypted:
- X25519 ECDH key agreement from existing ed25519 node identities
- HKDF-SHA256 key derivation with domain separation
- ChaCha20-Poly1305 authenticated encryption per message
- Random 12-byte nonce per message via OsRng (CSPRNG)
- Graceful fallback to plaintext if encryption fails
- Receiver auto-detects encrypted vs plaintext messages

The Tor transport was already encrypted (onion routing), this adds
application-layer E2E encryption so even a compromised receiving
backend can't read messages without the node's private key.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

core/archipelago/src/api/handler.rs

@@ -295,11 +295,14 @@ impl ApiHandler {
             from_pubkey: Option<String>,
             message: Option<String>,
             signature: Option<String>,
+            #[serde(default)]
+            encrypted: bool,
         }
         let incoming: Incoming = serde_json::from_slice(&body).unwrap_or(Incoming {
             from_pubkey: None,
             message: None,
             signature: None,
+            encrypted: false,
         });
         if let (Some(from), Some(msg)) = (incoming.from_pubkey.as_ref(), incoming.message.as_ref()) {
             // Validate from_pubkey is a valid hex ed25519 pubkey
@@ -322,17 +325,44 @@ impl ApiHandler {
                             .unwrap());
                     }
                 }
-            } else {
-                // No signature — accept but mark as unverified
-                tracing::warn!("Node message from {} has no signature — unverified", &from[..16.min(from.len())]);
             }
-            // Sanitize log output to prevent log injection
+
+            // Decrypt if the message is E2E encrypted
+            let plaintext = if incoming.encrypted {
+                // Load our identity to derive shared secret
+                let data_dir = std::path::Path::new("/var/lib/archipelago");
+                let identity_dir = data_dir.join("identity");
+                match crate::identity::NodeIdentity::load_or_create(&identity_dir).await {
+                    Ok(node_id) => {
+                        match node_msg::decrypt_from_peer(node_id.signing_key(), from, msg) {
+                            Ok(decrypted) => {
+                                tracing::info!("Decrypted E2E message from {}...", &from[..16.min(from.len())]);
+                                decrypted
+                            }
+                            Err(e) => {
+                                tracing::warn!("E2E decryption failed from {}: {}", &from[..16.min(from.len())], e);
+                                return Ok(Response::builder()
+                                    .status(StatusCode::BAD_REQUEST)
+                                    .header("Content-Type", "application/json")
+                                    .body(hyper::Body::from(r#"{"error":"Decryption failed"}"#))
+                                    .unwrap());
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        tracing::warn!("Cannot decrypt: identity load failed: {}", e);
+                        msg.clone()
+                    }
+                }
+            } else {
+                msg.clone()
+            };
+
             let safe_from = sanitize_log_string(from);
-            let safe_msg = sanitize_log_string(msg);
+            let safe_msg = sanitize_log_string(&plaintext);
             tracing::info!("Received message from {}: {}", safe_from, safe_msg);
-            // Sanitize stored message content (strip HTML entities)
             let clean_from = sanitize_html(from);
-            let clean_msg = sanitize_html(msg);
+            let clean_msg = sanitize_html(&plaintext);
             node_msg::store_received(&clean_from, &clean_msg).await;
         }
         Ok(Response::builder()

core/archipelago/src/api/rpc/peers.rs

@@ -89,7 +89,25 @@ impl RpcHandler {
 
         let (data, _) = self.state_manager.get_snapshot().await;
         let pubkey = data.server_info.pubkey.clone();
-        node_message::send_to_peer(onion, &pubkey, message).await?;
+
+        // Load signing key for E2E encryption
+        let identity_dir = self.config.data_dir.join("identity");
+        let node_id = crate::identity::NodeIdentity::load_or_create(&identity_dir).await?;
+
+        // Look up recipient's pubkey from federation nodes
+        let fed_nodes = federation::load_nodes(&self.config.data_dir).await.unwrap_or_default();
+        let recipient_pubkey = fed_nodes.iter()
+            .find(|n| n.onion == onion || n.onion == format!("{}.onion", onion)
+                || format!("{}.onion", n.onion) == onion)
+            .map(|n| n.pubkey.clone());
+
+        node_message::send_to_peer(
+            onion,
+            &pubkey,
+            message,
+            Some(node_id.signing_key()),
+            recipient_pubkey.as_deref(),
+        ).await?;
         Ok(serde_json::json!({ "ok": true, "sent_to": onion }))
     }