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

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

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DiffieHellman = void 0;
exports.createDiffieHellman = createDiffieHellman;
exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman;
var _reactNativeNitroModules = require("react-native-nitro-modules");
var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
var _dhGroups = require("./dh-groups");
var _conversion = require("./utils/conversion");
class DiffieHellman {
  constructor(sizeOrPrime, generator, encoding) {
    this._hybrid = _reactNativeNitroModules.NitroModules.createHybridObject('DiffieHellman');
    if (typeof sizeOrPrime === 'number') {
      const gen = typeof generator === 'number' ? generator : 2;
      this._hybrid.initWithSize(sizeOrPrime, gen);
    } else {
      let primeBuf;
      if (_reactNativeBuffer.Buffer.isBuffer(sizeOrPrime)) {
        primeBuf = sizeOrPrime;
      } else {
        primeBuf = _reactNativeBuffer.Buffer.from(sizeOrPrime, encoding);
      }
      let genBuf;
      if (generator === undefined) {
        genBuf = _reactNativeBuffer.Buffer.from([2]);
      } else if (typeof generator === 'number') {
        genBuf = _reactNativeBuffer.Buffer.from([generator]);
      } else if (_reactNativeBuffer.Buffer.isBuffer(generator)) {
        genBuf = generator;
      } else {
        genBuf = _reactNativeBuffer.Buffer.from(generator, encoding);
      }
      this._hybrid.init((0, _conversion.toArrayBuffer)(primeBuf), (0, _conversion.toArrayBuffer)(genBuf));
    }
  }
  generateKeys(encoding) {
    const keys = _reactNativeBuffer.Buffer.from(this._hybrid.generateKeys());
    if (encoding) return keys.toString(encoding);
    return keys;
  }
  computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
    let keyBuf;
    if (_reactNativeBuffer.Buffer.isBuffer(otherPublicKey)) {
      keyBuf = otherPublicKey;
    } else {
      keyBuf = _reactNativeBuffer.Buffer.from(otherPublicKey, inputEncoding);
    }
    const secret = _reactNativeBuffer.Buffer.from(this._hybrid.computeSecret((0, _conversion.toArrayBuffer)(keyBuf)));
    if (outputEncoding) return secret.toString(outputEncoding);
    return secret;
  }
  getPrime(encoding) {
    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPrime());
    if (encoding) return p.toString(encoding);
    return p;
  }
  getGenerator(encoding) {
    const g = _reactNativeBuffer.Buffer.from(this._hybrid.getGenerator());
    if (encoding) return g.toString(encoding);
    return g;
  }
  getPublicKey(encoding) {
    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPublicKey());
    if (encoding) return p.toString(encoding);
    return p;
  }
  getPrivateKey(encoding) {
    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPrivateKey());
    if (encoding) return p.toString(encoding);
    return p;
  }
  setPublicKey(publicKey, encoding) {
    let keyBuf;
    if (_reactNativeBuffer.Buffer.isBuffer(publicKey)) {
      keyBuf = publicKey;
    } else {
      keyBuf = _reactNativeBuffer.Buffer.from(publicKey, encoding);
    }
    this._hybrid.setPublicKey((0, _conversion.toArrayBuffer)(keyBuf));
  }
  setPrivateKey(privateKey, encoding) {
    let keyBuf;
    if (_reactNativeBuffer.Buffer.isBuffer(privateKey)) {
      keyBuf = privateKey;
    } else {
      keyBuf = _reactNativeBuffer.Buffer.from(privateKey, encoding);
    }
    this._hybrid.setPrivateKey((0, _conversion.toArrayBuffer)(keyBuf));
  }
  get verifyError() {
    return this._hybrid.getVerifyError();
  }
}
exports.DiffieHellman = DiffieHellman;
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 (_reactNativeBuffer.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 = _reactNativeBuffer.Buffer.from(primeOrSize, encoding);

    // Generator handling in this case
    if (generator !== undefined) {
      generatorVal = generator;
      if (typeof generator === 'string' && _generatorEncoding) {
        generatorVal = _reactNativeBuffer.Buffer.from(generator, _generatorEncoding);
      } else if (typeof generator === 'string') {
        // string with no encoding, assume same as prime? or utf8?
        generatorVal = _reactNativeBuffer.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);
}
function getDiffieHellman(groupName) {
  const group = _dhGroups.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');
}
//# sourceMappingURL=diffie-hellman.js.map