@happyvertical/encryption 0.74.8

package/dist/chunks/node-nfBpcQQH.js

@@ -0,0 +1,551 @@
+import * as crypto from "node:crypto";
+import { BaseEncryption, InvalidKeyError, EncryptError, DecryptError, KeyError, SignatureError } from "../index.js";
+class NodeCryptoEncryption extends BaseEncryption {
+  options;
+  key;
+  publicKey;
+  privateKey;
+  constructor(options) {
+    super("node", options.debug);
+    this.options = options;
+    this.initializeKeys();
+  }
+  /**
+   * Initialize keys from options
+   */
+  initializeKeys() {
+    if (this.options.keyDerivation) {
+      this.key = this.deriveKey(this.options.keyDerivation);
+    } else if (this.options.key) {
+      this.key = this.parseBuffer(this.options.key);
+    }
+    if (this.options.publicKey) {
+      this.publicKey = this.importPublicKeyObject(this.options.publicKey);
+    }
+    if (this.options.privateKey) {
+      this.privateKey = this.importPrivateKeyObject(
+        this.options.privateKey,
+        this.options.passphrase
+      );
+    }
+  }
+  /**
+   * Derive key from password using PBKDF2
+   */
+  deriveKey(derivation) {
+    const salt = derivation.salt ? this.parseBuffer(derivation.salt) : crypto.randomBytes(16);
+    const iterations = derivation.iterations || 1e5;
+    const keyLength = derivation.keyLength || this.getKeyLength();
+    const digest = derivation.digest || "sha256";
+    return crypto.pbkdf2Sync(
+      derivation.password,
+      salt,
+      iterations,
+      keyLength,
+      digest
+    );
+  }
+  /**
+   * Get key length for current algorithm
+   */
+  getKeyLength() {
+    const algo = this.options.algorithm.toLowerCase();
+    if (algo.includes("256")) return 32;
+    if (algo.includes("192")) return 24;
+    if (algo.includes("128")) return 16;
+    return 32;
+  }
+  /**
+   * Parse buffer from string or Buffer
+   */
+  parseBuffer(data) {
+    if (Buffer.isBuffer(data)) return data;
+    const encoding = this.options.encoding || "hex";
+    if (encoding === "hex") return Buffer.from(data, "hex");
+    if (encoding === "base64") return Buffer.from(data, "base64");
+    if (encoding === "utf8") return Buffer.from(data, "utf8");
+    return Buffer.from(data, "hex");
+  }
+  /**
+   * Import public key from PEM/DER
+   */
+  importPublicKeyObject(key) {
+    try {
+      return crypto.createPublicKey(key);
+    } catch (error) {
+      throw new InvalidKeyError(
+        `Failed to import public key: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Import private key from PEM/DER
+   */
+  importPrivateKeyObject(key, passphrase) {
+    try {
+      if (passphrase) {
+        return crypto.createPrivateKey({ key, passphrase });
+      }
+      return crypto.createPrivateKey(key);
+    } catch (error) {
+      throw new InvalidKeyError(
+        `Failed to import private key: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Check if algorithm is symmetric (AES)
+   */
+  isSymmetric() {
+    const algo = this.options.algorithm.toLowerCase();
+    return algo.startsWith("aes-") || algo.includes("cipher");
+  }
+  /**
+   * Check if algorithm is RSA
+   */
+  isRSA() {
+    const algo = this.options.algorithm.toLowerCase();
+    return algo.startsWith("rsa");
+  }
+  async encryptText(text, options) {
+    try {
+      this.log("Encrypting text", { length: text.length });
+      if (this.isSymmetric()) {
+        return this.encryptSymmetric(Buffer.from(text, "utf8"));
+      }
+      if (this.isRSA()) {
+        return this.encryptAsymmetric(Buffer.from(text, "utf8"));
+      }
+      throw new EncryptError(
+        `Unsupported encryption algorithm: ${this.options.algorithm}`,
+        this.adapterType
+      );
+    } catch (error) {
+      if (error instanceof EncryptError) throw error;
+      throw new EncryptError(
+        `Failed to encrypt text: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async decryptText(encrypted, options) {
+    try {
+      this.log("Decrypting text", { length: encrypted.length });
+      if (this.isSymmetric()) {
+        const decrypted = this.decryptSymmetric(encrypted);
+        return decrypted.toString("utf8");
+      }
+      if (this.isRSA()) {
+        const decrypted = this.decryptAsymmetric(encrypted);
+        return decrypted.toString("utf8");
+      }
+      throw new DecryptError(
+        `Unsupported decryption algorithm: ${this.options.algorithm}`,
+        this.adapterType
+      );
+    } catch (error) {
+      if (error instanceof DecryptError) throw error;
+      throw new DecryptError(
+        `Failed to decrypt text: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async encryptBuffer(buffer, options) {
+    try {
+      this.log("Encrypting buffer", { size: buffer.length });
+      if (this.isSymmetric()) {
+        const encrypted = this.encryptSymmetric(buffer);
+        return Buffer.from(encrypted, "base64");
+      }
+      if (this.isRSA()) {
+        const encrypted = this.encryptAsymmetric(buffer);
+        return Buffer.from(encrypted, "base64");
+      }
+      throw new EncryptError(
+        `Unsupported encryption algorithm: ${this.options.algorithm}`,
+        this.adapterType
+      );
+    } catch (error) {
+      if (error instanceof EncryptError) throw error;
+      throw new EncryptError(
+        `Failed to encrypt buffer: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async decryptBuffer(buffer, options) {
+    try {
+      this.log("Decrypting buffer", { size: buffer.length });
+      const base64 = buffer.toString("base64");
+      if (this.isSymmetric()) {
+        return this.decryptSymmetric(base64);
+      }
+      if (this.isRSA()) {
+        return this.decryptAsymmetric(base64);
+      }
+      throw new DecryptError(
+        `Unsupported decryption algorithm: ${this.options.algorithm}`,
+        this.adapterType
+      );
+    } catch (error) {
+      if (error instanceof DecryptError) throw error;
+      throw new DecryptError(
+        `Failed to decrypt buffer: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Symmetric encryption (AES)
+   */
+  encryptSymmetric(data) {
+    if (!this.key) {
+      throw new KeyError(
+        "Encryption key required for symmetric encryption",
+        this.adapterType
+      );
+    }
+    const algorithm = this.options.algorithm;
+    const isGCM = algorithm.toLowerCase().includes("gcm");
+    const ivLength = isGCM ? 12 : 16;
+    const iv = this.options.iv ? this.parseBuffer(this.options.iv) : crypto.randomBytes(ivLength);
+    const cipher = crypto.createCipheriv(algorithm, this.key, iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    let authTag;
+    if (isGCM) {
+      authTag = cipher.getAuthTag();
+    }
+    let result;
+    if (authTag) {
+      result = Buffer.concat([iv, authTag, encrypted]);
+    } else {
+      result = Buffer.concat([iv, encrypted]);
+    }
+    return result.toString("base64");
+  }
+  /**
+   * Symmetric decryption (AES)
+   */
+  decryptSymmetric(encrypted) {
+    if (!this.key) {
+      throw new KeyError(
+        "Decryption key required for symmetric decryption",
+        this.adapterType
+      );
+    }
+    const algorithm = this.options.algorithm;
+    const isGCM = algorithm.toLowerCase().includes("gcm");
+    const encryptedBuffer = Buffer.from(encrypted, "base64");
+    const ivLength = isGCM ? 12 : 16;
+    const iv = encryptedBuffer.subarray(0, ivLength);
+    let authTag;
+    let ciphertext;
+    if (isGCM) {
+      authTag = encryptedBuffer.subarray(ivLength, ivLength + 16);
+      ciphertext = encryptedBuffer.subarray(ivLength + 16);
+    } else {
+      ciphertext = encryptedBuffer.subarray(ivLength);
+    }
+    const decipher = crypto.createDecipheriv(algorithm, this.key, iv);
+    if (authTag) {
+      decipher.setAuthTag(authTag);
+    }
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return decrypted;
+  }
+  /**
+   * Asymmetric encryption (RSA)
+   */
+  encryptAsymmetric(data) {
+    if (!this.publicKey) {
+      throw new KeyError(
+        "Public key required for asymmetric encryption",
+        this.adapterType
+      );
+    }
+    const encrypted = crypto.publicEncrypt(
+      {
+        key: this.publicKey,
+        padding: this.getRSAPadding()
+      },
+      data
+    );
+    return encrypted.toString("base64");
+  }
+  /**
+   * Asymmetric decryption (RSA)
+   */
+  decryptAsymmetric(encrypted) {
+    if (!this.privateKey) {
+      throw new KeyError(
+        "Private key required for asymmetric decryption",
+        this.adapterType
+      );
+    }
+    const encryptedBuffer = Buffer.from(encrypted, "base64");
+    const decrypted = crypto.privateDecrypt(
+      {
+        key: this.privateKey,
+        padding: this.getRSAPadding()
+      },
+      encryptedBuffer
+    );
+    return decrypted;
+  }
+  /**
+   * Get RSA padding mode
+   */
+  getRSAPadding() {
+    const algo = this.options.algorithm.toLowerCase();
+    if (algo.includes("oaep")) {
+      return crypto.constants.RSA_PKCS1_OAEP_PADDING;
+    }
+    if (algo.includes("pss")) {
+      return crypto.constants.RSA_PKCS1_PSS_PADDING;
+    }
+    return crypto.constants.RSA_PKCS1_PADDING;
+  }
+  async generateKeyPair(options) {
+    try {
+      this.log("Generating key pair", options);
+      const keyType = options?.type || "rsa";
+      if (keyType === "rsa") {
+        const modulusLength = options?.keySize || 2048;
+        const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
+          modulusLength,
+          publicKeyEncoding: {
+            type: "spki",
+            format: "pem"
+          },
+          privateKeyEncoding: {
+            type: "pkcs8",
+            format: "pem",
+            ...options?.passphrase && {
+              cipher: "aes-256-cbc",
+              passphrase: options.passphrase
+            }
+          }
+        });
+        this.log("RSA key pair generated");
+        return { publicKey, privateKey };
+      }
+      if (keyType === "ecc" || keyType === "ecdh") {
+        const curve = options?.curve || "prime256v1";
+        const { publicKey, privateKey } = crypto.generateKeyPairSync("ec", {
+          namedCurve: curve,
+          publicKeyEncoding: {
+            type: "spki",
+            format: "pem"
+          },
+          privateKeyEncoding: {
+            type: "pkcs8",
+            format: "pem",
+            ...options?.passphrase && {
+              cipher: "aes-256-cbc",
+              passphrase: options.passphrase
+            }
+          }
+        });
+        this.log("EC key pair generated");
+        return { publicKey, privateKey };
+      }
+      if (keyType === "ecdsa") {
+        const curve = options?.curve || "prime256v1";
+        const { publicKey, privateKey } = crypto.generateKeyPairSync("ec", {
+          namedCurve: curve,
+          publicKeyEncoding: {
+            type: "spki",
+            format: "pem"
+          },
+          privateKeyEncoding: {
+            type: "pkcs8",
+            format: "pem",
+            ...options?.passphrase && {
+              cipher: "aes-256-cbc",
+              passphrase: options.passphrase
+            }
+          }
+        });
+        this.log("ECDSA key pair generated");
+        return { publicKey, privateKey };
+      }
+      throw new KeyError(
+        `Unsupported key type for Node crypto: ${keyType}`,
+        this.adapterType
+      );
+    } catch (error) {
+      throw new KeyError(
+        `Failed to generate key pair: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async importKey(key, options) {
+    try {
+      this.log("Importing key");
+      const keyType = options?.type || "public";
+      if (keyType === "public") {
+        const keyObj = crypto.createPublicKey(key);
+        const exported = keyObj.export({
+          type: "spki",
+          format: "pem"
+        });
+        return {
+          type: "public",
+          format: "pem",
+          data: exported.toString(),
+          algorithm: "node"
+        };
+      }
+      if (keyType === "private") {
+        const keyObj = options?.passphrase ? crypto.createPrivateKey({ key, passphrase: options.passphrase }) : crypto.createPrivateKey(key);
+        const exported = keyObj.export({
+          type: "pkcs8",
+          format: "pem"
+        });
+        return {
+          type: "private",
+          format: "pem",
+          data: exported.toString(),
+          algorithm: "node"
+        };
+      }
+      throw new InvalidKeyError(
+        `Unsupported key type: ${keyType}`,
+        this.adapterType
+      );
+    } catch (error) {
+      throw new InvalidKeyError(
+        `Failed to import key: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  async exportKey(key, options) {
+    try {
+      this.log("Exporting key");
+      const format = options?.format || key.format || "pem";
+      if (format === "pem" || format === "armored") {
+        return key.data;
+      }
+      if (format === "binary" || format === "der") {
+        if (typeof key.data === "string") {
+          return Buffer.from(key.data);
+        }
+        return key.data;
+      }
+      return key.data;
+    } catch (error) {
+      throw new KeyError(
+        `Failed to export key: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Sign data
+   */
+  async sign(data, options) {
+    try {
+      this.log("Signing data");
+      const privateKey = options?.privateKey ? this.importPrivateKeyObject(
+        options.privateKey,
+        options.passphrase
+      ) : this.privateKey;
+      if (!privateKey) {
+        throw new KeyError(
+          "No private key available for signing",
+          this.adapterType
+        );
+      }
+      const message = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+      const signature = crypto.sign(null, message, privateKey);
+      this.log("Data signed successfully");
+      if (typeof data === "string") {
+        return signature.toString("base64");
+      }
+      return signature;
+    } catch (error) {
+      throw new SignatureError(
+        `Failed to sign data: ${error.message}`,
+        this.adapterType,
+        error
+      );
+    }
+  }
+  /**
+   * Verify signature
+   */
+  async verify(data, signature, options) {
+    try {
+      this.log("Verifying signature");
+      if (!options?.publicKey) {
+        return false;
+      }
+      const publicKey = this.importPublicKeyObject(
+        options.publicKey
+      );
+      const message = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+      const sig = typeof signature === "string" ? Buffer.from(signature, "base64") : signature;
+      const valid = crypto.verify(null, message, publicKey, sig);
+      this.log(valid ? "Signature verified" : "Signature verification failed");
+      return valid;
+    } catch (error) {
+      this.log("Signature verification failed", error);
+      return false;
+    }
+  }
+  async getCapabilities() {
+    const algorithm = this.options.algorithm.toLowerCase();
+    const symmetricAlgorithms = [
+      "aes-256-gcm",
+      "aes-256-cbc",
+      "aes-128-gcm",
+      "aes-128-cbc"
+    ];
+    const asymmetricAlgorithms = [
+      "rsa",
+      "rsa-oaep",
+      "rsa-pss",
+      "ecdh",
+      "ecdsa"
+    ];
+    const isSymmetric = symmetricAlgorithms.includes(algorithm);
+    const isAsymmetric = asymmetricAlgorithms.some(
+      (algo) => algorithm.includes(algo)
+    );
+    return {
+      textEncryption: true,
+      fileEncryption: true,
+      bufferEncryption: true,
+      streamEncryption: true,
+      emailEncryption: false,
+      signing: true,
+      verification: true,
+      keyGeneration: true,
+      keyManagement: true,
+      multipleRecipients: false,
+      symmetricEncryption: isSymmetric,
+      asymmetricEncryption: isAsymmetric
+    };
+  }
+}
+export {
+  NodeCryptoEncryption
+};
+//# sourceMappingURL=node-nfBpcQQH.js.map

package/dist/chunks/node-nfBpcQQH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-nfBpcQQH.js","sources":["../../src/adapters/node.ts"],"sourcesContent":["import * as crypto from 'node:crypto';\nimport { BaseEncryption } from '../shared/base.js';\nimport {\n  DecryptError,\n  EncryptError,\n  InvalidKeyError,\n  KeyError,\n  SignatureError,\n} from '../shared/errors.js';\nimport type {\n  DecryptOptions,\n  EncryptionCapabilities,\n  EncryptOptions,\n  ExportKeyOptions,\n  ImportKeyOptions,\n  Key,\n  KeyPair,\n  KeyPairOptions,\n  NodeCryptoOptions,\n  SignOptions,\n  VerifyOptions,\n} from '../shared/types.js';\n\n/**\n * Node.js crypto adapter\n *\n * Uses Node.js built-in crypto module for standard encryption algorithms\n * (AES, RSA, ECDH, ECDSA, etc.).\n *\n * @example\n * ```typescript\n * const crypto = new NodeCryptoEncryption({\n *   type: 'node',\n *   algorithm: 'aes-256-gcm',\n *   key: encryptionKey\n * });\n *\n * const encrypted = await crypto.encryptText('Secret message');\n * const decrypted = await crypto.decryptText(encrypted);\n * ```\n */\nexport class NodeCryptoEncryption extends BaseEncryption {\n  private options: NodeCryptoOptions;\n  private key?: Buffer;\n  private publicKey?: crypto.KeyObject;\n  private privateKey?: crypto.KeyObject;\n\n  constructor(options: NodeCryptoOptions) {\n    super('node', options.debug);\n    this.options = options;\n    this.initializeKeys();\n  }\n\n  /**\n   * Initialize keys from options\n   */\n  private initializeKeys(): void {\n    // Derive key from password if specified\n    if (this.options.keyDerivation) {\n      this.key = this.deriveKey(this.options.keyDerivation);\n    } else if (this.options.key) {\n      this.key = this.parseBuffer(this.options.key);\n    }\n\n    // Initialize asymmetric keys\n    if (this.options.publicKey) {\n      this.publicKey = this.importPublicKeyObject(this.options.publicKey);\n    }\n\n    if (this.options.privateKey) {\n      this.privateKey = this.importPrivateKeyObject(\n        this.options.privateKey,\n        this.options.passphrase,\n      );\n    }\n  }\n\n  /**\n   * Derive key from password using PBKDF2\n   */\n  private deriveKey(\n    derivation: NonNullable<NodeCryptoOptions['keyDerivation']>,\n  ): Buffer {\n    const salt = derivation.salt\n      ? this.parseBuffer(derivation.salt)\n      : crypto.randomBytes(16);\n    const iterations = derivation.iterations || 100000;\n    const keyLength = derivation.keyLength || this.getKeyLength();\n    const digest = derivation.digest || 'sha256';\n\n    return crypto.pbkdf2Sync(\n      derivation.password,\n      salt,\n      iterations,\n      keyLength,\n      digest,\n    );\n  }\n\n  /**\n   * Get key length for current algorithm\n   */\n  private getKeyLength(): number {\n    const algo = this.options.algorithm.toLowerCase();\n    if (algo.includes('256')) return 32;\n    if (algo.includes('192')) return 24;\n    if (algo.includes('128')) return 16;\n    return 32; // Default to 256 bits\n  }\n\n  /**\n   * Parse buffer from string or Buffer\n   */\n  private parseBuffer(data: string | Buffer): Buffer {\n    if (Buffer.isBuffer(data)) return data;\n\n    const encoding = this.options.encoding || 'hex';\n    if (encoding === 'hex') return Buffer.from(data, 'hex');\n    if (encoding === 'base64') return Buffer.from(data, 'base64');\n    if (encoding === 'utf8') return Buffer.from(data, 'utf8');\n\n    return Buffer.from(data, 'hex');\n  }\n\n  /**\n   * Import public key from PEM/DER\n   */\n  private importPublicKeyObject(key: string | Buffer): crypto.KeyObject {\n    try {\n      return crypto.createPublicKey(key);\n    } catch (error) {\n      throw new InvalidKeyError(\n        `Failed to import public key: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  /**\n   * Import private key from PEM/DER\n   */\n  private importPrivateKeyObject(\n    key: string | Buffer,\n    passphrase?: string,\n  ): crypto.KeyObject {\n    try {\n      if (passphrase) {\n        return crypto.createPrivateKey({ key, passphrase });\n      }\n      return crypto.createPrivateKey(key);\n    } catch (error) {\n      throw new InvalidKeyError(\n        `Failed to import private key: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  /**\n   * Check if algorithm is symmetric (AES)\n   */\n  private isSymmetric(): boolean {\n    const algo = this.options.algorithm.toLowerCase();\n    return algo.startsWith('aes-') || algo.includes('cipher');\n  }\n\n  /**\n   * Check if algorithm is RSA\n   */\n  private isRSA(): boolean {\n    const algo = this.options.algorithm.toLowerCase();\n    return algo.startsWith('rsa');\n  }\n\n  async encryptText(text: string, options?: EncryptOptions): Promise<string> {\n    try {\n      this.log('Encrypting text', { length: text.length });\n\n      if (this.isSymmetric()) {\n        return this.encryptSymmetric(Buffer.from(text, 'utf8'));\n      }\n\n      if (this.isRSA()) {\n        return this.encryptAsymmetric(Buffer.from(text, 'utf8'));\n      }\n\n      throw new EncryptError(\n        `Unsupported encryption algorithm: ${this.options.algorithm}`,\n        this.adapterType,\n      );\n    } catch (error) {\n      if (error instanceof EncryptError) throw error;\n      throw new EncryptError(\n        `Failed to encrypt text: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  async decryptText(\n    encrypted: string,\n    options?: DecryptOptions,\n  ): Promise<string> {\n    try {\n      this.log('Decrypting text', { length: encrypted.length });\n\n      if (this.isSymmetric()) {\n        const decrypted = this.decryptSymmetric(encrypted);\n        return decrypted.toString('utf8');\n      }\n\n      if (this.isRSA()) {\n        const decrypted = this.decryptAsymmetric(encrypted);\n        return decrypted.toString('utf8');\n      }\n\n      throw new DecryptError(\n        `Unsupported decryption algorithm: ${this.options.algorithm}`,\n        this.adapterType,\n      );\n    } catch (error) {\n      if (error instanceof DecryptError) throw error;\n      throw new DecryptError(\n        `Failed to decrypt text: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  async encryptBuffer(\n    buffer: Buffer,\n    options?: EncryptOptions,\n  ): Promise<Buffer> {\n    try {\n      this.log('Encrypting buffer', { size: buffer.length });\n\n      if (this.isSymmetric()) {\n        const encrypted = this.encryptSymmetric(buffer);\n        return Buffer.from(encrypted, 'base64');\n      }\n\n      if (this.isRSA()) {\n        const encrypted = this.encryptAsymmetric(buffer);\n        return Buffer.from(encrypted, 'base64');\n      }\n\n      throw new EncryptError(\n        `Unsupported encryption algorithm: ${this.options.algorithm}`,\n        this.adapterType,\n      );\n    } catch (error) {\n      if (error instanceof EncryptError) throw error;\n      throw new EncryptError(\n        `Failed to encrypt buffer: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  async decryptBuffer(\n    buffer: Buffer,\n    options?: DecryptOptions,\n  ): Promise<Buffer> {\n    try {\n      this.log('Decrypting buffer', { size: buffer.length });\n\n      const base64 = buffer.toString('base64');\n\n      if (this.isSymmetric()) {\n        return this.decryptSymmetric(base64);\n      }\n\n      if (this.isRSA()) {\n        return this.decryptAsymmetric(base64);\n      }\n\n      throw new DecryptError(\n        `Unsupported decryption algorithm: ${this.options.algorithm}`,\n        this.adapterType,\n      );\n    } catch (error) {\n      if (error instanceof DecryptError) throw error;\n      throw new DecryptError(\n        `Failed to decrypt buffer: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  /**\n   * Symmetric encryption (AES)\n   */\n  private encryptSymmetric(data: Buffer): string {\n    if (!this.key) {\n      throw new KeyError(\n        'Encryption key required for symmetric encryption',\n        this.adapterType,\n      );\n    }\n\n    const algorithm = this.options.algorithm;\n    const isGCM = algorithm.toLowerCase().includes('gcm');\n\n    // Generate IV\n    const ivLength = isGCM ? 12 : 16; // GCM uses 12 bytes, CBC uses 16\n    const iv = this.options.iv\n      ? this.parseBuffer(this.options.iv)\n      : crypto.randomBytes(ivLength);\n\n    // Create cipher\n    const cipher = crypto.createCipheriv(algorithm, this.key, iv);\n\n    // Encrypt\n    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);\n\n    // For GCM, get auth tag\n    let authTag: Buffer | undefined;\n    if (isGCM) {\n      authTag = (cipher as crypto.CipherGCM).getAuthTag();\n    }\n\n    // Combine: iv + (authTag if GCM) + encrypted\n    let result: Buffer;\n    if (authTag) {\n      result = Buffer.concat([iv, authTag, encrypted]);\n    } else {\n      result = Buffer.concat([iv, encrypted]);\n    }\n\n    return result.toString('base64');\n  }\n\n  /**\n   * Symmetric decryption (AES)\n   */\n  private decryptSymmetric(encrypted: string): Buffer {\n    if (!this.key) {\n      throw new KeyError(\n        'Decryption key required for symmetric decryption',\n        this.adapterType,\n      );\n    }\n\n    const algorithm = this.options.algorithm;\n    const isGCM = algorithm.toLowerCase().includes('gcm');\n\n    const encryptedBuffer = Buffer.from(encrypted, 'base64');\n\n    // Extract IV\n    const ivLength = isGCM ? 12 : 16;\n    const iv = encryptedBuffer.subarray(0, ivLength);\n\n    // Extract auth tag if GCM\n    let authTag: Buffer | undefined;\n    let ciphertext: Buffer;\n    if (isGCM) {\n      authTag = encryptedBuffer.subarray(ivLength, ivLength + 16);\n      ciphertext = encryptedBuffer.subarray(ivLength + 16);\n    } else {\n      ciphertext = encryptedBuffer.subarray(ivLength);\n    }\n\n    // Create decipher\n    const decipher = crypto.createDecipheriv(algorithm, this.key, iv);\n\n    // Set auth tag for GCM\n    if (authTag) {\n      (decipher as crypto.DecipherGCM).setAuthTag(authTag);\n    }\n\n    // Decrypt\n    const decrypted = Buffer.concat([\n      decipher.update(ciphertext),\n      decipher.final(),\n    ]);\n\n    return decrypted;\n  }\n\n  /**\n   * Asymmetric encryption (RSA)\n   */\n  private encryptAsymmetric(data: Buffer): string {\n    if (!this.publicKey) {\n      throw new KeyError(\n        'Public key required for asymmetric encryption',\n        this.adapterType,\n      );\n    }\n\n    const encrypted = crypto.publicEncrypt(\n      {\n        key: this.publicKey,\n        padding: this.getRSAPadding(),\n      },\n      data,\n    );\n\n    return encrypted.toString('base64');\n  }\n\n  /**\n   * Asymmetric decryption (RSA)\n   */\n  private decryptAsymmetric(encrypted: string): Buffer {\n    if (!this.privateKey) {\n      throw new KeyError(\n        'Private key required for asymmetric decryption',\n        this.adapterType,\n      );\n    }\n\n    const encryptedBuffer = Buffer.from(encrypted, 'base64');\n\n    const decrypted = crypto.privateDecrypt(\n      {\n        key: this.privateKey,\n        padding: this.getRSAPadding(),\n      },\n      encryptedBuffer,\n    );\n\n    return decrypted;\n  }\n\n  /**\n   * Get RSA padding mode\n   */\n  private getRSAPadding(): number {\n    const algo = this.options.algorithm.toLowerCase();\n    if (algo.includes('oaep')) {\n      return crypto.constants.RSA_PKCS1_OAEP_PADDING;\n    }\n    if (algo.includes('pss')) {\n      return crypto.constants.RSA_PKCS1_PSS_PADDING;\n    }\n    return crypto.constants.RSA_PKCS1_PADDING;\n  }\n\n  async generateKeyPair(options?: KeyPairOptions): Promise<KeyPair> {\n    try {\n      this.log('Generating key pair', options);\n\n      const keyType = options?.type || 'rsa';\n\n      if (keyType === 'rsa') {\n        const modulusLength = options?.keySize || 2048;\n        const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {\n          modulusLength,\n          publicKeyEncoding: {\n            type: 'spki',\n            format: 'pem',\n          },\n          privateKeyEncoding: {\n            type: 'pkcs8',\n            format: 'pem',\n            ...(options?.passphrase && {\n              cipher: 'aes-256-cbc',\n              passphrase: options.passphrase,\n            }),\n          },\n        });\n\n        this.log('RSA key pair generated');\n\n        return { publicKey, privateKey };\n      }\n\n      if (keyType === 'ecc' || keyType === 'ecdh') {\n        const curve = options?.curve || 'prime256v1';\n        const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', {\n          namedCurve: curve,\n          publicKeyEncoding: {\n            type: 'spki',\n            format: 'pem',\n          },\n          privateKeyEncoding: {\n            type: 'pkcs8',\n            format: 'pem',\n            ...(options?.passphrase && {\n              cipher: 'aes-256-cbc',\n              passphrase: options.passphrase,\n            }),\n          },\n        });\n\n        this.log('EC key pair generated');\n\n        return { publicKey, privateKey };\n      }\n\n      if (keyType === 'ecdsa') {\n        const curve = options?.curve || 'prime256v1';\n        const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', {\n          namedCurve: curve,\n          publicKeyEncoding: {\n            type: 'spki',\n            format: 'pem',\n          },\n          privateKeyEncoding: {\n            type: 'pkcs8',\n            format: 'pem',\n            ...(options?.passphrase && {\n              cipher: 'aes-256-cbc',\n              passphrase: options.passphrase,\n            }),\n          },\n        });\n\n        this.log('ECDSA key pair generated');\n\n        return { publicKey, privateKey };\n      }\n\n      throw new KeyError(\n        `Unsupported key type for Node crypto: ${keyType}`,\n        this.adapterType,\n      );\n    } catch (error) {\n      throw new KeyError(\n        `Failed to generate key pair: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  async importKey(\n    key: string | Buffer,\n    options?: ImportKeyOptions,\n  ): Promise<Key> {\n    try {\n      this.log('Importing key');\n\n      const keyType = options?.type || 'public';\n\n      if (keyType === 'public') {\n        const keyObj = crypto.createPublicKey(key);\n        const exported = keyObj.export({\n          type: 'spki',\n          format: 'pem',\n        });\n\n        return {\n          type: 'public',\n          format: 'pem',\n          data: exported.toString(),\n          algorithm: 'node',\n        };\n      }\n\n      if (keyType === 'private') {\n        const keyObj = options?.passphrase\n          ? crypto.createPrivateKey({ key, passphrase: options.passphrase })\n          : crypto.createPrivateKey(key);\n\n        const exported = keyObj.export({\n          type: 'pkcs8',\n          format: 'pem',\n        });\n\n        return {\n          type: 'private',\n          format: 'pem',\n          data: exported.toString(),\n          algorithm: 'node',\n        };\n      }\n\n      throw new InvalidKeyError(\n        `Unsupported key type: ${keyType}`,\n        this.adapterType,\n      );\n    } catch (error) {\n      throw new InvalidKeyError(\n        `Failed to import key: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  async exportKey(\n    key: Key,\n    options?: ExportKeyOptions,\n  ): Promise<string | Buffer> {\n    try {\n      this.log('Exporting key');\n\n      const format = options?.format || key.format || 'pem';\n\n      if (format === 'pem' || format === 'armored') {\n        return key.data as string;\n      }\n\n      if (format === 'binary' || format === 'der') {\n        if (typeof key.data === 'string') {\n          return Buffer.from(key.data);\n        }\n        return key.data as Buffer;\n      }\n\n      return key.data as string;\n    } catch (error) {\n      throw new KeyError(\n        `Failed to export key: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  /**\n   * Sign data\n   */\n  async sign(\n    data: string | Buffer,\n    options?: SignOptions,\n  ): Promise<string | Buffer> {\n    try {\n      this.log('Signing data');\n\n      const privateKey = options?.privateKey\n        ? this.importPrivateKeyObject(\n            options.privateKey as string | Buffer,\n            options.passphrase,\n          )\n        : this.privateKey;\n\n      if (!privateKey) {\n        throw new KeyError(\n          'No private key available for signing',\n          this.adapterType,\n        );\n      }\n\n      const message =\n        typeof data === 'string' ? Buffer.from(data, 'utf8') : data;\n\n      const signature = crypto.sign(null, message, privateKey);\n\n      this.log('Data signed successfully');\n\n      if (typeof data === 'string') {\n        return signature.toString('base64');\n      }\n\n      return signature;\n    } catch (error) {\n      throw new SignatureError(\n        `Failed to sign data: ${(error as Error).message}`,\n        this.adapterType,\n        error,\n      );\n    }\n  }\n\n  /**\n   * Verify signature\n   */\n  async verify(\n    data: string | Buffer,\n    signature: string | Buffer,\n    options?: VerifyOptions,\n  ): Promise<boolean> {\n    try {\n      this.log('Verifying signature');\n\n      if (!options?.publicKey) {\n        return false;\n      }\n\n      const publicKey = this.importPublicKeyObject(\n        options.publicKey as string | Buffer,\n      );\n\n      const message =\n        typeof data === 'string' ? Buffer.from(data, 'utf8') : data;\n      const sig =\n        typeof signature === 'string'\n          ? Buffer.from(signature, 'base64')\n          : signature;\n\n      const valid = crypto.verify(null, message, publicKey, sig);\n\n      this.log(valid ? 'Signature verified' : 'Signature verification failed');\n\n      return valid;\n    } catch (error) {\n      this.log('Signature verification failed', error);\n      return false;\n    }\n  }\n\n  async getCapabilities(): Promise<EncryptionCapabilities> {\n    const algorithm = this.options.algorithm.toLowerCase();\n\n    // Determine if algorithm is symmetric or asymmetric\n    const symmetricAlgorithms = [\n      'aes-256-gcm',\n      'aes-256-cbc',\n      'aes-128-gcm',\n      'aes-128-cbc',\n    ];\n    const asymmetricAlgorithms = [\n      'rsa',\n      'rsa-oaep',\n      'rsa-pss',\n      'ecdh',\n      'ecdsa',\n    ];\n\n    const isSymmetric = symmetricAlgorithms.includes(algorithm);\n    const isAsymmetric = asymmetricAlgorithms.some((algo) =>\n      algorithm.includes(algo),\n    );\n\n    return {\n      textEncryption: true,\n      fileEncryption: true,\n      bufferEncryption: true,\n      streamEncryption: true,\n      emailEncryption: false,\n      signing: true,\n      verification: true,\n      keyGeneration: true,\n      keyManagement: true,\n      multipleRecipients: false,\n      symmetricEncryption: isSymmetric,\n      asymmetricEncryption: isAsymmetric,\n    };\n  }\n}\n"],"names":[],"mappings":"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"}