@protontech/openpgp 4.10.8 → 5.3.1

package/test/crypto/elliptic.js

@@ -1,251 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../dist/openpgp');
-const chai = require('chai');
-
-const elliptic_data = require('./elliptic_data');
-
-chai.use(require('chai-as-promised'));
-
-const expect = chai.expect;
-const key_data = elliptic_data.key_data;
-/* eslint-disable no-invalid-this */
-describe('Elliptic Curve Cryptography @lightweight', function () {
-  const elliptic_curves = openpgp.crypto.publicKey.elliptic;
-
-  const signature_data = {
-    priv: new Uint8Array([
-      0x14, 0x2B, 0xE2, 0xB7, 0x4D, 0xBD, 0x1B, 0x22,
-      0x4D, 0xDF, 0x96, 0xA4, 0xED, 0x8E, 0x5B, 0xF9,
-      0xBD, 0xD3, 0xFE, 0xAE, 0x3F, 0xB2, 0xCF, 0xEE,
-      0xA7, 0xDB, 0xD0, 0x58, 0xA7, 0x47, 0xF8, 0x7C
-    ]),
-    pub: new Uint8Array([
-      0x04,
-      0xD3, 0x36, 0x11, 0xF9, 0xF9, 0xAB, 0x39, 0x23,
-      0x15, 0xB9, 0x71, 0x7B, 0x2A, 0x0B, 0xA6, 0x6D,
-      0x39, 0x6D, 0x64, 0x87, 0x22, 0x9A, 0xA3, 0x0A,
-      0x55, 0x27, 0x14, 0x2E, 0x1C, 0x61, 0xA2, 0x8A,
-      0xDA, 0x4E, 0x8F, 0xCE, 0x04, 0xBE, 0xE2, 0xC3,
-      0x82, 0x0B, 0x21, 0x4C, 0xBC, 0xED, 0x0E, 0xE2,
-      0xF1, 0x14, 0x33, 0x9A, 0x86, 0x5F, 0xC6, 0xF9,
-      0x8E, 0x95, 0x24, 0x10, 0x1F, 0x0F, 0x13, 0xE4
-    ]),
-    message: new Uint8Array([
-      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
-    ]),
-    hashed: new Uint8Array([
-      0xbe, 0x45, 0xcb, 0x26, 0x05, 0xbf, 0x36, 0xbe,
-      0xbd, 0xe6, 0x84, 0x84, 0x1a, 0x28, 0xf0, 0xfd,
-      0x43, 0xc6, 0x98, 0x50, 0xa3, 0xdc, 0xe5, 0xfe,
-      0xdb, 0xa6, 0x99, 0x28, 0xee, 0x3a, 0x89, 0x91
-    ]),
-    signature: {
-      r: new Uint8Array([
-        0xF1, 0x78, 0x1C, 0xA5, 0x13, 0x21, 0x0C, 0xBA,
-        0x6F, 0x18, 0x5D, 0xB3, 0x01, 0xE2, 0x17, 0x1B,
-        0x67, 0x65, 0x7F, 0xC6, 0x1F, 0x50, 0x12, 0xFB,
-        0x2F, 0xD3, 0xA4, 0x29, 0xE3, 0xC2, 0x44, 0x9F
-      ]),
-      s: new Uint8Array([
-        0x7F, 0x08, 0x69, 0x6D, 0xBB, 0x1B, 0x9B, 0xF2,
-        0x62, 0x1C, 0xCA, 0x80, 0xC6, 0x15, 0xB2, 0xAE,
-        0x60, 0x50, 0xD1, 0xA7, 0x1B, 0x32, 0xF3, 0xB1,
-        0x01, 0x0B, 0xDF, 0xC6, 0xAB, 0xF0, 0xEB, 0x01
-      ])
-    }
-  };
-  describe('Basic Operations', function () {
-    it('Creating curve from name or oid', function (done) {
-      Object.keys(openpgp.enums.curve).forEach(function(name_or_oid) {
-        expect(new elliptic_curves.Curve(name_or_oid)).to.exist;
-      });
-      Object.values(openpgp.enums.curve).forEach(function(name_or_oid) {
-        expect(new elliptic_curves.Curve(name_or_oid)).to.exist;
-      });
-      done();
-    });
-    it('Creating KeyPair', function () {
-      if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-        this.skip();
-      }
-      const names = openpgp.config.use_indutny_elliptic ? ['p256', 'p384', 'p521', 'secp256k1', 'curve25519', 'brainpoolP256r1', 'brainpoolP384r1', 'brainpoolP512r1'] :
-        ['p256', 'p384', 'p521', 'curve25519'];
-      return Promise.all(names.map(function (name) {
-        const curve = new elliptic_curves.Curve(name);
-        return curve.genKeyPair().then(keyPair => {
-          expect(keyPair).to.exist;
-        });
-      }));
-    });
-    it('Signature verification', function (done) {
-      expect(
-        elliptic_curves.ecdsa.verify('p256', 8, signature_data.signature, signature_data.message, signature_data.pub, signature_data.hashed)
-      ).to.eventually.be.true.notify(done);
-    });
-    it('Invalid signature', function (done) {
-      expect(
-        elliptic_curves.ecdsa.verify('p256', 8, signature_data.signature, signature_data.message, key_data.p256.pub, signature_data.hashed)
-      ).to.eventually.be.false.notify(done);
-    });
-    it('Signature generation', function () {
-      return elliptic_curves.ecdsa.sign('p256', 8, signature_data.message, key_data.p256.pub, key_data.p256.priv, signature_data.hashed).then(async signature => {
-        await expect(
-          elliptic_curves.ecdsa.verify('p256', 8, signature, signature_data.message, key_data.p256.pub, signature_data.hashed)
-        ).to.eventually.be.true;
-      });
-    });
-    it('Shared secret generation', async function () {
-      const curve = new elliptic_curves.Curve('p256');
-      const { sharedKey: shared1 } = await elliptic_curves.ecdh.genPrivateEphemeralKey(curve, signature_data.pub, key_data.p256.pub, key_data.p256.priv);
-      const { sharedKey: shared2 } = await elliptic_curves.ecdh.genPrivateEphemeralKey(curve, key_data.p256.pub, signature_data.pub, signature_data.priv);
-      expect(shared1).to.deep.equal(shared2);
-    });
-  });
-  describe('ECDSA signature', function () {
-    const verify_signature = async function (oid, hash, r, s, message, pub) {
-      if (openpgp.util.isString(message)) {
-        message = openpgp.util.str_to_Uint8Array(message);
-      } else if (!openpgp.util.isUint8Array(message)) {
-        message = new Uint8Array(message);
-      }
-      const ecdsa = elliptic_curves.ecdsa;
-      return ecdsa.verify(
-        oid, hash, { r: new Uint8Array(r), s: new Uint8Array(s) }, message, new Uint8Array(pub), await openpgp.crypto.hash.digest(hash, message)
-      );
-    };
-    const verify_signature_elliptic = async function (oid, hash, r, s, message, pub) {
-      if (openpgp.util.isString(message)) {
-        message = openpgp.util.str_to_Uint8Array(message);
-      } else if (!openpgp.util.isUint8Array(message)) {
-        message = new Uint8Array(message);
-      }
-      const ecdsa = elliptic_curves.ecdsa;
-      return ecdsa.ellipticVerify(
-        new elliptic_curves.Curve(oid), { r: new Uint8Array(r), s: new Uint8Array(s) }, await openpgp.crypto.hash.digest(hash, message), new Uint8Array(pub)
-      );
-    };
-    const secp256k1_point = new Uint8Array([
-      0x04,
-      0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC,
-      0x55, 0xA0, 0x62, 0x95, 0xCE, 0x87, 0x0B, 0x07,
-      0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE, 0x28, 0xD9,
-      0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17, 0x98,
-      0x48, 0x3A, 0xDA, 0x77, 0x26, 0xA3, 0xC4, 0x65,
-      0x5D, 0xA4, 0xFB, 0xFC, 0x0E, 0x11, 0x08, 0xA8,
-      0xFD, 0x17, 0xB4, 0x48, 0xA6, 0x85, 0x54, 0x19,
-      0x9C, 0x47, 0xD0, 0x8F, 0xFB, 0x10, 0xD4, 0xB8
-    ]);
-    const secp256k1_invalid_point = new Uint8Array([
-      0x04,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    ]);
-    const secp256k1_invalid_point_format = new Uint8Array([
-      0x04,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-    ]);
-    it('Invalid curve oid', function () {
-      return Promise.all([
-        expect(verify_signature(
-          'invalid oid', 8, [], [], [], []
-        )).to.be.rejectedWith(Error, /Not valid curve/),
-        expect(verify_signature(
-          "\x00", 8, [], [], [], []
-        )).to.be.rejectedWith(Error, /Not valid curve/)
-      ]);
-    });
-    it('Invalid public key', async function () {
-      if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-        this.skip();
-      }
-      if (openpgp.util.getNodeCrypto()) {
-        await expect(verify_signature(
-          'secp256k1', 8, [], [], [], []
-        )).to.eventually.be.false;
-        await expect(verify_signature(
-          'secp256k1', 8, [], [], [], secp256k1_invalid_point_format
-        )).to.eventually.be.false;
-      }
-      if (openpgp.config.use_indutny_elliptic) {
-        return Promise.all([
-          expect(verify_signature_elliptic(
-            'secp256k1', 8, [], [], [], []
-          )).to.be.rejectedWith(Error, /Unknown point format/),
-          expect(verify_signature_elliptic(
-            'secp256k1', 8, [], [], [], secp256k1_invalid_point_format
-          )).to.be.rejectedWith(Error, /Unknown point format/)
-        ]);
-      }
-    });
-    it('Invalid point', function () {
-      if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-        this.skip();
-      }
-      if (openpgp.util.getNodeCrypto()) {
-        expect(verify_signature(
-          'secp256k1', 8, [], [], [], secp256k1_invalid_point
-        )).to.eventually.be.false;
-      }
-      if (openpgp.config.use_indutny_elliptic) {
-        expect(verify_signature_elliptic(
-          'secp256k1', 8, [], [], [], secp256k1_invalid_point
-        )).to.be.rejectedWith(Error, /Invalid elliptic public key/);
-      }
-    });
-    it('Invalid signature', function (done) {
-      if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-        this.skip();
-      }
-      expect(verify_signature(
-        'secp256k1', 8, [], [], [], secp256k1_point
-      )).to.eventually.be.false.notify(done);
-    });
-
-    const p384_message = new Uint8Array([
-      0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-      0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
-    ]);
-    const p384_r = new Uint8Array([
-      0x9D, 0x07, 0xCA, 0xA5, 0x9F, 0xBE, 0xB8, 0x76,
-      0xA9, 0xB9, 0x66, 0x0F, 0xA0, 0x64, 0x70, 0x5D,
-      0xE6, 0x37, 0x40, 0x43, 0xD0, 0x8E, 0x40, 0xA8,
-      0x8B, 0x37, 0x83, 0xE7, 0xBC, 0x1C, 0x4C, 0x86,
-      0xCB, 0x3C, 0xD5, 0x9B, 0x68, 0xF0, 0x65, 0xEB,
-      0x3A, 0xB6, 0xD6, 0xA6, 0xCF, 0x85, 0x3D, 0xA9
-    ]);
-    const p384_s = new Uint8Array([
-      0x32, 0x85, 0x78, 0xCC, 0xEA, 0xC5, 0x22, 0x83,
-      0x10, 0x73, 0x1C, 0xCF, 0x10, 0x8A, 0x52, 0x11,
-      0x8E, 0x49, 0x9E, 0xCF, 0x7E, 0x17, 0x18, 0xC3,
-      0x11, 0x11, 0xBC, 0x0F, 0x6D, 0x98, 0xE2, 0x16,
-      0x68, 0x58, 0x23, 0x1D, 0x11, 0xEF, 0x3D, 0x21,
-      0x30, 0x75, 0x24, 0x39, 0x48, 0x89, 0x03, 0xDC
-    ]);
-    it('Valid signature', function (done) {
-      expect(verify_signature('p384', 8, p384_r, p384_s, p384_message, key_data.p384.pub))
-        .to.eventually.be.true.notify(done);
-    });
-    it('Sign and verify message', function () {
-      const curve = new elliptic_curves.Curve('p521');
-      return curve.genKeyPair().then(async keyPair => {
-        const keyPublic = new Uint8Array(keyPair.publicKey);
-        const keyPrivate = new Uint8Array(keyPair.privateKey);
-        const oid = curve.oid;
-        const message = p384_message;
-        return elliptic_curves.ecdsa.sign(oid, 10, message, keyPublic, keyPrivate, await openpgp.crypto.hash.digest(10, message)).then(async signature => {
-          await expect(elliptic_curves.ecdsa.verify(oid, 10, signature, message, keyPublic, await openpgp.crypto.hash.digest(10, message)))
-            .to.eventually.be.true;
-        });
-      });
-    });
-  });
-});

package/test/crypto/elliptic_data.js

@@ -1,102 +0,0 @@
-const elliptic_data = {
-  key_data: {
-    p256: {
-      priv: new Uint8Array([
-        0x2B, 0x48, 0x2B, 0xE9, 0x88, 0x74, 0xE9, 0x49,
-        0x1F, 0x89, 0xCC, 0xFF, 0x0A, 0x26, 0x05, 0xA2,
-        0x3C, 0x2A, 0x35, 0x25, 0x26, 0x11, 0xD7, 0xEA,
-        0xA1, 0xED, 0x29, 0x95, 0xB5, 0xE1, 0x5F, 0x1D
-      ]),
-      pub: new Uint8Array([
-        0x04,
-        0x80, 0x2C, 0x40, 0x76, 0x31, 0x20, 0xB6, 0x9B,
-        0x48, 0x3B, 0x05, 0xEB, 0x6C, 0x1E, 0x3F, 0x49,
-        0x84, 0xF7, 0xD2, 0xAD, 0x16, 0xA1, 0x6F, 0x62,
-        0xFD, 0xCA, 0xEC, 0xB4, 0xA0, 0xBD, 0x4C, 0x1A,
-        0x6F, 0xAA, 0xE7, 0xFD, 0xC4, 0x7D, 0x89, 0xCC,
-        0x06, 0xCA, 0xFE, 0xAE, 0xCD, 0x0E, 0x9E, 0x62,
-        0x57, 0xA4, 0xC3, 0xE7, 0x5E, 0x69, 0x10, 0xEE,
-        0x67, 0xC2, 0x09, 0xF9, 0xEF, 0xE7, 0x9E, 0x56
-      ])
-    },
-    p384: {
-      priv: new Uint8Array([
-        0xB5, 0x38, 0xDA, 0xF3, 0x77, 0x58, 0x3F, 0x94,
-        0x5B, 0xC2, 0xCA, 0xC6, 0xA9, 0xFC, 0xAA, 0x3F,
-        0x97, 0xB0, 0x54, 0x26, 0x10, 0xB4, 0xEC, 0x2A,
-        0xA7, 0xC1, 0xA3, 0x4B, 0xC0, 0xBD, 0xFE, 0x3E,
-        0xF1, 0xBE, 0x76, 0xCB, 0xE8, 0xAB, 0x3B, 0xBD,
-        0xB6, 0x84, 0xC7, 0x8B, 0x91, 0x2F, 0x76, 0x8B
-      ]),
-      pub: new Uint8Array([
-        0x04,
-        0x44, 0x83, 0xA0, 0x3E, 0x5B, 0x0A, 0x0D, 0x9B,
-        0xA0, 0x06, 0xDF, 0x38, 0xC7, 0x64, 0xCD, 0x62,
-        0x7D, 0x5E, 0x3D, 0x3B, 0x50, 0xF5, 0x06, 0xC7,
-        0xF7, 0x9B, 0xF0, 0xDE, 0xB1, 0x0C, 0x64, 0x74,
-        0x0D, 0x03, 0x67, 0x24, 0xA0, 0xFF, 0xD1, 0x3D,
-        0x03, 0x96, 0x48, 0xE7, 0x73, 0x5E, 0xF1, 0xC0,
-        0x62, 0xCC, 0x33, 0x5A, 0x2A, 0x66, 0xA7, 0xAB,
-        0xCA, 0x77, 0x52, 0xB8, 0xCD, 0xB5, 0x91, 0x16,
-        0xAF, 0x42, 0xBB, 0x79, 0x0A, 0x59, 0x51, 0x68,
-        0x8E, 0xEA, 0x32, 0x7D, 0x4A, 0x4A, 0xBB, 0x26,
-        0x13, 0xFB, 0x95, 0xC0, 0xB1, 0xA4, 0x54, 0xCA,
-        0xFA, 0x85, 0x8A, 0x4B, 0x58, 0x7C, 0x61, 0x39
-      ])
-    },
-    p521: {
-      priv: new Uint8Array([
-        0x00, 0xBB, 0x35, 0x27, 0xBC, 0xD6, 0x7E, 0x35,
-        0xD5, 0xC5, 0x99, 0xC9, 0xB4, 0x6C, 0xEE, 0xDE,
-        0x79, 0x2D, 0x77, 0xBD, 0x0A, 0x08, 0x9A, 0xC2,
-        0x21, 0xF8, 0x35, 0x1C, 0x49, 0x5C, 0x40, 0x11,
-        0xAC, 0x95, 0x2A, 0xEE, 0x91, 0x3A, 0x60, 0x5A,
-        0x25, 0x5A, 0x95, 0x38, 0xDC, 0xEB, 0x59, 0x8E,
-        0x33, 0xAD, 0xC0, 0x0B, 0x56, 0xB1, 0x06, 0x8C,
-        0x57, 0x48, 0xA3, 0x73, 0xDB, 0xE0, 0x19, 0x50,
-        0x2E, 0x79
-      ]),
-      pub: new Uint8Array([
-        0x04,
-        0x01, 0x0D, 0xD5, 0xCA, 0xD8, 0xB0, 0xEF, 0x9F,
-        0x2B, 0x7E, 0x58, 0x99, 0xDE, 0x05, 0xF6, 0xF6,
-        0x64, 0x6B, 0xCD, 0x59, 0x2E, 0x39, 0xB8, 0x82,
-        0xB3, 0x13, 0xE6, 0x7D, 0x50, 0x85, 0xC3, 0xFA,
-        0x93, 0xA5, 0x3F, 0x92, 0x85, 0x42, 0x36, 0xC0,
-        0x83, 0xC9, 0xA4, 0x38, 0xB3, 0xD1, 0x99, 0xDA,
-        0xE1, 0x02, 0x37, 0x7A, 0x3A, 0xC2, 0xB4, 0x55,
-        0xEC, 0x1C, 0x0F, 0x00, 0x97, 0xFC, 0x75, 0x93,
-        0xFE, 0x87, 0x00, 0x7D, 0xBE, 0x1A, 0xF5, 0xF9,
-        0x57, 0x5C, 0xF2, 0x50, 0x2D, 0x14, 0x32, 0xEE,
-        0x9B, 0xBE, 0xB3, 0x0E, 0x12, 0x2F, 0xF8, 0x85,
-        0x11, 0x1A, 0x4F, 0x88, 0x50, 0xA4, 0xDB, 0x37,
-        0xA6, 0x53, 0x5C, 0xB7, 0x87, 0xA6, 0x06, 0x21,
-        0x15, 0xCC, 0x12, 0xC0, 0x1C, 0x83, 0x6F, 0x7B,
-        0x5A, 0x8A, 0x36, 0x4E, 0x46, 0x9E, 0x54, 0x3F,
-        0xE2, 0xF7, 0xED, 0x63, 0xC9, 0x92, 0xA4, 0x38,
-        0x2B, 0x9C, 0xE2, 0xB7
-      ])
-    },
-    secp256k1: {
-      priv: new Uint8Array([
-        0x9E, 0xB0, 0x30, 0xD6, 0xE1, 0xCE, 0xAA, 0x0B,
-        0x7B, 0x8F, 0xDE, 0x5D, 0x91, 0x4D, 0xDC, 0xA0,
-        0xAD, 0x05, 0xAB, 0x8F, 0x87, 0x9B, 0x57, 0x48,
-        0xAE, 0x8A, 0xE0, 0xF9, 0x39, 0xBD, 0x24, 0x00
-      ]),
-      pub: new Uint8Array([
-        0x04,
-        0xA8, 0x02, 0x35, 0x2C, 0xB7, 0x24, 0x95, 0x51,
-        0x0A, 0x65, 0x26, 0x7D, 0xDF, 0xEA, 0x64, 0xB3,
-        0xA8, 0xE1, 0x4F, 0xDD, 0x12, 0x84, 0x7E, 0x59,
-        0xDB, 0x81, 0x0F, 0x89, 0xED, 0xFB, 0x29, 0xFB,
-        0x07, 0x60, 0x29, 0x7D, 0x39, 0x8F, 0xB8, 0x68,
-        0xF0, 0xFD, 0xA6, 0x67, 0x83, 0x55, 0x75, 0x7D,
-        0xB8, 0xFD, 0x0B, 0xDF, 0x76, 0xCE, 0xBC, 0x95,
-        0x4B, 0x92, 0x26, 0xFC, 0xAA, 0x7A, 0x7C, 0x3F
-      ])
-    }
-  }
-};
-
-module.exports = elliptic_data;

package/test/crypto/hash/index.js

@@ -1,5 +0,0 @@
-describe('Hash', function () {
-  require('./md5.js');
-  require('./ripemd.js');
-  require('./sha.js');
-});

package/test/crypto/hash/md5.js

@@ -1,16 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../../dist/openpgp');
-
-const chai = require('chai');
-
-const { util } = openpgp;
-const md5 = openpgp.crypto.hash.md5;
-const { expect } = chai;
-
-it('MD5 with test vectors from RFC 1321', async function() {
-  expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array(''))), 'MD5("") = d41d8cd98f00b204e9800998ecf8427e')).to.equal('d41d8cd98f00b204e9800998ecf8427e');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('abc'))), 'MD5("a") = 0cc175b9c0f1b6a831c399e269772661')).to.equal('900150983cd24fb0d6963f7d28e17f72');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('message digest'))), 'MD5("message digest") = f96b697d7cb7938d525a2f31aaf161d0')).to.equal('f96b697d7cb7938d525a2f31aaf161d0');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('abcdefghijklmnopqrstuvwxyz'))), 'MD5("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b')).to.equal('c3fcd3d76192e4007dfb496cca67e13b');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'))), 'MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f')).to.equal('d174ab98d277d9f5a5611c2c9f419d9f');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('12345678901234567890123456789012345678901234567890123456789012345678901234567890'))), 'MD5("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a')).to.equal('57edf4a22be3c955ac49da2e2107b67a');
-});

package/test/crypto/hash/ripemd.js

@@ -1,14 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../../dist/openpgp');
-
-const chai = require('chai');
-
-const { util } = openpgp;
-const rmdString = openpgp.crypto.hash.ripemd;
-const { expect } = chai;
-
-it("RIPE-MD 160 bits with test vectors from https://homes.esat.kuleuven.be/~bosselae/ripemd160.html", async function() {
-  expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array(''))), 'RMDstring("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31')).to.equal('9c1185a5c5e9fc54612808977ee8f548b2258d31');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array('a'))), 'RMDstring("a") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe')).to.equal('0bdc9d2d256b3ee9daae347be6f4dc835a467ffe');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array('abc'))), 'RMDstring("abc") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc')).to.equal('8eb208f7e05d987a9b044a8e98c6b087f15a0bfc');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array('message digest'))), 'RMDstring("message digest") = 5d0689ef49d2fae572b881b123a85ffa21595f36')).to.equal('5d0689ef49d2fae572b881b123a85ffa21595f36');
-});

package/test/crypto/hash/sha.js

@@ -1,20 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../../dist/openpgp');
-
-const chai = require('chai');
-
-const { util } = openpgp;
-const { hash } = openpgp.crypto;
-const { expect } = chai;
-
-it('SHA* with test vectors from NIST FIPS 180-2', async function() {
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha1(util.str_to_Uint8Array('abc'))), 'hash.sha1("abc") = a9993e364706816aba3e25717850c26c9cd0d89d')).to.equal('a9993e364706816aba3e25717850c26c9cd0d89d');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha1(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e441c3bd26ebaae4aa1f95129e5e54670f1')).to.equal('84983e441c3bd26ebaae4aa1f95129e5e54670f1');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha224(util.str_to_Uint8Array('abc'))), 'hash.sha224("abc") = 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7')).to.equal('23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha224(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha224("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525')).to.equal('75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha256(util.str_to_Uint8Array('abc'))), 'hash.sha256("abc") = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad')).to.equal('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha256(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1')).to.equal('248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha384(util.str_to_Uint8Array('abc'))), 'hash.sha384("abc") = cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7')).to.equal('cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha384(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha384("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b')).to.equal('3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha512(util.str_to_Uint8Array('abc'))), 'hash.sha512("abc") = ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f')).to.equal('ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f');
-  expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha512(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445')).to.equal('204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445');
-});

package/test/crypto/index.js

@@ -1,14 +0,0 @@
-describe('Crypto', function () {
-  require('./cipher');
-  require('./hash');
-  require('./random.js');
-  require('./crypto.js');
-  require('./elliptic.js');
-  require('./ecdh.js');
-  require('./pkcs5.js');
-  require('./aes_kw.js');
-  require('./eax.js');
-  require('./ocb.js');
-  require('./rsa.js');
-  require('./validate.js');
-});

package/test/crypto/ocb.js

@@ -1,183 +0,0 @@
-// Modified by ProtonTech AG
-
-// Adapted from https://github.com/artjomb/cryptojs-extension/blob/8c61d159/test/eax.js
-
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../dist/openpgp');
-
-const chai = require('chai');
-chai.use(require('chai-as-promised'));
-
-const expect = chai.expect;
-
-describe('Symmetric AES-OCB', function() {
-  it('Passes all test vectors', async function() {
-    const K = '000102030405060708090A0B0C0D0E0F';
-    const keyBytes = openpgp.util.hex_to_Uint8Array(K);
-
-    const vectors = [
-      // From https://tools.ietf.org/html/rfc7253#appendix-A
-      {
-        N: 'BBAA99887766554433221100',
-        A: '',
-        P: '',
-        C: '785407BFFFC8AD9EDCC5520AC9111EE6'
-      },
-      {
-        N: 'BBAA99887766554433221101',
-        A: '0001020304050607',
-        P: '0001020304050607',
-        C: '6820B3657B6F615A5725BDA0D3B4EB3A257C9AF1F8F03009'
-      },
-      {
-        N: 'BBAA99887766554433221102',
-        A: '0001020304050607',
-        P: '',
-        C: '81017F8203F081277152FADE694A0A00'
-      },
-      {
-        N: 'BBAA99887766554433221103',
-        A: '',
-        P: '0001020304050607',
-        C: '45DD69F8F5AAE72414054CD1F35D82760B2CD00D2F99BFA9'
-      },
-      {
-        N: 'BBAA99887766554433221104',
-        A: '000102030405060708090A0B0C0D0E0F',
-        P: '000102030405060708090A0B0C0D0E0F',
-        C: '571D535B60B277188BE5147170A9A22C3AD7A4FF3835B8C5701C1CCEC8FC3358'
-      },
-      {
-        N: 'BBAA99887766554433221105',
-        A: '000102030405060708090A0B0C0D0E0F',
-        P: '',
-        C: '8CF761B6902EF764462AD86498CA6B97'
-      },
-      {
-        N: 'BBAA99887766554433221106',
-        A: '',
-        P: '000102030405060708090A0B0C0D0E0F',
-        C: '5CE88EC2E0692706A915C00AEB8B2396F40E1C743F52436BDF06D8FA1ECA343D'
-      },
-      {
-        N: 'BBAA99887766554433221107',
-        A: '000102030405060708090A0B0C0D0E0F1011121314151617',
-        P: '000102030405060708090A0B0C0D0E0F1011121314151617',
-        C: '1CA2207308C87C010756104D8840CE1952F09673A448A122C92C62241051F57356D7F3C90BB0E07F'
-      },
-      {
-        N: 'BBAA99887766554433221108',
-        A: '000102030405060708090A0B0C0D0E0F1011121314151617',
-        P: '',
-        C: '6DC225A071FC1B9F7C69F93B0F1E10DE'
-      },
-      {
-        N: 'BBAA99887766554433221109',
-        A: '',
-        P: '000102030405060708090A0B0C0D0E0F1011121314151617',
-        C: '221BD0DE7FA6FE993ECCD769460A0AF2D6CDED0C395B1C3CE725F32494B9F914D85C0B1EB38357FF'
-      },
-      {
-        N: 'BBAA9988776655443322110A',
-        A: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
-        P: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
-        C: 'BD6F6C496201C69296C11EFD138A467ABD3C707924B964DEAFFC40319AF5A48540FBBA186C5553C68AD9F592A79A4240'
-      },
-      {
-        N: 'BBAA9988776655443322110B',
-        A: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
-        P: '',
-        C: 'FE80690BEE8A485D11F32965BC9D2A32'
-      },
-      {
-        N: 'BBAA9988776655443322110C',
-        A: '',
-        P: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
-        C: '2942BFC773BDA23CABC6ACFD9BFD5835BD300F0973792EF46040C53F1432BCDFB5E1DDE3BC18A5F840B52E653444D5DF'
-      },
-      {
-        N: 'BBAA9988776655443322110D',
-        A: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627',
-        P: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627',
-        C: 'D5CA91748410C1751FF8A2F618255B68A0A12E093FF454606E59F9C1D0DDC54B65E8628E568BAD7AED07BA06A4A69483A7035490C5769E60'
-      },
-      {
-        N: 'BBAA9988776655443322110E',
-        A: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627',
-        P: '',
-        C: 'C5CD9D1850C141E358649994EE701B68'
-      },
-      {
-        N: 'BBAA9988776655443322110F',
-        A: '',
-        P: '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627',
-        C: '4412923493C57D5DE0D700F753CCE0D1D2D95060122E9F15A5DDBFC5787E50B5CC55EE507BCB084E479AD363AC366B95A98CA5F3000B1479'
-      }
-    ];
-
-    const cipher = 'aes128';
-
-    await Promise.all(vectors.map(async vec => {
-      const msgBytes = openpgp.util.hex_to_Uint8Array(vec.P);
-      const nonceBytes = openpgp.util.hex_to_Uint8Array(vec.N);
-      const headerBytes = openpgp.util.hex_to_Uint8Array(vec.A);
-      const ctBytes = openpgp.util.hex_to_Uint8Array(vec.C);
-
-      const ocb = await openpgp.crypto.ocb(cipher, keyBytes);
-
-      // encryption test
-      let ct = await ocb.encrypt(msgBytes, nonceBytes, headerBytes);
-      expect(openpgp.util.Uint8Array_to_hex(ct)).to.equal(vec.C.toLowerCase());
-
-      // decryption test with verification
-      let pt = await ocb.decrypt(ctBytes, nonceBytes, headerBytes);
-      expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.P.toLowerCase());
-
-      // tampering detection test
-      ct = await ocb.encrypt(msgBytes, nonceBytes, headerBytes);
-      ct[2] ^= 8;
-      pt = ocb.decrypt(ct, nonceBytes, headerBytes);
-      await expect(pt).to.eventually.be.rejectedWith('Authentication tag mismatch');
-
-      // testing without additional data
-      ct = await ocb.encrypt(msgBytes, nonceBytes, new Uint8Array());
-      pt = await ocb.decrypt(ct, nonceBytes, new Uint8Array());
-      expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.P.toLowerCase());
-
-      // testing with multiple additional data
-      ct = await ocb.encrypt(msgBytes, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
-      pt = await ocb.decrypt(ct, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
-      expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.P.toLowerCase());
-    }));
-  });
-
-  it('Different key size test vectors', async function() {
-    const taglen = 128;
-    const outputs = {
-      128: '67E944D23256C5E0B6C61FA22FDF1EA2',
-      192: 'F673F2C3E7174AAE7BAE986CA9F29E17',
-      256: 'D90EB8E9C977C88B79DD793D7FFA161C'
-    };
-    const keylens = [128, 192, 256];
-    await Promise.all(keylens.map(async keylen => {
-      const k = new Uint8Array(keylen / 8);
-      k[k.length - 1] = taglen;
-
-      const ocb = await openpgp.crypto.ocb('aes' + keylen, k);
-
-      const c = [];
-      let n;
-      for (let i = 0; i < 128; i++) {
-        const s = new Uint8Array(i);
-        n = openpgp.util.concatUint8Array([new Uint8Array(8), openpgp.util.writeNumber(3 * i + 1, 4)]);
-        c.push(await ocb.encrypt(s, n, s));
-        n = openpgp.util.concatUint8Array([new Uint8Array(8), openpgp.util.writeNumber(3 * i + 2, 4)]);
-        c.push(await ocb.encrypt(s, n, new Uint8Array()));
-        n = openpgp.util.concatUint8Array([new Uint8Array(8), openpgp.util.writeNumber(3 * i + 3, 4)]);
-        c.push(await ocb.encrypt(new Uint8Array(), n, s));
-      }
-      n = openpgp.util.concatUint8Array([new Uint8Array(8), openpgp.util.writeNumber(385, 4)]);
-      const output = await ocb.encrypt(new Uint8Array(), n, openpgp.util.concatUint8Array(c));
-      expect(openpgp.util.Uint8Array_to_hex(output)).to.equal(outputs[keylen].toLowerCase());
-    }));
-  });
-});

package/test/crypto/pkcs5.js

@@ -1,39 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../dist/openpgp');
-
-const expect = require('chai').expect;
-
-describe('PKCS5 padding', function() {
-  function repeat(pattern, count) {
-    let result = '';
-    for (let k = 0; k < count; ++k) {
-      result += pattern;
-    }
-    return result;
-  }
-  const pkcs5 = openpgp.crypto.pkcs5;
-  it('Add padding', function () {
-    let s = '';
-    while (s.length < 16) {
-      const r = pkcs5.encode(s);
-      // 0..7 -> 8, 8..15 -> 16
-      const l = Math.ceil((s.length + 1) / 8) * 8;
-      const c = l - s.length;
-      expect(r.length).to.equal(l);
-      expect(c).is.at.least(1).is.at.most(8);
-      expect(r.substr(-1)).to.equal(String.fromCharCode(c));
-      s += ' ';
-    }
-  });
-  it('Remove padding', function () {
-    for (let k = 1; k <= 8; ++k) {
-      const s = repeat(' ', 8 - k);
-      const r = s + repeat(String.fromCharCode(k), k);
-      const t = pkcs5.decode(r);
-      expect(t).to.equal(s);
-    }
-  });
-  it('Invalid padding', function () {
-    expect(function () { pkcs5.decode(' '); }).to.throw(Error, /Invalid padding/);
-    expect(function () { pkcs5.decode(''); }).to.throw(Error, /Invalid padding/);
-  });
-});