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

Cleanup of symmetric crypto functions and definitions. Broke a few tests.

Browse Source
This commit is contained in:
Michal Kolodziej 2013-05-12 14:27:23 +02:00
parent 664ab71686
commit 3537b92a51
20 changed files with 1304 additions and 1571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2354
resources/openpgp.js
View File

File diff suppressed because one or more lines are too long

77
src/crypto/cfb.js
View File

@ -15,7 +15,8 @@
* materials provided with the application or distribution.
*/
var util = require('../util');
var util = require('../util'),
cipher = require('./cipher');
module.exports = {
@ -51,7 +52,10 @@ module.exports = {
* encryptedintegrityprotecteddata packet is not resyncing the IV.
* @return {String} a string with the encrypted data
*/
encrypt: function (prefixrandom, blockcipherencryptfn, plaintext, block_size, key, resync) {
encrypt: function (prefixrandom, cipherfn, plaintext, key, resync) {
cipherfn = new cipher[cipherfn](key);
var block_size = cipherfn.blockSize;
var FR = new Array(block_size);
var FRE = new Array(block_size);
@ -63,7 +67,7 @@ module.exports = {
// 2. FR is encrypted to produce FRE (FR Encrypted). This is the
// encryption of an all-zero value.
FRE = blockcipherencryptfn(FR, key);
FRE = cipherfn.encrypt(FR);
// 3. FRE is xored with the first BS octets of random data prefixed to
// the plaintext to produce C[1] through C[BS], the first BS octets
// of ciphertext.
@ -74,7 +78,7 @@ module.exports = {
// 5. FR is encrypted to produce FRE, the encryption of the first BS
// octets of ciphertext.
FRE = blockcipherencryptfn(FR, key);
FRE = cipherfn.encrypt(FR);
// 6. The left two octets of FRE get xored with the next two octets of
// data that were prefixed to the plaintext. This produces C[BS+1]
@ -89,7 +93,7 @@ module.exports = {
for (var i = 0; i < block_size; i++) FR[i] = ciphertext.charCodeAt(i);
}
// 8. FR is encrypted to produce FRE.
FRE = blockcipherencryptfn(FR, key);
FRE = cipherfn.encrypt(FR, key);
if (resync) {
// 9. FRE is xored with the first 8 octets of the given plaintext, now
@ -102,7 +106,7 @@ module.exports = {
for (var i = 0; i < block_size; i++) FR[i] = ciphertext.charCodeAt(n+i);
// 11. FR is encrypted to produce FRE.
FRE = blockcipherencryptfn(FR, key);
FRE = cipherfn.encrypt(FR);
// 12. FRE is xored with the next 8 octets of plaintext, to produce the
// next 8 octets of ciphertext. These are loaded into FR and the
@ -124,7 +128,7 @@ module.exports = {
tempCiphertextString='';
// 11. FR is encrypted to produce FRE.
FRE = blockcipherencryptfn(FR, key);
FRE = cipherfn.encrypt(FR);
// 12. FRE is xored with the next 8 octets of plaintext, to produce the
// next 8 octets of ciphertext. These are loaded into FR and the
@ -136,33 +140,40 @@ module.exports = {
ciphertext = tempCiphertext.join('');
}
ciphertext = ciphertext.substring(0, plaintext.length + 2 + block_size);
return ciphertext;
},
/**
* Decrypts the prefixed data for the Modification Detection Code (MDC) computation
* @param {openpgp_block_cipher_fn} blockcipherencryptfn Cipher function to use
* @param {openpgp_block_cipher_fn} cipherfn.encrypt Cipher function to use
* @param {Integer} block_size Blocksize of the algorithm
* @param {openpgp_byte_array} key The key for encryption
* @param {String} ciphertext The encrypted data
* @return {String} plaintext Data of D(ciphertext) with blocksize length +2
*/
mdc: function (blockcipherencryptfn, block_size, key, ciphertext) {
mdc: function (cipherfn, key, ciphertext) {
cipherfn = new cipher[cipherfn](key);
var block_size = cipherfn.blockSize;
var iblock = new Array(block_size);
var ablock = new Array(block_size);
var i;
// initialisation vector
for(i=0; i < block_size; i++) iblock[i] = 0;
iblock = blockcipherencryptfn(iblock, key);
iblock = cipherfn.encrypt(iblock);
for(i = 0; i < block_size; i++)
{
ablock[i] = ciphertext.charCodeAt(i);
iblock[i] ^= ablock[i];
}
ablock = blockcipherencryptfn(ablock, key);
ablock = cipherfn.encrypt(ablock);
return util.bin2str(iblock)+
String.fromCharCode(ablock[0]^ciphertext.charCodeAt(block_size))+
@ -184,9 +195,10 @@ module.exports = {
* @return {String} a string with the plaintext data
*/
decrypt: function (blockcipherencryptfn, block_size, key, ciphertext, resync)
{
util.print_debug("resync:"+resync);
decrypt: function (cipherfn, key, ciphertext, resync) {
cipherfn = new cipher[cipherfn](key);
var block_size = cipherfn.blockSize;
var iblock = new Array(block_size);
var ablock = new Array(block_size);
var i, n = '';
@ -195,24 +207,20 @@ module.exports = {
// initialisation vector
for(i=0; i < block_size; i++) iblock[i] = 0;
iblock = blockcipherencryptfn(iblock, key);
iblock = cipherfn.encrypt(iblock, key);
for(i = 0; i < block_size; i++)
{
ablock[i] = ciphertext.charCodeAt(i);
iblock[i] ^= ablock[i];
}
ablock = blockcipherencryptfn(ablock, key);
ablock = cipherfn.encrypt(ablock, key);
util.print_debug("openpgp_cfb_decrypt:\niblock:"+util.hexidump(iblock)+"\nablock:"+util.hexidump(ablock)+"\n");
util.print_debug((ablock[0]^ciphertext.charCodeAt(block_size)).toString(16)+(ablock[1]^ciphertext.charCodeAt(block_size+1)).toString(16));
// test check octets
if(iblock[block_size-2]!=(ablock[0]^ciphertext.charCodeAt(block_size))
|| iblock[block_size-1]!=(ablock[1]^ciphertext.charCodeAt(block_size+1)))
{
util.print_eror("error duding decryption. Symmectric encrypted data not valid.");
return text.join('');
throw new Error('Invalid data.');
}
/* RFC4880: Tag 18 and Resync:
@ -226,7 +234,7 @@ module.exports = {
for(i=0; i<block_size; i++) iblock[i] = ciphertext.charCodeAt(i+2);
for(n=block_size+2; n<ciphertext.length; n+=block_size)
{
ablock = blockcipherencryptfn(iblock, key);
ablock = cipherfn.encrypt(iblock);
for(i = 0; i<block_size && i+n < ciphertext.length; i++)
{
@ -238,7 +246,7 @@ module.exports = {
for(i=0; i<block_size; i++) iblock[i] = ciphertext.charCodeAt(i);
for(n=block_size; n<ciphertext.length; n+=block_size)
{
ablock = blockcipherencryptfn(iblock, key);
ablock = cipherfn.encrypt(iblock);
for(i = 0; i<block_size && i+n < ciphertext.length; i++)
{
iblock[i] = ciphertext.charCodeAt(n+i);
@ -246,12 +254,22 @@ module.exports = {
}
}
}
var n = resync ? 0 : 2;
text = text.join('');
text = text.substring(n, ciphertext.length - block_size - 2 + n);
return text.join('');
return text;
},
normalEncrypt: function(blockcipherencryptfn, block_size, key, plaintext, iv) {
normalEncrypt: function(cipherfn, key, plaintext, iv) {
cipherfn = new cipher[cipherfn](key);
var block_size = cipherfn.blockSize;
var blocki ="";
var blockc = "";
var pos = 0;
@ -259,7 +277,7 @@ module.exports = {
var tempBlock = [];
blockc = iv.substring(0,block_size);
while (plaintext.length > block_size*pos) {
var encblock = blockcipherencryptfn(blockc, key);
var encblock = cipherfn.encrypt(util.str2bin(blockc));
blocki = plaintext.substring((pos*block_size),(pos*block_size)+block_size);
for (var i=0; i < blocki.length; i++)
tempBlock.push(String.fromCharCode(blocki.charCodeAt(i) ^ encblock[i]));
@ -271,7 +289,10 @@ module.exports = {
return cyphertext.join('');
},
normalDecrypt: function(blockcipherencryptfn, block_size, key, ciphertext, iv) {
normalDecrypt: function(cipherfn, key, ciphertext, iv) {
cipherfn = new cipher[cipherfn](key);
var block_size = cipherfn.blockSize;
var blockp ="";
var pos = 0;
var plaintext = [];
@ -281,7 +302,7 @@ module.exports = {
else
blockp = iv.substring(0,block_size);
while (ciphertext.length > (block_size*pos)) {
var decblock = blockcipherencryptfn(blockp, key);
var decblock = cipherfn.encrypt(util.str2bin(blockp));
blockp = ciphertext.substring((pos*(block_size))+offset,(pos*(block_size))+(block_size)+offset);
for (var i=0; i < blockp.length; i++) {
plaintext.push(String.fromCharCode(blockp.charCodeAt(i) ^ decblock[i]));

25
src/crypto/cipher/aes.js
View File

@ -485,7 +485,26 @@ function AESencrypt(block, ctx)
return unpackBytes(b);
}
module.exports = {
encrypt: AESencrypt,
keyExpansion: keyExpansion
function makeClass(length) {
var c = function(key) {
this.key = keyExpansion(key);
this.encrypt = function(block) {
return AESencrypt(block, this.key);
}
}
c.blockSize = c.prototype.blockSize = 16;
c.keySize = c.prototype.keySize = length / 8;
return c;
}
module.exports = {}
var types = [128, 192, 256];
for(var i in types ) {
module.exports[types[i]] = makeClass(types[i]);
}

16
src/crypto/cipher/blowfish.js
View File

@ -394,4 +394,18 @@ function BFencrypt(block,key) {
return bf.encrypt_block(block);
}
module.exports = BFencrypt;
function BF(key) {
this.bf = new Blowfish();
this.bf.init(util.str2bin(key));
this.encrypt = function(block) {
return this.bf.encrypt_block(block);
}
}
module.exports = BF;
module.exports.keySize = BF.prototype.keySize = 16;
module.exports.blockSize = BF.prototype.blockSize = 16;

21
src/crypto/cipher/cast5.js
View File

@ -15,13 +15,7 @@
// CAST5 constructor
var util = require('../../util');
function cast5_encrypt(block, key) {
var cast5 = new openpgp_symenc_cast5();
cast5.setKey(util.str2bin(key));
return cast5.encrypt(block);
}
function openpgp_symenc_cast5() {
this.BlockSize= 8;
@ -547,6 +541,17 @@ function openpgp_symenc_cast5() {
};
var util = require('../../util');
module.exports = cast5_encrypt;
module.exports.castClass = openpgp_symenc_cast5;
function cast5(key) {
this.cast5 = new openpgp_symenc_cast5();
this.cast5.setKey(util.str2bin(key));
this.encrypt = function(block) {
return this.cast5.encrypt(block);
}
}
module.exports = cast5;
module.exports.blockSize = cast5.prototype.blockSize = 8;
module.exports.keySize = cast5.prototype.keySize = 16;

31
src/crypto/cipher/des.js
View File

@ -21,15 +21,7 @@
//des
//this takes the key, the message, and whether to encrypt or decrypt
var util = require('../../util');
// added by Recurity Labs
function desede(block,key) {
var key1 = key.substring(0,8);
var key2 = key.substring(8,16);
var key3 = key.substring(16,24);
return util.str2bin(des(des_createKeys(key3),des(des_createKeys(key2),des(des_createKeys(key1),util.bin2str(block), true, 0,null,null), false, 0,null,null), true, 0,null,null));
}
function des (keys, message, encrypt, mode, iv, padding) {
@ -207,5 +199,26 @@ function des_createKeys (key) {
return keys;
} //end of des_createKeys
var util = require('../../util');
// added by Recurity Labs
function Des(key) {
this.key = [];
for(var i = 0; i < 3; i++) {
this.key.push(key.substr(i * 8, 8));
}
this.encrypt = function(block) {
return util.str2bin(des(des_createKeys(this.key[2]),
des(des_createKeys(this.key[1]),
des(des_createKeys(this.key[0]),
util.bin2str(block), true, 0,null,null),
false, 0,null,null), true, 0,null,null));
}
}
module.exports = Des;
module.exports.keySize = Des.prototype.keySize = 24;
module.exports.blockSize = Des.prototype.blockSize = 8;
module.exports = desede;

6
src/crypto/cipher/index.js
View File

@ -1,9 +1,13 @@
module.exports = {
aes: require('./aes.js'),
des: require('./des.js'),
cast5: require('./cast5.js'),
twofish: require('./twofish.js'),
blowfish: require('./blowfish.js')
}
var aes = require('./aes.js');
for(var i in aes) {
module.exports['aes' + i] = aes[i];
}

36
src/crypto/cipher/twofish.js
View File

@ -18,17 +18,7 @@
*
*/
var util = require('../../util');
// added by Recurity Labs
function TFencrypt(block, key) {
var block_copy = [].concat(block);
var tf = createTwofish();
tf.open(util.str2bin(key),0);
var result = tf.encrypt(block_copy, 0);
tf.close();
return result;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Math
@ -302,4 +292,28 @@ function createTwofish() {
};
}
module.exports = TFencrypt;
var util = require('../../util');
// added by Recurity Labs
function TFencrypt(block, key) {
var block_copy = [].concat(block);
var tf = createTwofish();
tf.open(util.str2bin(key),0);
var result = tf.encrypt(block_copy, 0);
tf.close();
return result;
}
function TF(key) {
this.tf = createTwofish();
this.tf.open(util.str2bin(key),0);
this.encrypt = function(block) {
return tf.encrypt(block, 0);
}
}
module.exports = TF;
module.exports.keySize = TF.prototype.keySize = 32;
module.exports.blockSize = TF.prototype.blockSize = 32;

76
src/crypto/crypto.js
View File

@ -173,39 +173,9 @@ getPublicMpiCount: function(algo) {
* size of the cipher
*/
getPrefixRandom: function(algo) {
return random.getRandomBytes(this.getBlockLength(algo));
return random.getRandomBytes(cipher[algo].blockSize);
},
/**
* retrieve the MDC prefixed bytes by decrypting them
* @param {Integer} algo Algorithm to use (see RFC4880 9.2)
* @param {String} key Key as string. length is depending on the algorithm used
* @param {String} data Encrypted data where the prefix is decrypted from
* @return {String} Plain text data of the prefixed data
*/
MDCSystemBytes: function(algo, key, data) {
switch(algo) {
case 'plaintext': // Plaintext or unencrypted data
return data;
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.');
}
},
/**
* Generating a session key for the specified symmetric algorithm
* @param {Integer} algo Algorithm to use (see RFC4880 9.2)
@ -215,50 +185,6 @@ generateSessionKey: function(algo) {
return random.getRandomBytes(this.getKeyLength(algo));
},
/**
* Get the key length by symmetric algorithm id.
* @param {Integer} algo Algorithm to use (see RFC4880 9.2)
* @return {String} Random bytes as a string to be used as a key
*/
getKeyLength: function(algo) {
switch (algo) {
case 'des': // TripleDES (DES-EDE, [SCHNEIER] [HAC] - 168 bit key derived from 192)
case 'aes192': // AES with 192-bit key
return 24;
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 'aes256': // AES with 256-bit key
case 'twofish':// Twofish with 256-bit key [TWOFISH]
return 32;
default:
throw new Error('Invalid algorithm.');
}
},
/**
* Returns the block length of the specified symmetric encryption algorithm
* @param {openpgp.symmetric} algo Symmetric algorithm idenhifier
* @return {Integer} The number of bytes in a single block encrypted by the algorithm
*/
getBlockLength: function(algo) {
switch (algo) {
case 'des':
case 'cast5':
return 8;
case 'blowfish':
case 'aes128':
case 'aes192':
case 'aes256':
return 16;
case 'twofish':
return 32;
default:
throw new Error('Invalid algorithm.');
}
},
/**
* Create a secure random big integer of bits length
* @param {Integer} bits Bit length of the MPI to create

3
src/crypto/index.js
View File

@ -6,8 +6,7 @@ module.exports = {
publicKey: require('./public_key'),
signature: require('./signature.js'),
random: require('./random.js'),
pkcs1: require('./pkcs1.js'),
symmetric: require('./sym.js')
pkcs1: require('./pkcs1.js')
}

94
src/crypto/sym.js
View File

@ -1,94 +0,0 @@
// GPG4Browsers - An OpenPGP implementation in javascript
// Copyright (C) 2011 Recurity Labs GmbH
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
// The GPG4Browsers symmetric crypto interface
var cfb = require('./cfb.js'),
cipher = require('./cipher');
module.exports = {
/**
* Symmetrically encrypts data using prefixedrandom, a key with length
* depending on the algorithm in openpgp_cfb mode with or without resync
* (MDC style)
* @param {String} prefixrandom Secure random bytes as string in
* length equal to the block size of the algorithm used (use
* openpgp_crypto_getPrefixRandom(algo) to retrieve that string
* @param {Integer} algo Algorithm to use (see RFC4880 9.2)
* @param {String} key Key as string. length is depending on the algorithm used
* @param {String} data Data to encrypt
* @param {Boolean} openpgp_cfb
* @return {String} Encrypted data
*/
encrypt: function (prefixrandom, algo, key, data, openpgp_cfb) {
switch(algo) {
case 'plaintext': // Plaintext or unencrypted data
return data; // blockcipherencryptfn, plaintext, block_size, key
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 '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 '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 '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 'twofish': // Twofish with 256-bit key [TWOFISH]
return cfb.encrypt(prefixrandom, cipher.twofish, data,16, key, openpgp_cfb).substring(0, data.length + 18);
default:
throw new Error('Invalid algorithm.');
}
},
/**
* Symmetrically decrypts data using a key with length depending on the
* algorithm in openpgp_cfb mode with or without resync (MDC style)
* @param {Integer} algo Algorithm to use (see RFC4880 9.2)
* @param {String} key Key as string. length is depending on the algorithm used
* @param {String} data Data to be decrypted
* @param {Boolean} openpgp_cfb If true use the resync (for encrypteddata);
* otherwise use without the resync (for MDC encrypted data)
* @return {String} Plaintext data
*/
decrypt: function (algo, key, data, openpgp_cfb) {
var n = 0;
if (!openpgp_cfb)
n = 2;
switch(algo) {
case 'plaintext': // Plaintext or unencrypted data
return data;
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 '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 '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 '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 '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;
default:
throw new Error('Invalid algorithm');
}
}
}

73
src/packet/secret_key.js
View File

@ -170,7 +170,7 @@ function packet_secret_key() {
symmetric = 'aes256',
cleartext = write_cleartext_mpi('sha1', this.algorithm, this.mpi),
key = produceEncryptionKey(s2k, passphrase, symmetric),
blockLen = crypto.getBlockLength(symmetric),
blockLen = crypto.cipher[symmetric].blockSize,
iv = crypto.random.getRandomBytes(blockLen);
@ -181,34 +181,13 @@ function packet_secret_key() {
this.encrypted += iv;
var fn;
switch(symmetric) {
case 'cast5':
fn = crypto.cipher.cast5;
break;
case 'aes128':
case 'aes192':
case 'aes256':
var fn = function(block,key) {
return crypto.cipher.aes.encrypt(util.str2bin(block),key);
}
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);
this.encrypted += crypto.cfb.normalEncrypt(symmetric, key, cleartext, iv);
}
function produceEncryptionKey(s2k, passphrase, algorithm) {
return s2k.produce_key(passphrase,
crypto.getKeyLength(algorithm));
crypto.cipher[algorithm].keySize);
}
/**
@ -255,55 +234,15 @@ function packet_secret_key() {
// not zero), an Initial Vector (IV) of the same length as the
// cipher's block size.
var iv = this.encrypted.substr(i,
crypto.getBlockLength(symmetric));
crypto.cipher[symmetric].blockSize);
i += iv.length;
var cleartext,
ciphertext = this.encrypted.substr(i);
switch (symmetric) {
case 'idea': // - IDEA [IDEA]
throw new Error("IDEA is not implemented.");
return false;
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 '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 '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 '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 crypto.cipher.aes.keyExpansion(key),
ciphertext, iv);
break;
case 'twofish': // - Twofish with 256-bit key [TWOFISH]
throw new Error("Twofish is not implemented.");
return false;
default:
throw new Error("Unknown symmetric algorithm.");
return false;
}
cleartext = crypto.cfb.normalDecrypt(symmetric, key, ciphertext, iv);
var hash = s2k_usage == 254 ?
'sha1' :
'mod';

8
src/packet/sym_encrypted_integrity_protected.js
View File

@ -82,8 +82,8 @@ module.exports = function packet_sym_encrypted_integrity_protected() {
tohash += crypto.hash.sha1(prefix + tohash);
this.encrypted = crypto.symmetric.encrypt(prefixrandom,
sessionKeyAlgorithm, key, tohash, false).substring(0,
this.encrypted = crypto.cfb.encrypt(prefixrandom,
sessionKeyAlgorithm, tohash, key, false).substring(0,
prefix.length + tohash.length);
}
@ -97,14 +97,14 @@ module.exports = function packet_sym_encrypted_integrity_protected() {
* @return {String} The decrypted data of this packet
*/
this.decrypt = function(sessionKeyAlgorithm, key) {
var decrypted = crypto.symmetric.decrypt(
var decrypted = crypto.cfb.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 = crypto.hash.sha1(
crypto.MDCSystemBytes(sessionKeyAlgorithm, key, this.encrypted)
crypto.cfb.mdc(sessionKeyAlgorithm, key, this.encrypted)
+ decrypted.substring(0, decrypted.length - 20));

6
src/packet/sym_encrypted_session_key.js
View File

@ -104,14 +104,14 @@ module.exports = function packet_sym_encrypted_session_key() {
this.sessionKeyAlgorithm;
var length = crypto.getKeyLength(algo);
var length = crypto.cipher[algo].keySize;
var key = this.s2k.produce_key(passphrase, length);
if(this.encrypted == null) {
this.sessionKey = key;
} else {
var decrypted = crypto.symmetric.decrypt(
var decrypted = crypto.cfb.decrypt(
this.sessionKeyEncryptionAlgorithm, key, this.encrypted, true);
this.sessionKeyAlgorithm = enums.read(enums.symmetric,
@ -131,7 +131,7 @@ module.exports = function packet_sym_encrypted_session_key() {
crypto.getRandomBytes(
crypto.getKeyLength(this.sessionKeyAlgorithm));
this.encrypted = crypto.symmetric.encrypt(
this.encrypted = crypto.cfb.encrypt(
crypto.getPrefixRandom(this.sessionKeyEncryptionAlgorithm),
this.sessionKeyEncryptionAlgorithm, key, private_key, true);
}

6
src/packet/symmetrically_encrypted.js
View File

@ -55,7 +55,7 @@ module.exports = function packet_symmetrically_encrypted() {
* @return The decrypted data;
*/
this.decrypt = function(sessionKeyAlgorithm, key) {
var decrypted = crypto.symmetric.decrypt(
var decrypted = crypto.cfb.decrypt(
sessionKeyAlgorithm, key, this.encrypted, true);
this.packets.read(decrypted);
@ -64,7 +64,7 @@ module.exports = function packet_symmetrically_encrypted() {
this.encrypt = function(algo, key) {
var data = this.packets.write();
this.encrypted = crypto.symmetric.encrypt(
crypto.getPrefixRandom(algo), algo, key, data, true);
this.encrypted = crypto.cfb.encrypt(
crypto.getPrefixRandom(algo), algo, data, key, true);
}
};

12
test/ciphers/symmetric/aes.js
View File

@ -2,14 +2,18 @@ var openpgp = require('openpgp')
unittests.register("AES Rijndael cipher test with test vectors from ecb_tbl.txt", function() {
var util = openpgp.util,
keyExpansion = openpgp.cipher.aes.keyExpansion,
AESencrypt = openpgp.cipher.aes.encrypt;
var util = openpgp.util;
var result = new Array();
function test_aes(input, key, output) {
return (util.hexstrdump(util.bin2str(AESencrypt(input,keyExpansion(util.bin2str(key))))) == util.hexstrdump(util.bin2str(output)));
var aes = new openpgp.cipher.aes128(util.bin2str(key));
var result = util.bin2str(aes.encrypt(input));
return util.hexstrdump(result) == util.hexstrdump(util.bin2str(output));
};
var testvectors128 = [[[0x00,0x01,0x02,0x03,0x05,0x06,0x07,0x08,0x0A,0x0B,0x0C,0x0D,0x0F,0x10,0x11,0x12],[0x50,0x68,0x12,0xA4,0x5F,0x08,0xC8,0x89,0xB9,0x7F,0x59,0x80,0x03,0x8B,0x83,0x59],[0xD8,0xF5,0x32,0x53,0x82,0x89,0xEF,0x7D,0x06,0xB5,0x06,0xA4,0xFD,0x5B,0xE9,0xC9]],
[[0x14,0x15,0x16,0x17,0x19,0x1A,0x1B,0x1C,0x1E,0x1F,0x20,0x21,0x23,0x24,0x25,0x26],[0x5C,0x6D,0x71,0xCA,0x30,0xDE,0x8B,0x8B,0x00,0x54,0x99,0x84,0xD2,0xEC,0x7D,0x4B],[0x59,0xAB,0x30,0xF4,0xD4,0xEE,0x6E,0x4F,0xF9,0x90,0x7E,0xF6,0x5B,0x1F,0xB6,0x8C]],
[[0x28,0x29,0x2A,0x2B,0x2D,0x2E,0x2F,0x30,0x32,0x33,0x34,0x35,0x37,0x38,0x39,0x3A],[0x53,0xF3,0xF4,0xC6,0x4F,0x86,0x16,0xE4,0xE7,0xC5,0x61,0x99,0xF4,0x8F,0x21,0xF6],[0xBF,0x1E,0xD2,0xFC,0xB2,0xAF,0x3F,0xD4,0x14,0x43,0xB5,0x6D,0x85,0x02,0x5C,0xB1]],

5
test/ciphers/symmetric/blowfish.js
View File

@ -6,7 +6,10 @@ unittests.register("Blowfish cipher test with test vectors from http://www.schne
var result = new Array();
function test_bf(input, key, output) {
return (util.hexstrdump(util.bin2str(BFencrypt(input,util.bin2str(key)))) == util.hexstrdump(util.bin2str(output)));
var blowfish = new openpgp.cipher.blowfish(util.bin2str(key));
var result = util.bin2str(blowfish.encrypt(input));
return (util.hexstrdump(result) == util.hexstrdump(util.bin2str(output)));
};
var testvectors = [[[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x4E,0xF9,0x97,0x45,0x61,0x98,0xDD,0x78]],
[[0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF],[0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF],[0x51,0x86,0x6F,0xD5,0xB8,0x5E,0xCB,0x8A]],

8
test/ciphers/symmetric/cast5.js
View File

@ -1,12 +1,14 @@
unittests.register("CAST-128 cipher test with test vectors from RFC2144", function() {
var openpgp = require('openpgp'),
util = openpgp.util,
cast5_encrypt = openpgp.cipher.cast5;
util = openpgp.util;
var result = new Array();
function test_cast(input, key, output) {
return (util.hexstrdump(util.bin2str(cast5_encrypt(input,util.bin2str(key)))) == util.hexstrdump(util.bin2str(output)));
var cast5 = new openpgp.cipher.cast5(util.bin2str(key));
var result = util.bin2str(cast5.encrypt(input));
return util.hexstrdump(result) == util.hexstrdump(util.bin2str(output));
};
var testvectors = [[[0x01,0x23,0x45,0x67,0x12,0x34,0x56,0x78,0x23,0x45,0x67,0x89,0x34,0x56,0x78,0x9A],[0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF],[0x23,0x8B,0x4F,0xE5,0x84,0x7E,0x44,0xB2]]];

13
test/ciphers/symmetric/des.js
View File

@ -1,8 +1,7 @@
unittests.register("TripleDES (EDE) cipher test with test vectors from http://csrc.nist.gov/publications/nistpubs/800-20/800-20.pdf", function() {
var openpgp = require('openpgp'),
util = openpgp.util,
desede = openpgp.cipher.des
util = openpgp.util;
var result = new Array();
var key = util.bin2str([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]);
@ -32,13 +31,19 @@ unittests.register("TripleDES (EDE) cipher test with test vectors from http://cs
var res = true;
var j = 0;
for (var i = 0; i < testvectors.length; i++) {
var res2 = (util.bin2str(desede(testvectors[i][0], key)) == util.bin2str(testvectors[i][1]));
var des = new openpgp.cipher.des(key);
var encr = util.bin2str(des.encrypt(testvectors[i][0], key));
var res2 = encr == util.bin2str(testvectors[i][1]);
res &= res2;
if (!res2) {
result[j] = new test_result("Testing vector with block "+
util.hexidump(testvectors[i][0])+
" and key "+util.hexstrdump(key)+
" should be "+util.hexidump(testvectors[i][1])+" != "+util.hexidump(desede(testvectors[i][0], key)),
" should be "+util.hexidump(testvectors[i][1])+" != "
+util.hexidump(encr),
false);
j++;
}

5
test/ciphers/symmetric/twofish.js
View File

@ -1,8 +1,9 @@
unittests.register("Twofish test with test vectors from http://www.schneier.com/code/ecb_ival.txt", function() {
var openpgp = require('openpgp'),
util = openpgp.util,
TFencrypt = openpgp.cipher.twofish;
util = openpgp.util;
function TFencrypt() { return [];}
var result = new Array();
var start = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];