Node.js crypto.privateDecrypt() Method

Last Updated : 31 Mar, 2023

The crypto.privateDecrypt() method is used to decrypt the content of the buffer with privateKey.buffer which was previously encrypted using the corresponding public key, i.e. crypto.publicEncrypt().

Syntax:

crypto.privateDecrypt( privateKey, buffer )

Parameters: This method accepts two parameters as mentioned above and described below:

privateKey: It can hold an Object, string, Buffer, or KeyObject type of data.
1. oaepHash It is the hash function of the typed string that is used for ‘OAEP’ padding. And the default value is ‘sha1’.
2. oaepLabel: It is the label that is used for ‘OAEP’ padding. And if it is not specified, then no label is used. It is of type Buffer, TypedArray, or DataView.
3. padding: It is an optional padding value that is defined in crypto.constants, which can be crypto.constants.RSA_NO_PADDING, crypto.constants.RSA_PKCS1_PADDING, or crypto.constants.RSA_PKCS1_OAEP_PADDING. It is of type crypto.constants.
buffer: It is of type Buffer, TypedArray, or DataView.

Return Value: It returns a new Buffer with the decrypted content.

The below example illustrates the use of crypto.privateDecrypt() method in Node.js:

Example 1:

javascript

// Node.js program to demonstrate the 
// crypto.privateDecrypt() method
 
// Including the crypto and fs modules
const crypto = require('crypto');
const fs = require('fs');
 
// Reading the Public Key
pubK = fs.readFileSync('pub.key').toString();
 
// Passing the text to be encrypted using private key
const buf = Buffer.from('This is secret code', 'utf8');
 
// Encrypting the text
secretData = crypto.publicEncrypt(pubK, buf);
 
// Printing the encrypted text
console.log(secretData);
 
// Reading the Private key
privK = fs.readFileSync('priv.key').toString();
 
// Decrypting the text using public key
origData = crypto.privateDecrypt(privK, secretData);
console.log();
 
// Printing the original content
console.log(origData);

Output:

<Buffer 58 dd 76 8f cb 25 52 2b e7 3a b2 1b
0f 43 aa e0 df 65 fa 1d 3b 31 6f b7 f9 47 06
d5 f7 72 19 cd 2f 67 66 27 00 bb 43 8e 64 38
07 38 28 aa07 59 b4 60 ... >

<Buffer 54 68 69 73 20 69 73 20 73 65 63 72
65 74 20 63 6f 64 65 >

Example 2:

javascript

// Node.js program to demonstrate the
// crypto.privateDecrypt() method
 
// Including crypto and fs module
const crypto = require('crypto');
const fs = require("fs");
 
// Using a function generateKeyFiles
function generateKeyFiles() {
 
    const keyPair = crypto.generateKeyPairSync('rsa', {
        modulusLength: 530,
        publicKeyEncoding: {
            type: 'spki',
            format: 'pem'
        },
        privateKeyEncoding: {
            type: 'pkcs8',
            format: 'pem',
            cipher: 'aes-256-cbc',
            passphrase: ''
        }
    });
 
    // Creating public and private key file
    fs.writeFileSync("public_key", keyPair.publicKey);
    fs.writeFileSync("private_key", keyPair.privateKey);
}
 
// Generate keys
generateKeyFiles();
 
// Creating a function to encrypt string
function encryptString(plaintext, publicKeyFile) {
    const publicKey = fs.readFileSync(publicKeyFile, "utf8");
 
    // publicEncrypt() method with its parameters
    const encrypted = crypto.publicEncrypt(
        publicKey, Buffer.from(plaintext));
 
    return encrypted.toString("base64");
}
 
// Creating a function to decrypt string
function decryptString(ciphertext, privateKeyFile) {
    const privateKey = fs.readFileSync(privateKeyFile, "utf8");
 
    // privateDecrypt() method with its parameters
    const decrypted = crypto.privateDecrypt(
        {
            key: privateKey,
            passphrase: '',
        },
        Buffer.from(ciphertext, "base64")
    );
 
    return decrypted.toString("utf8");
}
 
// Defining a text to be encrypted
const plainText = "Geeks!";
 
// Defining encrypted text
const encrypted = encryptString(plainText, "./public_key");
 
// Prints plain text
console.log("Plaintext:", plainText);
console.log();
 
// Prints buffer of encrypted content
console.log("Encrypted Text: ", encrypted);
console.log();
 
// Prints buffer of decrypted content
console.log("Decrypted Text: ",
    decryptString(encrypted, "private_key"));

Output:

Plaintext: Geeks!

Encrypted Text:  
ACks6H7InpaeGdI4w9MObyD73YB7N1V0nVsG5Jl10SNeH3no6gfgjeD4ZFsSFhCXzFkognMGbRNsg0BReVOHxRs7eQ==

Decrypted Text: Geeks!

Reference: https://nodejs.org/api/crypto.html#crypto_crypto_privatedecrypt_privatekey_buffer

Suggest improvement

Node.js crypto.createDiffieHellman(primeLength, generator) Method

Node.js crypto.createDiffieHellman(prime, primeEncoding, generator, generatorEncoding) Method

Share your thoughts in the comments