suzanne.soy/fork-openpgpjs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use ES6 destructuring and default parameters in public api

Browse Source
This commit is contained in:
Tankred Hase 2016-02-05 17:23:17 +07:00
parent c75a39e9b8
commit 1997e445f9
1 changed files with 67 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
src/openpgp.js
View File

@ -54,11 +54,9 @@ let asyncProxy = null; // instance of the asyncproxy
* web worker initialized with 'openpgp.worker.js' * web worker initialized with 'openpgp.worker.js'
* @return {Boolean} true if worker created successfully * @return {Boolean} true if worker created successfully
*/ */
export function initWorker(path, options) { export function initWorker({ path='openpgp.worker.js', worker } = {}) {
if (options && options.worker || typeof window !== 'undefined' && window.Worker) { if (worker || typeof window !== 'undefined' && window.Worker) {
options = options || {}; asyncProxy = new AsyncProxy({ path, worker, config });
options.config = config;
asyncProxy = new AsyncProxy(path, options);
return true; return true;
} else { } else {
return false; return false;
@ -83,37 +81,26 @@ export function getWorker() {
* @return {Promise<String> or Promise<Packetlist>} encrypted ASCII armored message, or Packetlist if params.packets is true * @return {Promise<String> or Promise<Packetlist>} encrypted ASCII armored message, or Packetlist if params.packets is true
* @static * @static
*/ */
export function encryptMessage(keys, data, passwords, params) { export function encryptMessage({ keys, data, passwords, filename, packets } = {}) {
if (asyncProxy) { return asyncProxy.encryptMessage({ keys, data, passwords, filename, packets }); }
if (asyncProxy) { return execute(() => {
return asyncProxy.encryptMessage(keys, data, passwords, params);
}
var filename, packets; let msg;
if(params) { if (data instanceof Uint8Array) { msg = message.fromBinary(data, filename); }
filename = params.filename; else { msg = message.fromText(data, filename); }
packets = params.packets;
}
return execute(function() {
var msg;
if(data instanceof Uint8Array) {
msg = message.fromBinary(data, filename);
}
else {
msg = message.fromText(data, filename);
}
msg = msg.encrypt(keys, passwords); msg = msg.encrypt(keys, passwords);
if(packets) { if(packets) {
var dataIndex = msg.packets.indexOfTag(enums.packet.symmetricallyEncrypted, enums.packet.symEncryptedIntegrityProtected)[0];
var obj = { const dataIndex = msg.packets.indexOfTag(enums.packet.symmetricallyEncrypted,enums.packet.symEncryptedIntegrityProtected)[0];
const obj = {
keys: msg.packets.slice(0,dataIndex).write(), keys: msg.packets.slice(0,dataIndex).write(),
data: msg.packets.slice(dataIndex,msg.packets.length).write() data: msg.packets.slice(dataIndex,msg.packets.length).write()
}; };
return obj; return obj;
}
else { } else {
return armor.encode(enums.armor.message, msg.packets.write()); return armor.encode(enums.armor.message, msg.packets.write());
} }
@ -129,18 +116,11 @@ export function encryptMessage(keys, data, passwords, params) {
* @return {Promise<Packetlist>} Binary string of key packets * @return {Promise<Packetlist>} Binary string of key packets
* @static * @static
*/ */
export function encryptSessionKey(sessionKey, algo, keys, passwords) { export function encryptSessionKey({ sessionKey, algo, keys, passwords } = {}) {
if (asyncProxy) { return asyncProxy.encryptSessionKey({ sessionKey, algo, keys, passwords }); }
if (asyncProxy) { return execute(() => message.encryptSessionKey(sessionKey, algo, keys, passwords).packets.write(),
return asyncProxy.encryptSessionKey(sessionKey, algo, keys, passwords); 'Error encrypting session key!');
}
return execute(function() {
var msg = message.encryptSessionKey(sessionKey, algo, keys, passwords);
return msg.packets.write();
}, 'Error encrypting session key!');
} }
/** /**
@ -151,22 +131,17 @@ export function encryptSessionKey(sessionKey, algo, keys, passwords) {
* @return {Promise<String>} encrypted ASCII armored message * @return {Promise<String>} encrypted ASCII armored message
* @static * @static
*/ */
export function signAndEncryptMessage(publicKeys, privateKey, text) { export function signAndEncryptMessage({ publicKeys, privateKey, text } = {}) {
if (!publicKeys.length) { publicKeys = publicKeys.length ? publicKeys : [publicKeys];
publicKeys = [publicKeys];
}
if (asyncProxy) { if (asyncProxy) { return asyncProxy.signAndEncryptMessage({ publicKeys, privateKey, text }); }
return asyncProxy.signAndEncryptMessage(publicKeys, privateKey, text);
}
return execute(function() { return execute(() => {
var msg, armored;
msg = message.fromText(text); let msg = message.fromText(text);
msg = msg.sign([privateKey]); msg = msg.sign([privateKey]);
msg = msg.encrypt(publicKeys); msg = msg.encrypt(publicKeys);
armored = armor.encode(enums.armor.message, msg.packets.write()); return armor.encode(enums.armor.message, msg.packets.write());
return armored;
}, 'Error signing and encrypting message!'); }, 'Error signing and encrypting message!');
} }
@ -181,27 +156,15 @@ export function signAndEncryptMessage(publicKeys, privateKey, text) {
* or null if no literal data found * or null if no literal data found
* @static * @static
*/ */
export function decryptMessage(privateKey, msg, params) { export function decryptMessage({ privateKey, msg, binary, sessionKeyAlgorithm } = {}) {
if (asyncProxy) { if (asyncProxy) { return asyncProxy.decryptMessage({ privateKey, msg, binary, sessionKeyAlgorithm }); }
return asyncProxy.decryptMessage(privateKey, msg, params);
}
var binary, sessionKeyAlgorithm; return execute(() => {
if(params) {
binary = params.binary;
sessionKeyAlgorithm = params.sessionKeyAlgorithm;
}
return execute(function() {
msg = msg.decrypt(privateKey, sessionKeyAlgorithm); msg = msg.decrypt(privateKey, sessionKeyAlgorithm);
if(binary) { if(binary) {
var obj = { return { data: msg.getLiteralData(), filename: msg.getFilename() };
data: msg.getLiteralData(), } else {
filename: msg.getFilename()
};
return obj;
}
else {
return msg.getText(); return msg.getText();
} }
@ -216,16 +179,10 @@ export function decryptMessage(privateKey, msg, params) {
* or null if no key packets found * or null if no key packets found
* @static * @static
*/ */
export function decryptSessionKey(privateKey, msg) { export function decryptSessionKey({ privateKey, msg } = {}) {
if (asyncProxy) { if (asyncProxy) { return asyncProxy.decryptSessionKey({ privateKey, msg }); }
return asyncProxy.decryptSessionKey(privateKey, msg);
}
return execute(function() { return execute(() => msg.decryptSessionKey(privateKey), 'Error decrypting session key!');
var obj = msg.decryptSessionKey(privateKey);
return obj;
}, 'Error decrypting session key!');
} }
/** /**
@ -238,19 +195,15 @@ export function decryptSessionKey(privateKey, msg) {
* with verified signatures or null if no literal data found * with verified signatures or null if no literal data found
* @static * @static
*/ */
export function decryptAndVerifyMessage(privateKey, publicKeys, msg) { export function decryptAndVerifyMessage({ privateKey, publicKeys, msg } = {}) {
if (!publicKeys.length) { publicKeys = publicKeys.length ? publicKeys : [publicKeys];
publicKeys = [publicKeys];
}
if (asyncProxy) { if (asyncProxy) { return asyncProxy.decryptAndVerifyMessage({ privateKey, publicKeys, msg }); }
return asyncProxy.decryptAndVerifyMessage(privateKey, publicKeys, msg);
} return execute(() => {
return execute(function() {
var result = {};
msg = msg.decrypt(privateKey); msg = msg.decrypt(privateKey);
result.text = msg.getText(); const result = { text:msg.getText() };
if (result.text) { if (result.text) {
result.signatures = msg.verify(publicKeys); result.signatures = msg.verify(publicKeys);
return result; return result;
@ -267,17 +220,14 @@ export function decryptAndVerifyMessage(privateKey, publicKeys, msg) {
* @return {Promise<String>} ASCII armored message * @return {Promise<String>} ASCII armored message
* @static * @static
*/ */
export function signClearMessage(privateKeys, text) { export function signClearMessage({ privateKeys, text } = {}) {
if (!privateKeys.length) { privateKeys = privateKeys.length ? privateKeys : [privateKeys];
privateKeys = [privateKeys];
}
if (asyncProxy) { if (asyncProxy) { return asyncProxy.signClearMessage({ privateKeys, text }); }
return asyncProxy.signClearMessage(privateKeys, text);
}
return execute(function() { return execute(() => {
var cleartextMessage = new cleartext.CleartextMessage(text);
const cleartextMessage = new cleartext.CleartextMessage(text);
cleartextMessage.sign(privateKeys); cleartextMessage.sign(privateKeys);
return cleartextMessage.armor(); return cleartextMessage.armor();
@ -292,23 +242,15 @@ export function signClearMessage(privateKeys, text) {
* cleartext with status of verified signatures * cleartext with status of verified signatures
* @static * @static
*/ */
export function verifyClearSignedMessage(publicKeys, msg) { export function verifyClearSignedMessage({ publicKeys, msg } = {}) {
if (!publicKeys.length) { publicKeys = publicKeys.length ? publicKeys : [publicKeys];
publicKeys = [publicKeys];
}
if (asyncProxy) { if (asyncProxy) { return asyncProxy.verifyClearSignedMessage({ publicKeys, msg }); }
return asyncProxy.verifyClearSignedMessage(publicKeys, msg);
}
return execute(function() { return execute(() => {
var result = {};
if (!(msg instanceof cleartext.CleartextMessage)) { if (!(msg instanceof cleartext.CleartextMessage)) { throw new Error('Parameter [message] needs to be of type CleartextMessage.'); }
throw new Error('Parameter [message] needs to be of type CleartextMessage.'); return { text:msg.getText(), signatures:msg.verify(publicKeys) };
}
result.text = msg.getText();
result.signatures = msg.verify(publicKeys);
return result;
}, 'Error verifying cleartext signed message!'); }, 'Error verifying cleartext signed message!');
} }
@ -325,27 +267,23 @@ export function verifyClearSignedMessage(publicKeys, msg) {
* @return {Promise<Object>} {key: module:key~Key, privateKeyArmored: String, publicKeyArmored: String} * @return {Promise<Object>} {key: module:key~Key, privateKeyArmored: String, publicKeyArmored: String}
* @static * @static
*/ */
export function generateKeyPair(options) { export function generateKeyPair({ numBits=2048, userId, passphrase, unlocked=false } = {}) {
const options = { numBits, userId, passphrase, unlocked };
// use web worker if web crypto apis are not supported // use web worker if web crypto apis are not supported
if (!util.getWebCrypto() && asyncProxy) { if (!util.getWebCrypto() && asyncProxy) { return asyncProxy.generateKeyPair(options); }
return asyncProxy.generateKeyPair(options);
}
return key.generate(options).then(function(newKey) { return key.generate(options).then(newKey => ({
var result = {};
result.key = newKey;
result.privateKeyArmored = newKey.armor();
result.publicKeyArmored = newKey.toPublic().armor();
return result;
}).catch(function(err) { key: newKey,
privateKeyArmored: newKey.armor(),
publicKeyArmored: newKey.toPublic().armor()
})).catch(err => {
// js fallback already tried
console.error(err); console.error(err);
if (!util.getWebCrypto()) { throw new Error('Error generating keypair using js fallback!'); }
if (!util.getWebCrypto()) {
// js fallback already tried
throw new Error('Error generating keypair using js fallback!');
}
// fall back to js keygen in a worker // fall back to js keygen in a worker
console.log('Error generating keypair using native WebCrypto... falling back back to js!'); console.log('Error generating keypair using native WebCrypto... falling back back to js!');
return asyncProxy.generateKeyPair(options); return asyncProxy.generateKeyPair(options);
@ -366,11 +304,7 @@ export function generateKeyPair(options) {
*/ */
function execute(cmd, errMsg) { function execute(cmd, errMsg) {
// wrap the sync cmd in a promise // wrap the sync cmd in a promise
var promise = new Promise(function(resolve) { const promise = new Promise(resolve => resolve(cmd()));
var result = cmd();
resolve(result);
});
// handler error globally // handler error globally
return promise.catch(onError.bind(null, errMsg)); return promise.catch(onError.bind(null, errMsg));
} }
@ -383,9 +317,7 @@ function execute(cmd, errMsg) {
*/ */
function onError(message, error) { function onError(message, error) {
// log the stack trace // log the stack trace
if (config.debug) { if (config.debug) { console.error(error.stack); }
console.error(error.stack);
}
// rethrow new high level error for api users // rethrow new high level error for api users
throw new Error(message); throw new Error(message);
} }