Example usage for org.bouncycastle.bcpg SecretKeyPacket getPublicKeyPacket

List of usage examples for org.bouncycastle.bcpg SecretKeyPacket getPublicKeyPacket

Introduction

In this page you can find the example usage for org.bouncycastle.bcpg SecretKeyPacket getPublicKeyPacket.

Prototype

public PublicKeyPacket getPublicKeyPacket() 

Source Link

Usage

From source file:org.sufficientlysecure.keychain.pgp.UncachedKeyringMergeTest.java

License:Open Source License

private UncachedKeyRing mergeWithChecks(UncachedKeyRing a, UncachedKeyRing b, UncachedKeyRing base)
        throws Exception {

    Assert.assertTrue("merging keyring must be secret type", a.isSecret());
    Assert.assertTrue("merged keyring must be secret type", b.isSecret());

    final UncachedKeyRing resultA;
    UncachedKeyRing resultB;/*w ww  .  j av a2 s . c o  m*/

    { // sec + sec
        resultA = a.merge(b, log, 0);
        Assert.assertNotNull("merge must succeed as sec(a)+sec(b)", resultA);

        resultB = b.merge(a, log, 0);
        Assert.assertNotNull("merge must succeed as sec(b)+sec(a)", resultB);

        // check commutativity, if requested
        Assert.assertFalse("result of merge must be commutative",
                KeyringTestingHelper.diffKeyrings(resultA.getEncoded(), resultB.getEncoded(), onlyA, onlyB));
    }

    final UncachedKeyRing pubA = a.extractPublicKeyRing();
    final UncachedKeyRing pubB = b.extractPublicKeyRing();

    { // sec + pub

        // this one is special, because GNU_DUMMY keys might be generated!

        resultB = a.merge(pubB, log, 0);
        Assert.assertNotNull("merge must succeed as sec(a)+pub(b)", resultA);

        // these MAY diff
        KeyringTestingHelper.diffKeyrings(resultA.getEncoded(), resultB.getEncoded(), onlyA, onlyB);

        Assert.assertEquals("sec(a)+pub(b): results must have equal number of packets", onlyA.size(),
                onlyB.size());

        for (int i = 0; i < onlyA.size(); i++) {
            Assert.assertEquals("sec(a)+pub(c): old packet must be secret subkey", PacketTags.SECRET_SUBKEY,
                    onlyA.get(i).tag);
            Assert.assertEquals("sec(a)+pub(c): new packet must be dummy secret subkey",
                    PacketTags.SECRET_SUBKEY, onlyB.get(i).tag);

            SecretKeyPacket pA = (SecretKeyPacket) new BCPGInputStream(
                    new ByteArrayInputStream(onlyA.get(i).buf)).readPacket();
            SecretKeyPacket pB = (SecretKeyPacket) new BCPGInputStream(
                    new ByteArrayInputStream(onlyB.get(i).buf)).readPacket();

            Assert.assertArrayEquals("sec(a)+pub(c): both packets must have equal pubkey parts",
                    pA.getPublicKeyPacket().getEncoded(), pB.getPublicKeyPacket().getEncoded());

            Assert.assertEquals("sec(a)+pub(c): new packet should have GNU_DUMMY S2K type", S2K.GNU_DUMMY_S2K,
                    pB.getS2K().getType());
            Assert.assertEquals("sec(a)+pub(c): new packet should have GNU_DUMMY protection mode 0x1", 0x1,
                    pB.getS2K().getProtectionMode());
            Assert.assertEquals("sec(a)+pub(c): new packet secret key data should have length zero", 0,
                    pB.getSecretKeyData().length);
            Assert.assertNull("sec(a)+pub(c): new packet should have no iv data", pB.getIV());

        }

    }

    { // pub + sec, and pub + pub
        final UncachedKeyRing pubResult = resultA.extractPublicKeyRing();

        resultB = pubA.merge(b, log, 0);
        Assert.assertNotNull("merge must succeed as pub(a)+sec(b)", resultA);

        Assert.assertFalse("result of pub(a)+sec(b) must be same as pub(sec(a)+sec(b))",
                KeyringTestingHelper.diffKeyrings(pubResult.getEncoded(), resultB.getEncoded(), onlyA, onlyB));

        resultB = pubA.merge(pubB, log, 0);
        Assert.assertNotNull("merge must succeed as pub(a)+pub(b)", resultA);

        Assert.assertFalse("result of pub(a)+pub(b) must be same as pub(sec(a)+sec(b))",
                KeyringTestingHelper.diffKeyrings(pubResult.getEncoded(), resultB.getEncoded(), onlyA, onlyB));

    }

    if (base != null) {
        // set up onlyA and onlyB to be a diff to the base
        Assert.assertTrue("merged keyring must differ from base",
                KeyringTestingHelper.diffKeyrings(base.getEncoded(), resultA.getEncoded(), onlyA, onlyB));
    }

    return resultA;

}