mirrors/CyberChef
1
0
Fork 0
mirror of https://github.com/gchq/CyberChef.git synced 2025-05-06 22:47:11 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Clean up really bad promise code in PGP ops

Browse source
This commit is contained in:
toby 2017-04-12 17:17:08 -04:00
parent f1be229b87
commit 057fb20ea4
1 changed files with 344 additions and 367 deletions
Download patch file Download diff file Expand all files Collapse all files

711
src/js/operations/PGP.js
View file

@ -42,25 +42,23 @@ var PGP = {
runEncrypt: function (plaintext, args) { runEncrypt: function (plaintext, args) {
var publicKey = args[0]; var publicKey = args[0];
return new Promise(function(resolve, reject) { try {
try { var publicKeys = openpgp.key.readArmored(publicKey).keys;
var publicKeys = openpgp.key.readArmored(publicKey).keys; } catch (err) {
} catch (err) { throw "Cannot read public key: " + err;
return reject("Cannot read public key: " + err); }
}
var options = { var options = {
data: plaintext, data: plaintext,
publicKeys: publicKeys, publicKeys: publicKeys,
}; };
openpgp.encrypt(options) return openpgp.encrypt(options)
.then(function(ciphertext) { .then(function(ciphertext) {
resolve(ciphertext.data); return ciphertext.data;
}) })
.catch(function(err) { .catch(function(err) {
reject("Could not encrypt text: " + err); throw "Could not encrypt text: " + err;
});
}); });
}, },
@ -76,38 +74,36 @@ var PGP = {
var privateKey = args[0], var privateKey = args[0],
password = args[1]; password = args[1];
return new Promise(function(resolve, reject) { try {
try { privateKey = openpgp.key.readArmored(privateKey).keys[0];
privateKey = openpgp.key.readArmored(privateKey).keys[0]; } catch (err) {
} catch (err) { throw "Cannot read private key: " + err;
return reject("Cannot read private key: " + err); }
}
try { try {
var message = openpgp.message.readArmored(input); var message = openpgp.message.readArmored(input);
} catch (err) { } catch (err) {
return reject("Cannot read message: " + err); throw "Cannot read message: " + err;
} }
var options = { var options = {
message: message, message: message,
privateKey: privateKey, privateKey: privateKey,
}; };
if (password) { if (password) {
privateKey.decrypt(password); privateKey.decrypt(password);
} }
if (privateKey.primaryKey.encrypted !== null) { if (privateKey.primaryKey.encrypted !== null) {
return reject("Could not decrypt private key."); throw "Could not decrypt private key.";
} }
openpgp.decrypt(options) return openpgp.decrypt(options)
.then(function(plaintext) { .then(function(plaintext) {
resolve(plaintext.data); return plaintext.data;
}) })
.catch(function(err) { .catch(function(err) {
reject("Could not decrypt message: " + err); throw "Could not decrypt message: " + err;
});
}); });
}, },
@ -124,39 +120,37 @@ var PGP = {
privateKey = args[1], privateKey = args[1],
password = args[2]; password = args[2];
return new Promise(function(resolve, reject) { try {
try { var publicKeys = openpgp.key.readArmored(publicKey).keys;
var publicKeys = openpgp.key.readArmored(publicKey).keys; } catch (err) {
} catch (err) { throw "Could not read public key: " + err;
return reject("Could not read public key: " + err); }
}
try { try {
var privateKeys = openpgp.key.readArmored(privateKey).keys; var privateKeys = openpgp.key.readArmored(privateKey).keys;
} catch (err) { } catch (err) {
return reject("Could not read private key: " + err); throw "Could not read private key: " + err;
} }
if (password) { if (password) {
privateKeys[0].decrypt(password); privateKeys[0].decrypt(password);
} }
if (privateKeys[0].primaryKey.encrypted !== null) { if (privateKeys[0].primaryKey.encrypted !== null) {
return reject("Could not decrypt private key."); throw "Could not decrypt private key.";
} }
var options = { var options = {
data: input, data: input,
publicKeys: publicKeys, publicKeys: publicKeys,
privateKeys: privateKeys, privateKeys: privateKeys,
}; };
openpgp.encrypt(options) return openpgp.encrypt(options)
.then(function(signedData) { .then(function(signedData) {
resolve(signedData.data); return signedData.data;
}) })
.catch(function(err) { .catch(function(err) {
reject("Could not sign input: " + err); throw "Could not sign input: " + err;
});
}); });
}, },
@ -173,75 +167,73 @@ var PGP = {
privateKey = args[1], privateKey = args[1],
password = args[2]; password = args[2];
return new Promise(function(resolve, reject) { try {
try { var publicKeys = openpgp.key.readArmored(publicKey).keys;
var publicKeys = openpgp.key.readArmored(publicKey).keys; } catch (err) {
} catch (err) { throw "Could not read public key: " + err;
return reject("Could not read public key: " + err); }
try {
var privateKeys = openpgp.key.readArmored(privateKey).keys;
} catch (err) {
throw "Could not read private key: " + err;
}
if (password) {
privateKeys[0].decrypt(password);
}
if (privateKeys[0].primaryKey.encrypted !== null) {
throw "Could not decrypt private key.";
}
try {
var message = openpgp.message.readArmored(input);
} catch (err) {
throw "Could not read encrypted message: " + err;
}
var packetContainingAlgorithms = message.packets.filterByTag(
openpgp.enums.packet.publicKeyEncryptedSessionKey
)[0];
var verification = {
verified: false,
pkAlgorithm: packetContainingAlgorithms.publicKeyAlgorithm,
sessionAlgorithm: packetContainingAlgorithms.sessionKeyAlgorithm,
author: publicKeys[0].users[0].userId.userid,
recipient: privateKeys[0].users[0].userId.userid,
keyID: "",
message: "",
};
return openpgp.decrypt({
message: message,
publicKeys: publicKeys,
privateKey: privateKeys[0],
})
.then(function(decrypted) {
if (decrypted.signatures) {
// valid is either true or null, casting required.
verification.verified = !!decrypted.signatures[0].valid;
verification.keyID = decrypted.signatures[0].keyid.toHex();
} }
try { return [
var privateKeys = openpgp.key.readArmored(privateKey).keys; "Verified: " + verification.verified,
} catch (err) { "Key ID: " + verification.keyID,
return reject("Could not read private key: " + err); "Encrypted for: " + verification.recipient,
} "Signed by: " + verification.author,
"Signed with: " +
verification.pkAlgorithm +
"/" +
verification.sessionAlgorithm,
"\n",
decrypted.data,
].join("\n");
if (password) { })
privateKeys[0].decrypt(password); .catch(function(err) {
} throw "Could not decrypt and verify message: " + err;
if (privateKeys[0].primaryKey.encrypted !== null) {
return reject("Could not decrypt private key.");
}
try {
var message = openpgp.message.readArmored(input);
} catch (err) {
return reject("Could not read encrypted message: " + err);
}
var packetContainingAlgorithms = message.packets.filterByTag(
openpgp.enums.packet.publicKeyEncryptedSessionKey
)[0];
var verification = {
verified: false,
pkAlgorithm: packetContainingAlgorithms.publicKeyAlgorithm,
sessionAlgorithm: packetContainingAlgorithms.sessionKeyAlgorithm,
author: publicKeys[0].users[0].userId.userid,
recipient: privateKeys[0].users[0].userId.userid,
keyID: "",
message: "",
};
openpgp.decrypt({
message: message,
publicKeys: publicKeys,
privateKey: privateKeys[0],
})
.then(function(decrypted) {
if (decrypted.signatures) {
// valid is either true or null, casting required.
verification.verified = !!decrypted.signatures[0].valid;
verification.keyID = decrypted.signatures[0].keyid.toHex();
}
resolve([
"Verified: " + verification.verified,
"Key ID: " + verification.keyID,
"Encrypted for: " + verification.recipient,
"Signed by: " + verification.author,
"Signed with: " +
verification.pkAlgorithm +
"/" +
verification.sessionAlgorithm,
"\n",
decrypted.data,
].join("\n"));
})
.catch(function(err) {
reject("Could not decrypt and verify message: " + err);
});
}); });
}, },
@ -257,59 +249,57 @@ var PGP = {
var privateKey = args[0], var privateKey = args[0],
password = args[1]; password = args[1];
return new Promise(function(resolve, reject) { try {
try { var privateKeys = openpgp.key.readArmored(privateKey).keys;
var privateKeys = openpgp.key.readArmored(privateKey).keys; } catch (err) {
} catch (err) { throw "Could not read private key: " + err;
return reject("Could not read private key: " + err); }
}
if (password) { if (password) {
privateKeys[0].decrypt(password); privateKeys[0].decrypt(password);
} }
if (privateKeys[0].primaryKey.encrypted !== null) { if (privateKeys[0].primaryKey.encrypted !== null) {
return reject("Could not decrypt private key."); throw "Could not decrypt private key.";
} }
var bytes = openpgp.util.str2Uint8Array(input); var bytes = openpgp.util.str2Uint8Array(input);
var message = openpgp.message.fromBinary(bytes); var message = openpgp.message.fromBinary(bytes);
var signedMessage = message.sign(privateKeys); var signedMessage = message.sign(privateKeys);
var signature = signedMessage.packets.filterByTag(openpgp.enums.packet.signature); var signature = signedMessage.packets.filterByTag(openpgp.enums.packet.signature);
var rawSignatureBytes = signature.write(); var rawSignatureBytes = signature.write();
var armouredMessage = openpgp.armor.encode( var armouredMessage = openpgp.armor.encode(
openpgp.enums.armor.message, openpgp.enums.armor.message,
rawSignatureBytes rawSignatureBytes
); );
armouredMessage = armouredMessage.replace( armouredMessage = armouredMessage.replace(
"-----BEGIN PGP MESSAGE-----\r\n", "-----BEGIN PGP MESSAGE-----\r\n",
"-----BEGIN PGP SIGNATURE-----\r\n" "-----BEGIN PGP SIGNATURE-----\r\n"
); );
armouredMessage = armouredMessage.replace( armouredMessage = armouredMessage.replace(
"-----END PGP MESSAGE-----\r\n", "-----END PGP MESSAGE-----\r\n",
"-----END PGP SIGNATURE-----\r\n" "-----END PGP SIGNATURE-----\r\n"
); );
var files = [{ var files = [{
fileName: "msg", fileName: "msg",
size: input.length, size: input.length,
contents: input, contents: input,
bytes: bytes, bytes: bytes,
}, { }, {
fileName: "msg.asc", fileName: "msg.asc",
size: armouredMessage.length, size: armouredMessage.length,
contents: armouredMessage, contents: armouredMessage,
bytes: openpgp.util.str2Uint8Array(armouredMessage), bytes: openpgp.util.str2Uint8Array(armouredMessage),
}, { }, {
fileName: "msg.sig", fileName: "msg.sig",
size: rawSignatureBytes.length, size: rawSignatureBytes.length,
contents: openpgp.util.Uint8Array2str(rawSignatureBytes), contents: openpgp.util.Uint8Array2str(rawSignatureBytes),
bytes: rawSignatureBytes, bytes: rawSignatureBytes,
}]; }];
resolve(Utils.displayFilesAsHTML(files)); return Utils.displayFilesAsHTML(files);
});
}, },
@ -324,57 +314,55 @@ var PGP = {
var publicKey = args[0], var publicKey = args[0],
armouredSignature = args[1]; armouredSignature = args[1];
return new Promise(function(resolve, reject) { try {
try { var publicKeys = openpgp.key.readArmored(publicKey).keys;
var publicKeys = openpgp.key.readArmored(publicKey).keys; } catch (err) {
} catch (err) { throw "Could not read public key: " + err;
return reject("Could not read public key: " + err); }
try {
var message = openpgp.message.readSignedContent(
input,
armouredSignature
);
} catch (err) {
throw "Could not read armoured signature or message: " + err;
}
var packetContainingSignature = message.packets.filterByTag(
openpgp.enums.packet.signature
)[0];
var verification = {
verified: false,
pkAlgorithm: publicKeys[0].primaryKey.algorithm,
author: publicKeys[0].users[0].userId.userid,
date: packetContainingSignature.created,
keyID: "",
message: "",
};
return Promise.resolve(message.verify(publicKeys))
.then(function(signatures) {
if (signatures && signatures.length) {
verification.verified = !!signatures[0].valid;
verification.keyID = signatures[0].keyid.toHex();
} }
try { return [
var message = openpgp.message.readSignedContent( "Verified: " + verification.verified,
input, "Key ID: " + verification.keyID,
armouredSignature "Signed on: " + verification.date,
); "Signed by: " + verification.author,
} catch (err) { "Signed with: " + verification.pkAlgorithm,
return reject("Could not read armoured signature or message: " + err); "\n",
} input,
].join("\n");
var packetContainingSignature = message.packets.filterByTag( })
openpgp.enums.packet.signature .catch(function(err) {
)[0]; throw "Could not verify message: " + err;
var verification = {
verified: false,
pkAlgorithm: publicKeys[0].primaryKey.algorithm,
author: publicKeys[0].users[0].userId.userid,
date: packetContainingSignature.created,
keyID: "",
message: "",
};
Promise.resolve(message.verify(publicKeys))
.then(function(signatures) {
if (signatures && signatures.length) {
verification.verified = !!signatures[0].valid;
verification.keyID = signatures[0].keyid.toHex();
}
resolve([
"Verified: " + verification.verified,
"Key ID: " + verification.keyID,
"Signed on: " + verification.date,
"Signed by: " + verification.author,
"Signed with: " + verification.pkAlgorithm,
"\n",
input,
].join("\n"));
})
.catch(function(err) {
reject("Could not verify message: " + err);
});
}); });
}, },
@ -390,33 +378,30 @@ var PGP = {
var privateKey = args[0], var privateKey = args[0],
password = args[1]; password = args[1];
try {
var privateKeys = openpgp.key.readArmored(privateKey).keys;
} catch (err) {
throw "Could not read private key: " + err;
}
return new Promise(function(resolve, reject) { if (password) {
try { privateKeys[0].decrypt(password);
var privateKeys = openpgp.key.readArmored(privateKey).keys; }
} catch (err) { if (privateKeys[0].primaryKey.encrypted !== null) {
return reject("Could not read private key: " + err); throw "Could not decrypt private key.";
} }
if (password) { var options = {
privateKeys[0].decrypt(password); data: input,
} privateKeys: privateKeys,
if (privateKeys[0].primaryKey.encrypted !== null) { };
return reject("Could not decrypt private key.");
}
var options = { return openpgp.sign(options)
data: input, .then(function(signedData) {
privateKeys: privateKeys, return signedData.data;
}; })
.catch(function(err) {
openpgp.sign(options) throw "Could not clearsign input: " + err;
.then(function(signedData) {
resolve(signedData.data);
})
.catch(function(err) {
reject("Could not clearsign input: " + err);
});
}); });
}, },
@ -431,58 +416,54 @@ var PGP = {
runVerifyCleartext: function (input, args) { runVerifyCleartext: function (input, args) {
var publicKey = args[0]; var publicKey = args[0];
return new Promise(function(resolve, reject) { try {
var publicKeys = openpgp.key.readArmored(publicKey).keys;
} catch (err) {
throw "Could not read public key: " + err;
}
try { try {
var publicKeys = openpgp.key.readArmored(publicKey).keys; var message = openpgp.cleartext.readArmored(input);
} catch (err) { } catch (err) {
return reject("Could not read public key: " + err); throw "Could not read input message: " + err;
}
var packetContainingSignature = message.packets.filterByTag(
openpgp.enums.packet.signature
)[0];
var verification = {
verified: false,
pkAlgorithm: publicKeys[0].primaryKey.algorithm,
author: publicKeys[0].users[0].userId.userid,
date: packetContainingSignature.created,
keyID: "",
message: message.text,
};
return openpgp.verify({
message: message,
publicKeys: publicKeys,
})
.then(function(verifiedData) {
if (verifiedData.signatures) {
// valid is either true or null, casting required.
verification.verified = !!verifiedData.signatures[0].valid;
verification.keyID = verifiedData.signatures[0].keyid.toHex();
} }
try { return [
var message = openpgp.cleartext.readArmored(input); "Verified: " + verification.verified,
} catch (err) { "Key ID: " + verification.keyID,
return reject("Could not read input message: " + err); "Signed on: " + verification.date,
} "Signed by: " + verification.author,
"Signed with: " + verification.pkAlgorithm,
var packetContainingSignature = message.packets.filterByTag( "\n",
openpgp.enums.packet.signature verification.message,
)[0]; ].join("\n");
})
var verification = { .catch(function(err) {
verified: false, throw "Could not verify message: " + err;
pkAlgorithm: publicKeys[0].primaryKey.algorithm,
author: publicKeys[0].users[0].userId.userid,
date: packetContainingSignature.created,
keyID: "",
message: message.text,
};
openpgp.verify({
message: message,
publicKeys: publicKeys,
})
.then(function(verifiedData) {
if (verifiedData.signatures) {
// valid is either true or null, casting required.
verification.verified = !!verifiedData.signatures[0].valid;
verification.keyID = verifiedData.signatures[0].keyid.toHex();
}
resolve([
"Verified: " + verification.verified,
"Key ID: " + verification.keyID,
"Signed on: " + verification.date,
"Signed by: " + verification.author,
"Signed with: " + verification.pkAlgorithm,
"\n",
verification.message,
].join("\n"));
})
.catch(function(err) {
reject("Could not verify message: " + err);
});
}); });
}, },
@ -500,27 +481,25 @@ var PGP = {
name = args[2], name = args[2],
email = args[3]; email = args[3];
return new Promise(function(resolve, reject) { var options = {
var options = { numBits: keySize,
numBits: keySize, userIds: [{name: name, email: email}],
userIds: [{name: name, email: email}], };
};
if (password) { if (password) {
options.passphrase = password; options.passphrase = password;
} }
openpgp.generateKey(options) throw openpgp.generateKey(options)
.then(function(key) { .then(function(key) {
var output = [ var output = [
key.publicKeyArmored, key.publicKeyArmored,
key.privateKeyArmored, key.privateKeyArmored,
].join(""); // Preceding and trailing newlines are already generated. ].join(""); // Preceding and trailing newlines are already generated.
resolve(output); return output;
}) })
.catch(function(err) { .catch(function(err) {
reject("Could not generate key pair: " + err); throw "Could not generate key pair: " + err;
});
}); });
}, },
@ -533,51 +512,49 @@ var PGP = {
* @returns {HTML} - HTML file display of message, armoured signature, and bytes signature * @returns {HTML} - HTML file display of message, armoured signature, and bytes signature
*/ */
runDetachClearsig: function (input, args) { runDetachClearsig: function (input, args) {
return new Promise(function(resolve, reject) { try {
try { var message = openpgp.cleartext.readArmored(input);
var message = openpgp.cleartext.readArmored(input); } catch (err) {
} catch (err) { throw "Could not read input message: " + err;
return reject("Could not read input message: " + err); }
}
var cleartext = message.getText(); var cleartext = message.getText();
var clearbytes = openpgp.util.str2Uint8Array(cleartext); var clearbytes = openpgp.util.str2Uint8Array(cleartext);
var signature = message.packets.filterByTag(openpgp.enums.packet.signature); var signature = message.packets.filterByTag(openpgp.enums.packet.signature);
var rawSignatureBytes = signature.write(); var rawSignatureBytes = signature.write();
var armouredMessage = openpgp.armor.encode( var armouredMessage = openpgp.armor.encode(
openpgp.enums.armor.message, openpgp.enums.armor.message,
rawSignatureBytes rawSignatureBytes
); );
armouredMessage = armouredMessage.replace( armouredMessage = armouredMessage.replace(
"-----BEGIN PGP MESSAGE-----\r\n", "-----BEGIN PGP MESSAGE-----\r\n",
"-----BEGIN PGP SIGNATURE-----\r\n" "-----BEGIN PGP SIGNATURE-----\r\n"
); );
armouredMessage = armouredMessage.replace( armouredMessage = armouredMessage.replace(
"-----END PGP MESSAGE-----\r\n", "-----END PGP MESSAGE-----\r\n",
"-----END PGP SIGNATURE-----\r\n" "-----END PGP SIGNATURE-----\r\n"
); );
var files = [{ var files = [{
fileName: "msg", fileName: "msg",
size: cleartext.length, size: cleartext.length,
contents: cleartext, contents: cleartext,
bytes: clearbytes, bytes: clearbytes,
}, { }, {
fileName: "msg.asc", fileName: "msg.asc",
size: armouredMessage.length, size: armouredMessage.length,
contents: armouredMessage, contents: armouredMessage,
bytes: openpgp.util.str2Uint8Array(armouredMessage), bytes: openpgp.util.str2Uint8Array(armouredMessage),
}, { }, {
fileName: "msg.sig", fileName: "msg.sig",
size: rawSignatureBytes.length, size: rawSignatureBytes.length,
contents: openpgp.util.Uint8Array2str(rawSignatureBytes), contents: openpgp.util.Uint8Array2str(rawSignatureBytes),
bytes: rawSignatureBytes, bytes: rawSignatureBytes,
}]; }];
resolve(Utils.displayFilesAsHTML(files)); return Utils.displayFilesAsHTML(files);
});
}, },