Mirror
/
CyberChef
mirror of https://github.com/gchq/CyberChef.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix linting in PGP operations

This commit is contained in:
tlwr 2017-11-26 20:13:49 +00:00
parent 60c8da7bbb
commit dcd8f98e8c
1 changed files with 84 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
src/core/operations/PGP.js
View File

@ -23,23 +23,23 @@ const PGP = {
* @returns {Integer} * @returns {Integer}
*/ */
validateKeySize(keySize, keyType) { validateKeySize(keySize, keyType) {
if (KEY_SIZES.indexOf(keySize) < 0) { if (KEY_SIZES.indexOf(keySize) < 0) {
throw `Invalid key size ${keySize}, must be in ${JSON.stringify(KEY_SIZES)}`; throw `Invalid key size ${keySize}, must be in ${JSON.stringify(KEY_SIZES)}`;
} }
if (keyType === "ecc") { if (keyType === "ecc") {
if (ECC_SIZES.indexOf(keySize) >= 0) { if (ECC_SIZES.indexOf(keySize) >= 0) {
return parseInt(keySize, 10); return parseInt(keySize, 10);
} else { } else {
throw `Invalid key size ${keySize}, must be in ${JSON.stringify(ECC_SIZES)} for ECC`; throw `Invalid key size ${keySize}, must be in ${JSON.stringify(ECC_SIZES)} for ECC`;
} }
} else { } else {
if (RSA_SIZES.indexOf(keySize) >= 0) { if (RSA_SIZES.indexOf(keySize) >= 0) {
return parseInt(keySize, 10); return parseInt(keySize, 10);
} else { } else {
throw `Invalid key size ${keySize}, must be in ${JSON.stringify(RSA_SIZES)} for RSA`; throw `Invalid key size ${keySize}, must be in ${JSON.stringify(RSA_SIZES)} for RSA`;
} }
} }
}, },
/** /**
@ -48,13 +48,13 @@ const PGP = {
* @returns {Integer} * @returns {Integer}
*/ */
getSubkeySize(keySize) { getSubkeySize(keySize) {
return { return {
1024: 1024, 1024: 1024,
2048: 1024, 2048: 1024,
4096: 2048, 4096: 2048,
256: 256, 256: 256,
384: 256, 384: 256,
}[keySize] }[keySize];
}, },
@ -67,7 +67,7 @@ const PGP = {
*/ */
validateKeyType(keyType) { validateKeyType(keyType) {
if (KEY_TYPES.indexOf(keyType) >= 0) return keyType.toLowerCase(); if (KEY_TYPES.indexOf(keyType) >= 0) return keyType.toLowerCase();
throw `Invalid key type ${keyType}, must be in ${JSON.stringify(KEY_TYPES)}`; throw `Invalid key type ${keyType}, must be in ${JSON.stringify(KEY_TYPES)}`;
}, },
/** /**
@ -79,76 +79,76 @@ const PGP = {
* @returns {string} * @returns {string}
*/ */
runGenerateKeyPair(input, args) { runGenerateKeyPair(input, args) {
let keyType = args[0], let keyType = args[0],
keySize = args[1], keySize = args[1],
password = args[2], password = args[2],
name = args[3], name = args[3],
email = args[4]; email = args[4];
keyType = PGP.validateKeyType(keyType);
keySize = PGP.validateKeySize(keySize, keyType);
let userIdentifier = ""; keyType = PGP.validateKeyType(keyType);
if (name) userIdentifier += name; keySize = PGP.validateKeySize(keySize, keyType);
if (email) userIdentifier += ` <${email}>`;
let flags = kbpgp.const.openpgp.certify_keys; let userIdentifier = "";
flags = flags | kbpgp.const.openpgp.sign_data; if (name) userIdentifier += name;
flags = flags | kbpgp.const.openpgp.auth; if (email) userIdentifier += ` <${email}>`;
flags = flags | kbpgp.const.openpgp.encrypt_comm;
flags = flags | kbpgp.const.openpgp.encrypt_storage;
let keyGenerationOptions = { let flags = kbpgp.const.openpgp.certify_keys;
userid: userIdentifier, flags = flags | kbpgp.const.openpgp.sign_data;
ecc: keyType === "ecc", flags = flags | kbpgp.const.openpgp.auth;
primary: { flags = flags | kbpgp.const.openpgp.encrypt_comm;
nbits: keySize, flags = flags | kbpgp.const.openpgp.encrypt_storage;
flags: flags,
expire_in: 0
},
subkeys: [{
nbits: PGP.getSubkeySize(keySize),
flags: kbpgp.const.openpgp.sign_data,
expire_in: 86400 * 365 * 8 // 8 years from kbpgp defaults
}, {
nbits: PGP.getSubkeySize(keySize),
flags: kbpgp.const.openpgp.encrypt_comm | kbpgp.const.openpgp.encrypt_storage,
expire_in: 86400 * 365 * 2 // 2 years from kbpgp defaults
}],
};
return new Promise((resolve, reject) => { let keyGenerationOptions = {
kbpgp.KeyManager.generate(keyGenerationOptions, (genErr, unsignedKey) => { userid: userIdentifier,
if (genErr) { ecc: keyType === "ecc",
return reject(`Error from kbpgp whilst generating key: ${genErr}`); primary: {
} nbits: keySize,
flags: flags,
expire_in: 0 // eslint-disable-line camelcase
},
subkeys: [{
nbits: PGP.getSubkeySize(keySize),
flags: kbpgp.const.openpgp.sign_data,
expire_in: 86400 * 365 * 8 // eslint-disable-line camelcase
}, {
nbits: PGP.getSubkeySize(keySize),
flags: kbpgp.const.openpgp.encrypt_comm | kbpgp.const.openpgp.encrypt_storage,
expire_in: 86400 * 365 * 2 // eslint-disable-line camelcase
}],
};
unsignedKey.sign({}, signErr => { return new Promise((resolve, reject) => {
let signedKey = unsignedKey; kbpgp.KeyManager.generate(keyGenerationOptions, (genErr, unsignedKey) => {
if (signErr) { if (genErr) {
return reject(`Error from kbpgp whilst signing the generated key: ${signErr}`); return reject(`Error from kbpgp whilst generating key: ${genErr}`);
} }
let privateKeyExportOptions = {}; unsignedKey.sign({}, signErr => {
if (password) privateKeyExportOptions.passphrase = password; let signedKey = unsignedKey;
if (signErr) {
return reject(`Error from kbpgp whilst signing the generated key: ${signErr}`);
}
signedKey.export_pgp_private(privateKeyExportOptions, (privateExportErr, privateKey) => { let privateKeyExportOptions = {};
if (privateExportErr) { if (password) privateKeyExportOptions.passphrase = password;
return reject(`Error from kbpgp whilst exporting the private part of the signed key: ${privateExportErr}`);
}
signedKey.export_pgp_public({}, (publicExportErr, publicKey) => { signedKey.export_pgp_private(privateKeyExportOptions, (privateExportErr, privateKey) => {
if (publicExportErr) { if (privateExportErr) {
return reject(`Error from kbpgp whilst exporting the public part of the signed key: ${publicExportErr}`); return reject(`Error from kbpgp whilst exporting the private part of the signed key: ${privateExportErr}`);
} }
return resolve(privateKey + "\n" + publicKey); signedKey.export_pgp_public({}, (publicExportErr, publicKey) => {
}); if (publicExportErr) {
}); return reject(`Error from kbpgp whilst exporting the public part of the signed key: ${publicExportErr}`);
}
}); return resolve(privateKey + "\n" + publicKey);
}) });
}); });
});
});
});
}, },
}; };