@protontech/openpgp 4.10.5 → 5.3.1

package/src/packet/packetlist.js

@@ -1,232 +0,0 @@
-/* eslint-disable callback-return */
-/**
- * @requires web-stream-tools
- * @requires packet/all_packets
- * @requires packet/packet
- * @requires config
- * @requires enums
- * @requires util
- */
-
-import stream from 'web-stream-tools';
-import * as packets from './all_packets';
-import packetParser from './packet';
-import config from '../config';
-import enums from '../enums';
-import util from '../util';
-
-/**
- * This class represents a list of openpgp packets.
- * Take care when iterating over it - the packets themselves
- * are stored as numerical indices.
- * @memberof module:packet
- * @constructor
- * @extends Array
- */
-function List() {
-  /**
-   * The number of packets contained within the list.
-   * @readonly
-   * @type {Integer}
-   */
-  this.length = 0;
-}
-
-List.prototype = [];
-
-/**
- * Reads a stream of binary data and interprents it as a list of packets.
- * @param {Uint8Array | ReadableStream<Uint8Array>} A Uint8Array of bytes.
- */
-List.prototype.read = async function (bytes, streaming) {
-  this.stream = stream.transformPair(bytes, async (readable, writable) => {
-    const writer = stream.getWriter(writable);
-    try {
-      while (true) {
-        await writer.ready;
-        const done = await packetParser.read(readable, streaming, async parsed => {
-          try {
-            const tag = enums.read(enums.packet, parsed.tag);
-            const packet = packets.newPacketFromTag(tag);
-            packet.packets = new List();
-            packet.fromStream = util.isStream(parsed.packet);
-            await packet.read(parsed.packet, streaming);
-            await writer.write(packet);
-          } catch (e) {
-            if (!config.tolerant || packetParser.supportsStreaming(parsed.tag)) {
-              // The packets that support streaming are the ones that contain
-              // message data. Those are also the ones we want to be more strict
-              // about and throw on parse errors for.
-              await writer.abort(e);
-            }
-            util.print_debug_error(e);
-          }
-        });
-        if (done) {
-          await writer.ready;
-          await writer.close();
-          return;
-        }
-      }
-    } catch (e) {
-      await writer.abort(e);
-    }
-  });
-
-  // Wait until first few packets have been read
-  const reader = stream.getReader(this.stream);
-  while (true) {
-    const { done, value } = await reader.read();
-    if (!done) {
-      this.push(value);
-    } else {
-      this.stream = null;
-    }
-    if (done || packetParser.supportsStreaming(value.tag)) {
-      break;
-    }
-  }
-  reader.releaseLock();
-};
-
-/**
- * Creates a binary representation of openpgp objects contained within the
- * class instance.
- * @returns {Uint8Array} A Uint8Array containing valid openpgp packets.
- */
-List.prototype.write = function () {
-  const arr = [];
-
-  for (let i = 0; i < this.length; i++) {
-    const packetbytes = this[i].write();
-    if (util.isStream(packetbytes) && packetParser.supportsStreaming(this[i].tag)) {
-      let buffer = [];
-      let bufferLength = 0;
-      const minLength = 512;
-      arr.push(packetParser.writeTag(this[i].tag));
-      arr.push(stream.transform(packetbytes, value => {
-        buffer.push(value);
-        bufferLength += value.length;
-        if (bufferLength >= minLength) {
-          const powerOf2 = Math.min(Math.log(bufferLength) / Math.LN2 | 0, 30);
-          const chunkSize = 2 ** powerOf2;
-          const bufferConcat = util.concat([packetParser.writePartialLength(powerOf2)].concat(buffer));
-          buffer = [bufferConcat.subarray(1 + chunkSize)];
-          bufferLength = buffer[0].length;
-          return bufferConcat.subarray(0, 1 + chunkSize);
-        }
-      }, () => util.concat([packetParser.writeSimpleLength(bufferLength)].concat(buffer))));
-    } else {
-      if (util.isStream(packetbytes)) {
-        let length = 0;
-        arr.push(stream.transform(stream.clone(packetbytes), value => {
-          length += value.length;
-        }, () => packetParser.writeHeader(this[i].tag, length)));
-      } else {
-        arr.push(packetParser.writeHeader(this[i].tag, packetbytes.length));
-      }
-      arr.push(packetbytes);
-    }
-  }
-
-  return util.concat(arr);
-};
-
-/**
- * Adds a packet to the list. This is the only supported method of doing so;
- * writing to packetlist[i] directly will result in an error.
- * @param {Object} packet Packet to push
- */
-List.prototype.push = function (packet) {
-  if (!packet) {
-    return;
-  }
-
-  packet.packets = packet.packets || new List();
-
-  this[this.length] = packet;
-  this.length++;
-};
-
-/**
- * Creates a new PacketList with all packets from the given types
- */
-List.prototype.filterByTag = function (...args) {
-  const filtered = new List();
-
-  const handle = tag => packetType => tag === packetType;
-
-  for (let i = 0; i < this.length; i++) {
-    if (args.some(handle(this[i].tag))) {
-      filtered.push(this[i]);
-    }
-  }
-
-  return filtered;
-};
-
-/**
- * Traverses packet tree and returns first matching packet
- * @param  {module:enums.packet} type The packet type
- * @returns {module:packet/packet|undefined}
- */
-List.prototype.findPacket = function (type) {
-  return this.find(packet => packet.tag === type);
-};
-
-/**
- * Returns array of found indices by tag
- */
-List.prototype.indexOfTag = function (...args) {
-  const tagIndex = [];
-  const that = this;
-
-  const handle = tag => packetType => tag === packetType;
-
-  for (let i = 0; i < this.length; i++) {
-    if (args.some(handle(that[i].tag))) {
-      tagIndex.push(i);
-    }
-  }
-  return tagIndex;
-};
-
-/**
- * Concatenates packetlist or array of packets
- */
-List.prototype.concat = function (packetlist) {
-  if (packetlist) {
-    for (let i = 0; i < packetlist.length; i++) {
-      this.push(packetlist[i]);
-    }
-  }
-  return this;
-};
-
-/**
- * Allocate a new packetlist from structured packetlist clone
- * See {@link https://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data}
- * @param {Object} packetClone packetlist clone
- * @returns {Object} new packetlist object with data from packetlist clone
- */
-List.fromStructuredClone = function(packetlistClone) {
-  const packetlist = new List();
-  for (let i = 0; i < packetlistClone.length; i++) {
-    const packet = packets.fromStructuredClone(packetlistClone[i]);
-    packetlist.push(packet);
-    if (packet.embeddedSignature) {
-      packet.embeddedSignature = packets.fromStructuredClone(packet.embeddedSignature);
-    }
-    if (packet.packets.length !== 0) {
-      packet.packets = this.fromStructuredClone(packet.packets);
-    } else {
-      packet.packets = new List();
-    }
-  }
-  if (packetlistClone.stream) {
-    packetlist.stream = stream.transform(packetlistClone.stream, packet => packets.fromStructuredClone(packet));
-  }
-  return packetlist;
-};
-
-export default List;

package/src/packet/public_key.js

@@ -1,280 +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 3.0 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
-
-/**
- * @requires type/keyid
- * @requires type/mpi
- * @requires config
- * @requires crypto
- * @requires enums
- * @requires util
- */
-
-import { Sha1 } from 'asmcrypto.js/dist_es5/hash/sha1/sha1';
-import { Sha256 } from 'asmcrypto.js/dist_es5/hash/sha256/sha256';
-import type_keyid from '../type/keyid';
-import type_mpi from '../type/mpi';
-import config from '../config';
-import crypto from '../crypto';
-import enums from '../enums';
-import util from '../util';
-
-/**
- * Implementation of the Key Material Packet (Tag 5,6,7,14)
- *
- * {@link https://tools.ietf.org/html/rfc4880#section-5.5|RFC4480 5.5}:
- * A key material packet contains all the information about a public or
- * private key.  There are four variants of this packet type, and two
- * major versions.
- *
- * A Public-Key packet starts a series of packets that forms an OpenPGP
- * key (sometimes called an OpenPGP certificate).
- * @memberof module:packet
- * @constructor
- */
-function PublicKey(date = new Date()) {
-  /**
-   * Packet type
-   * @type {module:enums.packet}
-   */
-  this.tag = enums.packet.publicKey;
-  /**
-   * Packet version
-   * @type {Integer}
-   */
-  this.version = config.v5_keys ? 5 : 4;
-  /**
-   * Key creation date.
-   * @type {Date}
-   */
-  this.created = util.normalizeDate(date);
-  /**
-   * Public key algorithm.
-   * @type {String}
-   */
-  this.algorithm = null;
-  /**
-   * Algorithm specific params
-   * @type {Array<Object>}
-   */
-  this.params = [];
-  /**
-   * Time until expiration in days (V3 only)
-   * @type {Integer}
-   */
-  this.expirationTimeV3 = 0;
-  /**
-   * Fingerprint in lowercase hex
-   * @type {String}
-   */
-  this.fingerprint = null;
-  /**
-   * Keyid
-   * @type {module:type/keyid}
-   */
-  this.keyid = null;
-}
-
-/**
- * Internal Parser for public keys as specified in {@link https://tools.ietf.org/html/rfc4880#section-5.5.2|RFC 4880 section 5.5.2 Public-Key Packet Formats}
- * called by read_tag&lt;num&gt;
- * @param {Uint8Array} bytes Input array to read the packet from
- * @returns {Object} This object with attributes set by the parser
- */
-PublicKey.prototype.read = function (bytes) {
-  let pos = 0;
-  // A one-octet version number (3, 4 or 5).
-  this.version = bytes[pos++];
-
-  if (this.version === 4 || this.version === 5) {
-    // - A four-octet number denoting the time that the key was created.
-    this.created = util.readDate(bytes.subarray(pos, pos + 4));
-    pos += 4;
-
-    // - A one-octet number denoting the public-key algorithm of this key.
-    this.algorithm = enums.read(enums.publicKey, bytes[pos++]);
-    const algo = enums.write(enums.publicKey, this.algorithm);
-
-    if (this.version === 5) {
-      // - A four-octet scalar octet count for the following key material.
-      pos += 4;
-    }
-
-    // - A series of values comprising the key material.  This is
-    //   algorithm-specific and described in section XXXX.
-    const types = crypto.getPubKeyParamTypes(algo);
-    this.params = crypto.constructParams(types);
-
-    for (let i = 0; i < types.length && pos < bytes.length; i++) {
-      pos += this.params[i].read(bytes.subarray(pos, bytes.length));
-      if (pos > bytes.length) {
-        throw new Error('Error reading MPI @:' + pos);
-      }
-    }
-
-    return pos;
-  }
-  throw new Error('Version ' + this.version + ' of the key packet is unsupported.');
-};
-
-/**
- * Alias of read()
- * @see module:packet.PublicKey#read
- */
-PublicKey.prototype.readPublicKey = PublicKey.prototype.read;
-
-/**
- * Same as write_private_key, but has less information because of
- * public key.
- * @returns {Uint8Array} OpenPGP packet body contents,
- */
-PublicKey.prototype.write = function () {
-  const arr = [];
-  // Version
-  arr.push(new Uint8Array([this.version]));
-  arr.push(util.writeDate(this.created));
-  // A one-octet number denoting the public-key algorithm of this key
-  const algo = enums.write(enums.publicKey, this.algorithm);
-  arr.push(new Uint8Array([algo]));
-
-  const paramCount = crypto.getPubKeyParamTypes(algo).length;
-  const params = util.concatUint8Array(this.params.slice(0, paramCount).map(param => param.write()));
-  if (this.version === 5) {
-    // A four-octet scalar octet count for the following key material
-    arr.push(util.writeNumber(params.length, 4));
-  }
-  // Algorithm-specific params
-  arr.push(params);
-  return util.concatUint8Array(arr);
-};
-
-/**
- * Alias of write()
- * @see module:packet.PublicKey#write
- */
-PublicKey.prototype.writePublicKey = PublicKey.prototype.write;
-
-/**
- * Write packet in order to be hashed; either for a signature or a fingerprint.
- */
-PublicKey.prototype.writeForHash = function (version) {
-  const bytes = this.writePublicKey();
-
-  if (version === 5) {
-    return util.concatUint8Array([new Uint8Array([0x9A]), util.writeNumber(bytes.length, 4), bytes]);
-  }
-  return util.concatUint8Array([new Uint8Array([0x99]), util.writeNumber(bytes.length, 2), bytes]);
-};
-
-/**
- * Check whether secret-key data is available in decrypted form. Returns null for public keys.
- * @returns {Boolean|null}
- */
-PublicKey.prototype.isDecrypted = function() {
-  return null;
-};
-
-/**
- * Returns the creation time of the key
- * @returns {Date}
- */
-PublicKey.prototype.getCreationTime = function() {
-  return this.created;
-};
-
-/**
- * Calculates the key id of the key
- * @returns {module:type/keyid} A 8 byte key id
- */
-PublicKey.prototype.getKeyId = function () {
-  if (this.keyid) {
-    return this.keyid;
-  }
-  this.keyid = new type_keyid();
-  if (this.version === 5) {
-    this.keyid.read(util.hex_to_Uint8Array(this.getFingerprint()).subarray(0, 8));
-  } else if (this.version === 4) {
-    this.keyid.read(util.hex_to_Uint8Array(this.getFingerprint()).subarray(12, 20));
-  }
-  return this.keyid;
-};
-
-/**
- * Calculates the fingerprint of the key
- * @returns {Uint8Array} A Uint8Array containing the fingerprint
- */
-PublicKey.prototype.getFingerprintBytes = function () {
-  if (this.fingerprint) {
-    return this.fingerprint;
-  }
-  const toHash = this.writeForHash(this.version);
-  if (this.version === 5) {
-    this.fingerprint = Sha256.bytes(toHash);
-  } else if (this.version === 4) {
-    this.fingerprint = Sha1.bytes(toHash);
-  }
-  return this.fingerprint;
-};
-
-/**
- * Calculates the fingerprint of the key
- * @returns {String} A string containing the fingerprint in lowercase hex
- */
-PublicKey.prototype.getFingerprint = function() {
-  return util.Uint8Array_to_hex(this.getFingerprintBytes());
-};
-
-/**
- * Calculates whether two keys have the same fingerprint without actually calculating the fingerprint
- * @returns {Boolean} Whether the two keys have the same version and public key data
- */
-PublicKey.prototype.hasSameFingerprintAs = function(other) {
-  return this.version === other.version && util.equalsUint8Array(this.writePublicKey(), other.writePublicKey());
-};
-
-/**
- * Returns algorithm information
- * @returns {Object} An object of the form {algorithm: String, rsaBits:int, curve:String}
- */
-PublicKey.prototype.getAlgorithmInfo = function () {
-  const result = {};
-  result.algorithm = this.algorithm;
-  if (this.params[0] instanceof type_mpi) {
-    result.rsaBits = this.params[0].byteLength() * 8;
-    result.bits = result.rsaBits; // Deprecated.
-  } else {
-    result.curve = this.params[0].getName();
-  }
-  return result;
-};
-
-/**
- * Fix custom types after cloning
- */
-PublicKey.prototype.postCloneTypeFix = function() {
-  const algo = enums.write(enums.publicKey, this.algorithm);
-  const types = crypto.getPubKeyParamTypes(algo);
-  for (let i = 0; i < types.length; i++) {
-    const param = this.params[i];
-    this.params[i] = types[i].fromClone(param);
-  }
-  if (this.keyid) {
-    this.keyid = type_keyid.fromClone(this.keyid);
-  }
-};
-
-export default PublicKey;

package/src/packet/public_key_encrypted_session_key.js

@@ -1,156 +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 3.0 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
-
-/**
- * @requires type/keyid
- * @requires type/mpi
- * @requires crypto
- * @requires enums
- * @requires util
- */
-
-import type_keyid from '../type/keyid';
-import crypto from '../crypto';
-import enums from '../enums';
-import util from '../util';
-
-/**
- * Public-Key Encrypted Session Key Packets (Tag 1)
- *
- * {@link https://tools.ietf.org/html/rfc4880#section-5.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.
- * @memberof module:packet
- * @constructor
- */
-function PublicKeyEncryptedSessionKey() {
-  this.tag = enums.packet.publicKeyEncryptedSessionKey;
-  this.version = 3;
-
-  this.publicKeyId = new type_keyid();
-  this.publicKeyAlgorithm = null;
-
-  this.sessionKey = null;
-  this.sessionKeyAlgorithm = null;
-
-  /** @type {Array<module:type/mpi>} */
-  this.encrypted = [];
-}
-
-/**
- * Parsing function for a publickey encrypted session key packet (tag 1).
- *
- * @param {Uint8Array} 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
- * @returns {module:packet.PublicKeyEncryptedSessionKey} Object representation
- */
-PublicKeyEncryptedSessionKey.prototype.read = function (bytes) {
-  this.version = bytes[0];
-  this.publicKeyId.read(bytes.subarray(1, bytes.length));
-  this.publicKeyAlgorithm = enums.read(enums.publicKey, bytes[9]);
-
-  let i = 10;
-
-  const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
-  const types = crypto.getEncSessionKeyParamTypes(algo);
-  this.encrypted = crypto.constructParams(types);
-
-  for (let j = 0; j < types.length; j++) {
-    i += this.encrypted[j].read(bytes.subarray(i, bytes.length));
-  }
-};
-
-/**
- * Create a string representation of a tag 1 packet
- *
- * @returns {Uint8Array} The Uint8Array representation
- */
-PublicKeyEncryptedSessionKey.prototype.write = function () {
-  const arr = [new Uint8Array([this.version]), this.publicKeyId.write(), new Uint8Array([enums.write(enums.publicKey, this.publicKeyAlgorithm)])];
-
-  for (let i = 0; i < this.encrypted.length; i++) {
-    arr.push(this.encrypted[i].write());
-  }
-
-  return util.concatUint8Array(arr);
-};
-
-/**
- * Encrypt session key packet
- * @param {module:packet.PublicKey} key Public key
- * @returns {Promise<Boolean>}
- * @async
- */
-PublicKeyEncryptedSessionKey.prototype.encrypt = async function (key) {
-  let data = String.fromCharCode(enums.write(enums.symmetric, this.sessionKeyAlgorithm));
-
-  data += util.Uint8Array_to_str(this.sessionKey);
-  data += util.Uint8Array_to_str(util.write_checksum(this.sessionKey));
-  const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
-  this.encrypted = await crypto.publicKeyEncrypt(
-    algo, key.params, data, key.getFingerprintBytes());
-  return true;
-};
-
-/**
- * Decrypts the session key (only for public key encrypted session key
- * packets (tag 1)
- *
- * @param {module:packet.SecretKey} key
- *            Private key with secret params unlocked
- * @returns {Promise<Boolean>}
- * @async
- */
-PublicKeyEncryptedSessionKey.prototype.decrypt = async function (key) {
-  const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
-  const decoded = await crypto.publicKeyDecrypt(algo, key.params, this.encrypted, key.getFingerprintBytes());
-  const checksum = util.str_to_Uint8Array(decoded.substr(decoded.length - 2));
-  key = util.str_to_Uint8Array(decoded.substring(1, decoded.length - 2));
-
-  if (!util.equalsUint8Array(checksum, util.write_checksum(key))) {
-    throw new Error('Decryption error');
-  } else {
-    this.sessionKey = key;
-    this.sessionKeyAlgorithm = enums.read(enums.symmetric, decoded.charCodeAt(0));
-  }
-  return true;
-};
-
-/**
- * Fix custom types after cloning
- */
-PublicKeyEncryptedSessionKey.prototype.postCloneTypeFix = function() {
-  this.publicKeyId = type_keyid.fromClone(this.publicKeyId);
-  const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
-  const types = crypto.getEncSessionKeyParamTypes(algo);
-  for (let i = 0; i < this.encrypted.length; i++) {
-    this.encrypted[i] = types[i].fromClone(this.encrypted[i]);
-  }
-};
-
-export default PublicKeyEncryptedSessionKey;

package/src/packet/public_subkey.js

@@ -1,44 +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 3.0 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
-
-/**
- * @requires packet/public_key
- * @requires enums
- */
-
-import PublicKey from './public_key';
-import enums from '../enums';
-
-/**
- * A Public-Subkey packet (tag 14) has exactly the same format as a
- * Public-Key packet, but denotes a subkey.  One or more subkeys may be
- * associated with a top-level key.  By convention, the top-level key
- * provides signature services, and the subkeys provide encryption
- * services.
- * @memberof module:packet
- * @constructor
- * @extends module:packet.PublicKey
- */
-function PublicSubkey() {
-  PublicKey.call(this);
-  this.tag = enums.packet.publicSubkey;
-}
-
-PublicSubkey.prototype = new PublicKey();
-PublicSubkey.prototype.constructor = PublicSubkey;
-
-export default PublicSubkey;