Decrypt pgp file using bouncycastle api

import org.bouncycastle.openpgp.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
 
import java.io.*;
import java.util.Iterator;
 
 
import java.security.NoSuchProviderException;
import java.security.Security;
 
 
 
public class PGPSecurityService {
 
 
    public static  void main(String[] args){
        try{
            Security.addProvider(new BouncyCastleProvider());
 
            /**
             * decrypt file
             **/
            // my private key
            InputStream privKey = new BufferedInputStream (new FileInputStream("C:\\apps\\private\\secring.gpg"));
            // file to decrypt
            InputStream file = new BufferedInputStream (new FileInputStream("C:\\apps\\encrypted.pgp"));
 
            decryptFile(file, privKey,"mykey".toCharArray());
        } catch (Exception ex){
            ex.printStackTrace();
        }
    }
 
    private static PGPPrivateKey findSecretKey(PGPSecretKeyRingCollection  pgpSec, long keyID, char[] pass)
        throws PGPException, NoSuchProviderException{
        PGPSecretKey pgpSecKey = pgpSec.getSecretKey(keyID);
        if (pgpSecKey == null){
            return null;
        } else {
            return pgpSecKey.extractPrivateKey(pass, "BC");
        }
    }
 
    private static PGPPublicKey readPublicKeyFromCol(InputStream in)throws Exception {
        PGPPublicKeyRing pkRing = null;
        PGPPublicKeyRingCollection pkCol = new PGPPublicKeyRingCollection(PGPUtil.getDecoderStream(in));
        //System.out.println("key ring size=" + pkCol.size());
        Iterator it = pkCol.getKeyRings();
        while (it.hasNext()) {
            pkRing = (PGPPublicKeyRing) it.next();
            Iterator pkIt = pkRing.getPublicKeys();
            while (pkIt.hasNext()) {
                PGPPublicKey key = (PGPPublicKey) pkIt.next();
                //System.out.println("Encryption key = " + key.isEncryptionKey() + ", Master key = " +key.isMasterKey());
                if (key.isMasterKey())
                    return key;
            }
        }
        return null;
    }
 
    private static void decryptFile( InputStream in, InputStream keyIn, char[] passwd)throws Exception{
        in = PGPUtil.getDecoderStream(in);
        try{
            PGPObjectFactory pgpF = new PGPObjectFactory(in);
            Object o = pgpF.nextObject();
            PGPEncryptedDataList enc = o instanceof PGPEncryptedDataList?(PGPEncryptedDataList)o : (PGPEncryptedDataList)pgpF.nextObject();
 
 
 
            //
            // the first object might be a PGP marker packet.
            //
            /*
            if (o instanceof PGPEncryptedDataList){
                enc = (PGPEncryptedDataList)o;
            }  else {
                enc = (PGPEncryptedDataList)pgpF.nextObject();
            }
            */
            //
            // find the secret key
            //
            Iterator it = enc.getEncryptedDataObjects();
            PGPPrivateKey sKey = null;
            PGPPublicKeyEncryptedData pbe = null;
            PGPSecretKeyRingCollection  pgpSec = new PGPSecretKeyRingCollection(PGPUtil.getDecoderStream(keyIn));
 
            while (sKey == null && it.hasNext()){
                pbe = (PGPPublicKeyEncryptedData)it.next();
                sKey = findSecretKey(pgpSec, pbe.getKeyID(), passwd);
            }
            if (sKey == null){
                throw new IllegalArgumentException("secret key for message not found.");
            }
 
            InputStream clear = pbe.getDataStream(sKey, "BC");
            PGPObjectFactory plainFact = new PGPObjectFactory(clear);
            Object message = plainFact.nextObject();
            if (message instanceof PGPCompressedData){
                PGPCompressedData   cData = (PGPCompressedData)message;
                PGPObjectFactory  pgpFact = new PGPObjectFactory(cData.getDataStream());
                message = pgpFact.nextObject();
                if (message instanceof PGPLiteralData){
                    PGPLiteralData      ld = (PGPLiteralData)message;
                    FileOutputStream    fOut = new FileOutputStream("C:\\apps\\private\\outputsigned.txt");
                    InputStream    unc = ld.getInputStream();
                    int    ch;
                    while ((ch = unc.read()) >= 0){
                        fOut.write(ch);
                    }
                }else if (message instanceof PGPOnePassSignatureList) {
 
                    PGPOnePassSignatureList p1 = (PGPOnePassSignatureList) message;
                    InputStream pubKey = new BufferedInputStream (new FileInputStream("C:\\apps\\private\\pubring.gpg"));
                    PGPPublicKey key =readPublicKeyFromCol(pubKey);
                    if(key!=null){
                        PGPOnePassSignature ops = p1.get(0);
                        System.out.println("ops.getKeyID()="+ops.getKeyID());
                        ops.initVerify(key, "BC");
                        // file output dirctory
                        FileOutputStream out = new FileOutputStream("C:\\apps\\private\\outputsigned.txt");
                        PGPLiteralData  p2 = (PGPLiteralData) pgpFact.nextObject();
                        int ch;
                        InputStream  dIn = p2.getInputStream();
                        while ((ch = dIn.read()) >= 0) {
                            ops.update((byte)ch);
                            out.write(ch);
                        }
                        out.close();
                    } else {
                        throw new PGPException ("unable to find public key for signed file");
                    }
                } else {
                    throw new PGPException("message is not a simple encrypted file - type unknown.");
                }
 
                if (pbe.isIntegrityProtected()){
                    if (!pbe.verify()){
                        System.err.println("message failed integrity check");
                    } else{
                        System.err.println("message integrity check passed");
                    }
                } else {
                    System.err.println("no message integrity check");
                }
            } else {
                System.out.println("unable to verify message");
            }
        }catch (PGPException e){
            System.err.println(e);
            if (e.getUnderlyingException() != null){
                e.getUnderlyingException().printStackTrace();
            }
        }
    }
 
 
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160: