react-native-quick-crypto/lib/module/diffie-hellman.js

A fast implementation of Node's `crypto` module written in C/C++ JSI

"use strict";

import { NitroModules } from 'react-native-nitro-modules';
import { Buffer } from '@craftzdog/react-native-buffer';
import { DH_GROUPS } from './dh-groups';
import { toArrayBuffer } from './utils/conversion';
export class DiffieHellman {
  constructor(sizeOrPrime, generator, encoding) {
    this._hybrid = NitroModules.createHybridObject('DiffieHellman');
    if (typeof sizeOrPrime === 'number') {
      const gen = typeof generator === 'number' ? generator : 2;
      this._hybrid.initWithSize(sizeOrPrime, gen);
    } else {
      let primeBuf;
      if (Buffer.isBuffer(sizeOrPrime)) {
        primeBuf = sizeOrPrime;
      } else {
        primeBuf = Buffer.from(sizeOrPrime, encoding);
      }
      let genBuf;
      if (generator === undefined) {
        genBuf = Buffer.from([2]);
      } else if (typeof generator === 'number') {
        genBuf = Buffer.from([generator]);
      } else if (Buffer.isBuffer(generator)) {
        genBuf = generator;
      } else {
        genBuf = Buffer.from(generator, encoding);
      }
      this._hybrid.init(toArrayBuffer(primeBuf), toArrayBuffer(genBuf));
    }
  }
  generateKeys(encoding) {
    const keys = Buffer.from(this._hybrid.generateKeys());
    if (encoding) return keys.toString(encoding);
    return keys;
  }
  computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
    let keyBuf;
    if (Buffer.isBuffer(otherPublicKey)) {
      keyBuf = otherPublicKey;
    } else {
      keyBuf = Buffer.from(otherPublicKey, inputEncoding);
    }
    const secret = Buffer.from(this._hybrid.computeSecret(toArrayBuffer(keyBuf)));
    if (outputEncoding) return secret.toString(outputEncoding);
    return secret;
  }
  getPrime(encoding) {
    const p = Buffer.from(this._hybrid.getPrime());
    if (encoding) return p.toString(encoding);
    return p;
  }
  getGenerator(encoding) {
    const g = Buffer.from(this._hybrid.getGenerator());
    if (encoding) return g.toString(encoding);
    return g;
  }
  getPublicKey(encoding) {
    const p = Buffer.from(this._hybrid.getPublicKey());
    if (encoding) return p.toString(encoding);
    return p;
  }
  getPrivateKey(encoding) {
    const p = Buffer.from(this._hybrid.getPrivateKey());
    if (encoding) return p.toString(encoding);
    return p;
  }
  setPublicKey(publicKey, encoding) {
    let keyBuf;
    if (Buffer.isBuffer(publicKey)) {
      keyBuf = publicKey;
    } else {
      keyBuf = Buffer.from(publicKey, encoding);
    }
    this._hybrid.setPublicKey(toArrayBuffer(keyBuf));
  }
  setPrivateKey(privateKey, encoding) {
    let keyBuf;
    if (Buffer.isBuffer(privateKey)) {
      keyBuf = privateKey;
    } else {
      keyBuf = Buffer.from(privateKey, encoding);
    }
    this._hybrid.setPrivateKey(toArrayBuffer(keyBuf));
  }
  get verifyError() {
    return this._hybrid.getVerifyError();
  }
}
export function createDiffieHellman(primeOrSize, primeEncodingOrGenerator, generator, _generatorEncoding) {
  if (typeof primeOrSize === 'number') {
    const gen = typeof primeEncodingOrGenerator === 'number' ? primeEncodingOrGenerator : 2;
    return new DiffieHellman(primeOrSize, gen);
  }

  // Standardize arguments for String/Buffer prime
  // createDiffieHellman(prime, [encoding], [generator], [encoding])

  let prime;
  let generatorVal;
  if (Buffer.isBuffer(primeOrSize)) {
    prime = primeOrSize;
    // 2nd arg is generator if not string (encoding)
    if (primeEncodingOrGenerator !== undefined && typeof primeEncodingOrGenerator !== 'string') {
      generatorVal = primeEncodingOrGenerator;
    } else if (generator !== undefined) {
      generatorVal = generator;
    } else {
      generatorVal = 2;
    }
  } else {
    // String prime
    const encoding = typeof primeEncodingOrGenerator === 'string' ? primeEncodingOrGenerator : 'utf8'; // Defaulting to utf8 or hex? Node default is 'binary' usually but utf8 safer for TS. Node docs say: "If no encoding is specified, 'binary' is used."
    // We'll trust user passed encoding if it's a string, otherwise handle it.
    prime = Buffer.from(primeOrSize, encoding);

    // Generator handling in this case
    if (generator !== undefined) {
      generatorVal = generator;
      if (typeof generator === 'string' && _generatorEncoding) {
        generatorVal = Buffer.from(generator, _generatorEncoding);
      } else if (typeof generator === 'string') {
        // string with no encoding, assume same as prime? or utf8?
        generatorVal = Buffer.from(generator, encoding);
      }
    } else if (typeof primeEncodingOrGenerator !== 'string' && primeEncodingOrGenerator !== undefined) {
      // 2nd arg was generator
      generatorVal = primeEncodingOrGenerator;
    } else {
      generatorVal = 2;
    }
  }
  return new DiffieHellman(prime, generatorVal);
}
export function getDiffieHellman(groupName) {
  const group = DH_GROUPS[groupName];
  if (!group) {
    throw new Error(`Unknown group: ${groupName}`);
  }
  // group.prime and group.generator are hex strings
  return new DiffieHellman(group.prime, group.generator, 'hex');
}
export { getDiffieHellman as createDiffieHellmanGroup };
//# sourceMappingURL=diffie-hellman.js.map