Switch to browserify. Basic unit tests are working.
This commit is contained in:
Michal Kolodziej
parent
18236ac097
commit
664ab71686
5045
resources/openpgp.js
5045
resources/openpgp.js
File diff suppressed because one or more lines are too long
|
|
@ -1224,3 +1224,5 @@ JXG.Util.genUUID = function() {
|
|||
return uuid.join('');
|
||||
};
|
||||
|
||||
|
||||
module.exports = JXG;
|
||||
|
|
@ -549,3 +549,4 @@ function openpgp_symenc_cast5() {
|
|||
|
||||
|
||||
module.exports = cast5_encrypt;
|
||||
module.exports.castClass = openpgp_symenc_cast5;
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@
|
|||
// The GPG4Browsers crypto interface
|
||||
|
||||
var random = require('./random.js'),
|
||||
cipher = require('./cipher'),
|
||||
cfb = require('./cfb.js'),
|
||||
publicKey= require('./public_key'),
|
||||
type_mpi = require('../type/mpi.js');
|
||||
|
||||
|
|
@ -34,21 +36,22 @@ module.exports = {
|
|||
publicKeyEncrypt: function(algo, publicMPIs, data) {
|
||||
var result = (function() {
|
||||
switch(algo) {
|
||||
case 1: // RSA (Encrypt or Sign) [HAC]
|
||||
case 2: // RSA Encrypt-Only [HAC]
|
||||
case 3: // RSA Sign-Only [HAC]
|
||||
case 'rsa_encrypt':
|
||||
case 'rsa_encrypt_sign':
|
||||
var rsa = new publicKey.rsa();
|
||||
var n = publicMPIs[0].toBigInteger();
|
||||
var e = publicMPIs[1].toBigInteger();
|
||||
var m = data.toBigInteger();
|
||||
return [rsa.encrypt(m,e,n)];
|
||||
case 16: // Elgamal (Encrypt-Only) [ELGAMAL] [HAC]
|
||||
|
||||
case 'elgamal':
|
||||
var elgamal = new publicKey.elgamal();
|
||||
var p = publicMPIs[0].toBigInteger();
|
||||
var g = publicMPIs[1].toBigInteger();
|
||||
var y = publicMPIs[2].toBigInteger();
|
||||
var m = data.toBigInteger();
|
||||
return elgamal.encrypt(m,g,p,y);
|
||||
|
||||
default:
|
||||
return [];
|
||||
}
|
||||
|
|
@ -76,9 +79,8 @@ publicKeyEncrypt: function(algo, publicMPIs, data) {
|
|||
publicKeyDecrypt: function (algo, keyIntegers, dataIntegers) {
|
||||
var bn = (function() {
|
||||
switch(algo) {
|
||||
case 1: // RSA (Encrypt or Sign) [HAC]
|
||||
case 2: // RSA Encrypt-Only [HAC]
|
||||
case 3: // RSA Sign-Only [HAC]
|
||||
case 'rsa_encrypt_sign':
|
||||
case 'rsa_encrypt':
|
||||
var rsa = new publicKey.rsa();
|
||||
// 0 and 1 are the public key.
|
||||
var d = keyIntegers[2].toBigInteger();
|
||||
|
|
@ -87,7 +89,7 @@ publicKeyDecrypt: function (algo, keyIntegers, dataIntegers) {
|
|||
var u = keyIntegers[5].toBigInteger();
|
||||
var m = dataIntegers[0].toBigInteger();
|
||||
return rsa.decrypt(m, d, p, q, u);
|
||||
case 16: // Elgamal (Encrypt-Only) [ELGAMAL] [HAC]
|
||||
case 'elgamal':
|
||||
var elgamal = new publicKey.elgamal();
|
||||
var x = keyIntegers[3].toBigInteger();
|
||||
var c1 = dataIntegers[0].toBigInteger();
|
||||
|
|
@ -109,38 +111,45 @@ publicKeyDecrypt: function (algo, keyIntegers, dataIntegers) {
|
|||
* @return {Integer} The number of integers.
|
||||
*/
|
||||
getPrivateMpiCount: function(algo) {
|
||||
if (algo > 0 && algo < 4) {
|
||||
switch(algo) {
|
||||
case 'rsa_encrypt':
|
||||
case 'rsa_encrypt_sign':
|
||||
case 'rsa_sign':
|
||||
// Algorithm-Specific Fields for RSA secret keys:
|
||||
// - multiprecision integer (MPI) of RSA secret exponent d.
|
||||
// - MPI of RSA secret prime value p.
|
||||
// - MPI of RSA secret prime value q (p < q).
|
||||
// - MPI of u, the multiplicative inverse of p, mod q.
|
||||
return 4;
|
||||
} else if (algo == 16) {
|
||||
case 'elgamal':
|
||||
// Algorithm-Specific Fields for Elgamal secret keys:
|
||||
// - MPI of Elgamal secret exponent x.
|
||||
return 1;
|
||||
} else if (algo == 17) {
|
||||
case 'dsa':
|
||||
// Algorithm-Specific Fields for DSA secret keys:
|
||||
// - MPI of DSA secret exponent x.
|
||||
return 1;
|
||||
default:
|
||||
throw new Error('Unknown algorithm');
|
||||
}
|
||||
else return 0;
|
||||
},
|
||||
|
||||
getPublicMpiCount: function(algorithm) {
|
||||
getPublicMpiCount: function(algo) {
|
||||
// - A series of multiprecision integers comprising the key material:
|
||||
// Algorithm-Specific Fields for RSA public keys:
|
||||
// - a multiprecision integer (MPI) of RSA public modulus n;
|
||||
// - an MPI of RSA public encryption exponent e.
|
||||
if (algorithm > 0 && algorithm < 4)
|
||||
switch(algo) {
|
||||
case 'rsa_encrypt':
|
||||
case 'rsa_encrypt_sign':
|
||||
case 'rsa_sign':
|
||||
return 2;
|
||||
|
||||
// Algorithm-Specific Fields for Elgamal public keys:
|
||||
// - MPI of Elgamal prime p;
|
||||
// - MPI of Elgamal group generator g;
|
||||
// - MPI of Elgamal public key value y (= g**x mod p where x is secret).
|
||||
else if (algorithm == 16)
|
||||
case 'elgamal':
|
||||
return 3;
|
||||
|
||||
// Algorithm-Specific Fields for DSA public keys:
|
||||
|
|
@ -148,10 +157,12 @@ getPublicMpiCount: function(algorithm) {
|
|||
// - MPI of DSA group order q (q is a prime divisor of p-1);
|
||||
// - MPI of DSA group generator g;
|
||||
// - MPI of DSA public-key value y (= g**x mod p where x is secret).
|
||||
else if (algorithm == 17)
|
||||
case 'dsa':
|
||||
return 4;
|
||||
else
|
||||
return 0;
|
||||
|
||||
default:
|
||||
throw new Error('Unknown algorithm.');
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
|
|
@ -162,19 +173,7 @@ getPublicMpiCount: function(algorithm) {
|
|||
* size of the cipher
|
||||
*/
|
||||
getPrefixRandom: function(algo) {
|
||||
switch(algo) {
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
return random.getRandomBytes(8);
|
||||
case 7:
|
||||
case 8:
|
||||
case 9:
|
||||
case 10:
|
||||
return random.getRandomBytes(16);
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
return random.getRandomBytes(this.getBlockLength(algo));
|
||||
},
|
||||
|
||||
/**
|
||||
|
|
@ -185,22 +184,23 @@ getPrefixRandom: function(algo) {
|
|||
* @return {String} Plain text data of the prefixed data
|
||||
*/
|
||||
MDCSystemBytes: function(algo, key, data) {
|
||||
|
||||
switch(algo) {
|
||||
case 0: // Plaintext or unencrypted data
|
||||
case 'plaintext': // Plaintext or unencrypted data
|
||||
return data;
|
||||
case 2: // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
return openpgp_cfb_mdc(desede, 8, key, data, openpgp_cfb);
|
||||
case 3: // CAST5 (128 bit key, as per [RFC2144])
|
||||
return openpgp_cfb_mdc(cast5_encrypt, 8, key, data);
|
||||
case 4: // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
return openpgp_cfb_mdc(BFencrypt, 8, key, data);
|
||||
case 7: // AES with 128-bit key [AES]
|
||||
case 8: // AES with 192-bit key
|
||||
case 9: // AES with 256-bit key
|
||||
return openpgp_cfb_mdc(AESencrypt, 16, keyExpansion(key), data);
|
||||
case 10:
|
||||
return openpgp_cfb_mdc(TFencrypt, 16, key, data);
|
||||
case 1: // IDEA [IDEA]
|
||||
case 'des': // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
return cfb.mdc(cipher.des, 8, key, data);
|
||||
case 'cast5': // CAST5 (128 bit key, as per [RFC2144])
|
||||
return cfb.mdc(cipher.cast5, 8, key, data);
|
||||
case 'blowfish': // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
return cfb.mdc(cipher.blowfish, 8, key, data);
|
||||
case 'aes128': // AES with 128-bit key [AES]
|
||||
case 'aes192': // AES with 192-bit key
|
||||
case 'aes256': // AES with 256-bit key
|
||||
return cfb.mdc(cipher.aes.encrypt, 16, cipher.aes.keyExpansion(key), data);
|
||||
case 'twofish':
|
||||
return cfb.mdc(cipher.twofish, 16, key, data);
|
||||
case 'idea': // IDEA [IDEA]
|
||||
throw new Error('IDEA Algorithm not implemented');
|
||||
default:
|
||||
throw new Error('Invalid algorithm.');
|
||||
|
|
@ -222,18 +222,19 @@ generateSessionKey: function(algo) {
|
|||
*/
|
||||
getKeyLength: function(algo) {
|
||||
switch (algo) {
|
||||
case 2: // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
case 8: // AES with 192-bit key
|
||||
case 'des': // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
case 'aes192': // AES with 192-bit key
|
||||
return 24;
|
||||
case 3: // CAST5 (128 bit key, as per [RFC2144])
|
||||
case 4: // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
case 7: // AES with 128-bit key [AES]
|
||||
case 'cast5': // CAST5 (128 bit key, as per [RFC2144])
|
||||
case 'blowfish': // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
case 'aes128': // AES with 128-bit key [AES]
|
||||
return 16;
|
||||
case 9: // AES with 256-bit key
|
||||
case 10:// Twofish with 256-bit key [TWOFISH]
|
||||
case 'aes256': // AES with 256-bit key
|
||||
case 'twofish':// Twofish with 256-bit key [TWOFISH]
|
||||
return 32;
|
||||
default:
|
||||
throw new Error('Invalid algorithm.');
|
||||
}
|
||||
return null;
|
||||
},
|
||||
|
||||
/**
|
||||
|
|
@ -243,19 +244,18 @@ getKeyLength: function(algo) {
|
|||
*/
|
||||
getBlockLength: function(algo) {
|
||||
switch (algo) {
|
||||
case 1: // - IDEA [IDEA]
|
||||
case 2: // - TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
case 3: // - CAST5 (128 bit key, as per [RFC2144])
|
||||
case 'des':
|
||||
case 'cast5':
|
||||
return 8;
|
||||
case 4: // - Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
case 7: // - AES with 128-bit key [AES]
|
||||
case 8: // - AES with 192-bit key
|
||||
case 9: // - AES with 256-bit key
|
||||
case 'blowfish':
|
||||
case 'aes128':
|
||||
case 'aes192':
|
||||
case 'aes256':
|
||||
return 16;
|
||||
case 10: // - Twofish with 256-bit key [TWOFISH]
|
||||
case 'twofish':
|
||||
return 32;
|
||||
default:
|
||||
return 0;
|
||||
throw new Error('Invalid algorithm.');
|
||||
}
|
||||
},
|
||||
|
||||
|
|
@ -277,61 +277,19 @@ getRandomBigInteger: function(bits) {
|
|||
randomBits.charCodeAt(0)) +
|
||||
randomBits.substring(1);
|
||||
}
|
||||
return new openpgp_type_mpi().create(randomBits).toBigInteger();
|
||||
return new type_mpi().create(randomBits).toBigInteger();
|
||||
},
|
||||
|
||||
getRandomBigIntegerInRange: function(min, max) {
|
||||
if (max.compareTo(min) <= 0)
|
||||
return;
|
||||
|
||||
var range = max.subtract(min);
|
||||
var r = openpgp_crypto_getRandomBigInteger(range.bitLength());
|
||||
var r = this.getRandomBigInteger(range.bitLength());
|
||||
while (r > range) {
|
||||
r = openpgp_crypto_getRandomBigInteger(range.bitLength());
|
||||
r = this.getRandomBigInteger(range.bitLength());
|
||||
}
|
||||
return min.add(r);
|
||||
},
|
||||
|
||||
|
||||
//This is a test method to ensure that encryption/decryption with a given 1024bit RSAKey object functions as intended
|
||||
testRSA: function(key){
|
||||
debugger;
|
||||
var rsa = new RSA();
|
||||
var mpi = new openpgp_type_mpi();
|
||||
mpi.create(openpgp_encoding_eme_pkcs1_encode('ABABABAB', 128));
|
||||
var msg = rsa.encrypt(mpi.toBigInteger(),key.ee,key.n);
|
||||
var result = rsa.decrypt(msg, key.d, key.p, key.q, key.u);
|
||||
},
|
||||
|
||||
/**
|
||||
* @typedef {Object} openpgp_keypair
|
||||
* @property {openpgp_packet_keymaterial} privateKey
|
||||
* @property {openpgp_packet_keymaterial} publicKey
|
||||
*/
|
||||
|
||||
/**
|
||||
* Calls the necessary crypto functions to generate a keypair.
|
||||
* Called directly by openpgp.js
|
||||
* @param {Integer} keyType Follows OpenPGP algorithm convention.
|
||||
* @param {Integer} numBits Number of bits to make the key to be generated
|
||||
* @return {openpgp_keypair}
|
||||
*/
|
||||
generateKeyPair: function(keyType, numBits, passphrase, s2kHash, symmetricEncryptionAlgorithm){
|
||||
var privKeyPacket;
|
||||
var publicKeyPacket;
|
||||
var d = new Date();
|
||||
d = d.getTime()/1000;
|
||||
var timePacket = String.fromCharCode(Math.floor(d/0x1000000%0x100)) + String.fromCharCode(Math.floor(d/0x10000%0x100)) + String.fromCharCode(Math.floor(d/0x100%0x100)) + String.fromCharCode(Math.floor(d%0x100));
|
||||
switch(keyType){
|
||||
case 1:
|
||||
var rsa = new RSA();
|
||||
var key = rsa.generate(numBits,"10001");
|
||||
privKeyPacket = new openpgp_packet_keymaterial().write_private_key(keyType, key, passphrase, s2kHash, symmetricEncryptionAlgorithm, timePacket);
|
||||
publicKeyPacket = new openpgp_packet_keymaterial().write_public_key(keyType, key, timePacket);
|
||||
break;
|
||||
default:
|
||||
util.print_error("Unknown keytype "+keyType)
|
||||
}
|
||||
return {privateKey: privKeyPacket, publicKey: publicKeyPacket};
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,6 +5,10 @@ module.exports = {
|
|||
cfb: require('./cfb.js'),
|
||||
publicKey: require('./public_key'),
|
||||
signature: require('./signature.js'),
|
||||
random: require('./random.js'),
|
||||
pkcs1: require('./pkcs1.js'),
|
||||
symmetric: require('./sym.js')
|
||||
|
||||
}
|
||||
|
||||
var crypto = require('./crypto.js');
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@
|
|||
// RSA implementation
|
||||
|
||||
var BigInteger = require('./jsbn.js'),
|
||||
util = require('../../util'),
|
||||
random = require('../random.js');
|
||||
|
||||
function SecureRandom(){
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ module.exports = {
|
|||
getRandomBytes: function(length) {
|
||||
var result = '';
|
||||
for (var i = 0; i < length; i++) {
|
||||
result += String.fromCharCode(openpgp_crypto_getSecureRandomOctet());
|
||||
result += String.fromCharCode(this.getSecureRandomOctet());
|
||||
}
|
||||
return result;
|
||||
},
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
var cfb = require('./cfb.js'),
|
||||
cipher = require('./cipher');
|
||||
|
||||
module.exports {
|
||||
module.exports = {
|
||||
|
||||
/**
|
||||
* Symmetrically encrypts data using prefixedrandom, a key with length
|
||||
|
|
@ -37,27 +37,24 @@ module.exports {
|
|||
*/
|
||||
encrypt: function (prefixrandom, algo, key, data, openpgp_cfb) {
|
||||
switch(algo) {
|
||||
case 0: // Plaintext or unencrypted data
|
||||
case 'plaintext': // Plaintext or unencrypted data
|
||||
return data; // blockcipherencryptfn, plaintext, block_size, key
|
||||
case 2: // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
case 'des': // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
return cfb.encrypt(prefixrandom, cipher.des, data,8,key, openpgp_cfb).substring(0, data.length + 10);
|
||||
case 3: // CAST5 (128 bit key, as per [RFC2144])
|
||||
case 'cast5': // CAST5 (128 bit key, as per [RFC2144])
|
||||
return cfb.encrypt(prefixrandom, cipher.cast5, data,8,key, openpgp_cfb).substring(0, data.length + 10);
|
||||
case 4: // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
case 'blowfish': // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
return cfb.encrypt(prefixrandom, cipher.blowfish, data,8,key, openpgp_cfb).substring(0, data.length + 10);
|
||||
case 7: // AES with 128-bit key [AES]
|
||||
case 8: // AES with 192-bit key
|
||||
case 9: // AES with 256-bit key
|
||||
case 'aes128': // AES with 128-bit key [AES]
|
||||
case 'aes192': // AES with 192-bit key
|
||||
case 'aes256': // AES with 256-bit key
|
||||
return cfb.encrypt(prefixrandom, cipher.aes.encrypt, data, 16, cipher.aes.keyExpansion(key), openpgp_cfb).substring(0, data.length + 18);
|
||||
case 10: // Twofish with 256-bit key [TWOFISH]
|
||||
case 'twofish': // Twofish with 256-bit key [TWOFISH]
|
||||
return cfb.encrypt(prefixrandom, cipher.twofish, data,16, key, openpgp_cfb).substring(0, data.length + 18);
|
||||
case 1: // IDEA [IDEA]
|
||||
util.print_error("IDEA Algorithm not implemented");
|
||||
return null;
|
||||
default:
|
||||
return null;
|
||||
throw new Error('Invalid algorithm.');
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Symmetrically decrypts data using a key with length depending on the
|
||||
|
|
@ -70,30 +67,28 @@ encrypt: function (prefixrandom, algo, key, data, openpgp_cfb) {
|
|||
* @return {String} Plaintext data
|
||||
*/
|
||||
decrypt: function (algo, key, data, openpgp_cfb) {
|
||||
util.print_debug_hexstr_dump("openpgp_crypto_symmetricDecrypt:\nalgo:"+algo+"\nencrypteddata:",data);
|
||||
var n = 0;
|
||||
if (!openpgp_cfb)
|
||||
n = 2;
|
||||
switch(algo) {
|
||||
case 0: // Plaintext or unencrypted data
|
||||
case 'plaintext': // Plaintext or unencrypted data
|
||||
return data;
|
||||
case 2: // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
case 'des': // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
return cfb.decrypt(cipher.des, 8, key, data, openpgp_cfb).substring(n, (data.length+n)-10);
|
||||
case 3: // CAST5 (128 bit key, as per [RFC2144])
|
||||
case 'cast5': // CAST5 (128 bit key, as per [RFC2144])
|
||||
return cfb.decrypt(cipher.cast5, 8, key, data, openpgp_cfb).substring(n, (data.length+n)-10);
|
||||
case 4: // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
case 'blowfish': // Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
return cfb.decrypt(cipher.blowfish, 8, key, data, openpgp_cfb).substring(n, (data.length+n)-10);
|
||||
case 7: // AES with 128-bit key [AES]
|
||||
case 8: // AES with 192-bit key
|
||||
case 9: // AES with 256-bit key
|
||||
case 'aes128': // AES with 128-bit key [AES]
|
||||
case 'aes192': // AES with 192-bit key
|
||||
case 'aes256': // AES with 256-bit key
|
||||
return cfb.decrypt(cipher.aes.encrypt, 16, cipher.aes.keyExpansion(key), data, openpgp_cfb).substring(n, (data.length+n)-18);
|
||||
case 10: // Twofish with 256-bit key [TWOFISH]
|
||||
case 'twofish': // Twofish with 256-bit key [TWOFISH]
|
||||
var result = cfb.decrypt(cipher.twofish, 16, key, data, openpgp_cfb).substring(n, (data.length+n)-18);
|
||||
return result;
|
||||
case 1: // IDEA [IDEA]
|
||||
util.print_error(""+ (algo == 1 ? "IDEA Algorithm not implemented" : "Twofish Algorithm not implemented"));
|
||||
return null;
|
||||
default:
|
||||
throw new Error('Invalid algorithm');
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ function getCheckSum(data) {
|
|||
var str = "" + String.fromCharCode(c >> 16)+
|
||||
String.fromCharCode((c >> 8) & 0xFF)+
|
||||
String.fromCharCode(c & 0xFF);
|
||||
return base64_encode(str);
|
||||
return base64.encode(str);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -177,7 +177,7 @@ function dearmor(text) {
|
|||
var splittedtext = text.split('-----');
|
||||
|
||||
var data = {
|
||||
openpgp: base64_decode(
|
||||
openpgp: base64.decode(
|
||||
splittedtext[2]
|
||||
.split('\n\n')[1]
|
||||
.split("\n=")[0]
|
||||
|
|
|
|||
12
src/enums.js
12
src/enums.js
|
|
@ -1,4 +1,16 @@
|
|||
module.exports = {
|
||||
|
||||
|
||||
/** A string to key specifier type
|
||||
* @enum {Integer}
|
||||
*/
|
||||
s2k: {
|
||||
simple: 0,
|
||||
salted: 1,
|
||||
iterated: 3,
|
||||
gnu: 101
|
||||
},
|
||||
|
||||
/** RFC4880, section 9.1
|
||||
* @enum {String}
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -15,7 +15,9 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var enums = require('../enums.js');
|
||||
var enums = require('../enums.js'),
|
||||
JXG = require('../compression/jxg.js'),
|
||||
base64 = require('../encoding/base64.js');
|
||||
|
||||
/**
|
||||
* @class
|
||||
|
|
@ -81,7 +83,7 @@ module.exports = function packet_compressed() {
|
|||
case 'zip':
|
||||
var compData = this.compressed;
|
||||
|
||||
var radix = s2r(compData).replace(/\n/g,"");
|
||||
var radix = base64.encode(compData).replace(/\n/g,"");
|
||||
// no header in this case, directly call deflate
|
||||
var jxg_obj = new JXG.Util.Unzip(JXG.Util.Base64.decodeAsArray(radix));
|
||||
|
||||
|
|
@ -99,7 +101,7 @@ module.exports = function packet_compressed() {
|
|||
if (compressionMethod == 8) { //CM 8 is for DEFLATE, RFC 1951
|
||||
// remove 4 bytes ADLER32 checksum from the end
|
||||
var compData = this.compressed.substring(0, this.compressed.length - 4);
|
||||
var radix = s2r(compData).replace(/\n/g,"");
|
||||
var radix = base64.encode(compData).replace(/\n/g,"");
|
||||
//TODO check ADLER32 checksum
|
||||
decompressed = JXG.decompress(radix);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -27,7 +27,8 @@
|
|||
* can compute the entire signed message in one pass.
|
||||
*/
|
||||
|
||||
var enums = require('../enums.js');
|
||||
var enums = require('../enums.js'),
|
||||
type_keyid = require('../type/keyid.js');
|
||||
|
||||
module.exports = function packet_one_pass_signature() {
|
||||
this.version = null; // A one-octet version number. The current version is 3.
|
||||
|
|
@ -60,8 +61,8 @@ module.exports = function packet_one_pass_signature() {
|
|||
this.publicKeyAlgorithm = enums.read(enums.publicKey, bytes.charCodeAt(mypos++));
|
||||
|
||||
// An eight-octet number holding the Key ID of the signing key.
|
||||
this.signingKeyId = new openpgp_type_keyid();
|
||||
this.signingKeyId.read_packet(bytes,mypos);
|
||||
this.signingKeyId = new type_keyid();
|
||||
this.signingKeyId.read(bytes.substr(mypos));
|
||||
mypos += 8;
|
||||
|
||||
// A one-octet number holding a flag showing whether the signature
|
||||
|
|
|
|||
|
|
@ -15,6 +15,11 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var util = require('../util'),
|
||||
type_mpi = require('../type/mpi.js'),
|
||||
enums = require('../enums.js'),
|
||||
crypto = require('../crypto');
|
||||
|
||||
/**
|
||||
* @class
|
||||
* @classdesc Implementation of the Key Material Packet (Tag 5,6,7,14)
|
||||
|
|
@ -51,12 +56,12 @@ module.exports = function packet_public_key() {
|
|||
|
||||
if (version == 4) {
|
||||
// - A four-octet number denoting the time that the key was created.
|
||||
this.created = openpgp_packet_time_read(bytes.substr(1, 4));
|
||||
this.created = util.readDate(bytes.substr(1, 4));
|
||||
|
||||
// - A one-octet number denoting the public-key algorithm of this key.
|
||||
this.algorithm = bytes[5].charCodeAt();
|
||||
this.algorithm = enums.read(enums.publicKey, bytes[5].charCodeAt());
|
||||
|
||||
var mpicount = openpgp_crypto_getPublicMpiCount(this.algorithm);
|
||||
var mpicount = crypto.getPublicMpiCount(this.algorithm);
|
||||
this.mpi = [];
|
||||
|
||||
var bmpi = bytes.substr(6);
|
||||
|
|
@ -66,7 +71,7 @@ module.exports = function packet_public_key() {
|
|||
i < mpicount && p < bmpi.length;
|
||||
i++) {
|
||||
|
||||
this.mpi[i] = new openpgp_type_mpi();
|
||||
this.mpi[i] = new type_mpi();
|
||||
|
||||
p += this.mpi[i].read(bmpi.substr(p))
|
||||
|
||||
|
|
@ -94,10 +99,10 @@ module.exports = function packet_public_key() {
|
|||
this.writePublicKey = this.write = function() {
|
||||
// Version
|
||||
var result = String.fromCharCode(4);
|
||||
result += openpgp_packet_time_write(this.created);
|
||||
result += String.fromCharCode(this.algorithm);
|
||||
result += util.writeDate(this.created);
|
||||
result += String.fromCharCode(enums.write(enums.publicKey, this.algorithm));
|
||||
|
||||
var mpicount = openpgp_crypto_getPublicMpiCount(this.algorithm);
|
||||
var mpicount = crypto.getPublicMpiCount(this.algorithm);
|
||||
|
||||
for(var i = 0; i < mpicount; i++) {
|
||||
result += this.mpi[i].write();
|
||||
|
|
@ -111,7 +116,7 @@ module.exports = function packet_public_key() {
|
|||
var bytes = this.writePublicKey();
|
||||
|
||||
return String.fromCharCode(0x99) +
|
||||
openpgp_packet_number_write(bytes.length, 2) +
|
||||
util.writeNumber(bytes.length, 2) +
|
||||
bytes;
|
||||
}
|
||||
|
||||
|
|
@ -129,7 +134,7 @@ module.exports = function packet_public_key() {
|
|||
*/
|
||||
this.getFingerprint = function() {
|
||||
var toHash = this.writeOld();
|
||||
return str_sha1(toHash, toHash.length);
|
||||
return crypto.hash.sha1(toHash, toHash.length);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,13 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var type_keyid = require('../type/keyid.js'),
|
||||
util = require('../util'),
|
||||
type_mpi = require('../type/mpi.js'),
|
||||
enums = require('../enums.js'),
|
||||
crypto = require('../crypto');
|
||||
|
||||
|
||||
/**
|
||||
* @class
|
||||
* @classdesc Public-Key Encrypted Session Key Packets (Tag 1)
|
||||
|
|
@ -34,7 +41,7 @@
|
|||
module.exports = function packet_public_key_encrypted_session_key() {
|
||||
this.version = 3;
|
||||
|
||||
this.publicKeyId = new openpgp_type_keyid();
|
||||
this.publicKeyId = new type_keyid();
|
||||
this.publicKeyAlgorithm = 'rsa_encrypt';
|
||||
|
||||
this.sessionKey = null;
|
||||
|
|
@ -53,40 +60,33 @@ module.exports = function packet_public_key_encrypted_session_key() {
|
|||
* @return {openpgp_packet_encrypteddata} Object representation
|
||||
*/
|
||||
this.read = function(bytes) {
|
||||
if (bytes.length < 10) {
|
||||
util.print_error("openpgp.packet.encryptedsessionkey.js\n"
|
||||
+ 'invalid length');
|
||||
return null;
|
||||
}
|
||||
|
||||
this.version = bytes[0].charCodeAt();
|
||||
this.public_key_id.read_packet(bytes, 1);
|
||||
this.public_key_algorithm = bytes[9].charCodeAt();
|
||||
this.publicKeyId.read(bytes.substr(1));
|
||||
this.publicKeyAlgorithm = enums.read(enums.publicKey, bytes[9].charCodeAt());
|
||||
|
||||
var i = 10;
|
||||
|
||||
switch (this.public_key_algorithm) {
|
||||
var integerCount = (function(algo) {
|
||||
switch (algo) {
|
||||
case 'rsa_encrypt':
|
||||
case 'rsa_encrypt_sign':
|
||||
return 1;
|
||||
|
||||
case openpgp.publickey.rsa_encrypt:
|
||||
case openpgp.publickey.rsa_encrypt_sign:
|
||||
this.encrypted = [];
|
||||
this.encrypted[0] = new openpgp_type_mpi();
|
||||
this.encrypted[0].read(bytes.substr(i));
|
||||
break;
|
||||
case 'elgamal':
|
||||
return 2;
|
||||
|
||||
case openpgp.publickey.elgamal:
|
||||
this.encrypted = [];
|
||||
this.encrypted[0] = new openpgp_type_mpi();
|
||||
i += this.encrypted[0].read(bytes.substr(i));
|
||||
this.encrypted[1] = new openpgp_type_mpi();
|
||||
this.encrypted[1].read(bytes.substr(i));
|
||||
break;
|
||||
default:
|
||||
throw new Error("Invalid algorithm.");
|
||||
}
|
||||
})(this.publicKeyAlgorithm);
|
||||
|
||||
default:
|
||||
util.print_error("openpgp.packet.encryptedsessionkey.js\n"
|
||||
+ "unknown public key packet algorithm type "
|
||||
+ this.public_key_algorithm);
|
||||
break;
|
||||
this.encrypted = [];
|
||||
|
||||
for(var j = 0; j < integerCount; j++) {
|
||||
var mpi = new type_mpi();
|
||||
i += mpi.read(bytes.substr(i));
|
||||
this.encrypted.push(mpi);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -111,8 +111,9 @@ module.exports = function packet_public_key_encrypted_session_key() {
|
|||
this.write = function() {
|
||||
|
||||
var result = String.fromCharCode(this.version);
|
||||
result += this.public_key_id.bytes;
|
||||
result += String.fromCharCode(this.public_key_algorithm);
|
||||
result += this.publicKeyId.write();
|
||||
result += String.fromCharCode(
|
||||
enums.write(enums.publicKey, this.publicKeyAlgorithm));
|
||||
|
||||
for ( var i = 0; i < this.encrypted.length; i++) {
|
||||
result += this.encrypted[i].write()
|
||||
|
|
@ -122,20 +123,20 @@ module.exports = function packet_public_key_encrypted_session_key() {
|
|||
}
|
||||
|
||||
this.encrypt = function(key) {
|
||||
|
||||
var data = String.fromCharCode(this.symmetric_algorithm);
|
||||
data += this.symmetric_key;
|
||||
var checksum = util.calc_checksum(this.symmetric_key);
|
||||
data += String.fromCharCode((checksum >> 8) & 0xFF);
|
||||
data += String.fromCharCode((checksum) & 0xFF);
|
||||
var data = String.fromCharCode(
|
||||
enums.write(enums.symmetric, this.sessionKeyAlgorithm));
|
||||
|
||||
var mpi = new openpgp_type_mpi();
|
||||
mpi.fromBytes(openpgp_encoding_eme_pkcs1_encode(
|
||||
data += this.sessionKey;
|
||||
var checksum = util.calc_checksum(this.sessionKey);
|
||||
data += util.writeNumber(checksum, 2);
|
||||
|
||||
var mpi = new type_mpi();
|
||||
mpi.fromBytes(crypto.pkcs1.eme.encode(
|
||||
data,
|
||||
key.mpi[0].byteLength()));
|
||||
|
||||
this.encrypted = openpgp_crypto_asymetricEncrypt(
|
||||
this.public_key_algorithm,
|
||||
this.encrypted = crypto.publicKeyEncrypt(
|
||||
this.publicKeyAlgorithm,
|
||||
key.mpi,
|
||||
mpi);
|
||||
}
|
||||
|
|
@ -151,26 +152,26 @@ module.exports = function packet_public_key_encrypted_session_key() {
|
|||
* @return {String} The unencrypted session key
|
||||
*/
|
||||
this.decrypt = function(key) {
|
||||
var result = openpgp_crypto_asymetricDecrypt(
|
||||
this.public_key_algorithm,
|
||||
var result = crypto.publicKeyDecrypt(
|
||||
this.publicKeyAlgorithm,
|
||||
key.mpi,
|
||||
this.encrypted).toBytes();
|
||||
|
||||
var checksum = ((result.charCodeAt(result.length - 2) << 8)
|
||||
+ result.charCodeAt(result.length - 1));
|
||||
var checksum = util.readNumber(result.substr(result.length - 2));
|
||||
|
||||
var decoded = openpgp_encoding_eme_pkcs1_decode(
|
||||
var decoded = crypto.pkcs1.eme.decode(
|
||||
result,
|
||||
key.mpi[0].byteLength());
|
||||
|
||||
var key = decoded.substring(1, decoded.length - 2);
|
||||
|
||||
if(checksum != util.calc_checksum(key)) {
|
||||
util.print_error("Checksum mismatch");
|
||||
throw new Error('Checksum mismatch');
|
||||
}
|
||||
else {
|
||||
this.symmetric_key = key;
|
||||
this.symmetric_algorithm = decoded.charCodeAt(0);
|
||||
this.sessionKey = key;
|
||||
this.sessionKeyAlgorithm =
|
||||
enums.read(enums.symmetric, decoded.charCodeAt(0));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -16,8 +16,11 @@
|
|||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var publicKey = require('./public_key.js'),
|
||||
enums = require('../enums.js'),
|
||||
util = require('../util'),
|
||||
crypto = require('../crypto');
|
||||
crypto = require('../crypto'),
|
||||
type_mpi = require('../type/mpi.js'),
|
||||
type_s2k = require('../type/s2k.js');
|
||||
|
||||
/**
|
||||
* @class
|
||||
|
|
@ -35,15 +38,15 @@ function packet_secret_key() {
|
|||
|
||||
|
||||
function get_hash_len(hash) {
|
||||
if(hash == openpgp.hash.sha1)
|
||||
if(hash == 'sha1')
|
||||
return 20;
|
||||
else
|
||||
return 2;
|
||||
}
|
||||
|
||||
function get_hash_fn(hash) {
|
||||
if(hash == openpgp.hash.sha1)
|
||||
return str_sha1;
|
||||
if(hash == 'sha1')
|
||||
return crypto.hash.sha1;
|
||||
else
|
||||
return function(c) {
|
||||
return util.writeNumber(util.calc_checksum(c), 2);
|
||||
|
|
@ -67,17 +70,18 @@ function packet_secret_key() {
|
|||
|
||||
var j = 0;
|
||||
var mpi = [];
|
||||
|
||||
for(var i = 0; i < mpis && j < cleartext.length; i++) {
|
||||
mpi[i] = new openpgp_type_mpi();
|
||||
mpi[i] = new type_mpi();
|
||||
j += mpi[i].read(cleartext.substr(j));
|
||||
}
|
||||
|
||||
return mpi;
|
||||
}
|
||||
|
||||
function write_cleartext_mpi(hash_algorithm, mpi) {
|
||||
function write_cleartext_mpi(hash_algorithm, algorithm, mpi) {
|
||||
var bytes= '';
|
||||
var discard = crypto.getPublicMpiCount(this.algorithm);
|
||||
var discard = crypto.getPublicMpiCount(algorithm);
|
||||
|
||||
for(var i = discard; i < mpi.length; i++) {
|
||||
bytes += mpi[i].write();
|
||||
|
|
@ -145,7 +149,7 @@ function packet_secret_key() {
|
|||
if(!this.encrypted) {
|
||||
bytes += String.fromCharCode(0);
|
||||
|
||||
bytes += write_cleartext_mpi('mod', this.mpi);
|
||||
bytes += write_cleartext_mpi('mod', this.algorithm, this.mpi);
|
||||
} else {
|
||||
bytes += this.encrypted;
|
||||
}
|
||||
|
|
@ -162,47 +166,49 @@ function packet_secret_key() {
|
|||
*/
|
||||
this.encrypt = function(passphrase) {
|
||||
|
||||
var s2k = new openpgp_type_s2k(),
|
||||
symmetric = openpgp.symmetric.aes256,
|
||||
cleartext = write_cleartext_mpi(openpgp.hash.sha1, this.mpi),
|
||||
var s2k = new type_s2k(),
|
||||
symmetric = 'aes256',
|
||||
cleartext = write_cleartext_mpi('sha1', this.algorithm, this.mpi),
|
||||
key = produceEncryptionKey(s2k, passphrase, symmetric),
|
||||
blockLen = openpgp_crypto_getBlockLength(symmetric),
|
||||
iv = openpgp_crypto_getRandomBytes(blockLen);
|
||||
blockLen = crypto.getBlockLength(symmetric),
|
||||
iv = crypto.random.getRandomBytes(blockLen);
|
||||
|
||||
|
||||
this.encrypted = '';
|
||||
this.encrypted += String.fromCharCode(254);
|
||||
this.encrypted += String.fromCharCode(symmetric);
|
||||
this.encrypted += String.fromCharCode(enums.write(enums.symmetric, symmetric));
|
||||
this.encrypted += s2k.write();
|
||||
this.encrypted += iv;
|
||||
|
||||
console.log(cleartext);
|
||||
|
||||
var fn;
|
||||
|
||||
switch(symmetric) {
|
||||
case 3:
|
||||
this.encrypted += normal_cfb_encrypt(function(block, key) {
|
||||
var cast5 = new openpgp_symenc_cast5();
|
||||
cast5.setKey(key);
|
||||
return cast5.encrypt(util.str2bin(block));
|
||||
}, iv.length, key, cleartext, iv);
|
||||
case 'cast5':
|
||||
fn = crypto.cipher.cast5;
|
||||
break;
|
||||
case 7:
|
||||
case 8:
|
||||
case 9:
|
||||
case 'aes128':
|
||||
case 'aes192':
|
||||
case 'aes256':
|
||||
var fn = function(block,key) {
|
||||
return AESencrypt(util.str2bin(block),key);
|
||||
return crypto.cipher.aes.encrypt(util.str2bin(block),key);
|
||||
}
|
||||
this.encrypted += normal_cfb_encrypt(fn,
|
||||
iv.length, new keyExpansion(key), cleartext, iv);
|
||||
|
||||
key = new crypto.cipher.aes.keyExpansion(key);
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Error("Unsupported symmetric encryption algorithm.");
|
||||
}
|
||||
|
||||
console.log(cleartext);
|
||||
|
||||
this.encrypted += crypto.cfb.normalEncrypt(fn, iv.length, key, cleartext, iv);
|
||||
}
|
||||
|
||||
function produceEncryptionKey(s2k, passphrase, algorithm) {
|
||||
return s2k.produce_key(passphrase,
|
||||
openpgp_crypto_getKeyLength(algorithm));
|
||||
crypto.getKeyLength(algorithm));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -229,77 +235,78 @@ function packet_secret_key() {
|
|||
// octet symmetric encryption algorithm.
|
||||
if (s2k_usage == 255 || s2k_usage == 254) {
|
||||
symmetric = this.encrypted[i++].charCodeAt();
|
||||
symmetric = enums.read(enums.symmetric, symmetric);
|
||||
|
||||
// - [Optional] If string-to-key usage octet was 255 or 254, a
|
||||
// string-to-key specifier. The length of the string-to-key
|
||||
// specifier is implied by its type, as described above.
|
||||
var s2k = new openpgp_type_s2k();
|
||||
var s2k = new type_s2k();
|
||||
i += s2k.read(this.encrypted.substr(i));
|
||||
|
||||
key = produceEncryptionKey(s2k, passphrase, symmetric);
|
||||
} else {
|
||||
symmetric = s2k_usage;
|
||||
key = MD5(passphrase);
|
||||
symmetric = enums.read(enums.symmetric, symmetric);
|
||||
key = crypto.hash.md5(passphrase);
|
||||
}
|
||||
|
||||
|
||||
// - [Optional] If secret data is encrypted (string-to-key usage octet
|
||||
// not zero), an Initial Vector (IV) of the same length as the
|
||||
// cipher's block size.
|
||||
var iv = this.encrypted.substr(i,
|
||||
openpgp_crypto_getBlockLength(symmetric));
|
||||
crypto.getBlockLength(symmetric));
|
||||
|
||||
i += iv.length;
|
||||
|
||||
var cleartext,
|
||||
ciphertext = this.encrypted.substr(i);
|
||||
|
||||
|
||||
switch (symmetric) {
|
||||
case 1: // - IDEA [IDEA]
|
||||
case 'idea': // - IDEA [IDEA]
|
||||
throw new Error("IDEA is not implemented.");
|
||||
return false;
|
||||
case 2: // - TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
cleartext = normal_cfb_decrypt(function(block, key) {
|
||||
return des(key, block,1,null,0);
|
||||
case 'des': // - TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
|
||||
cleartext = crypto.cfb.normal_decrypt(function(block, key) {
|
||||
return crypto.cipher.des(key, block,1,null,0);
|
||||
}, iv.length, key, ciphertext, iv);
|
||||
break;
|
||||
case 3: // - CAST5 (128 bit key, as per [RFC2144])
|
||||
cleartext = normal_cfb_decrypt(function(block, key) {
|
||||
var cast5 = new openpgp_symenc_cast5();
|
||||
cast5.setKey(key);
|
||||
return cast5.encrypt(util.str2bin(block));
|
||||
}, iv.length, util.str2bin(key.substring(0,16)), ciphertext, iv);
|
||||
case 'cast5': // - CAST5 (128 bit key, as per [RFC2144])
|
||||
cleartext = crypto.cfb.normalDecrypt(
|
||||
function(block, key) {
|
||||
var cast5 = new crypto.cipher.cast5.castClass();
|
||||
cast5.setKey(key);
|
||||
return cast5.encrypt(util.str2bin(block));
|
||||
}
|
||||
, iv.length,
|
||||
util.str2bin(key.substring(0,16)), ciphertext, iv);
|
||||
break;
|
||||
case 4: // - Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
case 'blowfish': // - Blowfish (128 bit key, 16 rounds) [BLOWFISH]
|
||||
cleartext = normal_cfb_decrypt(function(block, key) {
|
||||
var blowfish = new Blowfish(key);
|
||||
return blowfish.encrypt(block);
|
||||
}, iv.length, key, ciphertext, iv);
|
||||
break;
|
||||
case 7: // - AES with 128-bit key [AES]
|
||||
case 8: // - AES with 192-bit key
|
||||
case 9: // - AES with 256-bit key
|
||||
cleartext = normal_cfb_decrypt(function(block,key){
|
||||
return AESencrypt(util.str2bin(block),key);
|
||||
case 'aes128': // - AES with 128-bit key [AES]
|
||||
case 'aes192': // - AES with 192-bit key
|
||||
case 'aes256': // - AES with 256-bit key
|
||||
cleartext = crypto.cfb.normalDecrypt(function(block,key){
|
||||
return crypto.cipher.aes.encrypt(util.str2bin(block),key);
|
||||
},
|
||||
iv.length, new keyExpansion(key),
|
||||
iv.length, new crypto.cipher.aes.keyExpansion(key),
|
||||
ciphertext, iv);
|
||||
break;
|
||||
case 10: // - Twofish with 256-bit key [TWOFISH]
|
||||
case 'twofish': // - Twofish with 256-bit key [TWOFISH]
|
||||
throw new Error("Twofish is not implemented.");
|
||||
return false;
|
||||
case 5: // - Reserved
|
||||
case 6: // - Reserved
|
||||
default:
|
||||
throw new Error("Unknown symmetric algorithm.");
|
||||
return false;
|
||||
}
|
||||
|
||||
var hash;
|
||||
if(s2k_usage == 254)
|
||||
hash = openpgp.hash.sha1;
|
||||
else
|
||||
hash = 'mod';
|
||||
var hash = s2k_usage == 254 ?
|
||||
'sha1' :
|
||||
'mod';
|
||||
|
||||
|
||||
this.mpi = this.mpi.concat(parse_cleartext_mpi(hash, cleartext,
|
||||
|
|
|
|||
|
|
@ -15,6 +15,9 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var util = require('../util'),
|
||||
crypto = require('../crypto');
|
||||
|
||||
/**
|
||||
* @class
|
||||
* @classdesc Implementation of the Sym. Encrypted Integrity Protected Data
|
||||
|
|
@ -45,8 +48,7 @@ module.exports = function packet_sym_encrypted_integrity_protected() {
|
|||
var version = bytes[0].charCodeAt();
|
||||
|
||||
if (version != 1) {
|
||||
throw new Error('Version ' + version + ' of encrypted integrity protected' +
|
||||
' packet is unsupported');
|
||||
throw new Error('Invalid packet version.');
|
||||
}
|
||||
|
||||
// - Encrypted data, the output of the selected symmetric-key cipher
|
||||
|
|
@ -61,10 +63,10 @@ module.exports = function packet_sym_encrypted_integrity_protected() {
|
|||
+ this.encrypted;
|
||||
}
|
||||
|
||||
this.encrypt = function(symmetric_algorithm, key) {
|
||||
this.encrypt = function(sessionKeyAlgorithm, key) {
|
||||
var bytes = this.packets.write()
|
||||
|
||||
var prefixrandom = openpgp_crypto_getPrefixRandom(symmetric_algorithm);
|
||||
var prefixrandom = crypto.getPrefixRandom(sessionKeyAlgorithm);
|
||||
var prefix = prefixrandom
|
||||
+ prefixrandom.charAt(prefixrandom.length - 2)
|
||||
+ prefixrandom.charAt(prefixrandom.length - 1)
|
||||
|
|
@ -76,17 +78,12 @@ module.exports = function packet_sym_encrypted_integrity_protected() {
|
|||
tohash += String.fromCharCode(0xD3);
|
||||
tohash += String.fromCharCode(0x14);
|
||||
|
||||
util.print_debug_hexstr_dump("data to be hashed:"
|
||||
, prefix + tohash);
|
||||
|
||||
tohash += str_sha1(prefix + tohash);
|
||||
tohash += crypto.hash.sha1(prefix + tohash);
|
||||
|
||||
util.print_debug_hexstr_dump("hash:"
|
||||
, tohash.substring(tohash.length - 20,
|
||||
tohash.length));
|
||||
|
||||
this.encrypted = openpgp_crypto_symmetricEncrypt(prefixrandom,
|
||||
symmetric_algorithm, key, tohash, false).substring(0,
|
||||
this.encrypted = crypto.symmetric.encrypt(prefixrandom,
|
||||
sessionKeyAlgorithm, key, tohash, false).substring(0,
|
||||
prefix.length + tohash.length);
|
||||
}
|
||||
|
||||
|
|
@ -94,23 +91,22 @@ module.exports = function packet_sym_encrypted_integrity_protected() {
|
|||
* Decrypts the encrypted data contained in this object read_packet must
|
||||
* have been called before
|
||||
*
|
||||
* @param {Integer} symmetric_algorithm_type
|
||||
* @param {Integer} sessionKeyAlgorithm
|
||||
* The selected symmetric encryption algorithm to be used
|
||||
* @param {String} key The key of cipher blocksize length to be used
|
||||
* @return {String} The decrypted data of this packet
|
||||
*/
|
||||
this.decrypt = function(symmetric_algorithm_type, key) {
|
||||
var decrypted = openpgp_crypto_symmetricDecrypt(
|
||||
symmetric_algorithm_type, key, this.encrypted, false);
|
||||
this.decrypt = function(sessionKeyAlgorithm, key) {
|
||||
var decrypted = crypto.symmetric.decrypt(
|
||||
sessionKeyAlgorithm, key, this.encrypted, false);
|
||||
|
||||
|
||||
// there must be a modification detection code packet as the
|
||||
// last packet and everything gets hashed except the hash itself
|
||||
this.hash = str_sha1(
|
||||
openpgp_crypto_MDCSystemBytes(symmetric_algorithm_type, key, this.encrypted)
|
||||
this.hash = crypto.hash.sha1(
|
||||
crypto.MDCSystemBytes(sessionKeyAlgorithm, key, this.encrypted)
|
||||
+ decrypted.substring(0, decrypted.length - 20));
|
||||
|
||||
util.print_debug_hexstr_dump("calc hash = ", this.hash);
|
||||
|
||||
var mdc = decrypted.substr(decrypted.length - 20, 20);
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,10 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var type_s2k = require('../type/s2k.js'),
|
||||
enums = require('../enums.js'),
|
||||
crypto = require('../crypto');
|
||||
|
||||
/**
|
||||
* @class
|
||||
* @classdesc Public-Key Encrypted Session Key Packets (Tag 1)
|
||||
|
|
@ -33,10 +37,10 @@
|
|||
*/
|
||||
module.exports = function packet_sym_encrypted_session_key() {
|
||||
this.tag = 3;
|
||||
this.private_algorithm = null;
|
||||
this.algorithm = openpgp.symmetric.aes256;
|
||||
this.sessionKeyEncryptionAlgorithm = null;
|
||||
this.sessionKeyAlgorithm = 'aes256';
|
||||
this.encrypted = null;
|
||||
this.s2k = new openpgp_type_s2k();
|
||||
this.s2k = new type_s2k();
|
||||
|
||||
/**
|
||||
* Parsing function for a symmetric encrypted session key packet (tag 3).
|
||||
|
|
@ -53,7 +57,7 @@ module.exports = function packet_sym_encrypted_session_key() {
|
|||
this.version = bytes[0].charCodeAt();
|
||||
|
||||
// A one-octet number describing the symmetric algorithm used.
|
||||
var algo = bytes[1].charCodeAt();
|
||||
var algo = enums.read(enums.symmetric, bytes[1].charCodeAt());
|
||||
|
||||
// A string-to-key (S2K) specifier, length as defined above.
|
||||
var s2klength = this.s2k.read(bytes.substr(2));
|
||||
|
|
@ -64,18 +68,19 @@ module.exports = function packet_sym_encrypted_session_key() {
|
|||
|
||||
if(done < bytes.length) {
|
||||
this.encrypted = bytes.substr(done);
|
||||
this.private_algorithm = algo
|
||||
this.sessionKeyEncryptionAlgorithm = algo
|
||||
}
|
||||
else
|
||||
this.algorithm = algo;
|
||||
this.sessionKeyAlgorithm = algo;
|
||||
}
|
||||
|
||||
this.write = function() {
|
||||
var algo = this.encrypted == null ? this.algorithm :
|
||||
this.private_algorithm;
|
||||
var algo = this.encrypted == null ?
|
||||
this.sessionKeyAlgorithm :
|
||||
this.sessionKeyEncryptionAlgorithm;
|
||||
|
||||
var bytes = String.fromCharCode(this.version) +
|
||||
String.fromCharCode(algo) +
|
||||
String.fromCharCode(enums.write(enums.symmetric, algo)) +
|
||||
this.s2k.write();
|
||||
|
||||
if(this.encrypted != null)
|
||||
|
|
@ -94,38 +99,41 @@ module.exports = function packet_sym_encrypted_session_key() {
|
|||
* @return {String} The unencrypted session key
|
||||
*/
|
||||
this.decrypt = function(passphrase) {
|
||||
var algo = this.private_algorithm != null ?
|
||||
this.private_algorithm :
|
||||
this.algorithm
|
||||
var algo = this.sessionKeyEncryptionAlgorithm != null ?
|
||||
this.sessionKeyEncryptionAlgorithm :
|
||||
this.sessionKeyAlgorithm;
|
||||
|
||||
var length = openpgp_crypto_getKeyLength(algo);
|
||||
|
||||
var length = crypto.getKeyLength(algo);
|
||||
var key = this.s2k.produce_key(passphrase, length);
|
||||
|
||||
if(this.encrypted == null) {
|
||||
this.key = key;
|
||||
this.sessionKey = key;
|
||||
|
||||
} else {
|
||||
var decrypted = openpgp_crypto_symmetricDecrypt(
|
||||
this.private_algorithm, key, this.encrypted, true);
|
||||
var decrypted = crypto.symmetric.decrypt(
|
||||
this.sessionKeyEncryptionAlgorithm, key, this.encrypted, true);
|
||||
|
||||
this.algorithm = decrypted[0].keyCodeAt();
|
||||
this.key = decrypted.substr(1);
|
||||
this.sessionKeyAlgorithm = enums.read(enums.symmetric,
|
||||
decrypted[0].keyCodeAt());
|
||||
|
||||
this.sessionKey = decrypted.substr(1);
|
||||
}
|
||||
}
|
||||
|
||||
this.encrypt = function(passphrase) {
|
||||
var length = openpgp_crypto_getKeyLength(this.private_algorithm);
|
||||
var length = crypto.getKeyLength(this.sessionKeyEncryptionAlgorithm);
|
||||
var key = this.s2k.produce_key(passphrase, length);
|
||||
|
||||
var private_key = String.fromCharCode(
|
||||
enums.write(enums.symmetric, this.sessionKeyAlgorithm)) +
|
||||
|
||||
|
||||
var private_key = String.fromCharCode(this.algorithm) +
|
||||
openpgp_crypto_getRandomBytes(
|
||||
openpgp_crypto_getKeyLength(this.algorithm));
|
||||
crypto.getRandomBytes(
|
||||
crypto.getKeyLength(this.sessionKeyAlgorithm));
|
||||
|
||||
this.encrypted = openpgp_crypto_symmetricEncrypt(
|
||||
openpgp_crypto_getPrefixRandom(this.private_algorithm),
|
||||
this.private_algorithm, key, private_key, true);
|
||||
this.encrypted = crypto.symmetric.encrypt(
|
||||
crypto.getPrefixRandom(this.sessionKeyEncryptionAlgorithm),
|
||||
this.sessionKeyEncryptionAlgorithm, key, private_key, true);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,8 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var crypto = require('../crypto');
|
||||
|
||||
/**
|
||||
* @class
|
||||
* @classdesc Implementation of the Symmetrically Encrypted Data Packet (Tag 9)
|
||||
|
|
@ -45,16 +47,16 @@ module.exports = function packet_symmetrically_encrypted() {
|
|||
/**
|
||||
* Symmetrically decrypt the packet data
|
||||
*
|
||||
* @param {Integer} symmetric_algorithm_type
|
||||
* @param {Integer} sessionKeyAlgorithm
|
||||
* Symmetric key algorithm to use // See RFC4880 9.2
|
||||
* @param {String} key
|
||||
* Key as string with the corresponding length to the
|
||||
* algorithm
|
||||
* @return The decrypted data;
|
||||
*/
|
||||
this.decrypt = function(symmetric_algorithm_type, key) {
|
||||
var decrypted = openpgp_crypto_symmetricDecrypt(
|
||||
symmetric_algorithm_type, key, this.encrypted, true);
|
||||
this.decrypt = function(sessionKeyAlgorithm, key) {
|
||||
var decrypted = crypto.symmetric.decrypt(
|
||||
sessionKeyAlgorithm, key, this.encrypted, true);
|
||||
|
||||
this.packets.read(decrypted);
|
||||
}
|
||||
|
|
@ -62,7 +64,7 @@ module.exports = function packet_symmetrically_encrypted() {
|
|||
this.encrypt = function(algo, key) {
|
||||
var data = this.packets.write();
|
||||
|
||||
this.encrypted = openpgp_crypto_symmetricEncrypt(
|
||||
openpgp_crypto_getPrefixRandom(algo), algo, key, data, true);
|
||||
this.encrypted = crypto.symmetric.encrypt(
|
||||
crypto.getPrefixRandom(algo), algo, key, data, true);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
section "Enhanced Key Formats" below describes how Key IDs are
|
||||
formed.
|
||||
*/
|
||||
function openpgp_type_keyid() {
|
||||
module.exports = function keyid() {
|
||||
var bytes = '';
|
||||
|
||||
for(var i = 0; i < 8; i++)
|
||||
|
|
@ -35,19 +35,11 @@ function openpgp_type_keyid() {
|
|||
* id from input
|
||||
* @return {openpgp_type_keyid} This object
|
||||
*/
|
||||
function read_packet(input, position) {
|
||||
this.bytes = input.substring(position, position+8);
|
||||
return this;
|
||||
this.read = function(bytes) {
|
||||
this.bytes = bytes.substr(0, 8);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates debug output (pretty print)
|
||||
* @return {String} Key Id as hexadecimal string
|
||||
*/
|
||||
function toString() {
|
||||
return util.hexstrdump(this.bytes);
|
||||
|
||||
this.write = function() {
|
||||
return this.bytes;
|
||||
}
|
||||
|
||||
this.read_packet = read_packet;
|
||||
this.toString = toString;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -15,6 +15,10 @@
|
|||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
var enums = require('../enums.js'),
|
||||
util = require('../util'),
|
||||
crypto = require('../crypto');
|
||||
|
||||
/**
|
||||
* @class
|
||||
* @classdesc Implementation of the String-to-key specifier (RFC4880 3.7)
|
||||
|
|
@ -24,15 +28,15 @@
|
|||
private keyring, and to convert passphrases to encryption keys for
|
||||
symmetrically encrypted messages.
|
||||
*/
|
||||
function openpgp_type_s2k() {
|
||||
module.exports = function s2k() {
|
||||
/** @type {openpgp.hash} */
|
||||
this.algorithm = openpgp.hash.sha256;
|
||||
this.algorithm = 'sha256';
|
||||
/** @type {openpgp_type_s2k.type} */
|
||||
this.type = openpgp_type_s2k.type.iterated;
|
||||
this.type = 'iterated';
|
||||
this.c = 96;
|
||||
/** @type {openpgp_bytearray}
|
||||
* Eight bytes of salt. */
|
||||
this.salt = openpgp_crypto_getRandomBytes(8);
|
||||
this.salt = crypto.random.getRandomBytes(8);
|
||||
|
||||
|
||||
// Exponen bias, defined in RFC4880
|
||||
|
|
@ -49,21 +53,19 @@ function openpgp_type_s2k() {
|
|||
*/
|
||||
this.read = function(bytes) {
|
||||
var i = 0;
|
||||
this.type = bytes[i++].charCodeAt();
|
||||
this.algorithm = bytes[i++].charCodeAt();
|
||||
|
||||
var t = openpgp_type_s2k.type;
|
||||
this.type = enums.read(enums.s2k, bytes[i++].charCodeAt());
|
||||
this.algorithm = enums.read(enums.hash, bytes[i++].charCodeAt());
|
||||
|
||||
switch (this.type) {
|
||||
case t.simple:
|
||||
case 'simple':
|
||||
break;
|
||||
|
||||
case t.salted:
|
||||
case 'salted':
|
||||
this.salt = bytes.substr(i, 8);
|
||||
i += 8;
|
||||
break;
|
||||
|
||||
case t.iterated:
|
||||
case 'iterated':
|
||||
this.salt = bytes.substr(i, 8);
|
||||
i += 8;
|
||||
|
||||
|
|
@ -71,7 +73,7 @@ function openpgp_type_s2k() {
|
|||
this.c = bytes[i++].charCodeAt();
|
||||
break;
|
||||
|
||||
case t.gnu:
|
||||
case 'gnu':
|
||||
if(bytes.substr(i, 3) == "GNU") {
|
||||
i += 3; // GNU
|
||||
var gnuExtType = 1000 + bytes[i++].charCodeAt();
|
||||
|
|
@ -79,15 +81,15 @@ function openpgp_type_s2k() {
|
|||
this.type = gnuExtType;
|
||||
// GnuPG extension mode 1001 -- don't write secret key at all
|
||||
} else {
|
||||
util.print_error("unknown s2k gnu protection mode! "+this.type);
|
||||
throw new Error("Unknown s2k gnu protection mode.");
|
||||
}
|
||||
} else {
|
||||
util.print_error("unknown s2k type! "+this.type);
|
||||
throw new Error("Unknown s2k type.");
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
util.print_error("unknown s2k type! "+this.type);
|
||||
throw new Error("Unknown s2k type.");
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -100,17 +102,16 @@ function openpgp_type_s2k() {
|
|||
* @return {String} Produced key of hashAlgorithm hash length
|
||||
*/
|
||||
this.write = function() {
|
||||
var bytes = String.fromCharCode(this.type);
|
||||
bytes += String.fromCharCode(this.algorithm);
|
||||
var bytes = String.fromCharCode(enums.write(enums.s2k, this.type));
|
||||
bytes += String.fromCharCode(enums.write(enums.hash, this.algorithm));
|
||||
|
||||
var t = openpgp_type_s2k.type;
|
||||
switch(this.type) {
|
||||
case t.simple:
|
||||
case 'simple':
|
||||
break;
|
||||
case t.salted:
|
||||
case 'salted':
|
||||
bytes += this.salt;
|
||||
break;
|
||||
case t.iterated:
|
||||
case 'iterated':
|
||||
bytes += this.salt;
|
||||
bytes += String.fromCharCode(this.c);
|
||||
break;
|
||||
|
|
@ -130,17 +131,17 @@ function openpgp_type_s2k() {
|
|||
passphrase = util.encode_utf8(passphrase);
|
||||
|
||||
function round(prefix, s2k) {
|
||||
var algorithm = enums.write(enums.hash, s2k.algorithm);
|
||||
|
||||
var t = openpgp_type_s2k.type;
|
||||
switch(s2k.type) {
|
||||
case t.simple:
|
||||
return openpgp_crypto_hashData(s2k.algorithm, prefix + passphrase);
|
||||
case 'simple':
|
||||
return crypto.hash.digest(algorithm, prefix + passphrase);
|
||||
|
||||
case t.salted:
|
||||
return openpgp_crypto_hashData(s2k.algorithm,
|
||||
case 'salted':
|
||||
return crypto.hash.digest(algorithm,
|
||||
prefix + s2k.salt + passphrase);
|
||||
|
||||
case t.iterated:
|
||||
case 'iterated':
|
||||
var isp = [],
|
||||
count = s2k.get_count();
|
||||
data = s2k.salt + passphrase;
|
||||
|
|
@ -153,7 +154,7 @@ function openpgp_type_s2k() {
|
|||
if (isp.length > count)
|
||||
isp = isp.substr(0, count);
|
||||
|
||||
return openpgp_crypto_hashData(s2k.algorithm, prefix + isp);
|
||||
return crypto.hash.digest(algorithm, prefix + isp);
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -170,13 +171,3 @@ function openpgp_type_s2k() {
|
|||
}
|
||||
|
||||
|
||||
|
||||
/** A string to key specifier type
|
||||
* @enum {Integer}
|
||||
*/
|
||||
openpgp_type_s2k.type = {
|
||||
simple: 0,
|
||||
salted: 1,
|
||||
iterated: 3,
|
||||
gnu: 101
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ unittests.register("Packet testing", function() {
|
|||
|
||||
|
||||
var tests = [function() {
|
||||
var message = new openpgp_packetlist();
|
||||
var message = new openpgp.packet.list();
|
||||
|
||||
var literal = new openpgp.packet.literal();
|
||||
literal.set('Hello world', 'utf8');
|
||||
|
|
@ -107,8 +107,8 @@ unittests.register("Packet testing", function() {
|
|||
|
||||
parsed[0].decrypt('test');
|
||||
|
||||
var key = parsed[0].key;
|
||||
parsed[1].decrypt(parsed[0].algorithm, key);
|
||||
var key = parsed[0].sessionKey;
|
||||
parsed[1].decrypt(parsed[0].sessionKeyAlgorithm, key);
|
||||
var compressed = parsed[1].packets[0];
|
||||
|
||||
var result = compressed.packets[0].data;
|
||||
|
|
@ -133,10 +133,10 @@ unittests.register("Packet testing", function() {
|
|||
msg = new openpgp.packet.list(),
|
||||
msg2 = new openpgp.packet.list();
|
||||
|
||||
enc.symmetric_key = '12345678901234567890123456789012';
|
||||
enc.public_key_algorithm = 'rsa_encrypt';
|
||||
enc.symmetric_algorithm = 'aes256';
|
||||
enc.public_key_id.bytes = '12345678';
|
||||
enc.sessionKey = '12345678901234567890123456789012';
|
||||
enc.publicKeyAlgorithm = 'rsa_encrypt';
|
||||
enc.sessionKeyAlgorithm = 'aes256';
|
||||
enc.publicKeyId.bytes = '12345678';
|
||||
enc.encrypt({ mpi: mpi });
|
||||
|
||||
msg.push(enc);
|
||||
|
|
@ -146,8 +146,8 @@ unittests.register("Packet testing", function() {
|
|||
msg2[0].decrypt({ mpi: mpi });
|
||||
|
||||
return new test_result('Public key encrypted symmetric key packet',
|
||||
msg2[0].symmetric_key == enc.symmetric_key &&
|
||||
msg2[0].symmetric_algorithm == enc.symmetric_algorithm);
|
||||
msg2[0].sessionKey == enc.sessionKey &&
|
||||
msg2[0].sessionKeyAlgorithm == enc.sessionKeyAlgorithm);
|
||||
}, function() {
|
||||
var armored_key =
|
||||
'-----BEGIN PGP PRIVATE KEY BLOCK-----\n' +
|
||||
|
|
@ -172,23 +172,23 @@ unittests.register("Packet testing", function() {
|
|||
'-----END PGP PRIVATE KEY BLOCK-----';
|
||||
|
||||
key = new openpgp.packet.list();
|
||||
key.read(openpgp.armor.decoce(armored_key).openpgp);
|
||||
key.read(openpgp.armor.decode(armored_key).openpgp);
|
||||
key = key[0];
|
||||
|
||||
var enc = new openpgp.packet.public_key_encrypted_session_key(),
|
||||
secret = '12345678901234567890123456789012';
|
||||
|
||||
enc.symmetric_key = secret;
|
||||
enc.public_key_algorithm = openpgp.publickey.rsa_encrypt;
|
||||
enc.symmetric_algorithm = openpgp.symmetric.aes256;
|
||||
enc.public_key_id.bytes = '12345678';
|
||||
enc.sessionKey = secret;
|
||||
enc.publicKeyAlgorithm = 'rsa_encrypt';
|
||||
enc.sessionKeyAlgorithm = 'aes256';
|
||||
enc.publicKeyId.bytes = '12345678';
|
||||
|
||||
enc.encrypt(key);
|
||||
|
||||
enc.decrypt(key);
|
||||
|
||||
return new test_result('Secret key packet (reading, unencrpted)',
|
||||
enc.symmetric_key == secret);
|
||||
enc.sessionKey == secret);
|
||||
}, function() {
|
||||
|
||||
var armored_key =
|
||||
|
|
@ -247,7 +247,7 @@ unittests.register("Packet testing", function() {
|
|||
msg.read(openpgp.armor.decode(armored_msg).openpgp);
|
||||
|
||||
msg[0].decrypt(key);
|
||||
msg[1].decrypt(msg[0].symmetric_algorithm, msg[0].symmetric_key);
|
||||
msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
|
||||
|
||||
var text = msg[1].packets[0].packets[0].data;
|
||||
|
||||
|
|
@ -267,12 +267,12 @@ unittests.register("Packet testing", function() {
|
|||
msg.push(key_enc);
|
||||
msg.push(enc);
|
||||
|
||||
key_enc.algorithm = algo;
|
||||
key_enc.sessionKeyAlgorithm = algo;
|
||||
key_enc.decrypt(passphrase);
|
||||
|
||||
var key = key_enc.key;
|
||||
var key = key_enc.sessionKey;
|
||||
|
||||
literal.set_data('Hello world!', 'utf8');
|
||||
literal.set('Hello world!', 'utf8');
|
||||
enc.packets.push(literal);
|
||||
enc.encrypt(algo, key);
|
||||
|
||||
|
|
@ -281,8 +281,8 @@ unittests.register("Packet testing", function() {
|
|||
msg2.read(msg.write());
|
||||
|
||||
msg2[0].decrypt(passphrase);
|
||||
var key2 = msg2[0].key;
|
||||
msg2[1].decrypt(msg2[0].algorithm, key2);
|
||||
var key2 = msg2[0].sessionKey;
|
||||
msg2[1].decrypt(msg2[0].sessionKeyAlgorithm, key2);
|
||||
|
||||
|
||||
return new test_result('Sym encrypted session key reading/writing',
|
||||
|
|
@ -302,7 +302,7 @@ unittests.register("Packet testing", function() {
|
|||
'-----END PGP MESSAGE-----';
|
||||
|
||||
var key = new openpgp.packet.list();
|
||||
key.read(openpgp.armor.decoce(armored_key).openpgp);
|
||||
key.read(openpgp.armor.decode(armored_key).openpgp);
|
||||
key = key[3];
|
||||
key.decrypt('test');
|
||||
|
||||
|
|
@ -310,7 +310,7 @@ unittests.register("Packet testing", function() {
|
|||
msg.read(openpgp.armor.decode(armored_msg).openpgp);
|
||||
|
||||
msg[0].decrypt(key);
|
||||
msg[1].decrypt(msg[0].symmetric_algorithm, msg[0].symmetric_key);
|
||||
msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
|
||||
|
||||
var text = msg[1].packets[0].packets[0].data;
|
||||
|
||||
|
|
@ -367,7 +367,7 @@ unittests.register("Packet testing", function() {
|
|||
|
||||
|
||||
msg[0].decrypt(key[3]);
|
||||
msg[1].decrypt(msg[0].symmetric_algorithm, msg[0].symmetric_key);
|
||||
msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
|
||||
|
||||
var payload = msg[1].packets[0].packets
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user