Examples of PGPPublicKeyRing

org.bouncycastle.openpgp.PGPPublicKeyRing
Class to hold a single master public key and its subkeys.
Often PGP keyring files consist of multiple master keys, if you are trying to process or construct one of these you should use the PGPPublicKeyRingCollection class.

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

    {
        Security.addProvider(new BouncyCastleProvider());


        if (args.length == 1)
        {
            PGPPublicKeyRing ring = new PGPPublicKeyRing(PGPUtil.getDecoderStream(new FileInputStream(args[0])), new JcaKeyFingerprintCalculator());
            PGPPublicKey key = ring.getPublicKey();
            
            // iterate through all direct key signautures and look for NotationData subpackets
            Iterator iter = key.getSignaturesOfType(PGPSignature.DIRECT_KEY);
            while(iter.hasNext())
            {
                PGPSignature    sig = (PGPSignature)iter.next();
                
                System.out.println("Signature date is: " + sig.getHashedSubPackets().getSignatureCreationTime());


                NotationData[] data = sig.getHashedSubPackets().getNotationDataOccurences();//.getSubpacket(SignatureSubpacketTags.NOTATION_DATA);
                
                for (int i = 0; i < data.length; i++)
                {
                    System.out.println("Found Notaion named '"+data[i].getNotationName()+"' with content '"+data[i].getNotationValue()+"'.");
                }
            }
        }
        else if (args.length == 5)
        {
            // gather command line arguments
            PGPSecretKeyRing secRing = new PGPSecretKeyRing(PGPUtil.getDecoderStream(new FileInputStream(args[0])), new JcaKeyFingerprintCalculator());
            String secretKeyPass = args[1];
            PGPPublicKeyRing ring = new PGPPublicKeyRing(PGPUtil.getDecoderStream(new FileInputStream(args[2])), new JcaKeyFingerprintCalculator());
            String notationName = args[3];
            String notationValue = args[4];


            // create the signed keyRing
            PGPPublicKeyRing sRing = new PGPPublicKeyRing(new ByteArrayInputStream(signPublicKey(secRing.getSecretKey(), secretKeyPass, ring.getPublicKey(), notationName, notationValue, true)), new JcaKeyFingerprintCalculator());
            ring = sRing;


            // write the created keyRing to file
            ArmoredOutputStream out = new ArmoredOutputStream(new FileOutputStream("SignedKey.asc"));
            sRing.encode(out);
            out.flush();
            out.close();
        }
        else
        {

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing


        Iterator    rIt = pubRings.getKeyRings();
            
        while (rIt.hasNext())
        {
            PGPPublicKeyRing    pgpPub = (PGPPublicKeyRing)rIt.next();


            try
            {
                pgpPub.getPublicKey();
            }
            catch (Exception e)
            {
                e.printStackTrace();
                continue;
            }


            Iterator    it = pgpPub.getPublicKeys();
            boolean     first = true;
            while (it.hasNext())
            {
                PGPPublicKey    pgpKey = (PGPPublicKey)it.next();

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing


    private void doSigGenerateTest(String privateKeyFile, String publicKeyFile, int digest)
        throws Exception
    {
        PGPSecretKeyRing      secRing = loadSecretKey(privateKeyFile);
        PGPPublicKeyRing      pubRing = loadPublicKey(publicKeyFile);
        String                data = "hello world!";
        ByteArrayOutputStream bOut = new ByteArrayOutputStream();
        ByteArrayInputStream  testIn = new ByteArrayInputStream(data.getBytes());
        PGPSignatureGenerator sGen = new PGPSignatureGenerator(PublicKeyAlgorithmTags.DSA, digest, "BC");


        sGen.initSign(PGPSignature.BINARY_DOCUMENT, secRing.getSecretKey().extractPrivateKey("test".toCharArray(), "BC"));


        BCPGOutputStream bcOut = new BCPGOutputStream(bOut);


        sGen.generateOnePassVersion(false).encode(bcOut);


        PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();


        Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);
        OutputStream lOut = lGen.open(
            new UncloseableOutputStream(bcOut),
            PGPLiteralData.BINARY,
            "_CONSOLE",
            data.getBytes().length,
            testDate);


        int ch;
        while ((ch = testIn.read()) >= 0)
        {
            lOut.write(ch);
            sGen.update((byte)ch);
        }


        lGen.close();


        sGen.generate().encode(bcOut);


        PGPObjectFactory        pgpFact = new PGPObjectFactory(bOut.toByteArray());
        PGPOnePassSignatureList p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
        PGPOnePassSignature     ops = p1.get(0);


        assertEquals(digest, ops.getHashAlgorithm());
        assertEquals(PublicKeyAlgorithmTags.DSA, ops.getKeyAlgorithm());


        PGPLiteralData          p2 = (PGPLiteralData)pgpFact.nextObject();
        if (!p2.getModificationTime().equals(testDate))
        {
            fail("Modification time not preserved");
        }


        InputStream             dIn = p2.getInputStream();


        ops.initVerify(pubRing.getPublicKey(), "BC");


        while ((ch = dIn.read()) >= 0)
        {
            ops.update((byte)ch);
        }

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

    private void doSigVerifyTest(
        String      publicKeyFile,
        String      sigFile)
        throws Exception
    {
        PGPPublicKeyRing publicKey = loadPublicKey(publicKeyFile);
        PGPObjectFactory pgpFact = loadSig(sigFile);


        PGPCompressedData c1 = (PGPCompressedData)pgpFact.nextObject();


        pgpFact = new PGPObjectFactory(c1.getDataStream());


        PGPOnePassSignatureList p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
        PGPOnePassSignature ops = p1.get(0);


        PGPLiteralData p2 = (PGPLiteralData)pgpFact.nextObject();


        InputStream dIn = p2.getInputStream();


        ops.initVerify(publicKey.getPublicKey(), "BC");


        int ch;
        while ((ch = dIn.read()) >= 0)
        {
            ops.update((byte)ch);

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

        String keyName)
        throws Exception
    {
        FileInputStream fIn = new FileInputStream(getDataHome() + "/keys/" + keyName);


        return new PGPPublicKeyRing(fIn);
    }

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

            //
            // Read the public key
            //
            PGPObjectFactory    pgpFact = new PGPObjectFactory(testPubKeyRing);
            
            PGPPublicKeyRing        pgpPub = (PGPPublicKeyRing)pgpFact.nextObject();


               pubKey = pgpPub.getPublicKey();


            if (pubKey.getBitStrength() != 1024)
            {
                fail("failed - key strength reported incorrectly.");
            }


            //
            // Read the private key
            //
            PGPSecretKeyRing    sKey = new PGPSecretKeyRing(testPrivKeyRing);
            PGPPrivateKey        pgpPrivKey = sKey.getSecretKey().extractPrivateKey(pass, "BC");
            
            //
            // signature generation
            //
            String                                data = "hello world!";
            ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
            ByteArrayInputStream        testIn = new ByteArrayInputStream(data.getBytes());
            PGPSignatureGenerator    sGen = new PGPSignatureGenerator(PGPPublicKey.DSA, PGPUtil.SHA1, "BC");
        
            sGen.initSign(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);


            PGPCompressedDataGenerator cGen = new PGPCompressedDataGenerator(
                PGPCompressedData.ZIP);


            BCPGOutputStream bcOut = new BCPGOutputStream(
                cGen.open(new UncloseableOutputStream(bOut)));


            sGen.generateOnePassVersion(false).encode(bcOut);


            PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();
            
            Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);
            OutputStream lOut = lGen.open(
                new UncloseableOutputStream(bcOut),
                PGPLiteralData.BINARY,
                "_CONSOLE",
                data.getBytes().length,
                testDate);


            int ch;
            while ((ch = testIn.read()) >= 0)
            {
                lOut.write(ch);
                sGen.update((byte)ch);
            }


            lGen.close();


            sGen.generate().encode(bcOut);


            cGen.close();


            //
            // verify generated signature
            //
            pgpFact = new PGPObjectFactory(bOut.toByteArray());


            PGPCompressedData c1 = (PGPCompressedData)pgpFact.nextObject();


            pgpFact = new PGPObjectFactory(c1.getDataStream());
            
            PGPOnePassSignatureList p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
            
            PGPOnePassSignature ops = p1.get(0);
            
            PGPLiteralData p2 = (PGPLiteralData)pgpFact.nextObject();
            if (!p2.getModificationTime().equals(testDate))
            {
                fail("Modification time not preserved");
            }


            InputStream    dIn = p2.getInputStream();


            ops.initVerify(pubKey, "BC");
            
            while ((ch = dIn.read()) >= 0)
            {
                ops.update((byte)ch);
            }


            PGPSignatureList p3 = (PGPSignatureList)pgpFact.nextObject();


            if (!ops.verify(p3.get(0)))
            {
                fail("Failed generated signature check");
            }
            
            //
            // test encryption
            //
            
            //
            // find a key suitable for encryption
            //
            long            pgpKeyID = 0;
            PublicKey    pKey = null;
            
            Iterator    it = pgpPub.getPublicKeys();
            while (it.hasNext())
            {
                PGPPublicKey    pgpKey = (PGPPublicKey)it.next();


                if (pgpKey.getAlgorithm() == PGPPublicKey.ELGAMAL_ENCRYPT
                    || pgpKey.getAlgorithm() == PGPPublicKey.ELGAMAL_GENERAL)
                {
                    pKey = pgpKey.getKey("BC");
                    pgpKeyID = pgpKey.getKeyID();
                    if (pgpKey.getBitStrength() != 1024)
                    {
                        fail("failed - key strength reported incorrectly.");
                    }
                    
                    //
                    // verify the key
                    //
                    
                }
            }
             
            Cipher c = Cipher.getInstance("ElGamal/None/PKCS1Padding", "BC");


            c.init(Cipher.ENCRYPT_MODE, pKey);
            
            byte[]  in = "hello world".getBytes();


            byte[]  out = c.doFinal(in);
            
            pgpPrivKey = sKey.getSecretKey(pgpKeyID).extractPrivateKey(pass, "BC");
            
            c.init(Cipher.DECRYPT_MODE, pgpPrivKey.getKey());
            
            out = c.doFinal(out);
            
            if (!areEqual(in, out))
            {
                fail("decryption failed.");
            }


            //
            // encrypted message
            //
            byte[]    text = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)' ', (byte)'w', (byte)'o', (byte)'r', (byte)'l', (byte)'d', (byte)'!', (byte)'\n' };
            
            PGPObjectFactory pgpF = new PGPObjectFactory(encMessage);


            PGPEncryptedDataList            encList = (PGPEncryptedDataList)pgpF.nextObject();
        
            PGPPublicKeyEncryptedData    encP = (PGPPublicKeyEncryptedData)encList.get(0);


            InputStream clear = encP.getDataStream(pgpPrivKey, "BC");
                     
            pgpFact = new PGPObjectFactory(clear);


            c1 = (PGPCompressedData)pgpFact.nextObject();


            pgpFact = new PGPObjectFactory(c1.getDataStream());
            
            PGPLiteralData    ld = (PGPLiteralData)pgpFact.nextObject();
        
            bOut = new ByteArrayOutputStream();
            
            if (!ld.getFileName().equals("test.txt"))
            {
                throw new RuntimeException("wrong filename in packet");
            }


            InputStream    inLd = ld.getDataStream();
            
            while ((ch = inLd.read()) >= 0)
            {
                bOut.write(ch);
            }


            if (!areEqual(bOut.toByteArray(), text))
            {
                fail("wrong plain text in decrypted packet");
            }
            
            //
            // signed and encrypted message
            //
            pgpF = new PGPObjectFactory(signedAndEncMessage);


            encList = (PGPEncryptedDataList)pgpF.nextObject();
        
            encP = (PGPPublicKeyEncryptedData)encList.get(0);


            clear = encP.getDataStream(pgpPrivKey, "BC");
                     
            pgpFact = new PGPObjectFactory(clear);


            c1 = (PGPCompressedData)pgpFact.nextObject();


            pgpFact = new PGPObjectFactory(c1.getDataStream());
            
            p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
            
            ops = p1.get(0);
            
            ld = (PGPLiteralData)pgpFact.nextObject();
        
            bOut = new ByteArrayOutputStream();
            
            if (!ld.getFileName().equals("test.txt"))
            {
                throw new RuntimeException("wrong filename in packet");
            }


            inLd = ld.getDataStream();
            
            //
            // note: we use the DSA public key here.
            //
            ops.initVerify(pgpPub.getPublicKey(), "BC");
            
            while ((ch = inLd.read()) >= 0)
            {
                ops.update((byte)ch);
                bOut.write(ch);
            }


            p3 = (PGPSignatureList)pgpFact.nextObject();


            if (!ops.verify(p3.get(0)))
            {
                fail("Failed signature check");
            }
            
            if (!areEqual(bOut.toByteArray(), text))
            {
                fail("wrong plain text in decrypted packet");
            }
            
            //
            // encrypt
            //
            ByteArrayOutputStream        cbOut = new ByteArrayOutputStream();
            PGPEncryptedDataGenerator    cPk = new PGPEncryptedDataGenerator(SymmetricKeyAlgorithmTags.TRIPLE_DES, new SecureRandom(), "BC");            
            PGPPublicKey                        puK = sKey.getSecretKey(pgpKeyID).getPublicKey();
            
            cPk.addMethod(puK);
            
            OutputStream    cOut = cPk.open(new UncloseableOutputStream(cbOut), bOut.toByteArray().length);


            cOut.write(text);


            cOut.close();


            pgpF = new PGPObjectFactory(cbOut.toByteArray());


            encList = (PGPEncryptedDataList)pgpF.nextObject();
        
            encP = (PGPPublicKeyEncryptedData)encList.get(0);
            
            pgpPrivKey = sKey.getSecretKey(pgpKeyID).extractPrivateKey(pass, "BC");


            clear = encP.getDataStream(pgpPrivKey, "BC");
            
            bOut.reset();
            
            while ((ch = clear.read()) >= 0)
            {
                bOut.write(ch);
            }


            out = bOut.toByteArray();


            if (!areEqual(out, text))
            {
                fail("wrong plain text in generated packet");
            }
            
            //
            // use of PGPKeyPair
            //
            BigInteger g = new BigInteger("153d5d6172adb43045b68ae8e1de1070b6137005686d29d3d73a7749199681ee5b212c9b96bfdcfa5b20cd5e3fd2044895d609cf9b410b7a0f12ca1cb9a428cc", 16);
            BigInteger p = new BigInteger("9494fec095f3b85ee286542b3836fc81a5dd0a0349b4c239dd38744d488cf8e31db8bcb7d33b41abb9e5a33cca9144b1cef332c94bf0573bf047a3aca98cdf3b", 16);


            KeyPairGenerator       kpg = KeyPairGenerator.getInstance("ElGamal", "BC");
            
            ElGamalParameterSpec   elParams = new ElGamalParameterSpec(p, g);
            
            kpg.initialize(elParams);
            
            KeyPair kp = kpg.generateKeyPair();
            
            PGPKeyPair    pgpKp = new PGPKeyPair(PGPPublicKey.ELGAMAL_GENERAL , kp.getPublic(), kp.getPrivate(), new Date());
            
            PGPPublicKey k1 = pgpKp.getPublicKey();
            
            PGPPrivateKey k2 = pgpKp.getPrivateKey();






            // Test bug with ElGamal P size != 0 mod 8 (don't use these sizes at home!)
            SecureRandom random = new SecureRandom();
            for (int pSize = 257; pSize < 264; ++pSize)
            {
                // Generate some parameters of the given size
                AlgorithmParameterGenerator a = AlgorithmParameterGenerator.getInstance("ElGamal", "BC");
                a.init(pSize, new SecureRandom());
                AlgorithmParameters params = a.generateParameters();


                DHParameterSpec elP = (DHParameterSpec)params.getParameterSpec(DHParameterSpec.class);
                KeyPairGenerator keyGen = KeyPairGenerator.getInstance("ElGamal", "BC");


                keyGen.initialize(elP);




                // Run a short encrypt/decrypt test with random key for the given parameters
                kp = keyGen.generateKeyPair();


                PGPKeyPair elGamalKeyPair = new PGPKeyPair(
                    PublicKeyAlgorithmTags.ELGAMAL_GENERAL, kp, new Date());


                cPk = new PGPEncryptedDataGenerator(SymmetricKeyAlgorithmTags.CAST5, random, "BC");


                puK = elGamalKeyPair.getPublicKey();


                cPk.addMethod(puK);


                cbOut = new ByteArrayOutputStream();


                cOut = cPk.open(cbOut, text.length);


                cOut.write(text);


                cOut.close();


                pgpF = new PGPObjectFactory(cbOut.toByteArray());


                encList = (PGPEncryptedDataList)pgpF.nextObject();


                encP = (PGPPublicKeyEncryptedData)encList.get(0);


                pgpPrivKey = elGamalKeyPair.getPrivateKey();


                // Note: This is where an exception would be expected if the P size causes problems
                clear = encP.getDataStream(pgpPrivKey, "BC");


                ByteArrayOutputStream dec = new ByteArrayOutputStream();


                int b;
                while ((b = clear.read()) >= 0)
                {
                    dec.write(b);
                }


                byte[] decText = dec.toByteArray();


                if (!areEqual(text, decText))
                {
                    fail("decrypted message incorrect");
                }
            }


            // check sub key encoding


            it = pgpPub.getPublicKeys();
            while (it.hasNext())
            {
                PGPPublicKey    pgpKey = (PGPPublicKey)it.next();


                if (!pgpKey.isMasterKey())

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing


        Iterator    rIt = pubRings.getKeyRings();
        
        while (rIt.hasNext())
        {
            PGPPublicKeyRing                    pgpPub = (PGPPublicKeyRing)rIt.next();


            count++;
            
            int    keyCount = 0;
            
            byte[]    bytes = pgpPub.getEncoded();
            
            pgpPub = new PGPPublicKeyRing(bytes);
            
            Iterator    it = pgpPub.getPublicKeys();
            while (it.hasNext())
            {
                keyCount++;


                PGPPublicKey    pubKey = (PGPPublicKey)it.next();
                
                Iterator   sIt = pubKey.getSignatures();
                while (sIt.hasNext())
                {
                    ((PGPSignature)sIt.next()).getSignatureType();
                }
            }
            
            if (keyCount != 2)
            {
                fail("wrong number of public keys");
            }
        }
        
        if (count != 1)
        {
            fail("wrong number of public keyrings");
        }
        
        //
        // exact match
        //
        rIt = pubRings.getKeyRings("test (Test key) <test@ubicall.com>");
        count = 0;
        while (rIt.hasNext())
        {
            count++;
            rIt.next();
        }
        
        if (count != 1)
        {
            fail("wrong number of public keyrings on exact match");
        }
        
        //
        // partial match 1 expected
        //
        rIt = pubRings.getKeyRings("test", true);
        count = 0;
        while (rIt.hasNext())
        {
            count++;
            rIt.next();
        }
        
        if (count != 1)
        {
            fail("wrong number of public keyrings on partial match 1");
        }
        
        //
        // partial match 0 expected
        //
        rIt = pubRings.getKeyRings("XXX", true);
        count = 0;
        while (rIt.hasNext())
        {
            count++;
            rIt.next();
        }
        
        if (count != 0)
        {
            fail("wrong number of public keyrings on partial match 0");
        }


        //
        // case-insensitive partial match
        //
        rIt = pubRings.getKeyRings("TEST@ubicall.com", true, true);
        count = 0;
        while (rIt.hasNext())
        {
            count++;
            rIt.next();
        }
        
        if (count != 1)
        {
            fail("wrong number of public keyrings on case-insensitive partial match");
        }
        
        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec1);


        rIt = secretRings.getKeyRings();
        count = 0;
        
        while (rIt.hasNext())
        {
            PGPSecretKeyRing                    pgpSec = (PGPSecretKeyRing)rIt.next();
    
            count++;
            
            int    keyCount = 0;
            
            byte[]    bytes = pgpSec.getEncoded();
            
            pgpSec = new PGPSecretKeyRing(bytes);
            
            Iterator    it = pgpSec.getSecretKeys();
            while (it.hasNext())
            {
                keyCount++;


                PGPSecretKey    k = (PGPSecretKey)it.next();
                PGPPublicKey    pk = k.getPublicKey();
                
                pk.getSignatures();
                
                byte[] pkBytes = pk.getEncoded();
                
                PGPPublicKeyRing  pkR = new PGPPublicKeyRing(pkBytes);
            }
            
            if (keyCount != 2)
            {
                fail("wrong number of secret keys");

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

        
        Iterator    rIt = pubRings.getKeyRings();
        
        while (rIt.hasNext())
        {
            PGPPublicKeyRing        pgpPub = (PGPPublicKeyRing)rIt.next();
            
            count++;
            
            int    keyCount = 0;
            
            byte[]    bytes = pgpPub.getEncoded();
            
            pgpPub = new PGPPublicKeyRing(bytes);
            
            Iterator    it = pgpPub.getPublicKeys();
            while (it.hasNext())
            {
                PGPPublicKey    pk = (PGPPublicKey)it.next();
                
                byte[] pkBytes = pk.getEncoded();
                
                PGPPublicKeyRing  pkR = new PGPPublicKeyRing(pkBytes);
                
                keyCount++;
            }
            
            if (keyCount != 2)

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

        
        Iterator    rIt = pubRings.getKeyRings();
        
        while (rIt.hasNext())
        {
            PGPPublicKeyRing                    pgpPub = (PGPPublicKeyRing)rIt.next();
            
            count++;
            
            int    keyCount = 0;
            
            byte[]    bytes = pgpPub.getEncoded();
            
            pgpPub = new PGPPublicKeyRing(bytes);
            
            Iterator    it = pgpPub.getPublicKeys();
            while (it.hasNext())
            {
                keyCount++;


                PGPPublicKey pubK = (PGPPublicKey)it.next();

View Full Code Here

Examples of org.bouncycastle.openpgp.PGPPublicKeyRing

        
        Iterator    rIt = pubRings.getKeyRings();
        
        while (rIt.hasNext())
        {
            PGPPublicKeyRing                    pgpPub = (PGPPublicKeyRing)rIt.next();
            
            count++;
            
            int    keyCount = 0;
            
            byte[]    bytes = pgpPub.getEncoded();
            
            pgpPub = new PGPPublicKeyRing(bytes);
            
            Iterator    it = pgpPub.getPublicKeys();
            while (it.hasNext())
            {
                keyCount++;


                it.next();

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.