@protontech/openpgp 4.10.6 → 5.4.0

package/src/type/mpi.js

@@ -1,138 +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
-
-// Hint: We hold our MPIs as an array of octets in big endian format preceding a two
-// octet scalar: MPI: [a,b,c,d,e,f]
-// - MPI size: (a << 8) | b
-// - MPI = c | d << 8 | e << ((MPI.length -2)*8) | f ((MPI.length -2)*8)
-
-/**
- * Implementation of type MPI ({@link https://tools.ietf.org/html/rfc4880#section-3.2|RFC4880 3.2})
- * Multiprecision integers (also called MPIs) are unsigned integers used
- * to hold large integers such as the ones used in cryptographic
- * calculations.
- * An MPI consists of two pieces: a two-octet scalar that is the length
- * of the MPI in bits followed by a string of octets that contain the
- * actual integer.
- * @requires bn.js
- * @requires util
- * @module type/mpi
- */
-
-import BN from 'bn.js';
-import util from '../util';
-
-/**
- * @constructor
- */
-function MPI(data) {
-  /** An implementation dependent integer */
-  if (data instanceof MPI) {
-    this.data = data.data;
-  } else if (BN.isBN(data)) {
-    this.fromBN(data);
-  } else if (util.isUint8Array(data)) {
-    this.fromUint8Array(data);
-  } else if (util.isString(data)) {
-    this.fromString(data);
-  } else {
-    this.data = null;
-  }
-}
-
-/**
- * Parsing function for a MPI ({@link https://tools.ietf.org/html/rfc4880#section-3.2|RFC 4880 3.2}).
- * @param {Uint8Array} input  Payload of MPI data
- * @param {String}     endian Endianness of the data; 'be' for big-endian or 'le' for little-endian
- * @returns {Integer}          Length of data read
- */
-MPI.prototype.read = function (bytes, endian = 'be') {
-  if (util.isString(bytes)) {
-    bytes = util.str_to_Uint8Array(bytes);
-  }
-
-  const bits = (bytes[0] << 8) | bytes[1];
-  const bytelen = (bits + 7) >>> 3;
-  const payload = bytes.subarray(2, 2 + bytelen);
-
-  this.fromUint8Array(payload, endian);
-
-  return 2 + bytelen;
-};
-
-/**
- * Converts the mpi object to a bytes as specified in
- * {@link https://tools.ietf.org/html/rfc4880#section-3.2|RFC4880 3.2}
- * @param {String} endian Endianness of the payload; 'be' for big-endian or 'le' for little-endian
- * @param {Integer} length Length of the data part of the MPI
- * @returns {Uint8Aray} mpi Byte representation
- */
-MPI.prototype.write = function (endian, length) {
-  return util.Uint8Array_to_MPI(this.toUint8Array(endian, length));
-};
-
-MPI.prototype.bitLength = function () {
-  return (this.data.length - 1) * 8 + util.nbits(this.data[0]);
-};
-
-MPI.prototype.byteLength = function () {
-  return this.data.length;
-};
-
-MPI.prototype.toUint8Array = function (endian, length) {
-  endian = endian || 'be';
-  length = length || this.data.length;
-
-  const payload = new Uint8Array(length);
-  const start = endian === 'le' ? 0 : length - this.data.length;
-  payload.set(this.data, start);
-  if (endian === 'le') {
-    payload.reverse();
-  }
-  return payload;
-};
-
-MPI.prototype.fromUint8Array = function (bytes, endian = 'be') {
-  this.data = new Uint8Array(bytes.length);
-  this.data.set(bytes);
-
-  if (endian === 'le') {
-    this.data.reverse();
-  }
-};
-
-MPI.prototype.toString = function () {
-  return util.Uint8Array_to_str(this.toUint8Array());
-};
-
-MPI.prototype.fromString = function (str, endian = 'be') {
-  this.fromUint8Array(util.str_to_Uint8Array(str), endian);
-};
-
-MPI.prototype.toBN = function () {
-  return new BN(this.toUint8Array());
-};
-
-MPI.prototype.fromBN = function (bn) {
-  this.data = bn.toArrayLike(Uint8Array);
-};
-
-MPI.fromClone = function (clone) {
-  return new MPI(clone.data);
-};
-
-export default MPI;

package/src/type/oid.js

@@ -1,110 +0,0 @@
-// OpenPGP.js - An OpenPGP implementation in javascript
-// Copyright (C) 2015-2016 Decentral
-//
-// 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
-
-/**
- * Wrapper to an OID value
- *
- * {@link https://tools.ietf.org/html/rfc6637#section-11|RFC6637, section 11}:
- * The sequence of octets in the third column is the result of applying
- * the Distinguished Encoding Rules (DER) to the ASN.1 Object Identifier
- * with subsequent truncation.  The truncation removes the two fields of
- * encoded Object Identifier.  The first omitted field is one octet
- * representing the Object Identifier tag, and the second omitted field
- * is the length of the Object Identifier body.  For example, the
- * complete ASN.1 DER encoding for the NIST P-256 curve OID is "06 08 2A
- * 86 48 CE 3D 03 01 07", from which the first entry in the table above
- * is constructed by omitting the first two octets.  Only the truncated
- * sequence of octets is the valid representation of a curve OID.
- * @requires util
- * @requires enums
- * @module type/oid
- */
-
-import util from '../util';
-import enums from '../enums';
-
-/**
- * @constructor
- */
-function OID(oid) {
-  if (oid instanceof OID) {
-    this.oid = oid.oid;
-  } else if (util.isArray(oid) ||
-             util.isUint8Array(oid)) {
-    oid = new Uint8Array(oid);
-    if (oid[0] === 0x06) { // DER encoded oid byte array
-      if (oid[1] !== oid.length - 2) {
-        throw new Error('Length mismatch in DER encoded oid');
-      }
-      oid = oid.subarray(2);
-    }
-    this.oid = oid;
-  } else {
-    this.oid = '';
-  }
-}
-
-/**
- * Method to read an OID object
- * @param  {Uint8Array}  input  Where to read the OID from
- * @returns {Number}             Number of read bytes
- */
-OID.prototype.read = function (input) {
-  if (input.length >= 1) {
-    const length = input[0];
-    if (input.length >= 1 + length) {
-      this.oid = input.subarray(1, 1 + length);
-      return 1 + this.oid.length;
-    }
-  }
-  throw new Error('Invalid oid');
-};
-
-/**
- * Serialize an OID object
- * @returns {Uint8Array} Array with the serialized value the OID
- */
-OID.prototype.write = function () {
-  return util.concatUint8Array([new Uint8Array([this.oid.length]), this.oid]);
-};
-
-/**
- * Serialize an OID object as a hex string
- * @returns {string} String with the hex value of the OID
- */
-OID.prototype.toHex = function() {
-  return util.Uint8Array_to_hex(this.oid);
-};
-
-/**
- * If a known curve object identifier, return the canonical name of the curve
- * @returns {string} String with the canonical name of the curve
- */
-OID.prototype.getName = function() {
-  const hex = this.toHex();
-  if (enums.curve[hex]) {
-    return enums.write(enums.curve, hex);
-  } else {
-    throw new Error('Unknown curve object identifier.');
-  }
-};
-
-OID.fromClone = function (clone) {
-  return new OID(clone.oid);
-};
-
-export default OID;

package/src/type/s2k.js

@@ -1,203 +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
-
-/**
- * Implementation of the String-to-key specifier
- *
- * {@link https://tools.ietf.org/html/rfc4880#section-3.7|RFC4880 3.7}:
- * String-to-key (S2K) specifiers are used to convert passphrase strings
- * into symmetric-key encryption/decryption keys.  They are used in two
- * places, currently: to encrypt the secret part of private keys in the
- * private keyring, and to convert passphrases to encryption keys for
- * symmetrically encrypted messages.
- * @requires config
- * @requires crypto
- * @requires enums
- * @requires util
- * @module type/s2k
- */
-
-import config from '../config';
-import crypto from '../crypto';
-import enums from '../enums.js';
-import util from '../util.js';
-
-/**
- * @constructor
- */
-function S2K() {
-  /** @type {module:enums.hash} */
-  this.algorithm = 'sha256';
-  /** @type {module:enums.s2k} */
-  this.type = 'iterated';
-  /** @type {Integer} */
-  this.c = config.s2k_iteration_count_byte;
-  /** Eight bytes of salt in a binary string.
-   * @type {String}
-   */
-  this.salt = null;
-}
-
-S2K.prototype.get_count = function () {
-  // Exponent bias, defined in RFC4880
-  const expbias = 6;
-
-  return (16 + (this.c & 15)) << ((this.c >> 4) + expbias);
-};
-
-/**
- * Parsing function for a string-to-key specifier ({@link https://tools.ietf.org/html/rfc4880#section-3.7|RFC 4880 3.7}).
- * @param {String} input Payload of string-to-key specifier
- * @returns {Integer} Actual length of the object
- */
-S2K.prototype.read = function (bytes) {
-  let i = 0;
-  this.type = enums.read(enums.s2k, bytes[i++]);
-  this.algorithm = bytes[i++];
-  if (this.type !== 'gnu') {
-    this.algorithm = enums.read(enums.hash, this.algorithm);
-  }
-
-  switch (this.type) {
-    case 'simple':
-      break;
-
-    case 'salted':
-      this.salt = bytes.subarray(i, i + 8);
-      i += 8;
-      break;
-
-    case 'iterated':
-      this.salt = bytes.subarray(i, i + 8);
-      i += 8;
-
-      // Octet 10: count, a one-octet, coded value
-      this.c = bytes[i++];
-      break;
-
-    case 'gnu':
-      if (util.Uint8Array_to_str(bytes.subarray(i, i + 3)) === "GNU") {
-        i += 3; // GNU
-        const gnuExtType = 1000 + bytes[i++];
-        if (gnuExtType === 1001) {
-          this.type = 'gnu-dummy';
-          // GnuPG extension mode 1001 -- don't write secret key at all
-        } else {
-          throw new Error("Unknown s2k gnu protection mode.");
-        }
-      } else {
-        throw new Error("Unknown s2k type.");
-      }
-      break;
-
-    default:
-      throw new Error("Unknown s2k type.");
-  }
-
-  return i;
-};
-
-
-/**
- * Serializes s2k information
- * @returns {Uint8Array} binary representation of s2k
- */
-S2K.prototype.write = function () {
-  if (this.type === 'gnu-dummy') {
-    return new Uint8Array([101, 0, ...util.str_to_Uint8Array('GNU'), 1]);
-  }
-
-  const arr = [new Uint8Array([enums.write(enums.s2k, this.type), enums.write(enums.hash, this.algorithm)])];
-
-  switch (this.type) {
-    case 'simple':
-      break;
-    case 'salted':
-      arr.push(this.salt);
-      break;
-    case 'iterated':
-      arr.push(this.salt);
-      arr.push(new Uint8Array([this.c]));
-      break;
-    case 'gnu':
-      throw new Error("GNU s2k type not supported.");
-    default:
-      throw new Error("Unknown s2k type.");
-  }
-
-  return util.concatUint8Array(arr);
-};
-
-/**
- * Produces a key using the specified passphrase and the defined
- * hashAlgorithm
- * @param {String} passphrase Passphrase containing user input
- * @returns {Uint8Array} Produced key with a length corresponding to
- * hashAlgorithm hash length
- */
-S2K.prototype.produce_key = async function (passphrase, numBytes) {
-  passphrase = util.encode_utf8(passphrase);
-  const algorithm = enums.write(enums.hash, this.algorithm);
-
-  const arr = [];
-  let rlength = 0;
-
-  let prefixlen = 0;
-  while (rlength < numBytes) {
-    let toHash;
-    switch (this.type) {
-      case 'simple':
-        toHash = util.concatUint8Array([new Uint8Array(prefixlen), passphrase]);
-        break;
-      case 'salted':
-        toHash = util.concatUint8Array([new Uint8Array(prefixlen), this.salt, passphrase]);
-        break;
-      case 'iterated': {
-        const data = util.concatUint8Array([this.salt, passphrase]);
-        let datalen = data.length;
-        const count = Math.max(this.get_count(), datalen);
-        toHash = new Uint8Array(prefixlen + count);
-        toHash.set(data, prefixlen);
-        for (let pos = prefixlen + datalen; pos < count; pos += datalen, datalen *= 2) {
-          toHash.copyWithin(pos, prefixlen, pos);
-        }
-        break;
-      }
-      case 'gnu':
-        throw new Error("GNU s2k type not supported.");
-      default:
-        throw new Error("Unknown s2k type.");
-    }
-    const result = await crypto.hash.digest(algorithm, toHash);
-    arr.push(result);
-    rlength += result.length;
-    prefixlen++;
-  }
-
-  return util.concatUint8Array(arr).subarray(0, numBytes);
-};
-
-S2K.fromClone = function (clone) {
-  const s2k = new S2K();
-  s2k.algorithm = clone.algorithm;
-  s2k.type = clone.type;
-  s2k.c = clone.c;
-  s2k.salt = clone.salt;
-  return s2k;
-};
-
-export default S2K;