react-native-quick-crypto/lib/module/hkdf.js

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

"use strict";

import { Buffer } from '@craftzdog/react-native-buffer';
import { NitroModules } from 'react-native-nitro-modules';
import { binaryLikeToArrayBuffer, normalizeHashName } from './utils';
// Lazy load native module
let native;
function getNative() {
  if (native == null) {
    native = NitroModules.createHybridObject('Hkdf');
  }
  return native;
}
function validateCallback(callback) {
  if (callback === undefined || typeof callback !== 'function') {
    throw new Error('No callback provided to hkdf');
  }
}
function sanitizeInput(input, name) {
  try {
    return binaryLikeToArrayBuffer(input);
  } catch {
    throw new Error(`${name} must be a string, a Buffer, a typed array, or a DataView`);
  }
}
export function hkdf(digest, key, salt, info, keylen, callback) {
  validateCallback(callback);
  try {
    const normalizedDigest = normalizeHashName(digest);
    const sanitizedKey = sanitizeInput(key, 'Key');
    const sanitizedSalt = sanitizeInput(salt, 'Salt');
    const sanitizedInfo = sanitizeInput(info, 'Info');
    if (keylen < 0) {
      throw new TypeError('Bad key length');
    }
    const nativeMod = getNative();
    nativeMod.deriveKey(normalizedDigest, sanitizedKey, sanitizedSalt, sanitizedInfo, keylen).then(res => {
      callback(null, Buffer.from(res));
    }, err => {
      callback(err);
    });
  } catch (err) {
    callback(err);
  }
}
export function hkdfSync(digest, key, salt, info, keylen) {
  const normalizedDigest = normalizeHashName(digest);
  const sanitizedKey = sanitizeInput(key, 'Key');
  const sanitizedSalt = sanitizeInput(salt, 'Salt');
  const sanitizedInfo = sanitizeInput(info, 'Info');
  if (keylen < 0) {
    throw new TypeError('Bad key length');
  }
  const nativeMod = getNative();
  const result = nativeMod.deriveKeySync(normalizedDigest, sanitizedKey, sanitizedSalt, sanitizedInfo, keylen);
  return Buffer.from(result);
}
export function hkdfDeriveBits(algorithm, baseKey, length) {
  const hash = algorithm.hash;
  const salt = algorithm.salt;
  const info = algorithm.info;

  // Check if key is extractable or we can access its handle/buffer
  // For raw keys, we can export.
  const keyBuffer = baseKey.keyObject.export();

  // length is in bits, native expects bytes
  const keylen = Math.ceil(length / 8);
  const hashName = typeof hash === 'string' ? hash : hash.name;
  const normalizedDigest = normalizeHashName(hashName);
  const nativeMod = getNative();
  const result = nativeMod.deriveKeySync(normalizedDigest, binaryLikeToArrayBuffer(keyBuffer), binaryLikeToArrayBuffer(salt), binaryLikeToArrayBuffer(info), keylen);
  return result;
}
//# sourceMappingURL=hkdf.js.map