How to use

publicEncrypt

function

in

crypto

static publicEncrypt(key, data) {
    return crypto.publicEncrypt({
      key: key.toPem(),
      padding: crypto.constants.RSA_PKCS1_PADDING,
    }, data);
  }

const rsaEncrypt = (buffer, key) => {
  buffer = Buffer.concat([Buffer.alloc(128 - buffer.length), buffer])
  return crypto.publicEncrypt({key: key, padding: crypto.constants.RSA_NO_PADDING}, buffer)
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

const rsaEncrypt = (buffer, key) => {
 buffer = Buffer.concat([Buffer.alloc(128 - buffer.length), buffer])
 return crypto.publicEncrypt({key: key, padding: crypto.constants.RSA_NO_PADDING}, buffer)
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
    err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
   err.message
   }`
  );
 }
}

// Ensure the certificate and key provided are valid and if not
// throw an easy to debug error
function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
 let encrypted;
 try {
  // publicEncrypt will throw an error with an invalid cert
  encrypted = crypto.publicEncrypt(cert, Buffer.from('test'));
 } catch (err) {
  throw new Error(
   `The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`
  );
 }

 try {
  // privateDecrypt will throw an error with an invalid key
  crypto.privateDecrypt(key, encrypted);
 } catch (err) {
  throw new Error(
   `The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${
   err.message
   }`
  );
 }
}