diff --git a/_layouts/blog.html b/_layouts/blog.html
index 7972cad..5642485 100644
--- a/_layouts/blog.html
+++ b/_layouts/blog.html
@@ -1,5 +1,6 @@
---
layout: default
+description: Amolith's blog on various tech-related topics
---
{% include page/title.html %}
diff --git a/_layouts/default.html b/_layouts/default.html
index 5b8fae6..72bc9c1 100644
--- a/_layouts/default.html
+++ b/_layouts/default.html
@@ -1,5 +1,5 @@
-
+
{% include meta_tags/base.html %}
{% include meta_tags/sharing.html %}
diff --git a/_layouts/home.html b/_layouts/home.html
new file mode 100644
index 0000000..6396bd7
--- /dev/null
+++ b/_layouts/home.html
@@ -0,0 +1,8 @@
+---
+layout: default
+---
+{% include page/title.html %}
+
+{{ content }}
+
+{% include page/footer.html %}
diff --git a/_layouts/page.html b/_layouts/page.html
index 6396bd7..62c621b 100644
--- a/_layouts/page.html
+++ b/_layouts/page.html
@@ -2,7 +2,8 @@
layout: default
---
{% include page/title.html %}
-
+
{{ content }}
+
{% include page/footer.html %}
diff --git a/_posts/2018-12-14-forecasting-with-a-command.md b/_posts/2018-12-14-forecasting-with-a-command.md
index 6f82dcd..059b736 100644
--- a/_posts/2018-12-14-forecasting-with-a-command.md
+++ b/_posts/2018-12-14-forecasting-with-a-command.md
@@ -21,4 +21,4 @@ A great way to make this faster and simpler is to put an alias in your shell's `
echo "alias weather='curl sky.webionite.com/f/location'" >> ~/.bashrc
```
If you ever forget how to use the tool, just run `curl sky.webionite.com` and you'll be given instructions.
-
+
diff --git a/_posts/2019-02-05-dns-and-root-certificates-what-you-need-to-know.md b/_posts/2019-02-05-dns-and-root-certificates-what-you-need-to-know.md
index 82946d4..1c3d9c7 100644
--- a/_posts/2019-02-05-dns-and-root-certificates-what-you-need-to-know.md
+++ b/_posts/2019-02-05-dns-and-root-certificates-what-you-need-to-know.md
@@ -6,8 +6,8 @@ description: Protecting yourself from malicious third parties leveraging DNS and
cover: /assets/posts/privacy.png
date: 2019-02-05 10:53 -0500
---
-
This post was mirrored from Privacy Today on Telegram.
Due to recent events we felt compelled to write an impromptu article on this matter. It's intended for all audiences so it will be kept simple - technical details may be posted later.
@@ -72,7 +72,7 @@ This site will look absolutely fine to you; it has https in the URL and, if you
It now receives all the communication you intended to send to the original. This bypasses the checks created to avoid it. You won't receive error messages, your browser won't complain.
-All your data is compromised!
+All your data is compromised!
## 4. Conclusion
@@ -85,7 +85,7 @@ All your data is compromised!
**Do not ever install a 3rd party root certificate!** There are very few exceptions why you would want to do so and none of them are applicable to general end users.
-Do not fall for clever marketing that ensures "ad blocking", "military grade security", or something similar. There are methods of using DNS resolvers on their own to enhance your privacy but installing a 3rd party root certificate never makes sense. You are opening yourself up to extreme abuse.
+Do not fall for clever marketing that ensures "ad blocking", "military grade security", or something similar. There are methods of using DNS resolvers on their own to enhance your privacy but installing a 3rd party root certificate never makes sense. You are opening yourself up to extreme abuse.
## 5. Seeing It Live
@@ -111,8 +111,8 @@ Here is the link: [https-interception.info.tm](http://https-interception.info.tm
## 6. Further Information
-If you are interested in more technical details, let us know. If there is enough interest, we might write a more in-depth article but, for now, the important part is sharing the basics so you can make an informed decision and not fall for marketing and straight up fraud. Feel free to suggest other topics that are important to you.
+If you are interested in more technical details, let us know. If there is enough interest, we might write a more in-depth article but, for now, the important part is sharing the basics so you can make an informed decision and not fall for marketing and straight up fraud. Feel free to suggest other topics that are important to you.
-
For more information/feedback/corrections, join Privacy Today on Telegram.
-
This post is licensed under CC BY-NC-SA 4.0 and was mirrored with permission.
+
For more information/feedback/corrections, join Privacy Today on Telegram.
+
This post is licensed under CC BY-NC-SA 4.0 and was mirrored with permission.
diff --git a/_posts/2019-06-03-excluding-your-site-from-the-wayback-machine-keybase-only.md b/_posts/2019-06-03-excluding-your-site-from-the-wayback-machine-keybase-only.md
index 486790a..8922b30 100644
--- a/_posts/2019-06-03-excluding-your-site-from-the-wayback-machine-keybase-only.md
+++ b/_posts/2019-06-03-excluding-your-site-from-the-wayback-machine-keybase-only.md
@@ -16,7 +16,7 @@ If that's all you intend to do, this should be sufficient and there's no need to
# For domains you *don't* own
There are a few things I used that worked in harmony to verify my other accounts. [Keybase](https://keybase.io/) was the most useful for this purpose. It is a proprietary service but I deem the level of proof it facilitates worth compromising for.
-The other tool I used was [GPG](https://gnupg.org/). For the sake of keeping it simple, *this* guide will just deal with GPG from within Keybase. I ***really*** recommend actually learning to use GPG on its own; it's wonderful for protecting your privacy and verifying your identity in a multitude of situations. The next post will be on using GPG *outside* of Keybase for this so [stay tuned](nixnet.xyz/feed.xml).
+The other tool I used was [GPG](https://gnupg.org/). For the sake of keeping it simple, *this* guide will just deal with GPG from within Keybase. I ***really*** recommend actually learning to use GPG on its own; it's wonderful for protecting your privacy and verifying your identity in a multitude of situations. The next post will be on using GPG *outside* of Keybase for this so [stay tuned](/feed.xml).
## Generating your key
After creating your Keybase account, click "add a PGP key", "I need a public key", then enter the requisite information. You should use whatever name is associated with the account you'll be emailing Archive.org from as well as that address. Wait a bit while it generates the key . . .
diff --git a/_sass/_default.scss b/_sass/_default.scss
index 5718f7e..b7ca4e1 100644
--- a/_sass/_default.scss
+++ b/_sass/_default.scss
@@ -1,6 +1,7 @@
;
@font-face {
font-family: 'Open Sans';
+ font-display: auto;
font-style: normal;
font-weight: 300;
src: url('assets/fonts/open-sans-v15-latin-300.eot'); /* IE9 Compat Modes */
@@ -13,6 +14,7 @@
}
@font-face {
font-family: 'Open Sans';
+ font-display: auto;
font-style: italic;
font-weight: 300;
src: url('/assets/fonts/open-sans-v15-latin-300italic.eot'); /* IE9 Compat Modes */
@@ -25,6 +27,7 @@
}
@font-face {
font-family: 'Inconsolata';
+ font-display: auto;
font-style: normal;
font-weight: 400;
src: url('/assets/fonts/inconsolata-v16-latin-regular.eot'); /* IE9 Compat Modes */
@@ -37,6 +40,7 @@
}
@font-face {
font-family: 'Inconsolata';
+ font-display: auto;
font-style: normal;
font-weight: 700;
src: url('/assets/fonts/inconsolata-v16-latin-700.eot'); /* IE9 Compat Modes */
@@ -49,6 +53,7 @@
}
@font-face {
font-family: 'Overpass';
+ font-display: auto;
font-style: normal;
font-weight: 400;
src: url('/assets/fonts/overpass-v2-latin-regular.eot'); /* IE9 Compat Modes */
diff --git a/about.html b/about.html
index 351373d..f7caca5 100644
--- a/about.html
+++ b/about.html
@@ -1,5 +1,5 @@
---
-layout: page
+layout: home
title: About
subtitle: 'A little bit about NixNet.xyz and some financial information'
description: A little bit about NixNet.xyz and some financial information
@@ -14,28 +14,25 @@ permalink: /about/
Finance
-
At the moment, all the sites I host are running on netcup GmbH's 500 G8 VPS. I pay $6.10/mo in lump sums of $36.60 every six months. The domain nixnet.xyz is registered with gandi.net and it renews at $13.63/yr. I use Gandi because they have WHOIS privacy by default, every domain comes with two inboxes and unlimited aliases for both. One is amolith@nixnet.xyz and the other uses my real name rather than my pseudonym. My plans are to upgrade to the 1000 G8 (on the same page) and add a Tariff A storage server. This would cost $4.07/mo. I've also added the domain, nixnet.xyz to the goal, which is $13/year ($0.27/mo). My goal is $4.34/week exactly so I can upgrade VPSs, add a storage server, and not have anything left over.
+
At the moment, all the sites I host are running on netcup GmbH's 500 G8 VPS. I pay $6.10/mo in lump sums of $36.60 every six months. The domain nixnet.xyz is registered with gandi.net and it renews at $13.63/yr. I use Gandi because they have WHOIS privacy by default, every domain comes with two inboxes and unlimited aliases for both. One is amolith@nixnet.xyz and the other uses my real name rather than my pseudonym. My plans are to upgrade to the 1000 G8 (on the same page) and add a Tariff A storage server. This would cost $4.07/mo. I've also added the domain, nixnet.xyz to the goal, which is $13/year ($0.27/mo). My goal is $4.34/week exactly so I can upgrade VPSs, add a storage server, and not have anything left over.
-
+
-
-
-
-
+
-
If you want to donate in crypto currencies, I accept Bitcoin and Litecoin though I do prefer Litecoin because of its speed. If you do crypto on mobile, you can scan the QR codes with your preferred app or tap them to open the appropriate app. The address is also below for other methods.
+
If you want to donate in crypto currencies, I accept Bitcoin and Litecoin though I do prefer Litecoin because of its speed. If you do crypto on mobile, you can scan the QR codes with your preferred app or tap them to open the appropriate app. The address is also below for other methods.
@@ -40,9 +40,10 @@ These are some of my more public accounts; feel free to contact me at any of the
+
- I also have Briar if we meet IRL and I'm on Wire as @amolith. I can be found on my XMPP server at amolith@nixnet.xyz as well.
+ I also have Briar if we meet IRL and I'm on Wire as @amolith.
Despite the many ways to contact me, email and XMPP are and always will be my most preferrered methods (as well as the most reliable). If you email me, please be sure to encrypt it with my GPG key. If you message me over XMPP, please make sure it's with a client that has OMEMO encryption.
diff --git a/contact2.html b/contact2.html
new file mode 100644
index 0000000..af9e700
--- /dev/null
+++ b/contact2.html
@@ -0,0 +1,78 @@
+---
+layout: page
+title: Contact
+subtitle: Where to find me
+description: Various ways to contact me
+cover: /assets/pages/contact.png
+permalink: /contact2/
+---
+
+
+
+
+
+
Note: contents of this page are generated purely from the OpenPGP key in your browser.
+ If you want to add social proofs to your key see OpenPGP Proofs page.
+
If you want to adjust the keyserver used or the key being displayed just edit this HTML page.
+
+
diff --git a/css/main.scss b/css/main.scss
index 63425a0..37aa30a 100755
--- a/css/main.scss
+++ b/css/main.scss
@@ -8,7 +8,7 @@ sitemap:
/* =Colors */
$dorian: #323234;
$iron: #ffffff;
-$cloudy: #828282;
+$cloudy: #9d9d9d;
@import
"mixins",
diff --git a/friends.html b/friends.html
deleted file mode 100644
index 24f1360..0000000
--- a/friends.html
+++ /dev/null
@@ -1,23 +0,0 @@
----
-layout: page
-title: Friends of NixNet
-subtitle: A list of some like-minded people and their websites
-description: A list of some like-minded people and their websites
-cover: /assets/pages/friends.png
-permalink: /friends/
----
-
-
People
-
-
Anxhelo Lushka - graphic designer, frontend developer, computer engineering student and heavy open source user/advocate. Has an interesting blog.
LibreHo.st - a network of average people who host FLOSS services available for anyone to use
-
Lelux.fi - really cool guy who hosts some services like I do
-
Snopyta.org - Snopyta provides online services based on freedom, privacy and decentralization. Part of LibreHosters.
-
LibreDesigners.org - a website for learning how to create art, interfaces, websites, etc. with free/libre and open source software (Portuguese-only right now)
-
CYGONetwork.com - alternative to Facebook. Better features, better community, and enhanced privacy/security
-
-
diff --git a/img.py b/img.py
old mode 100644
new mode 100755
diff --git a/index.html b/index.html
index 5afd67a..678e9cd 100644
--- a/index.html
+++ b/index.html
@@ -1,5 +1,5 @@
---
-layout: page
+layout: home
title: "NixNet"
subtitle: "Freedom served with a slice of liberty"
description: "A network of websites and services hosted by Amolith available for anyone to use free of charge."
@@ -11,7 +11,7 @@ priority: 0.9
I host a variety of services that are available for anyone to use free of charge. Below is a list with descriptions of each.
-
+
Clone //
+// //
+//////////////////////////////
+
+
+/**
+ * Create a packetlist from the correspoding object types.
+ * @param {Object} options the object passed to and from the web worker
+ * @returns {Object} a mutated version of the options optject
+ */
+// OpenPGP.js - An OpenPGP implementation in javascript
+// Copyright (C) 2015 Tankred Hase
+//
+// 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
+
+/**
+ * @fileoverview This module implements packet list cloning required to
+ * pass certain object types between the web worker and main thread using
+ * the structured cloning algorithm.
+ * @module packet/clone
+ */
+
+function clonePackets(options) {
+ if (options.publicKeys) {
+ options.publicKeys = options.publicKeys.map(key => key.toPacketlist());
+ }
+ if (options.privateKeys) {
+ options.privateKeys = options.privateKeys.map(key => key.toPacketlist());
+ }
+ if (options.privateKey) {
+ options.privateKey = options.privateKey.toPacketlist();
+ }
+ if (options.key) {
+ options.key = options.key.toPacketlist();
+ }
+ if (options.message) {
+ //could be either a Message or CleartextMessage object
+ if (options.message instanceof _message.Message) {
+ options.message = options.message.packets;
+ } else if (options.message instanceof _cleartext.CleartextMessage) {
+ options.message = { text: options.message.text, signature: options.message.signature.packets };
+ }
+ }
+ if (options.signature && options.signature instanceof _signature.Signature) {
+ options.signature = options.signature.packets;
+ }
+ if (options.signatures) {
+ options.signatures.forEach(verificationObjectToClone);
+ }
+ return options;
+}
+
+function verificationObjectToClone(verObject) {
+ const verified = verObject.verified;
+ verObject.verified = _webStreamTools2.default.fromAsync(() => verified);
+ if (verObject.signature instanceof Promise) {
+ const signature = verObject.signature;
+ verObject.signature = _webStreamTools2.default.fromAsync(async () => {
+ const packets = (await signature).packets;
+ try {
+ await verified;
+ delete packets[0].signature;
+ } catch (e) {}
+ return packets;
+ });
+ } else {
+ verObject.signature = verObject.signature.packets;
+ }
+ if (verObject.error) {
+ verObject.error = verObject.error.message;
+ }
+ return verObject;
+}
+
+//////////////////////////////
+// //
+// Clone --> List //
+// //
+//////////////////////////////
+
+
+/**
+ * Creates an object with the correct prototype from a corresponding packetlist.
+ * @param {Object} options the object passed to and from the web worker
+ * @param {String} method the public api function name to be delegated to the worker
+ * @returns {Object} a mutated version of the options optject
+ */
+function parseClonedPackets(options) {
+ if (options.publicKeys) {
+ options.publicKeys = options.publicKeys.map(packetlistCloneToKey);
+ }
+ if (options.privateKeys) {
+ options.privateKeys = options.privateKeys.map(packetlistCloneToKey);
+ }
+ if (options.privateKey) {
+ options.privateKey = packetlistCloneToKey(options.privateKey);
+ }
+ if (options.key) {
+ options.key = packetlistCloneToKey(options.key);
+ }
+ if (options.message && options.message.signature) {
+ options.message = packetlistCloneToCleartextMessage(options.message);
+ } else if (options.message) {
+ options.message = packetlistCloneToMessage(options.message);
+ }
+ if (options.signatures) {
+ options.signatures = options.signatures.map(packetlistCloneToSignatures);
+ }
+ if (options.signature) {
+ options.signature = packetlistCloneToSignature(options.signature);
+ }
+ return options;
+}
+
+function packetlistCloneToKey(clone) {
+ const packetlist = _packetlist2.default.fromStructuredClone(clone);
+ return new _key.Key(packetlist);
+}
+
+function packetlistCloneToMessage(clone) {
+ const packetlist = _packetlist2.default.fromStructuredClone(clone);
+ return new _message.Message(packetlist);
+}
+
+function packetlistCloneToCleartextMessage(clone) {
+ const packetlist = _packetlist2.default.fromStructuredClone(clone.signature);
+ return new _cleartext.CleartextMessage(clone.text, new _signature.Signature(packetlist));
+}
+
+//verification objects
+function packetlistCloneToSignatures(clone) {
+ clone.keyid = _keyid2.default.fromClone(clone.keyid);
+ if (_util2.default.isStream(clone.signature)) {
+ clone.signature = _webStreamTools2.default.readToEnd(clone.signature, ([signature]) => new _signature.Signature(_packetlist2.default.fromStructuredClone(signature)));
+ clone.signature.catch(() => {});
+ } else {
+ clone.signature = new _signature.Signature(_packetlist2.default.fromStructuredClone(clone.signature));
+ }
+ clone.verified = _webStreamTools2.default.readToEnd(clone.verified, ([verified]) => verified);
+ clone.verified.catch(() => {});
+ if (clone.error) {
+ clone.error = new Error(clone.error);
+ }
+ return clone;
+}
+
+function packetlistCloneToSignature(clone) {
+ if (_util2.default.isString(clone) || _util2.default.isStream(clone)) {
+ //signature is armored
+ return clone;
+ }
+ const packetlist = _packetlist2.default.fromStructuredClone(clone);
+ return new _signature.Signature(packetlist);
+}
+
+},{"../cleartext":78,"../key":117,"../message":121,"../signature":146,"../type/keyid":149,"../util":153,"./packetlist":131,"web-stream-tools":76}],125:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _pako = require('pako');
+
+var _pako2 = _interopRequireDefault(_pako);
+
+var _seekBzip = require('seek-bzip');
+
+var _seekBzip2 = _interopRequireDefault(_seekBzip);
+
+var _webStreamTools = require('web-stream-tools');
+
+var _webStreamTools2 = _interopRequireDefault(_webStreamTools);
+
+var _config = require('../config');
+
+var _config2 = _interopRequireDefault(_config);
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Implementation of the Compressed Data Packet (Tag 8)
+ *
+ * {@link https://tools.ietf.org/html/rfc4880#section-5.6|RFC4880 5.6}:
+ * The Compressed Data packet contains compressed data. Typically,
+ * this packet is found as the contents of an encrypted packet, or following
+ * a Signature or One-Pass Signature packet, and contains a literal data packet.
+ * @memberof module:packet
+ * @constructor
+ */
+// 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 web-stream-tools
+ * @requires pako
+ * @requires config
+ * @requires enums
+ * @requires util
+ * @requires compression/bzip2
+ */
+
+function Compressed() {
+ /**
+ * Packet type
+ * @type {module:enums.packet}
+ */
+ this.tag = _enums2.default.packet.compressed;
+ /**
+ * List of packets
+ * @type {module:packet.List}
+ */
+ this.packets = null;
+ /**
+ * Compression algorithm
+ * @type {compression}
+ */
+ this.algorithm = 'zip';
+
+ /**
+ * Compressed packet data
+ * @type {Uint8Array | ReadableStream}
+ */
+ this.compressed = null;
+}
+
+/**
+ * Parsing function for the packet.
+ * @param {Uint8Array | ReadableStream} bytes Payload of a tag 8 packet
+ */
+Compressed.prototype.read = async function (bytes, streaming) {
+ await _webStreamTools2.default.parse(bytes, async reader => {
+
+ // One octet that gives the algorithm used to compress the packet.
+ this.algorithm = _enums2.default.read(_enums2.default.compression, (await reader.readByte()));
+
+ // Compressed data, which makes up the remainder of the packet.
+ this.compressed = reader.remainder();
+
+ await this.decompress(streaming);
+ });
+};
+
+/**
+ * Return the compressed packet.
+ * @returns {Uint8Array | ReadableStream} binary compressed packet
+ */
+Compressed.prototype.write = function () {
+ if (this.compressed === null) {
+ this.compress();
+ }
+
+ return _util2.default.concat([new Uint8Array([_enums2.default.write(_enums2.default.compression, this.algorithm)]), this.compressed]);
+};
+
+/**
+ * Decompression method for decompressing the compressed data
+ * read by read_packet
+ */
+Compressed.prototype.decompress = async function (streaming) {
+
+ if (!decompress_fns[this.algorithm]) {
+ throw new Error(this.algorithm + ' decompression not supported');
+ }
+
+ await this.packets.read(decompress_fns[this.algorithm](this.compressed), streaming);
+};
+
+/**
+ * Compress the packet data (member decompressedData)
+ */
+Compressed.prototype.compress = function () {
+
+ if (!compress_fns[this.algorithm]) {
+ throw new Error(this.algorithm + ' compression not supported');
+ }
+
+ this.compressed = compress_fns[this.algorithm](this.packets.write());
+};
+
+exports.default = Compressed;
+
+//////////////////////////
+// //
+// Helper functions //
+// //
+//////////////////////////
+
+
+const nodeZlib = _util2.default.getNodeZlib();
+
+function node_zlib(func, options = {}) {
+ return function (data) {
+ return _webStreamTools2.default.nodeToWeb(_webStreamTools2.default.webToNode(data).pipe(func(options)));
+ };
+}
+
+function pako_zlib(constructor, options = {}) {
+ return function (data) {
+ const obj = new constructor(options);
+ return _webStreamTools2.default.transform(data, value => {
+ if (value.length) {
+ obj.push(value, _pako2.default.Z_SYNC_FLUSH);
+ return obj.result;
+ }
+ }, () => {
+ if (constructor === _pako2.default.Deflate) {
+ obj.push([], _pako2.default.Z_FINISH);
+ return obj.result;
+ }
+ });
+ };
+}
+
+function bzip2(func) {
+ return function (data) {
+ return _webStreamTools2.default.fromAsync(async () => func((await _webStreamTools2.default.readToEnd(data))));
+ };
+}
+
+let compress_fns;
+let decompress_fns;
+if (nodeZlib) {
+ // Use Node native zlib for DEFLATE compression/decompression
+ compress_fns = {
+ zip: node_zlib(nodeZlib.createDeflateRaw, { level: _config2.default.deflate_level }),
+ zlib: node_zlib(nodeZlib.createDeflate, { level: _config2.default.deflate_level })
+ };
+
+ decompress_fns = {
+ zip: node_zlib(nodeZlib.createInflateRaw),
+ zlib: node_zlib(nodeZlib.createInflate),
+ bzip2: bzip2(_seekBzip2.default.decode)
+ };
+} else {
+ // Use JS fallbacks
+ compress_fns = {
+ zip: pako_zlib(_pako2.default.Deflate, { raw: true, level: _config2.default.deflate_level }),
+ zlib: pako_zlib(_pako2.default.Deflate, { level: _config2.default.deflate_level })
+ };
+
+ decompress_fns = {
+ zip: pako_zlib(_pako2.default.Inflate, { raw: true }),
+ zlib: pako_zlib(_pako2.default.Inflate),
+ bzip2: bzip2(_seekBzip2.default.decode)
+ };
+}
+
+},{"../config":80,"../enums":114,"../util":153,"pako":51,"seek-bzip":70,"web-stream-tools":76}],126:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _all_packets = require('./all_packets');
+
+var packets = _interopRequireWildcard(_all_packets);
+
+var _clone = require('./clone');
+
+var clone = _interopRequireWildcard(_clone);
+
+var _packetlist = require('./packetlist');
+
+var _packetlist2 = _interopRequireDefault(_packetlist);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+const mod = {
+ List: _packetlist2.default,
+ clone
+}; /**
+ * @fileoverview OpenPGP packet types
+ * @see module:packet/all_packets
+ * @see module:packet/clone
+ * @see module:packet.List
+ * @module packet
+ */
+
+Object.assign(mod, packets);
+
+exports.default = mod;
+
+},{"./all_packets":123,"./clone":124,"./packetlist":131}],127:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _webStreamTools = require('web-stream-tools');
+
+var _webStreamTools2 = _interopRequireDefault(_webStreamTools);
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Implementation of the Literal Data Packet (Tag 11)
+ *
+ * {@link https://tools.ietf.org/html/rfc4880#section-5.9|RFC4880 5.9}:
+ * A Literal Data packet contains the body of a message; data that is not to be
+ * further interpreted.
+ * @param {Date} date the creation date of the literal package
+ * @memberof module:packet
+ * @constructor
+ */
+function Literal(date = new Date()) {
+ this.tag = _enums2.default.packet.literal;
+ this.format = 'utf8'; // default format for literal data packets
+ this.date = _util2.default.normalizeDate(date);
+ this.text = null; // textual data representation
+ this.data = null; // literal data representation
+ this.filename = 'msg.txt';
+}
+
+/**
+ * Set the packet data to a javascript native string, end of line
+ * will be normalized to \r\n and by default text is converted to UTF8
+ * @param {String | ReadableStream} text Any native javascript string
+ * @param {utf8|binary|text|mime} format (optional) The format of the string of bytes
+ */
+// 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 web-stream-tools
+ * @requires enums
+ * @requires util
+ */
+
+Literal.prototype.setText = function (text, format = 'utf8') {
+ this.format = format;
+ this.text = text;
+ this.data = null;
+};
+
+/**
+ * Returns literal data packets as native JavaScript string
+ * with normalized end of line to \n
+ * @param {Boolean} clone (optional) Whether to return a clone so that getBytes/getText can be called again
+ * @returns {String | ReadableStream} literal data as text
+ */
+Literal.prototype.getText = function (clone = false) {
+ if (this.text === null || _util2.default.isStream(this.text)) {
+ // Assume that this.text has been read
+ this.text = _util2.default.nativeEOL(_util2.default.decode_utf8(this.getBytes(clone)));
+ }
+ return this.text;
+};
+
+/**
+ * Set the packet data to value represented by the provided string of bytes.
+ * @param {Uint8Array | ReadableStream} bytes The string of bytes
+ * @param {utf8|binary|text|mime} format The format of the string of bytes
+ */
+Literal.prototype.setBytes = function (bytes, format) {
+ this.format = format;
+ this.data = bytes;
+ this.text = null;
+};
+
+/**
+ * Get the byte sequence representing the literal packet data
+ * @param {Boolean} clone (optional) Whether to return a clone so that getBytes/getText can be called again
+ * @returns {Uint8Array | ReadableStream} A sequence of bytes
+ */
+Literal.prototype.getBytes = function (clone = false) {
+ if (this.data === null) {
+ // normalize EOL to \r\n and encode UTF8
+ this.data = _util2.default.encode_utf8(_util2.default.canonicalizeEOL(this.text));
+ }
+ if (clone) {
+ return _webStreamTools2.default.passiveClone(this.data);
+ }
+ return this.data;
+};
+
+/**
+ * Sets the filename of the literal packet data
+ * @param {String} filename Any native javascript string
+ */
+Literal.prototype.setFilename = function (filename) {
+ this.filename = filename;
+};
+
+/**
+ * Get the filename of the literal packet data
+ * @returns {String} filename
+ */
+Literal.prototype.getFilename = function () {
+ return this.filename;
+};
+
+/**
+ * Parsing function for a literal data packet (tag 11).
+ *
+ * @param {Uint8Array | ReadableStream} input Payload of a tag 11 packet
+ * @returns {module:packet.Literal} object representation
+ */
+Literal.prototype.read = async function (bytes) {
+ await _webStreamTools2.default.parse(bytes, async reader => {
+ // - A one-octet field that describes how the data is formatted.
+ const format = _enums2.default.read(_enums2.default.literal, (await reader.readByte()));
+
+ const filename_len = await reader.readByte();
+ this.filename = _util2.default.decode_utf8((await reader.readBytes(filename_len)));
+
+ this.date = _util2.default.readDate((await reader.readBytes(4)));
+
+ const data = reader.remainder();
+
+ this.setBytes(data, format);
+ });
+};
+
+/**
+ * Creates a string representation of the packet
+ *
+ * @returns {Uint8Array | ReadableStream} Uint8Array representation of the packet
+ */
+Literal.prototype.write = function () {
+ const filename = _util2.default.encode_utf8(this.filename);
+ const filename_length = new Uint8Array([filename.length]);
+
+ const format = new Uint8Array([_enums2.default.write(_enums2.default.literal, this.format)]);
+ const date = _util2.default.writeDate(this.date);
+ const data = this.getBytes();
+
+ return _util2.default.concat([format, filename_length, filename, date, data]);
+};
+
+exports.default = Literal;
+
+},{"../enums":114,"../util":153,"web-stream-tools":76}],128:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Implementation of the strange "Marker packet" (Tag 10)
+ *
+ * {@link https://tools.ietf.org/html/rfc4880#section-5.8|RFC4880 5.8}:
+ * An experimental version of PGP used this packet as the Literal
+ * packet, but no released version of PGP generated Literal packets with this
+ * tag. With PGP 5.x, this packet has been reassigned and is reserved for use as
+ * the Marker packet.
+ *
+ * Such a packet MUST be ignored when received.
+ * @memberof module:packet
+ * @constructor
+ */
+function Marker() {
+ this.tag = _enums2.default.packet.marker;
+}
+
+/**
+ * Parsing function for a literal data packet (tag 10).
+ *
+ * @param {String} input Payload of a tag 10 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.Marker} Object representation
+ */
+// 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 enums
+ */
+
+Marker.prototype.read = function (bytes) {
+ if (bytes[0] === 0x50 && // P
+ bytes[1] === 0x47 && // G
+ bytes[2] === 0x50) {
+ // P
+ return true;
+ }
+ // marker packet does not contain "PGP"
+ return false;
+};
+
+exports.default = Marker;
+
+},{"../enums":114}],129:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _signature = require('./signature');
+
+var _signature2 = _interopRequireDefault(_signature);
+
+var _keyid = require('../type/keyid');
+
+var _keyid2 = _interopRequireDefault(_keyid);
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Implementation of the One-Pass Signature Packets (Tag 4)
+ *
+ * {@link https://tools.ietf.org/html/rfc4880#section-5.4|RFC4880 5.4}:
+ * The One-Pass Signature packet precedes the signed data and contains
+ * enough information to allow the receiver to begin calculating any
+ * hashes needed to verify the signature. It allows the Signature
+ * packet to be placed at the end of the message, so that the signer
+ * can compute the entire signed message in one pass.
+ * @memberof module:packet
+ * @constructor
+ */
+// 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/signature
+ * @requires type/keyid
+ * @requires enums
+ * @requires util
+ */
+
+function OnePassSignature() {
+ /**
+ * Packet type
+ * @type {module:enums.packet}
+ */
+ this.tag = _enums2.default.packet.onePassSignature;
+ /** A one-octet version number. The current version is 3. */
+ this.version = null;
+ /**
+ * A one-octet signature type.
+ * Signature types are described in
+ * {@link https://tools.ietf.org/html/rfc4880#section-5.2.1|RFC4880 Section 5.2.1}.
+ */
+ this.signatureType = null;
+ /**
+ * A one-octet number describing the hash algorithm used.
+ * @see {@link https://tools.ietf.org/html/rfc4880#section-9.4|RFC4880 9.4}
+ */
+ this.hashAlgorithm = null;
+ /**
+ * A one-octet number describing the public-key algorithm used.
+ * @see {@link https://tools.ietf.org/html/rfc4880#section-9.1|RFC4880 9.1}
+ */
+ this.publicKeyAlgorithm = null;
+ /** An eight-octet number holding the Key ID of the signing key. */
+ this.issuerKeyId = null;
+ /**
+ * A one-octet number holding a flag showing whether the signature is nested.
+ * A zero value indicates that the next packet is another One-Pass Signature packet
+ * that describes another signature to be applied to the same message data.
+ */
+ this.flags = null;
+}
+
+/**
+ * parsing function for a one-pass signature packet (tag 4).
+ * @param {Uint8Array} bytes payload of a tag 4 packet
+ * @returns {module:packet.OnePassSignature} object representation
+ */
+OnePassSignature.prototype.read = function (bytes) {
+ let mypos = 0;
+ // A one-octet version number. The current version is 3.
+ this.version = bytes[mypos++];
+
+ // A one-octet signature type. Signature types are described in
+ // Section 5.2.1.
+ this.signatureType = bytes[mypos++];
+
+ // A one-octet number describing the hash algorithm used.
+ this.hashAlgorithm = bytes[mypos++];
+
+ // A one-octet number describing the public-key algorithm used.
+ this.publicKeyAlgorithm = bytes[mypos++];
+
+ // An eight-octet number holding the Key ID of the signing key.
+ this.issuerKeyId = new _keyid2.default();
+ this.issuerKeyId.read(bytes.subarray(mypos, mypos + 8));
+ mypos += 8;
+
+ // A one-octet number holding a flag showing whether the signature
+ // is nested. A zero value indicates that the next packet is
+ // another One-Pass Signature packet that describes another
+ // signature to be applied to the same message data.
+ this.flags = bytes[mypos++];
+ return this;
+};
+
+/**
+ * creates a string representation of a one-pass signature packet
+ * @returns {Uint8Array} a Uint8Array representation of a one-pass signature packet
+ */
+OnePassSignature.prototype.write = function () {
+ const start = new Uint8Array([3, _enums2.default.write(_enums2.default.signature, this.signatureType), _enums2.default.write(_enums2.default.hash, this.hashAlgorithm), _enums2.default.write(_enums2.default.publicKey, this.publicKeyAlgorithm)]);
+
+ const end = new Uint8Array([this.flags]);
+
+ return _util2.default.concatUint8Array([start, this.issuerKeyId.write(), end]);
+};
+
+/**
+ * Fix custom types after cloning
+ */
+OnePassSignature.prototype.postCloneTypeFix = function () {
+ this.issuerKeyId = _keyid2.default.fromClone(this.issuerKeyId);
+};
+
+OnePassSignature.prototype.hash = function () {
+ const version = this.version;
+ this.version = 4;
+ try {
+ return _signature2.default.prototype.hash.apply(this, arguments);
+ } finally {
+ this.version = version;
+ }
+};
+OnePassSignature.prototype.toHash = _signature2.default.prototype.toHash;
+OnePassSignature.prototype.toSign = _signature2.default.prototype.toSign;
+OnePassSignature.prototype.calculateTrailer = _signature2.default.prototype.calculateTrailer;
+
+OnePassSignature.prototype.verify = async function () {
+ const correspondingSig = await this.correspondingSig;
+ if (!correspondingSig || correspondingSig.tag !== _enums2.default.packet.signature) {
+ throw new Error('Corresponding signature packet missing');
+ }
+ if (correspondingSig.signatureType !== this.signatureType || correspondingSig.hashAlgorithm !== this.hashAlgorithm || correspondingSig.publicKeyAlgorithm !== this.publicKeyAlgorithm || !correspondingSig.issuerKeyId.equals(this.issuerKeyId)) {
+ throw new Error('Corresponding signature packet does not match one-pass signature packet');
+ }
+ correspondingSig.hashed = this.hashed;
+ return correspondingSig.verify.apply(correspondingSig, arguments);
+};
+
+exports.default = OnePassSignature;
+
+},{"../enums":114,"../type/keyid":149,"../util":153,"./signature":137}],130:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); // 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
+
+/* eslint-disable callback-return */
+
+/**
+ * @fileoverview Functions for reading and writing packets
+ * @requires web-stream-tools
+ * @requires enums
+ * @requires util
+ * @module packet/packet
+ */
+
+var _webStreamTools = require('web-stream-tools');
+
+var _webStreamTools2 = _interopRequireDefault(_webStreamTools);
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
+ readSimpleLength: function readSimpleLength(bytes) {
+ let len = 0;
+ let offset;
+ const type = bytes[0];
+
+ if (type < 192) {
+ var _bytes = _slicedToArray(bytes, 1);
+
+ len = _bytes[0];
+
+ offset = 1;
+ } else if (type < 255) {
+ len = (bytes[0] - 192 << 8) + bytes[1] + 192;
+ offset = 2;
+ } else if (type === 255) {
+ len = _util2.default.readNumber(bytes.subarray(1, 1 + 4));
+ offset = 5;
+ }
+
+ return {
+ len: len,
+ offset: offset
+ };
+ },
+
+ /**
+ * Encodes a given integer of length to the openpgp length specifier to a
+ * string
+ *
+ * @param {Integer} length The length to encode
+ * @returns {Uint8Array} String with openpgp length representation
+ */
+ writeSimpleLength: function writeSimpleLength(length) {
+ if (length < 192) {
+ return new Uint8Array([length]);
+ } else if (length > 191 && length < 8384) {
+ /*
+ * let a = (total data packet length) - 192 let bc = two octet
+ * representation of a let d = b + 192
+ */
+ return new Uint8Array([(length - 192 >> 8) + 192, length - 192 & 0xFF]);
+ }
+ return _util2.default.concatUint8Array([new Uint8Array([255]), _util2.default.writeNumber(length, 4)]);
+ },
+
+ writePartialLength: function writePartialLength(power) {
+ if (power < 0 || power > 30) {
+ throw new Error('Partial Length power must be between 1 and 30');
+ }
+ return new Uint8Array([224 + power]);
+ },
+
+ writeTag: function writeTag(tag_type) {
+ /* we're only generating v4 packet headers here */
+ return new Uint8Array([0xC0 | tag_type]);
+ },
+
+ /**
+ * Writes a packet header version 4 with the given tag_type and length to a
+ * string
+ *
+ * @param {Integer} tag_type Tag type
+ * @param {Integer} length Length of the payload
+ * @returns {String} String of the header
+ */
+ writeHeader: function writeHeader(tag_type, length) {
+ /* we're only generating v4 packet headers here */
+ return _util2.default.concatUint8Array([this.writeTag(tag_type), this.writeSimpleLength(length)]);
+ },
+
+ /**
+ * Writes a packet header Version 3 with the given tag_type and length to a
+ * string
+ *
+ * @param {Integer} tag_type Tag type
+ * @param {Integer} length Length of the payload
+ * @returns {String} String of the header
+ */
+ writeOldHeader: function writeOldHeader(tag_type, length) {
+ if (length < 256) {
+ return new Uint8Array([0x80 | tag_type << 2, length]);
+ } else if (length < 65536) {
+ return _util2.default.concatUint8Array([new Uint8Array([0x80 | tag_type << 2 | 1]), _util2.default.writeNumber(length, 2)]);
+ }
+ return _util2.default.concatUint8Array([new Uint8Array([0x80 | tag_type << 2 | 2]), _util2.default.writeNumber(length, 4)]);
+ },
+
+ /**
+ * Whether the packet type supports partial lengths per RFC4880
+ * @param {Integer} tag_type Tag type
+ * @returns {Boolean} String of the header
+ */
+ supportsStreaming: function supportsStreaming(tag_type) {
+ return [_enums2.default.packet.literal, _enums2.default.packet.compressed, _enums2.default.packet.symmetricallyEncrypted, _enums2.default.packet.symEncryptedIntegrityProtected, _enums2.default.packet.symEncryptedAEADProtected].includes(tag_type);
+ },
+
+ /**
+ * Generic static Packet Parser function
+ *
+ * @param {Uint8Array | ReadableStream} input Input stream as string
+ * @param {Function} callback Function to call with the parsed packet
+ * @returns {Boolean} Returns false if the stream was empty and parsing is done, and true otherwise.
+ */
+ read: async function read(input, streaming, callback) {
+ const reader = _webStreamTools2.default.getReader(input);
+ let writer;
+ try {
+ const peekedBytes = await reader.peekBytes(2);
+ // some sanity checks
+ if (!peekedBytes || peekedBytes.length < 2 || (peekedBytes[0] & 0x80) === 0) {
+ throw new Error("Error during parsing. This message / key probably does not conform to a valid OpenPGP format.");
+ }
+ const headerByte = await reader.readByte();
+ let tag = -1;
+ let format = -1;
+ let packet_length;
+
+ format = 0; // 0 = old format; 1 = new format
+ if ((headerByte & 0x40) !== 0) {
+ format = 1;
+ }
+
+ let packet_length_type;
+ if (format) {
+ // new format header
+ tag = headerByte & 0x3F; // bit 5-0
+ } else {
+ // old format header
+ tag = (headerByte & 0x3F) >> 2; // bit 5-2
+ packet_length_type = headerByte & 0x03; // bit 1-0
+ }
+
+ const supportsStreaming = this.supportsStreaming(tag);
+ let packet = null;
+ let callbackReturned;
+ if (streaming && supportsStreaming) {
+ const transform = new TransformStream();
+ writer = _webStreamTools2.default.getWriter(transform.writable);
+ packet = transform.readable;
+ callbackReturned = callback({ tag, packet });
+ } else {
+ packet = [];
+ }
+
+ let wasPartialLength;
+ do {
+ if (!format) {
+ // 4.2.1. Old Format Packet Lengths
+ switch (packet_length_type) {
+ case 0:
+ // The packet has a one-octet length. The header is 2 octets
+ // long.
+ packet_length = await reader.readByte();
+ break;
+ case 1:
+ // The packet has a two-octet length. The header is 3 octets
+ // long.
+ packet_length = (await reader.readByte()) << 8 | (await reader.readByte());
+ break;
+ case 2:
+ // The packet has a four-octet length. The header is 5
+ // octets long.
+ packet_length = (await reader.readByte()) << 24 | (await reader.readByte()) << 16 | (await reader.readByte()) << 8 | (await reader.readByte());
+ break;
+ default:
+ // 3 - The packet is of indeterminate length. The header is 1
+ // octet long, and the implementation must determine how long
+ // the packet is. If the packet is in a file, this means that
+ // the packet extends until the end of the file. In general,
+ // an implementation SHOULD NOT use indeterminate-length
+ // packets except where the end of the data will be clear
+ // from the context, and even then it is better to use a
+ // definite length, or a new format header. The new format
+ // headers described below have a mechanism for precisely
+ // encoding data of indeterminate length.
+ packet_length = Infinity;
+ break;
+ }
+ } else {
+ // 4.2.2. New Format Packet Lengths
+ // 4.2.2.1. One-Octet Lengths
+ const lengthByte = await reader.readByte();
+ wasPartialLength = false;
+ if (lengthByte < 192) {
+ packet_length = lengthByte;
+ // 4.2.2.2. Two-Octet Lengths
+ } else if (lengthByte >= 192 && lengthByte < 224) {
+ packet_length = (lengthByte - 192 << 8) + (await reader.readByte()) + 192;
+ // 4.2.2.4. Partial Body Lengths
+ } else if (lengthByte > 223 && lengthByte < 255) {
+ packet_length = 1 << (lengthByte & 0x1F);
+ wasPartialLength = true;
+ if (!supportsStreaming) {
+ throw new TypeError('This packet type does not support partial lengths.');
+ }
+ // 4.2.2.3. Five-Octet Lengths
+ } else {
+ packet_length = (await reader.readByte()) << 24 | (await reader.readByte()) << 16 | (await reader.readByte()) << 8 | (await reader.readByte());
+ }
+ }
+ if (packet_length > 0) {
+ let bytesRead = 0;
+ while (true) {
+ if (writer) await writer.ready;
+
+ var _ref = await reader.read();
+
+ const done = _ref.done,
+ value = _ref.value;
+
+ if (done) {
+ if (packet_length === Infinity) break;
+ throw new Error('Unexpected end of packet');
+ }
+ const chunk = packet_length === Infinity ? value : value.subarray(0, packet_length - bytesRead);
+ if (writer) await writer.write(chunk);else packet.push(chunk);
+ bytesRead += value.length;
+ if (bytesRead >= packet_length) {
+ reader.unshift(value.subarray(packet_length - bytesRead + value.length));
+ break;
+ }
+ }
+ }
+ } while (wasPartialLength);
+
+ if (!writer) {
+ packet = _util2.default.concatUint8Array(packet);
+ await callback({ tag, packet });
+ }
+ const nextPacket = await reader.peekBytes(2);
+ if (writer) {
+ await writer.ready;
+ await writer.close();
+ await callbackReturned;
+ }
+ return !nextPacket || !nextPacket.length;
+ } catch (e) {
+ if (writer) {
+ await writer.abort(e);
+ return true;
+ } else {
+ throw e;
+ }
+ } finally {
+ reader.releaseLock();
+ }
+ }
+};
+
+},{"../enums":114,"../util":153,"web-stream-tools":76}],131:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _webStreamTools = require('web-stream-tools');
+
+var _webStreamTools2 = _interopRequireDefault(_webStreamTools);
+
+var _all_packets = require('./all_packets');
+
+var packets = _interopRequireWildcard(_all_packets);
+
+var _packet = require('./packet');
+
+var _packet2 = _interopRequireDefault(_packet);
+
+var _config = require('../config');
+
+var _config2 = _interopRequireDefault(_config);
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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
+ */
+/* eslint-disable callback-return */
+/**
+ * @requires web-stream-tools
+ * @requires packet/all_packets
+ * @requires packet/packet
+ * @requires config
+ * @requires enums
+ * @requires util
+ */
+
+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} A Uint8Array of bytes.
+ */
+List.prototype.read = async function (bytes, streaming) {
+ this.stream = _webStreamTools2.default.transformPair(bytes, async (readable, writable) => {
+ const writer = _webStreamTools2.default.getWriter(writable);
+ try {
+ while (true) {
+ await writer.ready;
+ const done = await _packet2.default.read(readable, streaming, async parsed => {
+ try {
+ const tag = _enums2.default.read(_enums2.default.packet, parsed.tag);
+ const packet = packets.newPacketFromTag(tag);
+ packet.packets = new List();
+ packet.fromStream = _util2.default.isStream(parsed.packet);
+ await packet.read(parsed.packet, streaming);
+ await writer.write(packet);
+ } catch (e) {
+ if (!_config2.default.tolerant || _packet2.default.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);
+ }
+ _util2.default.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 = _webStreamTools2.default.getReader(this.stream);
+ while (true) {
+ var _ref = await reader.read();
+
+ const done = _ref.done,
+ value = _ref.value;
+
+ if (!done) {
+ this.push(value);
+ } else {
+ this.stream = null;
+ }
+ if (done || _packet2.default.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 (_util2.default.isStream(packetbytes) && _packet2.default.supportsStreaming(this[i].tag)) {
+ let buffer = [];
+ let bufferLength = 0;
+ const minLength = 512;
+ arr.push(_packet2.default.writeTag(this[i].tag));
+ arr.push(_webStreamTools2.default.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 = _util2.default.concat([_packet2.default.writePartialLength(powerOf2)].concat(buffer));
+ buffer = [bufferConcat.subarray(1 + chunkSize)];
+ bufferLength = buffer[0].length;
+ return bufferConcat.subarray(0, 1 + chunkSize);
+ }
+ }, () => _util2.default.concat([_packet2.default.writeSimpleLength(bufferLength)].concat(buffer))));
+ } else {
+ if (_util2.default.isStream(packetbytes)) {
+ let length = 0;
+ arr.push(_webStreamTools2.default.transform(_webStreamTools2.default.clone(packetbytes), value => {
+ length += value.length;
+ }, () => _packet2.default.writeHeader(this[i].tag, length)));
+ } else {
+ arr.push(_packet2.default.writeHeader(this[i].tag, packetbytes.length));
+ }
+ arr.push(packetbytes);
+ }
+ }
+
+ return _util2.default.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 = _webStreamTools2.default.transform(packetlistClone.stream, packet => packets.fromStructuredClone(packet));
+ }
+ return packetlist;
+};
+
+exports.default = List;
+
+},{"../config":80,"../enums":114,"../util":153,"./all_packets":123,"./packet":130,"web-stream-tools":76}],132:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _sha = require('asmcrypto.js/dist_es5/hash/sha1/sha1');
+
+var _sha2 = require('asmcrypto.js/dist_es5/hash/sha256/sha256');
+
+var _keyid = require('../type/keyid');
+
+var _keyid2 = _interopRequireDefault(_keyid);
+
+var _mpi = require('../type/mpi');
+
+var _mpi2 = _interopRequireDefault(_mpi);
+
+var _config = require('../config');
+
+var _config2 = _interopRequireDefault(_config);
+
+var _crypto = require('../crypto');
+
+var _crypto2 = _interopRequireDefault(_crypto);
+
+var _enums = require('../enums');
+
+var _enums2 = _interopRequireDefault(_enums);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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
+ */
+// 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
+ */
+
+function PublicKey(date = new Date()) {
+ /**
+ * Packet type
+ * @type {module:enums.packet}
+ */
+ this.tag = _enums2.default.packet.publicKey;
+ /**
+ * Packet version
+ * @type {Integer}
+ */
+ this.version = _config2.default.aead_protect && _config2.default.aead_protect_version === 4 ? 5 : 4;
+ /**
+ * Key creation date.
+ * @type {Date}
+ */
+ this.created = _util2.default.normalizeDate(date);
+ /**
+ * Public key algorithm.
+ * @type {String}
+ */
+ this.algorithm = null;
+ /**
+ * Algorithm specific params
+ * @type {Array
