Source: security/identity/memory-private-key-storage.js

  1. /**
  2.  * Copyright (C) 2014-2016 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * From ndn-cxx security by Yingdi Yu <yingdi@cs.ucla.edu>.
  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. // Use capitalized Crypto to not clash with the browser's crypto.subtle.
  22. /** @ignore */
  23. var Crypto = require('../../crypto.js'); /** @ignore */
  24. var Blob = require('../../util/blob.js').Blob; /** @ignore */
  25. var SecurityException = require('../security-exception.js').SecurityException; /** @ignore */
  26. var PublicKey = require('../certificate/public-key.js').PublicKey; /** @ignore */
  27. var KeyClass = require('../security-types.js').KeyClass; /** @ignore */
  28. var KeyType = require('../security-types').KeyType; /** @ignore */
  29. var DigestAlgorithm = require('../security-types.js').DigestAlgorithm; /** @ignore */
  30. var DataUtils = require('../../encoding/data-utils.js').DataUtils; /** @ignore */
  31. var PrivateKeyStorage = require('./private-key-storage.js').PrivateKeyStorage; /** @ignore */
  32. var DerNode = require('../../encoding/der/der-node.js').DerNode; /** @ignore */
  33. var OID = require('../../encoding/oid.js').OID; /** @ignore */
  34. var SyncPromise = require('../../util/sync-promise.js').SyncPromise; /** @ignore */
  35. var UseSubtleCrypto = require('../../use-subtle-crypto-node.js').UseSubtleCrypto; /** @ignore */
  36. var rsaKeygen = null;
  37. try {
  38.   // This should be installed with: sudo npm install rsa-keygen
  39.   rsaKeygen = require('rsa-keygen');
  40. }
  41. catch (e) {}
  43. /**
  44.  * MemoryPrivateKeyStorage class extends PrivateKeyStorage to implement private
  45.  * key storage in memory.
  46.  * @constructor
  47.  */
  48. var MemoryPrivateKeyStorage = function MemoryPrivateKeyStorage()
  49. {
  50.   // Call the base constructor.
  51.   PrivateKeyStorage.call(this);
  53.   // The key is the keyName.toUri(). The value is security.certificate.PublicKey.
  54.   this.publicKeyStore = {};
  55.   // The key is the keyName.toUri(). The value is the object
  56.   //  {keyType,     // number from KeyType
  57.   //   privateKey   // The PEM-encoded private key.
  58.   //  }.
  59.   this.privateKeyStore = {};
  60. };
  62. MemoryPrivateKeyStorage.prototype = new PrivateKeyStorage();
  63. MemoryPrivateKeyStorage.prototype.name = "MemoryPrivateKeyStorage";
  65. exports.MemoryPrivateKeyStorage = MemoryPrivateKeyStorage;
  67. /**
  68.  * Set the public key for the keyName.
  69.  * @param {Name} keyName The key name.
  70.  * @param {number} keyType The KeyType, such as KeyType.RSA.
  71.  * @param {Buffer} publicKeyDer The public key DER byte array.
  72.  */
  73. MemoryPrivateKeyStorage.prototype.setPublicKeyForKeyName = function
  74.   (keyName, keyType, publicKeyDer)
  75. {
  76.   this.publicKeyStore[keyName.toUri()] = new PublicKey
  77.     (new Blob(publicKeyDer, true));
  78. };
  80. /**
  81.  * Set the private key for the keyName.
  82.  * @param {Name} keyName The key name.
  83.  * @param {number} keyType The KeyType, such as KeyType.RSA.
  84.  * @param {Buffer} privateKeyDer The private key DER byte array.
  85.  */
  86. MemoryPrivateKeyStorage.prototype.setPrivateKeyForKeyName = function
  87.   (keyName, keyType, privateKeyDer)
  88. {
  89.   // Encode the DER as PEM.
  90.   var keyBase64 = privateKeyDer.toString('base64');
  91.   var keyPem = "-----BEGIN RSA PRIVATE KEY-----\n";
  92.   for (var i = 0; i < keyBase64.length; i += 64)
  93.     keyPem += (keyBase64.substr(i, 64) + "\n");
  94.   keyPem += "-----END RSA PRIVATE KEY-----";
  96.   this.privateKeyStore[keyName.toUri()] =
  97.     { keyType: keyType, privateKey: keyPem };
  98. };
  100. /**
  101.  * Set the public and private key for the keyName.
  102.  * @param {Name} keyName The key name.
  103.  * @param {number} keyType The KeyType, such as KeyType.RSA.
  104.  * @param {Buffer} publicKeyDer The public key DER byte array.
  105.  * @param {Buffer} privateKeyDer The private key DER byte array.
  106.  */
  107. MemoryPrivateKeyStorage.prototype.setKeyPairForKeyName = function
  108.   (keyName, keyType, publicKeyDer, privateKeyDer)
  109. {
  110.   this.setPublicKeyForKeyName(keyName, keyType, publicKeyDer);
  111.   this.setPrivateKeyForKeyName(keyName, keyType, privateKeyDer);
  112. };
  114. /**
  115.  * Generate a pair of asymmetric keys.
  116.  * @param {Name} keyName The name of the key pair.
  117.  * @param {KeyParams} params The parameters of the key.
  118.  * @param {boolean} useSync (optional) If true then use blocking crypto and
  119.  * return a SyncPromise which is already fulfilled. If omitted or false, if
  120.  * possible use crypto.subtle and return an async Promise, otherwise use
  121.  * blocking crypto and return a SyncPromise.
  122.  * @return {Promise|SyncPromise} A promise that fulfills when the pair is
  123.  * generated.
  124.  */
  125. MemoryPrivateKeyStorage.prototype.generateKeyPairPromise = function
  126.   (keyName, params, useSync)
  127. {
  128.   if (this.doesKeyExist(keyName, KeyClass.PUBLIC))
  129.     return SyncPromise.reject(new SecurityException(new Error
  130.       ("Public key already exists")));
  131.   if (this.doesKeyExist(keyName, KeyClass.PRIVATE))
  132.     return SyncPromise.reject(new SecurityException(new Error
  133.       ("Private key already exists")));
  135.   var thisStore = this;
  137.   if (UseSubtleCrypto() && !useSync) {
  138.     if (params.getKeyType() === KeyType.RSA) {
  139.       var privateKey = null;
  140.       var publicKeyDer = null;
  142.       return crypto.subtle.generateKey
  143.         ({ name: "RSASSA-PKCS1-v1_5", modulusLength: params.getKeySize(),
  144.            publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
  145.            hash: {name: "SHA-256"} },
  146.          true, ["sign", "verify"])
  147.       .then(function(key) {
  148.         privateKey = key.privateKey;
  150.         // Export the public key to DER.
  151.         return crypto.subtle.exportKey("spki", key.publicKey);
  152.       })
  153.       .then(function(exportedPublicKey) {
  154.         publicKeyDer = new Blob(new Uint8Array(exportedPublicKey), false).buf();
  156.         // Export the private key to DER.
  157.         return crypto.subtle.exportKey("pkcs8", privateKey);
  158.       })
  159.       .then(function(pkcs8Der) {
  160.         // Crypto.subtle exports the private key as PKCS #8. Decode it to find
  161.         // the inner private key DER.
  162.         var parsedNode = DerNode.parse
  163.           (new Blob(new Uint8Array(pkcs8Der), false).buf());
  164.         // Get the value of the 3rd child which is the octet string.
  165.         var privateKeyDer = parsedNode.getChildren()[2].toVal();
  167.         // Save the key pair.
  168.         thisStore.setKeyPairForKeyName
  169.           (keyName, params.getKeyType(), publicKeyDer, privateKeyDer.buf());
  171.         // sign will use subtleKey directly.
  172.         thisStore.privateKeyStore[keyName.toUri()].subtleKey = privateKey;
  174.         return Promise.resolve();
  175.       });
  176.     }
  177.     else
  178.       return SyncPromise.reject(new SecurityException(new Error
  179.         ("Only RSA key generation currently supported")));
  180.   }
  181.   else {
  182.     return SyncPromise.resolve()
  183.     .then(function() {
  184.       if (typeof RSAKey !== 'undefined') {
  185.         // Assume we are in the browser.
  186.         if (params.getKeyType() === KeyType.RSA) {
  187.           var rsaKey = new RSAKey();
  188.           rsaKey.generate(params.getKeySize(), '010001');
  189.           thisStore.setKeyPairForKeyName
  190.             (keyName, params.getKeyType(),
  191.              PrivateKeyStorage.encodePublicKeyFromRSAKey(rsaKey).buf(),
  192.              PrivateKeyStorage.encodePkcs1PrivateKeyFromRSAKey(rsaKey).buf());
  193.         }
  194.         else
  195.           return SyncPromise.reject(new SecurityException(new Error
  196.             ("Only RSA key generation currently supported")));
  197.       }
  198.       else {
  199.         // Assume we are in Node.js.
  200.         var publicKeyDer;
  201.         var privateKeyPem;
  203.         if (params.getKeyType() === KeyType.RSA) {
  204.           if (!rsaKeygen)
  205.             return SyncPromise.reject(new SecurityException(new Error
  206.               ("Need to install rsa-keygen: sudo npm install rsa-keygen")));
  208.           var keyPair = rsaKeygen.generate(params.getKeySize());
  210.           // Get the public key DER from the PEM string.
  211.           var publicKeyBase64 = keyPair.public_key.toString().replace
  212.             ("-----BEGIN PUBLIC KEY-----", "").replace
  213.             ("-----END PUBLIC KEY-----", "");
  214.           publicKeyDer = new Buffer(publicKeyBase64, 'base64');
  216.           privateKeyPem = keyPair.private_key.toString();
  217.         }
  218.         else
  219.           return SyncPromise.reject(new SecurityException(new Error
  220.             ("Only RSA key generation currently supported")));
  222.         thisStore.setPublicKeyForKeyName(keyName, params.getKeyType(), publicKeyDer);
  223.         thisStore.privateKeyStore[keyName.toUri()] =
  224.           { keyType: params.getKeyType(), privateKey: privateKeyPem };
  225.       }
  227.       return SyncPromise.resolve();
  228.     });
  229.   }
  230. };
  232. /**
  233.  * Delete a pair of asymmetric keys. If the key doesn't exist, do nothing.
  234.  * @param {Name} keyName The name of the key pair.
  235.  * @return {SyncPromise} A promise that fulfills when the key pair is deleted.
  236.  */
  237. MemoryPrivateKeyStorage.prototype.deleteKeyPairPromise = function(keyName)
  238. {
  239.   var keyUri = keyName.toUri();
  241.   delete this.publicKeyStore[keyUri];
  242.   delete this.privateKeyStore[keyUri];
  244.   return SyncPromise.resolve();
  245. };
  247. /**
  248.  * Get the public key
  249.  * @param {Name} keyName The name of public key.
  250.  * @return {SyncPromise} A promise that returns the PublicKey.
  251.  */
  252. MemoryPrivateKeyStorage.prototype.getPublicKeyPromise = function(keyName)
  253. {
  254.   var keyUri = keyName.toUri();
  255.   var publicKey = this.publicKeyStore[keyUri];
  256.   if (publicKey === undefined)
  257.     return SyncPromise.reject(new SecurityException(new Error
  258.       ("MemoryPrivateKeyStorage: Cannot find public key " + keyName.toUri())));
  260.   return SyncPromise.resolve(publicKey);
  261. };
  263. /**
  264.  * Fetch the private key for keyName and sign the data to produce a signature Blob.
  265.  * @param {Buffer} data Pointer to the input byte array.
  266.  * @param {Name} keyName The name of the signing key.
  267.  * @param {number} digestAlgorithm (optional) The digest algorithm from
  268.  * DigestAlgorithm, such as DigestAlgorithm.SHA256. If omitted, use
  269.  * DigestAlgorithm.SHA256.
  270.  * @param {boolean} useSync (optional) If true then use blocking crypto and
  271.  * return a SyncPromise which is already fulfilled. If omitted or false, if
  272.  * possible use crypto.subtle and return an async Promise, otherwise use
  273.  * blocking crypto and return a SyncPromise.
  274.  * @return {Promise|SyncPromise} A promise that returns the signature Blob.
  275.  */
  276. MemoryPrivateKeyStorage.prototype.signPromise = function
  277.   (data, keyName, digestAlgorithm, useSync)
  278. {
  279.   useSync = (typeof digestAlgorithm === "boolean") ? digestAlgorithm : useSync;
  280.   digestAlgorithm = (typeof digestAlgorithm === "boolean" || !digestAlgorithm) ? DigestAlgorithm.SHA256 : digestAlgorithm;
  282.   if (digestAlgorithm != DigestAlgorithm.SHA256)
  283.     return SyncPromise.reject(new SecurityException(new Error
  284.       ("MemoryPrivateKeyStorage.sign: Unsupported digest algorithm")));
  286.   // Find the private key.
  287.   var keyUri = keyName.toUri();
  288.   var privateKey = this.privateKeyStore[keyUri];
  289.   if (privateKey === undefined)
  290.     return SyncPromise.reject(new SecurityException(new Error
  291.       ("MemoryPrivateKeyStorage: Cannot find private key " + keyUri)));
  293.   if (UseSubtleCrypto() && !useSync){
  294.     var algo = {name:"RSASSA-PKCS1-v1_5",hash:{name:"SHA-256"}};
  296.     if (!privateKey.subtleKey){
  297.       //this is the first time in the session that we're using crypto subtle with this key
  298.       //so we have to convert to pkcs8 and import it.
  299.       //assigning it to privateKey.subtleKey means we only have to do this once per session,
  300.       //giving us a small, but not insignificant, performance boost.
  301.       var privateDER = DataUtils.privateKeyPemToDer(privateKey.privateKey);
  302.       var pkcs8 = PrivateKeyStorage.encodePkcs8PrivateKey
  303.         (privateDER, new OID(PrivateKeyStorage.RSA_ENCRYPTION_OID),
  304.          new DerNode.DerNull()).buf();
  306.       var promise = crypto.subtle.importKey("pkcs8", pkcs8.buffer, algo, true, ["sign"]).then(function(subtleKey){
  307.         //cache the crypto.subtle key object
  308.         privateKey.subtleKey = subtleKey;
  309.         return crypto.subtle.sign(algo, subtleKey, data);
  310.       });
  311.     } else {
  312.       // The crypto.subtle key has been cached on a previous sign or from keygen.
  313.       var promise = crypto.subtle.sign(algo, privateKey.subtleKey, data);
  314.     }
  316.     return promise.then(function(signature){
  317.       var result = new Blob(new Uint8Array(signature), true);
  318.       return Promise.resolve(result);
  319.     });
  320.   } else {
  321.     var rsa = Crypto.createSign('RSA-SHA256');
  322.     rsa.update(data);
  324.     var signature = new Buffer
  325.       (DataUtils.toNumbersIfString(rsa.sign(privateKey.privateKey)));
  326.     var result = new Blob(signature, false);
  328.     return SyncPromise.resolve(result);
  329.   }
  330. };
  332. /**
  333.  * Check if a particular key exists.
  334.  * @param {Name} keyName The name of the key.
  335.  * @param {number} keyClass The class of the key, e.g. KeyClass.PUBLIC,
  336.  * KeyClass.PRIVATE, or KeyClass.SYMMETRIC.
  337.  * @return {SyncPromise} A promise which returns true if the key exists.
  338.  */
  339. MemoryPrivateKeyStorage.prototype.doesKeyExistPromise = function
  340.   (keyName, keyClass)
  341. {
  342.   var keyUri = keyName.toUri();
  343.   var result = false;
  344.   if (keyClass == KeyClass.PUBLIC)
  345.     result = this.publicKeyStore[keyUri] !== undefined;
  346.   else if (keyClass == KeyClass.PRIVATE)
  347.     result = this.privateKeyStore[keyUri] !== undefined;
  349.   return SyncPromise.resolve(result);
  350. };