@digitalcredentials/x25519-key-agreement-key-2020/dist/crypto.js

An X25519 (Curve25519) DH (Diffie-Hellman) key implementation to work with the X25519 2020 Crypto suite.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var crypto = require('crypto');
var cryptoNacl = require('./crypto-nacl.js');
var util = require('util');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);

/*!
 * Copyright (c) 2021-2022 Digital Bazaar, Inc. All rights reserved.
 */

const PUBLIC_KEY_DER_PREFIX = new Uint8Array([
  48, 42, 48, 5, 6, 3, 43, 101, 110, 3, 33, 0
]);

const PRIVATE_KEY_DER_PREFIX = new Uint8Array([
  48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 110, 4, 34, 4, 32
]);

async function deriveSecretNative({privateKey, remotePublicKey}) {
  const nodePrivateKey = crypto__namespace.createPrivateKey({
    key: Buffer.concat([PRIVATE_KEY_DER_PREFIX, privateKey]),
    format: 'der',
    type: 'pkcs8'
  });
  const nodePublicKey = crypto__namespace.createPublicKey({
    key: Buffer.concat([PUBLIC_KEY_DER_PREFIX, remotePublicKey]),
    format: 'der',
    type: 'spki'
  });
  return crypto__namespace.diffieHellman({
    privateKey: nodePrivateKey,
    publicKey: nodePublicKey,
  });
}

async function generateKeyPairNative() {
  const generateKeyPairAsync = util.promisify(crypto__namespace.generateKeyPair);
  const publicKeyEncoding = {format: 'der', type: 'spki'};
  const privateKeyEncoding = {format: 'der', type: 'pkcs8'};
  const {publicKey: publicDerBytes, privateKey: privateDerBytes} =
    await generateKeyPairAsync('x25519', {
      publicKeyEncoding, privateKeyEncoding
    });
  const publicKey = publicDerBytes.slice(12, 12 + 32);
  const privateKey = privateDerBytes.slice(16, 16 + 32);
  return {publicKey, privateKey};
}

exports.deriveSecret = void 0;
exports.generateKeyPair = void 0;
if(crypto__namespace.diffieHellman) {
  exports.deriveSecret = deriveSecretNative;
  exports.generateKeyPair = generateKeyPairNative;
} else {
  exports.deriveSecret = cryptoNacl.deriveSecret;
  exports.generateKeyPair = cryptoNacl.generateKeyPair;
}

const {ed25519SecretKeyToX25519} = cryptoNacl;

exports.ed25519SecretKeyToX25519 = ed25519SecretKeyToX25519;