@protontech/openpgp 4.10.6 → 5.4.0

package/test/crypto/eax.js

@@ -1,150 +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;
-
-function testAESEAX() {
-  it('Passes all test vectors', async function() {
-    const vectors = [
-      // From http://www.cs.ucdavis.edu/~rogaway/papers/eax.pdf ...
-      {
-        msg: "",
-        key: "233952DEE4D5ED5F9B9C6D6FF80FF478",
-        nonce: "62EC67F9C3A4A407FCB2A8C49031A8B3",
-        header: "6BFB914FD07EAE6B",
-        ct: "E037830E8389F27B025A2D6527E79D01"
-      },
-      {
-        msg: "F7FB",
-        key: "91945D3F4DCBEE0BF45EF52255F095A4",
-        nonce: "BECAF043B0A23D843194BA972C66DEBD",
-        header: "FA3BFD4806EB53FA",
-        ct: "19DD5C4C9331049D0BDAB0277408F67967E5"
-      },
-      {
-        msg: "1A47CB4933",
-        key: "01F74AD64077F2E704C0F60ADA3DD523",
-        nonce: "70C3DB4F0D26368400A10ED05D2BFF5E",
-        header: "234A3463C1264AC6",
-        ct: "D851D5BAE03A59F238A23E39199DC9266626C40F80"
-      },
-      {
-        msg: "481C9E39B1",
-        key: "D07CF6CBB7F313BDDE66B727AFD3C5E8",
-        nonce: "8408DFFF3C1A2B1292DC199E46B7D617",
-        header: "33CCE2EABFF5A79D",
-        ct: "632A9D131AD4C168A4225D8E1FF755939974A7BEDE"
-      },
-      {
-        msg: "40D0C07DA5E4",
-        key: "35B6D0580005BBC12B0587124557D2C2",
-        nonce: "FDB6B06676EEDC5C61D74276E1F8E816",
-        header: "AEB96EAEBE2970E9",
-        ct: "071DFE16C675CB0677E536F73AFE6A14B74EE49844DD"
-      },
-      {
-        msg: "4DE3B35C3FC039245BD1FB7D",
-        key: "BD8E6E11475E60B268784C38C62FEB22",
-        nonce: "6EAC5C93072D8E8513F750935E46DA1B",
-        header: "D4482D1CA78DCE0F",
-        ct: "835BB4F15D743E350E728414ABB8644FD6CCB86947C5E10590210A4F"
-      },
-      {
-        msg: "8B0A79306C9CE7ED99DAE4F87F8DD61636",
-        key: "7C77D6E813BED5AC98BAA417477A2E7D",
-        nonce: "1A8C98DCD73D38393B2BF1569DEEFC19",
-        header: "65D2017990D62528",
-        ct: "02083E3979DA014812F59F11D52630DA30137327D10649B0AA6E1C181DB617D7F2"
-      },
-      {
-        msg: "1BDA122BCE8A8DBAF1877D962B8592DD2D56",
-        key: "5FFF20CAFAB119CA2FC73549E20F5B0D",
-        nonce: "DDE59B97D722156D4D9AFF2BC7559826",
-        header: "54B9F04E6A09189A",
-        ct: "2EC47B2C4954A489AFC7BA4897EDCDAE8CC33B60450599BD02C96382902AEF7F832A"
-      },
-      {
-        msg: "6CF36720872B8513F6EAB1A8A44438D5EF11",
-        key: "A4A4782BCFFD3EC5E7EF6D8C34A56123",
-        nonce: "B781FCF2F75FA5A8DE97A9CA48E522EC",
-        header: "899A175897561D7E",
-        ct: "0DE18FD0FDD91E7AF19F1D8EE8733938B1E8E7F6D2231618102FDB7FE55FF1991700"
-      },
-      {
-        msg: "CA40D7446E545FFAED3BD12A740A659FFBBB3CEAB7",
-        key: "8395FCF1E95BEBD697BD010BC766AAC3",
-        nonce: "22E7ADD93CFC6393C57EC0B3C17D6B44",
-        header: "126735FCC320D25A",
-        ct: "CB8920F87A6C75CFF39627B56E3ED197C552D295A7CFC46AFC253B4652B1AF3795B124AB6E"
-      }
-    ];
-
-    const cipher = 'aes128';
-
-    await Promise.all(vectors.map(async vec => {
-      const keyBytes = openpgp.util.hex_to_Uint8Array(vec.key);
-      const msgBytes = openpgp.util.hex_to_Uint8Array(vec.msg);
-      const nonceBytes = openpgp.util.hex_to_Uint8Array(vec.nonce);
-      const headerBytes = openpgp.util.hex_to_Uint8Array(vec.header);
-      const ctBytes = openpgp.util.hex_to_Uint8Array(vec.ct);
-
-      const eax = await openpgp.crypto.eax(cipher, keyBytes);
-
-      // encryption test
-      let ct = await eax.encrypt(msgBytes, nonceBytes, headerBytes);
-      expect(openpgp.util.Uint8Array_to_hex(ct)).to.equal(vec.ct.toLowerCase());
-
-      // decryption test with verification
-      let pt = await eax.decrypt(ctBytes, nonceBytes, headerBytes);
-      expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.msg.toLowerCase());
-
-      // tampering detection test
-      ct = await eax.encrypt(msgBytes, nonceBytes, headerBytes);
-      ct[2] ^= 8;
-      pt = eax.decrypt(ct, nonceBytes, headerBytes);
-      await expect(pt).to.eventually.be.rejectedWith('Authentication tag mismatch');
-
-      // testing without additional data
-      ct = await eax.encrypt(msgBytes, nonceBytes, new Uint8Array());
-      pt = await eax.decrypt(ct, nonceBytes, new Uint8Array());
-      expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.msg.toLowerCase());
-
-      // testing with multiple additional data
-      ct = await eax.encrypt(msgBytes, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
-      pt = await eax.decrypt(ct, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
-      expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.msg.toLowerCase());
-    }));
-  });
-}
-
-describe('Symmetric AES-EAX (native)', function() {
-  let use_nativeVal;
-  beforeEach(function() {
-    use_nativeVal = openpgp.config.use_native;
-    openpgp.config.use_native = true;
-  });
-  afterEach(function() {
-    openpgp.config.use_native = use_nativeVal;
-  });
-
-  testAESEAX();
-});
-
-describe('Symmetric AES-EAX (asm.js fallback)', function() {
-  let use_nativeVal;
-  beforeEach(function() {
-    use_nativeVal = openpgp.config.use_native;
-    openpgp.config.use_native = false;
-  });
-  afterEach(function() {
-    openpgp.config.use_native = use_nativeVal;
-  });
-
-  testAESEAX();
-});

package/test/crypto/ecdh.js

@@ -1,359 +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('ECDH key exchange @lightweight', function () {
-  const elliptic_curves = openpgp.crypto.publicKey.elliptic;
-  const decrypt_message = function (oid, hash, cipher, priv, pub, ephemeral, data, fingerprint) {
-    if (openpgp.util.isString(data)) {
-      data = openpgp.util.str_to_Uint8Array(data);
-    } else {
-      data = new Uint8Array(data);
-    }
-    return Promise.resolve().then(() => {
-      const curve = new elliptic_curves.Curve(oid);
-      return elliptic_curves.ecdh.decrypt(
-        new openpgp.OID(curve.oid),
-        new openpgp.KDFParams({ cipher, hash }),
-        new Uint8Array(ephemeral),
-        data,
-        new Uint8Array(pub),
-        new Uint8Array(priv),
-        new Uint8Array(fingerprint)
-      );
-    });
-  };
-  const secp256k1_value = new Uint8Array([
-    0x10, 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_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_data = new Uint8Array([
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-  ]);
-
-  it('Invalid curve oid', function (done) {
-    expect(decrypt_message(
-      '', 2, 7, [], [], [], [], []
-    )).to.be.rejectedWith(Error, /Not valid curve/).notify(done);
-  });
-  it('Invalid ephemeral key', function (done) {
-    if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-      this.skip();
-    }
-    expect(decrypt_message(
-      'secp256k1', 2, 7, [], [], [], [], []
-    )).to.be.rejectedWith(Error, /Private key is not valid for specified curve|Unknown point format/).notify(done);
-  });
-  it('Invalid elliptic public key', function (done) {
-    if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-      this.skip();
-    }
-    expect(decrypt_message(
-      'secp256k1', 2, 7, secp256k1_value, secp256k1_point, secp256k1_invalid_point, secp256k1_data, []
-    )).to.be.rejectedWith(Error, /Public key is not valid for specified curve|Failed to translate Buffer to a EC_POINT|Invalid elliptic public key/).notify(done);
-  });
-  it('Invalid key data integrity', function (done) {
-    if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-      this.skip();
-    }
-    expect(decrypt_message(
-      'secp256k1', 2, 7, secp256k1_value, secp256k1_point, secp256k1_point, secp256k1_data, []
-    )).to.be.rejectedWith(Error, /Key Data Integrity failed/).notify(done);
-  });
-
-  const Q1 = new Uint8Array([
-    64,
-    48, 226, 162, 114, 194, 194, 67, 214,
-    199, 10, 173, 22, 216, 240, 197, 202,
-    114, 49, 127, 107, 152, 58, 119, 48,
-    234, 194, 192, 66, 53, 165, 137, 93
-  ]);
-  const d1 = new Uint8Array([
-    65, 200, 132, 198, 77, 86, 126, 196,
-    247, 169, 156, 201, 32, 52, 3, 198,
-    127, 144, 139, 47, 153, 239, 64, 235,
-    61, 7, 17, 214, 64, 211, 215, 80
-  ]);
-  const Q2 = new Uint8Array([
-    64,
-    154, 115, 36, 108, 33, 153, 64, 184,
-    25, 139, 67, 25, 178, 194, 227, 53,
-    254, 40, 101, 213, 28, 121, 154, 62,
-    27, 99, 92, 126, 33, 223, 122, 91
-  ]);
-  const d2 = new Uint8Array([
-    123, 99, 163, 24, 201, 87, 0, 9,
-    204, 21, 154, 5, 5, 5, 127, 157,
-    237, 95, 76, 117, 89, 250, 64, 178,
-    72, 69, 69, 58, 89, 228, 113, 112
-  ]);
-  const fingerprint1 = new Uint8Array([
-    177, 183,
-    116, 123, 76, 133, 245, 212, 151, 243, 236,
-    71, 245, 86, 3, 168, 101, 74, 209, 105
-  ]);
-  const fingerprint2 = new Uint8Array([
-    177, 83,
-    123, 123, 76, 133, 245, 212, 151, 243, 236,
-    71, 245, 86, 3, 168, 101, 74, 209, 105
-  ]);
-  async function genPublicEphemeralKey(curve, Q, fingerprint) {
-    const curveObj = new openpgp.crypto.publicKey.elliptic.Curve(curve);
-    const oid = new openpgp.OID(curveObj.oid);
-    const { publicKey: V, sharedKey } = await openpgp.crypto.publicKey.elliptic.ecdh.genPublicEphemeralKey(
-      curveObj, Q
-    );
-    let cipher_algo = curveObj.cipher;
-    const hash_algo = curveObj.hash;
-    const kdfParams = new openpgp.KDFParams({ cipher: cipher_algo, hash: hash_algo });
-    const param = openpgp.crypto.publicKey.elliptic.ecdh.buildEcdhParam(
-      openpgp.enums.publicKey.ecdh, oid, kdfParams, fingerprint
-    );
-    cipher_algo = openpgp.enums.read(openpgp.enums.symmetric, cipher_algo);
-    const Z = await openpgp.crypto.publicKey.elliptic.ecdh.kdf(
-      hash_algo, sharedKey, openpgp.crypto.cipher[cipher_algo].keySize, param, curveObj, false
-    );
-    return { V, Z };
-  }
-
-  async function genPrivateEphemeralKey(curve, V, Q, d, fingerprint) {
-    const curveObj = new openpgp.crypto.publicKey.elliptic.Curve(curve);
-    const oid = new openpgp.OID(curveObj.oid);
-    const { sharedKey } = await openpgp.crypto.publicKey.elliptic.ecdh.genPrivateEphemeralKey(
-      curveObj, V, Q, d
-    );
-    let cipher_algo = curveObj.cipher;
-    const hash_algo = curveObj.hash;
-    const kdfParams = new openpgp.KDFParams({ cipher: cipher_algo, hash: hash_algo });
-    const param = openpgp.crypto.publicKey.elliptic.ecdh.buildEcdhParam(
-      openpgp.enums.publicKey.ecdh, oid, kdfParams, fingerprint
-    );
-    cipher_algo = openpgp.enums.read(openpgp.enums.symmetric, cipher_algo);
-    const Z = await openpgp.crypto.publicKey.elliptic.ecdh.kdf(
-      hash_algo, sharedKey, openpgp.crypto.cipher[cipher_algo].keySize, param, curveObj, false
-    );
-    return Z;
-  }
-
-  async function genPrivateEphemeralKeySpecific(fun, curve, V, Q, d, fingerprint) {
-    const curveObj = new openpgp.crypto.publicKey.elliptic.Curve(curve);
-    const oid = new openpgp.OID(curveObj.oid);
-    let result;
-    switch (fun) {
-      case 'webPrivateEphemeralKey': {
-        result = await openpgp.crypto.publicKey.elliptic.ecdh[fun](
-          curveObj, V, Q, d
-        );
-        break;
-      }
-      case 'nodePrivateEphemeralKey':
-      case 'ellipticPrivateEphemeralKey': {
-        result = await openpgp.crypto.publicKey.elliptic.ecdh[fun](
-          curveObj, V, d
-        );
-        break;
-      }
-    }
-    const sharedKey = result.sharedKey;
-    let cipher_algo = curveObj.cipher;
-    const hash_algo = curveObj.hash;
-    const kdfParams = new openpgp.KDFParams({ cipher: cipher_algo, hash: hash_algo });
-    const param = openpgp.crypto.publicKey.elliptic.ecdh.buildEcdhParam(
-      openpgp.enums.publicKey.ecdh, oid, kdfParams, fingerprint
-    );
-    cipher_algo = openpgp.enums.read(openpgp.enums.symmetric, cipher_algo);
-    const Z = await openpgp.crypto.publicKey.elliptic.ecdh.kdf(
-      hash_algo, sharedKey, openpgp.crypto.cipher[cipher_algo].keySize, param, curveObj, false
-    );
-    return Z;
-  }
-
-  describe('ECDHE key generation', function () {
-    it('Invalid curve', function (done) {
-      if (!openpgp.config.use_indutny_elliptic && !openpgp.util.getNodeCrypto()) {
-        this.skip();
-      }
-      expect(genPublicEphemeralKey("secp256k1", Q1, fingerprint1)
-      ).to.be.rejectedWith(Error, /Public key is not valid for specified curve|Failed to translate Buffer to a EC_POINT|Unknown point format/).notify(done);
-    });
-    it('Invalid public part of ephemeral key and private key', async function () {
-      const ECDHE_VZ1 = await genPublicEphemeralKey("curve25519", Q1, fingerprint1);
-      const ECDHE_Z12 = await genPrivateEphemeralKey("curve25519", ECDHE_VZ1.V, Q2, d2, fingerprint1);
-      expect(Array.from(ECDHE_Z12).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.false;
-    });
-    it('Invalid fingerprint', async function () {
-      const ECDHE_VZ2 = await genPublicEphemeralKey("curve25519", Q2, fingerprint1);
-      const ECDHE_Z2 = await genPrivateEphemeralKey("curve25519", ECDHE_VZ2.V, Q2, d2, fingerprint2);
-      expect(Array.from(ECDHE_Z2).join(' ') === Array.from(ECDHE_VZ2.Z).join(' ')).to.be.false;
-    });
-    it('Different keys', async function () {
-      const ECDHE_VZ1 = await genPublicEphemeralKey("curve25519", Q1, fingerprint1);
-      const ECDHE_VZ2 = await genPublicEphemeralKey("curve25519", Q2, fingerprint1);
-      const ECDHE_Z1 = await genPrivateEphemeralKey("curve25519", ECDHE_VZ1.V, Q1, d1, fingerprint1);
-      expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ2.Z).join(' ')).to.be.false;
-    });
-    it('Successful exchange curve25519', async function () {
-      const ECDHE_VZ1 = await genPublicEphemeralKey("curve25519", Q1, fingerprint1);
-      const ECDHE_Z1 = await genPrivateEphemeralKey("curve25519", ECDHE_VZ1.V, Q1, d1, fingerprint1);
-      expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.true;
-    });
-    it('Successful exchange NIST P256', async function () {
-      const ECDHE_VZ1 = await genPublicEphemeralKey("p256", key_data.p256.pub, fingerprint1);
-      const ECDHE_Z1 = await genPrivateEphemeralKey("p256", ECDHE_VZ1.V, key_data.p256.pub, key_data.p256.priv, fingerprint1);
-      expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.true;
-    });
-    it('Successful exchange NIST P384', async function () {
-      const ECDHE_VZ1 = await genPublicEphemeralKey("p384", key_data.p384.pub, fingerprint1);
-      const ECDHE_Z1 = await genPrivateEphemeralKey("p384", ECDHE_VZ1.V, key_data.p384.pub, key_data.p384.priv, fingerprint1);
-      expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.true;
-    });
-    it('Successful exchange NIST P521', async function () {
-      const ECDHE_VZ1 = await genPublicEphemeralKey("p521", key_data.p521.pub, fingerprint1);
-      const ECDHE_Z1 = await genPrivateEphemeralKey("p521", ECDHE_VZ1.V, key_data.p521.pub, key_data.p521.priv, fingerprint1);
-      expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.true;
-    });
-
-    it('Comparing keys derived using webCrypto and elliptic', async function () {
-      const names = ["p256", "p384", "p521"];
-      if (!openpgp.util.getWebCrypto() || !openpgp.config.use_indutny_elliptic) {
-        // eslint-disable-next-line no-invalid-this
-        this.skip();
-      }
-      return Promise.all(names.map(async function (name) {
-        const curve = new elliptic_curves.Curve(name);
-        try {
-          await window.crypto.subtle.generateKey({
-            name: "ECDSA",
-            namedCurve: curve.web.web
-          }, false, ["sign", "verify"]);
-        } catch (err) {
-          openpgp.util.print_debug_error(err);
-          return;
-        }
-        const ECDHE_VZ1 = await genPublicEphemeralKey(name, key_data[name].pub, fingerprint1);
-        const ECDHE_Z1 = await genPrivateEphemeralKeySpecific('ellipticPrivateEphemeralKey', name, ECDHE_VZ1.V, key_data[name].pub, key_data[name].priv, fingerprint1);
-        const ECDHE_Z2 = await genPrivateEphemeralKeySpecific('webPrivateEphemeralKey', name, ECDHE_VZ1.V, key_data[name].pub, key_data[name].priv, fingerprint1);
-        expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.true;
-        expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_Z2).join(' ')).to.be.true;
-      }));
-    });
-    it('Comparing keys derived using nodeCrypto and elliptic', async function () {
-      const names = ["p256", "p384", "p521"];
-      if (!openpgp.util.getNodeCrypto() || !openpgp.config.use_indutny_elliptic) {
-        // eslint-disable-next-line no-invalid-this
-        this.skip();
-      }
-      return Promise.all(names.map(async function (name) {
-        const ECDHE_VZ1 = await genPublicEphemeralKey(name, key_data[name].pub, fingerprint1);
-        const ECDHE_Z1 = await genPrivateEphemeralKeySpecific('ellipticPrivateEphemeralKey', name, ECDHE_VZ1.V, key_data[name].pub, key_data[name].priv, fingerprint1);
-        const ECDHE_Z2 = await genPrivateEphemeralKeySpecific('nodePrivateEphemeralKey', name, ECDHE_VZ1.V, key_data[name].pub, key_data[name].priv, fingerprint1);
-        expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_VZ1.Z).join(' ')).to.be.true;
-        expect(Array.from(ECDHE_Z1).join(' ') === Array.from(ECDHE_Z2).join(' ')).to.be.true;
-      }));
-    });
-  });
-});
-
-describe('KDF parameters', function () {
-  const fingerprint = new Uint8Array([
-    177, 183, 116, 123, 76, 133, 245, 212, 151, 243,
-    236, 71, 245, 86, 3, 168, 101, 74, 209, 105
-  ]);
-
-  it('Valid serialization', async function () {
-    const cipher = openpgp.enums.symmetric.aes256;
-    const hash = openpgp.enums.hash.sha256;
-
-    const v1 = new openpgp.KDFParams({ cipher, hash });
-    const v1Copy = new openpgp.KDFParams({});
-    v1Copy.read(v1.write());
-    expect(v1Copy).to.deep.equal(v1);
-
-    const v1Flags0x0 = new openpgp.KDFParams({
-      cipher,
-      hash,
-      flags: 0x0 // discarded
-    });
-    const v1Flags0x0Copy = new openpgp.KDFParams({});
-    v1Flags0x0Copy.read(v1Flags0x0.write());
-    v1Flags0x0.flags = undefined;
-    expect(v1Flags0x0Copy).to.deep.equal(v1Flags0x0);
-
-    const v2Flags0x3 = new openpgp.KDFParams({
-      cipher,
-      hash,
-      version: 2,
-      flags: 0x3,
-      replacementFingerprint: fingerprint,
-      replacementKDFParams: new Uint8Array([3, 1, cipher, hash])
-    });
-    const v2Flags0x3Copy = new openpgp.KDFParams();
-    v2Flags0x3Copy.read(v2Flags0x3.write());
-    expect(v2Flags0x3Copy).to.deep.equal(v2Flags0x3);
-
-    const v2Flags0x0 = new openpgp.KDFParams({
-      cipher,
-      hash,
-      version: 2,
-      flags: 0x0
-    });
-    const v2Flags0x0Copy = new openpgp.KDFParams({});
-    v2Flags0x0Copy.read(v2Flags0x0.write());
-
-    expect(v2Flags0x0Copy).to.deep.equal(v2Flags0x0);
-
-    const v2Flags0x1 = new openpgp.KDFParams({
-      cipher,
-      hash,
-      version: 2,
-      flags: 0x1,
-      replacementFingerprint: fingerprint
-    });
-    const v2Flags0x1Copy = new openpgp.KDFParams();
-    v2Flags0x1Copy.read(v2Flags0x1.write());
-    v2Flags0x1.replacementKDFParams = null;
-    expect(v2Flags0x1Copy).to.deep.equal(v2Flags0x1);
-
-    const v2Flags0x2 = new openpgp.KDFParams({
-      cipher,
-      hash,
-      version: 2,
-      flags: 0x2,
-      replacementKDFParams: new Uint8Array([3, 1, cipher, hash])
-    });
-    const v2Flags0x2Copy = new openpgp.KDFParams();
-    v2Flags0x2Copy.read(v2Flags0x2.write());
-    v2Flags0x2.replacementFingerprint = null;
-    expect(v2Flags0x2Copy).to.deep.equal(v2Flags0x2);
-  });
-});