Source: encrypt/group-manager.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/group-manager 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 Name = require('../name.js').Name; /** @ignore */
  23. var Data = require('../data.js').Data; /** @ignore */
  24. var SyncPromise = require('../util/sync-promise.js').SyncPromise; /** @ignore */
  25. var IdentityCertificate = require('../security/certificate/identity-certificate.js').IdentityCertificate; /** @ignore */
  26. var SecurityException = require('../security/security-exception.js').SecurityException; /** @ignore */
  27. var RsaKeyParams = require('../security/key-params.js').RsaKeyParams; /** @ignore */
  28. var EncryptParams = require('./algo/encrypt-params.js').EncryptParams; /** @ignore */
  29. var EncryptAlgorithmType = require('./algo/encrypt-params.js').EncryptAlgorithmType; /** @ignore */
  30. var Encryptor = require('./algo/encryptor.js').Encryptor; /** @ignore */
  31. var RsaAlgorithm = require('./algo/rsa-algorithm.js').RsaAlgorithm; /** @ignore */
  32. var Interval = require('./interval.js').Interval; /** @ignore */
  33. var Schedule = require('./schedule.js').Schedule;
  35. /**
  36.  * A GroupManager manages keys and schedules for group members in a particular
  37.  * namespace.
  38.  * Create a group manager with the given values. The group manager namespace
  39.  * is <prefix>/read/<dataType> .
  40.  * @param {Name} prefix The prefix for the group manager namespace.
  41.  * @param {Name} dataType The data type for the group manager namespace.
  42.  * @param {GroupManagerDb} database The GroupManagerDb for storing the group
  43.  * management information (including user public keys and schedules).
  44.  * @param {number} keySize The group key will be an RSA key with keySize bits.
  45.  * @param {number} freshnessHours The number of hours of the freshness period of
  46.  *   data packets carrying the keys.
  47.  * @param {KeyChain} keyChain The KeyChain to use for signing data packets. This
  48.  * signs with the default identity.
  49.  * @note This class is an experimental feature. The API may change.
  50.  * @constructor
  51.  */
  52. var GroupManager = function GroupManager
  53.   (prefix, dataType, database, keySize, freshnessHours, keyChain)
  54. {
  55.   this.namespace_ = new Name(prefix).append(Encryptor.NAME_COMPONENT_READ)
  56.     .append(dataType);
  57.   this.database_ = database;
  58.   this.keySize_ = keySize;
  59.   this.freshnessHours_ = freshnessHours;
  61.   this.keyChain_ = keyChain;
  62. };
  64. exports.GroupManager = GroupManager;
  66. /**
  67.  * Create a group key for the interval into which timeSlot falls. This creates
  68.  * a group key if it doesn't exist, and encrypts the key using the public key of
  69.  * each eligible member.
  70.  * @param {number} timeSlot The time slot to cover as milliseconds since
  71.  * Jan 1, 1970 UTC.
  72.  * @param {boolean} needRegenerate (optional) needRegenerate should be true if
  73.  * this is the first time this method is called, or a member was removed.
  74.  * needRegenerate can be false if this is not the first time this method is
  75.  * called, or a member was added. If omitted, use true. If useSync is specified,
  76.  * then needRegenerate must also be specified (since this can't disambiguate
  77.  * two optional boolean parameters).
  78.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  79.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  80.  * an async Promise. If useSync is specified, then needRegenerate must also be
  81.  * specified (since this can't disambiguate two optional boolean parameters).
  82.  * @return {Promise|SyncPromise} A promise that returns a List of Data packets
  83.  * (where the first is the E-KEY data packet with the group's public key and the
  84.  * rest are the D-KEY data packets with the group's private key encrypted with
  85.  * the public key of each eligible member), or that is rejected with
  86.  * GroupManagerDb.Error for a database error or SecurityException for an error
  87.  * using the security KeyChain.
  88.  */
  89. GroupManager.prototype.getGroupKeyPromise = function
  90.   (timeSlot, needRegenerate, useSync)
  91. {
  92.   if (needRegenerate == undefined)
  93.     needRegenerate = true;
  95.   var memberKeys = [];
  96.   var result = [];
  97.   var thisManager = this;
  98.   var privateKeyBlob;
  99.   var publicKeyBlob;
  100.   var startTimeStamp;
  101.   var endTimeStamp;
  103.   // Get the time interval.
  104.   return this.calculateIntervalPromise_(timeSlot, memberKeys, useSync)
  105.   .then(function(finalInterval) {
  106.     if (finalInterval.isValid() == false)
  107.       return SyncPromise.resolve(result);
  109.     startTimeStamp = Schedule.toIsoString(finalInterval.getStartTime());
  110.     endTimeStamp = Schedule.toIsoString(finalInterval.getEndTime());
  112.     // Generate the private and public keys.
  113.     var eKeyName = new Name(thisManager.namespace_);
  114.     eKeyName.append(Encryptor.NAME_COMPONENT_E_KEY).append(startTimeStamp)
  115.       .append(endTimeStamp);
  117.     return SyncPromise.resolve()
  118.     .then(function() {
  119.       // Only call hasEKeyPromise if needRegenerate is false.
  120.       if (!needRegenerate)
  121.         return thisManager.database_.hasEKeyPromise(eKeyName, useSync);
  122.       else
  123.         return SyncPromise.resolve(false);
  124.     })
  125.     .then(function(hasEKey) {
  126.       if (!needRegenerate && hasEKey) {
  127.         return thisManager.getEKeyPromise_(eKeyName, useSync)
  128.         .then(function(keyPair) {
  129.           privateKeyBlob = keyPair.privateKey;
  130.           publicKeyBlob = keyPair.publicKey;
  131.           return SyncPromise.resolve();
  132.         });
  133.       }
  134.       else {
  135.         return thisManager.generateKeyPairPromise_(useSync)
  136.         .then(function(keyPair) {
  137.           privateKeyBlob = keyPair.privateKeyBlob;
  138.           publicKeyBlob = keyPair.publicKeyBlob;
  140.           // deleteEKeyPromise_ does nothing if eKeyName does not exist.
  141.           return thisManager.deleteEKeyPromise_(eKeyName, useSync);
  142.         })
  143.         .then(function() {
  144.           return thisManager.addEKeyPromise_
  145.             (eKeyName, publicKeyBlob, privateKeyBlob, useSync);
  146.         });
  147.       }
  148.     })
  149.     .then(function() {
  150.       // Add the first element to the result.
  151.       // The E-KEY (public key) data packet name convention is:
  152.       // /<data_type>/E-KEY/[start-ts]/[end-ts]
  153.       return thisManager.createEKeyDataPromise_
  154.         (startTimeStamp, endTimeStamp, publicKeyBlob, useSync);
  155.     })
  156.     .then(function(data) {
  157.       result.push(data);
  159.       // Encrypt the private key with the public key from each member's certificate.
  161.       // Process the memberKeys entry at i, and recursively call to process the
  162.       // next entry. Return a promise which is resolved when all are processed.
  163.       // (We have to make a recursive function to use Promises.)
  164.       function processMemberKey(i) {
  165.         if (i >= memberKeys.length)
  166.           // Finished.
  167.           return SyncPromise.resolve();
  169.         var keyName = memberKeys[i].keyName;
  170.         var certificateKey = memberKeys[i].publicKey;
  172.         return thisManager.createDKeyDataPromise_
  173.           (startTimeStamp, endTimeStamp, keyName, privateKeyBlob, certificateKey,
  174.            useSync)
  175.         .then(function(data) {
  176.           result.push(data);
  178.           return processMemberKey(i + 1);
  179.         });
  180.       }
  182.       return processMemberKey(0);
  183.     })
  184.     .then(function() {
  185.       return SyncPromise.resolve(result);
  186.     });
  187.   });
  188. };
  190. /**
  191.  * Add a schedule with the given scheduleName.
  192.  * @param {string} scheduleName The name of the schedule. The name cannot be
  193.  * empty.
  194.  * @param {Schedule} schedule The Schedule to add.
  195.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  196.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  197.  * an async Promise.
  198.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  199.  * added, or that is rejected with GroupManagerDb.Error if a schedule with the
  200.  * same name already exists, if the name is empty, or other database error.
  201.  */
  202. GroupManager.prototype.addSchedulePromise = function
  203.   (scheduleName, schedule, useSync)
  204. {
  205.   return this.database_.addSchedulePromise(scheduleName, schedule, useSync);
  206. };
  208. /**
  209.  * Delete the schedule with the given scheduleName. Also delete members which
  210.  * use this schedule. If there is no schedule with the name, then do nothing.
  211.  * @param {string} scheduleName The name of the schedule.
  212.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  213.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  214.  * an async Promise.
  215.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  216.  * deleted (or there is no such schedule), or that is rejected with
  217.  * GroupManagerDb.Error for a database error.
  218.  */
  219. GroupManager.prototype.deleteSchedulePromise = function(scheduleName, useSync)
  220. {
  221.   return this.database_.deleteSchedulePromise(scheduleName, useSync);
  222. };
  224. /**
  225.  * Update the schedule with scheduleName and replace the old object with the
  226.  * given schedule. Otherwise, if no schedule with name exists, a new schedule
  227.  * with name and the given schedule will be added to database.
  228.  * @param {string} scheduleName The name of the schedule. The name cannot be
  229.  * empty.
  230.  * @param {Schedule} schedule The Schedule to update or add.
  231.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  232.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  233.  * an async Promise.
  234.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  235.  * updated, or that is rejected with GroupManagerDb.Error if the name is empty,
  236.  * or other database error.
  237.  */
  238. GroupManager.prototype.updateSchedulePromise = function
  239.   (scheduleName, schedule, useSync)
  240. {
  241.   return this.database_.updateSchedulePromise(scheduleName, schedule, useSync);
  242. };
  244. /**
  245.  * Add a new member with the given memberCertificate into a schedule named
  246.  * scheduleName. If cert is an IdentityCertificate made from memberCertificate,
  247.  * then the member's identity name is cert.getPublicKeyName().getPrefix(-1).
  248.  * @param {string} scheduleName The schedule name.
  249.  * @param {Data} memberCertificate The member's certificate.
  250.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  251.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  252.  * an async Promise.
  253.  * @return {Promise|SyncPromise} A promise that fulfills when the member is
  254.  * added, or that is rejected with GroupManagerDb.Error if there's no schedule
  255.  * named scheduleName, if the member's identity name already exists, or other
  256.  * database error. Or a promise that is rejected with DerDecodingException for
  257.  * an error decoding memberCertificate as a certificate.
  258.  */
  259. GroupManager.prototype.addMemberPromise = function
  260.   (scheduleName, memberCertificate, useSync)
  261. {
  262.   var cert = new IdentityCertificate(memberCertificate);
  263.   return this.database_.addMemberPromise
  264.     (scheduleName, cert.getPublicKeyName(), cert.getPublicKeyInfo().getKeyDer(),
  265.      useSync);
  266. };
  268. /**
  269.  * Remove a member with the given identity name. If there is no member with
  270.  * the identity name, then do nothing.
  271.  * @param {Name} identity The member's identity name.
  272.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  273.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  274.  * an async Promise.
  275.  * @return {Promise|SyncPromise} A promise that fulfills when the member is
  276.  * removed (or there is no such member), or that is rejected with
  277.  * GroupManagerDb.Error for a database error.
  278.  */
  279. GroupManager.prototype.removeMemberPromise = function(identity, useSync)
  280. {
  281.   return this.database_.deleteMemberPromise(identity, useSync);
  282. };
  284. /**
  285.  * Change the name of the schedule for the given member's identity name.
  286.  * @param {Name} identity The member's identity name.
  287.  * @param {string} scheduleName The new schedule name.
  288.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  289.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  290.  * an async Promise.
  291.  * @return {Promise|SyncPromise} A promise that fulfills when the member is
  292.  * updated, or that is rejected with GroupManagerDb.Error if there's no member
  293.  * with the given identity name in the database, or there's no schedule named
  294.  * scheduleName.
  295.  */
  296. GroupManager.prototype.updateMemberSchedulePromise = function
  297.   (identity, scheduleName, useSync)
  298. {
  299.   return this.database_.updateMemberSchedulePromise
  300.     (identity, scheduleName, useSync);
  301. };
  303. /**
  304.  * Delete all the EKeys in the database. The database will keep growing because
  305.  * EKeys will keep being added, so this method should be called periodically.
  306.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  307.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  308.  * an async Promise.
  309.  * @return {Promise|SyncPromise} A promise that fulfills when the EKeys are
  310.  * deleted, or that is rejected with GroupManagerDb.Error for a database error.
  311.  */
  312. GroupManager.prototype.cleanEKeysPromise = function(useSync)
  313. {
  314.   return this.database_.cleanEKeysPromise(useSync);
  315. };
  317. /**
  318.  * Calculate an Interval that covers the timeSlot.
  319.  * @param {number} timeSlot The time slot to cover as milliseconds since
  320.  * Jan 1, 1970 UTC.
  321.  * @param {Array<object>} memberKeys First clear memberKeys then fill it with
  322.  * the info of members who are allowed to access the interval. memberKeys is an
  323.  * array of object where "keyName" is the Name of the public key and "publicKey"
  324.  * is the Blob of the public key DER. The memberKeys entries are sorted by
  325.  * the entry keyName.
  326.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  327.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  328.  * an async Promise.
  329.  * @return {Promise|SyncPromise} A promise that returns a new nterval covering
  330.  * the time slot, or that is rejected with GroupManagerDb.Error for a database
  331.  * error.
  332.  */
  333. GroupManager.prototype.calculateIntervalPromise_ = function
  334.   (timeSlot, memberKeys, useSync)
  335. {
  336.   // Prepare.
  337.   var positiveResult = new Interval();
  338.   var negativeResult = new Interval();
  339.   // Clear memberKeys.
  340.   memberKeys.splice(0, memberKeys.length);
  341.   var thisManager = this;
  343.   // Get the all intervals from the schedules.
  344.   return this.database_.listAllScheduleNamesPromise(useSync)
  345.   .then(function(scheduleNames) {
  346.     // Process the scheduleNames entry at i, and recursively call to process the
  347.     // next entry. Return a promise which is resolved when all are processed.
  348.     // (We have to make a recursive function to use Promises.)
  349.     function processSchedule(i) {
  350.       if (i >= scheduleNames.length)
  351.         // Finished.
  352.         return SyncPromise.resolve();
  354.       var scheduleName = scheduleNames[i];
  356.       return thisManager.database_.getSchedulePromise(scheduleName, useSync)
  357.       .then(function(schedule) {
  358.         var result = schedule.getCoveringInterval(timeSlot);
  359.         var tempInterval = result.interval;
  361.         if (result.isPositive) {
  362.           if (!positiveResult.isValid())
  363.             positiveResult = tempInterval;
  364.           positiveResult.intersectWith(tempInterval);
  366.           return thisManager.database_.getScheduleMembersPromise
  367.             (scheduleName, useSync)
  368.           .then(function(map) {
  369.             // Add each entry in map to memberKeys.
  370.             for (var iMap = 0; iMap < map.length; ++iMap)
  371.               GroupManager.memberKeysAdd_(memberKeys, map[iMap]);
  373.             return processSchedule(i + 1);
  374.           });
  375.         }
  376.         else {
  377.           if (!negativeResult.isValid())
  378.             negativeResult = tempInterval;
  379.           negativeResult.intersectWith(tempInterval);
  381.           return processSchedule(i + 1);
  382.         }
  383.       });
  384.     }
  386.     return processSchedule(0);
  387.   })
  388.   .then(function() {
  389.     if (!positiveResult.isValid())
  390.       // Return an invalid interval when there is no member which has an
  391.       // interval covering the time slot.
  392.       return SyncPromise.resolve(new Interval(false));
  394.     // Get the final interval result.
  395.     var finalInterval;
  396.     if (negativeResult.isValid())
  397.       finalInterval = positiveResult.intersectWith(negativeResult);
  398.     else
  399.       finalInterval = positiveResult;
  401.     return SyncPromise.resolve(finalInterval);
  402.   });
  403. };
  405. /**
  406.  * Add entry to memberKeys, sorted by entry.keyName. If there is already an
  407.  * entry with keyName, then don't add.
  408.  */
  409. GroupManager.memberKeysAdd_ = function(memberKeys, entry)
  410. {
  411.   // Find the index of the first node where the keyName is not less than
  412.   // entry.keyName.
  413.   var i = 0;
  414.   while (i < memberKeys.length) {
  415.     var comparison = memberKeys[i].keyName.compare(entry.keyName);
  416.     if (comparison == 0)
  417.       // A duplicate, so don't add.
  418.       return;
  420.     if (comparison > 0)
  421.       break;
  422.     i += 1;
  423.   }
  425.   memberKeys.splice(i, 0, entry);
  426. };
  428. /**
  429.  * Generate an RSA key pair according to keySize_.
  430.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  431.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  432.  * an async Promise.
  433.  * @return {Promise|SyncPromise} A promise that returns an object where
  434.  * "privateKeyBlob" is the encoding Blob of the private key and "publicKeyBlob"
  435.  * is the encoding Blob of the public key.
  436.  */
  437. GroupManager.prototype.generateKeyPairPromise_ = function(useSync)
  438. {
  439.   var params = new RsaKeyParams(this.keySize_);
  441.   return RsaAlgorithm.generateKeyPromise(params)
  442.   .then(function(privateKey) {
  443.     var privateKeyBlob = privateKey.getKeyBits();
  444.     var publicKey = RsaAlgorithm.deriveEncryptKey(privateKeyBlob);
  445.     var publicKeyBlob = publicKey.getKeyBits();
  447.     return SyncPromise.resolve
  448.       ({ privateKeyBlob: privateKeyBlob, publicKeyBlob: publicKeyBlob });
  449.   });
  450. };
  452. /**
  453.  * Create an E-KEY Data packet for the given public key.
  454.  * @param {string} startTimeStamp The start time stamp string to put in the name.
  455.  * @param {string} endTimeStamp The end time stamp string to put in the name.
  456.  * @param {Blob} publicKeyBlob A Blob of the public key DER.
  457.  * @return The Data packet.
  458.  * @throws SecurityException for an error using the security KeyChain.
  459.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  460.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  461.  * an async Promise.
  462.  * @return {Promise|SyncPromise} A promise that returns the Data packet, or that
  463.  * is rejected with SecurityException for an error using the security KeyChain.
  464.  */
  465. GroupManager.prototype.createEKeyDataPromise_ = function
  466.   (startTimeStamp, endTimeStamp, publicKeyBlob, useSync)
  467. {
  468.   var name = new Name(this.namespace_);
  469.   name.append(Encryptor.NAME_COMPONENT_E_KEY).append(startTimeStamp)
  470.     .append(endTimeStamp);
  472.   var data = new Data(name);
  473.   data.getMetaInfo().setFreshnessPeriod
  474.     (this.freshnessHours_ * GroupManager.MILLISECONDS_IN_HOUR);
  475.   data.setContent(publicKeyBlob);
  477.   return this.keyChain_.signPromise(data);
  478. };
  480. /**
  481.  * Create a D-KEY Data packet with an EncryptedContent for the given private
  482.  * key, encrypted with the certificate key.
  483.  * @param {string} startTimeStamp The start time stamp string to put in the name.
  484.  * @param {string} endTimeStamp The end time stamp string to put in the name.
  485.  * @param {Name} keyName The key name to put in the data packet name and the
  486.  * EncryptedContent key locator.
  487.  * @param {Blob} privateKeyBlob A Blob of the encoded private key.
  488.  * @param {Blob} certificateKey The certificate key encoding, used to encrypt
  489.  * the private key.
  490.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  491.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  492.  * an async Promise.
  493.  * @return {Promise|SyncPromise} A promise that returns the Data packet, or that
  494.  * is rejected with SecurityException for an error using the security KeyChain.
  495.  */
  496. GroupManager.prototype.createDKeyDataPromise_ = function
  497.   (startTimeStamp, endTimeStamp, keyName, privateKeyBlob, certificateKey,
  498.    useSync)
  499. {
  500.   var name = new Name(this.namespace_);
  501.   name.append(Encryptor.NAME_COMPONENT_D_KEY);
  502.   name.append(startTimeStamp).append(endTimeStamp);
  503.   var data = new Data(name);
  504.   data.getMetaInfo().setFreshnessPeriod
  505.     (this.freshnessHours_ * GroupManager.MILLISECONDS_IN_HOUR);
  506.   var encryptParams = new EncryptParams(EncryptAlgorithmType.RsaOaep);
  507.   var thisManager = this;
  509.   return Encryptor.encryptDataPromise
  510.     (data, privateKeyBlob, keyName, certificateKey, encryptParams, useSync)
  511.   .catch(function(ex) {
  512.     // Consolidate errors such as InvalidKeyException.
  513.     return SyncPromise.reject(SecurityException(new Error
  514.       ("createDKeyData: Error in encryptData: " + ex)));
  515.   })
  516.   .then(function() {
  517.     return thisManager.keyChain_.signPromise(data);
  518.   });
  519. };
  521. /**
  522.  * Add the EKey with name eKeyName to the database.
  523.  * @param {Name} eKeyName The name of the EKey. This copies the Name.
  524.  * @param {Blob} publicKey The encoded public Key of the group key pair.
  525.  * @param {Blob} privateKey The encoded private Key of the group key pair.
  526.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  527.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  528.  * an async Promise.
  529.  * @return {Promise|SyncPromise} A promise that fulfills when the EKey is added,
  530.  * or that is rejected with GroupManagerDb.Error if a key with name eKeyName
  531.  * already exists in the database, or other database error.
  532.  */
  533. GroupManager.prototype.addEKeyPromise_ = function
  534.   (eKeyName, publicKey, privateKey, useSync)
  535. {
  536.   return this.database_.addEKeyPromise(eKeyName, publicKey, privateKey, useSync);
  537. };
  539. /**
  540.  * Get the group key pair with the name eKeyName from the database.
  541.  * @param {Name} eKeyName The name of the EKey.
  542.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  543.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  544.  * an async Promise.
  545.  * @return {Promise|SyncPromise} A promise that returns an object (where
  546.  * "publicKey" is the public key Blob and "privateKey" is the private key Blob),
  547.  * or that is rejected with GroupManagerDb.Error for a database error.
  548.  */
  549. GroupManager.prototype.getEKeyPromise_ = function(eKeyName, useSync)
  550. {
  551.   return this.database_.getEKeyPromise(eKeyName, useSync);
  552. };
  554. /**
  555.  * Delete the EKey with name eKeyName from the database. If no key with the
  556.  * name exists in the database, do nothing.
  557.  * @param {Name} eKeyName The name of the EKey.
  558.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  559.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  560.  * an async Promise.
  561.  * @return {Promise|SyncPromise} A promise that fulfills when the EKey is
  562.  * deleted (or there is no such key), or that is rejected with
  563.  * GroupManagerDb.Error for a database error.
  564.  */
  565. GroupManager.prototype.deleteEKeyPromise_ = function(eKeyName, useSync)
  566. {
  567.   return this.database_.deleteEKeyPromise(eKeyName, useSync);
  568. };
  570. GroupManager.MILLISECONDS_IN_HOUR = 3600 * 1000;