Added Step Decentralized-System#6

alesarritz · alesarritz · commit c28138af7e0a · 2025-03-17T11:51:29.000+01:00
diff --git a/src/crypto.ts b/src/crypto.ts
@@ -1,4 +1,5 @@
 import { webcrypto } from "crypto";
+type CK = webcrypto.CryptoKey;
 
 // #############
 // ### Utils ###
@@ -104,10 +105,13 @@ export async function rsaEncrypt(
     encodedData
   );
 
-  return arrayBufferToBase64(encryptedData);
+  const result = arrayBufferToBase64(encryptedData);
+  console.log("Encrypted Data:", result); // Debugging output
+  return result;
 }
 
 
+
 // Decrypts a message using an RSA private key
 export async function rsaDecrypt(
   encryptedData: string,
@@ -162,37 +166,65 @@ export async function importSymKey(strKey: string): Promise<webcrypto.CryptoKey>
 
 // Encrypt a message using a symmetric key
 export async function symEncrypt(
-  key: webcrypto.CryptoKey,
+  key: string | CK,
   data: string
 ): Promise<string> {
-  const iv = webcrypto.getRandomValues(new Uint8Array(16)); // Generate a random IV
-  const encodedData = new TextEncoder().encode(data);
+  let cryptoKey: CK;
+  if (typeof key === 'string') {
+    cryptoKey = await importSymKey(key);
+  } else {
+    cryptoKey = key;
+  }
 
-  const encryptedData = await webcrypto.subtle.encrypt(
-    { name: "AES-CBC", iv },
-    key,
-    encodedData
+  const iv = webcrypto.getRandomValues(new Uint8Array(16));
+  const encoded = new TextEncoder().encode(data);
+
+  const encrypted = await webcrypto.subtle.encrypt(
+    {
+      name: "AES-CBC",
+      iv
+    },
+    cryptoKey,
+    encoded
   );
 
-  return arrayBufferToBase64(iv) + "." + arrayBufferToBase64(encryptedData);
+  const combined = new Uint8Array(iv.length + encrypted.byteLength);
+  combined.set(iv);
+  combined.set(new Uint8Array(encrypted), iv.length);
+
+  return Buffer.from(combined).toString('base64');
 }
 
 
+
 // Decrypt a message using a symmetric key
 export async function symDecrypt(
-  strKey: string,
+  key: string | CK,
   encryptedData: string
 ): Promise<string> {
-  const key = await importSymKey(strKey);
-  const [ivStr, encryptedStr] = encryptedData.split(".");
-  const iv = base64ToArrayBuffer(ivStr);
-  const encryptedBuffer = base64ToArrayBuffer(encryptedStr);
+  let cryptoKey: CK;
+  if (typeof key === 'string') {
+    cryptoKey = await importSymKey(key);
+  } else {
+    cryptoKey = key;
+  }
 
-  const decryptedData = await webcrypto.subtle.decrypt(
-    { name: "AES-CBC", iv },
-    key,
-    encryptedBuffer
+  // Decode the concatenated IV + encrypted data
+  const combined = Buffer.from(encryptedData, 'base64');
+
+  // Extract IV and encrypted data correctly
+  const iv = combined.slice(0, 16);
+  const data = combined.slice(16);
+
+  const decrypted = await webcrypto.subtle.decrypt(
+    {
+      name: "AES-CBC",
+      iv
+    },
+    cryptoKey,
+    data
   );
 
-  return new TextDecoder().decode(decryptedData);
+  return new TextDecoder().decode(decrypted);
 }
+
diff --git a/src/onionRouters/simpleOnionRouter.ts b/src/onionRouters/simpleOnionRouter.ts
@@ -1,7 +1,15 @@
 import bodyParser from "body-parser";
-import express, { Request, Response } from "express";
-import { BASE_ONION_ROUTER_PORT, REGISTRY_PORT } from "../config";
-import { generateRsaKeyPair, exportPubKey, exportPrvKey } from "../crypto";
+import express from "express";
+import { BASE_ONION_ROUTER_PORT, REGISTRY_PORT, BASE_USER_PORT } from "../config";
+import {
+  generateRsaKeyPair,
+  rsaDecrypt,
+  symDecrypt,
+  importSymKey,
+  exportPubKey,
+  exportPrvKey,
+  exportSymKey,
+} from "../crypto";
 import { webcrypto } from "node:crypto";
 
 type CK = webcrypto.CryptoKey;
@@ -15,8 +23,7 @@ export async function simpleOnionRouter(nodeId: number) {
   let publicKey: CK;
   let privateKeyStr: string;
   let publicKeyStr: string;
-
-  // Store the last received messages and destination (default: null)
+  let lastCircuit: number[] = [];
   let lastReceivedEncryptedMessage: string | null = null;
   let lastReceivedDecryptedMessage: string | null = null;
   let lastMessageDestination: number | null = null;
@@ -25,56 +32,80 @@ export async function simpleOnionRouter(nodeId: number) {
     const keyPair = await generateRsaKeyPair();
     privateKey = keyPair.privateKey;
     publicKey = keyPair.publicKey;
-
-    // Convert keys to base64
     publicKeyStr = await exportPubKey(publicKey);
     privateKeyStr = await exportPrvKey(privateKey);
 
-    // Register with the registry
-    const response = await fetch(`http://localhost:${REGISTRY_PORT}/registerNode`, {
+    const registryResponse = await fetch(`http://localhost:${REGISTRY_PORT}/registerNode`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ nodeId, pubKey: publicKeyStr }),
     });
 
-    if (!response.ok) {
-      throw new Error(`Failed to register node ${nodeId}`);
-    }
-
+    if (!registryResponse.ok) throw new Error(`Failed to register node: ${registryResponse.statusText}`);
     console.log(`Node ${nodeId} registered successfully`);
   } catch (error) {
     console.error("Failed to initialize node:", error);
     throw error;
   }
 
-  // Status route
-  onionRouter.get("/status", (req: Request, res: Response) => {
-    res.send("live");
-  });
-
-  // GET last received encrypted message
-  onionRouter.get("/getLastReceivedEncryptedMessage", (req: Request, res: Response) => {
-    res.json({ result: lastReceivedEncryptedMessage });
-  });
-
-  // GET last received decrypted message
-  onionRouter.get("/getLastReceivedDecryptedMessage", (req: Request, res: Response) => {
-    res.json({ result: lastReceivedDecryptedMessage });
-  });
-
-  // GET last message destination
-  onionRouter.get("/getLastMessageDestination", (req: Request, res: Response) => {
-    res.json({ result: lastMessageDestination });
-  });
-
-  // Provide private key for testing purposes
-  onionRouter.get("/getPrivateKey", (req: Request, res: Response) => {
-    res.json({ result: privateKeyStr });
-  });
-
-  const server = onionRouter.listen(BASE_ONION_ROUTER_PORT + nodeId, () => {
-    console.log(`Onion router ${nodeId} is listening on port ${BASE_ONION_ROUTER_PORT + nodeId}`);
+  onionRouter.get("/status", (req, res) => res.send("live"));
+  onionRouter.get("/getLastReceivedEncryptedMessage", (req, res) => res.json({ result: lastReceivedEncryptedMessage }));
+  onionRouter.get("/getLastReceivedDecryptedMessage", (req, res) => res.json({ result: lastReceivedDecryptedMessage }));
+  onionRouter.get("/getLastMessageDestination", (req, res) => res.json({ result: lastMessageDestination }));
+  onionRouter.get("/getPrivateKey", async (req, res) => res.json({ result: privateKeyStr }));
+  onionRouter.get("/getLastCircuit", (req, res) => res.json({ result: lastCircuit }));
+
+  onionRouter.post("/message", async (req, res) => {
+    try {
+      const { message, circuit = [] } = req.body;
+      console.log(`Node ${nodeId} received message:`, message);
+  
+      if (!message) return res.status(400).json({ error: "Message required" });
+  
+      lastReceivedEncryptedMessage = message;
+      console.log(`Last received encrypted message on Node ${nodeId}:`, lastReceivedEncryptedMessage);
+
+      const encryptedSymKey = message.slice(0, 344);
+      const encryptedPayload = message.slice(344);
+
+      let symKey;
+      try {
+        const symKeyStr = await rsaDecrypt(encryptedSymKey, privateKey);
+        symKey = await importSymKey(symKeyStr);
+      } catch (error) {
+        console.error(`Node ${nodeId} failed to decrypt symmetric key:`, error);
+        return res.status(500).json({ error: "Symmetric key decryption failed" });
+      }
+
+      let decryptedPayload;
+      try {
+        decryptedPayload = await symDecrypt(await exportSymKey(symKey), encryptedPayload);
+      } catch (error) {
+        console.error(`Node ${nodeId} failed to decrypt payload:`, error);
+        return res.status(500).json({ error: "Payload decryption failed" });
+      }
+
+      const destination = parseInt(decryptedPayload.slice(0, 10), 10);
+      const remainingMessage = decryptedPayload.slice(10);
+
+      lastReceivedDecryptedMessage = remainingMessage;
+      lastMessageDestination = destination;
+      lastCircuit = [...circuit, nodeId];
+
+      await fetch(`http://localhost:${destination}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ message: remainingMessage, circuit: lastCircuit }),
+      });
+
+      return res.json({ success: true });
+    } catch (error) {
+      console.error("Error processing message:", error);
+      return res.status(500).json({ error: "Failed to process message" });
+    }
   });
 
-  return server;
+  return onionRouter.listen(BASE_ONION_ROUTER_PORT + nodeId, () =>
+    console.log(`Onion router ${nodeId} is listening on port ${BASE_ONION_ROUTER_PORT + nodeId}`)
+  );
 }
diff --git a/src/users/user.ts b/src/users/user.ts
@@ -1,50 +1,84 @@
 import bodyParser from "body-parser";
-import express, { Request, Response } from "express";
-import { BASE_USER_PORT } from "../config";
+import express from "express";
+import { BASE_USER_PORT, REGISTRY_PORT, BASE_ONION_ROUTER_PORT } from "../config";
+import { symEncrypt, rsaEncrypt, exportSymKey, importPubKey, createRandomSymmetricKey, exportPubKey } from "../crypto";
+interface RegistryResponse {
+  nodes: Array<{ nodeId: number; pubKey: string }>;
+}
 
-export type SendMessageBody = {
-  message: string;
-  destinationUserId: number;
-};
+let lastReceivedMessage: string | null = null;
+let lastSentMessage: string | null = null;
 
 export async function user(userId: number) {
+  let lastCircuit: number[] = [];
   const _user = express();
   _user.use(express.json());
   _user.use(bodyParser.json());
 
-  // Store last received and last sent messages (default: null)
-  let lastReceivedMessage: string | null = null;
-  let lastSentMessage: string | null = null;
+  _user.get("/status", (req, res) => res.send("live"));
+  _user.get("/getLastReceivedMessage", (req, res) => res.json({ result: lastReceivedMessage }));
+  _user.get("/getLastSentMessage", (req, res) => res.json({ result: lastSentMessage }));
+  _user.get("/getLastCircuit", (req, res) => res.json({ result: lastCircuit }));
 
-  // Status route
-  _user.get("/status", (req: Request, res: Response) => {
-    res.send("live");
-  });
+  _user.post("/message", (req, res) => {
+    const { message, circuit } = req.body;
+    if (!message) return res.status(400).json({ error: "Message required." });
 
-  // GET last received message
-  _user.get("/getLastReceivedMessage", (req: Request, res: Response) => {
-    res.json({ result: lastReceivedMessage });
-  });
+    lastReceivedMessage = message;
+    if (circuit) lastCircuit = circuit;
 
-  // GET last sent message
-  _user.get("/getLastSentMessage", (req: Request, res: Response) => {
-    res.json({ result: lastSentMessage });
+    return res.send("success");
   });
 
-  _user.post("/message", (req: Request, res: Response) => {
-    const { message } = req.body as SendMessageBody;
+  _user.post("/sendMessage", async (req, res) => {
+    const { message, destinationUserId } = req.body;
+    try {
+      const registryResponse = await fetch(`http://localhost:${REGISTRY_PORT}/getNodeRegistry`);
+      const { nodes } = await registryResponse.json() as RegistryResponse;
 
-    if (!message || typeof message !== "string") {
-        return res.status(400).json({ error: "Invalid message" });
-    }
+      if (nodes.length < 3) return res.status(500).json({ error: "Not enough nodes available" });
 
-    lastReceivedMessage = message;
-    return res.send("success"); // ✅ Explicitly returning ensures all paths return a value
-  });
+      const selectedNodes = selectRandomNodes(nodes, 3);
+      const circuit = selectedNodes.map(node => node.nodeId);
+      let finalDestination = `${BASE_USER_PORT + destinationUserId}`.padStart(10, "0");
+
+      let encryptedMessage = message;
+      for (let i = circuit.length - 1; i >= 0; i--) {
+        const symKey = await createRandomSymmetricKey();
+        const symKeyStr = await exportSymKey(symKey);
+        const nodePublicKey = await importPubKey(selectedNodes[i].pubKey);
 
-  const server = _user.listen(BASE_USER_PORT + userId, () => {
-    console.log(`User ${userId} is listening on port ${BASE_USER_PORT + userId}`);
+        const encryptedSymKey = await rsaEncrypt(symKeyStr, await exportPubKey(nodePublicKey));
+        const payload = finalDestination + encryptedMessage;
+        const encryptedPayload = await symEncrypt(symKey, payload);
+
+        encryptedMessage = encryptedSymKey + encryptedPayload;
+        finalDestination = `${BASE_ONION_ROUTER_PORT + circuit[i]}`.padStart(10, "0");
+      }
+
+      await fetch(`http://localhost:${BASE_ONION_ROUTER_PORT + circuit[0]}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ message: encryptedMessage, circuit: [] }),
+      }).then(response => response.text()).then(data => console.log("Message sent response:", data));
+      
+
+      lastSentMessage = message;
+      lastCircuit = circuit;
+      return res.json({ success: true });
+    } catch (error) {
+      console.error("Error sending message:", error);
+      return res.status(500).json({ error: "Failed to send message" });
+    }
   });
 
+  const server = _user.listen(BASE_USER_PORT + userId, () =>
+    console.log(`User ${userId} is listening on port ${BASE_USER_PORT + userId}`)
+  );
+
   return server;
 }
+
+function selectRandomNodes(nodes: Array<{ nodeId: number; pubKey: string }>, count: number) {
+  return nodes.sort(() => Math.random() - 0.5).slice(0, count);
+}
