Node.js keyObject.type Class

In NodeJS, the KeyObject class represents algorithm-specific keys and contains built-in functions or methods for working with cryptographic key instances.

KeyObject.from(key): It is a static method of the KeyObject class that creates a KeyObject instance from a given key. Used to generate a key object from a cryptographic key or key pair.

Syntax: The syntax for converting a cryptographic key instance to a key object from is:

keyObject.from( key )

• key: symmetric or asymmetric key
• keyObject.type: keyObject.type returns 'secret' for symmetric keys, 'private' for private keys, and 'public' for public keys.

Step 1: Run the following command in your terminal to set up your Node.js project package.json:

npm init

Step 2: Create an app.js file that describes the code.

Step 3: Now import the required classes or packages from the crypto module NodeJS. 

Step 4: The Subtle.generateKey() method returns a cryptographic key (either a symmetric key or an asymmetric key pair).

Syntax: The following is the syntax for subtle.generateKey() method:

const key = generateKey(algorithm : Object , extractable : boolean , keyUsages : array);

Parameters:

• Algorithm: An object specifies the kind of key we want to generate as well as further algorithmic details.
• Extractable: A boolean variable that represents whether or not the key may be exported by specific techniques such as SubtleCrypto.exportKey (). The key cannot be exported if true.
• Keyusages: An array that lists the steps that must be taken in order to use the created key. 

These are the potential values:

Returns: An object contains the result value along with some additional information.

Step 5: Use the KeyObject.from(key) method and pass the generated cryptographic key value to this method to generate the keyObject.

Example 1: In this example, we will generate an encryption key using the "AES-CBS" algorithm, convert this encryption key to a keyObject, and check the type of this keyObject.

App.js

//Importing the crypto module
const {
    webcrypto: { subtle }, KeyObject
} = require('node:crypto');

// Generating the crypto key that is
// not a keyObject.
(async function () {
    const k = await subtle.generateKey({
        // algorithm name
        name: 'AES-CBC',
        // length of key in bits.
        length: 192,
    },
        // not exportable.
        false,
        // key can be used in encryption and decryption.
        ['encrypt', 'decrypt']);

    // Converting cryptographic key into keyObject.
    const key_obj = KeyObject.from(k);

    // printing the type of keyObject.
    console.log(key_obj.type)

})();

Output: 

secret

Example 2: In this example, we will be generating Crypto key pairs of the public and private keys using the RSASSA-PKCS1-V1_5 Algorithm and for each crypto key - public and private running keyObject.type method.

//Importing the crypto module
const { Console } = require('node:console');
const {
    webcrypto: { subtle }, KeyObject
} = require('node:crypto');


// async function
(async function () {

    // generating the crypto key 
    // RSA Algorithm
    const k = await subtle.generateKey(
        {
            // Algorithm name.
            name: "RSASSA-PKCS1-v1_5",
            // Length of RSA modulus in bits (number of bits).       
            modulusLength: 4096,
            // Uint8Array -  consists of 8-bit unsigned integers.
            publicExponent: new Uint8Array([4, 5, 2]),
            // digital hash function
            hash: "SHA-256"

        }
        // Key is not exportable.
        , false,
        // Key can be used for generating and verifying 
        // the digital signature.
        ['sign', 'verify']
    );


    // Generating keyObject for private Key
    const private_key_object = KeyObject.from(k.privateKey);

    // printing the type of private KeyObject
    console.log(private_key_object.type);

    // Generating keyObject for public Key
    const public_key_object = KeyObject.from(k.publicKey);

    // printing the type of public KeyObject
    console.log(public_key_object.type);

})();

Output:

private
public