mirror of
https://github.com/the-djmaze/snappymail.git
synced 2026-09-03 14:37:02 +03:00
227 lines
6.9 KiB
JavaScript
227 lines
6.9 KiB
JavaScript
// GPG4Browsers - An OpenPGP implementation in javascript
|
|
// Copyright (C) 2011 Recurity Labs GmbH
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 3.0 of the License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
/**
|
|
* The class that deals with storage of the keyring. Currently the only option is to use HTML5 local storage.
|
|
* @requires enums
|
|
* @requires key
|
|
* @requires util
|
|
* @module keyring/keyring
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
import * as keyModule from '../key.js';
|
|
import LocalStore from './localstore.js';
|
|
|
|
/**
|
|
* Initialization routine for the keyring. This method reads the
|
|
* keyring from HTML5 local storage and initializes this instance.
|
|
* @constructor
|
|
* @param {class} [storeHandler] class implementing loadPublic(), loadPrivate(), storePublic(), and storePrivate() methods
|
|
*/
|
|
export default class Keyring
|
|
{
|
|
constructor(storeHandler) {
|
|
this.storeHandler = storeHandler || new LocalStore();
|
|
this.publicKeys = new KeyArray(this.storeHandler.loadPublic());
|
|
this.privateKeys = new KeyArray(this.storeHandler.loadPrivate());
|
|
}
|
|
|
|
/**
|
|
* Calls the storeHandler to save the keys
|
|
*/
|
|
store() {
|
|
this.storeHandler.storePublic(this.publicKeys.keys);
|
|
this.storeHandler.storePrivate(this.privateKeys.keys);
|
|
}
|
|
|
|
/**
|
|
* Clear the keyring - erase all the keys
|
|
*/
|
|
clear() {
|
|
this.publicKeys.keys = [];
|
|
this.privateKeys.keys = [];
|
|
}
|
|
|
|
/**
|
|
* Searches the keyring for keys having the specified key id
|
|
* @param {String} keyId provided as string of lowercase hex number
|
|
* withouth 0x prefix (can be 16-character key ID or fingerprint)
|
|
* @param {Boolean} deep if true search also in subkeys
|
|
* @returns {Array<module:key.Key>|null} keys found or null
|
|
*/
|
|
getKeysForId(keyId, deep) {
|
|
var result = [];
|
|
result = result.concat(this.publicKeys.getForId(keyId, deep) || []);
|
|
result = result.concat(this.privateKeys.getForId(keyId, deep) || []);
|
|
return result.length ? result : null;
|
|
}
|
|
|
|
/**
|
|
* Removes keys having the specified key id from the keyring
|
|
* @param {String} keyId provided as string of lowercase hex number
|
|
* withouth 0x prefix (can be 16-character key ID or fingerprint)
|
|
* @returns {Array<module:key.Key>|null} keys found or null
|
|
*/
|
|
removeKeysForId(keyId) {
|
|
var result = [];
|
|
result = result.concat(this.publicKeys.removeForId(keyId) || []);
|
|
result = result.concat(this.privateKeys.removeForId(keyId) || []);
|
|
return result.length ? result : null;
|
|
}
|
|
|
|
/**
|
|
* Get all public and private keys
|
|
* @returns {Array<module:key.Key>} all keys
|
|
*/
|
|
getAllKeys() {
|
|
return this.publicKeys.keys.concat(this.privateKeys.keys);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks a key to see if it matches the specified email address
|
|
* @private
|
|
* @param {String} email email address to search for
|
|
* @param {module:key.Key} key The key to be checked.
|
|
* @returns {Boolean} True if the email address is defined in the specified key
|
|
*/
|
|
function emailCheck(email, key) {
|
|
email = email.toLowerCase();
|
|
// escape email before using in regular expression
|
|
var emailEsc = email.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
var emailRegex = new RegExp('<' + emailEsc + '>');
|
|
var userIds = key.getUserIds();
|
|
for (var i = 0; i < userIds.length; i++) {
|
|
var userId = userIds[i].toLowerCase();
|
|
if (email === userId || emailRegex.test(userId)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks a key to see if it matches the specified keyid
|
|
* @private
|
|
* @param {String} keyId provided as string of lowercase hex number
|
|
* withouth 0x prefix (can be 16-character key ID or fingerprint)
|
|
* @param {module:packet/secret_key|public_key|public_subkey|secret_subkey} keypacket The keypacket to be checked
|
|
* @returns {Boolean} True if keypacket has the specified keyid
|
|
*/
|
|
function keyIdCheck(keyId, keypacket) {
|
|
if (keyId.length === 16) {
|
|
return keyId === keypacket.getKeyId().toHex();
|
|
} else {
|
|
return keyId === keypacket.getFingerprint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Array of keys
|
|
* @param {Array<module:key.Key>} keys The keys to store in this array
|
|
*/
|
|
class KeyArray
|
|
{
|
|
constructor(keys) {
|
|
this.keys = keys;
|
|
}
|
|
|
|
/**
|
|
* Searches all keys in the KeyArray matching the address or address part of the user ids
|
|
* @param {String} email email address to search for
|
|
* @returns {Array<module:key.Key>} The public keys associated with provided email address.
|
|
*/
|
|
getForAddress(email) {
|
|
var results = [];
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
if (emailCheck(email, this.keys[i])) {
|
|
results.push(this.keys[i]);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Searches the KeyArray for a key having the specified key id
|
|
* @param {String} keyId provided as string of lowercase hex number
|
|
* withouth 0x prefix (can be 16-character key ID or fingerprint)
|
|
* @param {Boolean} deep if true search also in subkeys
|
|
* @returns {module:key.Key|null} key found or null
|
|
*/
|
|
getForId(keyId, deep) {
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
if (keyIdCheck(keyId, this.keys[i].primaryKey)) {
|
|
return this.keys[i];
|
|
}
|
|
if (deep && this.keys[i].subKeys) {
|
|
for (var j = 0; j < this.keys[i].subKeys.length; j++) {
|
|
if (keyIdCheck(keyId, this.keys[i].subKeys[j].subKey)) {
|
|
return this.keys[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Imports a key from an ascii armored message
|
|
* @param {String} armored message to read the keys/key from
|
|
* @returns {Array<Error>|null} array of error objects or null
|
|
*/
|
|
importKey(armored) {
|
|
var imported = keyModule.readArmored(armored);
|
|
var that = this;
|
|
imported.keys.forEach(function(key) {
|
|
// check if key already in key array
|
|
var keyidHex = key.primaryKey.getKeyId().toHex();
|
|
var keyFound = that.getForId(keyidHex);
|
|
if (keyFound) {
|
|
keyFound.update(key);
|
|
} else {
|
|
that.push(key);
|
|
}
|
|
});
|
|
return imported.err ? imported.err : null;
|
|
}
|
|
|
|
/**
|
|
* Add key to KeyArray
|
|
* @param {module:key.Key} key The key that will be added to the keyring
|
|
* @returns {Number} The new length of the KeyArray
|
|
*/
|
|
push(key) {
|
|
return this.keys.push(key);
|
|
}
|
|
|
|
/**
|
|
* Removes a key with the specified keyid from the keyring
|
|
* @param {String} keyId provided as string of lowercase hex number
|
|
* withouth 0x prefix (can be 16-character key ID or fingerprint)
|
|
* @returns {module:key.Key|null} The key object which has been removed or null
|
|
*/
|
|
removeForId(keyId) {
|
|
for (let i = 0; i < this.keys.length; i++) {
|
|
if (keyIdCheck(keyId, this.keys[i].primaryKey)) {
|
|
return this.keys.splice(i, 1)[0];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|