chatly-sdk 0.0.1

package/src/ChatManager.ts

@@ -0,0 +1,103 @@
+
+import { KeyManager, KeyPair } from './crypto/keyManager';
+import { encrypt } from './crypto/encrypt';
+import { decrypt } from './crypto/decrypt';
+import { ChatClient } from './transport/websocketClient';
+import { Message } from './models/Message';
+
+export class ChatManager {
+  private keyManager: KeyManager;
+  private chatClient: ChatClient;
+  private contacts: { [id: string]: Uint8Array } = {}; // Maps user ID to public key
+
+  constructor(websocketUrl: string) {
+    this.keyManager = new KeyManager();
+    this.chatClient = new ChatClient(websocketUrl);
+  }
+
+  async initialize(): Promise<void> {
+    await this.keyManager.generateKeys();
+    this.chatClient.connect();
+    this.chatClient.onMessage(this.handleIncomingMessage.bind(this));
+  }
+
+  addContact(userId: string, publicKey: Uint8Array): void {
+    this.contacts[userId] = publicKey;
+  }
+
+  async sendMessage(recipientId: string, content: string): Promise<void> {
+    const recipientPublicKey = this.contacts[recipientId];
+    if (!recipientPublicKey) {
+      throw new Error(`Contact not found: ${recipientId}`);
+    }
+
+    const senderPrivateKey = this.keyManager.getPrivateKey();
+    if (!senderPrivateKey) {
+      throw new Error('Sender keys not generated.');
+    }
+
+    const message: Message = {
+      id: Date.now().toString(),
+      senderId: this.getOwnUserId(),
+      recipientId,
+      content,
+      timestamp: Date.now(),
+    };
+
+    const encryptedMessage = await encrypt(
+      JSON.stringify(message),
+      recipientPublicKey,
+      senderPrivateKey
+    );
+
+    this.chatClient.sendMessage(Buffer.from(encryptedMessage));
+  }
+
+  private async handleIncomingMessage(encryptedMessage: Buffer): Promise<void> {
+    // In a real application, you would need a way to identify the sender
+    // and get their public key. For this example, we'll assume the sender
+    // is the only other contact.
+    const senderId = Object.keys(this.contacts)[0];
+    if (!senderId) {
+      console.error('Received message but no contacts are known.');
+      return;
+    }
+    const senderPublicKey = this.contacts[senderId];
+
+    if (!senderPublicKey) {
+      console.error('Received message from unknown sender.');
+      return;
+    }
+
+    const recipientPrivateKey = this.keyManager.getPrivateKey();
+    if (!recipientPrivateKey) {
+      throw new Error('Recipient keys not generated.');
+    }
+
+    try {
+      const decryptedMessageJson = await decrypt(
+        encryptedMessage,
+        senderPublicKey,
+        recipientPrivateKey
+      );
+      const message: Message = JSON.parse(decryptedMessageJson);
+      console.log('Decrypted message:', message);
+    } catch (error) {
+      console.error('Failed to decrypt message:', error);
+    }
+  }
+
+  getOwnUserId(): string {
+    // In a real app, this would be a unique user ID.
+    // For this example, we'll use a hash of the public key.
+    const publicKey = this.keyManager.getPublicKey();
+    if (!publicKey) {
+      throw new Error('Keys not generated.');
+    }
+    return Buffer.from(publicKey).toString('hex');
+  }
+
+  getOwnPublicKey(): Uint8Array | null {
+    return this.keyManager.getPublicKey();
+  }
+}

package/src/chat/ChatSession.ts

@@ -0,0 +1,88 @@
+import type { User } from "../models/user.js";
+import type { Message } from "../models/message.js";
+import { deriveSharedSecret, encryptMessage, decryptMessage } from "../crypto/e2e.js";
+import type { KeyPair } from "../crypto/keys.js";
+import { generateUUID } from "../crypto/uuid.js";
+
+export class ChatSession {
+  private sharedSecret: Buffer | null = null;
+  private ephemeralKeyPair: KeyPair | null = null;
+
+  constructor(
+    public readonly id: string,
+    public readonly userA: User,
+    public readonly userB: User
+  ) {}
+
+  /**
+   * Initialize the session by deriving the shared secret
+   * ECDH is commutative, so we can use either user's keys
+   */
+  async initialize(): Promise<void> {
+    // For 1:1 chat, derive shared secret from identity keys
+    // Use userA's private key and userB's public key
+    // (ECDH is commutative, so userB could also use their private key and userA's public key)
+    const localKeyPair: KeyPair = {
+      publicKey: this.userA.publicKey,
+      privateKey: this.userA.privateKey,
+    };
+    
+    this.sharedSecret = deriveSharedSecret(localKeyPair, this.userB.publicKey);
+  }
+
+  /**
+   * Initialize from a specific user's perspective (useful when decrypting)
+   */
+  async initializeForUser(user: User): Promise<void> {
+    const otherUser = user.id === this.userA.id ? this.userB : this.userA;
+    const localKeyPair: KeyPair = {
+      publicKey: user.publicKey,
+      privateKey: user.privateKey,
+    };
+    
+    this.sharedSecret = deriveSharedSecret(localKeyPair, otherUser.publicKey);
+  }
+
+  /**
+   * Encrypt a message for this session
+   */
+  async encrypt(plaintext: string, senderId: string): Promise<Message> {
+    if (!this.sharedSecret) {
+      await this.initialize();
+    }
+
+    if (!this.sharedSecret) {
+      throw new Error("Failed to initialize session");
+    }
+
+    const { ciphertext, iv } = encryptMessage(plaintext, this.sharedSecret);
+
+    return {
+      id: generateUUID(),
+      senderId,
+      receiverId: senderId === this.userA.id ? this.userB.id : this.userA.id,
+      ciphertext,
+      iv,
+      timestamp: Date.now(),
+      type: "text",
+    };
+  }
+
+  /**
+   * Decrypt a message in this session
+   */
+  async decrypt(message: Message, user: User): Promise<string> {
+    // Re-initialize from the decrypting user's perspective if needed
+    // (though ECDH is commutative, this ensures we're using the right keys)
+    if (!this.sharedSecret || 
+        (user.id !== this.userA.id && user.id !== this.userB.id)) {
+      await this.initializeForUser(user);
+    }
+
+    if (!this.sharedSecret) {
+      throw new Error("Failed to initialize session");
+    }
+
+    return decryptMessage(message.ciphertext, message.iv, this.sharedSecret);
+  }
+}

package/src/chat/GroupSession.ts

@@ -0,0 +1,60 @@
+import type { Group } from "../models/group.js";
+import type { Message } from "../models/message.js";
+import { deriveGroupKey } from "../crypto/group.js";
+import { encryptMessage, decryptMessage } from "../crypto/e2e.js";
+import { base64ToBuffer } from "../crypto/utils.js";
+import { generateUUID } from "../crypto/uuid.js";
+
+export class GroupSession {
+  private groupKey: Buffer | null = null;
+
+  constructor(public readonly group: Group) {}
+
+  /**
+   * Initialize the session by deriving the group key
+   */
+  async initialize(): Promise<void> {
+    const groupKeyData = deriveGroupKey(this.group.id);
+    this.groupKey = base64ToBuffer(groupKeyData.key);
+  }
+
+  /**
+   * Encrypt a message for this group
+   */
+  async encrypt(plaintext: string, senderId: string): Promise<Message> {
+    if (!this.groupKey) {
+      await this.initialize();
+    }
+
+    if (!this.groupKey) {
+      throw new Error("Failed to initialize group session");
+    }
+
+    const { ciphertext, iv } = encryptMessage(plaintext, this.groupKey);
+
+    return {
+      id: generateUUID(),
+      senderId,
+      groupId: this.group.id,
+      ciphertext,
+      iv,
+      timestamp: Date.now(),
+      type: "text",
+    };
+  }
+
+  /**
+   * Decrypt a message in this group
+   */
+  async decrypt(message: Message): Promise<string> {
+    if (!this.groupKey) {
+      await this.initialize();
+    }
+
+    if (!this.groupKey) {
+      throw new Error("Failed to initialize group session");
+    }
+
+    return decryptMessage(message.ciphertext, message.iv, this.groupKey);
+  }
+}

package/src/crypto/e2e.ts

@@ -0,0 +1,95 @@
+  import { createECDH, createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
+  import type { KeyPair } from "./keys.js";
+  import { base64ToBuffer, bufferToBase64 } from "./utils.js";
+  import { SUPPORTED_CURVE } from "./keys.js";
+  import { createHash } from "crypto";
+
+  const ALGORITHM = "aes-256-gcm";
+  const IV_LENGTH = 12; // 96 bits for GCM
+  const SALT_LENGTH = 16;
+  const KEY_LENGTH = 32; // 256 bits
+  const TAG_LENGTH = 16;
+  const PBKDF2_ITERATIONS = 100000;
+
+  /**
+   * Derive a shared secret using ECDH key exchange
+   */
+  // export function deriveSharedSecret(local: KeyPair, remotePublicKey: string): Buffer {
+  //   const ecdh = createECDH(SUPPORTED_CURVE);
+  //   ecdh.setPrivateKey(base64ToBuffer(local.privateKey));
+    
+  //   const remotePublicKeyBuffer = base64ToBuffer(remotePublicKey);
+  //   const sharedSecret = ecdh.computeSecret(remotePublicKeyBuffer);
+    
+  //   // Derive a symmetric key from the shared secret using PBKDF2
+  //   // Use a deterministic salt based on both public keys for consistency
+  //   const salt = Buffer.concat([
+  //     base64ToBuffer(local.publicKey),
+  //     base64ToBuffer(remotePublicKey)
+  //   ]).slice(0, SALT_LENGTH);
+  //   const derivedKey = pbkdf2Sync(sharedSecret, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+    
+  //   return derivedKey;
+  // }
+
+  export function deriveSharedSecret(local: KeyPair, remotePublicKey: string): Buffer {
+    const ecdh = createECDH(SUPPORTED_CURVE);
+    ecdh.setPrivateKey(base64ToBuffer(local.privateKey));
+  
+    const remotePublicKeyBuffer = base64ToBuffer(remotePublicKey);
+    const sharedSecret = ecdh.computeSecret(remotePublicKeyBuffer);
+  
+    // Deterministic salt: sort the two public-key buffers lexically,
+    // then hash and take first SALT_LENGTH bytes.
+    const a = base64ToBuffer(local.publicKey);
+    const b = base64ToBuffer(remotePublicKey);
+    const [first, second] = Buffer.compare(a, b) <= 0 ? [a, b] : [b, a];
+  
+    const hash = createHash("sha256").update(first).update(second).digest();
+    const salt = hash.slice(0, SALT_LENGTH);
+  
+    const derivedKey = pbkdf2Sync(sharedSecret, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+  
+    return derivedKey;
+  }
+
+  /**
+   * Encrypt a message using AES-GCM
+   */
+  export function encryptMessage(plaintext: string, secret: Buffer): { ciphertext: string; iv: string } {
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, secret, iv);
+    
+    let ciphertext = cipher.update(plaintext, "utf8");
+    ciphertext = Buffer.concat([ciphertext, cipher.final()]);
+    
+    const tag = cipher.getAuthTag();
+    
+    // Combine ciphertext + tag
+    const encrypted = Buffer.concat([ciphertext, tag]);
+    
+    return {
+      ciphertext: bufferToBase64(encrypted),
+      iv: bufferToBase64(iv),
+    };
+  }
+
+  /**
+   * Decrypt a message using AES-GCM
+   */
+  export function decryptMessage(ciphertext: string, iv: string, secret: Buffer): string {
+    const encryptedBuffer = base64ToBuffer(ciphertext);
+    const ivBuffer = base64ToBuffer(iv);
+    
+    // Extract tag from the end
+    const tag = encryptedBuffer.slice(-TAG_LENGTH);
+    const actualCiphertext = encryptedBuffer.slice(0, -TAG_LENGTH);
+    
+    const decipher = createDecipheriv(ALGORITHM, secret, ivBuffer);
+    decipher.setAuthTag(tag);
+    
+    let decrypted = decipher.update(actualCiphertext);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    
+    return decrypted.toString("utf8");
+  }

package/src/crypto/group.ts

@@ -0,0 +1,24 @@
+import { randomBytes, pbkdf2Sync } from "crypto";
+import { bufferToBase64 } from "./utils.js";
+
+export interface GroupKey {
+  groupId: string;
+  key: string;
+}
+
+const KEY_LENGTH = 32; // 256 bits
+const PBKDF2_ITERATIONS = 100000;
+
+/**
+ * Derive a group shared key from the group ID
+ */
+export function deriveGroupKey(groupId: string): GroupKey {
+  // Use PBKDF2 to derive a deterministic key from the group ID
+  const salt = Buffer.from(groupId, "utf8");
+  const key = pbkdf2Sync(groupId, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+  
+  return {
+    groupId,
+    key: bufferToBase64(key),
+  };
+}

package/src/crypto/keyManager.ts

@@ -0,0 +1,28 @@
+
+import sodium from 'libsodium-wrappers';
+
+export interface KeyPair {
+  publicKey: Uint8Array;
+  privateKey: Uint8Array;
+}
+
+export class KeyManager {
+  private keyPair: KeyPair | null = null;
+
+  async generateKeys(): Promise<void> {
+    await sodium.ready;
+    const keys = sodium.crypto_box_keypair();
+    this.keyPair = {
+      publicKey: keys.publicKey,
+      privateKey: keys.privateKey,
+    };
+  }
+
+  getPublicKey(): Uint8Array | null {
+    return this.keyPair ? this.keyPair.publicKey : null;
+  }
+
+  getPrivateKey(): Uint8Array | null {
+    return this.keyPair ? this.keyPair.privateKey : null;
+  }
+}

package/src/crypto/keys.ts

@@ -0,0 +1,34 @@
+import { createECDH, randomBytes } from "crypto";
+import { bufferToBase64, base64ToBuffer } from "./utils.js";
+
+export interface KeyPair {
+  publicKey: string;
+  privateKey: string;
+}
+
+export interface StoredKeyPair extends KeyPair {
+  createdAt: number;
+}
+
+export const SUPPORTED_CURVE = "prime256v1";
+
+/**
+ * Generate a long-term identity key pair for a user
+ */
+export function generateIdentityKeyPair(): KeyPair {
+  const ecdh = createECDH(SUPPORTED_CURVE);
+  ecdh.generateKeys();
+  
+  return {
+    publicKey: bufferToBase64(ecdh.getPublicKey()),
+    privateKey: bufferToBase64(ecdh.getPrivateKey()),
+  };
+}
+
+/**
+ * Generate an ephemeral key pair for a session
+ */
+export function generateEphemeralKeyPair(): KeyPair {
+  // Ephemeral keys use the same curve, but are meant to be temporary
+  return generateIdentityKeyPair();
+}

package/src/crypto/utils.ts

@@ -0,0 +1,7 @@
+export function bufferToBase64(buffer: Buffer): string {
+  return buffer.toString("base64");
+}
+
+export function base64ToBuffer(data: string): Buffer {
+  return Buffer.from(data, "base64");
+}

package/src/crypto/uuid.ts

@@ -0,0 +1,42 @@
+/**
+ * Cross-platform UUID generator
+ * Works in both Node.js and browser environments
+ */
+export function generateUUID(): string {
+  // Try Node.js crypto.randomUUID first
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+
+  // Fallback for browsers: use crypto.getRandomValues
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    // Generate UUID v4 using crypto.getRandomValues
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    
+    // Set version (4) and variant bits
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // Version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // Variant 10
+    
+    // Convert to UUID string format
+    const hex = Array.from(bytes)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+    
+    return [
+      hex.slice(0, 8),
+      hex.slice(8, 12),
+      hex.slice(12, 16),
+      hex.slice(16, 20),
+      hex.slice(20, 32),
+    ].join("-");
+  }
+
+  // Last resort fallback (shouldn't happen in modern environments)
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+