/**
|
* Cipher base API.
|
*
|
* @author Dave Longley
|
*
|
* Copyright (c) 2010-2014 Digital Bazaar, Inc.
|
*/
|
var forge = require('./forge');
|
require('./util');
|
|
module.exports = forge.cipher = forge.cipher || {};
|
|
// registered algorithms
|
forge.cipher.algorithms = forge.cipher.algorithms || {};
|
|
/**
|
* Creates a cipher object that can be used to encrypt data using the given
|
* algorithm and key. The algorithm may be provided as a string value for a
|
* previously registered algorithm or it may be given as a cipher algorithm
|
* API object.
|
*
|
* @param algorithm the algorithm to use, either a string or an algorithm API
|
* object.
|
* @param key the key to use, as a binary-encoded string of bytes or a
|
* byte buffer.
|
*
|
* @return the cipher.
|
*/
|
forge.cipher.createCipher = function(algorithm, key) {
|
var api = algorithm;
|
if(typeof api === 'string') {
|
api = forge.cipher.getAlgorithm(api);
|
if(api) {
|
api = api();
|
}
|
}
|
if(!api) {
|
throw new Error('Unsupported algorithm: ' + algorithm);
|
}
|
|
// assume block cipher
|
return new forge.cipher.BlockCipher({
|
algorithm: api,
|
key: key,
|
decrypt: false
|
});
|
};
|
|
/**
|
* Creates a decipher object that can be used to decrypt data using the given
|
* algorithm and key. The algorithm may be provided as a string value for a
|
* previously registered algorithm or it may be given as a cipher algorithm
|
* API object.
|
*
|
* @param algorithm the algorithm to use, either a string or an algorithm API
|
* object.
|
* @param key the key to use, as a binary-encoded string of bytes or a
|
* byte buffer.
|
*
|
* @return the cipher.
|
*/
|
forge.cipher.createDecipher = function(algorithm, key) {
|
var api = algorithm;
|
if(typeof api === 'string') {
|
api = forge.cipher.getAlgorithm(api);
|
if(api) {
|
api = api();
|
}
|
}
|
if(!api) {
|
throw new Error('Unsupported algorithm: ' + algorithm);
|
}
|
|
// assume block cipher
|
return new forge.cipher.BlockCipher({
|
algorithm: api,
|
key: key,
|
decrypt: true
|
});
|
};
|
|
/**
|
* Registers an algorithm by name. If the name was already registered, the
|
* algorithm API object will be overwritten.
|
*
|
* @param name the name of the algorithm.
|
* @param algorithm the algorithm API object.
|
*/
|
forge.cipher.registerAlgorithm = function(name, algorithm) {
|
name = name.toUpperCase();
|
forge.cipher.algorithms[name] = algorithm;
|
};
|
|
/**
|
* Gets a registered algorithm by name.
|
*
|
* @param name the name of the algorithm.
|
*
|
* @return the algorithm, if found, null if not.
|
*/
|
forge.cipher.getAlgorithm = function(name) {
|
name = name.toUpperCase();
|
if(name in forge.cipher.algorithms) {
|
return forge.cipher.algorithms[name];
|
}
|
return null;
|
};
|
|
var BlockCipher = forge.cipher.BlockCipher = function(options) {
|
this.algorithm = options.algorithm;
|
this.mode = this.algorithm.mode;
|
this.blockSize = this.mode.blockSize;
|
this._finish = false;
|
this._input = null;
|
this.output = null;
|
this._op = options.decrypt ? this.mode.decrypt : this.mode.encrypt;
|
this._decrypt = options.decrypt;
|
this.algorithm.initialize(options);
|
};
|
|
/**
|
* Starts or restarts the encryption or decryption process, whichever
|
* was previously configured.
|
*
|
* For non-GCM mode, the IV may be a binary-encoded string of bytes, an array
|
* of bytes, a byte buffer, or an array of 32-bit integers. If the IV is in
|
* bytes, then it must be Nb (16) bytes in length. If the IV is given in as
|
* 32-bit integers, then it must be 4 integers long.
|
*
|
* Note: an IV is not required or used in ECB mode.
|
*
|
* For GCM-mode, the IV must be given as a binary-encoded string of bytes or
|
* a byte buffer. The number of bytes should be 12 (96 bits) as recommended
|
* by NIST SP-800-38D but another length may be given.
|
*
|
* @param options the options to use:
|
* iv the initialization vector to use as a binary-encoded string of
|
* bytes, null to reuse the last ciphered block from a previous
|
* update() (this "residue" method is for legacy support only).
|
* additionalData additional authentication data as a binary-encoded
|
* string of bytes, for 'GCM' mode, (default: none).
|
* tagLength desired length of authentication tag, in bits, for
|
* 'GCM' mode (0-128, default: 128).
|
* tag the authentication tag to check if decrypting, as a
|
* binary-encoded string of bytes.
|
* output the output the buffer to write to, null to create one.
|
*/
|
BlockCipher.prototype.start = function(options) {
|
options = options || {};
|
var opts = {};
|
for(var key in options) {
|
opts[key] = options[key];
|
}
|
opts.decrypt = this._decrypt;
|
this._finish = false;
|
this._input = forge.util.createBuffer();
|
this.output = options.output || forge.util.createBuffer();
|
this.mode.start(opts);
|
};
|
|
/**
|
* Updates the next block according to the cipher mode.
|
*
|
* @param input the buffer to read from.
|
*/
|
BlockCipher.prototype.update = function(input) {
|
if(input) {
|
// input given, so empty it into the input buffer
|
this._input.putBuffer(input);
|
}
|
|
// do cipher operation until it needs more input and not finished
|
while(!this._op.call(this.mode, this._input, this.output, this._finish) &&
|
!this._finish) {}
|
|
// free consumed memory from input buffer
|
this._input.compact();
|
};
|
|
/**
|
* Finishes encrypting or decrypting.
|
*
|
* @param pad a padding function to use in CBC mode, null for default,
|
* signature(blockSize, buffer, decrypt).
|
*
|
* @return true if successful, false on error.
|
*/
|
BlockCipher.prototype.finish = function(pad) {
|
// backwards-compatibility w/deprecated padding API
|
// Note: will overwrite padding functions even after another start() call
|
if(pad && (this.mode.name === 'ECB' || this.mode.name === 'CBC')) {
|
this.mode.pad = function(input) {
|
return pad(this.blockSize, input, false);
|
};
|
this.mode.unpad = function(output) {
|
return pad(this.blockSize, output, true);
|
};
|
}
|
|
// build options for padding and afterFinish functions
|
var options = {};
|
options.decrypt = this._decrypt;
|
|
// get # of bytes that won't fill a block
|
options.overflow = this._input.length() % this.blockSize;
|
|
if(!this._decrypt && this.mode.pad) {
|
if(!this.mode.pad(this._input, options)) {
|
return false;
|
}
|
}
|
|
// do final update
|
this._finish = true;
|
this.update();
|
|
if(this._decrypt && this.mode.unpad) {
|
if(!this.mode.unpad(this.output, options)) {
|
return false;
|
}
|
}
|
|
if(this.mode.afterFinish) {
|
if(!this.mode.afterFinish(this.output, options)) {
|
return false;
|
}
|
}
|
|
return true;
|
};
|
