@protontech/openpgp 4.10.6 → 5.4.0

package/test/crypto/random.js

@@ -1,79 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../dist/openpgp');
-
-const chai = require('chai');
-
-const { expect } = chai;
-
-describe('Random Buffer', function() {
-  let randomBuffer;
-
-  before(function() {
-    randomBuffer = new openpgp.crypto.random.randomBuffer.constructor();
-    expect(randomBuffer).to.exist;
-  });
-
-  it('Throw error if not initialized', async function () {
-    expect(randomBuffer.set.bind(randomBuffer)).to.throw('RandomBuffer is not initialized');
-    await expect(randomBuffer.get(new Uint8Array(1))).to.eventually.be.rejectedWith('RandomBuffer is not initialized');
-  });
-
-  it('Initialization', function () {
-    randomBuffer.init(5);
-    expect(randomBuffer.buffer).to.exist;
-    expect(randomBuffer.buffer).to.have.length(5);
-    expect(randomBuffer.size).to.equal(0);
-  });
-
-  function equal(buf, arr) {
-    for (let i = 0; i < buf.length; i++) {
-      if (buf[i] !== arr[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  it('Set Method', function () {
-    randomBuffer.init(5);
-    let buf = new Uint32Array(2);
-    expect(randomBuffer.set.bind(randomBuffer, buf)).to.throw('Invalid type: buf not an Uint8Array');
-    buf = new Uint8Array(2);
-    buf[0] = 1; buf[1] = 2;
-    randomBuffer.set(buf);
-    expect(equal(randomBuffer.buffer, [1,2,0,0,0])).to.be.true;
-    expect(randomBuffer.size).to.equal(2);
-    randomBuffer.set(buf);
-    expect(equal(randomBuffer.buffer, [1,2,1,2,0])).to.be.true;
-    expect(randomBuffer.size).to.equal(4);
-    randomBuffer.set(buf);
-    expect(equal(randomBuffer.buffer, [1,2,1,2,1])).to.be.true;
-    expect(randomBuffer.size).to.equal(5);
-    randomBuffer.init(1);
-    buf = new Uint8Array(2);
-    buf[0] = 1; buf[1] = 2;
-    randomBuffer.set(buf);
-    expect(buf).to.to.have.property('0', 1);
-    expect(randomBuffer.size).to.equal(1);
-  });
-
-  it('Get Method', async function () {
-    randomBuffer.init(5);
-    let buf = new Uint8Array(5);
-    buf[0] = 1; buf[1] = 2; buf[2] = 5; buf[3] = 7; buf[4] = 8;
-    randomBuffer.set(buf);
-    buf = new Uint32Array(2);
-    await expect(randomBuffer.get(buf)).to.eventually.be.rejectedWith('Invalid type: buf not an Uint8Array');
-    buf = new Uint8Array(2);
-    randomBuffer.get(buf);
-    expect(equal(randomBuffer.buffer, [1,2,5,0,0])).to.be.true;
-    expect(randomBuffer.size).to.equal(3);
-    expect(buf).to.to.have.property('0', 8);
-    expect(buf).to.to.have.property('1', 7);
-    randomBuffer.get(buf);
-    expect(buf).to.to.have.property('0', 5);
-    expect(buf).to.to.have.property('1', 2);
-    expect(equal(randomBuffer.buffer, [1,0,0,0,0])).to.be.true;
-    expect(randomBuffer.size).to.equal(1);
-    await expect(randomBuffer.get(buf)).to.eventually.be.rejectedWith('Random number buffer depleted');
-  });
-});

package/test/crypto/rsa.js

@@ -1,180 +0,0 @@
-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;
-
-/* eslint-disable no-unused-expressions */
-/* eslint-disable no-invalid-this */
-const native = openpgp.util.getWebCrypto() || openpgp.util.getNodeCrypto();
-(!native ? describe.skip : describe)('basic RSA cryptography with native crypto', function () {
-  it('generate rsa key', async function() {
-    const bits = openpgp.util.getWebCryptoAll() ? 2048 : 1024;
-    const keyObject = await openpgp.crypto.publicKey.rsa.generate(bits, "10001");
-    expect(keyObject.n).to.exist;
-    expect(keyObject.e).to.exist;
-    expect(keyObject.d).to.exist;
-    expect(keyObject.p).to.exist;
-    expect(keyObject.q).to.exist;
-    expect(keyObject.u).to.exist;
-  });
-
-  it('sign and verify using generated key params', async function() {
-    const bits = openpgp.util.getWebCryptoAll() ? 2048 : 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const message = await openpgp.crypto.random.getRandomBytes(64);
-    const hash_algo = openpgp.enums.write(openpgp.enums.hash, 'sha256');
-    const hashed = await openpgp.crypto.hash.digest(hash_algo, message);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const signature = await openpgp.crypto.publicKey.rsa.sign(hash_algo, message, n, e, d, p, q, u, hashed);
-    expect(signature).to.exist;
-    const verify = await openpgp.crypto.publicKey.rsa.verify(hash_algo, message, signature, n, e, hashed);
-    expect(verify).to.be.true;
-  });
-
-  it('encrypt and decrypt using generated key params', async function() {
-    const bits = openpgp.util.getWebCryptoAll() ? 2048 : 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const message = openpgp.util.Uint8Array_to_str(await openpgp.crypto.generateSessionKey('aes256'));
-    const encrypted = await openpgp.crypto.publicKey.rsa.encrypt(openpgp.util.str_to_Uint8Array(message), n, e);
-    const result = new openpgp.MPI(encrypted);
-    const decrypted = await openpgp.crypto.publicKey.rsa.decrypt(result.toUint8Array(), n, e, d, p, q, u);
-    expect(decrypted).to.be.equal(message);
-  });
-
-  it('decrypt nodeCrypto by bnCrypto and vice versa', async function() {
-    if (!openpgp.util.getNodeCrypto()) {
-      this.skip();
-    }
-    const bits = 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const message = openpgp.util.Uint8Array_to_str(await openpgp.crypto.generateSessionKey('aes256'));
-    const encryptedBn = await openpgp.crypto.publicKey.rsa.bnEncrypt(openpgp.util.str_to_Uint8Array(message), n, e);
-    const resultBN = new openpgp.MPI(encryptedBn);
-    const decrypted1 = await openpgp.crypto.publicKey.rsa.nodeDecrypt(resultBN.toUint8Array(), n, e, d, p, q, u);
-    expect(decrypted1).to.be.equal(message);
-    const encryptedNode = await openpgp.crypto.publicKey.rsa.nodeEncrypt(openpgp.util.str_to_Uint8Array(message), n, e);
-    const resultNode = new openpgp.MPI(encryptedNode);
-    const decrypted2 = await openpgp.crypto.publicKey.rsa.bnDecrypt(resultNode.toUint8Array(), n, e, d, p, q, u);
-    expect(decrypted2).to.be.equal(message);
-  });
-
-  it('compare webCrypto and bn math sign', async function() {
-    if (!openpgp.util.getWebCrypto()) {
-      this.skip();
-    }
-    const bits = openpgp.util.getWebCrypto() ? 2048 : 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const message = await openpgp.crypto.random.getRandomBytes(64);
-    const hashName = 'sha256';
-    const hash_algo = openpgp.enums.write(openpgp.enums.hash, hashName);
-    const hashed = await openpgp.crypto.hash.digest(hash_algo, message);
-    let signatureWeb;
-    try {
-      signatureWeb = await openpgp.crypto.publicKey.rsa.webSign('SHA-256', message, n, e, d, p, q, u, hashed);
-    } catch (error) {
-      openpgp.util.print_debug_error('web crypto error');
-      this.skip();
-    }
-    const signatureBN = await openpgp.crypto.publicKey.rsa.bnSign(hash_algo, n, d, hashed);
-    expect(openpgp.util.Uint8Array_to_hex(signatureWeb)).to.be.equal(openpgp.util.Uint8Array_to_hex(signatureBN));
-  });
-
-  it('compare webCrypto and bn math verify', async function() {
-    if (!openpgp.util.getWebCrypto()) {
-      this.skip();
-    }
-    const bits = openpgp.util.getWebCrypto() ? 2048 : 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const message = await openpgp.crypto.random.getRandomBytes(64);
-    const hashName = 'sha256';
-    const hash_algo = openpgp.enums.write(openpgp.enums.hash, hashName);
-    const hashed = await openpgp.crypto.hash.digest(hash_algo, message);
-    let verifyWeb;
-    let signature;
-    try {
-      signature = await openpgp.crypto.publicKey.rsa.webSign('SHA-256', message, n, e, d, p, q, u, hashed);
-      verifyWeb = await openpgp.crypto.publicKey.rsa.webVerify('SHA-256', message, signature, n, e);
-    } catch (error) {
-      openpgp.util.print_debug_error('web crypto error');
-      this.skip();
-    }
-    const verifyBN = await openpgp.crypto.publicKey.rsa.bnVerify(hash_algo, signature, n, e, hashed);
-    expect(verifyWeb).to.be.true;
-    expect(verifyBN).to.be.true;
-  });
-
-  it('compare nodeCrypto and bn math sign', async function() {
-    if (!openpgp.util.getNodeCrypto()) {
-      this.skip();
-    }
-    const bits = 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const message = await openpgp.crypto.random.getRandomBytes(64);
-    const hashName = 'sha256';
-    const hash_algo = openpgp.enums.write(openpgp.enums.hash, hashName);
-    const hashed = await openpgp.crypto.hash.digest(hash_algo, message);
-    const signatureNode = await openpgp.crypto.publicKey.rsa.nodeSign(hash_algo, message, n, e, d, p, q, u);
-    const signatureBN = await openpgp.crypto.publicKey.rsa.bnSign(hash_algo, n, d, hashed);
-    expect(openpgp.util.Uint8Array_to_hex(signatureNode)).to.be.equal(openpgp.util.Uint8Array_to_hex(signatureBN));
-  });
-
-  it('compare nodeCrypto and bn math verify', async function() {
-    if (!openpgp.util.getNodeCrypto()) {
-      this.skip();
-    }
-    const bits = openpgp.util.getWebCrypto() ? 2048 : 1024;
-    const keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, bits);
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const message = await openpgp.crypto.random.getRandomBytes(64);
-    const hashName = 'sha256';
-    const hash_algo = openpgp.enums.write(openpgp.enums.hash, hashName);
-    const hashed = await openpgp.crypto.hash.digest(hash_algo, message);
-    const signatureNode = await openpgp.crypto.publicKey.rsa.nodeSign(hash_algo, message, n, e, d, p, q, u);
-    const verifyNode = await openpgp.crypto.publicKey.rsa.nodeVerify(hash_algo, message, signatureNode, n, e);
-    const verifyBN = await openpgp.crypto.publicKey.rsa.bnVerify(hash_algo, signatureNode, n, e, hashed);
-    expect(verifyNode).to.be.true;
-    expect(verifyBN).to.be.true;
-  });
-});

package/test/crypto/validate.js

@@ -1,387 +0,0 @@
-const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../dist/openpgp');
-const chai = require('chai');
-const BN = require('bn.js');
-
-chai.use(require('chai-as-promised'));
-
-const expect = chai.expect;
-const armoredDSAKey = `-----BEGIN PGP PRIVATE KEY BLOCK-----
-
-lQNTBF69PO8RCACHP4KLQcYOPGsGV9owTZvxnvHvvrY8W0v8xDUL3y6CLc05srF1
-kQp/81iUfP5g57BEiDpJV95kMh+ulBthIOGnuMCkodJjuBICB4K6BtFTV4Fw1Q5S
-S7aLC9beCaMvvGHXsK6MbknYl+IVJY7Zmml1qUSrBIQFGp5kqdhIX4o+OrzZ1zYj
-ALicqzD7Zx2VRjGNQv7UKv4CkBOC8ncdnq/4/OQeOYFzVbCOf+sJhTgz6yxjHJVC
-fLk7w8l2v1zV11VJuc8cQiQ9g8tjbKgLMsbyzy7gl4m9MSCdinG36XZuPibZrSm0
-H8gKAdd1FT84a3/qU2rtLLR0y8tCxBj89Xx/AQCv7CDmwoU+/yGpBVVl1mh0ZUkA
-/VJUhnJfv5MIOIi3AQf8CS9HrEmYJg/A3z0DcvcwIu/9gqpRLTqH1iT5o4BCg2j+
-Cog2ExYkQl1OEPkEQ1lKJSnD8MDwO3BlkJ4cD0VSKxlnwd9dsu9m2+F8T+K1hoA7
-PfH89TjD5HrEaGAYIdivLYSwoTNOO+fY8FoVC0RR9pFNOmjiTU5PZZedOxAql5Os
-Hp2bYhky0G9trjo8Mt6CGhvgA3dAKyONftLQr9HSM0GKacFV+nRd9TGCPNZidKU8
-MDa/SB/08y1bBGX5FK5wwiZ6H5qD8VAUobH3kwKlrg0nL00/EqtYHJqvJ2gkT5/v
-h8+z4R4TuYiy4kKF2FLPd5OjdA31IVDoVgCwF0WHLgf/X9AiTr/DPs/5dIYN1+hf
-UJwqjzr3dlokRwx3CVDcOVsdkWRwb8cvxubbsIorvUrF02IhYjHJMjIHT/zFt2zA
-+VPzO4zabUlawWVepPEwrCtXgvn9aXqjhAYbilG3UZamhfstGUmbmvWVDadALwby
-EO8u2pfLhI2lep63V/+KtUOLhfk8jKRSvxvxlYAvMi7sK8kB+lYy17XKN+IMYgf8
-gMFV6XGKpdmMSV3jOvat8cI6vnRO0i+g3jANP3PfrFEivat/rVgxo67r4rxezfFn
-J29qwB9rgbRgMBGsbDvIlQNV/NWFvHy2uQAEKn5eX4CoLsCZoR2VfK3BwBCxhYDp
-/wAA/0GSmI9MlMnLadFNlcX2Bm4i15quZAGF8JxwHbj1dhdUEYq0E1Rlc3QgPHRl
-c3RAdGVzdC5pbz6IlAQTEQgAPBYhBAq6lCI5EfrbHP1qZCxnOy/rlEGVBQJevTzv
-AhsDBQsJCAcCAyICAQYVCgkICwIEFgIDAQIeBwIXgAAKCRAsZzsv65RBlUPoAP9Q
-aTCWpHWZkvZzC8VU64O76fHp31rLWlcZFttuDNLyeAEAhOxkQHk6GR88R+EF5mrn
-clr63t9Q4wreqOlO0NR5/9k=
-=UW2O
------END PGP PRIVATE KEY BLOCK-----
-`;
-
-const armoredElGamalKey = `-----BEGIN PGP PRIVATE KEY BLOCK-----
-
-lQM2BF7H/4ARCADCP4YLpUkRgnU/GJ3lbOUyA7yGLus0XkS7/bpbFsd/myTr4ZkD
-hhZjSOpxP2DuuFpBVbZwmCKKe9RSo13pUuFfXzspMHiyThCLWZCRZrfrxD/QZzi9
-X3fYlSJ0FJsdgI1mzVhKS5zNAufSOnBPAY21OJpmMKaCSy/p4FcbARXeuYsEuWeJ
-2JVfNqB3eAlVrcG8CqROvvVNpryaxmwB9QZnVM2H+e1nFaU/qcZNu2wQtfGIwmvR
-Bw94okvNvFPQht2IGI5JLhsCppr2XcSrmDzmJbOpfvS9kyy67Lw7/FhyNmplTomL
-f6ep+tk6dlLaFxXQv2zPCzmCb28LHo2KDJDLAQC86pc1bkq/n2wycc98hOH8ejGQ
-xzyVHWfmi0YsyVgogwf/U1BIp01tmmEv15dHN0aMITRBhysMPVw1JaWRsbRlwaXy
-hSkfrHSEKjRKz5peskLCT8PpDhEcy2sbbQNUZJYQ8G+qDC+F3/Uj+COh1tM4skqx
-7u8c5JT4cIoTZ8D8OI1xPs2NdMimesXv0bv8M3hbTjbMvrjXAeockUcOXLwDgFmY
-QhBvlo8CO6Is+AfQGK5Qp6c6A+Mi9deaufpQ1uI+cIW2LWuYtepSTHexJhxQ8sjp
-AJRiUSQlm9Gv+LKFkFAOhgOqsQcUImVivXCg1/rJVEvbzMRgPV+RwK4EFTk9qCi1
-D+5IiKJ3SGhb6Q0r/pdIv77xMm9cq2grG8BmM742Awf/RG0g9K3iDDL5B/M3gTAa
-HrNrqGJ/yGC7XTGoldzy+AoNxg4gNp0DGBmUxMxRaCYXJit7qPAsbqGRGOIFkAM+
-muMbqY8GlV5RmSlIRF4ctPVtfrTF6KYrkgFC3ChlWdaqrmTAfaXlwp58oZb834jv
-2fZ5BTty3ItFpzGm+jE2rESEbXEBphHzbY+V9Vm5VvFJdHM2tsZyHle9wOLr0sDd
-g6iO/TFU+chnob/Bg4PwtCnUAt0XHRZG8ZyBn/sBCU5JnpakTfKY6m45fQ0DV4BD
-bZDhcSX8f/8IqxJIm6Pml4Bu5gRi4Qrjii0jO8W7dPO3Plj/DkG0FX+uO1XpgYbT
-fP8AZQBHTlUBtBFCb2IgPGJvYkBib2IuY29tPoiUBBMRCAA8FiEE54DAVxxoTRoG
-9WYwfIV1VPa5rzAFAl7H/4ACGwMFCwkIBwIDIgIBBhUKCQgLAgQWAgMBAh4HAheA
-AAoJEHyFdVT2ua8w1cIA/RZDTn/OMlwXQ5/ezDUPl0AWAbUFkaUVNz3mmuCT7mEp
-APsHguiDpPEa6j/ps7C4xT4FIjhfje0wbYyzJ7r5YEYJW50CPQRex/+AEAgA+B3A
-PZgASX5raXdA+GXYljqAB12mmYDb0kDJe1zwpJtqGiO9Q+ze3fju3OIpn7SJIqmA
-nCCvmuuEsKzdA7ulw9idsPRYudwuaJK57jpLvZMTyXPt+3RYgBO4VBRzZuzti2rl
-HAiHh7mxip7q45r6tJW8fOqimlbEF0RYwb1Ux7bJdAJm3uDbq0HlPZaYwM2jTR5Z
-PNtW7NG89KhF4CiXTqxQO6jEha+lnZfFFMkKZsBrm++rESQ7zzsYLne180LJhHmr
-I2PTc8KtUR/u8u9Goz8KqgtE2IUKWKAmZnwV9/6tN0zJmW896CLY3v45SU9o2Pxz
-xCEuy097noPo5OTPWwADBggAul4tTya9RqRylzBFJTVrAvWXaOWHDpV2wfjwwiAw
-oYiLXPD0bJ4EOWKosRCKVWI6mBQ7Qda/2rNHGMahG6nEpe1/rsc7fprdynnEk08K
-GwWHvG1+gKJygl6PJpifKwkh6oIzqmXl0Xm+oohmGfbQRlMwbIc6BbZAyPNXmFEa
-cLX45qzLtheFRUcrFpS+MH8wzDxEHMsPPJox0l6/v09OWZwAtdidlTvAqfL7FNAK
-lZmoRfZt4JQzpYzKMa6ilC5pa413TbLfGmMZPTlOG6iQOPCycqtowX21U7JwqUDW
-70nuyUyrcVPAfve7yAsgrR2/g0jvoOp/tIJHz0HR1XuRAgABVArINvTyU1hn8d8m
-ucKUFmD6xfz5K1cxl6/jddz8aTsDvxj4t44uPXJpsKEX/4h4BBgRCAAgFiEE54DA
-VxxoTRoG9WYwfIV1VPa5rzAFAl7H/4ACGwwACgkQfIV1VPa5rzCzxAD9Ekc0rmvS
-O/oyRu0zeX+qySgJyNtOJ2rJ3V52VrwSPUAA/26s21WNs8M6Ryse7sEYcqAmk5QQ
-vqBGKJzmO5q3cECw
-=X9kJ
------END PGP PRIVATE KEY BLOCK-----`;
-
-describe('EdDSA parameter validation', function() {
-  let keyParams;
-  before(async () => {
-    keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.eddsa, null, 'ed25519');
-  });
-
-  it('EdDSA params should be valid', async function() {
-    const { oid, Q, seed } = openpgp.crypto.publicKey.elliptic.eddsa.parseParams(keyParams);
-    const valid = await openpgp.crypto.publicKey.elliptic.eddsa.validateParams(oid, Q, seed);
-    expect(valid).to.be.true;
-  });
-
-  it('detect invalid edDSA Q', async function() {
-    const { oid, Q, seed } = openpgp.crypto.publicKey.elliptic.eddsa.parseParams(keyParams);
-
-
-    Q[0]++;
-    let valid = await openpgp.crypto.publicKey.elliptic.eddsa.validateParams(oid, Q, seed);
-    expect(valid).to.be.false;
-
-    const infQ = new Uint8Array(Q.length);
-    valid = await openpgp.crypto.publicKey.elliptic.ecdh.validateParams(oid, infQ, seed);
-    expect(valid).to.be.false;
-  });
-});
-
-describe('ECC curve validation', function() {
-  it('EdDSA params are not valid for ECDH', async function() {
-    const keyParams = await openpgp.crypto.generateParams(
-      openpgp.enums.publicKey.eddsa,
-      null,
-      'ed25519'
-    );
-    const { oid, Q, seed } = openpgp.crypto.publicKey.elliptic.eddsa.parseParams(keyParams);
-    const valid = await openpgp.crypto.publicKey.elliptic.ecdsa.validateParams(oid, Q, seed);
-    expect(valid).to.be.false;
-  });
-
-  it('EdDSA params are not valid for EcDSA', async function() {
-    const keyParams = await openpgp.crypto.generateParams(
-      openpgp.enums.publicKey.eddsa,
-      null,
-      'ed25519'
-    );
-    const { oid, Q, seed } = openpgp.crypto.publicKey.elliptic.eddsa.parseParams(keyParams);
-    const valid = await openpgp.crypto.publicKey.elliptic.ecdsa.validateParams(oid, Q, seed);
-    expect(valid).to.be.false;
-  });
-
-  it('x25519 params are not valid for EcDSA', async function() {
-    const keyParams = await openpgp.crypto.generateParams(
-      openpgp.enums.publicKey.ecdsa,
-      null,
-      'curve25519'
-    );
-    const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-    const valid = await openpgp.crypto.publicKey.elliptic.ecdsa.validateParams(oid, Q, d);
-    expect(valid).to.be.false;
-  });
-
-  it('EcDSA params are not valid for EdDSA', async function() {
-    const keyParams = await openpgp.crypto.generateParams(
-      openpgp.enums.publicKey.ecdsa, null, 'p256'
-    );
-    const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-    const valid = await openpgp.crypto.publicKey.elliptic.eddsa.validateParams(oid, Q, d);
-    expect(valid).to.be.false;
-  });
-
-  it('x25519 params are not valid for EdDSA', async function() {
-    const keyParams = await openpgp.crypto.generateParams(
-      openpgp.enums.publicKey.ecdsa, null, 'curve25519'
-    );
-    const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-    const valid = await openpgp.crypto.publicKey.elliptic.eddsa.validateParams(oid, Q, d);
-    expect(valid).to.be.false;
-  });
-});
-
-
-const curves = ['curve25519', 'p256', 'p384', 'p521', 'secp256k1', 'brainpoolP256r1', 'brainpoolP384r1', 'brainpoolP512r1'];
-curves.forEach(curve => {
-  describe(`ECC ${curve} parameter validation`, () => {
-    let keyParams;
-    before(async () => {
-      // we generate also ecdh params as ecdsa ones since we do not need the kdf params
-      keyParams = await openpgp.crypto.generateParams(
-        openpgp.enums.publicKey.ecdsa, null, curve
-      );
-    });
-
-    if (curve !== 'curve25519') {
-      it(`EcDSA ${curve} params should be valid`, async function() {
-        const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-        const valid = await openpgp.crypto.publicKey.elliptic.ecdsa.validateParams(oid, Q, d);
-        expect(valid).to.be.true;
-      });
-
-      it('detect invalid EcDSA Q', async function() {
-        const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-
-        Q[16]++;
-        let valid = await openpgp.crypto.publicKey.elliptic.ecdsa.validateParams(oid, Q, d);
-        expect(valid).to.be.false;
-
-        const infQ = new Uint8Array(Q.length);
-        valid = await openpgp.crypto.publicKey.elliptic.ecdsa.validateParams(oid, infQ, d);
-        expect(valid).to.be.false;
-      });
-    }
-
-    it(`ECDH ${curve} params should be valid`, async function() {
-      const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-      const valid = await openpgp.crypto.publicKey.elliptic.ecdh.validateParams(oid, Q, d);
-      expect(valid).to.be.true;
-    });
-
-    it('detect invalid ECDH Q', async function() {
-      const { oid, Q, d } = openpgp.crypto.publicKey.elliptic.ecdsa.parseParams(keyParams);
-
-      Q[16]++;
-      let valid = await openpgp.crypto.publicKey.elliptic.ecdh.validateParams(oid, Q, d);
-      expect(valid).to.be.false;
-
-      const infQ = new Uint8Array(Q.length);
-      valid = await openpgp.crypto.publicKey.elliptic.ecdh.validateParams(oid, infQ, d);
-      expect(valid).to.be.false;
-    });
-  });
-});
-
-describe('RSA parameter validation', function() {
-  let keyParams;
-  before(async () => {
-    keyParams = await openpgp.crypto.generateParams(openpgp.enums.publicKey.rsa_sign, 2048);
-  });
-
-  it('generated RSA params are valid', async function() {
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-    const valid = await openpgp.crypto.publicKey.rsa.validateParams(n, e, d, p, q, u);
-    expect(valid).to.be.true;
-  });
-
-  it('detect invalid RSA n', async function() {
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-
-    n[0]++;
-    const valid = await openpgp.crypto.publicKey.rsa.validateParams(n, e, d, p, q, u);
-    expect(valid).to.be.false;
-  });
-
-  it('detect invalid RSA e', async function() {
-    const n = keyParams[0].toUint8Array();
-    const e = keyParams[1].toUint8Array();
-    const d = keyParams[2].toUint8Array();
-    const p = keyParams[3].toUint8Array();
-    const q = keyParams[4].toUint8Array();
-    const u = keyParams[5].toUint8Array();
-
-    e[0]++;
-    const valid = await openpgp.crypto.publicKey.rsa.validateParams(n, e, d, p, q, u);
-    expect(valid).to.be.false;
-  });
-});
-
-describe('DSA parameter validation', function() {
-  let dsaKey;
-  before(async () => {
-    dsaKey = (await openpgp.key.readArmored(armoredDSAKey)).keys[0];
-  });
-
-  it('DSA params should be valid', async function() {
-    const params = dsaKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const q = params[1].toUint8Array();
-    const g = params[2].toUint8Array();
-    const y = params[3].toUint8Array();
-    const x = params[4].toUint8Array();
-    const valid = await openpgp.crypto.publicKey.dsa.validateParams(p, q, g, y, x);
-    expect(valid).to.be.true;
-  });
-
-  it('detect invalid DSA p', async function() {
-    const params = dsaKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const q = params[1].toUint8Array();
-    const g = params[2].toUint8Array();
-    const y = params[3].toUint8Array();
-    const x = params[4].toUint8Array();
-
-    p[0]++;
-    const valid = await openpgp.crypto.publicKey.dsa.validateParams(p, q, g, y, x);
-
-    expect(valid).to.be.false;
-  });
-
-  it('detect invalid DSA y', async function() {
-    const params = dsaKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const q = params[1].toUint8Array();
-    const g = params[2].toUint8Array();
-    const y = params[3].toUint8Array();
-    const x = params[4].toUint8Array();
-
-    y[0]++;
-    const valid = await openpgp.crypto.publicKey.dsa.validateParams(p, q, g, y, x);
-
-    expect(valid).to.be.false;
-  });
-
-  it('detect invalid DSA g', async function() {
-    const params = dsaKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const q = params[1].toUint8Array();
-    const g = params[2].toUint8Array();
-    const y = params[3].toUint8Array();
-    const x = params[4].toUint8Array();
-
-    g[0]++;
-    let valid = await openpgp.crypto.publicKey.dsa.validateParams(p, q, g, y, x);
-    expect(valid).to.be.false;
-
-    const gOne = new Uint8Array([1]);
-    valid = await openpgp.crypto.publicKey.dsa.validateParams(p, q, gOne, y, x);
-    expect(valid).to.be.false;
-  });
-});
-
-describe('ElGamal parameter validation', function() {
-  let egKey;
-  before(async () => {
-    egKey = (await openpgp.key.readArmored(armoredElGamalKey)).keys[0].subKeys[0];
-  });
-
-  it('params should be valid', async function() {
-    const params = egKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const g = params[1].toUint8Array();
-    const y = params[2].toUint8Array();
-    const x = params[3].toUint8Array();
-
-    const valid = await openpgp.crypto.publicKey.elgamal.validateParams(p, g, y, x);
-    expect(valid).to.be.true;
-  });
-
-  it('detect invalid p', async function() {
-    const params = egKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const g = params[1].toUint8Array();
-    const y = params[2].toUint8Array();
-    const x = params[3].toUint8Array();
-    p[0]++;
-    const valid = await openpgp.crypto.publicKey.elgamal.validateParams(p, g, y, x);
-
-    expect(valid).to.be.false;
-  });
-
-  it('detect invalid y', async function() {
-    const params = egKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const g = params[1].toUint8Array();
-    const y = params[2].toUint8Array();
-    const x = params[3].toUint8Array();
-
-    y[0]++;
-    const valid = await openpgp.crypto.publicKey.elgamal.validateParams(p, g, y, x);
-
-    expect(valid).to.be.false;
-  });
-
-  it('detect invalid g', async function() {
-    const params = egKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const g = params[1].toUint8Array();
-    const y = params[2].toUint8Array();
-    const x = params[3].toUint8Array();
-
-    g[0]++;
-    let valid = await openpgp.crypto.publicKey.elgamal.validateParams(p, g, y, x);
-    expect(valid).to.be.false;
-
-    const gOne = new Uint8Array([1]);
-    valid = await openpgp.crypto.publicKey.elgamal.validateParams(p, gOne, y, x);
-    expect(valid).to.be.false;
-  });
-
-  it('detect g with small order', async function() {
-    const params = egKey.keyPacket.params;
-    const p = params[0].toUint8Array();
-    const g = params[1].toUint8Array();
-    const y = params[2].toUint8Array();
-    const x = params[3].toUint8Array();
-
-    const pBN = new BN(p);
-    const gModP = new BN(g).toRed(new BN.red(pBN));
-    // g**(p-1)/2 has order 2
-    const gOrd2 = gModP.redPow(pBN.subn(1).shrn(1));
-    const valid = await openpgp.crypto.publicKey.elgamal.validateParams(p, gOrd2.toArrayLike(Uint8Array, 'be'), y, x);
-    expect(valid).to.be.false;
-  });
-});