Crypto generation of RSA, ECDSA and Ed25519 KeyPairs using Node Crypto and Webcrypto

crypto.ts

import type { JsonWebKey } from 'crypto';
import crypto from 'crypto';

/**
 * Generates equivalent to RSASSA-PKCS1-v1_5 keypair
 */
async function generateKeyPairRSA(): Promise<{
  publicKey: JsonWebKey,
  privateKey: JsonWebKey
}> {
  return new Promise((resolve, reject) => {
    crypto.generateKeyPair('rsa', {
      modulusLength: 2048,
    }, (err, publicKey, privateKey) => {
      if (err) {
        reject(err);
      } else {
        resolve({
          publicKey: publicKey.export({ format: 'jwk' }),
          privateKey: privateKey.export({ format: 'jwk' }),
        });
      }
    });
  });
}

async function generateKeyPairECDSA(): Promise<{
  publicKey: JsonWebKey,
  privateKey: JsonWebKey,
}> {
  return new Promise((resolve, reject) => {
    crypto.generateKeyPair('ec', {
      namedCurve: 'P-256',
    }, (err, publicKey, privateKey) => {
      if (err) {
        reject(err);
      } else {
        resolve({
          publicKey: publicKey.export({
            format: 'jwk'
          }),
          privateKey: privateKey.export({
            format: 'jwk'
          })
        });
      }
    });
  });
}

async function generateKeyPairEd25519(): Promise<{
  publicKey: JsonWebKey,
  privateKey: JsonWebKey
}> {
  return new Promise((resolve, reject) => {
    crypto.generateKeyPair(
      'ed25519',
      undefined,
      (e, publicKey, privateKey) => {
        if (e) {
          reject(e);
        } else {
          resolve({
            publicKey: publicKey.export({
              format: 'jwk'
            }),
            privateKey: privateKey.export({
              format: 'jwk'
            })
          });
        }
      }
    );
  });
}

async function main() {
  console.log(await generateKeyPairRSA());
  console.log(await generateKeyPairECDSA());
  console.log(await generateKeyPairEd25519());
}

void main();

peculiar_webcrypto.ts

import { Crypto } from '@peculiar/webcrypto';

/**
 * WebCrypto polyfill from @peculiar/webcrypto
 * This behaves differently with respect to Ed25519 keys
 * See: https://github.com/PeculiarVentures/webcrypto/issues/55
 */
const webcrypto = new Crypto();

/**
 * Generates equivalent to RSASSA-PKCS1-v1_5 keypair
 */
async function generateKeyPairRSA(): Promise<{
  publicKey: JsonWebKey;
  privateKey: JsonWebKey;
}> {
  const keyPair = await webcrypto.subtle.generateKey(
    {
      name: 'RSASSA-PKCS1-v1_5',
      modulusLength: 2048,
      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
      hash: 'SHA-256'
    },
    true,
    [
      'sign',
      'verify',
    ]
  );
  return {
    publicKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.publicKey
    ),
    privateKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.privateKey
    )
  };
}

async function generateKeyPairECDSA(): Promise<{
  publicKey: JsonWebKey;
  privateKey: JsonWebKey;
}> {
  const keyPair = await webcrypto.subtle.generateKey(
    {
      name: 'ECDSA',
      namedCurve: 'P-256'
    },
    true,
    [
      'sign',
      'verify'
    ]
  );
  return {
    publicKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.publicKey
    ),
    privateKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.privateKey
    )
  };
}

async function generateKeyPairEd25519(): Promise<{
  publicKey: JsonWebKey;
  privateKey: JsonWebKey;
}> {
  const keyPair = await webcrypto.subtle.generateKey(
    {
      name: 'EdDSA',
      namedCurve: 'Ed25519'
    },
    true,
    [
      'sign',
      'verify'
    ]
  ) as CryptoKeyPair;
  return {
    publicKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.publicKey
    ),
    privateKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.privateKey
    )
  };
}

async function main() {
  console.log(await generateKeyPairRSA());
  console.log(await generateKeyPairECDSA());
  console.log(await generateKeyPairEd25519());
}

void main();

webcrypto.ts

import { webcrypto } from 'crypto';

/**
 * Generates equivalent to Node's regular RSA keypair
 */
async function generateKeyPairRSA(): Promise<{
  publicKey: JsonWebKey;
  privateKey: JsonWebKey;
}> {
  const keyPair = await webcrypto.subtle.generateKey(
    {
      name: 'RSASSA-PKCS1-v1_5',
      modulusLength: 2048,
      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
      hash: 'SHA-256'
    },
    true,
    [
      'sign',
      'verify',
    ]
  );
  return {
    publicKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.publicKey
    ),
    privateKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.privateKey
    )
  };
}

async function generateKeyPairECDSA(): Promise<{
  publicKey: JsonWebKey;
  privateKey: JsonWebKey;
}> {
  const keyPair = await webcrypto.subtle.generateKey(
    {
      name: 'ECDSA',
      namedCurve: 'P-256'
    },
    true,
    [
      'sign',
      'verify'
    ]
  );
  return {
    publicKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.publicKey
    ),
    privateKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.privateKey
    )
  };
}

/**
 * This is only available inside Node.
 * This is not part of the webcrypto specification.
 */
async function generateKeyPairEd25519(): Promise<{
  publicKey: JsonWebKey;
  privateKey: JsonWebKey;
}> {
  const keyPair = await webcrypto.subtle.generateKey(
    {
      name: 'ED25519',
    },
    true,
    [
      'sign',
      'verify'
    ]
  ) as webcrypto.CryptoKeyPair;
  return {
    publicKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.publicKey
    ),
    privateKey: await webcrypto.subtle.exportKey(
      'jwk',
      keyPair.privateKey
    )
  };
}

async function main() {
  console.log(await generateKeyPairRSA());
  console.log(await generateKeyPairECDSA());
  console.log(await generateKeyPairEd25519());
}

void main();

For RSA, the most compatible is always the PKCS1-v1.5, this is most commonly used in TLS.

For ECDSA, the most common curve is P-256.

Ed25519 is the best of course, but it's not fully supported everywhere.

Note that @peculiar/webcrypto has different API with webcrypto in Node.js for Ed25519.