/**
* Copyright (C) 2015-2016 Regents of the University of California.
* @author: Jeff Thompson <jefft0@remap.ucla.edu>
* @author: From ndn-group-encrypt src/encrypted-content https://github.com/named-data/ndn-group-encrypt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
* A copy of the GNU Lesser General Public License is in the file COPYING.
*/
/** @ignore */
var KeyLocator = require('../key-locator.js').KeyLocator; /** @ignore */
var WireFormat = require('../encoding/wire-format.js').WireFormat; /** @ignore */
var Blob = require('../util/blob.js').Blob;
/**
* An EncryptedContent holds an encryption type, a payload and other fields
* representing encrypted content.
* @param {EncryptedContent} (optional) If value is another EncryptedContent
* then copy it. If value is omitted then create an EncryptedContent with
* unspecified values.
* @note This class is an experimental feature. The API may change.
* @constructor
*/
var EncryptedContent = function EncryptedContent(value)
{
if (typeof value === 'object' && value instanceof EncryptedContent) {
// Make a deep copy.
this.algorithmType_ = value.algorithmType_;
this.keyLocator_ = new KeyLocator(value.keyLocator_);
this.initialVector_ = value.initialVector_;
this.payload_ = value.payload_;
}
else {
this.algorithmType_ = null;
this.keyLocator_ = new KeyLocator();
this.initialVector_ = new Blob();
this.payload_ = new Blob();
}
};
exports.EncryptedContent = EncryptedContent;
/**
* Get the algorithm type from EncryptAlgorithmType.
* @returns {number} The algorithm type from EncryptAlgorithmType, or null if
* not specified.
*/
EncryptedContent.prototype.getAlgorithmType = function()
{
return this.algorithmType_;
};
/**
* Get the key locator.
* @returns {KeyLocator} The key locator. If not specified, getType() is null.
*/
EncryptedContent.prototype.getKeyLocator = function()
{
return this.keyLocator_;
};
/**
* Get the initial vector.
* @returns {Blob} The initial vector. If not specified, isNull() is true.
*/
EncryptedContent.prototype.getInitialVector = function()
{
return this.initialVector_;
};
/**
* Get the payload.
* @returns {Blob} The payload. If not specified, isNull() is true.
*/
EncryptedContent.prototype.getPayload = function()
{
return this.payload_;
};
/**
* Set the algorithm type.
* @param {number} algorithmType The algorithm type from EncryptAlgorithmType.
* If not specified, set to null.
* @returns {EncryptedContent} This EncryptedContent so that you can chain calls
* to update values.
*/
EncryptedContent.prototype.setAlgorithmType = function(algorithmType)
{
this.algorithmType_ = algorithmType;
return this;
};
/**
* Set the key locator.
* @param {KeyLocator} keyLocator The key locator. This makes a copy of the
* object. If not specified, set to the default KeyLocator().
* @returns {EncryptedContent} This EncryptedContent so that you can chain calls
* to update values.
*/
EncryptedContent.prototype.setKeyLocator = function(keyLocator)
{
this.keyLocator_ = typeof keyLocator === 'object' &&
keyLocator instanceof KeyLocator ?
new KeyLocator(keyLocator) : new KeyLocator();
return this;
};
/**
* Set the initial vector.
* @param {Blob} initialVector The initial vector. If not specified, set to the
* default Blob() where isNull() is true.
* @returns {EncryptedContent} This EncryptedContent so that you can chain calls
* to update values.
*/
EncryptedContent.prototype.setInitialVector = function(initialVector)
{
this.initialVector_ =
typeof initialVector === 'object' && initialVector instanceof Blob ?
initialVector : new Blob(initialVector);
return this;
};
/**
* Set the encrypted payload.
* @param {Blob} payload The payload. If not specified, set to the default Blob()
* where isNull() is true.
* @returns {EncryptedContent} This EncryptedContent so that you can chain calls
* to update values.
*/
EncryptedContent.prototype.setPayload = function(payload)
{
this.payload_ = typeof payload === 'object' && payload instanceof Blob ?
payload : new Blob(payload);
return this;
};
/**
* Encode this EncryptedContent for a particular wire format.
* @param {WireFormat} wireFormat (optional) A WireFormat object used to encode
* this object. If omitted, use WireFormat.getDefaultWireFormat().
* @returns {Blob} The encoded buffer in a Blob object.
*/
EncryptedContent.prototype.wireEncode = function(wireFormat)
{
wireFormat = (wireFormat || WireFormat.getDefaultWireFormat());
return wireFormat.encodeEncryptedContent(this);
};
/**
* Decode the input using a particular wire format and update this
* EncryptedContent.
* @param {Blob|Buffer} input The buffer with the bytes to decode.
* @param {WireFormat} wireFormat (optional) A WireFormat object used to decode
* this object. If omitted, use WireFormat.getDefaultWireFormat().
*/
EncryptedContent.prototype.wireDecode = function(input, wireFormat)
{
wireFormat = (wireFormat || WireFormat.getDefaultWireFormat());
// If input is a blob, get its buf().
var decodeBuffer = typeof input === 'object' && input instanceof Blob ?
input.buf() : input;
wireFormat.decodeEncryptedContent(this, decodeBuffer);
};