cryptography

node-cryptography

About

Simplified functions for nodejs cryptography.

Usage

Functions

cryptography.encrypt(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>
• options.callback <Function>
  • error <Error>
  • encrypted <string>

Returns a promise which is resolved with encrypted string. If a callback is passed it is called with encrypted string.

cryptography.encryptSync(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>

Synchronous encrypt(). Returns encrypted string.

cryptography.decrypt(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>
• options.callback <Function>
  • error <Error>
  • decrypted <string>

Returns a promise which is resolved with decrypted string. If a callback is passed it is called with decrypted string.

cryptography.decryptSync(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>

Synchronous decrypt(). Returns decrypted string.

cryptography.hmac(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>
• options.callback <Function>
  • error <Error>
  • hashed <string>

Returns a promise which is resolved with hashed string. If a callback is passed it is called with hashed string.

cryptography.hmacSync(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>

Synchronous hmac(). Returns hashed string.

cryptography.hash(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>
• options.callback <Function>
  • error <Error>
  • hashed <string>

Returns a promise which is resolved with hashed string. If a callback is passed it is called with hashed string.

cryptography.hashSync(options)

• options <Object> | <string>
• options.key <string>
• options.algorithm <string>
• options.encoding <string>
• options.data <string>

Synchronous hash(). Returns hashed string.

cryptography.randomBytes(options)

• options <Object> | <Number>
• options.size <Number>
• options.encoding <string>
• options.callback <Function>
  • error <Error>
  • randomBytes <string>

Returns a promise which is resolved with random bytes string. If a callback is passed it is called with random bytes string.

cryptography.randomBytesSync(options)

• options <Object> | <Number>
• options.size <Number>
• options.encoding <string>

Synchronous randomBytes(). Returns random bytes string.

Example with promise

const cryptography = require("cryptography");

// Set defaults
cryptography.defaults.key = "password";
cryptography.defaults.encryptionAlgorithm = "aes192";
cryptography.defaults.encoding = "hex";

// Use defaults
cryptography.encrypt("string to encrypt")
.then(function(encrypted)
{
    return cryptography.decrypt(encrypted);
})
.then(function(decrypted)
{
    console.log(decrypted) // outputs: "string to encrypt"
})
.catch(function(error)
{
    // An error occurred
});

// Override defaults for one call
cryptography.encrypt({
    key: "another password",
    data: "string to encrypt"
})
.then(function(encrypted)
{
    return cryptography.decrypt({
        key: "another password",
        data: encrypted
    });
})
.then(function(decrypted)
{
    console.log(decrypted) // outputs: "string to encrypt"
})
.catch(function(error)
{
    // An error occurred
});

Example with callback

const cryptography = require("cryptography");
var decryptCallback = function(error, decrypted)
{
    if(error)
    {
        // Error occurred
        return;
    }

    console.log(decrypted);
};
var encryptCallback = function(error, encrypted)
{
    if(error)
    {
        // Error occurred
        return;
    }

    cryptography.decrypt({
        data: encrypted,
        callback: decryptCallback
    });
};

cryptography.encrypt({
    data: "string to encrypt",
    callback: encryptCallback
});

Example with synchronous

const cryptography = require("cryptography");

try
{
    var encrypted = cryptography.encryptSync("string to encrypt");
    var decrypted = cryptography.decryptSync(encrypted);
}
catch(error)
{
    // Error occurred
    return;
}

console.log(decrypted);