Source: security/identity/basic-identity-storage.js

  1. /**
  2.  * Copyright (C) 2015-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. /** @ignore */
  22. var Name = require('../../name.js').Name; /** @ignore */
  23. var Blob = require('../../util/blob.js').Blob; /** @ignore */
  24. var Sqlite3Promise = require('../../util/sqlite3-promise.js').Sqlite3Promise; /** @ignore */
  25. var KeyLocator = require('../../key-locator.js').KeyLocator; /** @ignore */
  26. var SecurityException = require('../security-exception.js').SecurityException; /** @ignore */
  27. var IdentityCertificate = require('../certificate/identity-certificate.js').IdentityCertificate; /** @ignore */
  28. var IdentityStorage = require('./identity-storage.js').IdentityStorage; /** @ignore */
  29. var path = require('path');
  31. /**
  32.  * BasicIdentityStorage extends IdentityStorage to implement basic storage of
  33.  * identity, public keys and certificates using the Node.js sqlite3 module.
  34.  * Create a new BasicIdentityStorage to use the SQLite3 file in the default
  35.  * location, or the optional given file.
  36.  * @param {string} databaseFilePath (optional) The path of the SQLite3 file. If
  37.  * omitted, use the default file (~/.ndn/ndnsec-public-info.db).
  38.  * @constructor
  39.  */
  40. var BasicIdentityStorage = function BasicIdentityStorage(databaseFilePath)
  41. {
  42.   // Call the base constructor.
  43.   IdentityStorage.call(this);
  45.   databaseFilePath = databaseFilePath || path.join
  46.     (BasicIdentityStorage.getUserHomePath(), ".ndn", "ndnsec-public-info.db");
  47.   this.database_ = new Sqlite3Promise
  48.     (databaseFilePath, BasicIdentityStorage.initializeDatabasePromise_);
  49. };
  51. BasicIdentityStorage.prototype = new IdentityStorage();
  52. BasicIdentityStorage.prototype.name = "BasicIdentityStorage";
  54. exports.BasicIdentityStorage = BasicIdentityStorage;
  56. /**
  57.  * Check if the specified identity already exists.
  58.  * @param {Name} identityName The identity name.
  59.  * @param {boolean} useSync (optional) If true then return a rejected promise
  60.  * since this only supports async code.
  61.  * @returns {Promise} A promise which returns true if the identity exists.
  62.  */
  63. BasicIdentityStorage.prototype.doesIdentityExistPromise = function
  64.   (identityName, useSync)
  65. {
  66.   if (useSync)
  67.     return Promise.reject(new SecurityException(new Error
  68.       ("BasicIdentityStorage.doesIdentityExistPromise is only supported for async")));
  70.   return this.getPromise_
  71.     ("SELECT count(*) FROM Identity WHERE identity_name=?", identityName.toUri())
  72.   .then(function(row) {
  73.     if (row["count(*)"] > 0)
  74.       return Promise.resolve(true);
  75.     else
  76.       return Promise.resolve(false);
  77.   });
  78. };
  80. /**
  81.  * Add a new identity. Do nothing if the identity already exists.
  82.  * @param {Name} identityName The identity name to be added.
  83.  * @param {boolean} useSync (optional) If true then return a rejected promise
  84.  * since this only supports async code.
  85.  * @return {Promise} A promise which fulfills when the identity is added.
  86.  */
  87. BasicIdentityStorage.prototype.addIdentityPromise = function(identityName, useSync)
  88. {
  89.   if (useSync)
  90.     return Promise.reject(new SecurityException(new Error
  91.       ("BasicIdentityStorage.addIdentityPromise is only supported for async")));
  93.   var thisStorage = this;
  94.   var identityUri = identityName.toUri();
  95.   return this.doesIdentityExistPromise(identityName)
  96.   .then(function(exists) {
  97.     if (exists)
  98.       return Promise.resolve();
  100.     return thisStorage.runPromise_
  101.       ("INSERT INTO Identity (identity_name) VALUES(?)", identityUri);
  102.   });
  103. };
  105. /**
  106.  * Check if the specified key already exists.
  107.  * @param {Name} keyName The name of the key.
  108.  * @param {boolean} useSync (optional) If true then return a rejected promise
  109.  * since this only supports async code.
  110.  * @return {Promise} A promise which returns true if the key exists.
  111.  */
  112. BasicIdentityStorage.prototype.doesKeyExistPromise = function(keyName, useSync)
  113. {
  114.   if (useSync)
  115.     return Promise.reject(new SecurityException(new Error
  116.       ("BasicIdentityStorage.doesKeyExistPromise is only supported for async")));
  118.   var keyId = keyName.get(-1).toEscapedString();
  119.   var identityName = keyName.getPrefix(-1);
  121.   return this.getPromise_
  122.     ("SELECT count(*) FROM Key WHERE identity_name=? AND key_identifier=?",
  123.      [identityName.toUri(), keyId])
  124.   .then(function(row) {
  125.     if (row["count(*)"] > 0)
  126.       return Promise.resolve(true);
  127.     else
  128.       return Promise.resolve(false);
  129.   });
  130. };
  132. /**
  133.  * Add a public key to the identity storage. Also call addIdentity to ensure
  134.  * that the identityName for the key exists. However, if the key already
  135.    * exists, do nothing.
  136.  * @param {Name} keyName The name of the public key to be added.
  137.  * @param {number} keyType Type of the public key to be added from KeyType, such
  138.  * as KeyType.RSA..
  139.  * @param {Blob} publicKeyDer A blob of the public key DER to be added.
  140.  * @param {boolean} useSync (optional) If true then return a rejected promise
  141.  * since this only supports async code.
  142.  * @return {Promise} A promise which fulfills when complete.
  143.  */
  144. BasicIdentityStorage.prototype.addKeyPromise = function
  145.   (keyName, keyType, publicKeyDer, useSync)
  146. {
  147.   if (useSync)
  148.     return Promise.reject(new SecurityException(new Error
  149.       ("BasicIdentityStorage.addKeyPromise is only supported for async")));
  151.   if (keyName.size() === 0)
  152.     return Promise.resolve();
  154.   var thisStorage = this;
  155.   return this.doesKeyExistPromise(keyName)
  156.   .then(function(exists) {
  157.     if (exists)
  158.       return Promise.resolve();
  160.     var identityName = keyName.getPrefix(-1);
  161.     var identityUri = identityName.toUri();
  163.     return thisStorage.addIdentityPromise(identityName)
  164.     .then(function() {
  165.       var keyId = keyName.get(-1).toEscapedString();
  166.       var keyBuffer = publicKeyDer.buf();
  168.       return thisStorage.runPromise_
  169.         ("INSERT INTO Key (identity_name, key_identifier, key_type, public_key) VALUES(?,?,?,?)",
  170.          [identityUri, keyId, keyType, keyBuffer]);
  171.     });
  172.   });
  173. };
  175. /**
  176.  * Get the public key DER blob from the identity storage.
  177.  * @param {Name} keyName The name of the requested public key.
  178.  * @param {boolean} useSync (optional) If true then return a rejected promise
  179.  * since this only supports async code.
  180.  * @return {Promise} A promise which returns the DER Blob, or a promise rejected
  181.  * with SecurityException if the key doesn't exist.
  182.  */
  183. BasicIdentityStorage.prototype.getKeyPromise = function(keyName, useSync)
  184. {
  185.   if (useSync)
  186.     return Promise.reject(new SecurityException(new Error
  187.       ("BasicIdentityStorage.getKeyPromise is only supported for async")));
  189.   if (keyName.size() === 0)
  190.     return Promise.reject(new SecurityException(new Error
  191.       ("BasicIdentityStorage::getKeyPromise: Empty keyName")));
  193.   var identityUri = keyName.getPrefix(-1).toUri();
  194.   var keyId = keyName.get(-1).toEscapedString();
  196.   return this.getPromise_
  197.     ("SELECT public_key FROM Key WHERE identity_name=? AND key_identifier=?",
  198.      [identityUri, keyId])
  199.   .then(function(row) {
  200.     if (row)
  201.       return Promise.resolve(new Blob(row.public_key, false));
  202.     else
  203.       return Promise.reject(new SecurityException(new Error
  204.         ("BasicIdentityStorage::getKeyPromise: The key does not exist")));
  205.   });
  206. };
  208. /**
  209.  * Check if the specified certificate already exists.
  210.  * @param {Name} certificateName The name of the certificate.
  211.  * @param {boolean} useSync (optional) If true then return a rejected promise
  212.  * since this only supports async code.
  213.  * @return {Promise} A promise which returns true if the certificate exists.
  214.  */
  215. BasicIdentityStorage.prototype.doesCertificateExistPromise = function
  216.   (certificateName, useSync)
  217. {
  218.   if (useSync)
  219.     return Promise.reject(new SecurityException(new Error
  220.       ("BasicIdentityStorage.doesCertificateExistPromise is only supported for async")));
  222.   return this.getPromise_
  223.     ("SELECT count(*) FROM Certificate WHERE cert_name=?", certificateName.toUri())
  224.   .then(function(row) {
  225.     if (row["count(*)"] > 0)
  226.       return Promise.resolve(true);
  227.     else
  228.       return Promise.resolve(false);
  229.   });
  230. };
  232. /**
  233.  * Add a certificate to the identity storage. Also call addKey to ensure that
  234.  * the certificate key exists. If the certificate is already installed, don't
  235.  * replace it.
  236.  * @param {IdentityCertificate} certificate The certificate to be added.  This
  237.  * makes a copy of the certificate.
  238.  * @param {boolean} useSync (optional) If true then return a rejected promise
  239.  * since this only supports async code.
  240.  * @return {Promise} A promise which fulfills when finished.
  241.  */
  242. BasicIdentityStorage.prototype.addCertificatePromise = function
  243.   (certificate, useSync)
  244. {
  245.   if (useSync)
  246.     return Promise.reject(new SecurityException(new Error
  247.       ("BasicIdentityStorage.addCertificatePromise is only supported for async")));
  249.   var certificateName = certificate.getName();
  250.   var keyName = certificate.getPublicKeyName();
  252.   var thisStorage = this;
  253.   return this.addKeyPromise
  254.     (keyName, certificate.getPublicKeyInfo().getKeyType(),
  255.      certificate.getPublicKeyInfo().getKeyDer(), useSync)
  256.   .then(function() {
  257.     return thisStorage.doesCertificateExistPromise(certificateName);
  258.   })
  259.   .then(function(exists) {
  260.     if (exists)
  261.       return Promise.resolve();
  263.     var keyId = keyName.get(-1).toEscapedString();
  264.     var identity = keyName.getPrefix(-1);
  266.     // Insert the certificate.
  268.     var signature = certificate.getSignature();
  269.     var signerName = KeyLocator.getFromSignature(signature).getKeyName();
  270.     // Convert from milliseconds to seconds since 1/1/1970.
  271.     var notBefore = Math.floor(certificate.getNotBefore() / 1000.0);
  272.     var notAfter = Math.floor(certificate.getNotAfter() / 1000.0);
  273.     var encodedCert = certificate.wireEncode().buf();
  275.     return thisStorage.runPromise_
  276.       ("INSERT INTO Certificate (cert_name, cert_issuer, identity_name, key_identifier, not_before, not_after, certificate_data) " +
  277.        "VALUES (?,?,?,?,?,?,?)",
  278.        [certificateName.toUri(), signerName.toUri(), identity.toUri(), keyId,
  279.         notBefore, notAfter, encodedCert]);
  280.   });
  281. };
  283. /**
  284.  * Get a certificate from the identity storage.
  285.  * @param {Name} certificateName The name of the requested certificate.
  286.  * @param {boolean} useSync (optional) If true then return a rejected promise
  287.  * since this only supports async code.
  288.  * @return {Promise} A promise which returns the requested
  289.  * IdentityCertificate, or a promise rejected with SecurityException if the
  290.  * certificate doesn't exist.
  291.  */
  292. BasicIdentityStorage.prototype.getCertificatePromise = function
  293.   (certificateName, useSync)
  294. {
  295.   if (useSync)
  296.     return Promise.reject(new SecurityException(new Error
  297.       ("BasicIdentityStorage.getCertificatePromise is only supported for async")));
  299.   return this.getPromise_
  300.     ("SELECT certificate_data FROM Certificate WHERE cert_name=?",
  301.      certificateName.toUri())
  302.   .then(function(row) {
  303.     if (row) {
  304.       var certificate = new IdentityCertificate()
  305.       try {
  306.         certificate.wireDecode(new Blob(row.certificate_data, false))
  307.       } catch (ex) {
  308.         return Promise.reject(new SecurityException(new Error
  309.           ("BasicIdentityStorage.getCertificatePromise: The certificate cannot be decoded")));
  310.       }
  311.       return Promise.resolve(certificate);
  312.     }
  313.     else
  314.       return Promise.reject(new SecurityException(new Error
  315.         ("BasicIdentityStorage.getCertificatePromise: The certificate does not exist")));
  316.   });
  317. };
  319. /*****************************************
  320.  *           Get/Set Default             *
  321.  *****************************************/
  323. /**
  324.  * Get the default identity.
  325.  * @param {boolean} useSync (optional) If true then return a rejected promise
  326.  * since this only supports async code.
  327.  * @return {Promise} A promise which returns the Name of default identity, or a
  328.  * promise rejected with SecurityException if the default identity is not set.
  329.  */
  330. BasicIdentityStorage.prototype.getDefaultIdentityPromise = function(useSync)
  331. {
  332.   if (useSync)
  333.     return Promise.reject(new SecurityException(new Error
  334.       ("BasicIdentityStorage.getDefaultIdentityPromise is only supported for async")));
  336.   return this.getPromise_
  337.     ("SELECT identity_name FROM Identity WHERE default_identity=1")
  338.   .then(function(row) {
  339.     if (row)
  340.       return Promise.resolve(new Name(row.identity_name));
  341.     else
  342.       return Promise.reject(new SecurityException(new Error
  343.         ("BasicIdentityStorage::getDefaultIdentityPromise: The default identity is not defined")));
  344.   });
  345. };
  347. /**
  348.  * Get the default key name for the specified identity.
  349.  * @param {Name} identityName The identity name.
  350.  * @param {boolean} useSync (optional) If true then return a rejected promise
  351.  * since this only supports async code.
  352.  * @return {Promise} A promise which returns the default key Name, or a promise
  353.  * rejected with SecurityException if the default key name for the identity is
  354.  * not set.
  355.  */
  356. BasicIdentityStorage.prototype.getDefaultKeyNameForIdentityPromise = function
  357.   (identityName, useSync)
  358. {
  359.   if (useSync)
  360.     return Promise.reject(new SecurityException(new Error
  361.       ("BasicIdentityStorage.getDefaultKeyNameForIdentityPromise is only supported for async")));
  363.   return this.getPromise_
  364.     ("SELECT key_identifier FROM Key WHERE identity_name=? AND default_key=1",
  365.      identityName.toUri())
  366.   .then(function(row) {
  367.     if (row)
  368.       return Promise.resolve(new Name(identityName).append(row.key_identifier));
  369.     else
  370.       return Promise.reject(new SecurityException(new Error
  371.         ("BasicIdentityStorage::getDefaultKeyNameForIdentityPromise: The default key for the identity is not defined")));
  372.   });
  373. };
  375. /**
  376.  * Get the default certificate name for the specified key.
  377.  * @param {Name} keyName The key name.
  378.  * @param {boolean} useSync (optional) If true then return a rejected promise
  379.  * since this only supports async code.
  380.  * @return {Promise} A promise which returns the default certificate Name, or a
  381.  * promise rejected with SecurityException if the default certificate name for
  382.  * the key name is not set.
  383.  */
  384. BasicIdentityStorage.prototype.getDefaultCertificateNameForKeyPromise = function
  385.   (keyName, useSync)
  386. {
  387.   if (useSync)
  388.     return Promise.reject(new SecurityException(new Error
  389.       ("BasicIdentityStorage.getDefaultCertificateNameForKeyPromise is only supported for async")));
  391.   var keyId = keyName.get(-1).toEscapedString();
  392.   var identityName = keyName.getPrefix(-1);
  394.   return this.getPromise_
  395.     ("SELECT cert_name FROM Certificate WHERE identity_name=? AND key_identifier=? AND default_cert=1",
  396.      [identityName.toUri(), keyId])
  397.   .then(function(row) {
  398.     if (row)
  399.       return Promise.resolve(new Name(row.cert_name));
  400.     else
  401.       return Promise.reject(new SecurityException(new Error
  402.         ("BasicIdentityStorage::getDefaultCertificateNameForKeyPromise: The default certificate for the key name is not defined")));
  403.   });
  404. };
  406. /**
  407.  * Append all the identity names to the nameList.
  408.  * @param {Array<Name>} nameList Append result names to nameList.
  409.  * @param {boolean} isDefault If true, add only the default identity name. If
  410.  * false, add only the non-default identity names.
  411.  * @param {boolean} useSync (optional) If true then return a rejected promise
  412.  * since this only supports async code.
  413.  * @return {Promise} A promise which fulfills when the names are added to
  414.  * nameList.
  415.  */
  416. BasicIdentityStorage.prototype.getAllIdentitiesPromise = function
  417.   (nameList, isDefault, useSync)
  418. {
  419.   if (useSync)
  420.     return Promise.reject(new SecurityException(new Error
  421.       ("BasicIdentityStorage.getAllIdentitiesPromise is only supported for async")));
  423.   var query;
  424.   if (isDefault)
  425.     query = "SELECT identity_name FROM Identity WHERE default_identity=1";
  426.   else
  427.     query = "SELECT identity_name FROM Identity WHERE default_identity=0";
  429.   return this.eachPromise_(query, [], function(err, row) {
  430.     nameList.push(new Name(row.identity_name));
  431.   });
  432. };
  434. /**
  435.  * Append all the key names of a particular identity to the nameList.
  436.  * @param {Name} identityName The identity name to search for.
  437.  * @param {Array<Name>} nameList Append result names to nameList.
  438.  * @param {boolean} isDefault If true, add only the default key name. If false,
  439.  * add only the non-default key names.
  440.  * @param {boolean} useSync (optional) If true then return a rejected promise
  441.  * since this only supports async code.
  442.  * @return {Promise} A promise which fulfills when the names are added to
  443.  * nameList.
  444.  */
  445. BasicIdentityStorage.prototype.getAllKeyNamesOfIdentityPromise = function
  446.   (identityName, nameList, isDefault, useSync)
  447. {
  448.   if (useSync)
  449.     return Promise.reject(new SecurityException(new Error
  450.       ("BasicIdentityStorage.getAllKeyNamesOfIdentityPromise is only supported for async")));
  452.   var query;
  453.   if (isDefault)
  454.     query = "SELECT key_identifier FROM Key WHERE default_key=1 and identity_name=?";
  455.   else
  456.     query = "SELECT key_identifier FROM Key WHERE default_key=0 and identity_name=?";
  458.   return this.eachPromise_(query, identityName.toUri(), function(err, row) {
  459.     nameList.push(new Name(identityName).append(row.key_identifier));
  460.   });
  461. };
  463. /**
  464.  * Append all the certificate names of a particular key name to the nameList.
  465.  * @param {Name} keyName The key name to search for.
  466.  * @param {Array<Name>} nameList Append result names to nameList.
  467.  * @param {boolean} isDefault If true, add only the default certificate name.
  468.  * If false, add only the non-default certificate names.
  469.  * @param {boolean} useSync (optional) If true then return a rejected promise
  470.  * since this only supports async code.
  471.  * @return {Promise} A promise which fulfills when the names are added to
  472.  * nameList.
  473.  */
  474. BasicIdentityStorage.prototype.getAllCertificateNamesOfKeyPromise = function
  475.   (keyName, nameList, isDefault, useSync)
  476. {
  477.   if (useSync)
  478.     return Promise.reject(new SecurityException(new Error
  479.       ("BasicIdentityStorage.getAllCertificateNamesOfKeyPromise is only supported for async")));
  481.   var query;
  482.   if (isDefault)
  483.     query = "SELECT cert_name FROM Certificate" +
  484.             "  WHERE default_cert=1 and identity_name=? and key_identifier=?";
  485.   else
  486.     query = "SELECT cert_name FROM Certificate" +
  487.             "  WHERE default_cert=0 and identity_name=? and key_identifier=?";
  489.   return this.eachPromise_
  490.     (query, [keyName.getPrefix(-1).toUri(), keyName.get(-1).toEscapedString()],
  491.      function(err, row) {
  492.     nameList.push(new Name(row.cert_name));
  493.   });
  494. };
  496. /**
  497.  * Set the default identity.  If the identityName does not exist, then clear the
  498.  * default identity so that getDefaultIdentity() throws an exception.
  499.  * @param {Name} identityName The default identity name.
  500.  * @param {boolean} useSync (optional) If true then return a rejected promise
  501.  * since this only supports async code.
  502.  * @return {Promise} A promise which fulfills when the default identity is set.
  503.  */
  504. BasicIdentityStorage.prototype.setDefaultIdentityPromise = function
  505.   (identityName, useSync)
  506. {
  507.   if (useSync)
  508.     return Promise.reject(new SecurityException(new Error
  509.       ("BasicIdentityStorage.setDefaultIdentityPromise is only supported for async")));
  511.   var thisStorage = this;
  513.   // Reset the previous default identity.
  514.   return this.runPromise_
  515.     ("UPDATE Identity SET default_identity=0 WHERE default_identity=1")
  516.   .then(function() {
  517.     // Set the current default identity.
  518.     return thisStorage.runPromise_
  519.       ("UPDATE Identity SET default_identity=1 WHERE identity_name=?",
  520.        identityName.toUri());
  521.   });
  522. };
  524. /**
  525.  * Set a key as the default key of an identity. The identity name is inferred
  526.  * from keyName.
  527.  * @param {Name} keyName The name of the key.
  528.  * @param {Name} identityNameCheck (optional) The identity name to check that the
  529.  * keyName contains the same identity name. If an empty name, it is ignored.
  530.  * @param {boolean} useSync (optional) If true then return a rejected promise
  531.  * since this only supports async code.
  532.  * @return {Promise} A promise which fulfills when the default key name is set.
  533.  */
  534. BasicIdentityStorage.prototype.setDefaultKeyNameForIdentityPromise = function
  535.   (keyName, identityNameCheck, useSync)
  536. {
  537.   useSync = (typeof identityNameCheck === "boolean") ? identityNameCheck : useSync;
  538.   identityNameCheck = (identityNameCheck instanceof Name) ? identityNameCheck : null;
  540.   if (useSync)
  541.     return Promise.reject(new SecurityException(new Error
  542.       ("BasicIdentityStorage.setDefaultKeyNameForIdentityPromise is only supported for async")));
  544.   var keyId = keyName.get(-1).toEscapedString();
  545.   var identityName = keyName.getPrefix(-1);
  547.   if (identityNameCheck != null && identityNameCheck.size() != 0 &&
  548.       !identityNameCheck.equals(identityName))
  549.     return Promise.reject(new SecurityException(new Error
  550.       ("Specified identity name does not match the key name")));
  552.   var thisStorage = this;
  554.   // Reset the previous default key.
  555.   var identityUri = identityName.toUri();
  556.   return this.runPromise_
  557.     ("UPDATE Key SET default_key=0 WHERE default_key=1 and identity_name=?",
  558.      identityUri)
  559.   .then(function() {
  560.     // Set the current default key.
  561.     return thisStorage.runPromise_
  562.       ("UPDATE Key SET default_key=1 WHERE identity_name=? AND key_identifier=?",
  563.        [identityUri, keyId]);
  564.   });
  565. };
  567. /**
  568.  * Set the default key name for the specified identity.
  569.  * @param {Name} keyName The key name.
  570.  * @param {Name} certificateName The certificate name.
  571.  * @param {boolean} useSync (optional) If true then return a rejected promise
  572.  * since this only supports async code.
  573.  * @return {Promise} A promise which fulfills when the default certificate name
  574.  * is set.
  575.  */
  576. BasicIdentityStorage.prototype.setDefaultCertificateNameForKeyPromise = function
  577.   (keyName, certificateName, useSync)
  578. {
  579.   if (useSync)
  580.     return Promise.reject(new SecurityException(new Error
  581.       ("BasicIdentityStorage.setDefaultCertificateNameForKeyPromise is only supported for async")));
  583.   var keyId = keyName.get(-1).toEscapedString();
  584.   var identityName = keyName.getPrefix(-1);
  585.   var thisStorage = this;
  587.   // Reset the previous default certificate.
  588.   var identityUri = identityName.toUri();
  589.   return this.runPromise_
  590.     ("UPDATE Certificate SET default_cert=0 WHERE default_cert=1 AND identity_name=? AND key_identifier=?",
  591.      [identityUri, keyId])
  592.   .then(function() {
  593.     // Set the current default certificate.
  594.     return thisStorage.runPromise_
  595.       ("UPDATE Certificate SET default_cert=1 WHERE identity_name=? AND key_identifier=? AND cert_name=?",
  596.        [identityUri, keyId, certificateName.toUri()]);
  597.   });
  598. };
  600. /*****************************************
  601.  *            Delete Methods             *
  602.  *****************************************/
  604. /**
  605.  * Delete a certificate.
  606.  * @param {Name} certificateName The certificate name.
  607.  * @param {boolean} useSync (optional) If true then return a rejected promise
  608.  * since this only supports async code.
  609.  * @return {Promise} A promise which fulfills when the certificate info is
  610.  * deleted.
  611.  */
  612. BasicIdentityStorage.prototype.deleteCertificateInfoPromise = function
  613.   (certificateName, useSync)
  614. {
  615.   if (useSync)
  616.     return Promise.reject(new SecurityException(new Error
  617.       ("BasicIdentityStorage.deleteCertificateInfoPromise is only supported for async")));
  619.   if (certificateName.size() === 0)
  620.     return
  622.   return this.runPromise_
  623.     ("DELETE FROM Certificate WHERE cert_name=?", certificateName.toUri());
  624. };
  626. /**
  627.  * Delete a public key and related certificates.
  628.  * @param {Name} keyName The key name.
  629.  * @param {boolean} useSync (optional) If true then return a rejected promise
  630.  * since this only supports async code.
  631.  * @return {Promise} A promise which fulfills when the public key info is
  632.  * deleted.
  633.  */
  634. BasicIdentityStorage.prototype.deletePublicKeyInfoPromise = function(keyName, useSync)
  635. {
  636.   if (useSync)
  637.     return Promise.reject(new SecurityException(new Error
  638.       ("BasicIdentityStorage.deletePublicKeyInfoPromise is only supported for async")));
  640.   if (keyName.size() === 0)
  641.     return Promise.resolve();
  643.   var thisStorage = this;
  644.   var keyId = keyName.get(-1).toEscapedString();
  645.   var identityName = keyName.getPrefix(-1);
  647.   return this.runPromise_
  648.     ("DELETE FROM Certificate WHERE identity_name=? AND key_identifier=?",
  649.      [identityName.toUri(), keyId])
  650.   .then(function() {
  651.     return thisStorage.runPromise_
  652.       ("DELETE FROM Key WHERE identity_name=? and key_identifier=?",
  653.        [identityName.toUri(), keyId]);
  654.   });
  655. };
  657. /**
  658.  * Delete an identity and related public keys and certificates.
  659.  * @param {Name} identityName The identity name.
  660.  * @param {boolean} useSync (optional) If true then return a rejected promise
  661.  * since this only supports async code.
  662.  * @return {Promise} A promise which fulfills when the identity info is deleted.
  663.  */
  664. BasicIdentityStorage.prototype.deleteIdentityInfoPromise = function
  665.   (identityName, useSync)
  666. {
  667.   if (useSync)
  668.     return Promise.reject(new SecurityException(new Error
  669.       ("BasicIdentityStorage.deleteIdentityInfoPromise is only supported for async")));
  671.   var thisStorage = this;
  672.   var identity = identityName.toUri();
  674.   return this.runPromise_
  675.     ("DELETE FROM Certificate WHERE identity_name=?", identity)
  676.   .then(function() {
  677.     return thisStorage.runPromise_("DELETE FROM Key WHERE identity_name=?", identity);
  678.   })
  679.   .then(function() {
  680.     return thisStorage.runPromise_("DELETE FROM Identity WHERE identity_name=?", identity);
  681.   });
  682. };
  684. /**
  685.  * Retrieve the user's current home directory
  686.  * @returns {string} path to the user's home directory
  687.  */
  688. BasicIdentityStorage.getUserHomePath = function() {
  689.   return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
  690. };
  692. /**
  693.  * Call Sqlite3Promise.runPromise, wrapping an Error in SecurityException.
  694.  */
  695. BasicIdentityStorage.prototype.runPromise_ = function(sql, params)
  696. {
  697.   return this.database_.runPromise(sql, params)
  698.   .catch(function(error) {
  699.     return Promise.reject(new SecurityException(error));
  700.   });
  701. };
  703. /**
  704.  * Call Sqlite3Promise.getPromise, wrapping an Error in SecurityException.
  705.  */
  706. BasicIdentityStorage.prototype.getPromise_ = function(sql, params)
  707. {
  708.   return this.database_.getPromise(sql, params)
  709.   .catch(function(error) {
  710.     return Promise.reject(new SecurityException(error));
  711.   });
  712. };
  714. /**
  715.  * Call Sqlite3Promise.eachPromise, wrapping an Error in SecurityException.
  716.  */
  717. BasicIdentityStorage.prototype.eachPromise_ = function(sql, params, onRow)
  718. {
  719.   return this.database_.eachPromise(sql, params, onRow)
  720.   .catch(function(error) {
  721.     return Promise.reject(new SecurityException(error));
  722.   });
  723. };
  725. /**
  726.  * Retrieve the user's current home directory
  727.  * @returns {string} path to the user's home directory
  728.  */
  729. BasicIdentityStorage.getUserHomePath = function() {
  730.   return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
  731. };
  733. BasicIdentityStorage.initializeDatabasePromise_ = function(database)
  734. {
  735.   // Check if the ID table exists.
  736.   return database.getPromise
  737.     ("SELECT name FROM sqlite_master WHERE type='table' And name='Identity'")
  738.   .then(function(row) {
  739.     if (row)
  740.       return Promise.resolve();
  741.     else {
  742.       return database.runPromise(BasicIdentityStorage.INIT_ID_TABLE1)
  743.       .then(function() {
  744.         return database.runPromise(BasicIdentityStorage.INIT_ID_TABLE2);
  745.       });
  746.     }
  747.   })
  748.   .then(function() {
  749.     // Check if the Key table exists.
  750.     return database.getPromise
  751.       ("SELECT name FROM sqlite_master WHERE type='table' And name='Key'");
  752.   })
  753.   .then(function(row) {
  754.     if (row)
  755.       return Promise.resolve();
  756.     else {
  757.       return database.runPromise(BasicIdentityStorage.INIT_KEY_TABLE1)
  758.       .then(function() {
  759.         return database.runPromise(BasicIdentityStorage.INIT_KEY_TABLE2);
  760.       });
  761.     }
  762.   })
  763.   .then(function() {
  764.     // Check if the Certificate table exists.
  765.     return database.getPromise
  766.       ("SELECT name FROM sqlite_master WHERE type='table' And name='Certificate'");
  767.   })
  768.   .then(function(row) {
  769.     if (row)
  770.       return Promise.resolve();
  771.     else {
  772.       return database.runPromise(BasicIdentityStorage.INIT_CERT_TABLE1)
  773.       .then(function() {
  774.         return database.runPromise(BasicIdentityStorage.INIT_CERT_TABLE2);
  775.       })
  776.       .then(function() {
  777.         return database.runPromise(BasicIdentityStorage.INIT_CERT_TABLE3);
  778.       });
  779.     }
  780.   });
  781. };
  783. BasicIdentityStorage.INIT_ID_TABLE1 =
  784. "CREATE TABLE IF NOT EXISTS                                           \n" +
  785. "  Identity(                                                          \n" +
  786. "      identity_name     BLOB NOT NULL,                               \n" +
  787. "      default_identity  INTEGER DEFAULT 0,                           \n" +
  788. "                                                                     \n" +
  789. "      PRIMARY KEY (identity_name)                                    \n" +
  790. "  );                                                                 \n" +
  791. "                                                                     \n";
  792. BasicIdentityStorage.INIT_ID_TABLE2 =
  793. "CREATE INDEX identity_index ON Identity(identity_name);              \n";
  795. BasicIdentityStorage.INIT_KEY_TABLE1 =
  796. "CREATE TABLE IF NOT EXISTS                                           \n" +
  797. "  Key(                                                               \n" +
  798. "      identity_name     BLOB NOT NULL,                               \n" +
  799. "      key_identifier    BLOB NOT NULL,                               \n" +
  800. "      key_type          INTEGER,                                     \n" +
  801. "      public_key        BLOB,                                        \n" +
  802. "      default_key       INTEGER DEFAULT 0,                           \n" +
  803. "      active            INTEGER DEFAULT 0,                           \n" +
  804. "                                                                     \n" +
  805. "      PRIMARY KEY (identity_name, key_identifier)                    \n" +
  806. "  );                                                                 \n" +
  807. "                                                                     \n";
  808. BasicIdentityStorage.INIT_KEY_TABLE2 =
  809. "CREATE INDEX key_index ON Key(identity_name);                        \n";
  811. BasicIdentityStorage.INIT_CERT_TABLE1 =
  812. "CREATE TABLE IF NOT EXISTS                                           \n" +
  813. "  Certificate(                                                       \n" +
  814. "      cert_name         BLOB NOT NULL,                               \n" +
  815. "      cert_issuer       BLOB NOT NULL,                               \n" +
  816. "      identity_name     BLOB NOT NULL,                               \n" +
  817. "      key_identifier    BLOB NOT NULL,                               \n" +
  818. "      not_before        TIMESTAMP,                                   \n" +
  819. "      not_after         TIMESTAMP,                                   \n" +
  820. "      certificate_data  BLOB NOT NULL,                               \n" +
  821. "      valid_flag        INTEGER DEFAULT 1,                           \n" +
  822. "      default_cert      INTEGER DEFAULT 0,                           \n" +
  823. "                                                                     \n" +
  824. "      PRIMARY KEY (cert_name)                                        \n" +
  825. "  );                                                                 \n" +
  826. "                                                                     \n";
  827. BasicIdentityStorage.INIT_CERT_TABLE2 =
  828. "CREATE INDEX cert_index ON Certificate(cert_name);           \n";
  829. BasicIdentityStorage.INIT_CERT_TABLE3 =
  830. "CREATE INDEX subject ON Certificate(identity_name);          \n";