cryptix

Classes

AsimetricUtils

A utility class for asymmetric encryption using RSA. Provides functions for generating, storing, retrieving, encrypting, and decrypting data securely.

Decryptor

Utility class for decrypting AES-GCM encrypted data using a password-derived key.

EncryptFile

Utility class for encrypting files using a combination of random per-file keys and a fixed secret key.

Encryptor

Provides AES-GCM encryption with PBKDF2 key derivation for strong security.

HashingUtils

Provides methods for securely hashing passwords using PBKDF2, salt, and a pepper.

KeyGenerator

Class for generating secure keys and random passwords using strong cryptography.

SecureKeys

Class for managing secure key storage, decryption, and retrieval. This class supports loading encrypted data, decrypting it, and storing it in memory for fast access.

SecurityUtils

This class provides advanced security utilities, including HMAC generation and verification, secure key generation using PBKDF2, random key and salt generation, and more.

AsimetricUtils

A utility class for asymmetric encryption using RSA. Provides functions for generating, storing, retrieving, encrypting, and decrypting data securely.

Kind: global class

• AsimetricUtils
  • .generateRSAKeyPair(keySize) ⇒ Object
  • .savePublicKey(publicKey, filePath)
  • .loadPublicKey(filePath) ⇒ crypto.KeyObject
  • .savePrivateKey(privateKey, filePath)
  • .loadPrivateKey(filePath) ⇒ crypto.KeyObject
  • .encryptWithPublicKey(data, publicKey) ⇒ Buffer
  • .decryptWithPrivateKey(encryptedData, privateKey) ⇒ string

AsimetricUtils.generateRSAKeyPair(keySize) ⇒ Object

Generates an RSA key pair (public and private keys).

Kind: static method of AsimetricUtils
Returns: Object - An object containing the keys in PEM format.
Throws:

• Error If key generation fails.

Param	Type	Description
keySize	number	The size of the RSA key in bits (recommended: 2048 or 4096).

Example

// Generate a 2048-bit RSA key pair
const keys = AsimetricUtils.generateRSAKeyPair(2048);
console.log("Public Key:\n", keys.publicKey);
console.log("Private Key:\n", keys.privateKey);

AsimetricUtils.savePublicKey(publicKey, filePath)

Saves a public key to a file.

Kind: static method of AsimetricUtils
Throws:

• Error If the file cannot be written.

Param	Type	Description
publicKey	string	The public key in PEM format.
filePath	string	The file path where the key should be saved.

Example

const keys = AsimetricUtils.generateRSAKeyPair(2048);
AsimetricUtils.savePublicKey(keys.publicKey, './public.pem');
console.log("Public key saved successfully!");

AsimetricUtils.loadPublicKey(filePath) ⇒ crypto.KeyObject

Loads a public key from a file.

Kind: static method of AsimetricUtils
Returns: crypto.KeyObject - The loaded public key.
Throws:

• Error If the file cannot be read.

Param	Type	Description
filePath	string	The path of the file containing the public key.

Example

const publicKey = AsimetricUtils.loadPublicKey('./public.pem');
console.log("Loaded Public Key:\n", publicKey);

AsimetricUtils.savePrivateKey(privateKey, filePath)

Saves a private key to a file.

Kind: static method of AsimetricUtils
Throws:

• Error If the file cannot be written.

Param	Type	Description
privateKey	string	The private key in PEM format.
filePath	string	The file path where the key should be saved.

Example

const keys = AsimetricUtils.generateRSAKeyPair(2048);
AsimetricUtils.savePrivateKey(keys.privateKey, './private.pem');
console.log("Private key saved successfully!");

AsimetricUtils.loadPrivateKey(filePath) ⇒ crypto.KeyObject

Loads a private key from a file.

Kind: static method of AsimetricUtils
Returns: crypto.KeyObject - The loaded private key.
Throws:

• Error If the file cannot be read.

Param	Type	Description
filePath	string	The path of the file containing the private key.

Example

const privateKey = AsimetricUtils.loadPrivateKey('./private.pem');
console.log("Loaded Private Key:\n", privateKey);

AsimetricUtils.encryptWithPublicKey(data, publicKey) ⇒ Buffer

Encrypts a message using a public key.

Kind: static method of AsimetricUtils
Returns: Buffer - The encrypted message.
Throws:

• Error If encryption fails.

Param	Type	Description
data	string	The plaintext message to encrypt.
publicKey	crypto.KeyObject	The public key used for encryption.

Example

const publicKey = AsimetricUtils.loadPublicKey('./public.pem');
const encrypted = AsimetricUtils.encryptWithPublicKey("Hello, World!", publicKey);
console.log("Encrypted Data:", encrypted.toString('base64'));

AsimetricUtils.decryptWithPrivateKey(encryptedData, privateKey) ⇒ string

Decrypts a message using a private key.

Kind: static method of AsimetricUtils
Returns: string - The decrypted message.
Throws:

• Error If decryption fails.

Param	Type	Description
encryptedData	Buffer	The encrypted data.
privateKey	crypto.KeyObject	The private key used for decryption.

Example

const privateKey = AsimetricUtils.loadPrivateKey('./private.pem');
const decrypted = AsimetricUtils.decryptWithPrivateKey(encryptedData, privateKey);
console.log("Decrypted Message:", decrypted);

Decryptor

Utility class for decrypting AES-GCM encrypted data using a password-derived key.

Kind: global class

• Decryptor
  • .ITERATIONS
  • .SALT_LENGTH
  • .KEY_LENGTH
  • .IV_LENGTH
  • .AUTH_TAG_LENGTH
  • .decrypt(encryptedText, password) ⇒ string | undefined

Decryptor.ITERATIONS

Number of PBKDF2 iterations for key derivation (higher = more secure but slower).

Kind: static property of Decryptor

Decryptor.SALT_LENGTH

Salt length in bytes (16 bytes = 128 bits, recommended for security).

Kind: static property of Decryptor

Decryptor.KEY_LENGTH

Key length in bytes (32 bytes = 256 bits, AES-256).

Kind: static property of Decryptor

Decryptor.IV_LENGTH

Initialization Vector (IV) length in bytes (12 bytes is recommended for AES-GCM).

Kind: static property of Decryptor

Decryptor.AUTH_TAG_LENGTH

Authentication Tag length in bytes (16 bytes ensures message integrity).

Kind: static property of Decryptor

Decryptor.decrypt(encryptedText, password) ⇒ string | undefined

Decrypts an AES-GCM encrypted message using a password.

Kind: static method of Decryptor
Returns: string | undefined - - The decrypted plaintext string, or undefined if decryption fails.
Throws:

• Error If decryption fails.

Param	Type	Description
encryptedText	string	The Base64-encoded encrypted string (contains salt + IV + cipherText + authTag).
password	string	The password used to derive the decryption key.

Example

const decrypted = Decryptor.decrypt(encryptedData, "my_secure_password");
console.log("Decrypted Text:", decrypted);

EncryptFile

Utility class for encrypting files using a combination of random per-file keys and a fixed secret key.

Kind: global class

EncryptFile.encryptFile(inputDecPath, outputEncPath)

Encrypts a plaintext file and saves it to a new location with obfuscation techniques applied.

Kind: static method of EncryptFile
Throws:

• Error If file operations fail or encryption encounters an error.

Param	Type	Description
inputDecPath	string	Path to the plaintext input file.
outputEncPath	string	Path where the encrypted file will be saved.

Example

EncryptFile.encryptFile("data.txt", "data.enc");

Encryptor

Provides AES-GCM encryption with PBKDF2 key derivation for strong security.

Kind: global class

• Encryptor
  • .ITERATIONS
  • .SALT_LENGTH
  • .KEY_LENGTH
  • .IV_LENGTH
  • .AUTH_TAG_LENGTH
  • .encrypt(plainText, password) ⇒ string

Encryptor.ITERATIONS

Number of iterations for PBKDF2 (increases brute-force resistance). Higher values = more security but slower processing.

Kind: static property of Encryptor

Encryptor.SALT_LENGTH

Length of the salt in bytes (16 bytes = 128 bits). Salt ensures each encryption is unique, even with the same password.

Kind: static property of Encryptor

Encryptor.KEY_LENGTH

AES-256 key length in bytes (32 bytes = 256 bits). AES-256 requires a 32-byte key for maximum security.

Kind: static property of Encryptor

Encryptor.IV_LENGTH

IV (Initialization Vector) length in bytes (12 bytes = recommended for GCM mode). IV ensures non-repeating ciphertext for the same input.

Kind: static property of Encryptor

Encryptor.AUTH_TAG_LENGTH

Authentication Tag length in bytes (16 bytes = 128 bits). Ensures the integrity of the ciphertext and prevents tampering.

Kind: static property of Encryptor

Encryptor.encrypt(plainText, password) ⇒ string

Encrypts a plaintext string using AES-256-GCM with a password-derived key.

Kind: static method of Encryptor
Returns: string - - The encrypted text, encoded in Base64 (salt + IV + cipherText + authTag).
Throws:

• Error - If encryption fails.

Param	Type	Description
plainText	string	The text to be encrypted.
password	string	The password used to derive the encryption key.

Example

const encrypted = Encryptor.encrypt("Hello, world!", "my_secure_password");
console.log(encrypted); // Encrypted text in Base64 format

HashingUtils

Provides methods for securely hashing passwords using PBKDF2, salt, and a pepper.

Kind: global class

• HashingUtils
  • .generateSecureHashSHA512(input) ⇒ string
  • .generateSecureHashSHA256(input) ⇒ string
  • .verifyHashSHA512(input, storedHash) ⇒ boolean
  • .verifyHashSHA256(input, storedHash) ⇒ boolean
  • .generateSecureHash(input, algorithm) ⇒ string
  • .verifyHash(input, storedHash, algorithm) ⇒ boolean
  • .deriveKey(input, salt, algorithm) ⇒ Buffer
  • .generateSalt() ⇒ Buffer

HashingUtils.generateSecureHashSHA512(input) ⇒ string

Generates a secure SHA-512 hash using PBKDF2, a random salt, and a secret pepper.

Kind: static method of HashingUtils
Returns: string - The Base64 encoded hash (salt$hash format).

Param	Type	Description
input	string	The plain text to hash.

HashingUtils.generateSecureHashSHA256(input) ⇒ string

Generates a secure SHA-256 hash using PBKDF2, a random salt, and a secret pepper.

Kind: static method of HashingUtils
Returns: string - The Base64 encoded hash (salt$hash format).

Param	Type	Description
input	string	The plain text to hash.

HashingUtils.verifyHashSHA512(input, storedHash) ⇒ boolean

Verifies if a SHA-512 hash matches the plain text.

Kind: static method of HashingUtils
Returns: boolean - true if the hash matches, false otherwise.

Param	Type	Description
input	string	The plain text to check.
storedHash	string	The stored hash (salt$hash in Base64).

HashingUtils.verifyHashSHA256(input, storedHash) ⇒ boolean

Verifies if a SHA-256 hash matches the plain text.

Kind: static method of HashingUtils
Returns: boolean - true if the hash matches, false otherwise.

Param	Type	Description
input	string	The plain text to check.
storedHash	string	The stored hash (salt$hash in Base64).

HashingUtils.generateSecureHash(input, algorithm) ⇒ string

Generates a secure hash using PBKDF2 + Salt + Pepper.

Kind: static method of HashingUtils
Returns: string - The Base64 encoded hash (salt$hash format).

Param	Type	Description
input	string	The plain text to hash.
algorithm	"sha512" | "sha256"	The hashing algorithm to use.

HashingUtils.verifyHash(input, storedHash, algorithm) ⇒ boolean

Verifies if a hash corresponds to the plain text.

Kind: static method of HashingUtils
Returns: boolean - true if the hash matches, false otherwise.

Param	Type	Description
input	string	The plain text to check.
storedHash	string	The stored hash (salt$hash in Base64).
algorithm	"sha512" | "sha256"	The hashing algorithm used.

HashingUtils.deriveKey(input, salt, algorithm) ⇒ Buffer

Derives a key using PBKDF2 + Pepper.

Kind: static method of HashingUtils
Returns: Buffer - The derived hash.

Param	Type	Description
input	string	The plain text.
salt	Buffer	The salt used in hashing.
algorithm	"sha512" | "sha256"	The hashing algorithm used.

HashingUtils.generateSalt() ⇒ Buffer

Generates a random salt.

Kind: static method of HashingUtils
Returns: Buffer - The random salt.

KeyGenerator

Class for generating secure keys and random passwords using strong cryptography.

Kind: global class

• KeyGenerator
  • .generateKey(password, salt) ⇒ Promise.<Buffer>
  • .generateSalt() ⇒ Buffer
  • .generateSecurePassword(length) ⇒ string

KeyGenerator.generateKey(password, salt) ⇒ Promise.<Buffer>

Generates a secure AES key from a password and salt using PBKDF2 with HMAC-SHA-512.

Kind: static method of KeyGenerator
Returns: Promise.<Buffer> - A secure 256-bit (32-byte) derived key.
Throws:

• Error If an error occurs during the key generation.

Param	Type	Description
password	string	The password used to generate the key.
salt	Buffer	The random salt used in the key derivation.

KeyGenerator.generateSalt() ⇒ Buffer

Generates a random salt of fixed length.

Kind: static method of KeyGenerator
Returns: Buffer - A random 16-byte salt buffer.

KeyGenerator.generateSecurePassword(length) ⇒ string

Generates a secure random password containing alphanumeric characters and special symbols.

Kind: static method of KeyGenerator
Returns: string - A securely generated random password.
Throws:

• Error If the length is less than or equal to 0.

Param	Type	Description
length	number	The length of the generated password (minimum 1).

SecureKeys

Class for managing secure key storage, decryption, and retrieval. This class supports loading encrypted data, decrypting it, and storing it in memory for fast access.

Kind: global class

• SecureKeys
  • .init(encFilePath) ⇒ Promise.<void>
  • .parseDecryptedContent()
  • .decrypt(encryptedText, password) ⇒ string | undefined
  • .getKey(keyName) ⇒ any
  • .extractEncryptedKey(content) ⇒ string | null
  • .extractEncryptedData(content) ⇒ string | null

SecureKeys.init(encFilePath) ⇒ Promise.<void>

Initializes the class by loading and decrypting the content of an encrypted file.

Kind: static method of SecureKeys
Returns: Promise.<void> - Resolves when the file is loaded and decrypted successfully.
Throws:

• Error If an error occurs during file reading or decryption.

Param	Type	Description
encFilePath	string	The path to the encrypted .enc file.

SecureKeys.parseDecryptedContent()

Parses the decrypted content and stores it in a key-value map. Only processes lines that match the format: "| key -> value".

Kind: static method of SecureKeys

SecureKeys.decrypt(encryptedText, password) ⇒ string | undefined

Decrypts a given encrypted text using AES-GCM with a key derived from PBKDF2.

Kind: static method of SecureKeys
Returns: string | undefined - The decrypted text or undefined if an error occurs.
Throws:

• Error If decryption fails.

Param	Type	Description
encryptedText	string	The encrypted text in Base64.
password	string	The password used to derive the decryption key.

SecureKeys.getKey(keyName) ⇒ any

Retrieves the value associated with a key from the in-memory key-value map.

Kind: static method of SecureKeys
Returns: any - The associated value, or null if the key does not exist.

Param	Type	Description
keyName	string	The name of the key to retrieve.

SecureKeys.extractEncryptedKey(content) ⇒ string | null

Extracts the encrypted key from the encrypted file content.

Kind: static method of SecureKeys
Returns: string | null - The encrypted key in Base64 format, or null if not found.

Param	Type	Description
content	string	The content of the encrypted file.

SecureKeys.extractEncryptedData(content) ⇒ string | null

Extracts the encrypted data from the encrypted file content.

Kind: static method of SecureKeys
Returns: string | null - The encrypted data in Base64 format, or null if not found.

Param	Type	Description
content	string	The content of the encrypted file.

SecurityUtils

This class provides advanced security utilities, including HMAC generation and verification, secure key generation using PBKDF2, random key and salt generation, and more.

Kind: global class

• SecurityUtils
  • .generateHMAC(message, secretKey) ⇒ string | undefined
  • .verifyHMAC(message, secretKey, receivedHMAC) ⇒ boolean
  • .generateSecureKey(password, salt) ⇒ string | undefined
  • .generateRandomKey() ⇒ string
  • .generateSalt() ⇒ Buffer

SecurityUtils.generateHMAC(message, secretKey) ⇒ string | undefined

Generates an HMAC (Hashed Message Authentication Code) using SHA-512 with a secret key.

Kind: static method of SecurityUtils
Returns: string | undefined - The generated HMAC in Base64 format, or undefined if an error occurs.
Throws:

• Error If there is an error during HMAC generation.

Param	Type	Description
message	string	The message to authenticate.
secretKey	string	The secret key used to generate the HMAC.

SecurityUtils.verifyHMAC(message, secretKey, receivedHMAC) ⇒ boolean

Verifies if a given HMAC is valid by comparing it with the computed HMAC for the message.

Kind: static method of SecurityUtils
Returns: boolean - Returns true if the HMAC is valid, false otherwise.

Param	Type	Description
message	string	The original message.
secretKey	string	The secret key used to generate the HMAC.
receivedHMAC	string	The received HMAC to verify.

SecurityUtils.generateSecureKey(password, salt) ⇒ string | undefined

Generates a secure secret key using PBKDF2 with HMAC-SHA-512.

Kind: static method of SecurityUtils
Returns: string | undefined - A secure secret key in Base64 format, or undefined if an error occurs.
Throws:

• Error If there is an error during key generation.

Param	Type	Description
password	string	The base password to derive the key.
salt	Buffer	A random value to strengthen the key.

SecurityUtils.generateRandomKey() ⇒ string

Generates a secure random secret key.

Kind: static method of SecurityUtils
Returns: string - A random secret key in Base64 format.

SecurityUtils.generateSalt() ⇒ Buffer

Generates a secure random salt.

Kind: static method of SecurityUtils
Returns: Buffer - A random salt in bytes (256 bits).