Source: encrypt/algo/encryptor.js

  1. /**
  2.  * Copyright (C) 2015-2016 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * @author: From ndn-group-encrypt src/encryptor https://github.com/named-data/ndn-group-encrypt
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU Lesser General Public License as published by
  8.  * the Free Software Foundation, either version 3 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  19.  */
  21. /** @ignore */
  22. var Crypto = require('../../crypto.js'); /** @ignore */
  23. var Name = require('../../name.js').Name; /** @ignore */
  24. var KeyLocator = require('../../key-locator.js').KeyLocator; /** @ignore */
  25. var KeyLocatorType = require('../../key-locator.js').KeyLocatorType; /** @ignore */
  26. var TlvWireFormat = require('../../encoding/tlv-wire-format.js').TlvWireFormat; /** @ignore */
  27. var Blob = require('../../util/blob.js').Blob; /** @ignore */
  28. var AesAlgorithm = require('./aes-algorithm.js').AesAlgorithm; /** @ignore */
  29. var RsaAlgorithm = require('./rsa-algorithm.js').RsaAlgorithm; /** @ignore */
  30. var EncryptParams = require('./encrypt-params.js').EncryptParams; /** @ignore */
  31. var EncryptAlgorithmType = require('./encrypt-params.js').EncryptAlgorithmType; /** @ignore */
  32. var EncryptedContent = require('../encrypted-content.js').EncryptedContent; /** @ignore */
  33. var SyncPromise = require('../../util/sync-promise.js').SyncPromise;
  35. /**
  36.  * Encryptor has static constants and utility methods for encryption, such as
  37.  * encryptData.
  38.  * @constructor
  39.  */
  40. var Encryptor = function Encryptor(value)
  41. {
  42. };
  44. exports.Encryptor = Encryptor;
  46. Encryptor.NAME_COMPONENT_FOR = new Name.Component("FOR");
  47. Encryptor.NAME_COMPONENT_READ = new Name.Component("READ");
  48. Encryptor.NAME_COMPONENT_SAMPLE = new Name.Component("SAMPLE");
  49. Encryptor.NAME_COMPONENT_ACCESS = new Name.Component("ACCESS");
  50. Encryptor.NAME_COMPONENT_E_KEY = new Name.Component("E-KEY");
  51. Encryptor.NAME_COMPONENT_D_KEY = new Name.Component("D-KEY");
  52. Encryptor.NAME_COMPONENT_C_KEY = new Name.Component("C-KEY");
  54. /**
  55.  * Prepare an encrypted data packet by encrypting the payload using the key
  56.  * according to the params. In addition, this prepares the encoded
  57.  * EncryptedContent with the encryption result using keyName and params. The
  58.  * encoding is set as the content of the data packet. If params defines an
  59.  * asymmetric encryption algorithm and the payload is larger than the maximum
  60.  * plaintext size, this encrypts the payload with a symmetric key that is
  61.  * asymmetrically encrypted and provided as a nonce in the content of the data
  62.  * packet. The packet's /<dataName>/ is updated to be <dataName>/FOR/<keyName>.
  63.  * @param {Data} data The data packet which is updated.
  64.  * @param {Blob} payload The payload to encrypt.
  65.  * @param {Name} keyName The key name for the EncryptedContent.
  66.  * @param {Blob} key The encryption key value.
  67.  * @param {EncryptParams} params The parameters for encryption.
  68.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  69.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  70.  * an async Promise.
  71.  * @return {Promise|SyncPromise} A promise which fulfills when the data packet
  72.  * is updated.
  73.  */
  74. Encryptor.encryptDataPromise = function
  75.   (data, payload, keyName, key, params, useSync)
  76. {
  77.   var dataName = data.getName();
  78.   dataName.append(Encryptor.NAME_COMPONENT_FOR).append(keyName);
  79.   data.setName(dataName);
  81.   var algorithmType = params.getAlgorithmType();
  83.   if (algorithmType == EncryptAlgorithmType.AesCbc ||
  84.       algorithmType == EncryptAlgorithmType.AesEcb) {
  85.     return Encryptor.encryptSymmetricPromise_
  86.       (payload, key, keyName, params, useSync)
  87.     .then(function(content) {
  88.       data.setContent(content.wireEncode(TlvWireFormat.get()));
  89.       return SyncPromise.resolve();
  90.     });
  91.   }
  92.   else if (algorithmType == EncryptAlgorithmType.RsaPkcs ||
  93.            algorithmType == EncryptAlgorithmType.RsaOaep) {
  94.     // Node.js doesn't have a direct way to get the maximum plain text size, so
  95.     // try to encrypt the payload first and catch the error if it is too big.
  96.     return Encryptor.encryptAsymmetricPromise_
  97.       (payload, key, keyName, params, useSync)
  98.     .then(function(content) {
  99.       data.setContent(content.wireEncode(TlvWireFormat.get()));
  100.       return SyncPromise.resolve();
  101.     }, function(err) {
  102.       if (err.message.indexOf("data too large for key size") < 0)
  103.         // Not the expected error.
  104.         throw err;
  106.       // The payload is larger than the maximum plaintext size.
  107.       // 128-bit nonce.
  108.       var nonceKeyBuffer = Crypto.randomBytes(16);
  109.       var nonceKey = new Blob(nonceKeyBuffer, false);
  111.       var nonceKeyName = new Name(keyName);
  112.       nonceKeyName.append("nonce");
  114.       var symmetricParams = new EncryptParams
  115.         (EncryptAlgorithmType.AesCbc, AesAlgorithm.BLOCK_SIZE);
  117.       var nonceContent;
  118.       return Encryptor.encryptSymmetricPromise_
  119.         (payload, nonceKey, nonceKeyName, symmetricParams, useSync)
  120.       .then(function(localNonceContent) {
  121.         nonceContent = localNonceContent;
  122.         return Encryptor.encryptAsymmetricPromise_
  123.           (nonceKey, key, keyName, params, useSync);
  124.       })
  125.       .then(function(payloadContent) {
  126.         var nonceContentEncoding = nonceContent.wireEncode();
  127.         var payloadContentEncoding = payloadContent.wireEncode();
  128.         var content = new Buffer
  129.           (nonceContentEncoding.size() + payloadContentEncoding.size());
  130.         payloadContentEncoding.buf().copy(content, 0);
  131.         nonceContentEncoding.buf().copy(content, payloadContentEncoding.size());
  133.         data.setContent(new Blob(content, false));
  134.         return SyncPromise.resolve();
  135.       });
  136.     });
  137.   }
  138.   else
  139.     return SyncPromise.reject(new Error("Unsupported encryption method"));
  140. };
  142. /**
  143.  * Prepare an encrypted data packet by encrypting the payload using the key
  144.  * according to the params. In addition, this prepares the encoded
  145.  * EncryptedContent with the encryption result using keyName and params. The
  146.  * encoding is set as the content of the data packet. If params defines an
  147.  * asymmetric encryption algorithm and the payload is larger than the maximum
  148.  * plaintext size, this encrypts the payload with a symmetric key that is
  149.  * asymmetrically encrypted and provided as a nonce in the content of the data
  150.  * packet.
  151.  * @param {Data} data The data packet which is updated.
  152.  * @param {Blob} payload The payload to encrypt.
  153.  * @param {Name} keyName The key name for the EncryptedContent.
  154.  * @param {Blob} key The encryption key value.
  155.  * @param {EncryptParams} params The parameters for encryption.
  156.  * @throws Error If encryptPromise doesn't return a SyncPromise which is
  157.  * already fulfilled.
  158.  */
  159. Encryptor.encryptData = function(data, payload, keyName, key, params)
  160. {
  161.   return SyncPromise.getValue(Encryptor.encryptDataPromise
  162.     (data, payload, keyName, key, params, true));
  163. };
  165. /**
  166.  * Encrypt the payload using the symmetric key according to params, and return
  167.  * an EncryptedContent.
  168.  * @param {Blob} payload The data to encrypt.
  169.  * @param {Blob} key The key value.
  170.  * @param {Name} keyName The key name for the EncryptedContent key locator.
  171.  * @param {EncryptParams} params The parameters for encryption.
  172.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  173.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  174.  * an async Promise.
  175.  * @return {Promise|SyncPromise} A promise which returns a new EncryptedContent.
  176.  */
  177. Encryptor.encryptSymmetricPromise_ = function
  178.   (payload, key, keyName, params, useSync)
  179. {
  180.   var algorithmType = params.getAlgorithmType();
  181.   var initialVector = params.getInitialVector();
  182.   var keyLocator = new KeyLocator();
  183.   keyLocator.setType(KeyLocatorType.KEYNAME);
  184.   keyLocator.setKeyName(keyName);
  186.   if (algorithmType == EncryptAlgorithmType.AesCbc ||
  187.       algorithmType == EncryptAlgorithmType.AesEcb) {
  188.     if (algorithmType == EncryptAlgorithmType.AesCbc) {
  189.       if (initialVector.size() != AesAlgorithm.BLOCK_SIZE)
  190.         return SyncPromise.reject(new Error("incorrect initial vector size"));
  191.     }
  193.     return AesAlgorithm.encryptPromise(key, payload, params, useSync)
  194.     .then(function(encryptedPayload) {
  195.       var result = new EncryptedContent();
  196.       result.setAlgorithmType(algorithmType);
  197.       result.setKeyLocator(keyLocator);
  198.       result.setPayload(encryptedPayload);
  199.       result.setInitialVector(initialVector);
  200.       return SyncPromise.resolve(result);
  201.     });
  202.   }
  203.   else
  204.     return SyncPromise.reject(new Error("Unsupported encryption method"));
  205. };
  207. /**
  208.  * Encrypt the payload using the asymmetric key according to params, and
  209.  * return an EncryptedContent.
  210.  * @param {Blob} payload The data to encrypt. The size should be within range of
  211.  * the key.
  212.  * @param {Blob} key The key value.
  213.  * @param {Name} keyName The key name for the EncryptedContent key locator.
  214.  * @param {EncryptParams} params The parameters for encryption.
  215.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  216.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  217.  * an async Promise.
  218.  * @return {Promise|SyncPromise} A promise which returns a new EncryptedContent.
  219.  */
  220. Encryptor.encryptAsymmetricPromise_ = function
  221.   (payload, key, keyName, params, useSync)
  222. {
  223.   var algorithmType = params.getAlgorithmType();
  224.   var keyLocator = new KeyLocator();
  225.   keyLocator.setType(KeyLocatorType.KEYNAME);
  226.   keyLocator.setKeyName(keyName);
  228.   if (algorithmType == EncryptAlgorithmType.RsaPkcs ||
  229.       algorithmType == EncryptAlgorithmType.RsaOaep) {
  230.     return RsaAlgorithm.encryptPromise(key, payload, params, useSync)
  231.     .then(function(encryptedPayload) {
  232.       var result = new EncryptedContent();
  233.       result.setAlgorithmType(algorithmType);
  234.       result.setKeyLocator(keyLocator);
  235.       result.setPayload(encryptedPayload);
  236.       return SyncPromise.resolve(result);
  237.     });
  238.   }
  239.   else
  240.     return SyncPromise.reject(new Error("Unsupported encryption method"));
  241. };