@bananalink-sdk/protocol 1.2.7

package/src/crypto/providers/node-provider.ts

@@ -0,0 +1,433 @@
+import type { Logger } from '@bananalink-sdk/logger';
+import type { CryptoProvider, CryptoKeyLike, ProviderKeyPair } from '../../types/crypto-provider';
+import { registerCryptoProvider } from './registry';
+
+/**
+ * Type definition for Node.js crypto module (loaded dynamically to prevent Metro bundling)
+ */
+type NodeCrypto = typeof import('crypto');
+
+/**
+ * Node.js crypto.KeyObject wrapper to implement CryptoKeyLike interface
+ * Note: keyObject type is unknown at compile time (crypto.KeyObject | Buffer at runtime)
+ */
+class NodeCryptoKeyWrapper implements CryptoKeyLike {
+  constructor(
+    private readonly keyObject: unknown, // crypto.KeyObject | Buffer at runtime
+    private readonly keyType: 'public' | 'private' | 'secret'
+  ) {}
+
+  get type(): 'public' | 'private' | 'secret' {
+    return this.keyType;
+  }
+
+  get algorithm(): string {
+    return 'ECDH-P256';
+  }
+
+  get extractable(): boolean {
+    return true;
+  }
+
+  get usages(): readonly string[] {
+    return this.keyType === 'secret' ? ['encrypt', 'decrypt'] : ['deriveKey'];
+  }
+
+  get nativeKey(): unknown {
+    return this.keyObject;
+  }
+}
+
+/**
+ * Helper function to unwrap CryptoKeyLike to native KeyObject or Buffer
+ */
+function unwrapKeyObject(keyLike: CryptoKeyLike): unknown {
+  if (keyLike instanceof NodeCryptoKeyWrapper) {
+    return keyLike.nativeKey;
+  }
+  // Assume it's already a KeyObject
+  return keyLike;
+}
+
+/**
+ * Node.js crypto module implementation of CryptoProvider
+ * Optimized for backend services with native crypto performance
+ *
+ * This provider uses the native Node.js crypto module which provides:
+ * - Superior performance compared to Web Crypto API in Node.js
+ * - Direct access to OpenSSL optimizations
+ * - Zero additional dependencies
+ * - Full support for ECDH P-256 and AES-256-GCM
+ *
+ * @example
+ * ```typescript
+ * import { NodeCryptoProvider } from '@bananalink-sdk/protocol/crypto/provider/node';
+ * const provider = new NodeCryptoProvider();
+ * const keyPair = await provider.generateKeyPair();
+ * ```
+ */
+export class NodeCryptoProvider implements CryptoProvider {
+  public readonly name = 'NodeCrypto';
+  private readonly logger?: Logger;
+  private cryptoModule: NodeCrypto | null = null;
+
+  public get isAvailable(): boolean {
+    try {
+      // Check if we're in Node.js environment
+      if (typeof process === 'undefined' || !process.versions?.node) {
+        return false;
+      }
+      // Crypto module availability will be checked when getCrypto() is called
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  constructor(logger?: Logger) {
+    if (!this.isAvailable) {
+      throw new Error('Node.js crypto module not available in this environment');
+    }
+    this.logger = logger?.child({ component: 'NodeCryptoProvider' });
+  }
+
+  /**
+   * Get crypto module instance via dynamic import
+   * This prevents Metro bundler from trying to resolve 'crypto' at build time
+   */
+  private async getCrypto(): Promise<NodeCrypto> {
+    if (!this.cryptoModule) {
+      try {
+        // Dynamic import prevents static analysis by bundlers
+        this.cryptoModule = await import('crypto');
+      } catch {
+        throw new Error(
+          'Failed to load Node.js crypto module. ' +
+          'This provider requires a Node.js environment.'
+        );
+      }
+    }
+    return this.cryptoModule;
+  }
+
+  /**
+   * Generate ECDH P-256 key pair using Node.js crypto
+   */
+  async generateKeyPair(): Promise<ProviderKeyPair> {
+    this.logger?.debug('Generating ECDH P-256 key pair with Node.js crypto');
+    const cryptoModule = await this.getCrypto();
+
+    return new Promise((resolve, reject) => {
+      cryptoModule.generateKeyPair(
+        'ec',
+        {
+          namedCurve: 'prime256v1', // P-256
+          publicKeyEncoding: { type: 'spki', format: 'der' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (err: Error | null, publicKey: any, privateKey: any) => {
+          if (err) {
+            this.logger?.error('Key pair generation failed', { error: err });
+            reject(err);
+            return;
+          }
+
+          this.logger?.debug('Key pair generation completed');
+          resolve({
+            publicKey: new NodeCryptoKeyWrapper(publicKey, 'public'),
+            privateKey: new NodeCryptoKeyWrapper(privateKey, 'private'),
+          });
+        }
+      );
+    });
+  }
+
+  /**
+   * Export public key to raw ArrayBuffer format (65 bytes uncompressed)
+   */
+  async exportPublicKey(publicKey: CryptoKeyLike): Promise<ArrayBuffer> {
+    this.logger?.debug('Exporting public key');
+    const cryptoModule = await this.getCrypto();
+    const keyObject = unwrapKeyObject(publicKey);
+
+    // If it's a Buffer (DER format from generateKeyPair), convert to KeyObject first
+    const keyObj = keyObject instanceof Buffer
+      ? cryptoModule.createPublicKey({ key: keyObject, format: 'der', type: 'spki' })
+      : keyObject;
+
+    // Export as JWK to get X/Y coordinates
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    const jwk = (keyObj as any).export({ format: 'jwk' });
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const x = Buffer.from(jwk.x as string, 'base64url');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const y = Buffer.from(jwk.y as string, 'base64url');
+
+    // Construct 65-byte uncompressed point: 0x04 + X (32 bytes) + Y (32 bytes)
+    const uncompressed = Buffer.concat([Buffer.from([0x04]), x, y]);
+
+    return await Promise.resolve(
+      uncompressed.buffer.slice(
+        uncompressed.byteOffset,
+        uncompressed.byteOffset + uncompressed.byteLength
+      )
+    );
+  }
+
+  /**
+   * Export private key to raw ArrayBuffer format (32 bytes)
+   */
+  async exportPrivateKey(privateKey: CryptoKeyLike): Promise<ArrayBuffer> {
+    this.logger?.debug('Exporting private key');
+    const cryptoModule = await this.getCrypto();
+    const keyObject = unwrapKeyObject(privateKey);
+
+    // Convert KeyObject to raw format
+    const keyBuffer = keyObject instanceof Buffer ? keyObject : Buffer.from(keyObject as ArrayBuffer);
+    const keyObj = cryptoModule.createPrivateKey({
+      key: keyBuffer,
+      format: 'der',
+      type: 'pkcs8',
+    });
+
+    // Export as raw scalar (32 bytes)
+    const jwk = keyObj.export({ format: 'jwk' });
+    const dValue = Buffer.from(jwk.d as string, 'base64url');
+
+    return await Promise.resolve(
+      dValue.buffer.slice(dValue.byteOffset, dValue.byteOffset + dValue.byteLength)
+    );
+  }
+
+  /**
+   * Import public key from raw ArrayBuffer format
+   */
+  async importPublicKey(keyData: ArrayBuffer): Promise<CryptoKeyLike> {
+    this.logger?.debug('Importing public key');
+    const cryptoModule = await this.getCrypto();
+    const keyBuffer = Buffer.from(keyData);
+
+    // Ensure it's uncompressed format (65 bytes starting with 0x04)
+    if (keyBuffer.length !== 65 || keyBuffer[0] !== 0x04) {
+      throw new Error('Invalid public key format: expected 65 bytes uncompressed point');
+    }
+
+    // Create KeyObject from raw uncompressed point
+    // We need to wrap it in DER format
+    const x = keyBuffer.slice(1, 33);
+    const y = keyBuffer.slice(33, 65);
+
+    // Create JWK representation
+    const jwk = {
+      kty: 'EC' as const,
+      crv: 'P-256' as const,
+      x: x.toString('base64url'),
+      y: y.toString('base64url'),
+    };
+
+    const keyObject = cryptoModule.createPublicKey({ key: jwk, format: 'jwk' });
+    return await Promise.resolve(new NodeCryptoKeyWrapper(keyObject, 'public'));
+  }
+
+  /**
+   * Import private key from raw ArrayBuffer format
+   */
+  async importPrivateKey(keyData: ArrayBuffer): Promise<CryptoKeyLike> {
+    this.logger?.debug('Importing private key');
+    const cryptoModule = await this.getCrypto();
+    const keyBuffer = Buffer.from(keyData);
+
+    if (keyBuffer.length !== 32) {
+      throw new Error('Invalid private key format: expected 32 bytes');
+    }
+
+    // Create JWK representation
+    const jwk = {
+      kty: 'EC' as const,
+      crv: 'P-256' as const,
+      d: keyBuffer.toString('base64url'),
+    };
+
+    const keyObject = cryptoModule.createPrivateKey({ key: jwk, format: 'jwk' });
+    return await Promise.resolve(new NodeCryptoKeyWrapper(keyObject, 'private'));
+  }
+
+  /**
+   * Derive shared secret using ECDH
+   */
+  async deriveSharedSecret(privateKey: CryptoKeyLike, publicKey: CryptoKeyLike): Promise<CryptoKeyLike> {
+    this.logger?.debug('Deriving shared secret');
+    const cryptoModule = await this.getCrypto();
+
+    // Create ECDH object
+    const ecdh = cryptoModule.createECDH('prime256v1');
+
+    // Set private key
+    const privateRaw = await this.exportPrivateKey(privateKey);
+    ecdh.setPrivateKey(Buffer.from(privateRaw));
+
+    // Compute shared secret
+    const publicRaw = await this.exportPublicKey(publicKey);
+    const sharedSecret = ecdh.computeSecret(Buffer.from(publicRaw));
+
+    // Wrap as secret key
+    const keyObject = cryptoModule.createSecretKey(sharedSecret);
+    return new NodeCryptoKeyWrapper(keyObject, 'secret');
+  }
+
+  /**
+   * Derive AES-GCM encryption key using HKDF-SHA256
+   */
+  async deriveEncryptionKey(
+    sharedSecret: CryptoKeyLike,
+    salt: ArrayBuffer,
+    info: ArrayBuffer
+  ): Promise<CryptoKeyLike> {
+    this.logger?.debug('Deriving AES-GCM encryption key');
+    const cryptoModule = await this.getCrypto();
+
+    // Extract raw shared secret
+    const keyObject = unwrapKeyObject(sharedSecret);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    const sharedSecretRaw = (keyObject as any).export();
+
+    // Use HKDF to derive 32-byte key
+    const derivedKey = cryptoModule.hkdfSync(
+      'sha256',
+      Buffer.isBuffer(sharedSecretRaw) ? sharedSecretRaw : Buffer.from(sharedSecretRaw),
+      Buffer.from(salt),
+      Buffer.from(info),
+      32 // 256 bits
+    ) as Buffer;
+
+    // Create secret key object
+    const aesKeyObject = cryptoModule.createSecretKey(derivedKey);
+    return await Promise.resolve(new NodeCryptoKeyWrapper(aesKeyObject, 'secret'));
+  }
+
+  /**
+   * Encrypt data using AES-256-GCM
+   */
+  async encrypt(key: CryptoKeyLike, data: ArrayBuffer, iv: ArrayBuffer): Promise<ArrayBuffer> {
+    this.logger?.debug('Encrypting with AES-256-GCM');
+    const cryptoModule = await this.getCrypto();
+    const keyObject = unwrapKeyObject(key);
+
+    const cipher = cryptoModule.createCipheriv(
+      'aes-256-gcm',
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+      (keyObject as any).export(),
+      Buffer.from(iv)
+    );
+
+    const encrypted = Buffer.concat([
+      cipher.update(Buffer.from(data)),
+      cipher.final(),
+      cipher.getAuthTag(),
+    ]);
+
+    return await Promise.resolve(
+      encrypted.buffer.slice(
+        encrypted.byteOffset,
+        encrypted.byteOffset + encrypted.byteLength
+      )
+    );
+  }
+
+  /**
+   * Decrypt data using AES-256-GCM
+   */
+  async decrypt(key: CryptoKeyLike, data: ArrayBuffer, iv: ArrayBuffer): Promise<ArrayBuffer> {
+    this.logger?.debug('Decrypting with AES-256-GCM');
+    const cryptoModule = await this.getCrypto();
+    const keyObject = unwrapKeyObject(key);
+    const dataBuffer = Buffer.from(data);
+
+    // Last 16 bytes are the auth tag
+    const authTag = dataBuffer.slice(-16);
+    const ciphertext = dataBuffer.slice(0, -16);
+
+    const decipher = cryptoModule.createDecipheriv(
+      'aes-256-gcm',
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+      (keyObject as any).export(),
+      Buffer.from(iv)
+    );
+    decipher.setAuthTag(authTag);
+
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+
+    return await Promise.resolve(
+      decrypted.buffer.slice(
+        decrypted.byteOffset,
+        decrypted.byteOffset + decrypted.byteLength
+      )
+    );
+  }
+
+  /**
+   * Generate HMAC-SHA256 authentication code
+   */
+  async generateHMAC(key: CryptoKeyLike, data: ArrayBuffer): Promise<ArrayBuffer> {
+    this.logger?.debug('Generating HMAC-SHA256');
+    const cryptoModule = await this.getCrypto();
+    const keyObject = unwrapKeyObject(key);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    const hmac = cryptoModule.createHmac('sha256', (keyObject as any).export());
+    hmac.update(Buffer.from(data));
+    const mac = hmac.digest();
+
+    return await Promise.resolve(mac.buffer.slice(mac.byteOffset, mac.byteOffset + mac.byteLength));
+  }
+
+  /**
+   * Verify HMAC-SHA256 authentication code
+   */
+  async verifyHMAC(key: CryptoKeyLike, data: ArrayBuffer, mac: ArrayBuffer): Promise<boolean> {
+    this.logger?.debug('Verifying HMAC-SHA256');
+    const cryptoModule = await this.getCrypto();
+    const computed = await this.generateHMAC(key, data);
+    const expected = new Uint8Array(mac);
+    const actual = new Uint8Array(computed);
+
+    if (expected.length !== actual.length) {
+      return false;
+    }
+
+    // Constant-time comparison
+    return cryptoModule.timingSafeEqual(
+      Buffer.from(expected),
+      Buffer.from(actual)
+    );
+  }
+
+  /**
+   * Generate cryptographically secure random bytes
+   * Note: This is a synchronous method, so it uses require() instead of dynamic import
+   */
+  randomBytes(length: number): ArrayBuffer {
+    // Use cached module if available, otherwise use synchronous require
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const cryptoModule = this.cryptoModule ?? require('crypto') as NodeCrypto;
+    const buffer = cryptoModule.randomBytes(length);
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+}
+
+/**
+ * Self-register Node provider on import
+ * This allows the provider to be available when explicitly imported
+ */
+registerCryptoProvider('node', (logger) => new NodeCryptoProvider(logger));
+
+// TypeScript module augmentation to track this provider is available
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace BananaLink {
+    interface RegisteredCryptoProviders {
+      node: true;
+    }
+  }
+}