react-native-quick-crypto/lib/commonjs/ecdh.js

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

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ECDH = void 0;
exports.createECDH = createECDH;
var _reactNativeNitroModules = require("react-native-nitro-modules");
var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
var _conversion = require("./utils/conversion");
const POINT_CONVERSION_COMPRESSED = 2;
const POINT_CONVERSION_UNCOMPRESSED = 4;
const POINT_CONVERSION_HYBRID = 6;
class ECDH {
  static get convertKeyHybrid() {
    if (!this._convertKeyHybrid) {
      this._convertKeyHybrid = _reactNativeNitroModules.NitroModules.createHybridObject('ECDH');
    }
    return this._convertKeyHybrid;
  }
  constructor(curveName) {
    this._hybrid = _reactNativeNitroModules.NitroModules.createHybridObject('ECDH');
    this._hybrid.init(curveName);
  }
  generateKeys() {
    const key = this._hybrid.generateKeys();
    return _reactNativeBuffer.Buffer.from(key);
  }
  computeSecret(otherPublicKey, inputEncoding) {
    let keyBuf;
    if (_reactNativeBuffer.Buffer.isBuffer(otherPublicKey)) {
      keyBuf = otherPublicKey;
    } else if (typeof otherPublicKey === 'string') {
      keyBuf = _reactNativeBuffer.Buffer.from(otherPublicKey, inputEncoding);
    } else {
      // Handle array view or other types if necessary, but Node.js typically expects Buffer or string + encoding
      throw new TypeError('Invalid otherPublicKey type');
    }

    // ECDH.computeSecret in Node.js returns Buffer
    const secret = this._hybrid.computeSecret((0, _conversion.toArrayBuffer)(keyBuf));
    return _reactNativeBuffer.Buffer.from(secret);
  }
  getPrivateKey() {
    return _reactNativeBuffer.Buffer.from(this._hybrid.getPrivateKey());
  }
  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));
  }
  getPublicKey(encoding) {
    // Node.js getPublicKey([encoding[, format]])
    // If encoding is provided, returns string. If not, Buffer.
    // Our C++ returns ArrayBuffer (Buffer).
    // We ignore format for now as C++ implementation defaults to uncompressed.
    const pub = _reactNativeBuffer.Buffer.from(this._hybrid.getPublicKey());
    if (encoding) {
      return pub.toString(encoding);
    }
    return pub;
  }
  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));
  }
  static convertKey(key, curve, inputEncoding, outputEncoding, format) {
    let keyBuf;
    if (_reactNativeBuffer.Buffer.isBuffer(key)) {
      keyBuf = key;
    } else {
      keyBuf = _reactNativeBuffer.Buffer.from(key, inputEncoding);
    }
    let formatNum;
    switch (format) {
      case 'compressed':
        formatNum = POINT_CONVERSION_COMPRESSED;
        break;
      case 'hybrid':
        formatNum = POINT_CONVERSION_HYBRID;
        break;
      case 'uncompressed':
      case undefined:
        formatNum = POINT_CONVERSION_UNCOMPRESSED;
        break;
      default:
        throw new TypeError(`Invalid point conversion format: ${format}`);
    }
    const result = _reactNativeBuffer.Buffer.from(ECDH.convertKeyHybrid.convertKey((0, _conversion.toArrayBuffer)(keyBuf), curve, formatNum));
    if (outputEncoding) {
      return result.toString(outputEncoding);
    }
    return result;
  }
}
exports.ECDH = ECDH;
function createECDH(curveName) {
  return new ECDH(curveName);
}
//# sourceMappingURL=ecdh.js.map