147 lines
5.0 KiB
JavaScript
147 lines
5.0 KiB
JavaScript
// 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
|
|
|
|
/**
|
|
* @class
|
|
* @classdesc Public-Key Encrypted Session Key Packets (Tag 1)
|
|
*
|
|
* RFC4880 5.1: A Public-Key Encrypted Session Key packet holds the session key
|
|
* used to encrypt a message. Zero or more Public-Key Encrypted Session Key
|
|
* packets and/or Symmetric-Key Encrypted Session Key packets may precede a
|
|
* Symmetrically Encrypted Data Packet, which holds an encrypted message. The
|
|
* message is encrypted with the session key, and the session key is itself
|
|
* encrypted and stored in the Encrypted Session Key packet(s). The
|
|
* Symmetrically Encrypted Data Packet is preceded by one Public-Key Encrypted
|
|
* Session Key packet for each OpenPGP key to which the message is encrypted.
|
|
* The recipient of the message finds a session key that is encrypted to their
|
|
* public key, decrypts the session key, and then uses the session key to
|
|
* decrypt the message.
|
|
*/
|
|
function openpgp_packet_sym_encrypted_session_key() {
|
|
this.tag = 3;
|
|
this.private_algorithm = null;
|
|
this.algorithm = openpgp.symmetric.aes256;
|
|
this.encrypted = null;
|
|
this.s2k = new openpgp_type_s2k();
|
|
|
|
/**
|
|
* Parsing function for a symmetric encrypted session key packet (tag 3).
|
|
*
|
|
* @param {String} input Payload of a tag 1 packet
|
|
* @param {Integer} position Position to start reading from the input string
|
|
* @param {Integer} len
|
|
* Length of the packet or the remaining length of
|
|
* input at position
|
|
* @return {openpgp_packet_encrypteddata} Object representation
|
|
*/
|
|
this.read = function(bytes) {
|
|
// A one-octet version number. The only currently defined version is 4.
|
|
this.version = bytes[0].charCodeAt();
|
|
|
|
// A one-octet number describing the symmetric algorithm used.
|
|
var algo = bytes[1].charCodeAt();
|
|
|
|
// A string-to-key (S2K) specifier, length as defined above.
|
|
var s2klength = this.s2k.read(bytes.substr(2));
|
|
|
|
// Optionally, the encrypted session key itself, which is decrypted
|
|
// with the string-to-key object.
|
|
var done = s2klength + 2;
|
|
|
|
if(done < bytes.length) {
|
|
this.encrypted = bytes.substr(done);
|
|
this.private_algorithm = algo
|
|
}
|
|
else
|
|
this.algorithm = algo;
|
|
}
|
|
|
|
this.write = function() {
|
|
var algo = this.encrypted == null ? this.algorithm :
|
|
this.private_algorithm;
|
|
|
|
var bytes = String.fromCharCode(this.version) +
|
|
String.fromCharCode(algo) +
|
|
this.s2k.write();
|
|
|
|
if(this.encrypted != null)
|
|
bytes += this.encrypted;
|
|
return bytes;
|
|
}
|
|
|
|
/**
|
|
* Decrypts the session key (only for public key encrypted session key
|
|
* packets (tag 1)
|
|
*
|
|
* @param {openpgp_msg_message} msg
|
|
* The message object (with member encryptedData
|
|
* @param {openpgp_msg_privatekey} key
|
|
* Private key with secMPIs unlocked
|
|
* @return {String} The unencrypted session key
|
|
*/
|
|
this.decrypt = function(passphrase) {
|
|
var algo = this.private_algorithm != null ?
|
|
this.private_algorithm :
|
|
this.algorithm
|
|
|
|
var length = openpgp_crypto_getKeyLength(algo);
|
|
var key = this.s2k.produce_key(passphrase, length);
|
|
|
|
if(this.encrypted == null) {
|
|
this.key = key;
|
|
|
|
} else {
|
|
var decrypted = openpgp_crypto_symmetricDecrypt(
|
|
this.private_algorithm, key, this.encrypted, true);
|
|
|
|
this.algorithm = decrypted[0].keyCodeAt();
|
|
this.key = decrypted.substr(1);
|
|
}
|
|
}
|
|
|
|
this.encrypt = function(passphrase) {
|
|
var length = openpgp_crypto_getKeyLength(this.private_algorithm);
|
|
var key = this.s2k.produce_key(passphrase, length);
|
|
|
|
|
|
|
|
var private_key = String.fromCharCode(this.algorithm) +
|
|
openpgp_crypto_getRandomBytes(
|
|
openpgp_crypto_getKeyLength(this.algorithm));
|
|
|
|
this.encrypted = openpgp_crypto_symmetricEncrypt(
|
|
openpgp_crypto_getPrefixRandom(this.private_algorithm),
|
|
this.private_algorithm, key, private_key, true);
|
|
}
|
|
|
|
/**
|
|
* Creates a string representation of this object (useful for debug
|
|
* purposes)
|
|
*
|
|
* @return {String} The string containing a openpgp description
|
|
*/
|
|
this.toString = function() {
|
|
return '5.3 Symmetric-Key Encrypted Session Key Packets (Tag 3)\n'
|
|
+ ' KeyId: ' + this.keyId.toString() + '\n'
|
|
+ ' length: ' + this.packetLength + '\n'
|
|
+ ' version:' + this.version + '\n' + ' symKeyA:'
|
|
+ this.symmetricKeyAlgorithmUsed + '\n' + ' s2k: '
|
|
+ this.s2k + '\n';
|
|
}
|
|
};
|
|
|