How to use

privateDecrypt

function

in

crypto

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

// 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
   }`
  );
 }
}

// 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
   }`
  );
 }
}