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

Use generic AsyncProxy.delegate for all public apis

Browse Source
This commit is contained in:
Tankred Hase 2016-02-09 09:15:52 +07:00
parent f5375ef700
commit 994b8d2354
3 changed files with 41 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/openpgp.js
View File

@ -213,7 +213,7 @@ export function sign({ data, privateKeys }) {
privateKeys = toArray(privateKeys);
if (asyncProxy) { // use web worker if available
return asyncProxy.sign({ data, privateKeys });
return asyncProxy.delegate('sign', { data, privateKeys });
}
return execute(() => {
@ -240,7 +240,7 @@ export function verify({ message, publicKeys }) {
publicKeys = toArray(publicKeys);
if (asyncProxy) { // use web worker if available
return asyncProxy.verify({ message, publicKeys });
return asyncProxy.delegate('verify', { message, publicKeys });
}
return execute(() => ({
@ -270,7 +270,7 @@ export function verify({ message, publicKeys }) {
*/
export function encryptSessionKey({ sessionKey, algo, publicKeys, passwords }) {
if (asyncProxy) { // use web worker if available
return asyncProxy.encryptSessionKey({ sessionKey, algo, publicKeys, passwords });
return asyncProxy.delegate('encryptSessionKey', { sessionKey, algo, publicKeys, passwords });
}
return execute(() => ({
@ -294,7 +294,7 @@ export function encryptSessionKey({ sessionKey, algo, publicKeys, passwords }) {
*/
export function decryptSessionKey({ message, privateKey, sessionKey, password }) {
if (asyncProxy) { // use web worker if available
return asyncProxy.decryptSessionKey({ message, privateKey, sessionKey, password });
return asyncProxy.delegate('decryptSessionKey', { message, privateKey, sessionKey, password });
}
return execute(() => message.decryptSessionKey(privateKey, sessionKey, password), 'Error decrypting session key');

72
src/worker/async_proxy.js
View File

@ -167,78 +167,6 @@ function parseClonedPackets(data) {
return data;
}
AsyncProxy.prototype.encryptSessionKey = function({ sessionKey, algo, keys, passwords }) {
return this.execute(() => {
if(keys) {
keys = keys.length ? keys : [keys];
keys = keys.map(key => key.toPacketlist());
}
this.worker.postMessage({ event:'encrypt-session-key', sessionKey, algo, keys, passwords });
});
};
AsyncProxy.prototype.decryptSessionKey = function(privateKey, message) {
var self = this;
return self.execute(function() {
if(!(String.prototype.isPrototypeOf(privateKey) || typeof privateKey === 'string')) {
privateKey = privateKey.toPacketlist();
}
self.worker.postMessage({
event: 'decrypt-session-key',
privateKey: privateKey,
message: message
});
});
};
AsyncProxy.prototype.signClearMessage = function(privateKeys, text) {
var self = this;
return self.execute(function() {
if (!privateKeys.length) {
privateKeys = [privateKeys];
}
privateKeys = privateKeys.map(function(key) {
return key.toPacketlist();
});
self.worker.postMessage({
event: 'sign-clear-message',
privateKeys: privateKeys,
text: text
});
});
};
AsyncProxy.prototype.verifyClearSignedMessage = function(publicKeys, message) {
var self = this;
var promise = new Promise(function(resolve, reject) {
if (!publicKeys.length) {
publicKeys = [publicKeys];
}
publicKeys = publicKeys.map(function(key) {
return key.toPacketlist();
});
self.worker.postMessage({
event: 'verify-clear-signed-message',
publicKeys: publicKeys,
message: message
});
self.tasks.push({ resolve:function(data) {
data.signatures = data.signatures.map(function(sig) {
sig.keyid = type_keyid.fromClone(sig.keyid);
return sig;
});
resolve(data);
}, reject:reject });
});
return promise;
};
AsyncProxy.prototype.decryptKey = function(privateKey, password) {
var self = this;

108
src/worker/worker.js
View File

@ -69,64 +69,6 @@ self.onmessage = function (event) {
window.openpgp.crypto.random.randomBuffer.set(msg.buf);
break;
case 'generateKey':
case 'encrypt':
case 'decrypt':
// parse cloned packets
window.openpgp[msg.event](parseClonedPackets(opt)).then(function(data) {
// clone packets (for web worker structured cloning algorithm)
response({ event:'method-return', data:clonePackets(data) });
}).catch(function(e) {
response({ event:'method-return', err:e.message });
});
break;
case 'encrypt-session-key':
if(msg.keys) {
msg.keys = msg.keys.map(packetlistCloneToKey);
}
window.openpgp.encryptSessionKey(msg.sessionKey, msg.algo, msg.keys, msg.passwords).then(function(data) {
response({event: 'method-return', data: data});
}).catch(function(e) {
response({event: 'method-return', err: e.message});
});
break;
case 'decrypt-session-key':
if(!(String.prototype.isPrototypeOf(msg.privateKey) || typeof msg.privateKey === 'string')) {
msg.privateKey = packetlistCloneToKey(msg.privateKey);
}
msg.message = packetlistCloneToMessage(msg.message.packets);
window.openpgp.decryptSessionKey(msg.privateKey, msg.message).then(function(data) {
response({event: 'method-return', data: data});
}).catch(function(e) {
response({event: 'method-return', err: e.message});
});
break;
case 'sign-clear-message':
msg.privateKeys = msg.privateKeys.map(packetlistCloneToKey);
window.openpgp.signClearMessage(msg.privateKeys, msg.text).then(function(data) {
response({event: 'method-return', data: data});
}).catch(function(e) {
response({event: 'method-return', err: e.message});
});
break;
case 'verify-clear-signed-message':
if (!msg.publicKeys.length) {
msg.publicKeys = [msg.publicKeys];
}
msg.publicKeys = msg.publicKeys.map(packetlistCloneToKey);
var packetlist = window.openpgp.packet.List.fromStructuredClone(msg.message.packets);
msg.message = new window.openpgp.cleartext.CleartextMessage(msg.message.text, packetlist);
window.openpgp.verifyClearSignedMessage(msg.publicKeys, msg.message).then(function(data) {
response({event: 'method-return', data: data});
}).catch(function(e) {
response({event: 'method-return', err: e.message});
});
break;
case 'decrypt-key':
try {
msg.privateKey = packetlistCloneToKey(msg.privateKey);
@ -158,12 +100,28 @@ self.onmessage = function (event) {
response({event: 'method-return', data: data, err: err});
break;
case 'generateKey':
case 'encrypt':
case 'decrypt':
case 'sign':
case 'verify':
case 'encryptSessionKey':
case 'decryptSessionKey':
// parse cloned packets
window.openpgp[msg.event](parseClonedPackets(opt, msg.event)).then(function(data) {
// clone packets (for web worker structured cloning algorithm)
response({ event:'method-return', data:clonePackets(data) });
}).catch(function(e) {
response({ event:'method-return', err:e.message });
});
break;
default:
throw new Error('Unknown Worker Event.');
}
};
function parseClonedPackets(options) {
function parseClonedPackets(options, method) {
if(options.publicKeys) {
options.publicKeys = options.publicKeys.map(packetlistCloneToKey);
}
@ -173,12 +131,30 @@ function parseClonedPackets(options) {
if(options.privateKey) {
options.privateKey = packetlistCloneToKey(options.privateKey);
}
if (options.message) {
options.message = packetlistCloneToMessage(options.message.packets);
// parse message depending on method
if (options.message && method === 'verify') {
options.message = packetlistCloneToCleartextMessage(options.message);
} else if (options.message) {
options.message = packetlistCloneToMessage(options.message);
}
return options;
}
function packetlistCloneToKey(packetlistClone) {
var packetlist = window.openpgp.packet.List.fromStructuredClone(packetlistClone);
return new window.openpgp.key.Key(packetlist);
}
function packetlistCloneToMessage(message) {
var packetlist = window.openpgp.packet.List.fromStructuredClone(message.packets);
return new window.openpgp.message.Message(packetlist);
}
function packetlistCloneToCleartextMessage(message) {
var packetlist = window.openpgp.packet.List.fromStructuredClone(message.packets);
return new window.openpgp.cleartext.CleartextMessage(message.text, packetlist);
}
function clonePackets(data) {
if (data.key) {
data.key = data.key.toPacketlist();
@ -192,13 +168,3 @@ function response(event) {
}
postMessage(event);
}
function packetlistCloneToKey(packetlistClone) {
var packetlist = window.openpgp.packet.List.fromStructuredClone(packetlistClone);
return new window.openpgp.key.Key(packetlist);
}
function packetlistCloneToMessage(packetlistClone) {
var packetlist = window.openpgp.packet.List.fromStructuredClone(packetlistClone);
return new window.openpgp.message.Message(packetlist);
}