Source: encrypt/algo/aes-algorithm.js

  1. /**
  2.  * Copyright (C) 2015-2018 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * @author: From ndn-group-encrypt src/algo/aes 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. // (This is ported from ndn::gep::algo::Aes, and named AesAlgorithm because
  22. // "Aes" is very short and not all the Common Client Libraries have namespaces.)
  24. /** @ignore */
  25. var Crypto = require('../../crypto.js'); /** @ignore */
  26. var Blob = require('../../util/blob.js').Blob; /** @ignore */
  27. var DecryptKey = require('../decrypt-key.js').DecryptKey; /** @ignore */
  28. var EncryptKey = require('../encrypt-key.js').EncryptKey; /** @ignore */
  29. var EncryptAlgorithmType = require('./encrypt-params.js').EncryptAlgorithmType; /** @ignore */
  30. var UseSubtleCrypto = require('../../use-subtle-crypto-node.js').UseSubtleCrypto; /** @ignore */
  31. var SyncPromise = require('../../util/sync-promise.js').SyncPromise;
  33. /**
  34.  * The AesAlgorithm class provides static methods to manipulate keys, encrypt
  35.  * and decrypt using the AES symmetric key cipher.
  36.  * @note This class is an experimental feature. The API may change.
  37.  * @constructor
  38.  */
  39. var AesAlgorithm = function AesAlgorithm()
  40. {
  41. };
  43. exports.AesAlgorithm = AesAlgorithm;
  45. /**
  46.  * Generate a new random decrypt key for AES based on the given params.
  47.  * @param {AesKeyParams} params The key params with the key size (in bits).
  48.  * @return {DecryptKey} The new decrypt key.
  49.  */
  50. AesAlgorithm.generateKey = function(params)
  51. {
  52.   // Convert the key bit size to bytes.
  53.   var key = Crypto.randomBytes(params.getKeySize() / 8);
  55.   var decryptKey = new DecryptKey(new Blob(key, false));
  56.   return decryptKey;
  57. };
  59. /**
  60.  * Derive a new encrypt key from the given decrypt key value.
  61.  * @param {Blob} keyBits The key value of the decrypt key.
  62.  * @return {EncryptKey} The new encrypt key.
  63.  */
  64. AesAlgorithm.deriveEncryptKey = function(keyBits)
  65. {
  66.   return new EncryptKey(keyBits);
  67. };
  69. /**
  70.  * Decrypt the encryptedData using the keyBits according the encrypt params.
  71.  * @param {Blob} keyBits The key value.
  72.  * @param {Blob} encryptedData The data to decrypt.
  73.  * @param {EncryptParams} params This decrypts according to
  74.  * params.getAlgorithmType() and other params as needed such as
  75.  * params.getInitialVector().
  76.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  77.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  78.  * an async Promise.
  79.  * @return {Promise|SyncPromise} A promise which returns the decrypted Blob.
  80.  */
  81. AesAlgorithm.decryptPromise = function(keyBits, encryptedData, params, useSync)
  82. {
  83.   if (UseSubtleCrypto() && !useSync &&
  84.       // Crypto.subtle doesn't implement ECB.
  85.       params.getAlgorithmType() != EncryptAlgorithmType.AesEcb) {
  86.     if (params.getAlgorithmType() == EncryptAlgorithmType.AesCbc) {
  87.       return crypto.subtle.importKey
  88.         ("raw", keyBits.buf(), { name: "AES-CBC" }, false,
  89.          ["encrypt", "decrypt"])
  90.       .then(function(key) {
  91.         return crypto.subtle.decrypt
  92.           ({ name: "AES-CBC", iv: params.getInitialVector().buf() },
  93.            key, encryptedData.buf());
  94.       })
  95.       .then(function(result) {
  96.         return Promise.resolve(new Blob(new Uint8Array(result), false));
  97.       });
  98.     }
  99.     else
  100.       return Promise.reject(new Error("unsupported encryption mode"));
  101.   }
  102.   else {
  103.     if (params.getAlgorithmType() == EncryptAlgorithmType.AesEcb) {
  104.       try {
  105.         // ECB ignores the initial vector.
  106.         var cipher = Crypto.createDecipheriv
  107.           (keyBits.size()  == 32 ? "aes-256-ecb" : "aes-128-ecb",
  108.            keyBits.buf(), "");
  109.         return SyncPromise.resolve(new Blob
  110.           (Buffer.concat([cipher.update(encryptedData.buf()), cipher.final()]),
  111.            false));
  112.       } catch (err) {
  113.         return SyncPromise.reject(err);
  114.       }
  115.     }
  116.     else if (params.getAlgorithmType() == EncryptAlgorithmType.AesCbc) {
  117.       try {
  118.         var cipher = Crypto.createDecipheriv
  119.           (keyBits.size()  == 32 ? "aes-256-cbc" : "aes-128-cbc",
  120.            keyBits.buf(), params.getInitialVector().buf());
  121.         return SyncPromise.resolve(new Blob
  122.           (Buffer.concat([cipher.update(encryptedData.buf()), cipher.final()]),
  123.            false));
  124.       } catch (err) {
  125.         return SyncPromise.reject(err);
  126.       }
  127.     }
  128.     else
  129.       return SyncPromise.reject(new Error("unsupported encryption mode"));
  130.   }
  131. };
  133. /**
  134.  * Decrypt the encryptedData using the keyBits according the encrypt params.
  135.  * @param {Blob} keyBits The key value.
  136.  * @param {Blob} encryptedData The data to decrypt.
  137.  * @param {EncryptParams} params This decrypts according to
  138.  * params.getAlgorithmType() and other params as needed such as
  139.  * params.getInitialVector().
  140.  * @return {Blob} The decrypted data.
  141.  * @throws Error If decryptPromise doesn't return a SyncPromise which is
  142.  * already fulfilled.
  143.  */
  144. AesAlgorithm.decrypt = function(keyBits, encryptedData, params)
  145. {
  146.   return SyncPromise.getValue(this.decryptPromise
  147.     (keyBits, encryptedData, params, true));
  148. };
  150. /**
  151.  * Encrypt the plainData using the keyBits according the encrypt params.
  152.  * @param {Blob} keyBits The key value.
  153.  * @param {Blob} plainData The data to encrypt.
  154.  * @param {EncryptParams} params This encrypts according to
  155.  * params.getAlgorithmType() and other params as needed such as
  156.  * params.getInitialVector().
  157.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  158.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  159.  * an async Promise.
  160.  * @return {Promise|SyncPromise} A promise which returns the encrypted Blob.
  161.  */
  162. AesAlgorithm.encryptPromise = function(keyBits, plainData, params, useSync)
  163. {
  164.   if (params.getAlgorithmType() == EncryptAlgorithmType.AesCbc) {
  165.     if (params.getInitialVector().size() != AesAlgorithm.BLOCK_SIZE)
  166.       return SyncPromise.reject(new Error("incorrect initial vector size"));
  167.   }
  169.   if (UseSubtleCrypto() && !useSync &&
  170.       // Crypto.subtle doesn't implement ECB.
  171.       params.getAlgorithmType() != EncryptAlgorithmType.AesEcb) {
  172.     if (params.getAlgorithmType() == EncryptAlgorithmType.AesCbc) {
  173.       return crypto.subtle.importKey
  174.         ("raw", keyBits.buf(), { name: "AES-CBC" }, false,
  175.          ["encrypt", "decrypt"])
  176.       .then(function(key) {
  177.         return crypto.subtle.encrypt
  178.           ({ name: "AES-CBC", iv: params.getInitialVector().buf() },
  179.            key, plainData.buf());
  180.       })
  181.       .then(function(result) {
  182.         return Promise.resolve(new Blob(new Uint8Array(result), false));
  183.       });
  184.     }
  185.     else
  186.       return Promise.reject(new Error("unsupported encryption mode"));
  187.   }
  188.   else {
  189.     if (params.getAlgorithmType() == EncryptAlgorithmType.AesEcb) {
  190.       // ECB ignores the initial vector.
  191.       var cipher = Crypto.createCipheriv
  192.         (keyBits.size()  == 32 ? "aes-256-ecb" : "aes-128-ecb", keyBits.buf(), "");
  193.       return SyncPromise.resolve(new Blob
  194.         (Buffer.concat([cipher.update(plainData.buf()), cipher.final()]),
  195.          false));
  196.     }
  197.     else if (params.getAlgorithmType() == EncryptAlgorithmType.AesCbc) {
  198.       var cipher = Crypto.createCipheriv
  199.         (keyBits.size()  == 32 ? "aes-256-cbc" : "aes-128-cbc",
  200.          keyBits.buf(), params.getInitialVector().buf());
  201.       return SyncPromise.resolve(new Blob
  202.         (Buffer.concat([cipher.update(plainData.buf()), cipher.final()]),
  203.          false));
  204.     }
  205.     else
  206.       return SyncPromise.reject(new Error("unsupported encryption mode"));
  207.   }
  208. };
  210. /**
  211.  * Encrypt the plainData using the keyBits according the encrypt params.
  212.  * @param {Blob} keyBits The key value.
  213.  * @param {Blob} plainData The data to encrypt.
  214.  * @param {EncryptParams} params This encrypts according to
  215.  * params.getAlgorithmType() and other params as needed such as
  216.  * params.getInitialVector().
  217.  * @return {Blob} The encrypted data.
  218.  * @throws Error If encryptPromise doesn't return a SyncPromise which is
  219.  * already fulfilled.
  220.  */
  221. AesAlgorithm.encrypt = function(keyBits, plainData, params)
  222. {
  223.   return SyncPromise.getValue(this.encryptPromise
  224.     (keyBits, plainData, params, true));
  225. };
  227. AesAlgorithm.BLOCK_SIZE = 16;