first cut of PGP packages.

25 files changed, 10266 insertions, 44 deletions

diff --git a/crypto/j2me/org/bouncycastle/cms/test/SHA1DigestCalculator.java b/crypto/j2me/org/bouncycastle/cms/test/SHA1DigestCalculator.java
deleted file mode 100644
index 934bfcffd..000000000
--- a/crypto/j2me/org/bouncycastle/cms/test/SHA1DigestCalculator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.bouncycastle.cms.test;
-
-import java.io.ByteArrayOutputStream;
-import java.io.OutputStream;
-
-import org.bouncycastle.asn1.oiw.OIWObjectIdentifiers;
-import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
-import org.bouncycastle.crypto.Digest;
-import org.bouncycastle.crypto.digests.SHA1Digest;
-import org.bouncycastle.operator.DigestCalculator;
-
-
-class SHA1DigestCalculator
-    implements DigestCalculator
-{
-    private ByteArrayOutputStream bOut = new ByteArrayOutputStream();
-
-    public AlgorithmIdentifier getAlgorithmIdentifier()
-    {
-        return new AlgorithmIdentifier(OIWObjectIdentifiers.idSHA1);
-    }
-
-    public OutputStream getOutputStream()
-    {
-        return bOut;
-    }
-
-    public byte[] getDigest()
-    {
-        byte[] bytes = bOut.toByteArray();
-
-        bOut.reset();
-
-        Digest sha1 = new SHA1Digest();
-
-        sha1.update(bytes, 0, bytes.length);
-
-        byte[] digest = new byte[sha1.getDigestSize()];
-
-        sha1.doFinal(digest, 0);
-
-        return digest;
-    }
-}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java b/crypto/j2me/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java
new file mode 100644
index 000000000..6f36dbc9d
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java
@@ -0,0 +1,360 @@
+package org.bouncycastle.openpgp;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.HashAlgorithmTags;
+import org.bouncycastle.bcpg.PacketTags;
+import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
+import org.bouncycastle.openpgp.operator.PBEKeyEncryptionMethodGenerator;
+import org.bouncycastle.openpgp.operator.PGPDataEncryptor;
+import org.bouncycastle.openpgp.operator.PGPDataEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.PGPDigestCalculator;
+import org.bouncycastle.openpgp.operator.PGPKeyEncryptionMethodGenerator;
+import org.bouncycastle.util.io.TeeOutputStream;
+
+/**
+ *  Generator for encrypted objects.
+ */
+public class PGPEncryptedDataGenerator
+    implements SymmetricKeyAlgorithmTags, StreamGenerator
+{
+    /**
+     * Specifier for SHA-1 S2K PBE generator.
+     */
+    public static final int S2K_SHA1 = HashAlgorithmTags.SHA1;
+
+    /**
+     * Specifier for SHA-224 S2K PBE generator.
+     */
+    public static final int S2K_SHA224 = HashAlgorithmTags.SHA224;
+
+    /**
+     * Specifier for SHA-256 S2K PBE generator.
+     */
+    public static final int S2K_SHA256 = HashAlgorithmTags.SHA256;
+
+    /**
+     * Specifier for SHA-384 S2K PBE generator.
+     */
+    public static final int S2K_SHA384 = HashAlgorithmTags.SHA384;
+
+    /**
+     * Specifier for SHA-512 S2K PBE generator.
+     */
+    public static final int S2K_SHA512 = HashAlgorithmTags.SHA512;
+
+    private BCPGOutputStream     pOut;
+    private OutputStream         cOut;
+    private boolean              oldFormat = false;
+    private PGPDigestCalculator digestCalc;
+    private OutputStream            genOut;
+    private PGPDataEncryptorBuilder dataEncryptorBuilder;
+
+    private List            methods = new ArrayList();
+    private int             defAlgorithm;
+    private SecureRandom    rand;
+
+   /**
+       * Base constructor.
+       *
+       * @param encryptorBuilder builder to create actual data encryptor.
+       */
+    public PGPEncryptedDataGenerator(PGPDataEncryptorBuilder encryptorBuilder)
+    {
+        this(encryptorBuilder, false);
+    }
+
+   /**
+       * Base constructor with the option to turn on formatting for PGP 2.6.x compatibility.
+       *
+       * @param encryptorBuilder builder to create actual data encryptor.
+       * @param oldFormat PGP 2.6.x compatibility required.
+       */
+    public PGPEncryptedDataGenerator(PGPDataEncryptorBuilder encryptorBuilder, boolean oldFormat)
+    {
+        this.dataEncryptorBuilder = encryptorBuilder;
+        this.oldFormat = oldFormat;
+
+        this.defAlgorithm = dataEncryptorBuilder.getAlgorithm();
+        this.rand = dataEncryptorBuilder.getSecureRandom();
+    }
+
+    /**
+        *  Added a key encryption method to be used to encrypt the session data associated
+        *  with this encrypted data.
+        *
+        * @param method  key encryption method to use.
+        */
+    public void addMethod(PGPKeyEncryptionMethodGenerator method)
+    {
+        methods.add(method);
+    }
+
+    private void addCheckSum(
+        byte[]    sessionInfo)
+    {
+        int    check = 0;
+        
+        for (int i = 1; i != sessionInfo.length - 2; i++)
+        {
+            check += sessionInfo[i] & 0xff;
+        }
+        
+        sessionInfo[sessionInfo.length - 2] = (byte)(check >> 8);
+        sessionInfo[sessionInfo.length - 1] = (byte)(check);
+    }
+
+    private byte[] createSessionInfo(
+        int     algorithm,
+        byte[]  keyBytes)
+    {
+        byte[] sessionInfo = new byte[keyBytes.length + 3];
+        sessionInfo[0] = (byte) algorithm;
+        System.arraycopy(keyBytes, 0, sessionInfo, 1, keyBytes.length);
+        addCheckSum(sessionInfo);
+        return sessionInfo;
+    }
+
+    /**
+     * If buffer is non null stream assumed to be partial, otherwise the
+     * length will be used to output a fixed length packet.
+     * <p>
+     * The stream created can be closed off by either calling close()
+     * on the stream or close() on the generator. Closing the returned
+     * stream does not close off the OutputStream parameter out.
+     * 
+     * @param out
+     * @param length
+     * @param buffer
+     * @return
+     * @throws java.io.IOException
+     * @throws PGPException
+     * @throws IllegalStateException
+     */
+    private OutputStream open(
+        OutputStream    out,
+        long            length,
+        byte[]          buffer)
+        throws IOException, PGPException, IllegalStateException
+    {
+        if (cOut != null)
+        {
+            throw new IllegalStateException("generator already in open state");
+        }
+
+        if (methods.size() == 0)
+        {
+            throw new IllegalStateException("no encryption methods specified");
+        }
+
+        byte[] key = null;
+
+        pOut = new BCPGOutputStream(out);
+
+        defAlgorithm = dataEncryptorBuilder.getAlgorithm();
+        rand = dataEncryptorBuilder.getSecureRandom();
+
+        if (methods.size() == 1)
+        {    
+
+            if (methods.get(0) instanceof PBEKeyEncryptionMethodGenerator)
+            {
+                PBEKeyEncryptionMethodGenerator m = (PBEKeyEncryptionMethodGenerator)methods.get(0);
+
+                key = m.getKey(dataEncryptorBuilder.getAlgorithm());
+
+                pOut.writePacket(((PGPKeyEncryptionMethodGenerator)methods.get(0)).generate(defAlgorithm, null));
+            }
+            else
+            {
+                key = PGPUtil.makeRandomKey(defAlgorithm, rand);
+                byte[] sessionInfo = createSessionInfo(defAlgorithm, key);
+                PGPKeyEncryptionMethodGenerator m = (PGPKeyEncryptionMethodGenerator)methods.get(0);
+
+                pOut.writePacket(m.generate(defAlgorithm, sessionInfo));
+            }
+        }
+        else // multiple methods
+        {
+            key = PGPUtil.makeRandomKey(defAlgorithm, rand);
+            byte[] sessionInfo = createSessionInfo(defAlgorithm, key);
+
+            for (int i = 0; i != methods.size(); i++)
+            {
+                PGPKeyEncryptionMethodGenerator m = (PGPKeyEncryptionMethodGenerator)methods.get(i);
+
+                pOut.writePacket(m.generate(defAlgorithm, sessionInfo));
+            }
+        }
+
+        try
+        {
+            PGPDataEncryptor dataEncryptor = dataEncryptorBuilder.build(key);
+
+            digestCalc = dataEncryptor.getIntegrityCalculator();
+            
+            if (buffer == null)
+            {
+                //
+                // we have to add block size + 2 for the generated IV and + 1 + 22 if integrity protected
+                //
+                if (digestCalc != null)
+                {
+                    pOut = new ClosableBCPGOutputStream(out, PacketTags.SYM_ENC_INTEGRITY_PRO, length + dataEncryptor.getBlockSize() + 2 + 1 + 22);
+
+                    pOut.write(1);        // version number
+                }
+                else
+                {
+                    pOut = new ClosableBCPGOutputStream(out, PacketTags.SYMMETRIC_KEY_ENC, length + dataEncryptor.getBlockSize() + 2, oldFormat);
+                }
+            }
+            else
+            {
+                if (digestCalc != null)
+                {
+                    pOut = new ClosableBCPGOutputStream(out, PacketTags.SYM_ENC_INTEGRITY_PRO, buffer);
+                    pOut.write(1);        // version number
+                }
+                else
+                {
+                    pOut = new ClosableBCPGOutputStream(out, PacketTags.SYMMETRIC_KEY_ENC, buffer);
+                }
+            }
+
+            genOut = cOut = dataEncryptor.getOutputStream(pOut);
+
+            if (digestCalc != null)
+            {
+                genOut = new TeeOutputStream(digestCalc.getOutputStream(), cOut);
+            }
+
+            byte[] inLineIv = new byte[dataEncryptor.getBlockSize() + 2];
+            rand.nextBytes(inLineIv);
+            inLineIv[inLineIv.length - 1] = inLineIv[inLineIv.length - 3];
+            inLineIv[inLineIv.length - 2] = inLineIv[inLineIv.length - 4];
+
+            genOut.write(inLineIv);
+
+            return new WrappedGeneratorStream(genOut, this);
+        }
+        catch (Exception e)
+        {
+            throw new PGPException("Exception creating cipher", e);
+        }
+    }
+
+    /**
+     * Return an outputstream which will encrypt the data as it is written
+     * to it.
+     * <p>
+     * The stream created can be closed off by either calling close()
+     * on the stream or close() on the generator. Closing the returned
+     * stream does not close off the OutputStream parameter out.
+     * 
+     * @param out
+     * @param length
+     * @return OutputStream
+     * @throws IOException
+     * @throws PGPException
+     */
+    public OutputStream open(
+        OutputStream    out,
+        long            length)
+        throws IOException, PGPException
+    {
+        return this.open(out, length, null);
+    }
+    
+    /**
+     * Return an outputstream which will encrypt the data as it is written
+     * to it. The stream will be written out in chunks according to the size of the
+     * passed in buffer.
+     * <p>
+     * The stream created can be closed off by either calling close()
+     * on the stream or close() on the generator. Closing the returned
+     * stream does not close off the OutputStream parameter out.
+     * <p>
+     * <b>Note</b>: if the buffer is not a power of 2 in length only the largest power of 2
+     * bytes worth of the buffer will be used.
+     * 
+     * @param out
+     * @param buffer the buffer to use.
+     * @return OutputStream
+     * @throws IOException
+     * @throws PGPException
+     */
+    public OutputStream open(
+        OutputStream    out,
+        byte[]          buffer)
+        throws IOException, PGPException
+    {
+        return this.open(out, 0, buffer);
+    }
+    
+    /**
+     * Close off the encrypted object - this is equivalent to calling close on the stream
+     * returned by the open() method.
+     * <p>
+     * <b>Note</b>: This does not close the underlying output stream, only the stream on top of it created by the open() method.
+     * @throws java.io.IOException
+     */
+    public void close()
+        throws IOException
+    {
+        if (cOut != null)
+        {    
+            if (digestCalc != null)
+            {
+                //
+                // hand code a mod detection packet
+                //
+                BCPGOutputStream bOut = new BCPGOutputStream(genOut, PacketTags.MOD_DETECTION_CODE, 20);
+
+                bOut.flush();
+
+                byte[] dig = digestCalc.getDigest();
+
+                cOut.write(dig);
+            }
+
+            cOut.close();
+
+            cOut = null;
+            pOut = null;
+        }
+    }
+
+    private class ClosableBCPGOutputStream
+        extends BCPGOutputStream
+    {
+        public ClosableBCPGOutputStream(OutputStream out, int symmetricKeyEnc, byte[] buffer)
+            throws IOException
+        {
+            super(out, symmetricKeyEnc, buffer);
+        }
+
+        public ClosableBCPGOutputStream(OutputStream out, int symmetricKeyEnc, long length, boolean oldFormat)
+            throws IOException
+        {
+            super(out, symmetricKeyEnc, length, oldFormat);
+        }
+
+        public ClosableBCPGOutputStream(OutputStream out, int symEncIntegrityPro, long length)
+            throws IOException
+        {
+            super(out, symEncIntegrityPro, length);
+        }
+
+        public void close()
+            throws IOException
+        {
+             this.finish();
+        }
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPKeyPair.java b/crypto/j2me/org/bouncycastle/openpgp/PGPKeyPair.java
new file mode 100644
index 000000000..feedae153
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPKeyPair.java
@@ -0,0 +1,62 @@
+package org.bouncycastle.openpgp;
+
+import java.util.Date;
+
+import org.bouncycastle.bcpg.BCPGKey;
+import org.bouncycastle.bcpg.DSASecretBCPGKey;
+import org.bouncycastle.bcpg.ElGamalSecretBCPGKey;
+import org.bouncycastle.bcpg.RSASecretBCPGKey;
+
+
+/**
+ * General class to handle JCA key pairs and convert them into OpenPGP ones.
+ * <p>
+ * A word for the unwary, the KeyID for a OpenPGP public key is calculated from
+ * a hash that includes the time of creation, if you pass a different date to the 
+ * constructor below with the same public private key pair the KeyID will not be the
+ * same as for previous generations of the key, so ideally you only want to do 
+ * this once.
+ */
+public class PGPKeyPair
+{
+    protected PGPPublicKey        pub;
+    protected PGPPrivateKey       priv;
+
+    protected PGPKeyPair()
+    {
+    }
+
+    /**
+     * Create a key pair from a PGPPrivateKey and a PGPPublicKey.
+     * 
+     * @param pub the public key
+     * @param priv the private key
+     */
+    public PGPKeyPair(
+        PGPPublicKey    pub,
+        PGPPrivateKey   priv)
+    {
+        this.pub = pub;
+        this.priv = priv;
+    }
+    
+    /**
+     * Return the keyID associated with this key pair.
+     * 
+     * @return keyID
+     */
+    public long getKeyID()
+    {
+        return pub.getKeyID();
+    }
+    
+    public PGPPublicKey getPublicKey()
+    {
+        return pub;
+    }
+    
+    public PGPPrivateKey getPrivateKey()
+    {
+        return priv;
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPKeyRingGenerator.java b/crypto/j2me/org/bouncycastle/openpgp/PGPKeyRingGenerator.java
new file mode 100644
index 000000000..a5f84b4fa
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPKeyRingGenerator.java
@@ -0,0 +1,151 @@
+package org.bouncycastle.openpgp;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.bouncycastle.bcpg.PublicSubkeyPacket;
+import org.bouncycastle.openpgp.operator.PBESecretKeyEncryptor;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.PGPDigestCalculator;
+
+/**
+ * Generator for a PGP master and subkey ring. This class will generate
+ * both the secret and public key rings
+ */
+public class PGPKeyRingGenerator
+{    
+    List                                keys = new ArrayList();
+
+    private PBESecretKeyEncryptor       keyEncryptor;
+    private PGPDigestCalculator checksumCalculator;
+    private PGPKeyPair                  masterKey;
+    private PGPSignatureSubpacketVector hashedPcks;
+    private PGPSignatureSubpacketVector unhashedPcks;
+    private PGPContentSignerBuilder     keySignerBuilder;
+
+    /**
+     * Create a new key ring generator.
+     *
+     * @param certificationLevel
+     * @param masterKey
+     * @param id
+     * @param checksumCalculator
+     * @param hashedPcks
+     * @param unhashedPcks
+     * @param keySignerBuilder
+     * @param keyEncryptor
+     * @throws PGPException
+     */
+    public PGPKeyRingGenerator(
+        int                            certificationLevel,
+        PGPKeyPair                     masterKey,
+        String                         id,
+        PGPDigestCalculator checksumCalculator,
+        PGPSignatureSubpacketVector    hashedPcks,
+        PGPSignatureSubpacketVector    unhashedPcks,
+        PGPContentSignerBuilder        keySignerBuilder,
+        PBESecretKeyEncryptor          keyEncryptor)
+        throws PGPException
+    {
+        this.masterKey = masterKey;
+        this.keyEncryptor = keyEncryptor;
+        this.checksumCalculator = checksumCalculator;
+        this.keySignerBuilder = keySignerBuilder;
+        this.hashedPcks = hashedPcks;
+        this.unhashedPcks = unhashedPcks;
+
+        keys.add(new PGPSecretKey(certificationLevel, masterKey, id, checksumCalculator, hashedPcks, unhashedPcks, keySignerBuilder, keyEncryptor));
+    }
+
+    /**
+     * Add a sub key to the key ring to be generated with default certification and inheriting
+     * the hashed/unhashed packets of the master key.
+     * 
+     * @param keyPair
+     * @throws PGPException
+     */
+    public void addSubKey(
+        PGPKeyPair    keyPair) 
+        throws PGPException
+    {
+        addSubKey(keyPair, hashedPcks, unhashedPcks);
+    }
+    
+    /**
+     * Add a subkey with specific hashed and unhashed packets associated with it and default
+     * certification. 
+     * 
+     * @param keyPair public/private key pair.
+     * @param hashedPcks hashed packet values to be included in certification.
+     * @param unhashedPcks unhashed packets values to be included in certification.
+     * @throws PGPException
+     */
+    public void addSubKey(
+        PGPKeyPair                  keyPair,
+        PGPSignatureSubpacketVector hashedPcks,
+        PGPSignatureSubpacketVector unhashedPcks) 
+        throws PGPException
+    {
+        try
+        {
+            //
+            // generate the certification
+            //
+            PGPSignatureGenerator  sGen = new PGPSignatureGenerator(keySignerBuilder);
+
+            sGen.init(PGPSignature.SUBKEY_BINDING, masterKey.getPrivateKey());
+
+            sGen.setHashedSubpackets(hashedPcks);
+            sGen.setUnhashedSubpackets(unhashedPcks);
+
+            List                 subSigs = new ArrayList();
+            
+            subSigs.add(sGen.generateCertification(masterKey.getPublicKey(), keyPair.getPublicKey()));
+            
+            keys.add(new PGPSecretKey(keyPair.getPrivateKey(), new PGPPublicKey(keyPair.getPublicKey(), null, subSigs), checksumCalculator, keyEncryptor));
+        }
+        catch (PGPException e)
+        {
+            throw e;
+        } 
+        catch (Exception e)
+        {
+            throw new PGPException("exception adding subkey: ", e);
+        }
+    }
+    
+    /**
+     * Return the secret key ring.
+     * 
+     * @return a secret key ring.
+     */
+    public PGPSecretKeyRing generateSecretKeyRing()
+    {
+        return new PGPSecretKeyRing(keys);
+    }
+    
+    /**
+     * Return the public key ring that corresponds to the secret key ring.
+     * 
+     * @return a public key ring.
+     */
+    public PGPPublicKeyRing generatePublicKeyRing()
+    {
+        Iterator it = keys.iterator();
+        List     pubKeys = new ArrayList();
+        
+        pubKeys.add(((PGPSecretKey)it.next()).getPublicKey());
+        
+        while (it.hasNext())
+        {
+            PGPPublicKey k = new PGPPublicKey(((PGPSecretKey)it.next()).getPublicKey());
+            
+            k.publicPk = new PublicSubkeyPacket(k.getAlgorithm(), k.getCreationTime(), k.publicPk.getKey());
+            
+            pubKeys.add(k);
+        }
+        
+        return new PGPPublicKeyRing(pubKeys);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPLiteralDataGenerator.java b/crypto/j2me/org/bouncycastle/openpgp/PGPLiteralDataGenerator.java
new file mode 100644
index 000000000..b35c78984
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPLiteralDataGenerator.java
@@ -0,0 +1,167 @@
+package org.bouncycastle.openpgp;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Date;
+
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.PacketTags;
+import org.bouncycastle.util.Strings;
+
+/**
+ * Class for producing literal data packets.
+ */
+public class PGPLiteralDataGenerator implements StreamGenerator
+{    
+    public static final char    BINARY = PGPLiteralData.BINARY;
+    public static final char    TEXT = PGPLiteralData.TEXT;
+    public static final char    UTF8 = PGPLiteralData.UTF8;
+    
+    /**
+     * The special name indicating a "for your eyes only" packet.
+     */
+    public static final String  CONSOLE = PGPLiteralData.CONSOLE;
+    
+    /**
+     * The special time for a modification time of "now" or
+     * the present time.
+     */
+    public static final Date    NOW = PGPLiteralData.NOW;
+    
+    private BCPGOutputStream    pkOut;
+    private boolean             oldFormat = false;
+    
+    public PGPLiteralDataGenerator()
+    {        
+    }
+    
+    /**
+     * Generates literal data objects in the old format, this is
+     * important if you need compatability with  PGP 2.6.x.
+     * 
+     * @param oldFormat
+     */
+    public PGPLiteralDataGenerator(
+        boolean    oldFormat)
+    {
+        this.oldFormat = oldFormat;
+    }
+    
+    private void writeHeader(
+        OutputStream    out,
+        char            format,
+        byte[]          encName,
+        long            modificationTime) 
+        throws IOException
+    {
+        out.write(format);
+
+        out.write((byte)encName.length);
+
+        for (int i = 0; i != encName.length; i++)
+        {
+            out.write(encName[i]);
+        }
+
+        long    modDate = modificationTime / 1000;
+
+        out.write((byte)(modDate >> 24));
+        out.write((byte)(modDate >> 16));
+        out.write((byte)(modDate >> 8));
+        out.write((byte)(modDate));
+    }
+    
+    /**
+     * Open a literal data packet, returning a stream to store the data inside
+     * the packet.
+     * <p>
+     * The stream created can be closed off by either calling close()
+     * on the stream or close() on the generator. Closing the returned
+     * stream does not close off the OutputStream parameter out.
+     * 
+     * @param out the stream we want the packet in
+     * @param format the format we are using
+     * @param name the name of the "file"
+     * @param length the length of the data we will write
+     * @param modificationTime the time of last modification we want stored.
+     */
+    public OutputStream open(
+        OutputStream    out,
+        char            format,
+        String          name,
+        long            length,
+        Date            modificationTime)
+        throws IOException
+    {
+        if (pkOut != null)
+        {
+            throw new IllegalStateException("generator already in open state");
+        }
+
+        byte[] encName = Strings.toUTF8ByteArray(name);
+
+        pkOut = new BCPGOutputStream(out, PacketTags.LITERAL_DATA, length + 2 + encName.length + 4, oldFormat);
+        
+        writeHeader(pkOut, format, encName, modificationTime.getTime());
+
+        return new WrappedGeneratorStream(pkOut, this);
+    }
+    
+    /**
+     * Open a literal data packet, returning a stream to store the data inside
+     * the packet as an indefinite length stream. The stream is written out as a 
+     * series of partial packets with a chunk size determined by the size of the
+     * passed in buffer.
+     * <p>
+     * The stream created can be closed off by either calling close()
+     * on the stream or close() on the generator. Closing the returned
+     * stream does not close off the OutputStream parameter out.
+     * <p>
+     * <b>Note</b>: if the buffer is not a power of 2 in length only the largest power of 2
+     * bytes worth of the buffer will be used.
+     * 
+     * @param out the stream we want the packet in
+     * @param format the format we are using
+     * @param name the name of the "file"
+     * @param modificationTime the time of last modification we want stored.
+     * @param buffer the buffer to use for collecting data to put into chunks.
+     */
+    public OutputStream open(
+        OutputStream    out,
+        char            format,
+        String          name,
+        Date            modificationTime,
+        byte[]          buffer)
+        throws IOException
+    {
+        if (pkOut != null)
+        {
+            throw new IllegalStateException("generator already in open state");
+        }
+
+        pkOut = new BCPGOutputStream(out, PacketTags.LITERAL_DATA, buffer);
+
+        byte[] encName = Strings.toUTF8ByteArray(name);
+
+        writeHeader(pkOut, format, encName, modificationTime.getTime());
+
+        return new WrappedGeneratorStream(pkOut, this);
+    }
+
+    /**
+     * Close the literal data packet - this is equivalent to calling close on the stream
+     * returned by the open() method.
+     * 
+     * @throws IOException
+     */
+    public void close()
+        throws IOException
+    {
+        if (pkOut != null)
+        {
+            pkOut.finish();
+            pkOut.flush();
+            pkOut = null;
+        }
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPObjectFactory.java b/crypto/j2me/org/bouncycastle/openpgp/PGPObjectFactory.java
new file mode 100644
index 000000000..d5697e95c
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPObjectFactory.java
@@ -0,0 +1,151 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.PacketTags;
+import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator;
+import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator;
+
+/**
+ * General class for reading a PGP object stream.
+ * <p>
+ * Note: if this class finds a PGPPublicKey or a PGPSecretKey it
+ * will create a PGPPublicKeyRing, or a PGPSecretKeyRing for each
+ * key found. If all you are trying to do is read a key ring file use
+ * either PGPPublicKeyRingCollection or PGPSecretKeyRingCollection.
+ */
+public class PGPObjectFactory
+{
+    private BCPGInputStream in;
+    private KeyFingerPrintCalculator fingerPrintCalculator;
+
+    public PGPObjectFactory(
+        InputStream in)
+    {
+        this(in, new BcKeyFingerprintCalculator());
+    }
+
+    /**
+     * Create an object factor suitable for reading keys, key rings and key ring collections.
+     *
+     * @param in stream to read from
+     * @param fingerPrintCalculator  calculator to use in key finger print calculations.
+     */
+    public PGPObjectFactory(
+        InputStream              in,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+    {
+        this.in = new BCPGInputStream(in);
+        this.fingerPrintCalculator = fingerPrintCalculator;
+    }
+
+    public PGPObjectFactory(
+        byte[] bytes)
+    {
+        this(new ByteArrayInputStream(bytes));
+    }
+
+    /**
+     * Create an object factor suitable for reading keys, key rings and key ring collections.
+     *
+     * @param bytes stream to read from
+     * @param fingerPrintCalculator  calculator to use in key finger print calculations.
+     */
+    public PGPObjectFactory(
+        byte[] bytes,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+    {
+        this(new ByteArrayInputStream(bytes), fingerPrintCalculator);
+    }
+
+    /**
+     * Return the next object in the stream, or null if the end is reached.
+     * 
+     * @return Object
+     * @throws IOException on a parse error
+     */
+    public Object nextObject()
+        throws IOException
+    {
+        List l;
+
+        switch (in.nextPacketTag())
+        {
+        case -1:
+            return null;
+        case PacketTags.SIGNATURE:
+            l = new ArrayList();
+            
+            while (in.nextPacketTag() == PacketTags.SIGNATURE)
+            {
+                try
+                {
+                    l.add(new PGPSignature(in));
+                }
+                catch (PGPException e)
+                {
+                    throw new IOException("can't create signature object: " + e);
+                }
+            }
+            
+            return new PGPSignatureList((PGPSignature[])l.toArray(new PGPSignature[l.size()]));
+        case PacketTags.SECRET_KEY:
+            try
+            {
+                return new PGPSecretKeyRing(in, fingerPrintCalculator);
+            }
+            catch (PGPException e)
+            {
+                throw new IOException("can't create secret key object: " + e);
+            }
+        case PacketTags.PUBLIC_KEY:
+            return new PGPPublicKeyRing(in, fingerPrintCalculator);
+        case PacketTags.PUBLIC_SUBKEY:
+            try
+            {
+                return PGPPublicKeyRing.readSubkey(in, fingerPrintCalculator);
+            }
+            catch (PGPException e)
+            {
+                throw new IOException("processing error: " + e.getMessage());
+            }
+        case PacketTags.COMPRESSED_DATA:
+            throw new IOException("processing error: " + "compressed data not supported");
+        case PacketTags.LITERAL_DATA:
+            return new PGPLiteralData(in);
+        case PacketTags.PUBLIC_KEY_ENC_SESSION:
+        case PacketTags.SYMMETRIC_KEY_ENC_SESSION:
+            return new PGPEncryptedDataList(in);
+        case PacketTags.ONE_PASS_SIGNATURE:
+            l = new ArrayList();
+            
+            while (in.nextPacketTag() == PacketTags.ONE_PASS_SIGNATURE)
+            {
+                try
+                {
+                    l.add(new PGPOnePassSignature(in));
+                }
+                catch (PGPException e)
+                {
+                    throw new IOException("can't create one pass signature object: " + e);
+                }
+            }
+            
+            return new PGPOnePassSignatureList((PGPOnePassSignature[])l.toArray(new PGPOnePassSignature[l.size()]));
+        case PacketTags.MARKER:
+            return new PGPMarker(in);
+        case PacketTags.EXPERIMENTAL_1:
+        case PacketTags.EXPERIMENTAL_2:
+        case PacketTags.EXPERIMENTAL_3:
+        case PacketTags.EXPERIMENTAL_4:
+            return in.readPacket();
+        }
+        
+        throw new IOException("unknown object in stream: " + in.nextPacketTag());
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPOnePassSignature.java b/crypto/j2me/org/bouncycastle/openpgp/PGPOnePassSignature.java
new file mode 100644
index 000000000..a1d5b9b02
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPOnePassSignature.java
@@ -0,0 +1,227 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.OnePassSignaturePacket;
+import org.bouncycastle.openpgp.operator.PGPContentVerifier;
+import org.bouncycastle.openpgp.operator.PGPContentVerifierBuilder;
+import org.bouncycastle.openpgp.operator.PGPContentVerifierBuilderProvider;
+
+/**
+ * A one pass signature object.
+ */
+public class PGPOnePassSignature
+{
+    private OnePassSignaturePacket sigPack;
+    private int                    signatureType;
+
+    private PGPContentVerifier verifier;
+    private byte               lastb;
+    private OutputStream       sigOut;
+
+    PGPOnePassSignature(
+        BCPGInputStream    pIn)
+        throws IOException, PGPException
+    {
+        this((OnePassSignaturePacket)pIn.readPacket());
+    }
+    
+    PGPOnePassSignature(
+        OnePassSignaturePacket    sigPack)
+        throws PGPException
+    {
+        this.sigPack = sigPack;
+        this.signatureType = sigPack.getSignatureType();
+    }
+
+    /**
+     * Initialise the signature object for verification.
+     *
+     * @param verifierBuilderProvider   provider for a content verifier builder for the signature type of interest.
+     * @param pubKey  the public key to use for verification
+     * @throws PGPException if there's an issue with creating the verifier.
+     */
+    public void init(PGPContentVerifierBuilderProvider verifierBuilderProvider, PGPPublicKey pubKey)
+        throws PGPException
+    {
+        PGPContentVerifierBuilder verifierBuilder = verifierBuilderProvider.get(sigPack.getKeyAlgorithm(), sigPack.getHashAlgorithm());
+
+        verifier = verifierBuilder.build(pubKey);
+
+        lastb = 0;
+        sigOut = verifier.getOutputStream();
+    }
+
+    public void update(
+        byte    b)
+        throws PGPSignatureException
+    {
+        if (signatureType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            if (b == '\r')
+            {
+                byteUpdate((byte)'\r');
+                byteUpdate((byte)'\n');
+            }
+            else if (b == '\n')
+            {
+                if (lastb != '\r')
+                {
+                    byteUpdate((byte)'\r');
+                    byteUpdate((byte)'\n');
+                }
+            }
+            else
+            {
+                byteUpdate(b);
+            }
+
+            lastb = b;
+        }
+        else
+        {
+            byteUpdate(b);
+        }
+    }
+
+    public void update(
+        byte[]    bytes)
+        throws PGPSignatureException
+    {
+        if (signatureType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            for (int i = 0; i != bytes.length; i++)
+            {
+                this.update(bytes[i]);
+            }
+        }
+        else
+        {
+            blockUpdate(bytes, 0, bytes.length);
+        }
+    }
+    
+    public void update(
+        byte[]    bytes,
+        int       off,
+        int       length)
+        throws PGPSignatureException
+    {
+        if (signatureType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            int finish = off + length;
+            
+            for (int i = off; i != finish; i++)
+            {
+                this.update(bytes[i]);
+            }
+        }
+        else
+        {
+            blockUpdate(bytes, off, length);
+        }
+    }
+
+    private void byteUpdate(byte b)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(b);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    private void blockUpdate(byte[] block, int off, int len)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(block, off, len);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Verify the calculated signature against the passed in PGPSignature.
+     * 
+     * @param pgpSig
+     * @return boolean
+     * @throws PGPException
+     */
+    public boolean verify(
+        PGPSignature    pgpSig)
+        throws PGPException
+    {
+        try
+        {
+            sigOut.write(pgpSig.getSignatureTrailer());
+
+            sigOut.close();
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("unable to add trailer: " + e.getMessage(), e);
+        }
+
+        return verifier.verify(pgpSig.getSignature());
+    }
+    
+    public long getKeyID()
+    {
+        return sigPack.getKeyID();
+    }
+    
+    public int getSignatureType()
+    {
+        return sigPack.getSignatureType();
+    }
+
+    public int getHashAlgorithm()
+    {
+        return sigPack.getHashAlgorithm();
+    }
+
+    public int getKeyAlgorithm()
+    {
+        return sigPack.getKeyAlgorithm();
+    }
+
+    public byte[] getEncoded()
+        throws IOException
+    {
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        
+        this.encode(bOut);
+        
+        return bOut.toByteArray();
+    }
+    
+    public void encode(
+        OutputStream    outStream) 
+        throws IOException
+    {
+        BCPGOutputStream    out;
+        
+        if (outStream instanceof BCPGOutputStream)
+        {
+            out = (BCPGOutputStream)outStream;
+        }
+        else
+        {
+            out = new BCPGOutputStream(outStream);
+        }
+
+        out.writePacket(sigPack);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPPBEEncryptedData.java b/crypto/j2me/org/bouncycastle/openpgp/PGPPBEEncryptedData.java
new file mode 100644
index 000000000..a24cdc470
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPPBEEncryptedData.java
@@ -0,0 +1,141 @@
+package org.bouncycastle.openpgp;
+
+import java.io.EOFException;
+import java.io.InputStream;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.InputStreamPacket;
+import org.bouncycastle.bcpg.SymmetricEncIntegrityPacket;
+import org.bouncycastle.bcpg.SymmetricKeyEncSessionPacket;
+import org.bouncycastle.openpgp.operator.PBEDataDecryptorFactory;
+import org.bouncycastle.openpgp.operator.PGPDataDecryptor;
+import org.bouncycastle.util.io.TeeInputStream;
+
+/**
+ * A password based encryption object.
+ */
+public class PGPPBEEncryptedData
+    extends PGPEncryptedData
+{
+    SymmetricKeyEncSessionPacket    keyData;
+    
+    PGPPBEEncryptedData(
+        SymmetricKeyEncSessionPacket    keyData,
+        InputStreamPacket               encData)
+    {
+        super(encData);
+        
+        this.keyData = keyData;
+    }
+    
+    /**
+     * Return the raw input stream for the data stream.
+     * 
+     * @return InputStream
+     */
+    public InputStream getInputStream()
+    {
+        return encData.getInputStream();
+    }
+
+   /**
+     * Return the symmetric key algorithm required to decrypt the data protected by this object.
+     *
+     * @param dataDecryptorFactory   decryptor factory to use to recover the session data.
+     * @return  the integer encryption algorithm code.
+     * @throws PGPException if the session data cannot be recovered.
+     */
+    public int getSymmetricAlgorithm(
+        PBEDataDecryptorFactory dataDecryptorFactory)
+        throws PGPException
+    {
+        byte[]       key = dataDecryptorFactory.makeKeyFromPassPhrase(keyData.getEncAlgorithm(), keyData.getS2K());
+        byte[]       sessionData = dataDecryptorFactory.recoverSessionData(keyData.getEncAlgorithm(), key, keyData.getSecKeyData());
+
+        return sessionData[0];
+    }
+
+   /**
+     * Open an input stream which will provide the decrypted data protected by this object.
+     *
+     * @param dataDecryptorFactory  decryptor factory to use to recover the session data and provide the stream.
+     * @return  the resulting input stream
+     * @throws PGPException  if the session data cannot be recovered or the stream cannot be created.
+     */
+    public InputStream getDataStream(
+        PBEDataDecryptorFactory dataDecryptorFactory)
+        throws PGPException
+    {
+        try
+        {
+            int          keyAlgorithm = keyData.getEncAlgorithm();
+            byte[]       key = dataDecryptorFactory.makeKeyFromPassPhrase(keyAlgorithm, keyData.getS2K());
+            boolean      withIntegrityPacket = encData instanceof SymmetricEncIntegrityPacket;
+
+            byte[]       sessionData = dataDecryptorFactory.recoverSessionData(keyData.getEncAlgorithm(), key, keyData.getSecKeyData());
+            byte[]       sessionKey = new byte[sessionData.length - 1];
+
+            System.arraycopy(sessionData, 1, sessionKey, 0, sessionKey.length);
+
+            PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor(withIntegrityPacket, sessionData[0] & 0xff, sessionKey);
+
+            encStream = new BCPGInputStream(dataDecryptor.getInputStream(encData.getInputStream()));
+
+            if (withIntegrityPacket)
+            {
+                truncStream = new TruncatedStream(encStream);
+
+                integrityCalculator = dataDecryptor.getIntegrityCalculator();
+
+                encStream = new TeeInputStream(truncStream, integrityCalculator.getOutputStream());
+            }
+
+            byte[] iv = new byte[dataDecryptor.getBlockSize()];
+            for (int i = 0; i != iv.length; i++)
+            {
+                int    ch = encStream.read();
+
+                if (ch < 0)
+                {
+                    throw new EOFException("unexpected end of stream.");
+                }
+
+                iv[i] = (byte)ch;
+            }
+
+            int    v1 = encStream.read();
+            int    v2 = encStream.read();
+
+            if (v1 < 0 || v2 < 0)
+            {
+                throw new EOFException("unexpected end of stream.");
+            }
+
+
+            // Note: the oracle attack on "quick check" bytes is not deemed
+            // a security risk for PBE (see PGPPublicKeyEncryptedData)
+
+            boolean repeatCheckPassed = iv[iv.length - 2] == (byte) v1
+                    && iv[iv.length - 1] == (byte) v2;
+
+            // Note: some versions of PGP appear to produce 0 for the extra
+            // bytes rather than repeating the two previous bytes
+            boolean zeroesCheckPassed = v1 == 0 && v2 == 0;
+
+            if (!repeatCheckPassed && !zeroesCheckPassed)
+            {
+                throw new PGPDataValidationException("data check failed.");
+            }
+
+            return encStream;
+        }
+        catch (PGPException e)
+        {
+            throw e;
+        }
+        catch (Exception e)
+        {
+            throw new PGPException("Exception creating cipher", e);
+        }
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPPrivateKey.java b/crypto/j2me/org/bouncycastle/openpgp/PGPPrivateKey.java
new file mode 100644
index 000000000..c658e29bf
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPPrivateKey.java
@@ -0,0 +1,48 @@
+package org.bouncycastle.openpgp;
+
+import org.bouncycastle.bcpg.BCPGKey;
+import org.bouncycastle.bcpg.DSASecretBCPGKey;
+import org.bouncycastle.bcpg.ElGamalSecretBCPGKey;
+import org.bouncycastle.bcpg.PublicKeyPacket;
+import org.bouncycastle.bcpg.RSASecretBCPGKey;
+
+/**
+ * general class to contain a private key for use with other openPGP
+ * objects.
+ */
+public class PGPPrivateKey
+{
+    private long          keyID;
+    private PublicKeyPacket publicKeyPacket;
+    private BCPGKey privateKeyDataPacket;
+
+    public PGPPrivateKey(
+        long              keyID,
+        PublicKeyPacket   publicKeyPacket,
+        BCPGKey           privateKeyDataPacket)
+    {
+        this.keyID = keyID;
+        this.publicKeyPacket = publicKeyPacket;
+        this.privateKeyDataPacket = privateKeyDataPacket;
+    }
+
+    /**
+     * Return the keyID associated with the contained private key.
+     * 
+     * @return long
+     */
+    public long getKeyID()
+    {
+        return keyID;
+    }
+    
+    public PublicKeyPacket getPublicKeyPacket()
+    {
+        return publicKeyPacket;
+    }
+
+    public BCPGKey getPrivateKeyDataPacket()
+    {
+        return privateKeyDataPacket;
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKey.java b/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKey.java
new file mode 100644
index 000000000..fdb91f76a
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKey.java
@@ -0,0 +1,893 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+
+import org.bouncycastle.bcpg.BCPGKey;
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.ContainedPacket;
+import org.bouncycastle.bcpg.DSAPublicBCPGKey;
+import org.bouncycastle.bcpg.ElGamalPublicBCPGKey;
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.bcpg.PublicKeyPacket;
+import org.bouncycastle.bcpg.RSAPublicBCPGKey;
+import org.bouncycastle.bcpg.TrustPacket;
+import org.bouncycastle.bcpg.UserAttributePacket;
+import org.bouncycastle.bcpg.UserIDPacket;
+import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * general class to handle a PGP public key object.
+ */
+public class PGPPublicKey
+    implements PublicKeyAlgorithmTags
+{
+    private static final int[] MASTER_KEY_CERTIFICATION_TYPES = new int[] { PGPSignature.POSITIVE_CERTIFICATION, PGPSignature.CASUAL_CERTIFICATION, PGPSignature.NO_CERTIFICATION, PGPSignature.DEFAULT_CERTIFICATION };
+    
+    PublicKeyPacket publicPk;
+    TrustPacket     trustPk;
+    List            keySigs = new ArrayList();
+    List            ids = new ArrayList();
+    List            idTrusts = new ArrayList();
+    List            idSigs = new ArrayList();
+    
+    List            subSigs = null;
+
+    private long    keyID;
+    private byte[]  fingerprint;
+    private int     keyStrength;
+
+    private void init(KeyFingerPrintCalculator fingerPrintCalculator)
+        throws PGPException
+    {
+        BCPGKey                key = publicPk.getKey();
+
+        this.fingerprint = fingerPrintCalculator.calculateFingerprint(publicPk);
+
+        if (publicPk.getVersion() <= 3)
+        {
+            RSAPublicBCPGKey    rK = (RSAPublicBCPGKey)key;
+            
+            this.keyID = rK.getModulus().longValue();
+            this.keyStrength = rK.getModulus().bitLength();
+        }
+        else
+        {
+            this.keyID = ((long)(fingerprint[fingerprint.length - 8] & 0xff) << 56)
+                            | ((long)(fingerprint[fingerprint.length - 7] & 0xff) << 48)
+                            | ((long)(fingerprint[fingerprint.length - 6] & 0xff) << 40)
+                            | ((long)(fingerprint[fingerprint.length - 5] & 0xff) << 32)
+                            | ((long)(fingerprint[fingerprint.length - 4] & 0xff) << 24)
+                            | ((long)(fingerprint[fingerprint.length - 3] & 0xff) << 16)
+                            | ((long)(fingerprint[fingerprint.length - 2] & 0xff) << 8)
+                            | ((fingerprint[fingerprint.length - 1] & 0xff));
+            
+            if (key instanceof RSAPublicBCPGKey)
+            {
+                this.keyStrength = ((RSAPublicBCPGKey)key).getModulus().bitLength();
+            }
+            else if (key instanceof DSAPublicBCPGKey)
+            {
+                this.keyStrength = ((DSAPublicBCPGKey)key).getP().bitLength();
+            }
+            else if (key instanceof ElGamalPublicBCPGKey)
+            {
+                this.keyStrength = ((ElGamalPublicBCPGKey)key).getP().bitLength();
+            }
+        }
+    }
+    
+    /**
+     * Create a PGP public key from a packet descriptor using the passed in fingerPrintCalculator to do calculate
+     * the fingerprint and keyID.
+     *
+     * @param publicKeyPacket  packet describing the public key.
+     * @param fingerPrintCalculator calculator providing the digest support ot create the key fingerprint.
+     * @throws PGPException  if the packet is faulty, or the required calculations fail.
+     */
+    public PGPPublicKey(PublicKeyPacket publicKeyPacket, KeyFingerPrintCalculator fingerPrintCalculator)
+        throws PGPException
+    {
+        this.publicPk = publicKeyPacket;
+        this.ids = new ArrayList();
+        this.idSigs = new ArrayList();
+
+        init(fingerPrintCalculator);
+    }
+
+    /*
+     * Constructor for a sub-key.
+     */
+    PGPPublicKey(
+        PublicKeyPacket publicPk, 
+        TrustPacket     trustPk, 
+        List            sigs,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+        throws PGPException
+     {
+        this.publicPk = publicPk;
+        this.trustPk = trustPk;
+        this.subSigs = sigs;
+        
+        init(fingerPrintCalculator);
+     }
+
+    PGPPublicKey(
+        PGPPublicKey key,
+        TrustPacket trust, 
+        List        subSigs)
+    {
+        this.publicPk = key.publicPk;
+        this.trustPk = trust;
+        this.subSigs = subSigs;
+                
+        this.fingerprint = key.fingerprint;
+        this.keyID = key.keyID;
+        this.keyStrength = key.keyStrength;
+    }
+    
+    /**
+     * Copy constructor.
+     * @param pubKey the public key to copy.
+     */
+    PGPPublicKey(
+        PGPPublicKey    pubKey)
+     {
+        this.publicPk = pubKey.publicPk;
+        
+        this.keySigs = new ArrayList(pubKey.keySigs);
+        this.ids = new ArrayList(pubKey.ids);
+        this.idTrusts = new ArrayList(pubKey.idTrusts);
+        this.idSigs = new ArrayList(pubKey.idSigs.size());
+        for (int i = 0; i != pubKey.idSigs.size(); i++)
+        {
+            this.idSigs.add(new ArrayList((ArrayList)pubKey.idSigs.get(i)));
+        }
+       
+        if (pubKey.subSigs != null)
+        {
+            this.subSigs = new ArrayList(pubKey.subSigs.size());
+            for (int i = 0; i != pubKey.subSigs.size(); i++)
+            {
+                this.subSigs.add(pubKey.subSigs.get(i));
+            }
+        }
+        
+        this.fingerprint = pubKey.fingerprint;
+        this.keyID = pubKey.keyID;
+        this.keyStrength = pubKey.keyStrength;
+     }
+
+    PGPPublicKey(
+        PublicKeyPacket publicPk,
+        TrustPacket     trustPk,
+        List            keySigs,
+        List            ids,
+        List            idTrusts,
+        List            idSigs,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+        throws PGPException
+    {
+        this.publicPk = publicPk;
+        this.trustPk = trustPk;
+        this.keySigs = keySigs;
+        this.ids = ids;
+        this.idTrusts = idTrusts;
+        this.idSigs = idSigs;
+    
+        init(fingerPrintCalculator);
+    }
+    
+    /**
+     * @return the version of this key.
+     */
+    public int getVersion()
+    {
+        return publicPk.getVersion();
+    }
+    
+    /**
+     * @return creation time of key.
+     */
+    public Date getCreationTime()
+    {
+        return publicPk.getTime();
+    }
+    
+    /**
+     * @return number of valid days from creation time - zero means no
+     * expiry.
+     */
+    public int getValidDays()
+    {
+        if (publicPk.getVersion() > 3)
+        {
+            return (int)(this.getValidSeconds() / (24 * 60 * 60));
+        }
+        else
+        {
+            return publicPk.getValidDays();
+        }
+    }
+
+    /**
+     * Return the trust data associated with the public key, if present.
+     * @return a byte array with trust data, null otherwise.
+     */
+    public byte[] getTrustData()
+    {
+        if (trustPk == null)
+        {
+            return null;
+        }
+
+        return Arrays.clone(trustPk.getLevelAndTrustAmount());
+    }
+
+    /**
+     * @return number of valid seconds from creation time - zero means no
+     * expiry.
+     */
+    public long getValidSeconds()
+    {
+        if (publicPk.getVersion() > 3)
+        {
+            if (this.isMasterKey())
+            {
+                for (int i = 0; i != MASTER_KEY_CERTIFICATION_TYPES.length; i++)
+                {
+                    long seconds = getExpirationTimeFromSig(true, MASTER_KEY_CERTIFICATION_TYPES[i]);
+                    
+                    if (seconds >= 0)
+                    {
+                        return seconds;
+                    }
+                }
+            }
+            else
+            {
+                long seconds = getExpirationTimeFromSig(false, PGPSignature.SUBKEY_BINDING);
+                
+                if (seconds >= 0)
+                {
+                    return seconds;
+                }
+            }
+            
+            return 0;
+        }
+        else
+        {
+            return (long)publicPk.getValidDays() * 24 * 60 * 60;
+        }
+    }
+
+    private long getExpirationTimeFromSig(
+        boolean selfSigned,
+        int signatureType) 
+    {
+        Iterator signatures = this.getSignaturesOfType(signatureType);
+        long     expiryTime = -1;
+
+        while (signatures.hasNext())
+        {
+            PGPSignature sig = (PGPSignature)signatures.next();
+
+            if (!selfSigned || sig.getKeyID() == this.getKeyID())
+            {
+                PGPSignatureSubpacketVector hashed = sig.getHashedSubPackets();
+                
+                if (hashed != null)
+                {
+                    long current = hashed.getKeyExpirationTime();
+
+                    if (current == 0 || current > expiryTime)
+                    {
+                        expiryTime = current;
+                    }
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+        }
+        
+        return expiryTime;
+    }
+    
+    /**
+     * Return the keyID associated with the public key.
+     * 
+     * @return long
+     */
+    public long getKeyID()
+    {
+        return keyID;
+    }
+    
+    /**
+     * Return the fingerprint of the key.
+     * 
+     * @return key fingerprint.
+     */
+    public byte[] getFingerprint()
+    {
+        byte[]    tmp = new byte[fingerprint.length];
+        
+        System.arraycopy(fingerprint, 0, tmp, 0, tmp.length);
+        
+        return tmp;
+    }
+    
+    /**
+     * Return true if this key has an algorithm type that makes it suitable to use for encryption.
+     * <p>
+     * Note: with version 4 keys KeyFlags subpackets should also be considered when present for
+     * determining the preferred use of the key.
+     *
+     * @return true if the key algorithm is suitable for encryption.
+     */
+    public boolean isEncryptionKey()
+    {
+        int algorithm = publicPk.getAlgorithm();
+
+        return ((algorithm == RSA_GENERAL) || (algorithm == RSA_ENCRYPT)
+                || (algorithm == ELGAMAL_ENCRYPT) || (algorithm == ELGAMAL_GENERAL));
+    }
+
+    /**
+     * Return true if this is a master key.
+     * @return true if a master key.
+     */
+    public boolean isMasterKey()
+    {
+        return (subSigs == null);
+    }
+    
+    /**
+     * Return the algorithm code associated with the public key.
+     * 
+     * @return int
+     */
+    public int getAlgorithm()
+    {
+        return publicPk.getAlgorithm();
+    }
+    
+    /**
+     * Return the strength of the key in bits.
+     * 
+     * @return bit strenght of key.
+     */
+    public int getBitStrength()
+    {
+        return keyStrength;
+    }
+
+    /**
+     * Return any userIDs associated with the key.
+     * 
+     * @return an iterator of Strings.
+     */
+    public Iterator getUserIDs()
+    {
+        List    temp = new ArrayList();
+        
+        for (int i = 0; i != ids.size(); i++)
+        {
+            if (ids.get(i) instanceof String)
+            {
+                temp.add(ids.get(i));
+            }
+        }
+        
+        return temp.iterator();
+    }
+    
+    /**
+     * Return any user attribute vectors associated with the key.
+     * 
+     * @return an iterator of PGPUserAttributeSubpacketVector objects.
+     */
+    public Iterator getUserAttributes()
+    {
+        List    temp = new ArrayList();
+        
+        for (int i = 0; i != ids.size(); i++)
+        {
+            if (ids.get(i) instanceof PGPUserAttributeSubpacketVector)
+            {
+                temp.add(ids.get(i));
+            }
+        }
+        
+        return temp.iterator();
+    }
+    
+    /**
+     * Return any signatures associated with the passed in id.
+     * 
+     * @param id the id to be matched.
+     * @return an iterator of PGPSignature objects.
+     */
+    public Iterator getSignaturesForID(
+        String   id)
+    {
+        for (int i = 0; i != ids.size(); i++)
+        {
+            if (id.equals(ids.get(i)))
+            {
+                return ((ArrayList)idSigs.get(i)).iterator();
+            }
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Return an iterator of signatures associated with the passed in user attributes.
+     * 
+     * @param userAttributes the vector of user attributes to be matched.
+     * @return an iterator of PGPSignature objects.
+     */
+    public Iterator getSignaturesForUserAttribute(
+        PGPUserAttributeSubpacketVector    userAttributes)
+    {
+        for (int i = 0; i != ids.size(); i++)
+        {
+            if (userAttributes.equals(ids.get(i)))
+            {
+                return ((ArrayList)idSigs.get(i)).iterator();
+            }
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Return signatures of the passed in type that are on this key.
+     * 
+     * @param signatureType the type of the signature to be returned.
+     * @return an iterator (possibly empty) of signatures of the given type.
+     */
+    public Iterator getSignaturesOfType(
+        int signatureType)
+    {
+        List        l = new ArrayList();
+        Iterator    it = this.getSignatures();
+        
+        while (it.hasNext())
+        {
+            PGPSignature    sig = (PGPSignature)it.next();
+            
+            if (sig.getSignatureType() == signatureType)
+            {
+                l.add(sig);
+            }
+        }
+        
+        return l.iterator();
+    }
+    
+    /**
+     * Return all signatures/certifications associated with this key.
+     * 
+     * @return an iterator (possibly empty) with all signatures/certifications.
+     */
+    public Iterator getSignatures()
+    {
+        if (subSigs == null)
+        {
+            List sigs = new ArrayList();
+
+            sigs.addAll(keySigs);
+
+            for (int i = 0; i != idSigs.size(); i++)
+            {
+                sigs.addAll((Collection)idSigs.get(i));
+            }
+            
+            return sigs.iterator();
+        }
+        else
+        {
+            return subSigs.iterator();
+        }
+    }
+
+    public PublicKeyPacket getPublicKeyPacket()
+    {
+        return publicPk;
+    }
+
+    public byte[] getEncoded() 
+        throws IOException
+    {
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        
+        this.encode(bOut);
+        
+        return bOut.toByteArray();
+    }
+    
+    public void encode(
+        OutputStream    outStream) 
+        throws IOException
+    {
+        BCPGOutputStream    out;
+        
+        if (outStream instanceof BCPGOutputStream)
+        {
+            out = (BCPGOutputStream)outStream;
+        }
+        else
+        {
+            out = new BCPGOutputStream(outStream);
+        }
+        
+        out.writePacket(publicPk);
+        if (trustPk != null)
+        {
+            out.writePacket(trustPk);
+        }
+        
+        if (subSigs == null)    // not a sub-key
+        {
+            for (int i = 0; i != keySigs.size(); i++)
+            {
+                ((PGPSignature)keySigs.get(i)).encode(out);
+            }
+            
+            for (int i = 0; i != ids.size(); i++)
+            {
+                if (ids.get(i) instanceof String)
+                {
+                    String    id = (String)ids.get(i);
+                    
+                    out.writePacket(new UserIDPacket(id));
+                }
+                else
+                {
+                    PGPUserAttributeSubpacketVector    v = (PGPUserAttributeSubpacketVector)ids.get(i);
+
+                    out.writePacket(new UserAttributePacket(v.toSubpacketArray()));
+                }
+                
+                if (idTrusts.get(i) != null)
+                {
+                    out.writePacket((ContainedPacket)idTrusts.get(i));
+                }
+                
+                List    sigs = (List)idSigs.get(i);
+                for (int j = 0; j != sigs.size(); j++)
+                {
+                    ((PGPSignature)sigs.get(j)).encode(out);
+                }
+            }
+        }
+        else
+        {
+            for (int j = 0; j != subSigs.size(); j++)
+            {
+                ((PGPSignature)subSigs.get(j)).encode(out);
+            }
+        }
+    }
+    
+    /**
+     * Check whether this (sub)key has a revocation signature on it.
+     * 
+     * @return boolean indicating whether this (sub)key has been revoked.
+     */
+    public boolean isRevoked()
+    {
+        int ns = 0;
+        boolean revoked = false;
+
+        if (this.isMasterKey())    // Master key
+        {
+            while (!revoked && (ns < keySigs.size()))
+            {
+                if (((PGPSignature)keySigs.get(ns++)).getSignatureType() == PGPSignature.KEY_REVOCATION)
+                {
+                    revoked = true;
+                }
+            }
+        }
+        else                    // Sub-key
+        {
+            while (!revoked && (ns < subSigs.size()))
+            {
+                if (((PGPSignature)subSigs.get(ns++)).getSignatureType() == PGPSignature.SUBKEY_REVOCATION)
+                {
+                    revoked = true;
+                }
+            }
+        }
+
+        return revoked;
+    }
+
+
+    /**
+     * Add a certification for an id to the given public key.
+     * 
+     * @param key the key the certification is to be added to.
+     * @param id the id the certification is associated with.
+     * @param certification the new certification.
+     * @return the re-certified key.
+     */
+    public static PGPPublicKey addCertification(
+        PGPPublicKey    key,
+        String          id,
+        PGPSignature    certification)
+    {
+        return addCert(key, id, certification);
+    }
+
+    /**
+     * Add a certification for the given UserAttributeSubpackets to the given public key.
+     *
+     * @param key the key the certification is to be added to.
+     * @param userAttributes the attributes the certification is associated with.
+     * @param certification the new certification.
+     * @return the re-certified key.
+     */
+    public static PGPPublicKey addCertification(
+        PGPPublicKey                    key,
+        PGPUserAttributeSubpacketVector userAttributes,
+        PGPSignature                    certification)
+    {
+        return addCert(key, userAttributes, certification);
+    }
+
+    private static PGPPublicKey addCert(
+        PGPPublicKey  key,
+        Object        id,
+        PGPSignature  certification)
+    {
+        PGPPublicKey    returnKey = new PGPPublicKey(key);
+        List            sigList = null;
+
+        for (int i = 0; i != returnKey.ids.size(); i++)
+        {
+            if (id.equals(returnKey.ids.get(i)))
+            {
+                sigList = (List)returnKey.idSigs.get(i);
+            }
+        }
+
+        if (sigList != null)
+        {
+            sigList.add(certification);
+        }
+        else
+        {
+            sigList = new ArrayList();
+
+            sigList.add(certification);
+            returnKey.ids.add(id);
+            returnKey.idTrusts.add(null);
+            returnKey.idSigs.add(sigList);
+        }
+
+        return returnKey;
+    }
+
+    /**
+     * Remove any certifications associated with a given user attribute subpacket
+     *  on a key.
+     * 
+     * @param key the key the certifications are to be removed from.
+     * @param userAttributes the attributes to be removed.
+     * @return the re-certified key, null if the user attribute subpacket was not found on the key.
+     */
+    public static PGPPublicKey removeCertification(
+        PGPPublicKey                    key,
+        PGPUserAttributeSubpacketVector userAttributes)
+    {
+        return removeCert(key, userAttributes);
+    }
+
+    /**
+     * Remove any certifications associated with a given id on a key.
+     *
+     * @param key the key the certifications are to be removed from.
+     * @param id the id that is to be removed.
+     * @return the re-certified key, null if the id was not found on the key.
+     */
+    public static PGPPublicKey removeCertification(
+        PGPPublicKey    key,
+        String          id)
+    {
+        return removeCert(key, id);
+    }
+
+    private static PGPPublicKey removeCert(
+        PGPPublicKey    key,
+        Object          id)
+    {
+        PGPPublicKey    returnKey = new PGPPublicKey(key);
+        boolean         found = false;
+
+        for (int i = 0; i < returnKey.ids.size(); i++)
+        {
+            if (id.equals(returnKey.ids.get(i)))
+            {
+                found = true;
+                returnKey.ids.remove(i);
+                returnKey.idTrusts.remove(i);
+                returnKey.idSigs.remove(i);
+            }
+        }
+
+        if (!found)
+        {
+            return null;
+        }
+
+        return returnKey;
+    }
+
+    /**
+     * Remove a certification associated with a given id on a key.
+     * 
+     * @param key the key the certifications are to be removed from.
+     * @param id the id that the certification is to be removed from.
+     * @param certification the certification to be removed.
+     * @return the re-certified key, null if the certification was not found.
+     */
+    public static PGPPublicKey removeCertification(
+        PGPPublicKey    key,
+        String          id,
+        PGPSignature    certification)
+    {
+        return removeCert(key, id, certification);
+    }
+
+    /**
+     * Remove a certification associated with a given user attributes on a key.
+     *
+     * @param key the key the certifications are to be removed from.
+     * @param userAttributes the user attributes that the certification is to be removed from.
+     * @param certification the certification to be removed.
+     * @return the re-certified key, null if the certification was not found.
+     */
+    public static PGPPublicKey removeCertification(
+        PGPPublicKey                     key,
+        PGPUserAttributeSubpacketVector  userAttributes,
+        PGPSignature                     certification)
+    {
+        return removeCert(key, userAttributes, certification);
+    }
+
+    private static PGPPublicKey removeCert(
+        PGPPublicKey    key,
+        Object          id,
+        PGPSignature    certification)
+    {
+        PGPPublicKey    returnKey = new PGPPublicKey(key);
+        boolean         found = false;
+
+        for (int i = 0; i < returnKey.ids.size(); i++)
+        {
+            if (id.equals(returnKey.ids.get(i)))
+            {
+                found = ((List)returnKey.idSigs.get(i)).remove(certification);
+            }
+        }
+
+        if (!found)
+        {
+            return null;
+        }
+
+        return returnKey;
+    }
+
+    /**
+     * Add a revocation or some other key certification to a key.
+     * 
+     * @param key the key the revocation is to be added to.
+     * @param certification the key signature to be added.
+     * @return the new changed public key object.
+     */
+    public static PGPPublicKey addCertification(
+        PGPPublicKey    key,
+        PGPSignature    certification)
+    {
+        if (key.isMasterKey())
+        {
+            if (certification.getSignatureType() == PGPSignature.SUBKEY_REVOCATION)
+            {
+                throw new IllegalArgumentException("signature type incorrect for master key revocation.");
+            }
+        }
+        else
+        {
+            if (certification.getSignatureType() == PGPSignature.KEY_REVOCATION)
+            {
+                throw new IllegalArgumentException("signature type incorrect for sub-key revocation.");
+            }
+        }
+
+        PGPPublicKey    returnKey = new PGPPublicKey(key);
+        
+        if (returnKey.subSigs != null)
+        {
+            returnKey.subSigs.add(certification);
+        }
+        else
+        {
+            returnKey.keySigs.add(certification);
+        }
+        
+        return returnKey;
+    }
+
+    /**
+     * Remove a certification from the key.
+     *
+     * @param key the key the certifications are to be removed from.
+     * @param certification the certification to be removed.
+     * @return the modified key, null if the certification was not found.
+     */
+    public static PGPPublicKey removeCertification(
+        PGPPublicKey    key,
+        PGPSignature    certification)
+    {
+        PGPPublicKey    returnKey = new PGPPublicKey(key);
+        boolean         found;
+
+        if (returnKey.subSigs != null)
+        {
+            found = returnKey.subSigs.remove(certification);
+        }
+        else
+        {
+            found = returnKey.keySigs.remove(certification);
+        }
+
+        if (!found)
+        {
+            for (Iterator it = key.getUserIDs(); it.hasNext();)
+            {
+                String id = (String)it.next();
+                for (Iterator sIt = key.getSignaturesForID(id); sIt.hasNext();)
+                {
+                    if (certification == sIt.next())
+                    {
+                        found = true;
+                        returnKey = PGPPublicKey.removeCertification(returnKey, id, certification);
+                    }
+                }
+            }
+
+            if (!found)
+            {
+                for (Iterator it = key.getUserAttributes(); it.hasNext();)
+                {
+                    PGPUserAttributeSubpacketVector id = (PGPUserAttributeSubpacketVector)it.next();
+                    for (Iterator sIt = key.getSignaturesForUserAttribute(id); sIt.hasNext();)
+                    {
+                        if (certification == sIt.next())
+                        {
+                            found = true;
+                            returnKey = PGPPublicKey.removeCertification(returnKey, id, certification);
+                        }
+                    }
+                }
+            }
+        }
+
+        return returnKey;
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java b/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java
new file mode 100644
index 000000000..1dde086b4
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java
@@ -0,0 +1,167 @@
+package org.bouncycastle.openpgp;
+
+import java.io.EOFException;
+import java.io.InputStream;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.InputStreamPacket;
+import org.bouncycastle.bcpg.PublicKeyEncSessionPacket;
+import org.bouncycastle.bcpg.SymmetricEncIntegrityPacket;
+import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
+import org.bouncycastle.openpgp.operator.PGPDataDecryptor;
+import org.bouncycastle.openpgp.operator.PublicKeyDataDecryptorFactory;
+import org.bouncycastle.util.io.TeeInputStream;
+
+/**
+ * A public key encrypted data object.
+ */
+public class PGPPublicKeyEncryptedData
+    extends PGPEncryptedData
+{    
+    PublicKeyEncSessionPacket        keyData;
+    
+    PGPPublicKeyEncryptedData(
+        PublicKeyEncSessionPacket    keyData,
+        InputStreamPacket            encData)
+    {
+        super(encData);
+        
+        this.keyData = keyData;
+    }
+
+    private boolean confirmCheckSum(
+        byte[]    sessionInfo)
+    {
+        int    check = 0;
+        
+        for (int i = 1; i != sessionInfo.length - 2; i++)
+        {
+            check += sessionInfo[i] & 0xff;
+        }
+        
+        return (sessionInfo[sessionInfo.length - 2] == (byte)(check >> 8))
+                    && (sessionInfo[sessionInfo.length - 1] == (byte)(check));
+    }
+    
+    /**
+     * Return the keyID for the key used to encrypt the data.
+     * 
+     * @return long
+     */
+    public long getKeyID()
+    {
+        return keyData.getKeyID();
+    }
+
+    /**
+     * Return the symmetric key algorithm required to decrypt the data protected by this object.
+     *
+     * @param dataDecryptorFactory   decryptor factory to use to recover the session data.
+     * @return  the integer encryption algorithm code.
+     * @throws PGPException if the session data cannot be recovered.
+     */
+    public int getSymmetricAlgorithm(
+        PublicKeyDataDecryptorFactory dataDecryptorFactory)
+        throws PGPException
+    {
+        byte[] plain = dataDecryptorFactory.recoverSessionData(keyData.getAlgorithm(), keyData.getEncSessionKey());
+
+        return plain[0];
+    }
+
+    /**
+     * Open an input stream which will provide the decrypted data protected by this object.
+     *
+     * @param dataDecryptorFactory  decryptor factory to use to recover the session data and provide the stream.
+     * @return  the resulting input stream
+     * @throws PGPException  if the session data cannot be recovered or the stream cannot be created.
+     */
+    public InputStream getDataStream(
+        PublicKeyDataDecryptorFactory dataDecryptorFactory)
+        throws PGPException
+    {
+        byte[] sessionData = dataDecryptorFactory.recoverSessionData(keyData.getAlgorithm(), keyData.getEncSessionKey());
+
+        if (!confirmCheckSum(sessionData))
+        {
+            throw new PGPKeyValidationException("key checksum failed");
+        }
+
+        if (sessionData[0] != SymmetricKeyAlgorithmTags.NULL)
+        {
+            try
+            {
+                boolean      withIntegrityPacket = encData instanceof SymmetricEncIntegrityPacket;
+                byte[]       sessionKey = new byte[sessionData.length - 3];
+
+                System.arraycopy(sessionData, 1, sessionKey, 0, sessionKey.length);
+
+                PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor(withIntegrityPacket, sessionData[0] & 0xff, sessionKey);
+
+                encStream = new BCPGInputStream(dataDecryptor.getInputStream(encData.getInputStream()));
+
+                if (withIntegrityPacket)
+                {
+                    truncStream = new TruncatedStream(encStream);
+
+                    integrityCalculator = dataDecryptor.getIntegrityCalculator();
+
+                    encStream = new TeeInputStream(truncStream, integrityCalculator.getOutputStream());
+                }
+
+                byte[] iv = new byte[dataDecryptor.getBlockSize()];
+
+                for (int i = 0; i != iv.length; i++)
+                {
+                    int    ch = encStream.read();
+
+                    if (ch < 0)
+                    {
+                        throw new EOFException("unexpected end of stream.");
+                    }
+
+                    iv[i] = (byte)ch;
+                }
+
+                int    v1 = encStream.read();
+                int    v2 = encStream.read();
+
+                if (v1 < 0 || v2 < 0)
+                {
+                    throw new EOFException("unexpected end of stream.");
+                }
+
+                //
+                // some versions of PGP appear to produce 0 for the extra
+                // bytes rather than repeating the two previous bytes
+                //
+                /*
+                             * Commented out in the light of the oracle attack.
+                            if (iv[iv.length - 2] != (byte)v1 && v1 != 0)
+                            {
+                                throw new PGPDataValidationException("data check failed.");
+                            }
+
+                            if (iv[iv.length - 1] != (byte)v2 && v2 != 0)
+                            {
+                                throw new PGPDataValidationException("data check failed.");
+                            }
+                            */
+
+                return encStream;
+            }
+            catch (PGPException e)
+            {
+                throw e;
+            }
+            catch (Exception e)
+            {
+                throw new PGPException("Exception starting decryption", e);
+            }
+        }
+        else
+        {
+            return encData.getInputStream();
+        }
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKeyRing.java b/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKeyRing.java
new file mode 100644
index 000000000..f39bfd1a5
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPPublicKeyRing.java
@@ -0,0 +1,252 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.PacketTags;
+import org.bouncycastle.bcpg.PublicKeyPacket;
+import org.bouncycastle.bcpg.TrustPacket;
+import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator;
+
+/**
+ * Class to hold a single master public key and its subkeys.
+ * <p>
+ * 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.
+ */
+public class PGPPublicKeyRing
+    extends PGPKeyRing
+{
+    List keys;
+
+    public PGPPublicKeyRing(
+        byte[]    encoding,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+        throws IOException
+    {
+        this(new ByteArrayInputStream(encoding), fingerPrintCalculator);
+    }
+
+    /**
+     * @param pubKeys
+     */
+    PGPPublicKeyRing(
+        List pubKeys)
+    {
+        this.keys = pubKeys;
+    }
+
+    public PGPPublicKeyRing(
+        InputStream    in,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+        throws IOException
+    {
+        this.keys = new ArrayList();
+
+        BCPGInputStream pIn = wrap(in);
+
+        int initialTag = pIn.nextPacketTag();
+        if (initialTag != PacketTags.PUBLIC_KEY && initialTag != PacketTags.PUBLIC_SUBKEY)
+        {
+            throw new IOException(
+                "public key ring doesn't start with public key tag: " +
+                "tag 0x" + Integer.toHexString(initialTag));
+        }
+
+        PublicKeyPacket pubPk = (PublicKeyPacket)pIn.readPacket();
+        TrustPacket     trustPk = readOptionalTrustPacket(pIn);
+
+        // direct signatures and revocations
+        List keySigs = readSignaturesAndTrust(pIn);
+
+        List ids = new ArrayList();
+        List idTrusts = new ArrayList();
+        List idSigs = new ArrayList();
+        readUserIDs(pIn, ids, idTrusts, idSigs);
+
+        try
+        {
+            keys.add(new PGPPublicKey(pubPk, trustPk, keySigs, ids, idTrusts, idSigs, fingerPrintCalculator));
+
+            // Read subkeys
+            while (pIn.nextPacketTag() == PacketTags.PUBLIC_SUBKEY)
+            {
+                keys.add(readSubkey(pIn, fingerPrintCalculator));
+            }
+        }
+        catch (PGPException e)
+        {
+            throw new IOException("processing exception: " + e.toString());
+        }
+    }
+
+    /**
+     * Return the first public key in the ring.
+     * 
+     * @return PGPPublicKey
+     */
+    public PGPPublicKey getPublicKey()
+    {
+        return (PGPPublicKey)keys.get(0);
+    }
+    
+    /**
+     * Return the public key referred to by the passed in keyID if it
+     * is present.
+     * 
+     * @param keyID
+     * @return PGPPublicKey
+     */
+    public PGPPublicKey getPublicKey(
+        long        keyID)
+    {    
+        for (int i = 0; i != keys.size(); i++)
+        {
+            PGPPublicKey    k = (PGPPublicKey)keys.get(i);
+            
+            if (keyID == k.getKeyID())
+            {
+                return k;
+            }
+        }
+    
+        return null;
+    }
+    
+    /**
+     * Return an iterator containing all the public keys.
+     * 
+     * @return Iterator
+     */
+    public Iterator getPublicKeys()
+    {
+        return Collections.unmodifiableList(keys).iterator();
+    }
+    
+    public byte[] getEncoded() 
+        throws IOException
+    {
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        
+        this.encode(bOut);
+        
+        return bOut.toByteArray();
+    }
+    
+    public void encode(
+        OutputStream    outStream) 
+        throws IOException
+    {
+        for (int i = 0; i != keys.size(); i++)
+        {
+            PGPPublicKey    k = (PGPPublicKey)keys.get(i);
+            
+            k.encode(outStream);
+        }
+    }
+    
+    /**
+     * Returns a new key ring with the public key passed in
+     * either added or replacing an existing one.
+     * 
+     * @param pubRing the public key ring to be modified
+     * @param pubKey the public key to be inserted.
+     * @return a new keyRing
+     */
+    public static PGPPublicKeyRing insertPublicKey(
+        PGPPublicKeyRing  pubRing,
+        PGPPublicKey      pubKey)
+    {
+        List       keys = new ArrayList(pubRing.keys);
+        boolean    found = false;
+        boolean    masterFound = false;
+
+        for (int i = 0; i != keys.size();i++)
+        {
+            PGPPublicKey   key = (PGPPublicKey)keys.get(i);
+            
+            if (key.getKeyID() == pubKey.getKeyID())
+            {
+                found = true;
+                keys.set(i, pubKey);
+            }
+            if (key.isMasterKey())
+            {
+                masterFound = true;
+            }
+        }
+
+        if (!found)
+        {
+            if (pubKey.isMasterKey())
+            {
+                if (masterFound)
+                {
+                    throw new IllegalArgumentException("cannot add a master key to a ring that already has one");
+                }
+
+                keys.add(0, pubKey);
+            }
+            else
+            {
+                keys.add(pubKey);
+            }
+        }
+        
+        return new PGPPublicKeyRing(keys);
+    }
+    
+    /**
+     * Returns a new key ring with the public key passed in
+     * removed from the key ring.
+     * 
+     * @param pubRing the public key ring to be modified
+     * @param pubKey the public key to be removed.
+     * @return a new keyRing, null if pubKey is not found.
+     */
+    public static PGPPublicKeyRing removePublicKey(
+        PGPPublicKeyRing  pubRing,
+        PGPPublicKey      pubKey)
+    {
+        List       keys = new ArrayList(pubRing.keys);
+        boolean    found = false;
+        
+        for (int i = 0; i < keys.size();i++)
+        {
+            PGPPublicKey   key = (PGPPublicKey)keys.get(i);
+            
+            if (key.getKeyID() == pubKey.getKeyID())
+            {
+                found = true;
+                keys.remove(i);
+            }
+        }
+        
+        if (!found)
+        {
+            return null;
+        }
+        
+        return new PGPPublicKeyRing(keys);
+    }
+
+    static PGPPublicKey readSubkey(BCPGInputStream in, KeyFingerPrintCalculator fingerPrintCalculator)
+        throws IOException, PGPException
+    {
+        PublicKeyPacket pk = (PublicKeyPacket)in.readPacket();
+        TrustPacket     kTrust = readOptionalTrustPacket(in);
+
+        // PGP 8 actually leaves out the signature.
+        List sigList = readSignaturesAndTrust(in);
+
+        return new PGPPublicKey(pk, kTrust, sigList, fingerPrintCalculator);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPSecretKey.java b/crypto/j2me/org/bouncycastle/openpgp/PGPSecretKey.java
new file mode 100644
index 000000000..7ee6cf5a5
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPSecretKey.java
@@ -0,0 +1,627 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.BCPGObject;
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.ContainedPacket;
+import org.bouncycastle.bcpg.DSASecretBCPGKey;
+import org.bouncycastle.bcpg.ElGamalSecretBCPGKey;
+import org.bouncycastle.bcpg.HashAlgorithmTags;
+import org.bouncycastle.bcpg.PublicKeyPacket;
+import org.bouncycastle.bcpg.RSASecretBCPGKey;
+import org.bouncycastle.bcpg.S2K;
+import org.bouncycastle.bcpg.SecretKeyPacket;
+import org.bouncycastle.bcpg.SecretSubkeyPacket;
+import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
+import org.bouncycastle.bcpg.UserAttributePacket;
+import org.bouncycastle.bcpg.UserIDPacket;
+import org.bouncycastle.openpgp.operator.PBESecretKeyDecryptor;
+import org.bouncycastle.openpgp.operator.PBESecretKeyEncryptor;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.PGPDigestCalculator;
+
+/**
+ * general class to handle a PGP secret key object.
+ */
+public class PGPSecretKey
+{    
+    SecretKeyPacket secret;
+    PGPPublicKey    pub;
+
+    PGPSecretKey(
+        SecretKeyPacket secret,
+        PGPPublicKey    pub)
+    {
+        this.secret = secret;
+        this.pub = pub;
+    }
+    
+    PGPSecretKey(
+        PGPPrivateKey   privKey,
+        PGPPublicKey    pubKey,
+        PGPDigestCalculator checksumCalculator,
+        PBESecretKeyEncryptor keyEncryptor)
+        throws PGPException
+    {
+        this(privKey, pubKey, checksumCalculator, false, keyEncryptor);
+    }
+    
+    PGPSecretKey(
+        PGPPrivateKey   privKey,
+        PGPPublicKey    pubKey,
+        PGPDigestCalculator checksumCalculator,
+        boolean         isMasterKey,
+        PBESecretKeyEncryptor keyEncryptor)
+        throws PGPException
+    {
+        this.pub = pubKey;
+
+        BCPGObject      secKey = (BCPGObject)privKey.getPrivateKeyDataPacket();
+
+        try
+        {
+            ByteArrayOutputStream   bOut = new ByteArrayOutputStream();
+            BCPGOutputStream        pOut = new BCPGOutputStream(bOut);
+            
+            pOut.writeObject(secKey);
+            
+            byte[]    keyData = bOut.toByteArray();
+
+            pOut.write(checksum(checksumCalculator, keyData, keyData.length));
+
+            int encAlgorithm = keyEncryptor.getAlgorithm();
+
+            if (encAlgorithm != SymmetricKeyAlgorithmTags.NULL)
+            {
+                keyData = bOut.toByteArray(); // include checksum
+
+                byte[] encData = keyEncryptor.encryptKeyData(keyData, 0, keyData.length);
+                byte[] iv = keyEncryptor.getCipherIV();
+
+                S2K    s2k = keyEncryptor.getS2K();
+
+                int s2kUsage;
+
+                if (checksumCalculator != null)
+                {
+                    if (checksumCalculator.getAlgorithm() != HashAlgorithmTags.SHA1)
+                    {
+                        throw new PGPException("only SHA1 supported for key checksum calculations.");
+                    }
+                    s2kUsage = SecretKeyPacket.USAGE_SHA1;
+                }
+                else
+                {
+                    s2kUsage = SecretKeyPacket.USAGE_CHECKSUM;
+                }
+
+                if (isMasterKey)
+                {
+                    this.secret = new SecretKeyPacket(pub.publicPk, encAlgorithm, s2kUsage, s2k, iv, encData);
+                }
+                else
+                {
+                    this.secret = new SecretSubkeyPacket(pub.publicPk, encAlgorithm, s2kUsage, s2k, iv, encData);
+                }
+            }
+            else
+            {
+                if (isMasterKey)
+                {
+                    this.secret = new SecretKeyPacket(pub.publicPk, encAlgorithm, null, null, bOut.toByteArray());
+                }
+                else
+                {
+                    this.secret = new SecretSubkeyPacket(pub.publicPk, encAlgorithm, null, null, bOut.toByteArray());
+                }
+            }
+        }
+        catch (PGPException e)
+        {
+            throw e;
+        }
+        catch (Exception e)
+        {
+            throw new PGPException("Exception encrypting key", e);
+        }
+    }
+
+    public PGPSecretKey(
+        int                         certificationLevel,
+        PGPKeyPair                  keyPair,
+        String                      id,
+        PGPSignatureSubpacketVector hashedPcks,
+        PGPSignatureSubpacketVector unhashedPcks,
+        PGPContentSignerBuilder     certificationSignerBuilder,
+        PBESecretKeyEncryptor       keyEncryptor)
+        throws PGPException
+    {
+        this(certificationLevel, keyPair, id, null, hashedPcks, unhashedPcks, certificationSignerBuilder, keyEncryptor);
+    }
+
+    public PGPSecretKey(
+        int                         certificationLevel,
+        PGPKeyPair                  keyPair,
+        String                      id,
+        PGPDigestCalculator         checksumCalculator,
+        PGPSignatureSubpacketVector hashedPcks,
+        PGPSignatureSubpacketVector unhashedPcks,
+        PGPContentSignerBuilder     certificationSignerBuilder,
+        PBESecretKeyEncryptor       keyEncryptor)
+        throws PGPException
+    {
+        this(keyPair.getPrivateKey(), certifiedPublicKey(certificationLevel, keyPair, id, hashedPcks, unhashedPcks, certificationSignerBuilder), checksumCalculator, true, keyEncryptor);
+    }
+
+    private static PGPPublicKey certifiedPublicKey(
+        int certificationLevel,
+        PGPKeyPair keyPair,
+        String id,
+        PGPSignatureSubpacketVector hashedPcks,
+        PGPSignatureSubpacketVector unhashedPcks,
+        PGPContentSignerBuilder     certificationSignerBuilder)
+        throws PGPException
+    {
+        PGPSignatureGenerator    sGen;
+
+        try
+        {
+            sGen = new PGPSignatureGenerator(certificationSignerBuilder);
+        }
+        catch (Exception e)
+        {
+            throw new PGPException("creating signature generator: " + e, e);
+        }
+
+        //
+        // generate the certification
+        //
+        sGen.init(certificationLevel, keyPair.getPrivateKey());
+
+        sGen.setHashedSubpackets(hashedPcks);
+        sGen.setUnhashedSubpackets(unhashedPcks);
+
+        try
+        {
+            PGPSignature    certification = sGen.generateCertification(id, keyPair.getPublicKey());
+
+            return PGPPublicKey.addCertification(keyPair.getPublicKey(), id, certification);
+        }
+        catch (Exception e)
+        {
+            throw new PGPException("exception doing certification: " + e, e);
+        }
+    }
+
+    /**
+     * Return true if this key has an algorithm type that makes it suitable to use for signing.
+     * <p>
+     * Note: with version 4 keys KeyFlags subpackets should also be considered when present for
+     * determining the preferred use of the key.
+     *
+     * @return true if this key algorithm is suitable for use with signing.
+     */
+    public boolean isSigningKey()
+    {
+        int algorithm = pub.getAlgorithm();
+
+        return ((algorithm == PGPPublicKey.RSA_GENERAL) || (algorithm == PGPPublicKey.RSA_SIGN)
+                    || (algorithm == PGPPublicKey.DSA) || (algorithm == PGPPublicKey.ECDSA) || (algorithm == PGPPublicKey.ELGAMAL_GENERAL));
+    }
+    
+    /**
+     * Return true if this is a master key.
+     * @return true if a master key.
+     */
+    public boolean isMasterKey()
+    {
+        return pub.isMasterKey();
+    }
+    
+    /**
+     * return the algorithm the key is encrypted with.
+     *
+     * @return the algorithm used to encrypt the secret key.
+     */
+    public int getKeyEncryptionAlgorithm()
+    {
+        return secret.getEncAlgorithm();
+    }
+
+    /**
+     * Return the keyID of the public key associated with this key.
+     * 
+     * @return the keyID associated with this key.
+     */
+    public long getKeyID()
+    {
+        return pub.getKeyID();
+    }
+    
+    /**
+     * Return the public key associated with this key.
+     * 
+     * @return the public key for this key.
+     */
+    public PGPPublicKey getPublicKey()
+    {
+        return pub;
+    }
+    
+    /**
+     * Return any userIDs associated with the key.
+     * 
+     * @return an iterator of Strings.
+     */
+    public Iterator getUserIDs()
+    {
+        return pub.getUserIDs();
+    }
+    
+    /**
+     * Return any user attribute vectors associated with the key.
+     * 
+     * @return an iterator of Strings.
+     */
+    public Iterator getUserAttributes()
+    {
+        return pub.getUserAttributes();
+    }
+
+    private byte[] extractKeyData(
+        PBESecretKeyDecryptor decryptorFactory)
+        throws PGPException
+    {
+        byte[] encData = secret.getSecretKeyData();
+        byte[] data = null;
+
+        if (secret.getEncAlgorithm() != SymmetricKeyAlgorithmTags.NULL)
+        {
+            try
+            {
+                if (secret.getPublicKeyPacket().getVersion() == 4)
+                {
+                    byte[] key = decryptorFactory.makeKeyFromPassPhrase(secret.getEncAlgorithm(), secret.getS2K());
+
+                    data = decryptorFactory.recoverKeyData(secret.getEncAlgorithm(), key, secret.getIV(), encData, 0, encData.length);
+
+                    boolean useSHA1 = secret.getS2KUsage() == SecretKeyPacket.USAGE_SHA1;
+                    byte[] check = checksum(useSHA1 ? decryptorFactory.getChecksumCalculator(HashAlgorithmTags.SHA1) : null, data, (useSHA1) ? data.length - 20 : data.length - 2);
+
+                    for (int i = 0; i != check.length; i++)
+                    {
+                        if (check[i] != data[data.length - check.length + i])
+                        {
+                            throw new PGPException("checksum mismatch at " + i + " of " + check.length);
+                        }
+                    }
+                }
+                else // version 2 or 3, RSA only.
+                {
+                    byte[] key = decryptorFactory.makeKeyFromPassPhrase(secret.getEncAlgorithm(), secret.getS2K());
+
+                    data = new byte[encData.length];
+
+                    byte[] iv = new byte[secret.getIV().length];
+
+                    System.arraycopy(secret.getIV(), 0, iv, 0, iv.length);
+
+                    //
+                    // read in the four numbers
+                    //
+                    int pos = 0;
+
+                    for (int i = 0; i != 4; i++)
+                    {
+                        int encLen = (((encData[pos] << 8) | (encData[pos + 1] & 0xff)) + 7) / 8;
+
+                        data[pos] = encData[pos];
+                        data[pos + 1] = encData[pos + 1];
+
+                        byte[] tmp = decryptorFactory.recoverKeyData(secret.getEncAlgorithm(), key, iv, encData, pos + 2, encLen);
+                        System.arraycopy(tmp, 0, data, pos + 2, tmp.length);
+                        pos += 2 + encLen;
+
+                        if (i != 3)
+                        {
+                            System.arraycopy(encData, pos - iv.length, iv, 0, iv.length);
+                        }
+                    }
+
+                    //
+                    // verify checksum
+                    //
+
+                    int cs = ((encData[pos] << 8) & 0xff00) | (encData[pos + 1] & 0xff);
+                    int calcCs = 0;
+                    for (int j = 0; j < data.length - 2; j++)
+                    {
+                        calcCs += data[j] & 0xff;
+                    }
+
+                    calcCs &= 0xffff;
+                    if (calcCs != cs)
+                    {
+                        throw new PGPException("checksum mismatch: passphrase wrong, expected "
+                            + Integer.toHexString(cs)
+                            + " found " + Integer.toHexString(calcCs));
+                    }
+                }
+            }
+            catch (PGPException e)
+            {
+                throw e;
+            }
+            catch (Exception e)
+            {
+                throw new PGPException("Exception decrypting key", e);
+            }
+        }
+        else
+        {
+            data = encData;
+        }
+
+        return data;
+    }
+
+    /**
+     * Extract a PGPPrivate key from the SecretKey's encrypted contents.
+     *
+     * @param decryptorFactory  factory to use to generate a decryptor for the passed in secretKey.
+     * @return PGPPrivateKey  the unencrypted private key.
+     * @throws PGPException on failure.
+     */
+    public  PGPPrivateKey extractPrivateKey(
+        PBESecretKeyDecryptor decryptorFactory)
+        throws PGPException
+    {
+        byte[] secKeyData = secret.getSecretKeyData();
+        if (secKeyData == null || secKeyData.length < 1)
+        {
+            return null;
+        }
+
+        PublicKeyPacket pubPk = secret.getPublicKeyPacket();
+
+        try
+        {
+            byte[]             data = extractKeyData(decryptorFactory);
+            BCPGInputStream    in = new BCPGInputStream(new ByteArrayInputStream(data));
+
+
+            switch (pubPk.getAlgorithm())
+            {
+            case PGPPublicKey.RSA_ENCRYPT:
+            case PGPPublicKey.RSA_GENERAL:
+            case PGPPublicKey.RSA_SIGN:
+                RSASecretBCPGKey        rsaPriv = new RSASecretBCPGKey(in);
+
+                return new PGPPrivateKey(this.getKeyID(), pubPk, rsaPriv);
+            case PGPPublicKey.DSA:
+                DSASecretBCPGKey    dsaPriv = new DSASecretBCPGKey(in);
+
+                return new PGPPrivateKey(this.getKeyID(), pubPk, dsaPriv);
+            case PGPPublicKey.ELGAMAL_ENCRYPT:
+            case PGPPublicKey.ELGAMAL_GENERAL:
+                ElGamalSecretBCPGKey    elPriv = new ElGamalSecretBCPGKey(in);
+
+                return new PGPPrivateKey(this.getKeyID(), pubPk, elPriv);
+            default:
+                throw new PGPException("unknown public key algorithm encountered");
+            }
+        }
+        catch (PGPException e)
+        {
+            throw e;
+        }
+        catch (Exception e)
+        {
+            throw new PGPException("Exception constructing key", e);
+        }
+    }
+    
+    private static byte[] checksum(PGPDigestCalculator digCalc, byte[] bytes, int length)
+        throws PGPException
+    {
+        if (digCalc != null)
+        {
+            OutputStream dOut = digCalc.getOutputStream();
+
+            try
+            {
+            dOut.write(bytes, 0, length);
+
+            dOut.close();
+            }
+            catch (Exception e)
+            {
+               throw new PGPException("checksum digest calculation failed: " + e.getMessage(), e);
+            }
+            return digCalc.getDigest();
+        }
+        else
+        {
+            int       checksum = 0;
+        
+            for (int i = 0; i != length; i++)
+            {
+                checksum += bytes[i] & 0xff;
+            }
+        
+            byte[] check = new byte[2];
+
+            check[0] = (byte)(checksum >> 8);
+            check[1] = (byte)checksum;
+
+            return check;
+        }
+    }
+    
+    public byte[] getEncoded() 
+        throws IOException
+    {
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        
+        this.encode(bOut);
+        
+        return bOut.toByteArray();
+    }
+    
+    public void encode(
+        OutputStream    outStream) 
+        throws IOException
+    {
+        BCPGOutputStream    out;
+        
+        if (outStream instanceof BCPGOutputStream)
+        {
+            out = (BCPGOutputStream)outStream;
+        }
+        else
+        {
+            out = new BCPGOutputStream(outStream);
+        }
+
+        out.writePacket(secret);
+        if (pub.trustPk != null)
+        {
+            out.writePacket(pub.trustPk);
+        }
+        
+        if (pub.subSigs == null)        // is not a sub key
+        {
+            for (int i = 0; i != pub.keySigs.size(); i++)
+            {
+                ((PGPSignature)pub.keySigs.get(i)).encode(out);
+            }
+            
+            for (int i = 0; i != pub.ids.size(); i++)
+            {
+                if (pub.ids.get(i) instanceof String)
+                {
+                    String    id = (String)pub.ids.get(i);
+                    
+                    out.writePacket(new UserIDPacket(id));
+                }
+                else
+                {
+                    PGPUserAttributeSubpacketVector    v = (PGPUserAttributeSubpacketVector)pub.ids.get(i);
+
+                    out.writePacket(new UserAttributePacket(v.toSubpacketArray()));
+                }
+                
+                if (pub.idTrusts.get(i) != null)
+                {
+                    out.writePacket((ContainedPacket)pub.idTrusts.get(i));
+                }
+                
+                List         sigs = (ArrayList)pub.idSigs.get(i);
+                
+                for (int j = 0; j != sigs.size(); j++)
+                {
+                    ((PGPSignature)sigs.get(j)).encode(out);
+                }
+            }
+        }
+        else
+        {        
+            for (int j = 0; j != pub.subSigs.size(); j++)
+            {
+                ((PGPSignature)pub.subSigs.get(j)).encode(out);
+            }
+        }
+    }
+
+    /**
+     * Return a copy of the passed in secret key, encrypted using a new
+     * password and the passed in algorithm.
+     *
+     * @param key the PGPSecretKey to be copied.
+     * @param oldKeyDecryptor the current password for key.
+     * @param newKeyEncryptor the encryptor for encrypting the secret key material.
+     */
+    public static PGPSecretKey copyWithNewPassword(
+        PGPSecretKey           key,
+        PBESecretKeyDecryptor  oldKeyDecryptor,
+        PBESecretKeyEncryptor  newKeyEncryptor)
+        throws PGPException
+    {
+        byte[]   rawKeyData = key.extractKeyData(oldKeyDecryptor);
+        int        s2kUsage = key.secret.getS2KUsage();
+        byte[]      iv = null;
+        S2K         s2k = null;
+        byte[]      keyData;
+        int         newEncAlgorithm = SymmetricKeyAlgorithmTags.NULL;
+
+        if (newKeyEncryptor == null || newKeyEncryptor.getAlgorithm() == SymmetricKeyAlgorithmTags.NULL)
+        {
+            s2kUsage = SecretKeyPacket.USAGE_NONE;
+            if (key.secret.getS2KUsage() == SecretKeyPacket.USAGE_SHA1)   // SHA-1 hash, need to rewrite checksum
+            {
+                keyData = new byte[rawKeyData.length - 18];
+
+                System.arraycopy(rawKeyData, 0, keyData, 0, keyData.length - 2);
+
+                byte[] check = checksum(null, keyData, keyData.length - 2);
+
+                keyData[keyData.length - 2] = check[0];
+                keyData[keyData.length - 1] = check[1];
+            }
+            else
+            {
+                keyData = rawKeyData;
+            }
+        }
+        else
+        {
+            keyData = newKeyEncryptor.encryptKeyData(rawKeyData, 0, rawKeyData.length);
+
+            iv = newKeyEncryptor.getCipherIV();
+
+            s2k = newKeyEncryptor.getS2K();
+
+            newEncAlgorithm = newKeyEncryptor.getAlgorithm();
+        }
+
+        SecretKeyPacket             secret;
+        if (key.secret instanceof SecretSubkeyPacket)
+        {
+            secret = new SecretSubkeyPacket(key.secret.getPublicKeyPacket(),
+                newEncAlgorithm, s2kUsage, s2k, iv, keyData);
+        }
+        else
+        {
+            secret = new SecretKeyPacket(key.secret.getPublicKeyPacket(),
+                newEncAlgorithm, s2kUsage, s2k, iv, keyData);
+        }
+
+        return new PGPSecretKey(secret, key.pub);
+    }
+
+    /**
+     * Replace the passed the public key on the passed in secret key.
+     *
+     * @param secretKey secret key to change
+     * @param publicKey new public key.
+     * @return a new secret key.
+     * @throws IllegalArgumentException if keyIDs do not match.
+     */
+    public static PGPSecretKey replacePublicKey(PGPSecretKey secretKey, PGPPublicKey publicKey)
+    {
+        if (publicKey.getKeyID() != secretKey.getKeyID())
+        {
+            throw new IllegalArgumentException("keyIDs do not match");
+        }
+
+        return new PGPSecretKey(secretKey.secret, publicKey);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPSecretKeyRing.java b/crypto/j2me/org/bouncycastle/openpgp/PGPSecretKeyRing.java
new file mode 100644
index 000000000..601a2f1ca
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPSecretKeyRing.java
@@ -0,0 +1,366 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.PacketTags;
+import org.bouncycastle.bcpg.PublicSubkeyPacket;
+import org.bouncycastle.bcpg.SecretKeyPacket;
+import org.bouncycastle.bcpg.SecretSubkeyPacket;
+import org.bouncycastle.bcpg.TrustPacket;
+import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator;
+
+/**
+ * Class to hold a single master secret key and its subkeys.
+ * <p>
+ * Often PGP keyring files consist of multiple master keys, if you are trying to process
+ * or construct one of these you should use the PGPSecretKeyRingCollection class.
+ */
+public class PGPSecretKeyRing
+    extends PGPKeyRing
+{    
+    List keys;
+    List extraPubKeys;
+
+    PGPSecretKeyRing(List keys)
+    {
+        this(keys, new ArrayList());
+    }
+
+    private PGPSecretKeyRing(List keys, List extraPubKeys)
+    {
+        this.keys = keys;
+        this.extraPubKeys = extraPubKeys;
+    }
+
+    public PGPSecretKeyRing(
+        byte[]    encoding,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+        throws IOException, PGPException
+    {
+        this(new ByteArrayInputStream(encoding), fingerPrintCalculator);
+    }
+
+    public PGPSecretKeyRing(
+        InputStream              in,
+        KeyFingerPrintCalculator fingerPrintCalculator)
+        throws IOException, PGPException
+    {
+        this.keys = new ArrayList();
+        this.extraPubKeys = new ArrayList();
+
+        BCPGInputStream pIn = wrap(in);
+
+        int initialTag = pIn.nextPacketTag();
+        if (initialTag != PacketTags.SECRET_KEY && initialTag != PacketTags.SECRET_SUBKEY)
+        {
+            throw new IOException(
+                "secret key ring doesn't start with secret key tag: " +
+                "tag 0x" + Integer.toHexString(initialTag));
+        }
+
+        SecretKeyPacket secret = (SecretKeyPacket)pIn.readPacket();
+
+        //
+        // ignore GPG comment packets if found.
+        //
+        while (pIn.nextPacketTag() == PacketTags.EXPERIMENTAL_2)
+        {
+            pIn.readPacket();
+        }
+        
+        TrustPacket trust = readOptionalTrustPacket(pIn);
+
+        // revocation and direct signatures
+        List keySigs = readSignaturesAndTrust(pIn);
+
+        List ids = new ArrayList();
+        List idTrusts = new ArrayList();
+        List idSigs = new ArrayList();
+        readUserIDs(pIn, ids, idTrusts, idSigs);
+
+        keys.add(new PGPSecretKey(secret, new PGPPublicKey(secret.getPublicKeyPacket(), trust, keySigs, ids, idTrusts, idSigs, fingerPrintCalculator)));
+
+
+        // Read subkeys
+        while (pIn.nextPacketTag() == PacketTags.SECRET_SUBKEY
+            || pIn.nextPacketTag() == PacketTags.PUBLIC_SUBKEY)
+        {
+            if (pIn.nextPacketTag() == PacketTags.SECRET_SUBKEY)
+            {
+                SecretSubkeyPacket    sub = (SecretSubkeyPacket)pIn.readPacket();
+
+                //
+                // ignore GPG comment packets if found.
+                //
+                while (pIn.nextPacketTag() == PacketTags.EXPERIMENTAL_2)
+                {
+                    pIn.readPacket();
+                }
+
+                TrustPacket subTrust = readOptionalTrustPacket(pIn);
+                List        sigList = readSignaturesAndTrust(pIn);
+
+                keys.add(new PGPSecretKey(sub, new PGPPublicKey(sub.getPublicKeyPacket(), subTrust, sigList, fingerPrintCalculator)));
+            }
+            else
+            {
+                PublicSubkeyPacket sub = (PublicSubkeyPacket)pIn.readPacket();
+
+                TrustPacket subTrust = readOptionalTrustPacket(pIn);
+                List        sigList = readSignaturesAndTrust(pIn);
+
+                extraPubKeys.add(new PGPPublicKey(sub, subTrust, sigList, fingerPrintCalculator));
+            }
+        }
+    }
+
+    /**
+     * Return the public key for the master key.
+     * 
+     * @return PGPPublicKey
+     */
+    public PGPPublicKey getPublicKey()
+    {
+        return ((PGPSecretKey)keys.get(0)).getPublicKey();
+    }
+
+  /**
+     * Return the public key referred to by the passed in keyID if it
+     * is present.
+     *
+     * @param keyID
+     * @return PGPPublicKey
+     */
+    public PGPPublicKey getPublicKey(
+        long        keyID)
+    {
+        PGPSecretKey key = getSecretKey(keyID);
+        if (key != null)
+        {
+            return key.getPublicKey();
+        }
+
+        for (int i = 0; i != extraPubKeys.size(); i++)
+        {
+            PGPPublicKey    k = (PGPPublicKey)keys.get(i);
+
+            if (keyID == k.getKeyID())
+            {
+                return k;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Return an iterator containing all the public keys.
+     *
+     * @return Iterator
+     */
+    public Iterator getPublicKeys()
+    {
+        List pubKeys = new ArrayList();
+
+        for (Iterator it = getSecretKeys(); it.hasNext();)
+        {
+            pubKeys.add(((PGPSecretKey)it.next()).getPublicKey());
+        }
+
+        pubKeys.addAll(extraPubKeys);
+
+        return Collections.unmodifiableList(pubKeys).iterator();
+    }
+
+    /**
+     * Return the master private key.
+     * 
+     * @return PGPSecretKey
+     */
+    public PGPSecretKey getSecretKey()
+    {
+        return ((PGPSecretKey)keys.get(0));
+    }
+    
+    /**
+     * Return an iterator containing all the secret keys.
+     * 
+     * @return Iterator
+     */
+    public Iterator getSecretKeys()
+    {
+        return Collections.unmodifiableList(keys).iterator();
+    }
+    
+    public PGPSecretKey getSecretKey(
+        long        keyId)
+    {    
+        for (int i = 0; i != keys.size(); i++)
+        {
+            PGPSecretKey    k = (PGPSecretKey)keys.get(i);
+            
+            if (keyId == k.getKeyID())
+            {
+                return k;
+            }
+        }
+    
+        return null;
+    }
+
+    /**
+     * Return an iterator of the public keys in the secret key ring that
+     * have no matching private key. At the moment only personal certificate data
+     * appears in this fashion.
+     *
+     * @return  iterator of unattached, or extra, public keys.
+     */
+    public Iterator getExtraPublicKeys()
+    {
+        return extraPubKeys.iterator();
+    }
+
+    public byte[] getEncoded() 
+        throws IOException
+    {
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        
+        this.encode(bOut);
+        
+        return bOut.toByteArray();
+    }
+    
+    public void encode(
+        OutputStream    outStream) 
+        throws IOException
+    {
+        for (int i = 0; i != keys.size(); i++)
+        {
+            PGPSecretKey    k = (PGPSecretKey)keys.get(i);
+            
+            k.encode(outStream);
+        }
+        for (int i = 0; i != extraPubKeys.size(); i++)
+        {
+            PGPPublicKey    k = (PGPPublicKey)extraPubKeys.get(i);
+
+            k.encode(outStream);
+        }
+    }
+
+    /**
+     * Replace the public key set on the secret ring with the corresponding key off the public ring.
+     *
+     * @param secretRing secret ring to be changed.
+     * @param publicRing public ring containing the new public key set.
+     */
+    public static PGPSecretKeyRing replacePublicKeys(PGPSecretKeyRing secretRing, PGPPublicKeyRing publicRing)
+    {
+        List newList = new ArrayList(secretRing.keys.size());
+
+        for (Iterator it = secretRing.keys.iterator(); it.hasNext();)
+        {
+            PGPSecretKey sk = (PGPSecretKey)it.next();
+            PGPPublicKey pk = publicRing.getPublicKey(sk.getKeyID());
+
+            newList.add(PGPSecretKey.replacePublicKey(sk, pk));
+        }
+
+        return new PGPSecretKeyRing(newList);
+    }
+
+    /**
+     * Returns a new key ring with the secret key passed in either added or
+     * replacing an existing one with the same key ID.
+     * 
+     * @param secRing the secret key ring to be modified.
+     * @param secKey the secret key to be added.
+     * @return a new secret key ring.
+     */
+    public static PGPSecretKeyRing insertSecretKey(
+        PGPSecretKeyRing  secRing,
+        PGPSecretKey      secKey)
+    {
+        List       keys = new ArrayList(secRing.keys);
+        boolean    found = false;
+        boolean    masterFound = false;
+        
+        for (int i = 0; i != keys.size();i++)
+        {
+            PGPSecretKey   key = (PGPSecretKey)keys.get(i);
+            
+            if (key.getKeyID() == secKey.getKeyID())
+            {
+                found = true;
+                keys.set(i, secKey);
+            }
+            if (key.isMasterKey())
+            {
+                masterFound = true;
+            }
+        }
+
+        if (!found)
+        {
+            if (secKey.isMasterKey())
+            {
+                if (masterFound)
+                {
+                    throw new IllegalArgumentException("cannot add a master key to a ring that already has one");
+                }
+
+                keys.add(0, secKey);
+            }
+            else
+            {
+                keys.add(secKey);
+            }
+        }
+        
+        return new PGPSecretKeyRing(keys, secRing.extraPubKeys);
+    }
+    
+    /**
+     * Returns a new key ring with the secret key passed in removed from the
+     * key ring.
+     * 
+     * @param secRing the secret key ring to be modified.
+     * @param secKey the secret key to be removed.
+     * @return a new secret key ring, or null if secKey is not found.
+     */
+    public static PGPSecretKeyRing removeSecretKey(
+        PGPSecretKeyRing  secRing,
+        PGPSecretKey      secKey)
+    {
+        List       keys = new ArrayList(secRing.keys);
+        boolean    found = false;
+        
+        for (int i = 0; i < keys.size();i++)
+        {
+            PGPSecretKey   key = (PGPSecretKey)keys.get(i);
+            
+            if (key.getKeyID() == secKey.getKeyID())
+            {
+                found = true;
+                keys.remove(i);
+            }
+        }
+        
+        if (!found)
+        {
+            return null;
+        }
+        
+        return new PGPSecretKeyRing(keys, secRing.extraPubKeys);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPSignature.java b/crypto/j2me/org/bouncycastle/openpgp/PGPSignature.java
new file mode 100644
index 000000000..7f20fdc9e
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPSignature.java
@@ -0,0 +1,534 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Date;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.DERInteger;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.bcpg.BCPGInputStream;
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.MPInteger;
+import org.bouncycastle.bcpg.SignaturePacket;
+import org.bouncycastle.bcpg.SignatureSubpacket;
+import org.bouncycastle.bcpg.TrustPacket;
+import org.bouncycastle.bcpg.UserAttributeSubpacket;
+import org.bouncycastle.openpgp.operator.PGPContentVerifier;
+import org.bouncycastle.openpgp.operator.PGPContentVerifierBuilder;
+import org.bouncycastle.openpgp.operator.PGPContentVerifierBuilderProvider;
+import org.bouncycastle.util.BigIntegers;
+import org.bouncycastle.util.Strings;
+
+/**
+ *A PGP signature object.
+ */
+public class PGPSignature
+{
+    public static final int    BINARY_DOCUMENT = 0x00;
+    public static final int    CANONICAL_TEXT_DOCUMENT = 0x01;
+    public static final int    STAND_ALONE = 0x02;
+    
+    public static final int    DEFAULT_CERTIFICATION = 0x10;
+    public static final int    NO_CERTIFICATION = 0x11;
+    public static final int    CASUAL_CERTIFICATION = 0x12;
+    public static final int    POSITIVE_CERTIFICATION = 0x13;
+    
+    public static final int    SUBKEY_BINDING = 0x18;
+    public static final int    PRIMARYKEY_BINDING = 0x19;
+    public static final int    DIRECT_KEY = 0x1f;
+    public static final int    KEY_REVOCATION = 0x20;
+    public static final int    SUBKEY_REVOCATION = 0x28;
+    public static final int    CERTIFICATION_REVOCATION = 0x30;
+    public static final int    TIMESTAMP = 0x40;
+    
+    private SignaturePacket    sigPck;
+    private int                signatureType;
+    private TrustPacket        trustPck;
+    private PGPContentVerifier verifier;
+    private byte               lastb;
+    private OutputStream       sigOut;
+
+    PGPSignature(
+        BCPGInputStream    pIn)
+        throws IOException, PGPException
+    {
+        this((SignaturePacket)pIn.readPacket());
+    }
+    
+    PGPSignature(
+        SignaturePacket    sigPacket)
+        throws PGPException
+    {
+        sigPck = sigPacket;
+        signatureType = sigPck.getSignatureType();
+        trustPck = null;
+    }
+    
+    PGPSignature(
+        SignaturePacket    sigPacket,
+        TrustPacket        trustPacket)
+        throws PGPException
+    {
+        this(sigPacket);
+        
+        this.trustPck = trustPacket;
+    }
+
+    /**
+     * Return the OpenPGP version number for this signature.
+     * 
+     * @return signature version number.
+     */
+    public int getVersion()
+    {
+        return sigPck.getVersion();
+    }
+    
+    /**
+     * Return the key algorithm associated with this signature.
+     * @return signature key algorithm.
+     */
+    public int getKeyAlgorithm()
+    {
+        return sigPck.getKeyAlgorithm();
+    }
+    
+    /**
+     * Return the hash algorithm associated with this signature.
+     * @return signature hash algorithm.
+     */
+    public int getHashAlgorithm()
+    {
+        return sigPck.getHashAlgorithm();
+    }
+
+    public void init(PGPContentVerifierBuilderProvider verifierBuilderProvider, PGPPublicKey pubKey)
+        throws PGPException
+    {
+        PGPContentVerifierBuilder verifierBuilder = verifierBuilderProvider.get(sigPck.getKeyAlgorithm(), sigPck.getHashAlgorithm());
+
+        verifier = verifierBuilder.build(pubKey);
+
+        lastb = 0;
+        sigOut = verifier.getOutputStream();
+    }
+
+    public void update(
+        byte    b)
+        throws PGPSignatureException
+    {
+        if (signatureType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            if (b == '\r')
+            {
+                byteUpdate((byte)'\r');
+                byteUpdate((byte)'\n');
+            }
+            else if (b == '\n')
+            {
+                if (lastb != '\r')
+                {
+                    byteUpdate((byte)'\r');
+                    byteUpdate((byte)'\n');
+                }
+            }
+            else
+            {
+                byteUpdate(b);
+            }
+
+            lastb = b;
+        }
+        else
+        {
+            byteUpdate(b);
+        }
+    }
+        
+    public void update(
+        byte[]    bytes)
+        throws PGPSignatureException
+    {
+        this.update(bytes, 0, bytes.length);
+    }
+        
+    public void update(
+        byte[]    bytes,
+        int       off,
+        int       length)
+        throws PGPSignatureException
+    {
+        if (signatureType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            int finish = off + length;
+            
+            for (int i = off; i != finish; i++)
+            {
+                this.update(bytes[i]);
+            }
+        }
+        else
+        {
+            blockUpdate(bytes, off, length);
+        }
+    }
+
+    private void byteUpdate(byte b)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(b);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    private void blockUpdate(byte[] block, int off, int len)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(block, off, len);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    public boolean verify()
+        throws PGPException
+    {
+        try
+        {
+            sigOut.write(this.getSignatureTrailer());
+
+            sigOut.close();
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+
+        return verifier.verify(this.getSignature());
+    }
+
+
+    private void updateWithIdData(int header, byte[] idBytes)
+        throws PGPException
+    {
+        this.update((byte)header);
+        this.update((byte)(idBytes.length >> 24));
+        this.update((byte)(idBytes.length >> 16));
+        this.update((byte)(idBytes.length >> 8));
+        this.update((byte)(idBytes.length));
+        this.update(idBytes);
+    }
+    
+    private void updateWithPublicKey(PGPPublicKey key)
+        throws PGPException
+    {
+        byte[] keyBytes = getEncodedPublicKey(key);
+
+        this.update((byte)0x99);
+        this.update((byte)(keyBytes.length >> 8));
+        this.update((byte)(keyBytes.length));
+        this.update(keyBytes);
+    }
+
+    /**
+     * Verify the signature as certifying the passed in public key as associated
+     * with the passed in user attributes.
+     *
+     * @param userAttributes user attributes the key was stored under
+     * @param key the key to be verified.
+     * @return true if the signature matches, false otherwise.
+     * @throws PGPException
+     */
+    public boolean verifyCertification(
+        PGPUserAttributeSubpacketVector userAttributes,
+        PGPPublicKey    key)
+        throws PGPException
+    {
+        if (verifier == null)
+        {
+            throw new PGPException("PGPSignature not initialised - call init().");
+        }
+
+        updateWithPublicKey(key);
+
+        //
+        // hash in the userAttributes
+        //
+        try
+        {
+            ByteArrayOutputStream bOut = new ByteArrayOutputStream();
+            UserAttributeSubpacket[] packets = userAttributes.toSubpacketArray();
+            for (int i = 0; i != packets.length; i++)
+            {
+                packets[i].encode(bOut);
+            }
+            updateWithIdData(0xd1, bOut.toByteArray());
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("cannot encode subpacket array", e);
+        }
+
+        addTrailer();
+
+        return verifier.verify(this.getSignature());
+    }
+
+    /**
+     * Verify the signature as certifying the passed in public key as associated
+     * with the passed in id.
+     * 
+     * @param id id the key was stored under
+     * @param key the key to be verified.
+     * @return true if the signature matches, false otherwise.
+     * @throws PGPException
+     */
+    public boolean verifyCertification(
+        String          id,
+        PGPPublicKey    key)
+        throws PGPException
+    {
+        if (verifier == null)
+        {
+            throw new PGPException("PGPSignature not initialised - call init().");
+        }
+
+        updateWithPublicKey(key);
+            
+        //
+        // hash in the id
+        //
+        updateWithIdData(0xb4, Strings.toUTF8ByteArray(id));
+
+        addTrailer();
+
+        return verifier.verify(this.getSignature());
+    }
+
+    /**
+     * Verify a certification for the passed in key against the passed in
+     * master key.
+     * 
+     * @param masterKey the key we are verifying against.
+     * @param pubKey the key we are verifying.
+     * @return true if the certification is valid, false otherwise.
+     * @throws PGPException
+     */
+    public boolean verifyCertification(
+        PGPPublicKey    masterKey,
+        PGPPublicKey    pubKey) 
+        throws PGPException
+    {
+        if (verifier == null)
+        {
+            throw new PGPException("PGPSignature not initialised - call init().");
+        }
+
+        updateWithPublicKey(masterKey);
+        updateWithPublicKey(pubKey);
+
+        addTrailer();
+
+        return verifier.verify(this.getSignature());
+    }
+
+    private void addTrailer()
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(sigPck.getSignatureTrailer());
+
+            sigOut.close();
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Verify a key certification, such as a revocation, for the passed in key.
+     * 
+     * @param pubKey the key we are checking.
+     * @return true if the certification is valid, false otherwise.
+     * @throws PGPException
+     */
+    public boolean verifyCertification(
+        PGPPublicKey    pubKey) 
+        throws PGPException
+    {
+        if (verifier == null)
+        {
+            throw new PGPException("PGPSignature not initialised - call init().");
+        }
+
+        if (this.getSignatureType() != KEY_REVOCATION
+            && this.getSignatureType() != SUBKEY_REVOCATION)
+        {
+            throw new PGPException("signature is not a key signature");
+        }
+
+        updateWithPublicKey(pubKey);
+
+        addTrailer();
+
+        return verifier.verify(this.getSignature());
+    }
+
+    public int getSignatureType()
+    {
+         return sigPck.getSignatureType();
+    }
+    
+    /**
+     * Return the id of the key that created the signature.
+     * @return keyID of the signatures corresponding key.
+     */
+    public long getKeyID()
+    {
+         return sigPck.getKeyID();
+    }
+    
+    /**
+     * Return the creation time of the signature.
+     * 
+     * @return the signature creation time.
+     */
+    public Date getCreationTime()
+    {
+        return new Date(sigPck.getCreationTime());
+    }
+    
+    public byte[] getSignatureTrailer()
+    {
+        return sigPck.getSignatureTrailer();
+    }
+
+    /**
+     * Return true if the signature has either hashed or unhashed subpackets.
+     * 
+     * @return true if either hashed or unhashed subpackets are present, false otherwise.
+     */
+    public boolean hasSubpackets()
+    {
+        return sigPck.getHashedSubPackets() != null || sigPck.getUnhashedSubPackets() != null;
+    }
+
+    public PGPSignatureSubpacketVector getHashedSubPackets()
+    {
+        return createSubpacketVector(sigPck.getHashedSubPackets());
+    }
+
+    public PGPSignatureSubpacketVector getUnhashedSubPackets()
+    {
+        return createSubpacketVector(sigPck.getUnhashedSubPackets());
+    }
+    
+    private PGPSignatureSubpacketVector createSubpacketVector(SignatureSubpacket[] pcks)
+    {
+        if (pcks != null)
+        {
+            return new PGPSignatureSubpacketVector(pcks);
+        }
+        
+        return null;
+    }
+    
+    public byte[] getSignature()
+        throws PGPException
+    {
+        MPInteger[]    sigValues = sigPck.getSignature();
+        byte[]         signature;
+
+        if (sigValues != null)
+        {
+            if (sigValues.length == 1)    // an RSA signature
+            {
+                signature = BigIntegers.asUnsignedByteArray(sigValues[0].getValue());
+            }
+            else
+            {
+                try
+                {
+                    ASN1EncodableVector v = new ASN1EncodableVector();
+                    v.add(new DERInteger(sigValues[0].getValue()));
+                    v.add(new DERInteger(sigValues[1].getValue()));
+
+                    signature = new DERSequence(v).getEncoded();
+                }
+                catch (IOException e)
+                {
+                    throw new PGPException("exception encoding DSA sig.", e);
+                }
+            }
+        }
+        else
+        {
+            signature = sigPck.getSignatureBytes();
+        }
+        
+        return signature;
+    }
+    
+    public byte[] getEncoded() 
+        throws IOException
+    {
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        
+        this.encode(bOut);
+        
+        return bOut.toByteArray();
+    }
+    
+    public void encode(
+        OutputStream    outStream) 
+        throws IOException
+    {
+        BCPGOutputStream    out;
+        
+        if (outStream instanceof BCPGOutputStream)
+        {
+            out = (BCPGOutputStream)outStream;
+        }
+        else
+        {
+            out = new BCPGOutputStream(outStream);
+        }
+
+        out.writePacket(sigPck);
+        if (trustPck != null)
+        {
+            out.writePacket(trustPck);
+        }
+    }
+    
+    private byte[] getEncodedPublicKey(
+        PGPPublicKey pubKey) 
+        throws PGPException
+    {
+        byte[]    keyBytes;
+        
+        try
+        {
+            keyBytes = pubKey.publicPk.getEncodedContents();
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("exception preparing key.", e);
+        }
+        
+        return keyBytes;
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPSignatureException.java b/crypto/j2me/org/bouncycastle/openpgp/PGPSignatureException.java
new file mode 100644
index 000000000..44bf8aeef
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPSignatureException.java
@@ -0,0 +1,15 @@
+package org.bouncycastle.openpgp;
+
+public class PGPSignatureException
+    extends PGPException
+{
+    public PGPSignatureException(String message)
+    {
+        super(message);
+    }
+
+    public PGPSignatureException(String message, Exception cause)
+    {
+        super(message, cause);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPSignatureGenerator.java b/crypto/j2me/org/bouncycastle/openpgp/PGPSignatureGenerator.java
new file mode 100644
index 000000000..84de58097
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPSignatureGenerator.java
@@ -0,0 +1,487 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.Date;
+
+import org.bouncycastle.bcpg.MPInteger;
+import org.bouncycastle.bcpg.OnePassSignaturePacket;
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.bcpg.SignaturePacket;
+import org.bouncycastle.bcpg.SignatureSubpacket;
+import org.bouncycastle.bcpg.SignatureSubpacketTags;
+import org.bouncycastle.bcpg.UserAttributeSubpacket;
+import org.bouncycastle.bcpg.sig.IssuerKeyID;
+import org.bouncycastle.bcpg.sig.SignatureCreationTime;
+import org.bouncycastle.openpgp.operator.PGPContentSigner;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+import org.bouncycastle.util.Strings;
+
+/**
+ * Generator for PGP Signatures.
+ */
+public class PGPSignatureGenerator
+{
+    private SignatureSubpacket[]    unhashed = new SignatureSubpacket[0];
+    private SignatureSubpacket[]    hashed = new SignatureSubpacket[0];
+    private OutputStream sigOut;
+    private PGPContentSignerBuilder contentSignerBuilder;
+    private PGPContentSigner contentSigner;
+    private int             sigType;
+    private byte            lastb;
+    private int providedKeyAlgorithm = -1;
+
+    /**
+     * Create a signature generator built on the passed in contentSignerBuilder.
+     *
+     * @param contentSignerBuilder  builder to produce PGPContentSigner objects for generating signatures.
+     */
+    public PGPSignatureGenerator(
+        PGPContentSignerBuilder contentSignerBuilder)
+    {
+        this.contentSignerBuilder = contentSignerBuilder;
+    }
+
+    /**
+     * Initialise the generator for signing.
+     * 
+     * @param signatureType
+     * @param key
+     * @throws PGPException
+     * @deprecated use init() method
+     */
+    public void initSign(
+        int             signatureType,
+        PGPPrivateKey   key)
+        throws PGPException
+    {
+        contentSigner = contentSignerBuilder.build(signatureType, key);
+        sigOut = contentSigner.getOutputStream();
+        sigType = contentSigner.getType();
+        lastb = 0;
+
+        if (providedKeyAlgorithm >= 0 && providedKeyAlgorithm != contentSigner.getKeyAlgorithm())
+        {
+            throw new PGPException("key algorithm mismatch");
+        }
+    }
+
+    /**
+     * Initialise the generator for signing.
+     *
+     * @param signatureType
+     * @param key
+     * @throws PGPException
+     */
+    public void init(
+        int             signatureType,
+        PGPPrivateKey   key)
+        throws PGPException
+    {
+        contentSigner = contentSignerBuilder.build(signatureType, key);
+        sigOut = contentSigner.getOutputStream();
+        sigType = contentSigner.getType();
+        lastb = 0;
+
+        if (providedKeyAlgorithm >= 0 && providedKeyAlgorithm != contentSigner.getKeyAlgorithm())
+        {
+            throw new PGPException("key algorithm mismatch");
+        }
+    }
+
+    /**
+     * Initialise the generator for signing.
+     * 
+     * @param signatureType
+     * @param key
+     * @param random
+     * @throws PGPException
+     * @deprecated random parameter now ignored.
+     */
+    public void initSign(
+        int             signatureType,
+        PGPPrivateKey   key,
+        SecureRandom    random)
+        throws PGPException
+    {
+        initSign(signatureType, key);
+    }
+    
+    public void update(
+        byte    b) 
+        throws PGPSignatureException
+    {
+        if (sigType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            if (b == '\r')
+            {
+                byteUpdate((byte)'\r');
+                byteUpdate((byte)'\n');
+            }
+            else if (b == '\n')
+            {
+                if (lastb != '\r')
+                {
+                    byteUpdate((byte)'\r');
+                    byteUpdate((byte)'\n');
+                }
+            }
+            else
+            {
+                byteUpdate(b);
+            }
+            
+            lastb = b;
+        }
+        else
+        {
+            byteUpdate(b);
+        }
+    }
+    
+    public void update(
+        byte[]    b) 
+        throws PGPSignatureException
+    {
+        this.update(b, 0, b.length);
+    }
+    
+    public void update(
+        byte[]  b,
+        int     off,
+        int     len) 
+        throws PGPSignatureException
+    {
+        if (sigType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            int finish = off + len;
+            
+            for (int i = off; i != finish; i++)
+            {
+                this.update(b[i]);
+            }
+        }
+        else
+        {
+            blockUpdate(b, off, len);
+        }
+    }
+
+    private void byteUpdate(byte b)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(b);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    private void blockUpdate(byte[] block, int off, int len)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(block, off, len);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException(e.getMessage(), e);
+        }
+    }
+
+    public void setHashedSubpackets(
+        PGPSignatureSubpacketVector    hashedPcks)
+    {
+        if (hashedPcks == null)
+        {
+            hashed = new SignatureSubpacket[0];
+            return;
+        }
+        
+        hashed = hashedPcks.toSubpacketArray();
+    }
+    
+    public void setUnhashedSubpackets(
+        PGPSignatureSubpacketVector    unhashedPcks)
+    {
+        if (unhashedPcks == null)
+        {
+            unhashed = new SignatureSubpacket[0];
+            return;
+        }
+
+        unhashed = unhashedPcks.toSubpacketArray();
+    }
+    
+    /**
+     * Return the one pass header associated with the current signature.
+     * 
+     * @param isNested
+     * @return PGPOnePassSignature
+     * @throws PGPException
+     */
+    public PGPOnePassSignature generateOnePassVersion(
+        boolean    isNested)
+        throws PGPException
+    {
+        return new PGPOnePassSignature(new OnePassSignaturePacket(sigType, contentSigner.getHashAlgorithm(), contentSigner.getKeyAlgorithm(), contentSigner.getKeyID(), isNested));
+    }
+    
+    /**
+     * Return a signature object containing the current signature state.
+     * 
+     * @return PGPSignature
+     * @throws PGPException
+     */
+    public PGPSignature generate()
+        throws PGPException
+    {
+        MPInteger[]             sigValues;
+        int                     version = 4;
+        ByteArrayOutputStream   sOut = new ByteArrayOutputStream();
+        SignatureSubpacket[]    hPkts, unhPkts;
+
+        if (!packetPresent(hashed, SignatureSubpacketTags.CREATION_TIME))
+        {
+            hPkts = insertSubpacket(hashed, new SignatureCreationTime(false, new Date()));
+        }
+        else
+        {
+            hPkts = hashed;
+        }
+        
+        if (!packetPresent(hashed, SignatureSubpacketTags.ISSUER_KEY_ID) && !packetPresent(unhashed, SignatureSubpacketTags.ISSUER_KEY_ID))
+        {
+            unhPkts = insertSubpacket(unhashed, new IssuerKeyID(false, contentSigner.getKeyID()));
+        }
+        else
+        {
+            unhPkts = unhashed;
+        }
+        
+        try
+        {
+            sOut.write((byte)version);
+            sOut.write((byte)sigType);
+            sOut.write((byte)contentSigner.getKeyAlgorithm());
+            sOut.write((byte)contentSigner.getHashAlgorithm());
+            
+            ByteArrayOutputStream    hOut = new ByteArrayOutputStream();
+            
+            for (int i = 0; i != hPkts.length; i++)
+            {
+                hPkts[i].encode(hOut);
+            }
+                
+            byte[]                            data = hOut.toByteArray();
+    
+            sOut.write((byte)(data.length >> 8));
+            sOut.write((byte)data.length);
+            sOut.write(data);
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("exception encoding hashed data.", e);
+        }
+        
+        byte[]    hData = sOut.toByteArray();
+        
+        sOut.write((byte)version);
+        sOut.write((byte)0xff);
+        sOut.write((byte)(hData.length >> 24));
+        sOut.write((byte)(hData.length >> 16));
+        sOut.write((byte)(hData.length >> 8));
+        sOut.write((byte)(hData.length));
+        
+        byte[]    trailer = sOut.toByteArray();
+
+        blockUpdate(trailer, 0, trailer.length);
+
+        if (contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.RSA_SIGN
+            || contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.RSA_GENERAL)    // an RSA signature
+        {
+            sigValues = new MPInteger[1];
+            sigValues[0] = new MPInteger(new BigInteger(1, contentSigner.getSignature()));
+        }
+        else
+        {   
+            sigValues = PGPUtil.dsaSigToMpi(contentSigner.getSignature());
+        }
+        
+        byte[]                        digest = contentSigner.getDigest();
+        byte[]                        fingerPrint = new byte[2];
+
+        fingerPrint[0] = digest[0];
+        fingerPrint[1] = digest[1];
+        
+        return new PGPSignature(new SignaturePacket(sigType, contentSigner.getKeyID(), contentSigner.getKeyAlgorithm(), contentSigner.getHashAlgorithm(), hPkts, unhPkts, fingerPrint, sigValues));
+    }
+
+    /**
+     * Generate a certification for the passed in id and key.
+     * 
+     * @param id the id we are certifying against the public key.
+     * @param pubKey the key we are certifying against the id.
+     * @return the certification.
+     * @throws PGPException
+     */
+    public PGPSignature generateCertification(
+        String          id,
+        PGPPublicKey    pubKey) 
+        throws PGPException
+    {
+        updateWithPublicKey(pubKey);
+
+        //
+        // hash in the id
+        //
+        updateWithIdData(0xb4, Strings.toUTF8ByteArray(id));
+
+        return this.generate();
+    }
+
+    /**
+     * Generate a certification for the passed in userAttributes
+     * @param userAttributes the id we are certifying against the public key.
+     * @param pubKey the key we are certifying against the id.
+     * @return the certification.
+     * @throws PGPException
+     */
+    public PGPSignature generateCertification(
+        PGPUserAttributeSubpacketVector userAttributes,
+        PGPPublicKey                    pubKey)
+        throws PGPException
+    {
+        updateWithPublicKey(pubKey);
+
+        //
+        // hash in the attributes
+        //
+        try
+        {
+            ByteArrayOutputStream bOut = new ByteArrayOutputStream();
+            UserAttributeSubpacket[] packets = userAttributes.toSubpacketArray();
+            for (int i = 0; i != packets.length; i++)
+            {
+                packets[i].encode(bOut);
+            }
+            updateWithIdData(0xd1, bOut.toByteArray());
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("cannot encode subpacket array", e);
+        }
+
+        return this.generate();
+    }
+
+    /**
+     * Generate a certification for the passed in key against the passed in
+     * master key.
+     * 
+     * @param masterKey the key we are certifying against.
+     * @param pubKey the key we are certifying.
+     * @return the certification.
+     * @throws PGPException
+     */
+    public PGPSignature generateCertification(
+        PGPPublicKey    masterKey,
+        PGPPublicKey    pubKey) 
+        throws PGPException
+    {
+        updateWithPublicKey(masterKey);
+        updateWithPublicKey(pubKey);
+        
+        return this.generate();
+    }
+    
+    /**
+     * Generate a certification, such as a revocation, for the passed in key.
+     * 
+     * @param pubKey the key we are certifying.
+     * @return the certification.
+     * @throws PGPException
+     */
+    public PGPSignature generateCertification(
+        PGPPublicKey    pubKey)
+        throws PGPException
+    {
+        updateWithPublicKey(pubKey);
+
+        return this.generate();
+    }
+    
+    private byte[] getEncodedPublicKey(
+        PGPPublicKey pubKey) 
+        throws PGPException
+    {
+        byte[]    keyBytes;
+        
+        try
+        {
+            keyBytes = pubKey.publicPk.getEncodedContents();
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("exception preparing key.", e);
+        }
+        
+        return keyBytes;
+    }
+
+    private boolean packetPresent(
+        SignatureSubpacket[] packets,
+        int type)
+    {
+        for (int i = 0; i != packets.length; i++)
+        {
+            if (packets[i].getType() == type)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private SignatureSubpacket[] insertSubpacket(
+        SignatureSubpacket[] packets,
+        SignatureSubpacket subpacket)
+    {
+        SignatureSubpacket[] tmp = new SignatureSubpacket[packets.length + 1];
+
+        tmp[0] = subpacket;
+        System.arraycopy(packets, 0, tmp, 1, packets.length);
+
+        return tmp;
+    }
+
+    private void updateWithIdData(int header, byte[] idBytes)
+        throws PGPSignatureException
+    {
+        this.update((byte)header);
+        this.update((byte)(idBytes.length >> 24));
+        this.update((byte)(idBytes.length >> 16));
+        this.update((byte)(idBytes.length >> 8));
+        this.update((byte)(idBytes.length));
+        this.update(idBytes);
+    }
+
+    private void updateWithPublicKey(PGPPublicKey key)
+        throws PGPException
+    {
+        byte[] keyBytes = getEncodedPublicKey(key);
+
+        this.update((byte)0x99);
+        this.update((byte)(keyBytes.length >> 8));
+        this.update((byte)(keyBytes.length));
+        this.update(keyBytes);
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPUtil.java b/crypto/j2me/org/bouncycastle/openpgp/PGPUtil.java
new file mode 100644
index 000000000..2bae0cee2
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPUtil.java
@@ -0,0 +1,152 @@
+package org.bouncycastle.openpgp;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+
+import org.bouncycastle.asn1.ASN1InputStream;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERInteger;
+import org.bouncycastle.bcpg.HashAlgorithmTags;
+import org.bouncycastle.bcpg.MPInteger;
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
+
+/**
+ * Basic utility class
+ */
+public class PGPUtil
+    implements HashAlgorithmTags
+{
+    static MPInteger[] dsaSigToMpi(
+        byte[] encoding) 
+        throws PGPException
+    {
+        ASN1InputStream aIn = new ASN1InputStream(encoding);
+
+        DERInteger i1;
+        DERInteger i2;
+
+        try
+        {
+            ASN1Sequence s = (ASN1Sequence)aIn.readObject();
+
+            i1 = (DERInteger)s.getObjectAt(0);
+            i2 = (DERInteger)s.getObjectAt(1);
+        }
+        catch (IOException e)
+        {
+            throw new PGPException("exception encoding signature", e);
+        }
+
+        MPInteger[] values = new MPInteger[2];
+        
+        values[0] = new MPInteger(i1.getValue());
+        values[1] = new MPInteger(i2.getValue());
+        
+        return values;
+    }
+    
+    static String getDigestName(
+        int        hashAlgorithm)
+        throws PGPException
+    {
+        switch (hashAlgorithm)
+        {
+        case HashAlgorithmTags.SHA1:
+            return "SHA1";
+        case HashAlgorithmTags.MD2:
+            return "MD2";
+        case HashAlgorithmTags.MD5:
+            return "MD5";
+        case HashAlgorithmTags.RIPEMD160:
+            return "RIPEMD160";
+        case HashAlgorithmTags.SHA256:
+            return "SHA256";
+        case HashAlgorithmTags.SHA384:
+            return "SHA384";
+        case HashAlgorithmTags.SHA512:
+            return "SHA512";
+        case HashAlgorithmTags.SHA224:
+            return "SHA224";
+        default:
+            throw new PGPException("unknown hash algorithm tag in getDigestName: " + hashAlgorithm);
+        }
+    }
+    
+    static String getSignatureName(
+        int        keyAlgorithm,
+        int        hashAlgorithm)
+        throws PGPException
+    {
+        String     encAlg;
+                
+        switch (keyAlgorithm)
+        {
+        case PublicKeyAlgorithmTags.RSA_GENERAL:
+        case PublicKeyAlgorithmTags.RSA_SIGN:
+            encAlg = "RSA";
+            break;
+        case PublicKeyAlgorithmTags.DSA:
+            encAlg = "DSA";
+            break;
+        case PublicKeyAlgorithmTags.ELGAMAL_ENCRYPT: // in some malformed cases.
+        case PublicKeyAlgorithmTags.ELGAMAL_GENERAL:
+            encAlg = "ElGamal";
+            break;
+        default:
+            throw new PGPException("unknown algorithm tag in signature:" + keyAlgorithm);
+        }
+
+        return getDigestName(hashAlgorithm) + "with" + encAlg;
+    }
+
+    public static byte[] makeRandomKey(
+        int             algorithm,
+        SecureRandom    random) 
+        throws PGPException
+    {
+        int        keySize = 0;
+        
+        switch (algorithm)
+        {
+        case SymmetricKeyAlgorithmTags.TRIPLE_DES:
+            keySize = 192;
+            break;
+        case SymmetricKeyAlgorithmTags.IDEA:
+            keySize = 128;
+            break;
+        case SymmetricKeyAlgorithmTags.CAST5:
+            keySize = 128;
+            break;
+        case SymmetricKeyAlgorithmTags.BLOWFISH:
+            keySize = 128;
+            break;
+        case SymmetricKeyAlgorithmTags.SAFER:
+            keySize = 128;
+            break;
+        case SymmetricKeyAlgorithmTags.DES:
+            keySize = 64;
+            break;
+        case SymmetricKeyAlgorithmTags.AES_128:
+            keySize = 128;
+            break;
+        case SymmetricKeyAlgorithmTags.AES_192:
+            keySize = 192;
+            break;
+        case SymmetricKeyAlgorithmTags.AES_256:
+            keySize = 256;
+            break;
+        case SymmetricKeyAlgorithmTags.TWOFISH:
+            keySize = 256;
+            break;
+        default:
+            throw new PGPException("unknown symmetric algorithm: " + algorithm);
+        }
+        
+        byte[]    keyBytes = new byte[(keySize + 7) / 8];
+        
+        random.nextBytes(keyBytes);
+        
+        return keyBytes;
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/PGPV3SignatureGenerator.java b/crypto/j2me/org/bouncycastle/openpgp/PGPV3SignatureGenerator.java
new file mode 100644
index 000000000..b666f55c8
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/PGPV3SignatureGenerator.java
@@ -0,0 +1,241 @@
+package org.bouncycastle.openpgp;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.Date;
+
+import org.bouncycastle.bcpg.MPInteger;
+import org.bouncycastle.bcpg.OnePassSignaturePacket;
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.bcpg.SignaturePacket;
+import org.bouncycastle.openpgp.operator.PGPContentSigner;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+
+/**
+ * Generator for old style PGP V3 Signatures.
+ */
+public class PGPV3SignatureGenerator
+{
+    private byte            lastb;
+    private OutputStream    sigOut;
+    private PGPContentSignerBuilder contentSignerBuilder;
+    private PGPContentSigner contentSigner;
+    private int              sigType;
+    private int              providedKeyAlgorithm = -1;
+
+    /**
+     * Create a signature generator built on the passed in contentSignerBuilder.
+     *
+     * @param contentSignerBuilder  builder to produce PGPContentSigner objects for generating signatures.
+     */
+    public PGPV3SignatureGenerator(
+        PGPContentSignerBuilder contentSignerBuilder)
+    {
+        this.contentSignerBuilder = contentSignerBuilder;
+    }
+    
+    /**
+     * Initialise the generator for signing.
+     * 
+     * @param signatureType
+     * @param key
+     * @throws PGPException
+     */
+    public void init(
+        int           signatureType,
+        PGPPrivateKey key)
+        throws PGPException
+    {
+        contentSigner = contentSignerBuilder.build(signatureType, key);
+        sigOut = contentSigner.getOutputStream();
+        sigType = contentSigner.getType();
+        lastb = 0;
+
+        if (providedKeyAlgorithm >= 0 && providedKeyAlgorithm != contentSigner.getKeyAlgorithm())
+        {
+            throw new PGPException("key algorithm mismatch");
+        }
+    }
+
+    /**
+     * Initialise the generator for signing.
+     * 
+     * @param signatureType
+     * @param key
+     * @param random
+     * @throws PGPException
+     * @deprecated random now ignored - set random in PGPContentSignerBuilder
+     */
+    public void initSign(
+        int           signatureType,
+        PGPPrivateKey key,
+        SecureRandom  random)
+        throws PGPException
+    {
+        init(signatureType, key);
+    }
+
+    /**
+     * Initialise the generator for signing.
+     *
+     * @param signatureType
+     * @param key
+     * @throws PGPException
+     * @deprecated use init()
+     */
+    public void initSign(
+        int           signatureType,
+        PGPPrivateKey key)
+        throws PGPException
+    {
+        init(signatureType, key);
+    }
+
+    public void update(
+        byte b) 
+        throws PGPSignatureException
+    {
+        if (sigType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            if (b == '\r')
+            {
+                byteUpdate((byte)'\r');
+                byteUpdate((byte)'\n');
+            }
+            else if (b == '\n')
+            {
+                if (lastb != '\r')
+                {
+                    byteUpdate((byte)'\r');
+                    byteUpdate((byte)'\n');
+                }
+            }
+            else
+            {
+                byteUpdate(b);
+            }
+            
+            lastb = b;
+        }
+        else
+        {
+            byteUpdate(b);
+        }
+    }
+    
+    public void update(
+        byte[] b) 
+        throws PGPSignatureException
+    {
+        this.update(b, 0, b.length);
+    }
+    
+    public void update(
+        byte[]  b,
+        int     off,
+        int     len) 
+        throws PGPSignatureException
+    {
+        if (sigType == PGPSignature.CANONICAL_TEXT_DOCUMENT)
+        {
+            int finish = off + len;
+            
+            for (int i = off; i != finish; i++)
+            {
+                this.update(b[i]);
+            }
+        }
+        else
+        {
+            blockUpdate(b, off, len);
+        }
+    }
+
+    private void byteUpdate(byte b)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(b);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException("unable to update signature", e);
+        }
+    }
+
+    private void blockUpdate(byte[] block, int off, int len)
+        throws PGPSignatureException
+    {
+        try
+        {
+            sigOut.write(block, off, len);
+        }
+        catch (IOException e)
+        {
+            throw new PGPSignatureException("unable to update signature", e);
+        }
+    }
+
+    /**
+     * Return the one pass header associated with the current signature.
+     * 
+     * @param isNested
+     * @return PGPOnePassSignature
+     * @throws PGPException
+     */
+    public PGPOnePassSignature generateOnePassVersion(
+        boolean isNested)
+        throws PGPException
+    {
+        return new PGPOnePassSignature(new OnePassSignaturePacket(sigType, contentSigner.getHashAlgorithm(), contentSigner.getKeyAlgorithm(), contentSigner.getKeyID(), isNested));
+    }
+    
+    /**
+     * Return a V3 signature object containing the current signature state.
+     * 
+     * @return PGPSignature
+     * @throws PGPException
+     */
+    public PGPSignature generate()
+        throws PGPException
+    {
+        long creationTime = new Date().getTime() / 1000;
+
+        ByteArrayOutputStream sOut = new ByteArrayOutputStream();
+
+        sOut.write(sigType);
+        sOut.write((byte)(creationTime >> 24));
+        sOut.write((byte)(creationTime >> 16));
+        sOut.write((byte)(creationTime >> 8));
+        sOut.write((byte)creationTime);
+
+        byte[] hData = sOut.toByteArray();
+
+        blockUpdate(hData, 0, hData.length);
+
+        MPInteger[] sigValues;
+        if (contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.RSA_SIGN
+            || contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.RSA_GENERAL)
+            // an RSA signature
+        {
+            sigValues = new MPInteger[1];
+            sigValues[0] = new MPInteger(new BigInteger(1, contentSigner.getSignature()));
+        }
+        else
+        {
+            sigValues = PGPUtil.dsaSigToMpi(contentSigner.getSignature());
+        }
+
+        byte[] digest = contentSigner.getDigest();
+        byte[] fingerPrint = new byte[2];
+
+        fingerPrint[0] = digest[0];
+        fingerPrint[1] = digest[1];
+
+        return new PGPSignature(new SignaturePacket(3, contentSigner.getType(), contentSigner.getKeyID(), contentSigner.getKeyAlgorithm(), contentSigner.getHashAlgorithm(), creationTime * 1000, fingerPrint, sigValues));
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPDSAElGamalTest.java b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPDSAElGamalTest.java
new file mode 100644
index 000000000..34382a5e6
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPDSAElGamalTest.java
@@ -0,0 +1,469 @@
+package org.bouncycastle.openpgp.test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.Date;
+import java.util.Iterator;
+
+import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
+import org.bouncycastle.crypto.AsymmetricBlockCipher;
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.encodings.PKCS1Encoding;
+import org.bouncycastle.crypto.engines.ElGamalEngine;
+import org.bouncycastle.crypto.generators.ElGamalKeyPairGenerator;
+import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
+import org.bouncycastle.crypto.params.ElGamalKeyGenerationParameters;
+import org.bouncycastle.crypto.params.ElGamalParameters;
+import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedDataList;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPKeyPair;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPObjectFactory;
+import org.bouncycastle.openpgp.PGPOnePassSignature;
+import org.bouncycastle.openpgp.PGPOnePassSignatureList;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPPublicKey;
+import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
+import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPSecretKeyRing;
+import org.bouncycastle.openpgp.PGPSignature;
+import org.bouncycastle.openpgp.PGPSignatureGenerator;
+import org.bouncycastle.openpgp.PGPSignatureList;
+import org.bouncycastle.openpgp.PGPUtil;
+import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator;
+import org.bouncycastle.openpgp.operator.bc.BcPBESecretKeyDecryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentVerifierBuilderProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDataEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDigestCalculatorProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyConverter;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyPair;
+import org.bouncycastle.openpgp.operator.bc.BcPublicKeyDataDecryptorFactory;
+import org.bouncycastle.openpgp.operator.bc.BcPublicKeyKeyEncryptionMethodGenerator;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.UncloseableOutputStream;
+
+public class BcPGPDSAElGamalTest
+    extends SimpleTest
+{
+
+    byte[] testPubKeyRing =
+        Base64.decode(
+            "mQGiBEAR8jYRBADNifuSopd20JOQ5x30ljIaY0M6927+vo09NeNxS3KqItba"
+         + "nz9o5e2aqdT0W1xgdHYZmdElOHTTsugZxdXTEhghyxoo3KhVcNnTABQyrrvX"
+         + "qouvmP2fEDEw0Vpyk+90BpyY9YlgeX/dEA8OfooRLCJde/iDTl7r9FT+mts8"
+         + "g3azjwCgx+pOLD9LPBF5E4FhUOdXISJ0f4EEAKXSOi9nZzajpdhe8W2ZL9gc"
+         + "BpzZi6AcrRZBHOEMqd69gtUxA4eD8xycUQ42yH89imEcwLz8XdJ98uHUxGJi"
+         + "qp6hq4oakmw8GQfiL7yQIFgaM0dOAI9Afe3m84cEYZsoAFYpB4/s9pVMpPRH"
+         + "NsVspU0qd3NHnSZ0QXs8L8DXGO1uBACjDUj+8GsfDCIP2QF3JC+nPUNa0Y5t"
+         + "wKPKl+T8hX/0FBD7fnNeC6c9j5Ir/Fp/QtdaDAOoBKiyNLh1JaB1NY6US5zc"
+         + "qFks2seZPjXEiE6OIDXYra494mjNKGUobA4hqT2peKWXt/uBcuL1mjKOy8Qf"
+         + "JxgEd0MOcGJO+1PFFZWGzLQ3RXJpYyBILiBFY2hpZG5hICh0ZXN0IGtleSBv"
+         + "bmx5KSA8ZXJpY0Bib3VuY3ljYXN0bGUub3JnPohZBBMRAgAZBQJAEfI2BAsH"
+         + "AwIDFQIDAxYCAQIeAQIXgAAKCRAOtk6iUOgnkDdnAKC/CfLWikSBdbngY6OK"
+         + "5UN3+o7q1ACcDRqjT3yjBU3WmRUNlxBg3tSuljmwAgAAuQENBEAR8jgQBAC2"
+         + "kr57iuOaV7Ga1xcU14MNbKcA0PVembRCjcVjei/3yVfT/fuCVtGHOmYLEBqH"
+         + "bn5aaJ0P/6vMbLCHKuN61NZlts+LEctfwoya43RtcubqMc7eKw4k0JnnoYgB"
+         + "ocLXOtloCb7jfubOsnfORvrUkK0+Ne6anRhFBYfaBmGU75cQgwADBQP/XxR2"
+         + "qGHiwn+0YiMioRDRiIAxp6UiC/JQIri2AKSqAi0zeAMdrRsBN7kyzYVVpWwN"
+         + "5u13gPdQ2HnJ7d4wLWAuizUdKIQxBG8VoCxkbipnwh2RR4xCXFDhJrJFQUm+"
+         + "4nKx9JvAmZTBIlI5Wsi5qxst/9p5MgP3flXsNi1tRbTmRhqIRgQYEQIABgUC"
+         + "QBHyOAAKCRAOtk6iUOgnkBStAJoCZBVM61B1LG2xip294MZecMtCwQCbBbsk"
+         + "JVCXP0/Szm05GB+WN+MOCT2wAgAA");
+           
+    byte[] testPrivKeyRing =
+        Base64.decode(
+            "lQHhBEAR8jYRBADNifuSopd20JOQ5x30ljIaY0M6927+vo09NeNxS3KqItba"
+         + "nz9o5e2aqdT0W1xgdHYZmdElOHTTsugZxdXTEhghyxoo3KhVcNnTABQyrrvX"
+         + "qouvmP2fEDEw0Vpyk+90BpyY9YlgeX/dEA8OfooRLCJde/iDTl7r9FT+mts8"
+         + "g3azjwCgx+pOLD9LPBF5E4FhUOdXISJ0f4EEAKXSOi9nZzajpdhe8W2ZL9gc"
+         + "BpzZi6AcrRZBHOEMqd69gtUxA4eD8xycUQ42yH89imEcwLz8XdJ98uHUxGJi"
+         + "qp6hq4oakmw8GQfiL7yQIFgaM0dOAI9Afe3m84cEYZsoAFYpB4/s9pVMpPRH"
+         + "NsVspU0qd3NHnSZ0QXs8L8DXGO1uBACjDUj+8GsfDCIP2QF3JC+nPUNa0Y5t"
+         + "wKPKl+T8hX/0FBD7fnNeC6c9j5Ir/Fp/QtdaDAOoBKiyNLh1JaB1NY6US5zc"
+         + "qFks2seZPjXEiE6OIDXYra494mjNKGUobA4hqT2peKWXt/uBcuL1mjKOy8Qf"
+         + "JxgEd0MOcGJO+1PFFZWGzP4DAwLeUcsVxIC2s2Bb9ab2XD860TQ2BI2rMD/r"
+         + "7/psx9WQ+Vz/aFAT3rXkEJ97nFeqEACgKmUCAEk9939EwLQ3RXJpYyBILiBF"
+         + "Y2hpZG5hICh0ZXN0IGtleSBvbmx5KSA8ZXJpY0Bib3VuY3ljYXN0bGUub3Jn"
+         + "PohZBBMRAgAZBQJAEfI2BAsHAwIDFQIDAxYCAQIeAQIXgAAKCRAOtk6iUOgn"
+         + "kDdnAJ9Ala3OcwEV1DbK906CheYWo4zIQwCfUqUOLMp/zj6QAk02bbJAhV1r"
+         + "sAewAgAAnQFYBEAR8jgQBAC2kr57iuOaV7Ga1xcU14MNbKcA0PVembRCjcVj"
+         + "ei/3yVfT/fuCVtGHOmYLEBqHbn5aaJ0P/6vMbLCHKuN61NZlts+LEctfwoya"
+         + "43RtcubqMc7eKw4k0JnnoYgBocLXOtloCb7jfubOsnfORvrUkK0+Ne6anRhF"
+         + "BYfaBmGU75cQgwADBQP/XxR2qGHiwn+0YiMioRDRiIAxp6UiC/JQIri2AKSq"
+         + "Ai0zeAMdrRsBN7kyzYVVpWwN5u13gPdQ2HnJ7d4wLWAuizUdKIQxBG8VoCxk"
+         + "bipnwh2RR4xCXFDhJrJFQUm+4nKx9JvAmZTBIlI5Wsi5qxst/9p5MgP3flXs"
+         + "Ni1tRbTmRhr+AwMC3lHLFcSAtrNg/EiWFLAnKNXH27zjwuhje8u2r+9iMTYs"
+         + "GjbRxaxRY0GKRhttCwqe2BC0lHhzifdlEcc9yjIjuKfepG2fnnSIRgQYEQIA"
+         + "BgUCQBHyOAAKCRAOtk6iUOgnkBStAJ9HFejVtVJ/A9LM/mDPe0ExhEXt/QCg"
+         + "m/KM7hJ/JrfnLQl7IaZsdg1F6vCwAgAA");
+
+    byte[] encMessage =
+        Base64.decode(
+            "hQEOAynbo4lhNjcHEAP/dgCkMtPB6mIgjFvNiotjaoh4sAXf4vFNkSeehQ2c"
+         + "r+IMt9CgIYodJI3FoJXxOuTcwesqTp5hRzgUBJS0adLDJwcNubFMy0M2tp5o"
+         + "KTWpXulIiqyO6f5jI/oEDHPzFoYgBmR4x72l/YpMy8UoYGtNxNvR7LVOfqJv"
+         + "uDY/71KMtPQEAIadOWpf1P5Td+61Zqn2VH2UV7H8eI6hGa6Lsy4sb9iZNE7f"
+         + "c+spGJlgkiOt8TrQoq3iOK9UN9nHZLiCSIEGCzsEn3uNuorD++Qs065ij+Oy"
+         + "36TKeuJ+38CfT7u47dEshHCPqWhBKEYrxZWHUJU/izw2Q1Yxd2XRxN+nafTL"
+         + "X1fQ0lABQUASa18s0BkkEERIdcKQXVLEswWcGqWNv1ZghC7xO2VDBX4HrPjp"
+         + "drjL63p2UHzJ7/4gPWGGtnqq1Xita/1mrImn7pzLThDWiT55vjw6Hw==");
+
+    byte[] signedAndEncMessage =
+        Base64.decode(
+            "hQEOAynbo4lhNjcHEAP+K20MVhzdX57hf/cU8TH0prP0VePr9mmeBedzqqMn"
+         + "fp2p8Zb68zmcMlI/WiL5XMNLYRmCgEcXyWbKdP/XV9m9LDBe1CMAGrkCeGBy"
+         + "je69IQQ5LS9vDPyEMF4iAAv/EqACjqHkizdY/a/FRx/t2ioXYdEC2jA6kS9C"
+         + "McpsNz16DE8EAIk3uKn4bGo/+15TXkyFYzW5Cf71SfRoHNmU2zAI93zhjN+T"
+         + "B7mGJwWXzsMkIO6FkMU5TCSrwZS3DBWCIaJ6SYoaawE/C/2j9D7bX1Jv8kum"
+         + "4cq+eZM7z6JYs6xend+WAwittpUxbEiyC2AJb3fBSXPAbLqWd6J6xbZZ7GDK"
+         + "r2Ca0pwBxwGhbMDyi2zpHLzw95H7Ah2wMcGU6kMLB+hzBSZ6mSTGFehqFQE3"
+         + "2BnAj7MtnbghiefogacJ891jj8Y2ggJeKDuRz8j2iICaTOy+Y2rXnnJwfYzm"
+         + "BMWcd2h1C5+UeBJ9CrrLniCCI8s5u8z36Rno3sfhBnXdRmWSxExXtocbg1Ht"
+         + "dyiThf6TK3W29Yy/T6x45Ws5zOasaJdsFKM=");    
+    char[] pass = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd' };
+    
+    public void performTest()
+        throws Exception
+    {
+        try
+        {
+            PGPPublicKey pubKey;
+
+            //
+            // 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, new BcKeyFingerprintCalculator());
+            PGPPrivateKey        pgpPrivKey = sKey.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+            
+            //
+            // signature generation
+            //
+            String                                data = "hello world!";
+            ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+            ByteArrayInputStream        testIn = new ByteArrayInputStream(data.getBytes());
+            PGPSignatureGenerator    sGen = new PGPSignatureGenerator(new BcPGPContentSignerBuilder(PGPPublicKey.DSA, PGPUtil.SHA1));
+        
+            sGen.init(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);
+
+            sGen.generateOnePassVersion(false).encode(bOut);
+
+            PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();
+            
+            Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);
+            OutputStream lOut = lGen.open(
+                new UncloseableOutputStream(bOut),
+                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(bOut);
+
+            //
+            // verify generated signature
+            //
+            pgpFact = new PGPObjectFactory(bOut.toByteArray());
+            
+            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.init(new BcPGPContentVerifierBuilderProvider(), pubKey);
+            
+            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;
+            AsymmetricKeyParameter pKey = null;
+            BcPGPKeyConverter keyConverter = new BcPGPKeyConverter();
+
+            Iterator    it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                PGPPublicKey    pgpKey = (PGPPublicKey)it.next();
+
+                if (pgpKey.getAlgorithm() == PGPPublicKey.ELGAMAL_ENCRYPT
+                    || pgpKey.getAlgorithm() == PGPPublicKey.ELGAMAL_GENERAL)
+                {
+                    pKey = keyConverter.getPublicKey(pgpKey);
+                    pgpKeyID = pgpKey.getKeyID();
+                    if (pgpKey.getBitStrength() != 1024)
+                    {
+                        fail("failed - key strength reported incorrectly.");
+                    }
+                    
+                    //
+                    // verify the key
+                    //
+                    
+                }
+            }
+             
+            AsymmetricBlockCipher c = new PKCS1Encoding(new ElGamalEngine());
+
+            c.init(true, pKey);
+            
+            byte[]  in = "hello world".getBytes();
+
+            byte[]  out = c.processBlock(in, 0, in.length);
+            
+            pgpPrivKey = sKey.getSecretKey(pgpKeyID).extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+            
+            c.init(false, keyConverter.getPrivateKey(pgpPrivKey));
+            
+            out = c.processBlock(out, 0, out.length);
+            
+            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(new BcPublicKeyDataDecryptorFactory(pgpPrivKey));
+                     
+            pgpFact = new PGPObjectFactory(clear);
+            /* No compressed data support
+            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(new BcPublicKeyDataDecryptorFactory(pgpPrivKey));
+                     
+            pgpFact = new PGPObjectFactory(clear);
+            
+            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.init(new BcPGPContentVerifierBuilderProvider(), pgpPub.getPublicKey());
+            
+            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(new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.TRIPLE_DES).setSecureRandom(new SecureRandom()));
+            PGPPublicKey                        puK = sKey.getSecretKey(pgpKeyID).getPublicKey();
+            
+            cPk.addMethod(new BcPublicKeyKeyEncryptionMethodGenerator(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(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+
+            clear = encP.getDataStream(new BcPublicKeyDataDecryptorFactory(pgpPrivKey));
+            
+            bOut.reset();
+//           compressed data not supported
+//            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);
+
+            ElGamalKeyPairGenerator       kpg = new ElGamalKeyPairGenerator();
+            
+            ElGamalParameters   elParams = new ElGamalParameters(p, g);
+            
+            kpg.init(new ElGamalKeyGenerationParameters(new SecureRandom(), elParams));
+            
+            AsymmetricCipherKeyPair kp = kpg.generateKeyPair();
+            
+            PGPKeyPair    pgpKp = new BcPGPKeyPair(PGPPublicKey.ELGAMAL_GENERAL , kp, new Date());
+            
+            PGPPublicKey k1 = pgpKp.getPublicKey();
+            
+            PGPPrivateKey k2 = pgpKp.getPrivateKey();
+
+            // check sub key encoding
+
+            it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                PGPPublicKey    pgpKey = (PGPPublicKey)it.next();
+
+                if (!pgpKey.isMasterKey())
+                {
+                    byte[] kEnc = pgpKey.getEncoded();
+
+                    PGPObjectFactory objF = new PGPObjectFactory(kEnc);
+
+                    PGPPublicKey k = (PGPPublicKey)objF.nextObject();
+
+                    pKey = keyConverter.getPublicKey(k);
+                    pgpKeyID = k.getKeyID();
+                    if (k.getBitStrength() != 1024)
+                    {
+                        fail("failed - key strength reported incorrectly.");
+                    }
+       
+                    if (objF.nextObject() != null)
+                    {
+                        fail("failed - stream not fully parsed.");
+                    }
+                }
+            }
+           
+        }
+        catch (PGPException e)
+        {
+            fail("exception: " + e.getMessage(), e.getUnderlyingException());
+        }
+    }
+
+    public String getName()
+    {
+        return "PGPDSAElGamalTest";
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new BcPGPDSAElGamalTest());
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPDSATest.java b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPDSATest.java
new file mode 100644
index 000000000..3ef0c0cb4
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPDSATest.java
@@ -0,0 +1,609 @@
+package org.bouncycastle.openpgp.test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.Date;
+import java.util.Iterator;
+
+import org.bouncycastle.bcpg.HashAlgorithmTags;
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.generators.RSAKeyPairGenerator;
+import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
+import org.bouncycastle.crypto.params.RSAKeyGenerationParameters;
+import org.bouncycastle.openpgp.PGPKeyPair;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPObjectFactory;
+import org.bouncycastle.openpgp.PGPOnePassSignature;
+import org.bouncycastle.openpgp.PGPOnePassSignatureList;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPPublicKey;
+import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPSecretKeyRing;
+import org.bouncycastle.openpgp.PGPSignature;
+import org.bouncycastle.openpgp.PGPSignatureGenerator;
+import org.bouncycastle.openpgp.PGPSignatureList;
+import org.bouncycastle.openpgp.PGPSignatureSubpacketGenerator;
+import org.bouncycastle.openpgp.PGPUserAttributeSubpacketVector;
+import org.bouncycastle.openpgp.PGPUtil;
+import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator;
+import org.bouncycastle.openpgp.operator.bc.BcPBESecretKeyDecryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentVerifierBuilderProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDigestCalculatorProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyConverter;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyPair;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.UncloseableOutputStream;
+
+public class BcPGPDSATest
+    extends SimpleTest
+{
+    byte[] testPubKey =
+        Base64.decode(
+            "mQGiBD9HBzURBACzkxRCVGJg5+Ld9DU4Xpnd4LCKgMq7YOY7Gi0EgK92gbaa6+zQ"
+                + "oQFqz1tt3QUmpz3YVkm/zLESBBtC1ACIXGggUdFMUr5I87+1Cb6vzefAtGt8N5VV"
+                + "1F/MXv1gJz4Bu6HyxL/ncfe71jsNhav0i4yAjf2etWFj53zK6R+Ojg5H6wCgpL9/"
+                + "tXVfGP8SqFvyrN/437MlFSUEAIN3V6j/MUllyrZglrtr2+RWIwRrG/ACmrF6hTug"
+                + "Ol4cQxaDYNcntXbhlTlJs9MxjTH3xxzylyirCyq7HzGJxZzSt6FTeh1DFYzhJ7Qu"
+                + "YR1xrSdA6Y0mUv0ixD5A4nPHjupQ5QCqHGeRfFD/oHzD4zqBnJp/BJ3LvQ66bERJ"
+                + "mKl5A/4uj3HoVxpb0vvyENfRqKMmGBISycY4MoH5uWfb23FffsT9r9KL6nJ4syLz"
+                + "aRR0gvcbcjkc9Z3epI7gr3jTrb4d8WPxsDbT/W1tv9bG/EHawomLcihtuUU68Uej"
+                + "6/wZot1XJqu2nQlku57+M/V2X1y26VKsipolPfja4uyBOOyvbLQzRXJpYyBFY2hp"
+                + "ZG5hIChEU0EgVGVzdCBLZXkpIDxlcmljQGJvdW5jeWNhc3RsZS5vcmc+iFkEExEC"
+                + "ABkFAj9HBzUECwcDAgMVAgMDFgIBAh4BAheAAAoJEM0j9enEyjRDAlwAn2rrom0s"
+                + "MhufWK5vIRwg7gj5qsLEAJ4vnT5dPBVblofsG+pDoCVeJXGGng==");
+
+    byte[] testPrivKey =
+        Base64.decode(
+            "lQHhBD9HBzURBACzkxRCVGJg5+Ld9DU4Xpnd4LCKgMq7YOY7Gi0EgK92gbaa6+zQ"
+                + "oQFqz1tt3QUmpz3YVkm/zLESBBtC1ACIXGggUdFMUr5I87+1Cb6vzefAtGt8N5VV"
+                + "1F/MXv1gJz4Bu6HyxL/ncfe71jsNhav0i4yAjf2etWFj53zK6R+Ojg5H6wCgpL9/"
+                + "tXVfGP8SqFvyrN/437MlFSUEAIN3V6j/MUllyrZglrtr2+RWIwRrG/ACmrF6hTug"
+                + "Ol4cQxaDYNcntXbhlTlJs9MxjTH3xxzylyirCyq7HzGJxZzSt6FTeh1DFYzhJ7Qu"
+                + "YR1xrSdA6Y0mUv0ixD5A4nPHjupQ5QCqHGeRfFD/oHzD4zqBnJp/BJ3LvQ66bERJ"
+                + "mKl5A/4uj3HoVxpb0vvyENfRqKMmGBISycY4MoH5uWfb23FffsT9r9KL6nJ4syLz"
+                + "aRR0gvcbcjkc9Z3epI7gr3jTrb4d8WPxsDbT/W1tv9bG/EHawomLcihtuUU68Uej"
+                + "6/wZot1XJqu2nQlku57+M/V2X1y26VKsipolPfja4uyBOOyvbP4DAwIDIBTxWjkC"
+                + "GGAWQO2jy9CTvLHJEoTO7moHrp1FxOVpQ8iJHyRqZzLllO26OzgohbiPYz8u9qCu"
+                + "lZ9Xn7QzRXJpYyBFY2hpZG5hIChEU0EgVGVzdCBLZXkpIDxlcmljQGJvdW5jeWNh"
+                + "c3RsZS5vcmc+iFkEExECABkFAj9HBzUECwcDAgMVAgMDFgIBAh4BAheAAAoJEM0j"
+                + "9enEyjRDAlwAnjTjjt57NKIgyym7OTCwzIU3xgFpAJ0VO5m5PfQKmGJRhaewLSZD"
+                + "4nXkHg==");
+
+    byte[] testPrivKey2 =
+        Base64.decode(
+               "lQHhBEAnoewRBADRvKgDhbV6pMzqYfUgBsLxSHzmycpuxGbjMrpyKHDOEemj"
+             + "iQb6TyyBKUoR28/pfshFP9R5urtKIT7wjVrDuOkxYkgRhNm+xmPXW2Lw3D++"
+             + "MQrC5VWe8ywBltz6T9msmChsaKo2hDhIiRI/mg9Q6rH9pJKtVGi4R7CgGxM2"
+             + "STQ5fwCgub38qGS1W2O4hUsa+3gva5gaNZUEAItegda4/H4t88XdWxW3D8pv"
+             + "RnFz26/ADdImVaQlBoumD15VmcgYoT1Djizey7X8vfV+pntudESzLbn3GHlI"
+             + "6C09seH4e8eYP63t7KU/qbUCDomlSswd1OgQ/RxfN86q765K2t3K1i3wDSxe"
+             + "EgSRyGKee0VNvOBFOFhuWt+patXaBADE1riNkUxg2P4lBNWwu8tEZRmsl/Ys"
+             + "DBIzXBshoMzZCvS5PnNXMW4G3SAaC9OC9jvKSx9IEWhKjfjs3QcWzXR28mcm"
+             + "5na0bTxeOMlaPPhBdkTCmFl0IITWlH/pFlR2ah9WYoWYhZEL2tqB82wByzxH"
+             + "SkSeD9V5oeSCdCcqiqkEmv4DAwLeNsQ2XGJVRmA4lld+CR5vRxpT/+/2xklp"
+             + "lxVf/nx0+thrHDpro3u/nINIIObk0gh59+zaEEe3APlHqbQVYWFhIGJiYiA8"
+             + "Y2NjQGRkZC5lZWU+iFoEExECABoFAkAnoewFCwcDAgEDFQIDAxYCAQIeAQIX"
+             + "gAAKCRA5nBpCS63az85BAKCbPfU8ATrFvkXhzGNGlc1BJo6DWQCgnK125xVK"
+             + "lWLpt6ZJJ7TXcx3nkm6wAgAAnQFXBEAnoe0QBACsQxPvaeBcv2TkbgU/5Wc/"
+             + "tO222dPE1mxFbXjGTKfb+6ge96iyD8kTRLrKCkEEeVBa8AZqMSoXUVN6tV8j"
+             + "/zD8Bc76o5iJ6wgpg3Mmy2GxInVfsfZN6/G3Y2ukmouz+CDNvQdUw8cTguIb"
+             + "QoV3XhQ03MLbfVmNcHsku9F4CuKNWwADBQP0DSSe8v5PXF9CSCXOIxBDcQ5x"
+             + "RKjyYOveqoH/4lbOV0YNUbIDZq4RaUdotpADuPREFmWf0zTB6KV/WIiag8XU"
+             + "WU9zdDvLKR483Bo6Do5pDBcN+NqfQ+ntGY9WJ7BSFnhQ3+07i1K+NsfFTRfv"
+             + "hf9X3MP75rCf7MxAIWHTabEmUf4DAwLeNsQ2XGJVRmA8DssBUCghogG9n8T3"
+             + "qfBeKsplGyCcF+JjPeQXkKQaoYGJ0aJz36qFP9d8DuWtT9soQcqIxVf6mTa8"
+             + "kN1594hGBBgRAgAGBQJAJ6HtAAoJEDmcGkJLrdrPpMkAnRyjQSKugz0YJqOB"
+             + "yGasMLQLxd2OAKCEIlhtCarlufVQNGZsuWxHVbU8crACAAA=");
+
+    byte[] sig1 =
+        Base64.decode(
+            "owGbwMvMwCR4VvnryyOnTJwZ10gncZSkFpfolVSU2Ltz78hIzcnJVyjPL8pJUeTq"
+                + "sGdmZQCJwpQLMq3ayTA/0Fj3xf4jbwPfK/H3zj55Z9L1n2k/GOapKJrvMZ4tLiCW"
+                + "GtP/XeDqX4fORDUA");
+
+    byte[] sig1crc = Base64.decode("OZa/");
+
+    byte[] testPubWithUserAttr =
+        Base64.decode(
+           "mQGiBD2Rqv0RBADqKCkhVEtB/lEEr/9CubuHEy2oN/yU5j+2GXSdcNdVnRI/rwFy"
+         + "fHEQIk3uU7zHSUKFrC59yDm0sODYyjEdE3BVb0xvEJ5LE/OdndcIMXT1DungZ1vB"
+         + "zIK/3lr33W/PHixYxv9jduH3WrTehBpiKkgMZp8XloSFj2Cnw9LDyfqB7QCg/8K1"
+         + "o2k75NkOd9ZjnA9ye7Ri3bEEAKyr61Mo7viPWBK1joWAEsxG0OBWM+iSlG7kwh31"
+         + "8efgC/7Os6x4Y0jzs8mpcbBjeZtZjS9lRbfp7RinhF269xL0TZ3JxIdtaAV/6yDQ"
+         + "9NXfZY9dskN++HIR/5GCEEgq/qTJZt6ti5k7aV19ZFfO6wiK3NUy08wOrVsdOkVE"
+         + "w9IcBADaplhpcel3201uU3OCboogJtw81R5MJMZ4Y9cKL/ca2jGISn0nA7KrAw9v"
+         + "ShheSixGO4BV9JECkLEbtg7i+W/j/De6S+x2GLNcphuTP3UmgtKbhs0ItRqzW561"
+         + "s6gLkqi6aWmgaFLd8E1pMJcd9DSY95P13EYB9VJIUxFNUopzo7QcUmFsZiBIYXVz"
+         + "ZXIgPGhhdXNlckBhY20ub3JnPokAWAQQEQIAGAUCPZGq/QgLAwkIBwIBCgIZAQUb"
+         + "AwAAAAAKCRAqIBiOh4JvOKg4AJ9j14yygOqqzqiLKeaasIzqT8LCIgCggx14WuLO"
+         + "wOUTUswTaVKMFnU7tseJAJwEEAECAAYFAj2Rqx8ACgkQ9aWTKMpUDFV+9QP/RiWT"
+         + "5FAF5Rgb7beaApsgXsME+Pw7HEYFtqGa6VcXEpbcUXO6rjaXsgMgY90klWlWCF1T"
+         + "HOyKITvj2FdhE+0j8NQn4vaGpiTwORW/zMf/BZ0abdSWQybp10Yjs8gXw30UheO+"
+         + "F1E524MC+s2AeUi2hwHMiS+AVYd4WhxWHmWuBpTRypP/AAALTgEQAAEBAAAAAQAA"
+         + "AAABAAAA/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAoHBwgHBgoICAgLCgoLDhgQ"
+         + "Dg0NDh0VFhEYIx8lJCIfIiEmKzcvJik0KSEiMEExNDk7Pj4+JS5ESUM8SDc9Pjv/"
+         + "2wBDAQoLCw4NDhwQEBw7KCIoOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7"
+         + "Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozv/wAARCABqAF0DASIAAhEBAxEB/8QAHwAAAQUB"
+         + "AQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQID"
+         + "AAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0"
+         + "NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKT"
+         + "lJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl"
+         + "5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL"
+         + "/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHB"
+         + "CSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpj"
+         + "ZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3"
+         + "uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIR"
+         + "AxEAPwD2aiiq9xcxWsRllcKqjOT06E/0oAsVm6jrmm6VGXvLuOPGflz8x+grzXxV"
+         + "8U51u5LXRgBGowZHXknnkc9OQcV51caneXdw9xPOXlckl2AJHY4J6cD1oA9J1z4p"
+         + "TRkrYQhRyQ0hIY5/2QRx7k9ulczN8SvEEshdZkX0UorDrznI759a5Mksckkknqec"
+         + "mkoA7WD4oavEoEttbTepYEZ+mCMVv6H8SLTULhbe/gFozAYkD5Unp3Ax/kV5XRQB"
+         + "9EAhgCDkHkEcgilryTwd4zn0m4WzvpTJZSMBuY5MfbueletKyugZWDKwyCOc/j3o"
+         + "AduyWLDeWB5Ynj8jSUUUAdFXn/xU15dO0RbGGYC5uWwUB6L1Jx+n413F1cJa2stz"
+         + "J92JC5+gGa+bdfvp9S1q4urmRneQg5Yk4HGAPYZoAzySxySSSep5yaSvQvAPhOHU"
+         + "rB7u5iLGUlIwQRx7HPr/AJ9LGsfC+dJGngc+X12gc8nvx1/rQB5rRXS3Xg28t9ye"
+         + "VLvA7Ddj8MDt6Vnx6JKJCsocnBwqqQSOxPH+fWgDKorTl0SaLGXxkZ+ZcZ4z1yfb"
+         + "P1qg0MqLueN1A6kqRigCOvVPh74mF9YjS7tgLi3GIm6b17c+oOfrXlda3haeW38R"
+         + "WjxfeMgBOCcD/PHpzQB7nRRRQBqarZjUNLubPJXz4yhI64PFfO3iDRrnRtdm0+cq"
+         + "0ocEbehzyOv1xX0vXnHxU8Kf2hYf23aRk3VsMTAZO6MZ5x7UAbfga1W00WzjRSF8"
+         + "kbsg5z744HT/ADmuoysikdQSVP8AI1yPgq6il0axk27V8sDcTg5x7V1qSxOcJIrH"
+         + "/ZOaAKV5p8JgJSPJGMr97PNcxqOiRXLiRI8nONoIGO55z/8AqyeldhPcQxwyOzoQ"
+         + "owRkflXH6t4q0nTLjy57mNXfJCA5x+Qx0NAGXd6LD5iiaPYwTAAx07+vXvXOXmiR"
+         + "Qu6u5VTk/MQQV7cdvxPT866KbxTpt7HGR8p7SMw5HuOP8/Ws/ULlb2No0bKMOGBJ"
+         + "BHrjHHXn6D8QDzWZQk8iAYVWIA9K6LwDZNeeJ4sEqsaF2YHBHpz2/wA/WsG+V0vZ"
+         + "kkGGVsEZz9OcntXffC62iiS7vJTsklKxRFuAw6nBP+eKAPRKKKKAOiqOSNJYzHIo"
+         + "ZGGCD0NSUUAeRajIunwzQG4e3tYZTHGsPzOxJ6ADuQcH8Pw5v+19Q0rVJVgl1JG3"
+         + "cxykEj13cnHT1r1C38OQ3l063cIkkhmkZDKSeCfx9R/kVLeeGIRKs7hVVDn5OCx9"
+         + "yeTjqMf0oAo3k1xP4biuJFeKV4w7gDaQcen1/wAjt5gbK81HW41kIiJBZppULe47"
+         + "eoxx+YzivW9Vh/0FAE+XPIJGCOR0rnbPT7eG+LyxlkAG1wQSPXrjvg9MfjQBycNj"
+         + "4hMRZgJkUjETQqAy/UAY6DoO/wCNbVlYTNbSNJbmBlBwoUfM30B7j2/lz20VhbKA"
+         + "wHmZOQWbOfyrO1G3jil8tBhWToOcdu+c/wAvagDzbUdGlu9aRxFiB/vsuBggZOfq"
+         + "cfWujSIR2dnNZTEeXKgMcb4BUHjofbjNKmI5juiabaGGxVJLcdh/nFWtI0oxagsD"
+         + "DIkkWXYp4VQDnOemSfyHbigDtgSQMjBI6HqKKKKAOiopoPXjGKdQBnXLiDUI5SMK"
+         + "VwxHGf8APFUtW1A+YkMKmbnc23njuf6D/ObWquoaNSQCM/rwP1rMYxxTGWR1UsoU"
+         + "biAcdep+o/KgDG1LxdpracIirCVRjaykHr6cHGQe1cv/AGjNcXBW3sntyT/rHcjj"
+         + "Hp6Z+nQdAK6PXIdIvcE3Fv5rEfNgP9eRn8c8d/rgzX2i2sqo1y8745CD5WPseOnH"
+         + "f8aANiz1O9gjiR5FMUhAV1wcH0Ix6jHHSrMsskz7pGy2MZNc8PEEM7xxWsM/lr8r"
+         + "b4jtI9CcHt7nr7Vqi4JuEjB2qse9y2Ace47dRn/OQDMuRMl8RHw7SgDBPGT6jpwf"
+         + "yzXa2NmbYF3IMrDB2kkAe3HP5Vwk99u1hdg3ANuOOOB0z6ZwPz6c8eiAhgCDkHkE"
+         + "cgigBaKKKAOiqJiMEb9mBknjim3LFIGcOU285ArNa8mKIN3QclScn6+/FADL9xOc"
+         + "K2Tj7xAxnAwQPqOmawdSNpeSJBfQyGNXwQpIAPvjqOPyPT12nYsxYnJIGSeMnHP+"
+         + "e9UL7TUumEqOYp1GNw6N/vDv/wDXoA5+70vSbFGlhtopUxkBl3EZ45z7/kKwTdpN"
+         + "cIsOmeSCduUiCnB9cdeg/M/j0v8AbFtY5hu0gjmGSRICT19cdMDt3+lULzxPZGZv"
+         + "LXcBnCrwB6Y4PX+ZoAptMRbiMDAGSSMksf8A9Q6DuKzJtVYs+BvcPgMTkEdOTnrx"
+         + "/KoLzVmvZZQjjaT82DyPbqcdx+GKitLf7TNsLYAGWPfH+TQBcsYJDE0rOyu4wjHk"
+         + "gfQ+p/zzWjpnja5sdSOm6yyK0Z2pMCQjZ+6SM9CCMdhnp3E1hYy393FaW0eXfjAx"
+         + "gAdT26D+X4Vg/EuFLbxOsCYBitkQkEdsgcADsB+lAHplvqUbsu5vlYA5PIB7468e"
+         + "nPf8lfUlDkRRrIvqZNn6EV41o3iO/wBFcCJ/MhBP7pjwD6g9ua7G08b6TcRl7h5L"
+         + "eTPKvGz5+hUH9cUAeo3uFDrt+Y4O7HOOB69Pr/8AXqhUlx/r2/z2qOgBCQoJJwBy"
+         + "SeABXHeIfHVvbXcemaW4luHlVJJlIKxjODgg8nqKq/Em6uItOhWOeVAx5CuRnrXn"
+         + "+jf8hyw/6+Y//QhQB6xrmlxzXc0NyuHVyQcdjnBz379D1BGeK5u88LMJGlt2RlX7"
+         + "qkEsPXn6/pXo/ilVzbttG7DDOOeornqAONbRpI4v3pKOQcAqQD+Y/P6j052NK0p5"
+         + "HWHy3IBPyqrfN6gZz+P4/hpXoGzOOiP/ACNdH4XRftsp2jIBxx70AX9E0pdMtvMm"
+         + "VRNt5xyEGOgPf3NeDeLdVOs+J768zlGkKx+yjgfy/WvoPXeNEvMcfujXzJQAUUUU"
+         + "Af/ZiQBGBBARAgAGBQI9katEAAoJECogGI6Hgm84xz8AoNGz1fJrVPxqkBrUDmWA"
+         + "GsP6qVGYAJ0ZOftw/GfQHzdGR8pOK85DLUPEErQkUmFsZiBIYXVzZXIgPGhhdXNl"
+         + "ckBwcml2YXNwaGVyZS5jb20+iQBGBBARAgAGBQI9katmAAoJECogGI6Hgm84m0oA"
+         + "oJS3CTrgpqRZfhgPtHGtUVjRCJbbAJ9stJgPcbqA2xXEg9yl2TQToWdWxbQkUmFs"
+         + "ZiBIYXVzZXIgPGhhdXNlckBwcml2YXNwaGVyZS5vcmc+iQBGBBARAgAGBQI9kauJ"
+         + "AAoJECogGI6Hgm84GfAAnRswktLMzDfIjv6ni76Qp5B850byAJ90I0LEHOLhda7r"
+         + "kqTwZ8rguNssUrQkUmFsZiBIYXVzZXIgPGhhdXNlckBwcml2YXNwaGVyZS5uZXQ+"
+         + "iQBGBBARAgAGBQI9kaubAAoJECogGI6Hgm84zi0An16C4s/B9Z0/AtfoN4ealMh3"
+         + "i3/7AJ9Jg4GOUqGCGRRKUA9Gs5pk8yM8GbQmUmFsZiBDLiBIYXVzZXIgPHJhbGZo"
+         + "YXVzZXJAYmx1ZXdpbi5jaD6JAEYEEBECAAYFAj2Rq8oACgkQKiAYjoeCbzhPOACg"
+         + "iiTohKuIa66FNiI24mQ+XR9nTisAoLmh3lJf16/06qLPsRd9shTkLfmHtB9SYWxm"
+         + "IEhhdXNlciA8cmFsZmhhdXNlckBnbXguY2g+iQBGBBARAgAGBQI9kavvAAoJECog"
+         + "GI6Hgm84ZE8An0RlgL8mPBa/P08S5e/lD35MlDdgAJ99pjCeY46S9+nVyx7ACyKO"
+         + "SZ4OcLQmUmFsZiBIYXVzZXIgPGhhdXNlci5yYWxmQG15c3VucmlzZS5jaD6JAEYE"
+         + "EBECAAYFAj2RrEEACgkQKiAYjoeCbzjz0wCg+q801XrXk+Rf+koSI50MW5OaaKYA"
+         + "oKOVA8SLxE29qSR/bJeuW0ryzRLqtCVSYWxmIEhhdXNlciA8aGF1c2VyLnJhbGZA"
+         + "ZnJlZXN1cmYuY2g+iQBGBBARAgAGBQI9kaxXAAoJECogGI6Hgm848zoAnRBtWH6e"
+         + "fTb3is63s8J2zTfpsyS0AKDxTjl+ZZV0COHLrSCaNLZVcpImFrkEDQQ9kar+EBAA"
+         + "+RigfloGYXpDkJXcBWyHhuxh7M1FHw7Y4KN5xsncegus5D/jRpS2MEpT13wCFkiA"
+         + "tRXlKZmpnwd00//jocWWIE6YZbjYDe4QXau2FxxR2FDKIldDKb6V6FYrOHhcC9v4"
+         + "TE3V46pGzPvOF+gqnRRh44SpT9GDhKh5tu+Pp0NGCMbMHXdXJDhK4sTw6I4TZ5dO"
+         + "khNh9tvrJQ4X/faY98h8ebByHTh1+/bBc8SDESYrQ2DD4+jWCv2hKCYLrqmus2UP"
+         + "ogBTAaB81qujEh76DyrOH3SET8rzF/OkQOnX0ne2Qi0CNsEmy2henXyYCQqNfi3t"
+         + "5F159dSST5sYjvwqp0t8MvZCV7cIfwgXcqK61qlC8wXo+VMROU+28W65Szgg2gGn"
+         + "VqMU6Y9AVfPQB8bLQ6mUrfdMZIZJ+AyDvWXpF9Sh01D49Vlf3HZSTz09jdvOmeFX"
+         + "klnN/biudE/F/Ha8g8VHMGHOfMlm/xX5u/2RXscBqtNbno2gpXI61Brwv0YAWCvl"
+         + "9Ij9WE5J280gtJ3kkQc2azNsOA1FHQ98iLMcfFstjvbzySPAQ/ClWxiNjrtVjLhd"
+         + "ONM0/XwXV0OjHRhs3jMhLLUq/zzhsSlAGBGNfISnCnLWhsQDGcgHKXrKlQzZlp+r"
+         + "0ApQmwJG0wg9ZqRdQZ+cfL2JSyIZJrqrol7DVes91hcAAgIQAKD9MGkS8SUD2irI"
+         + "AiwVHU0WXLBnk2CvvueSmT9YtC34UKkIkDPZ7VoeuXDfqTOlbiE6T16zPvArZfbl"
+         + "JGdrU7HhsTdu+ADxRt1dPur0G0ICJ3pBD3ydGWpdLI/94x1BvTY4rsR5mS4YWmpf"
+         + "e2kWc7ZqezhP7Xt9q7m4EK456ddeUZWtkwGU+PKyRAZ+CK82Uhouw+4aW0NjiqmX"
+         + "hfH9/BUhI1P/8R9VkTfAFGPmZzqoHr4AuO5tLRLD2RFSmQCP8nZTiP9nP+wBBvn7"
+         + "vuqKRQsj9PwwPD4V5SM+kpW+rUIWr9TZYl3UqSnlXlpEZFd2Bfl6NloeH0cfU69E"
+         + "gtjcWGvGxYKPS0cg5yhVb4okka6RqIPQiYl6eJgv4tRTKoPRX29o0aUVdqVvDr5u"
+         + "tnFzcINq7jTo8GiO8Ia3cIFWfo0LyQBd1cf1U+eEOz+DleEFqyljaz9VCbDPE4GP"
+         + "o+ALESBlOwn5daUSaah9iU8aVPaSjn45hoQqxOKPwJxnCKKQ01iy0Gir+CDU8JJB"
+         + "7bmbvQN4bke30EGAeED3oi+3VaBHrhjYLv7SHIxP5jtCJKWMJuLRV709HsWJi3kn"
+         + "fGHwH+yCDF8+PDeROAzpXBaD2EFhKgeUTjP5Rgn6ltRf8TQnfbW4qlwyiXMhPOfC"
+         + "x6qNmwaFPKQJpIkVq5VGfRXAERfkiQBMBBgRAgAMBQI9kar+BRsMAAAAAAoJECog"
+         + "GI6Hgm84CDMAoNrNeP4c8XqFJnsLLPcjk5YGLaVIAKCrL5KFuLQVIp7d0Fkscx3/"
+         + "7DGrzw==");
+
+    byte[] aesSecretKey = Base64.decode(
+            "lQHpBEBSdIYRBADpd7MeIxRk4RsvyMnJNIYe4FiVv6i7I7+LPRvnIjDct0bN"
+          + "1gCV48QFej7g/PsvXRjYSowV3VIvchWX8OERd/5i10cLbcs7X52EP1vwYaLj"
+          + "uRfNUBg8Q51RQsKR+/rBmnVsi68rjU4yTH6wpo6FOO4pz4wFV+tWwGOwOitA"
+          + "K31L4wCgqh59eFFBrOlRFAbDvaL7emoCIR8EAOLxDKiLQJYQrKZfXdZnifeo"
+          + "dhEP0uuV4O5TG6nrqkhWffzC9cSoFD0BhMl979d8IB2Uft4FNvQc2u8hbJL5"
+          + "7OCGDCUAidlB9jSdu0/J+kfRaTGhYDjBgw7AA42576BBSMNouJg/aOOQENEN"
+          + "Nn4n7NxR3viBzIsL/OIeU8HSkBgaA/41PsvcgZ3kwpdltJ/FVRWhmMmv/q/X"
+          + "qp1YOnF8xPU9bv2ofELrxJfRsbS4GW1etzD+nXs/woW4Vfixs01x+cutR4iF"
+          + "3hw+eU+yLToMPmmo8D2LUvX1SRODJpx5yBBeRIYv6nz9H3sQRDx3kaLASxDV"
+          + "jTxKmrLYnZz5w5qyVpvRyv4JAwKyWlhdblPudWBFXNkW5ydKn0AV2f51wEtj"
+          + "Zy0aLIeutVMSJf1ytLqjFqrnFe6pdJrHO3G00TE8OuFhftWosLGLbEGytDtF"
+          + "cmljIEguIEVjaGlkbmEgKHRlc3Qga2V5IC0gQUVTMjU2KSA8ZXJpY0Bib3Vu"
+          + "Y3ljYXN0bGUub3JnPohZBBMRAgAZBQJAUnSGBAsHAwIDFQIDAxYCAQIeAQIX"
+          + "gAAKCRBYt1NnUiCgeFKaAKCiqtOO+NQES1gJW6XuOGmSkXt8bQCfcuW7SXZH"
+          + "zxK1FfdcG2HEDs3YEVawAgAA");
+
+    byte[] aesPublicKey = Base64.decode(
+            "mQGiBEBSdIYRBADpd7MeIxRk4RsvyMnJNIYe4FiVv6i7I7+LPRvnIjDct0bN"
+          + "1gCV48QFej7g/PsvXRjYSowV3VIvchWX8OERd/5i10cLbcs7X52EP1vwYaLj"
+          + "uRfNUBg8Q51RQsKR+/rBmnVsi68rjU4yTH6wpo6FOO4pz4wFV+tWwGOwOitA"
+          + "K31L4wCgqh59eFFBrOlRFAbDvaL7emoCIR8EAOLxDKiLQJYQrKZfXdZnifeo"
+          + "dhEP0uuV4O5TG6nrqkhWffzC9cSoFD0BhMl979d8IB2Uft4FNvQc2u8hbJL5"
+          + "7OCGDCUAidlB9jSdu0/J+kfRaTGhYDjBgw7AA42576BBSMNouJg/aOOQENEN"
+          + "Nn4n7NxR3viBzIsL/OIeU8HSkBgaA/41PsvcgZ3kwpdltJ/FVRWhmMmv/q/X"
+          + "qp1YOnF8xPU9bv2ofELrxJfRsbS4GW1etzD+nXs/woW4Vfixs01x+cutR4iF"
+          + "3hw+eU+yLToMPmmo8D2LUvX1SRODJpx5yBBeRIYv6nz9H3sQRDx3kaLASxDV"
+          + "jTxKmrLYnZz5w5qyVpvRyrQ7RXJpYyBILiBFY2hpZG5hICh0ZXN0IGtleSAt"
+          + "IEFFUzI1NikgPGVyaWNAYm91bmN5Y2FzdGxlLm9yZz6IWQQTEQIAGQUCQFJ0"
+          + "hgQLBwMCAxUCAwMWAgECHgECF4AACgkQWLdTZ1IgoHhSmgCfU83BLBF2nCua"
+          + "zk2dXB9zO1l6XS8AnA07U4cq5W0GrKM6/kP9HWtPhgOFsAIAAA==");
+
+    byte[] twofishSecretKey = Base64.decode(
+            "lQHpBEBSdtIRBACf7WfrqTl8F051+EbaljPf/8/ajFpAfMq/7p3Hri8OCsuc"
+          + "fJJIufEEOV1/Lt/wkN67MmSyrU0fUCsRbEckRiB4EJ0zGHVFfAnku2lzdgc8"
+          + "AVounqcHOmqA/gliFDEnhYOx3bOIAOav+yiOqfKVBhWRCpFdOTE+w/XoDM+p"
+          + "p8bH5wCgmP2FuWpzfSut7GVKp51xNEBRNuED/3t2Q+Mq834FVynmLKEmeXB/"
+          + "qtIz5reHEQR8eMogsOoJS3bXs6v3Oblj4in1gLyTVfcID5tku6kLP20xMRM2"
+          + "zx2oRbz7TyOCrs15IpRXyqqJxUWD8ipgJPkPXE7hK8dh4YSTUi4i5a1ug8xG"
+          + "314twlPzrchpWZiutDvZ+ks1rzOtBACHrEFG2frUu+qVkL43tySE0cV2bnuK"
+          + "LVhXbpzF3Qdkfxou2nuzsCbl6m87OWocJX8uYcQGlHLKv8Q2cfxZyieLFg6v"
+          + "06LSFdE9drGBWz7mbrT4OJjxPyvnkffPfLOOqae3PMYIIuscvswuhm4X5aoj"
+          + "KJs01YT3L6f0iIj03hCeV/4KAwLcGrxT3X0qR2CZyZYSVBdjXeNYKXuGBtOf"
+          + "ood26WOtwLw4+l9sHVoiXNv0LomkO58ndJRPGCeZWZEDMVrfkS7rcOlktDxF"
+          + "cmljIEguIEVjaGlkbmEgKHRlc3Qga2V5IC0gdHdvZmlzaCkgPGVyaWNAYm91"
+          + "bmN5Y2FzdGxlLm9yZz6IWQQTEQIAGQUCQFJ20gQLBwMCAxUCAwMWAgECHgEC"
+          + "F4AACgkQaCCMaHh9zR2+RQCghcQwlt4B4YmNxp2b3v6rP3E8M0kAn2Gspi4u"
+          + "A/ynoqnC1O8HNlbjPdlVsAIAAA==");
+
+    byte[] twofishPublicKey = Base64.decode(
+            "mQGiBEBSdtIRBACf7WfrqTl8F051+EbaljPf/8/ajFpAfMq/7p3Hri8OCsuc"
+          + "fJJIufEEOV1/Lt/wkN67MmSyrU0fUCsRbEckRiB4EJ0zGHVFfAnku2lzdgc8"
+          + "AVounqcHOmqA/gliFDEnhYOx3bOIAOav+yiOqfKVBhWRCpFdOTE+w/XoDM+p"
+          + "p8bH5wCgmP2FuWpzfSut7GVKp51xNEBRNuED/3t2Q+Mq834FVynmLKEmeXB/"
+          + "qtIz5reHEQR8eMogsOoJS3bXs6v3Oblj4in1gLyTVfcID5tku6kLP20xMRM2"
+          + "zx2oRbz7TyOCrs15IpRXyqqJxUWD8ipgJPkPXE7hK8dh4YSTUi4i5a1ug8xG"
+          + "314twlPzrchpWZiutDvZ+ks1rzOtBACHrEFG2frUu+qVkL43tySE0cV2bnuK"
+          + "LVhXbpzF3Qdkfxou2nuzsCbl6m87OWocJX8uYcQGlHLKv8Q2cfxZyieLFg6v"
+          + "06LSFdE9drGBWz7mbrT4OJjxPyvnkffPfLOOqae3PMYIIuscvswuhm4X5aoj"
+          + "KJs01YT3L6f0iIj03hCeV7Q8RXJpYyBILiBFY2hpZG5hICh0ZXN0IGtleSAt"
+          + "IHR3b2Zpc2gpIDxlcmljQGJvdW5jeWNhc3RsZS5vcmc+iFkEExECABkFAkBS"
+          + "dtIECwcDAgMVAgMDFgIBAh4BAheAAAoJEGggjGh4fc0dvkUAn2QGdNk8Wrrd"
+          + "+DvKECrO5+yoPRx3AJ91DhCMme6uMrQorKSDYxHlgc7iT7ACAAA=");
+
+    char[] pass = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd' };
+
+    /**
+     * Generated signature test
+     * 
+     * @param sKey
+     * @param pgpPrivKey
+     */
+    public void generateTest(
+        PGPSecretKeyRing sKey,
+        PGPPublicKey     pgpPubKey,
+        PGPPrivateKey    pgpPrivKey)
+        throws Exception
+    {
+        String                  data = "hello world!";
+        ByteArrayOutputStream   bOut = new ByteArrayOutputStream();
+        ByteArrayInputStream    testIn = new ByteArrayInputStream(data.getBytes());
+        PGPSignatureGenerator   sGen = new PGPSignatureGenerator(new BcPGPContentSignerBuilder(PublicKeyAlgorithmTags.DSA, HashAlgorithmTags.SHA1));
+    
+        sGen.init(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);
+
+        PGPSignatureSubpacketGenerator spGen = new PGPSignatureSubpacketGenerator();
+        
+        Iterator        it = sKey.getSecretKey().getPublicKey().getUserIDs();
+        String          primaryUserID = (String)it.next();
+        
+        spGen.setSignerUserID(true, primaryUserID);
+        
+        sGen.setHashedSubpackets(spGen.generate());
+
+        sGen.generateOnePassVersion(false).encode(bOut);
+
+        PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();
+        
+        Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);
+        OutputStream lOut = lGen.open(
+            new UncloseableOutputStream(bOut),
+            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(bOut);
+
+        PGPObjectFactory        pgpFact = new PGPObjectFactory(bOut.toByteArray());
+
+        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.init(new BcPGPContentVerifierBuilderProvider(), pgpPubKey);
+        
+        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");
+        }
+    }
+    
+    public void performTest()
+        throws Exception
+    {
+        String file = null;
+        PGPPublicKey pubKey = null;
+
+        //
+        // Read the public key
+        //
+        PGPPublicKeyRing        pgpPub = new PGPPublicKeyRing(testPubKey, new BcKeyFingerprintCalculator());
+
+        pubKey = pgpPub.getPublicKey();
+
+        //
+        // Read the private key
+        //
+        PGPSecretKeyRing        sKey = new PGPSecretKeyRing(testPrivKey, new BcKeyFingerprintCalculator());
+        PGPPrivateKey           pgpPrivKey = sKey.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+        
+        //
+        // test signature message
+        //
+        PGPOnePassSignatureList p1;
+
+        PGPOnePassSignature ops;
+
+        PGPLiteralData p2;
+
+        InputStream dIn;
+        int ch;
+
+
+        PGPObjectFactory        pgpFact = new PGPObjectFactory(sig1);
+//          compressed data not supported
+//        PGPOnePassSignatureList p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
+//
+//        PGPOnePassSignature     ops = p1.get(0);
+//
+//        PGPLiteralData          p2 = (PGPLiteralData)pgpFact.nextObject();
+//
+//        InputStream             dIn = p2.getInputStream();
+//        int                     ch;
+//
+//        ops.init(new BcPGPContentVerifierBuilderProvider(), pubKey);
+//
+//        while ((ch = dIn.read()) >= 0)
+//        {
+//            ops.update((byte)ch);
+//        }
+//
+//        PGPSignatureList        p3 = (PGPSignatureList)pgpFact.nextObject();
+//
+//        if (!ops.verify(p3.get(0)))
+//        {
+//            fail("Failed signature check");
+//        }
+        
+        //
+        // signature generation
+        //
+        generateTest(sKey, pubKey, pgpPrivKey);
+        
+        //
+        // signature generation - canonical text
+        //
+        String                      data = "hello world!";
+        ByteArrayOutputStream       bOut = new ByteArrayOutputStream();
+        ByteArrayInputStream        testIn = new ByteArrayInputStream(data.getBytes());
+        PGPSignatureGenerator       sGen = new PGPSignatureGenerator(new BcPGPContentSignerBuilder(PGPPublicKey.DSA, PGPUtil.SHA1));
+
+        sGen.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, pgpPrivKey);
+
+        sGen.generateOnePassVersion(false).encode(bOut);
+
+        PGPLiteralDataGenerator     lGen = new PGPLiteralDataGenerator();
+        Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);
+        OutputStream lOut = lGen.open(
+            new UncloseableOutputStream(bOut),
+            PGPLiteralData.TEXT,
+            "_CONSOLE",
+            data.getBytes().length,
+            testDate);
+
+        while ((ch = testIn.read()) >= 0)
+        {
+            lOut.write(ch);
+            sGen.update((byte)ch);
+        }
+
+        lGen.close();
+
+        sGen.generate().encode(bOut);
+
+        //
+        // verify generated signature - canconical text
+        //
+        pgpFact = new PGPObjectFactory(bOut.toByteArray());
+
+    
+        p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
+    
+        ops = p1.get(0);
+    
+        p2 = (PGPLiteralData)pgpFact.nextObject();
+        if (!p2.getModificationTime().equals(testDate))
+        {
+            fail("Modification time not preserved");
+        }
+
+        dIn = p2.getInputStream();
+
+        ops.init(new BcPGPContentVerifierBuilderProvider(), pubKey);
+    
+        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");
+        }
+        
+        //
+        // Read the public key with user attributes
+        //
+        pgpPub = new PGPPublicKeyRing(testPubWithUserAttr, new BcKeyFingerprintCalculator());
+
+        pubKey = pgpPub.getPublicKey();
+
+        Iterator it = pubKey.getUserAttributes();
+        int      count = 0;
+        while (it.hasNext())
+        {
+            PGPUserAttributeSubpacketVector attributes = (PGPUserAttributeSubpacketVector)it.next();
+            
+            Iterator    sigs = pubKey.getSignaturesForUserAttribute(attributes);
+            int sigCount = 0;
+            while (sigs.hasNext())
+            {
+                sigs.next();
+                
+                sigCount++;
+            }
+            
+            if (sigCount != 1)
+            {
+                fail("Failed user attributes signature check");
+            }
+            count++;
+        }
+
+        if (count != 1)
+        {
+            fail("Failed user attributes check");
+        }
+
+        byte[]  pgpPubBytes = pgpPub.getEncoded();
+
+        pgpPub = new PGPPublicKeyRing(pgpPubBytes, new BcKeyFingerprintCalculator());
+
+           pubKey = pgpPub.getPublicKey();
+
+        it = pubKey.getUserAttributes();
+        count = 0;
+        while (it.hasNext())
+        {
+            it.next();
+            count++;
+        }
+
+        if (count != 1)
+        {
+            fail("Failed user attributes reread");
+        }
+
+        //
+        // reading test extra data - key with edge condition for DSA key password.
+        //
+        char []   passPhrase = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
+
+        sKey = new PGPSecretKeyRing(testPrivKey2, new BcKeyFingerprintCalculator());
+        pgpPrivKey = sKey.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase));
+
+        AsymmetricKeyParameter bytes = new BcPGPKeyConverter().getPrivateKey(pgpPrivKey);
+        
+        //
+        // reading test - aes256 encrypted passphrase.
+        //
+        sKey = new PGPSecretKeyRing(aesSecretKey, new BcKeyFingerprintCalculator());
+        pgpPrivKey = sKey.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+
+        bytes = new BcPGPKeyConverter().getPrivateKey(pgpPrivKey);
+        
+        //
+        // reading test - twofish encrypted passphrase.
+        //
+        sKey = new PGPSecretKeyRing(twofishSecretKey, new BcKeyFingerprintCalculator());
+        pgpPrivKey = sKey.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+
+        bytes = new BcPGPKeyConverter().getPrivateKey(pgpPrivKey);
+        
+        //
+        // use of PGPKeyPair
+        //
+        RSAKeyPairGenerator    kpg = new RSAKeyPairGenerator();
+        
+        kpg.init(new RSAKeyGenerationParameters(BigInteger.valueOf(0x11), new SecureRandom(), 512, 25));
+
+        AsymmetricCipherKeyPair kp = kpg.generateKeyPair();
+        
+        PGPKeyPair    pgpKp = new BcPGPKeyPair(PGPPublicKey.RSA_GENERAL , kp, new Date());
+        
+        PGPPublicKey k1 = pgpKp.getPublicKey();
+        
+        PGPPrivateKey k2 = pgpKp.getPrivateKey();
+    }
+
+    public String getName()
+    {
+        return "BcPGPDSATest";
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new BcPGPDSATest());
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPKeyRingTest.java b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPKeyRingTest.java
new file mode 100644
index 000000000..b0fe290e3
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPKeyRingTest.java
@@ -0,0 +1,2379 @@
+package org.bouncycastle.openpgp.test;
+
+import java.io.ByteArrayInputStream;
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.Date;
+import java.util.Iterator;
+
+import org.bouncycastle.bcpg.HashAlgorithmTags;
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.generators.DSAKeyPairGenerator;
+import org.bouncycastle.crypto.generators.DSAParametersGenerator;
+import org.bouncycastle.crypto.generators.ElGamalKeyPairGenerator;
+import org.bouncycastle.crypto.generators.RSAKeyPairGenerator;
+import org.bouncycastle.crypto.params.DSAKeyGenerationParameters;
+import org.bouncycastle.crypto.params.ElGamalKeyGenerationParameters;
+import org.bouncycastle.crypto.params.ElGamalParameters;
+import org.bouncycastle.crypto.params.RSAKeyGenerationParameters;
+import org.bouncycastle.openpgp.PGPEncryptedData;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPKeyPair;
+import org.bouncycastle.openpgp.PGPKeyRingGenerator;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPPublicKey;
+import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
+import org.bouncycastle.openpgp.PGPSecretKey;
+import org.bouncycastle.openpgp.PGPSecretKeyRing;
+import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
+import org.bouncycastle.openpgp.PGPSignature;
+import org.bouncycastle.openpgp.operator.PGPDigestCalculator;
+import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator;
+import org.bouncycastle.openpgp.operator.bc.BcPBESecretKeyDecryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPBESecretKeyEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentVerifierBuilderProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDigestCalculatorProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyPair;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class BcPGPKeyRingTest
+    extends SimpleTest
+{
+    byte[] pub1 = Base64.decode(
+        "mQGiBEA83v0RBADzKVLVCnpWQxX0LCsevw/3OLs0H7MOcLBQ4wMO9sYmzGYn"
+      + "xpVj+4e4PiCP7QBayWyy4lugL6Lnw7tESvq3A4v3fefcxaCTkJrryiKn4+Cg"
+      + "y5rIBbrSKNtCEhVi7xjtdnDjP5kFKgHYjVOeIKn4Cz/yzPG3qz75kDknldLf"
+      + "yHxp2wCgwW1vAE5EnZU4/UmY7l8kTNkMltMEAJP4/uY4zcRwLI9Q2raPqAOJ"
+      + "TYLd7h+3k/BxI0gIw96niQ3KmUZDlobbWBI+VHM6H99vcttKU3BgevNf8M9G"
+      + "x/AbtW3SS4De64wNSU3189XDG8vXf0vuyW/K6Pcrb8exJWY0E1zZQ1WXT0gZ"
+      + "W0kH3g5ro//Tusuil9q2lVLF2ovJA/0W+57bPzi318dWeNs0tTq6Njbc/GTG"
+      + "FUAVJ8Ss5v2u6h7gyJ1DB334ExF/UdqZGldp0ugkEXaSwBa2R7d3HBgaYcoP"
+      + "Ck1TrovZzEY8gm7JNVy7GW6mdOZuDOHTxyADEEP2JPxh6eRcZbzhGuJuYIif"
+      + "IIeLOTI5Dc4XKeV32a+bWrQidGVzdCAoVGVzdCBrZXkpIDx0ZXN0QHViaWNh"
+      + "bGwuY29tPohkBBMRAgAkBQJAPN79AhsDBQkB4TOABgsJCAcDAgMVAgMDFgIB"
+      + "Ah4BAheAAAoJEJh8Njfhe8KmGDcAoJWr8xgPr75y/Cp1kKn12oCCOb8zAJ4p"
+      + "xSvk4K6tB2jYbdeSrmoWBZLdMLACAAC5AQ0EQDzfARAEAJeUAPvUzJJbKcc5"
+      + "5Iyb13+Gfb8xBWE3HinQzhGr1v6A1aIZbRj47UPAD/tQxwz8VAwJySx82ggN"
+      + "LxCk4jW9YtTL3uZqfczsJngV25GoIN10f4/j2BVqZAaX3q79a3eMiql1T0oE"
+      + "AGmD7tO1LkTvWfm3VvA0+t8/6ZeRLEiIqAOHAAQNBACD0mVMlAUgd7REYy/1"
+      + "mL99Zlu9XU0uKyUex99sJNrcx1aj8rIiZtWaHz6CN1XptdwpDeSYEOFZ0PSu"
+      + "qH9ByM3OfjU/ya0//xdvhwYXupn6P1Kep85efMBA9jUv/DeBOzRWMFG6sC6y"
+      + "k8NGG7Swea7EHKeQI40G3jgO/+xANtMyTIhPBBgRAgAPBQJAPN8BAhsMBQkB"
+      + "4TOAAAoJEJh8Njfhe8KmG7kAn00mTPGJCWqmskmzgdzeky5fWd7rAKCNCp3u"
+      + "ZJhfg0htdgAfIy8ppm05vLACAAA=");
+
+    byte[] sec1 = Base64.decode(
+        "lQHhBEA83v0RBADzKVLVCnpWQxX0LCsevw/3OLs0H7MOcLBQ4wMO9sYmzGYn"
+      + "xpVj+4e4PiCP7QBayWyy4lugL6Lnw7tESvq3A4v3fefcxaCTkJrryiKn4+Cg"
+      + "y5rIBbrSKNtCEhVi7xjtdnDjP5kFKgHYjVOeIKn4Cz/yzPG3qz75kDknldLf"
+      + "yHxp2wCgwW1vAE5EnZU4/UmY7l8kTNkMltMEAJP4/uY4zcRwLI9Q2raPqAOJ"
+      + "TYLd7h+3k/BxI0gIw96niQ3KmUZDlobbWBI+VHM6H99vcttKU3BgevNf8M9G"
+      + "x/AbtW3SS4De64wNSU3189XDG8vXf0vuyW/K6Pcrb8exJWY0E1zZQ1WXT0gZ"
+      + "W0kH3g5ro//Tusuil9q2lVLF2ovJA/0W+57bPzi318dWeNs0tTq6Njbc/GTG"
+      + "FUAVJ8Ss5v2u6h7gyJ1DB334ExF/UdqZGldp0ugkEXaSwBa2R7d3HBgaYcoP"
+      + "Ck1TrovZzEY8gm7JNVy7GW6mdOZuDOHTxyADEEP2JPxh6eRcZbzhGuJuYIif"
+      + "IIeLOTI5Dc4XKeV32a+bWv4CAwJ5KgazImo+sGBfMhDiBcBTqyDGhKHNgHic"
+      + "0Pky9FeRvfXTc2AO+jGmFPjcs8BnTWuDD0/jkQnRZpp1TrQidGVzdCAoVGVz"
+      + "dCBrZXkpIDx0ZXN0QHViaWNhbGwuY29tPohkBBMRAgAkBQJAPN79AhsDBQkB"
+      + "4TOABgsJCAcDAgMVAgMDFgIBAh4BAheAAAoJEJh8Njfhe8KmGDcAn3XeXDMg"
+      + "BZgrZzFWU2IKtA/5LG2TAJ0Vf/jjyq0jZNZfGfoqGTvD2MAl0rACAACdAVgE"
+      + "QDzfARAEAJeUAPvUzJJbKcc55Iyb13+Gfb8xBWE3HinQzhGr1v6A1aIZbRj4"
+      + "7UPAD/tQxwz8VAwJySx82ggNLxCk4jW9YtTL3uZqfczsJngV25GoIN10f4/j"
+      + "2BVqZAaX3q79a3eMiql1T0oEAGmD7tO1LkTvWfm3VvA0+t8/6ZeRLEiIqAOH"
+      + "AAQNBACD0mVMlAUgd7REYy/1mL99Zlu9XU0uKyUex99sJNrcx1aj8rIiZtWa"
+      + "Hz6CN1XptdwpDeSYEOFZ0PSuqH9ByM3OfjU/ya0//xdvhwYXupn6P1Kep85e"
+      + "fMBA9jUv/DeBOzRWMFG6sC6yk8NGG7Swea7EHKeQI40G3jgO/+xANtMyTP4C"
+      + "AwJ5KgazImo+sGBl2C7CFuI+5KM4ZhbtVie7l+OiTpr5JW2z5VgnV3EX9p04"
+      + "LcGKfQvD65+ELwli6yh8B2zGcipqTaYk3QoYNIhPBBgRAgAPBQJAPN8BAhsM"
+      + "BQkB4TOAAAoJEJh8Njfhe8KmG7kAniuRkaFFv1pdCBN8JJXpcorHmyouAJ9L"
+      + "xxmusffR6OI7WgD3XZ0AL8zUC7ACAAA=");
+
+    char[]    pass1 = "qwertzuiop".toCharArray();
+
+    byte[] pub2 = Base64.decode(
+         "mQGiBEBtfW8RBADfWjTxFedIbGBNVgh064D/OCf6ul7x4PGsCl+BkAyheYkr"
+      + "mVUsChmBKoeXaY+Fb85wwusXzyM/6JFK58Rg+vEb3Z19pue8Ixxq7cRtCtOA"
+      + "tOP1eKXLNtTRWJutvLkQmeOa19UZ6ziIq23aWuWKSq+KKMWek2GUnGycnx5M"
+      + "W0pn1QCg/39r9RKhY9cdKYqRcqsr9b2B/AsD/Ru24Q15Jmrsl9zZ6EC47J49"
+      + "iNW5sLQx1qf/mgfVWQTmU2j6gq4ND1OuK7+0OP/1yMOUpkjjcqxFgTnDAAoM"
+      + "hHDTzCv/aZzIzmMvgLsYU3aIMfbz+ojpuASMCMh+te01cEMjiPWwDtdWWOdS"
+      + "OSyX9ylzhO3PiNDks8R83onsacYpA/9WhTcg4bvkjaj66I7wGZkm3BmTxNSb"
+      + "pE4b5HZDh31rRYhY9tmrryCfFnU4BS2Enjj5KQe9zFv7pUBCBW2oFo8i8Osn"
+      + "O6fa1wVN4fBHC6wqWmmpnkFerNPkiC9V75KUFIfeWHmT3r2DVSO3dfdHDERA"
+      + "jFIAioMLjhaX6DnODF5KQrABh7QmU2FpIFB1bGxhYmhvdGxhIDxwc2FpQG15"
+      + "amF2YXdvcmxkLmNvbT6wAwP//4kAVwQQEQIAFwUCQG19bwcLCQgHAwIKAhkB"
+      + "BRsDAAAAAAoJEKXQf/RT99uYmfAAoMKxV5g2owIfmy2w7vSLvOQUpvvOAJ4n"
+      + "jB6xJot523rPAQW9itPoGGekirABZ7kCDQRAbX1vEAgA9kJXtwh/CBdyorrW"
+      + "qULzBej5UxE5T7bxbrlLOCDaAadWoxTpj0BV89AHxstDqZSt90xkhkn4DIO9"
+      + "ZekX1KHTUPj1WV/cdlJPPT2N286Z4VeSWc39uK50T8X8dryDxUcwYc58yWb/"
+      + "Ffm7/ZFexwGq01uejaClcjrUGvC/RgBYK+X0iP1YTknbzSC0neSRBzZrM2w4"
+      + "DUUdD3yIsxx8Wy2O9vPJI8BD8KVbGI2Ou1WMuF040zT9fBdXQ6MdGGzeMyEs"
+      + "tSr/POGxKUAYEY18hKcKctaGxAMZyAcpesqVDNmWn6vQClCbAkbTCD1mpF1B"
+      + "n5x8vYlLIhkmuquiXsNV6TILOwACAgf9F7/nJHDayJ3pBVTTVSq2g5WKUXMg"
+      + "xxGKTvOahiVRcbO03w0pKAkH85COakVfe56sMYpWRl36adjNoKOxaciow74D"
+      + "1R5snY/hv/kBXPBkzo4UMkbANIVaZ0IcnLp+rkkXcDVbRCibZf8FfCY1zXbq"
+      + "d680UtEgRbv1D8wFBqfMt7kLsuf9FnIw6vK4DU06z5ZDg25RHGmswaDyY6Mw"
+      + "NGCrKGbHf9I/T7MMuhGF/in8UU8hv8uREOjseOqklG3/nsI1hD/MdUC7fzXi"
+      + "MRO4RvahLoeXOuaDkMYALdJk5nmNuCL1YPpbFGttI3XsK7UrP/Fhd8ND6Nro"
+      + "wCqrN6keduK+uLABh4kATAQYEQIADAUCQG19bwUbDAAAAAAKCRCl0H/0U/fb"
+      + "mC/0AJ4r1yvyu4qfOXlDgmVuCsvHFWo63gCfRIrCB2Jv/N1cgpmq0L8LGHM7"
+      + "G/KwAWeZAQ0EQG19owEIAMnavLYqR7ffaDPbbq+lQZvLCK/3uA0QlyngNyTa"
+      + "sDW0WC1/ryy2dx7ypOOCicjnPYfg3LP5TkYAGoMjxH5+xzM6xfOR+8/EwK1z"
+      + "N3A5+X/PSBDlYjQ9dEVKrvvc7iMOp+1K1VMf4Ug8Yah22Ot4eLGP0HRCXiv5"
+      + "vgdBNsAl/uXnBJuDYQmLrEniqq/6UxJHKHxZoS/5p13Cq7NfKB1CJCuJXaCE"
+      + "TW2do+cDpN6r0ltkF/r+ES+2L7jxyoHcvQ4YorJoDMlAN6xpIZQ8dNaTYP/n"
+      + "Mx/pDS3shUzbU+UYPQrreJLMF1pD+YWP5MTKaZTo+U/qPjDFGcadInhPxvh3"
+      + "1ssAEQEAAbABh7QuU2FuZGh5YSBQdWxsYWJob3RsYSA8cHNhbmRoeWFAbXlq"
+      + "YXZhd29ybGQuY29tPrADA///iQEtBBABAgAXBQJAbX2jBwsJCAcDAgoCGQEF"
+      + "GwMAAAAACgkQx87DL9gOvoeVUwgAkQXYiF0CxhKbDnuabAssnOEwJrutgCRO"
+      + "CJRQvIwTe3fe6hQaWn2Yowt8OQtNFiR8GfAY6EYxyFLKzZbAI/qtq5fHmN3e"
+      + "RSyNWe6d6e17hqZZL7kf2sVkyGTChHj7Jiuo7vWkdqT2MJN6BW5tS9CRH7Me"
+      + "D839STv+4mAAO9auGvSvicP6UEQikAyCy/ihoJxLQlspfbSNpi0vrUjCPT7N"
+      + "tWwfP0qF64i9LYkjzLqihnu+UareqOPhXcWnyFKrjmg4ezQkweNU2pdvCLbc"
+      + "W24FhT92ivHgpLyWTswXcqjhFjVlRr0+2sIz7v1k0budCsJ7PjzOoH0hJxCv"
+      + "sJQMlZR/e7ABZ7kBDQRAbX2kAQgAm5j+/LO2M4pKm/VUPkYuj3eefHkzjM6n"
+      + "KbvRZX1Oqyf+6CJTxQskUWKAtkzzKafPdS5Wg0CMqeXov+EFod4bPEYccszn"
+      + "cKd1U8NRwacbEpCvvvB84Yl2YwdWpDpkryyyLI4PbCHkeuwx9Dc2z7t4XDB6"
+      + "FyAJTMAkia7nzYa/kbeUO3c2snDb/dU7uyCsyKtTZyTyhTgtl/f9L03Bgh95"
+      + "y3mOUz0PimJ0Sg4ANczF4d04BpWkjLNVJi489ifWodPlHm1hag5drYekYpWJ"
+      + "+3g0uxs5AwayV9BcOkPKb1uU3EoYQw+nn0Kn314Nvx2M1tKYunuVNLEm0PhA"
+      + "/+B8PTq8BQARAQABsAGHiQEiBBgBAgAMBQJAbX2kBRsMAAAAAAoJEMfOwy/Y"
+      + "Dr6HkLoH/RBY8lvUv1r8IdTs5/fN8e/MnGeThLl+JrlYF/4t3tjXYIf5xUj/"
+      + "c9NdjreKYgHfMtrbVM08LlxUVQlkjuF3DIk5bVH9Blq8aXmyiwiM5GrCry+z"
+      + "WiqkpZze1G577C38mMJbHDwbqNCLALMzo+W2q04Avl5sniNnDNGbGz9EjhRg"
+      + "o7oS16KkkD6Ls4RnHTEZ0vyZOXodDHu+sk/2kzj8K07kKaM8rvR7aDKiI7HH"
+      + "1GxJz70fn1gkKuV2iAIIiU25bty+S3wr+5h030YBsUZF1qeKCdGOmpK7e9Of"
+      + "yv9U7rf6Z5l8q+akjqLZvej9RnxeH2Um7W+tGg2me482J+z6WOawAWc=");
+
+    byte[] sec2 = Base64.decode(
+        "lQHpBEBtfW8RBADfWjTxFedIbGBNVgh064D/OCf6ul7x4PGsCl+BkAyheYkr"
+      + "mVUsChmBKoeXaY+Fb85wwusXzyM/6JFK58Rg+vEb3Z19pue8Ixxq7cRtCtOA"
+      + "tOP1eKXLNtTRWJutvLkQmeOa19UZ6ziIq23aWuWKSq+KKMWek2GUnGycnx5M"
+      + "W0pn1QCg/39r9RKhY9cdKYqRcqsr9b2B/AsD/Ru24Q15Jmrsl9zZ6EC47J49"
+      + "iNW5sLQx1qf/mgfVWQTmU2j6gq4ND1OuK7+0OP/1yMOUpkjjcqxFgTnDAAoM"
+      + "hHDTzCv/aZzIzmMvgLsYU3aIMfbz+ojpuASMCMh+te01cEMjiPWwDtdWWOdS"
+      + "OSyX9ylzhO3PiNDks8R83onsacYpA/9WhTcg4bvkjaj66I7wGZkm3BmTxNSb"
+      + "pE4b5HZDh31rRYhY9tmrryCfFnU4BS2Enjj5KQe9zFv7pUBCBW2oFo8i8Osn"
+      + "O6fa1wVN4fBHC6wqWmmpnkFerNPkiC9V75KUFIfeWHmT3r2DVSO3dfdHDERA"
+      + "jFIAioMLjhaX6DnODF5KQv4JAwIJH6A/rzqmMGAG4e+b8Whdvp8jaTGVT4CG"
+      + "M1b65rbiDyAuf5KTFymQBOIi9towgFzG9NXAZC07nEYSukN56tUTUDNVsAGH"
+      + "tCZTYWkgUHVsbGFiaG90bGEgPHBzYWlAbXlqYXZhd29ybGQuY29tPrADA///"
+      + "iQBXBBARAgAXBQJAbX1vBwsJCAcDAgoCGQEFGwMAAAAACgkQpdB/9FP325iZ"
+      + "8ACgwrFXmDajAh+bLbDu9Iu85BSm+84AnieMHrEmi3nbes8BBb2K0+gYZ6SK"
+      + "sAFnnQJqBEBtfW8QCAD2Qle3CH8IF3KiutapQvMF6PlTETlPtvFuuUs4INoB"
+      + "p1ajFOmPQFXz0AfGy0OplK33TGSGSfgMg71l6RfUodNQ+PVZX9x2Uk89PY3b"
+      + "zpnhV5JZzf24rnRPxfx2vIPFRzBhznzJZv8V+bv9kV7HAarTW56NoKVyOtQa"
+      + "8L9GAFgr5fSI/VhOSdvNILSd5JEHNmszbDgNRR0PfIizHHxbLY7288kjwEPw"
+      + "pVsYjY67VYy4XTjTNP18F1dDox0YbN4zISy1Kv884bEpQBgRjXyEpwpy1obE"
+      + "AxnIByl6ypUM2Zafq9AKUJsCRtMIPWakXUGfnHy9iUsiGSa6q6Jew1XpMgs7"
+      + "AAICB/0Xv+ckcNrInekFVNNVKraDlYpRcyDHEYpO85qGJVFxs7TfDSkoCQfz"
+      + "kI5qRV97nqwxilZGXfpp2M2go7FpyKjDvgPVHmydj+G/+QFc8GTOjhQyRsA0"
+      + "hVpnQhycun6uSRdwNVtEKJtl/wV8JjXNdup3rzRS0SBFu/UPzAUGp8y3uQuy"
+      + "5/0WcjDq8rgNTTrPlkODblEcaazBoPJjozA0YKsoZsd/0j9Pswy6EYX+KfxR"
+      + "TyG/y5EQ6Ox46qSUbf+ewjWEP8x1QLt/NeIxE7hG9qEuh5c65oOQxgAt0mTm"
+      + "eY24IvVg+lsUa20jdewrtSs/8WF3w0Po2ujAKqs3qR524r64/gkDAmmp39NN"
+      + "U2pqYHokufIOab2VpD7iQo8UjHZNwR6dpjyky9dVfIe4MA0H+t0ju8UDdWoe"
+      + "IkRu8guWsI83mjGPbIq8lmsZOXPCA8hPuBmL0iaj8TnuotmsBjIBsAGHiQBM"
+      + "BBgRAgAMBQJAbX1vBRsMAAAAAAoJEKXQf/RT99uYL/QAnivXK/K7ip85eUOC"
+      + "ZW4Ky8cVajreAJ9EisIHYm/83VyCmarQvwsYczsb8rABZ5UDqARAbX2jAQgA"
+      + "ydq8tipHt99oM9tur6VBm8sIr/e4DRCXKeA3JNqwNbRYLX+vLLZ3HvKk44KJ"
+      + "yOc9h+Dcs/lORgAagyPEfn7HMzrF85H7z8TArXM3cDn5f89IEOViND10RUqu"
+      + "+9zuIw6n7UrVUx/hSDxhqHbY63h4sY/QdEJeK/m+B0E2wCX+5ecEm4NhCYus"
+      + "SeKqr/pTEkcofFmhL/mnXcKrs18oHUIkK4ldoIRNbZ2j5wOk3qvSW2QX+v4R"
+      + "L7YvuPHKgdy9DhiismgMyUA3rGkhlDx01pNg/+czH+kNLeyFTNtT5Rg9Cut4"
+      + "kswXWkP5hY/kxMpplOj5T+o+MMUZxp0ieE/G+HfWywARAQABCWEWL2cKQKcm"
+      + "XFTNsWgRoOcOkKyJ/osERh2PzNWvOF6/ir1BMRsg0qhd+hEcoWHaT+7Vt12i"
+      + "5Y2Ogm2HFrVrS5/DlV/rw0mkALp/3cR6jLOPyhmq7QGwhG27Iy++pLIksXQa"
+      + "RTboa7ZasEWw8zTqa4w17M5Ebm8dtB9Mwl/kqU9cnIYnFXj38BWeia3iFBNG"
+      + "PD00hqwhPUCTUAcH9qQPSqKqnFJVPe0KQWpq78zhCh1zPUIa27CE86xRBf45"
+      + "XbJwN+LmjCuQEnSNlloXJSPTRjEpla+gWAZz90fb0uVIR1dMMRFxsuaO6aCF"
+      + "QMN2Mu1wR/xzTzNCiQf8cVzq7YkkJD8ChJvu/4BtWp3BlU9dehAz43mbMhaw"
+      + "Qx3NmhKR/2dv1cJy/5VmRuljuzC+MRtuIjJ+ChoTa9ubNjsT6BF5McRAnVzf"
+      + "raZK+KVWCGA8VEZwe/K6ouYLsBr6+ekCKIkGZdM29927m9HjdFwEFjnzQlWO"
+      + "NZCeYgDcK22v7CzobKjdo2wdC7XIOUVCzMWMl+ch1guO/Y4KVuslfeQG5X1i"
+      + "PJqV+bwJriCx5/j3eE/aezK/vtZU6cchifmvefKvaNL34tY0Myz2bOx44tl8"
+      + "qNcGZbkYF7xrNCutzI63xa2ruN1p3hNxicZV1FJSOje6+ITXkU5Jmufto7IJ"
+      + "t/4Q2dQefBQ1x/d0EdX31yK6+1z9dF/k3HpcSMb5cAWa2u2g4duAmREHc3Jz"
+      + "lHCsNgyzt5mkb6kS43B6og8Mm2SOx78dBIOA8ANzi5B6Sqk3/uN5eQFLY+sQ"
+      + "qGxXzimyfbMjyq9DdqXThx4vlp3h/GC39KxL5MPeB0oe6P3fSP3C2ZGjsn3+"
+      + "XcYk0Ti1cBwBOFOZ59WYuc61B0wlkiU/WGeaebABh7QuU2FuZGh5YSBQdWxs"
+      + "YWJob3RsYSA8cHNhbmRoeWFAbXlqYXZhd29ybGQuY29tPrADA///iQEtBBAB"
+      + "AgAXBQJAbX2jBwsJCAcDAgoCGQEFGwMAAAAACgkQx87DL9gOvoeVUwgAkQXY"
+      + "iF0CxhKbDnuabAssnOEwJrutgCROCJRQvIwTe3fe6hQaWn2Yowt8OQtNFiR8"
+      + "GfAY6EYxyFLKzZbAI/qtq5fHmN3eRSyNWe6d6e17hqZZL7kf2sVkyGTChHj7"
+      + "Jiuo7vWkdqT2MJN6BW5tS9CRH7MeD839STv+4mAAO9auGvSvicP6UEQikAyC"
+      + "y/ihoJxLQlspfbSNpi0vrUjCPT7NtWwfP0qF64i9LYkjzLqihnu+UareqOPh"
+      + "XcWnyFKrjmg4ezQkweNU2pdvCLbcW24FhT92ivHgpLyWTswXcqjhFjVlRr0+"
+      + "2sIz7v1k0budCsJ7PjzOoH0hJxCvsJQMlZR/e7ABZ50DqARAbX2kAQgAm5j+"
+      + "/LO2M4pKm/VUPkYuj3eefHkzjM6nKbvRZX1Oqyf+6CJTxQskUWKAtkzzKafP"
+      + "dS5Wg0CMqeXov+EFod4bPEYccszncKd1U8NRwacbEpCvvvB84Yl2YwdWpDpk"
+      + "ryyyLI4PbCHkeuwx9Dc2z7t4XDB6FyAJTMAkia7nzYa/kbeUO3c2snDb/dU7"
+      + "uyCsyKtTZyTyhTgtl/f9L03Bgh95y3mOUz0PimJ0Sg4ANczF4d04BpWkjLNV"
+      + "Ji489ifWodPlHm1hag5drYekYpWJ+3g0uxs5AwayV9BcOkPKb1uU3EoYQw+n"
+      + "n0Kn314Nvx2M1tKYunuVNLEm0PhA/+B8PTq8BQARAQABCXo6bD6qi3s4U8Pp"
+      + "Uf9l3DyGuwiVPGuyb2P+sEmRFysi2AvxMe9CkF+CLCVYfZ32H3Fcr6XQ8+K8"
+      + "ZGH6bJwijtV4QRnWDZIuhUQDS7dsbGqTh4Aw81Fm0Bz9fpufViM9RPVEysxs"
+      + "CZRID+9jDrACthVsbq/xKomkKdBfNTK7XzGeZ/CBr9F4EPlnBWClURi9txc0"
+      + "pz9YP5ZRy4XTFgx+jCbHgKWUIz4yNaWQqpSgkHEDrGZwstXeRaaPftcfQN+s"
+      + "EO7OGl/Hd9XepGLez4vKSbT35CnqTwMzCK1IwUDUzyB4BYEFZ+p9TI18HQDW"
+      + "hA0Wmf6E8pjS16m/SDXoiRY43u1jUVZFNFzz25uLFWitfRNHCLl+VfgnetZQ"
+      + "jMFr36HGVQ65fogs3avkgvpgPwDc0z+VMj6ujTyXXgnCP/FdhzgkRFJqgmdJ"
+      + "yOlC+wFmZJEs0MX7L/VXEXdpR27XIGYm24CC7BTFKSdlmR1qqenXHmCCg4Wp"
+      + "00fV8+aAsnesgwPvxhCbZQVp4v4jqhVuB/rvsQu9t0rZnKdDnWeom/F3StYo"
+      + "A025l1rrt0wRP8YS4XlslwzZBqgdhN4urnzLH0/F3X/MfjP79Efj7Zk07vOH"
+      + "o/TPjz8lXroPTscOyXWHwtQqcMhnVsj9jvrzhZZSdUuvnT30DR7b8xcHyvAo"
+      + "WG2cnF/pNSQX11RlyyAOlw9TOEiDJ4aLbFdkUt+qZdRKeC8mEC2xsQ87HqFR"
+      + "pWKWABWaoUO0nxBEmvNOy97PkIeGVFNHDLlIeL++Ry03+JvuNNg4qAnwacbJ"
+      + "TwQzWP4vJqre7Gl/9D0tVlD4Yy6Xz3qyosxdoFpeMSKHhgKVt1bk0SQP7eXA"
+      + "C1c+eDc4gN/ZWpl+QLqdk2T9vr4wRAaK5LABh4kBIgQYAQIADAUCQG19pAUb"
+      + "DAAAAAAKCRDHzsMv2A6+h5C6B/0QWPJb1L9a/CHU7Of3zfHvzJxnk4S5fia5"
+      + "WBf+Ld7Y12CH+cVI/3PTXY63imIB3zLa21TNPC5cVFUJZI7hdwyJOW1R/QZa"
+      + "vGl5sosIjORqwq8vs1oqpKWc3tRue+wt/JjCWxw8G6jQiwCzM6PltqtOAL5e"
+      + "bJ4jZwzRmxs/RI4UYKO6EteipJA+i7OEZx0xGdL8mTl6HQx7vrJP9pM4/CtO"
+      + "5CmjPK70e2gyoiOxx9RsSc+9H59YJCrldogCCIlNuW7cvkt8K/uYdN9GAbFG"
+      + "RdanignRjpqSu3vTn8r/VO63+meZfKvmpI6i2b3o/UZ8Xh9lJu1vrRoNpnuP"
+      + "Nifs+ljmsAFn");
+
+
+    char[]  sec2pass1 = "sandhya".toCharArray();
+    char[]    sec2pass2 = "psai".toCharArray();
+
+    byte[] pub3 = Base64.decode(
+        "mQGiBEB9BH0RBACtYQtE7tna6hgGyGLpq+ds3r2cLC0ISn5dNw7tm9vwiNVF"
+      + "JA2N37RRrifw4PvgelRSvLaX3M3ZBqC9s1Metg3v4FSlIRtSLWCNpHSvNw7i"
+      + "X8C2Xy9Hdlbh6Y/50o+iscojLRE14upfR1bIkcCZQGSyvGV52V2wBImUUZjV"
+      + "s2ZngwCg7mu852vK7+euz4WaL7ERVYtq9CMEAJ5swrljerDpz/RQ4Lhp6KER"
+      + "KyuI0PUttO57xINGshEINgYlZdGaZHRueHe7uKfI19mb0T4N3NJWaZ0wF+Cn"
+      + "rixsq0VrTUfiwfZeGluNG73aTCeY45fVXMGTTSYXzS8T0LW100Xn/0g9HRyA"
+      + "xUpuWo8IazxkMqHJis2uwriYKpAfA/9anvj5BS9p5pfPjp9dGM7GTMIYl5f2"
+      + "fcP57f+AW1TVR6IZiMJAvAdeWuLtwLnJiFpGlnFz273pfl+sAuqm1yNceImR"
+      + "2SDDP4+vtyycWy8nZhgEuhZx3W3cWMQz5WyNJSY1JJHh9TCQkCoN8E7XpVP4"
+      + "zEPboB2GzD93mfD8JLHP+7QtVGVzdCBLZXkgKG5vIGNvbW1lbnQpIDx0ZXN0"
+      + "QGJvdW5jeWNhc3RsZS5vcmc+iFkEExECABkFAkB9BH0ECwcDAgMVAgMDFgIB"
+      + "Ah4BAheAAAoJEKnMV8vjZQOpSRQAnidAQswYkrXQAFcLBzhxQTknI9QMAKDR"
+      + "ryV3l6xuCCgHST8JlxpbjcXhlLACAAPRwXPBcQEQAAEBAAAAAAAAAAAAAAAA"
+      + "/9j/4AAQSkZJRgABAQEASABIAAD//gAXQ3JlYXRlZCB3aXRoIFRoZSBHSU1Q"
+      + "/9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZEhMPFB0aHx4dGhwcICQuJyAi"
+      + "LCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy/9sAQwEJCQkMCwwYDQ0YMiEcITIy"
+      + "MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy"
+      + "MjIy/8AAEQgAFAAUAwEiAAIRAQMRAf/EABoAAQACAwEAAAAAAAAAAAAAAAAE"
+      + "BQIDBgf/xAAoEAABAgUDBAEFAAAAAAAAAAABAgMABBEhMQUSQQYTIiNhFFGB"
+      + "kcH/xAAXAQEAAwAAAAAAAAAAAAAAAAAEAgMF/8QAJBEAAQQAAwkAAAAAAAAA"
+      + "AAAAAQACERIEIfATMTJBUZGx0fH/2gAMAwEAAhEDEQA/APMuotJlJVxstqaP"
+      + "o22NlAUp+YsNO0qSUtBcMu6n6EtOHcfPAHHFI16++oajQtTA3DapK02HFR8U"
+      + "pE9pTbQWtKm2WG2rlxVyQTcfGbn7Qm0OIjL77Wrs2NNm9lzTmmSxQ0PX4opS"
+      + "prk5tmESF6syggzGwOLG6gXgHFbZhBixk8XlIDcOQLRKt+rX+3qC5ZLTQblp"
+      + "Qlvwvxn9CMpZturVGkJHapQJphRH8hCLXbzrqpYsCx1zC5rtpJNuYQhASc0U"
+      + "AQv/2YhcBBMRAgAcBQJAfQV+AhsDBAsHAwIDFQIDAxYCAQIeAQIXgAAKCRCp"
+      + "zFfL42UDqfa2AJ9hjtEeDTbTEAuuSbzhYFxN/qc0FACgsmzysdbBpuN65yK0"
+      + "1tbEaeIMtqCwAgADuM0EQH0EfhADAKpG5Y6vGbm//xZYG08RRmdi67dZjF59"
+      + "Eqfo43mRrliangB8qkqoqqf3za2OUbXcZUQ/ajDXUvjJAoY2b5XJURqmbtKk"
+      + "wPRIeD2+wnKABat8wmcFhZKATX1bqjdyRRGxawADBgMAoMJKJLELdnn885oJ"
+      + "6HDmIez++ZWTlafzfUtJkQTCRKiE0NsgSvKJr/20VdK3XUA/iy0m1nQwfzv/"
+      + "okFuIhEPgldzH7N/NyEvtN5zOv/TpAymFKewAQ26luEu6l+lH4FsiEYEGBEC"
+      + "AAYFAkB9BH4ACgkQqcxXy+NlA6mtMgCgtQMFBaKymktM+DQmCgy2qjW7WY0A"
+      + "n3FaE6UZE9GMDmCIAjhI+0X9aH6CsAIAAw==");
+
+    byte[] sec3 = Base64.decode(
+        "lQHhBEB9BH0RBACtYQtE7tna6hgGyGLpq+ds3r2cLC0ISn5dNw7tm9vwiNVF"
+      + "JA2N37RRrifw4PvgelRSvLaX3M3ZBqC9s1Metg3v4FSlIRtSLWCNpHSvNw7i"
+      + "X8C2Xy9Hdlbh6Y/50o+iscojLRE14upfR1bIkcCZQGSyvGV52V2wBImUUZjV"
+      + "s2ZngwCg7mu852vK7+euz4WaL7ERVYtq9CMEAJ5swrljerDpz/RQ4Lhp6KER"
+      + "KyuI0PUttO57xINGshEINgYlZdGaZHRueHe7uKfI19mb0T4N3NJWaZ0wF+Cn"
+      + "rixsq0VrTUfiwfZeGluNG73aTCeY45fVXMGTTSYXzS8T0LW100Xn/0g9HRyA"
+      + "xUpuWo8IazxkMqHJis2uwriYKpAfA/9anvj5BS9p5pfPjp9dGM7GTMIYl5f2"
+      + "fcP57f+AW1TVR6IZiMJAvAdeWuLtwLnJiFpGlnFz273pfl+sAuqm1yNceImR"
+      + "2SDDP4+vtyycWy8nZhgEuhZx3W3cWMQz5WyNJSY1JJHh9TCQkCoN8E7XpVP4"
+      + "zEPboB2GzD93mfD8JLHP+/4DAwIvYrn+YqRaaGAu19XUj895g/GROyP8WEaU"
+      + "Bd/JNqWc4kE/0guetGnPzq7G3bLVwiKfFd4X7BrgHAo3mrQtVGVzdCBLZXkg"
+      + "KG5vIGNvbW1lbnQpIDx0ZXN0QGJvdW5jeWNhc3RsZS5vcmc+iFkEExECABkF"
+      + "AkB9BH0ECwcDAgMVAgMDFgIBAh4BAheAAAoJEKnMV8vjZQOpSRQAoKZy6YS1"
+      + "irF5/Q3JlWiwbkN6dEuLAJ9lldRLOlXsuQ5JW1+SLEc6K9ho4rACAADRwXPB"
+      + "cQEQAAEBAAAAAAAAAAAAAAAA/9j/4AAQSkZJRgABAQEASABIAAD//gAXQ3Jl"
+      + "YXRlZCB3aXRoIFRoZSBHSU1Q/9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZ"
+      + "EhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy/9sA"
+      + "QwEJCQkMCwwYDQ0YMiEcITIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy"
+      + "MjIyMjIyMjIyMjIyMjIyMjIyMjIy/8AAEQgAFAAUAwEiAAIRAQMRAf/EABoA"
+      + "AQACAwEAAAAAAAAAAAAAAAAEBQIDBgf/xAAoEAABAgUDBAEFAAAAAAAAAAAB"
+      + "AgMABBEhMQUSQQYTIiNhFFGBkcH/xAAXAQEAAwAAAAAAAAAAAAAAAAAEAgMF"
+      + "/8QAJBEAAQQAAwkAAAAAAAAAAAAAAQACERIEIfATMTJBUZGx0fH/2gAMAwEA"
+      + "AhEDEQA/APMuotJlJVxstqaPo22NlAUp+YsNO0qSUtBcMu6n6EtOHcfPAHHF"
+      + "I16++oajQtTA3DapK02HFR8UpE9pTbQWtKm2WG2rlxVyQTcfGbn7Qm0OIjL7"
+      + "7Wrs2NNm9lzTmmSxQ0PX4opSprk5tmESF6syggzGwOLG6gXgHFbZhBixk8Xl"
+      + "IDcOQLRKt+rX+3qC5ZLTQblpQlvwvxn9CMpZturVGkJHapQJphRH8hCLXbzr"
+      + "qpYsCx1zC5rtpJNuYQhASc0UAQv/2YhcBBMRAgAcBQJAfQV+AhsDBAsHAwID"
+      + "FQIDAxYCAQIeAQIXgAAKCRCpzFfL42UDqfa2AJ9hjtEeDTbTEAuuSbzhYFxN"
+      + "/qc0FACgsmzysdbBpuN65yK01tbEaeIMtqCwAgAAnQEUBEB9BH4QAwCqRuWO"
+      + "rxm5v/8WWBtPEUZnYuu3WYxefRKn6ON5ka5Ymp4AfKpKqKqn982tjlG13GVE"
+      + "P2ow11L4yQKGNm+VyVEapm7SpMD0SHg9vsJygAWrfMJnBYWSgE19W6o3ckUR"
+      + "sWsAAwYDAKDCSiSxC3Z5/POaCehw5iHs/vmVk5Wn831LSZEEwkSohNDbIEry"
+      + "ia/9tFXSt11AP4stJtZ0MH87/6JBbiIRD4JXcx+zfzchL7Teczr/06QMphSn"
+      + "sAENupbhLupfpR+BbP4DAwIvYrn+YqRaaGBjvFK1fbxCt7ZM4I2W/3BC0lCX"
+      + "m/NypKNspGflec8u96uUlA0fNCnxm6f9nbB0jpvoKi0g4iqAf+P2iEYEGBEC"
+      + "AAYFAkB9BH4ACgkQqcxXy+NlA6mtMgCgvccZA/Sg7BXVpxli47SYhxSHoM4A"
+      + "oNCOMplSnYTuh5ikKeBWtz36gC1psAIAAA==");
+
+    char[]  sec3pass1 = "123456".toCharArray();
+    
+    //
+    // GPG comment packets.
+    //
+    byte[] sec4 = Base64.decode(
+           "lQG7BD0PbK8RBAC0cW4Y2MZXmAmqYp5Txyw0kSQsFvwZKHNMFRv996IsN57URVF5"
+        + "BGMVPRBi9dNucWbjiSYpiYN13wE9IuLZsvVaQojV4XWGRDc+Rxz9ElsXnsYQ3mZU"
+        + "7H1bNQEofstChk4z+dlvPBN4GFahrIzn/CeVUn6Ut7dVdYbiTqviANqNXwCglfVA"
+        + "2OEePvqFnGxs1jhJyPSOnTED/RwRvsLH/k43mk6UEvOyN1RIpBXN+Ieqs7h1gFrQ"
+        + "kB+WMgeP5ZUsotTffVDSUS9UMxRQggVUW1Xml0geGwQsNfkr/ztWMs/T4xp1v5j+"
+        + "QyJx6OqNlkGdqOsoqkzJx0SQ1zBxdinFyyC4H95SDAb/RQOu5LQmxFG7quexztMs"
+        + "infEA/9cVc9+qCo92yRAaXRqKNVVQIQuPxeUsGMyVeJQvJBD4An8KTMCdjpF10Cp"
+        + "qA3t+n1S0zKr5WRUtvS6y60MOONO+EJWVWBNkx8HJDaIMNkfoqQoz3Krn7w6FE/v"
+        + "/5uwMd6jY3N3yJZn5nDZT9Yzv9Nx3j+BrY+henRlSU0c6xDc9QAAnjJYg0Z83VJG"
+        + "6HrBcgc4+4K6lHulCqH9JiM6RFNBX2ZhY3RvcjoAAK9hV206agp99GI6x5qE9+pU"
+        + "vs6O+Ich/SYjOkRTQV9mYWN0b3I6AACvYAfGn2FGrpBYbjnpTuFOHJMS/T5xg/0m"
+        + "IzpEU0FfZmFjdG9yOgAAr0dAQz6XxMwxWIn8xIZR/v2iN2L9C6O0EkZvbyBCYXIg"
+        + "PGJhekBxdXV4PohXBBMRAgAXBQI9D2yvBQsHCgMEAxUDAgMWAgECF4AACgkQUGLI"
+        + "YCIktfoGogCfZiXMJUKrScqozv5tMwzTTk2AaT8AniM5iRr0Du/Y08SL/NMhtF6H"
+        + "hJ89nO4EPQ9ssRADAI6Ggxj6ZBfoavuXd/ye99osW8HsNlbqhXObu5mCMNySX2wa"
+        + "HoWyRUEaUkI9eQw+MlHzIwzA32E7y2mU3OQBKdgLcBg4jxtcWVEg8ESKF9MpFXxl"
+        + "pExxWrr4DFBfCRcsTwAFEQL9G3OvwJuEZXgx2JSS41D3pG4/qiHYICVa0u3p/14i"
+        + "cq0kXajIk5ZJ6frCIAHIzuQ3n7jjzr05yR8s/qCrNbBA+nlkVNa/samk+jCzxxxa"
+        + "cR/Dbh2wkvTFuDFFETwQYLuZAADcDck4YGQAmHivVT2NNDCf/aTz0+CJWl+xRc2l"
+        + "Qw7D/SQjOkVMR19mYWN0b3I6AACbBnv9m5/bb/pjYAm2PtDp0CysQ9X9JCM6RUxH"
+        + "X2ZhY3RvcjoAAJsFyHnSmaWguTFf6lJ/j39LtUNtmf0kIzpFTEdfZmFjdG9yOgAA"
+        + "mwfwMD3LxmWtuCWBE9BptWMNH07Z/SQjOkVMR19mYWN0b3I6AACbBdhBrbSiM4UN"
+        + "y7khDW2Sk0e4v9mIRgQYEQIABgUCPQ9ssQAKCRBQYshgIiS1+jCMAJ9txwHnb1Kl"
+        + "6i/fSoDs8SkdM7w48wCdFvPEV0sSxE73073YhBgPZtMWbBo=");
+
+    //
+    // PGP freeware version 7
+    //
+    byte[] pub5 = Base64.decode(
+        "mQENBEBrBE4BCACjXVcNIFDQSofaIyZnALb2CRg+WY9uUqgHEEAOlPe03Cs5STM5"
+      + "HDlNmrh4TdFceJ46rxk1mQOjULES1YfHay8lCIzrD7FX4oj0r4DC14Fs1vXaSar2"
+      + "1szIpttOw3obL4A1e0p6N4jjsoG7N/pA0fEL0lSw92SoBrMbAheXRg4qNTZvdjOR"
+      + "grcuOuwgJRvPLtRXlhyLBoyhkd5mmrIDGv8QHJ/UjpeIcRXY9kn9oGXnEYcRbMaU"
+      + "VwXB4pLzWqz3ZejFI3lOxRWjm760puPOnGYlzSVBxlt2LgzUgSj1Mn+lIpWmAzsa"
+      + "xEiU4xUwEomQns72yYRZ6D3euNCibcte4SeXABEBAAG0KXBhbGFzaCBrYXNvZGhh"
+      + "biA8cGthc29kaGFuQHRpYWEtY3JlZi5vcmc+iQEuBBABAgAYBQJAawROCAsBAwkI"
+      + "BwIKAhkBBRsDAAAAAAoJEOfelumuiOrYqPEH+wYrdP5Tq5j+E5yN1pyCg1rwbSOt"
+      + "Dka0y0p7Oq/VIGLk692IWPItLEunnBXQtGBcWqklrvogvlhxtf16FgoyScfLJx1e"
+      + "1cJa+QQnVuH+VOESN6iS9Gp9lUfVOHv74mEMXw0l2Djfy/lnrkAMBatggyGnF9xF"
+      + "VXOLk1J2WVFm9KUE23o6qdB7RGkf31pN2eA7SWmkdJSkUH7o/QSFBI+UTRZ/IY5P"
+      + "ZIJpsdiIOqd9YMG/4RoSZuPqNRR6x7BSs8nQVR9bYs4PPlp4GfdRnOcRonoTeJCZ"
+      + "83RnsraWJnJTg34gRLBcqumhTuFKc8nuCNK98D6zkQESdcHLLTquCOaF5L+5AQ0E"
+      + "QGsETwEIAOVwNCTaDZvW4dowPbET1bI5UeYY8rAGLYsWSUfgaFv2srMiApyBVltf"
+      + "i6OLcPjcUCHDBjCv4pwx/C4qcHWb8av4xQIpqQXOpO9NxYE1eZnel/QB7DtH12ZO"
+      + "nrDNmHtaXlulcKNGe1i1utlFhgzfFx6rWkRL0ENmkTkaQmPY4gTGymJTUhBbsSRq"
+      + "2ivWqQA1TPwBuda73UgslIAHRd/SUaxjXoLpMbGOTeqzcKGjr5XMPTs7/YgBpWPP"
+      + "UxMlEQIiU3ia1bxpEhx05k97ceK6TSH2oCPQA7gumjxOSjKT+jEm+8jACVzymEmc"
+      + "XRy4D5Ztqkw/Z16pvNcu1DI5m6xHwr8AEQEAAYkBIgQYAQIADAUCQGsETwUbDAAA"
+      + "AAAKCRDn3pbprojq2EynB/4/cEOtKbI5UisUd3vkTzvWOcqWUqGqi5wjjioNtIM5"
+      + "pur2nFvhQE7SZ+PbAa87HRJU/4WcWMcoLkHD48JrQwHCHOLHSV5muYowb78X4Yh9"
+      + "epYtSJ0uUahcn4Gp48p4BkhgsPYXkxEImSYzAOWStv21/7WEMqItMYl89BV6Upm8"
+      + "HyTJx5MPTDbMR7X51hRg3OeQs6po3WTCWRzFIMyGm1rd/VK1L5ZDFPqO3S6YUJ0z"
+      + "cxecYruvfK0Wp7q834wE8Zkl/PQ3NhfEPL1ZiLr/L00Ty+77/FZqt8SHRCICzOfP"
+      + "OawcVGI+xHVXW6lijMpB5VaVIH8i2KdBMHXHtduIkPr9");
+      
+    byte[] sec5 = Base64.decode(
+        "lQOgBEBrBE4BCACjXVcNIFDQSofaIyZnALb2CRg+WY9uUqgHEEAOlPe03Cs5STM5"
+      + "HDlNmrh4TdFceJ46rxk1mQOjULES1YfHay8lCIzrD7FX4oj0r4DC14Fs1vXaSar2"
+      + "1szIpttOw3obL4A1e0p6N4jjsoG7N/pA0fEL0lSw92SoBrMbAheXRg4qNTZvdjOR"
+      + "grcuOuwgJRvPLtRXlhyLBoyhkd5mmrIDGv8QHJ/UjpeIcRXY9kn9oGXnEYcRbMaU"
+      + "VwXB4pLzWqz3ZejFI3lOxRWjm760puPOnGYlzSVBxlt2LgzUgSj1Mn+lIpWmAzsa"
+      + "xEiU4xUwEomQns72yYRZ6D3euNCibcte4SeXABEBAAEB8wqP7JkKN6oMNi1xJNqU"
+      + "vvt0OV4CCnrIFiOPCjebjH/NC4T/9pJ6BYSjYdo3VEPNhPhRS9U3071Kqbdt35J5"
+      + "kmzMq1yNStC1jkxHRCNTMsb1yIEY1v+fv8/Cy+tBpvAYiJKaox8jW3ppi9vTHZjW"
+      + "tYYq0kwAVojMovz1O3wW/pEF69UPBmPYsze+AHA1UucYYqdWO8U2tsdFJET/hYpe"
+      + "o7ppHJJCdqWzeiE1vDUrih9pP3MPpzcRS/gU7HRDb5HbfP7ghSLzByEa+2mvg5eK"
+      + "eLwNAx2OUtrVg9rJswXX7DOLa1nKPhdGrSV/qwuK4rBdaqJ/OvszVJ0Vln0T/aus"
+      + "it1PAuVROLUPqTVVN8/zkMenFbf5vtryC3GQYXvvZq+l3a4EXwrR/1pqrTfnfOuD"
+      + "GwlFhRJAqPfthxZS68/xC8qAmTtkl7j4nscNM9kSoZ3BFwSyD9B/vYHPWGlqnpGF"
+      + "k/hBXuIgl07KIeNIyEC3f1eRyaiMFqEz5yXbbTfEKirSVpHM/mpeKxG8w96aK3Je"
+      + "AV0X6ZkC4oLTp6HCG2TITUIeNxCh2rX3fhr9HvBDXBbMHgYlIcLwzNkwDX74cz/7"
+      + "nIclcubaWjEkDHP20XFicuChFc9zx6kBYuYy170snltTBgTWSuRH15W4NQqrLo37"
+      + "zyzZQubX7CObgQJu4ahquiOg4SWl6uEI7+36U0SED7sZzw8ns1LxrwOWbXuHie1i"
+      + "xCvsJ4RpJJ03iEdNdUIb77qf6AriqE92tXzcVXToBv5S2K5LdFYNJ1rWdwaKJRkt"
+      + "kmjCL67KM9WT/IagsUyU+57ao3COtqw9VWZi6ev+ubM6fIV0ZK46NEggOLph1hi2"
+      + "gZ9ew9uVuruYg7lG2Ku82N0fjrQpcGFsYXNoIGthc29kaGFuIDxwa2Fzb2RoYW5A"
+      + "dGlhYS1jcmVmLm9yZz6dA6AEQGsETwEIAOVwNCTaDZvW4dowPbET1bI5UeYY8rAG"
+      + "LYsWSUfgaFv2srMiApyBVltfi6OLcPjcUCHDBjCv4pwx/C4qcHWb8av4xQIpqQXO"
+      + "pO9NxYE1eZnel/QB7DtH12ZOnrDNmHtaXlulcKNGe1i1utlFhgzfFx6rWkRL0ENm"
+      + "kTkaQmPY4gTGymJTUhBbsSRq2ivWqQA1TPwBuda73UgslIAHRd/SUaxjXoLpMbGO"
+      + "TeqzcKGjr5XMPTs7/YgBpWPPUxMlEQIiU3ia1bxpEhx05k97ceK6TSH2oCPQA7gu"
+      + "mjxOSjKT+jEm+8jACVzymEmcXRy4D5Ztqkw/Z16pvNcu1DI5m6xHwr8AEQEAAQF7"
+      + "osMrvQieBAJFYY+x9jKPVclm+pVaMaIcHKwCTv6yUZMqbHNRTfwdCVKTdAzdlh5d"
+      + "zJNXXRu8eNwOcfnG3WrWAy59cYE389hA0pQPOh7iL2V1nITf1qdLru1HJqqLC+dy"
+      + "E5GtkNcgvQYbv7ACjQacscvnyBioYC6TATtPnHipMO0S1sXEnmUugNlW88pDln4y"
+      + "VxCtQXMBjuqMt0bURqmb+RoYhHhoCibo6sexxSnbEAPHBaW1b1Rm7l4UBSW6S5U0"
+      + "MXURE60IHfP1TBe1l/xOIxOi8qdBQCyaFW2up00EhRBy/WOO6KAYXQrRRpOs9TBq"
+      + "ic2wquwZePmErTbIttnnBcAKmpodrM/JBkn/we5fVg+FDTP8sM/Ubv0ZuM70aWmF"
+      + "v0/ZKbkCkh2YORLWl5+HR/RKShdkmmFgZZ5uzbOGxxEGKhw+Q3+QFUF7PmYOnOtv"
+      + "s9PZE3dV7ovRDoXIjfniD1+8sLUWwW5d+3NHAQnCHJrLnPx4sTHx6C0yWMcyZk6V"
+      + "fNHpLK4xDTbgoTmxJa/4l+wa0iD69h9K/Nxw/6+X/GEM5w3d/vjlK1Da6urN9myc"
+      + "GMsfiIll5DNIWdLLxCBPFmhJy653CICQLY5xkycWB7JOZUBTOEVrYr0AbBZSTkuB"
+      + "fq5p9MfH4N51M5TWnwlJnqEiGnpaK+VDeP8GniwCidTYyiocNPvghvWIzG8QGWMY"
+      + "PFncRpjFxmcY4XScYYpyRme4qyPbJhbZcgGpfeLvFKBPmNxVKJ2nXTdx6O6EbHDj"
+      + "XctWqNd1EQas7rUN728u7bk8G7m37MGqQuKCpNvOScH4TnPROBY8get0G3bC4mWz"
+      + "6emPeENnuyElfWQiHEtCZr1InjnNbb/C97O+vWu9PfsE");
+
+    char[]  sec5pass1 = "12345678".toCharArray();
+
+        //
+        // Werner Koch "odd keys"
+        //
+    byte[] pub6 = Base64.decode(
+        "mQGiBDWiHh4RBAD+l0rg5p9rW4M3sKvmeyzhs2mDxhRKDTVVUnTwpMIR2kIA9pT4"
+      + "3No/coPajDvhZTaDM/vSz25IZDZWJ7gEu86RpoEdtr/eK8GuDcgsWvFs5+YpCDwW"
+      + "G2dx39ME7DN+SRvEE1xUm4E9G2Nnd2UNtLgg82wgi/ZK4Ih9CYDyo0a9awCgisn3"
+      + "RvZ/MREJmQq1+SjJgDx+c2sEAOEnxGYisqIKcOTdPOTTie7o7x+nem2uac7uOW68"
+      + "N+wRWxhGPIxsOdueMIa7U94Wg/Ydn4f2WngJpBvKNaHYmW8j1Q5zvZXXpIWRXSvy"
+      + "TR641BceGHNdYiR/PiDBJsGQ3ac7n7pwhV4qex3IViRDJWz5Dzr88x+Oju63KtxY"
+      + "urUIBACi7d1rUlHr4ok7iBRlWHYXU2hpUIQ8C+UOE1XXT+HB7mZLSRONQnWMyXnq"
+      + "bAAW+EUUX2xpb54CevAg4eOilt0es8GZMmU6c0wdUsnMWWqOKHBFFlDIvyI27aZ9"
+      + "quf0yvby63kFCanQKc0QnqGXQKzuXbFqBYW2UQrYgjXji8rd8bQnV2VybmVyIEtv"
+      + "Y2ggKGdudXBnIHNpZykgPGRkOWpuQGdudS5vcmc+iGUEExECAB0FAjZVoKYFCQht"
+      + "DIgDCwQDBRUDAgYBAxYCAQIXgAASCRBot6uJV1SNzQdlR1BHAAEBLj4AoId15gcy"
+      + "YpBX2YLtEQTlXPp3mtEGAJ9UxzJE/t3EHCHK2bAIOkBwIW8ItIkBXwMFEDWiHkMD"
+      + "bxG4/z6qCxADYzIFHR6I9Si9gzPQNRcFs2znrTp5pV5Mk6f1aqRgZxL3E4qUZ3xe"
+      + "PQhwAo3fSy3kCwLmFGqvzautSMHn8K5V1u+T5CSHqLFYKqj5FGtuB/xwoKDXH6UO"
+      + "P0+l5IP8H1RTjme3Fhqahec+zPG3NT57vc2Ru2t6PmuAwry2BMuSFMBs7wzXkyC3"
+      + "DbI54MV+IKPjHMORivK8uI8jmna9hdNVyBifCk1GcxkHBSCFvU8xJePsA/Q//zCe"
+      + "lvrnrIiMfY4CQTmKzke9MSzbAZQIRddgrGAsiX1tE8Z3YMd8lDpuujHLVEdWZo6s"
+      + "54OJuynHrtFFObdapu0uIrT+dEXSASMUbEuNCLL3aCnrEtGJCwxB2TPQvCCvR2BK"
+      + "zol6MGWxA+nmddeQib2r+GXoKXLdnHcpsAjA7lkXk3IFyJ7MLFK6uDrjGbGJs2FK"
+      + "SduUjS/Ib4hGBBARAgAGBQI1oic8AAoJEGx+4bhiHMATftYAn1fOaKDUOt+dS38r"
+      + "B+CJ2Q+iElWJAKDRPpp8q5GylbM8DPlMpClWN3TYqYhGBBARAgAGBQI27U5sAAoJ"
+      + "EF3iSZZbA1iiarYAn35qU3ZOlVECELE/3V6q98Q30eAaAKCtO+lacH0Qq1E6v4BP"
+      + "/9y6MoLIhohiBBMRAgAiAhsDBAsHAwIDFQIDAxYCAQIeAQIXgAUCP+mCaQUJDDMj"
+      + "ywAKCRBot6uJV1SNzaLvAJwLsPV1yfc2D+yT+2W11H/ftNMDvwCbBweORhCb/O/E"
+      + "Okg2UTXJBR4ekoCIXQQTEQIAHQMLBAMFFQMCBgEDFgIBAheABQI/6YJzBQkMMyPL"
+      + "AAoJEGi3q4lXVI3NgroAn2Z+4KgVo2nzW72TgCJwkAP0cOc2AJ0ZMilsOWmxmEG6"
+      + "B4sHMLkB4ir4GIhdBBMRAgAdAwsEAwUVAwIGAQMWAgECF4AFAj/pgnMFCQwzI8sA"
+      + "CgkQaLeriVdUjc2CugCfRrOIfllp3mSmGpHgIxvg5V8vtMcAn0BvKVehOn+12Yvn"
+      + "9BCHfg34jUZbiF0EExECAB0DCwQDBRUDAgYBAxYCAQIXgAUCP+mCcwUJDDMjywAK"
+      + "CRBot6uJV1SNzYK6AJ9x7R+daNIjkieNW6lJeVUIoj1UHgCeLZm025uULML/5DFs"
+      + "4tUvXs8n9XiZAaIENaIg8xEEALYPe0XNsPjx+inTQ+Izz527ZJnoc6BhWik/4a2b"
+      + "ZYENSOQXAMKTDQMv2lLeI0i6ceB967MNubhHeVdNeOWYHFSM1UGRfhmZERISho3b"
+      + "p+wVZvVG8GBVwpw34PJjgYU/0tDwnJaJ8BzX6j0ecTSTjQPnaUEtdJ/u/gmG9j02"
+      + "18TzAKDihdNoKJEU9IKUiSjdGomSuem/VwQArHfaucSiDmY8+zyZbVLLnK6UJMqt"
+      + "sIv1LvAg20xwXoUk2bY8H3tXL4UZ8YcoSXYozwALq3cIo5UZJ0q9Of71mI8WLK2i"
+      + "FSYVplpTX0WMClAdkGt3HgVb7xtOhGt1mEKeRQjNZ2LteUQrRDD9MTQ+XxcvEN0I"
+      + "pAj4kBJe9bR6HzAD/iecCmGwSlHUZZrgqWzv78o79XxDdcuLdl4i2fL7kwEOf9js"
+      + "De7hGs27yrdJEmAG9QF9TOF9LJFmE1CqkgW+EpKxsY01Wjm0BFJB1R7iPUaUtFRZ"
+      + "xYqfgXarmPjql2iBi+cVjLzGu+4BSojVAPgP/hhcnIowf4M4edPiICMP1GVjtCFX"
+      + "ZXJuZXIgS29jaCA8d2VybmVyLmtvY2hAZ3V1Zy5kZT6IYwQTEQIAGwUCNs8JNwUJ"
+      + "CCCxRAMLCgMDFQMCAxYCAQIXgAASCRBsfuG4YhzAEwdlR1BHAAEBaSAAn3YkpT5h"
+      + "xgehGFfnX7izd+c8jI0SAJ9qJZ6jJvXnGB07p60aIPYxgJbLmYkAdQMFEDWjdxQd"
+      + "GfTBDJhXpQEBPfMC/0cxo+4xYVAplFO0nIYyjQgP7D8O0ufzPsIwF3kvb7b5FNNj"
+      + "fp+DAhN6G0HOIgkL3GsWtCfH5UHali+mtNFIKDpTtr+F/lPpZP3OPzzsLZS4hYTq"
+      + "mMs1O/ACq8axKgAilYkBXwMFEDWiJw4DbxG4/z6qCxADB9wFH0i6mmn6rWYKFepJ"
+      + "hXyhE4wWqRPJAnvfoiWUntDp4aIQys6lORigVXIWo4k4SK/FH59YnzF7578qrTZW"
+      + "/RcA0bIqJqzqaqsOdTYEFa49cCjvLnBW4OebJlLTUs/nnmU0FWKW8OwwL+pCu8d7"
+      + "fLSSnggBsrUQwbepuw0cJoctFPAz5T1nQJieQKVsHaCNwL2du0XefOgF5ujB1jK1"
+      + "q3p4UysF9hEcBR9ltE3THr+iv4jtZXmC1P4at9W5LFWsYuwr0U3yJcaKSKp0v/wG"
+      + "EWe2J/gFQZ0hB1+35RrCZPgiWsEv87CHaG6XtQ+3HhirBCJsYhmOikVKoEan6PhU"
+      + "VR1qlXEytpAt389TBnvyceAX8hcHOE3diuGvILEgYes3gw3s5ZmM7bUX3jm2BrX8"
+      + "WchexUFUQIuKW2cL379MFXR8TbxpVxrsRYE/4jHZBYhGBBARAgAGBQI27U4LAAoJ"
+      + "EF3iSZZbA1iifJoAoLEsGy16hV/CfmDku6D1CBUIxXvpAJ9GBApdC/3OXig7sBrV"
+      + "CWOb3MQzcLkBjQQ2zwcIEAYA9zWEKm5eZpMMBRsipL0IUeSKEyeKUjABX4vYNurl"
+      + "44+2h6Y8rHn7rG1l/PNj39UJXBkLFj1jk8Q32v+3BQDjvwv8U5e/kTgGlf7hH3WS"
+      + "W38RkZw18OXYCvnoWkYneIuDj6/HH2bVNXmTac05RkBUPUv4yhqlaFpkVcswKGuE"
+      + "NRxujv/UWvVF+/2P8uSQgkmGp/cbwfMTkC8JBVLLBRrJhl1uap2JjZuSVklUUBez"
+      + "Vf3NJMagVzx47HPqLVl4yr4bAAMGBf9PujlH5I5OUnvZpz+DXbV/WQVfV1tGRCra"
+      + "kIj3mpN6GnUDF1LAbe6vayUUJ+LxkM1SqQVcmuy/maHXJ+qrvNLlPqUZPmU5cINl"
+      + "sA7bCo1ljVUp54J1y8PZUx6HxfEl/LzLVkr+ITWnyqeiRikDecUf4kix2teTlx6I"
+      + "3ecqT5oNqZSRXWwnN4SbkXtAd7rSgEptUYhQXgSEarp1pXJ4J4rgqFa49jKISDJq"
+      + "rn/ElltHe5Fx1bpfkCIYlYk45Cga9bOIVAQYEQIADAUCNs8HCAUJBvPJAAASCRBs"
+      + "fuG4YhzAEwdlR1BHAAEBeRUAoIGpCDmMy195TatlloHAJEjZu5KaAJwOvW989hOb"
+      + "8cg924YIFVA1+4/Ia7kBjQQ1oiE8FAYAkQmAlOXixb8wra83rE1i7LCENLzlvBZW"
+      + "KBXN4ONelZAnnkOm7IqRjMhtKRJN75zqVyKUaUwDKjpf9J5K2t75mSxBtnbNRqL3"
+      + "XodjHK93OcAUkz3ci7iuC/b24JI2q4XeQG/v4YR1VodM0zEQ1IC0JCq4Pl39QZyX"
+      + "JdZCrUFvMcXq5ruNSldztBqTFFUiFbkw1Fug/ZyXJve2FVcbsRXFrB7EEuy+iiU/"
+      + "kZ/NViKk0L4T6KRHVsEiriNlCiibW19fAAMFBf9Tbv67KFMDrLqQan/0oSSodjDQ"
+      + "KDGqtoh7KQYIKPXqfqT8ced9yd5MLFwPKf3t7AWG1ucW2x118ANYkPSU122UTndP"
+      + "sax0cY4XkaHxaNwpNFCotGQ0URShxKNpcqbdfvy+1d8ppEavgOyxnV1JOkLjZJLw"
+      + "K8bgxFdbPWcsJJnjuuH3Pwz87CzTgOSYQxMPnIwQcx5buZIV5NeELJtcbbd3RVua"
+      + "K/GQht8QJpuXSji8Nl1FihYDjACR8TaRlAh50GmIRgQoEQIABgUCOCv7gwAKCRBs"
+      + "fuG4YhzAE9hTAJ9cRHu+7q2hkxpFfnok4mRisofCTgCgzoPjNIuYiiV6+wLB5o11"
+      + "7MNWPZCIVAQYEQIADAUCNaIhPAUJB4TOAAASCRBsfuG4YhzAEwdlR1BHAAEBDfUA"
+      + "oLstR8cg5QtHwSQ3nFCOKEREUFIwAKDID3K3hM+b6jW1o+tNX9dnjb+YMZkAbQIw"
+      + "bYOUAAABAwC7ltmO5vdKssohwzXEZeYvDW2ll3CYD2I+ruiNq0ybxkfFBopq9cxt"
+      + "a0OvVML4LK/TH+60f/Fqx9wg2yk9APXyaomdLrXfWyfZ91YtNCfj3ElC4XB4qqm0"
+      + "HRn0wQyYV6UABRG0IVdlcm5lciBLb2NoIDx3ZXJuZXIua29jaEBndXVnLmRlPokA"
+      + "lQMFEDRfoOmOB31Gi6BmjQEBzwgD/2fHcdDXuRRY+SHvIVESweijstB+2/sVRp+F"
+      + "CDjR74Kg576sJHfTJCxtSSmzpaVpelb5z4URGJ/Byi5L9AU7hC75S1ZnJ+MjBT6V"
+      + "ePyk/r0uBrMkU/lMG7lk/y2By3Hll+edjzJsdwn6aoNPiyen4Ch4UGTEguxYsLq0"
+      + "HES/UvojiQEVAwUTNECE2gnp+QqKck5FAQH+1Af/QMlYPlLG+5E19qP6AilKQUzN"
+      + "kd1TWMenXTS66hGIVwkLVQDi6RCimhnLMq/F7ENA8bSbyyMuncaBz5dH4kjfiDp1"
+      + "o64LULcTmN1LW9ctpTAIeLLJZnwxoJLkUbLUYKADKqIBXHMt2B0zRmhFOqEjRN+P"
+      + "hI7XCcHeHWHiDeUB58QKMyeoJ/QG/7zLwnNgDN2PVqq2E72C3ye5FOkYLcHfWKyB"
+      + "Rrn6BdUphAB0LxZujSGk8ohZFbia+zxpWdE8xSBhZbjVGlwLurmS2UTjjxByBNih"
+      + "eUD6IC3u5P6psld0OfqnpriZofP0CBP2oTk65r529f/1lsy2kfWrVPYIFJXEnIkA"
+      + "lQMFEDQyneGkWMS9SnJfMQEBMBMD/1ADuhhuY9kyN7Oj6DPrDt5SpPQDGS0Jtw3y"
+      + "uIPoed+xyzlrEuL2HeaOj1O9urpn8XLN7V21ajkzlqsxnGkOuifbE9UT67o2b2vC"
+      + "ldCcY4nV5n+U1snMDwNv+RkcEgNa8ANiWkm03UItd7/FpHDQP0FIgbPEPwRoBN87"
+      + "I4gaebfRiQCVAwUQNDUSwxRNm5Suj3z1AQGMTAP/UaXXMhPzcjjLxBW0AccTdHUt"
+      + "Li+K+rS5PNxxef2nnasEhCdK4GkM9nwJgsP0EZxCG3ZSAIlWIgQ3MK3ZAV1Au5pL"
+      + "KolRjFyEZF420wAtiE7V+4lw3FCqNoXDJEFC3BW431kx1wAhDk9VaIHHadYcof4d"
+      + "dmMLQOW2cJ7LDEEBW/WJAJUDBRA0M/VQImbGhU33abUBARcoA/9eerDBZGPCuGyE"
+      + "mQBcr24KPJHWv/EZIKl5DM/Ynz1YZZbzLcvEFww34mvY0jCfoVcCKIeFFBMKiSKr"
+      + "OMtoVC6cQMKpmhE9hYRStw4E0bcf0BD/stepdVtpwRnG8SDP2ZbmtgyjYT/7T4Yt"
+      + "6/0f6N/0NC7E9qfq4ZlpU3uCGGu/44kAlQMFEDQz8kp2sPVxuCQEdQEBc5YD/Rix"
+      + "vFcLTO1HznbblrO0WMzQc+R4qQ50CmCpWcFMwvVeQHo/bxoxGggNMmuVT0bqf7Mo"
+      + "lZDSJNS96IAN32uf25tYHgERnQaMhmi1aSHvRDh4jxFu8gGVgL6lWit/vBDW/BiF"
+      + "BCH6sZJJrGSuSdpecTtaWC8OJGDoKTO9PqAA/HQRiQB1AwUQNDJSx011eFs7VOAZ"
+      + "AQGdKQL/ea3qD2OP3wVTzXvfjQL1CosX4wyKusBBhdt9u2vOT+KWkiRk1o35nIOG"
+      + "uZLHtSFQDY8CVDOkqg6g4sVbOcTl8QUwHA+A4AVDInwTm1m4Bk4oeCIwk4Bp6mDd"
+      + "W11g28k/iQEVAgUSNDIWPm/Y4wPDeaMxAQGvBQgAqGhzA/21K7oL/L5S5Xz//eO7"
+      + "J8hgvqqGXWd13drNy3bHbKPn7TxilkA3ca24st+6YPZDdSUHLMCqg16YOMyQF8gE"
+      + "kX7ZHWPacVoUpCmSz1uQ3p6W3+u5UCkRpgQN8wBbJx5ZpBBqeq5q/31okaoNjzA2"
+      + "ghEWyR5Ll+U0C87MY7pc7PlNHGCr0ZNOhhtf1jU+H9ag5UyT6exIYim3QqWYruiC"
+      + "LSUcim0l3wK7LMW1w/7Q6cWfAFQvl3rGjt3rg6OWg9J4H2h5ukf5JNiRybkupmat"
+      + "UM+OVMRkf93jzU62kbyZpJBHiQZuxxJaLkhpv2RgWib9pbkftwEy/ZnmjkxlIIkA"
+      + "lQMFEDQvWjh4313xYR8/NQEB37QEAIi9vR9h9ennz8Vi7RNU413h1ZoZjxfEbOpk"
+      + "QAjE/LrZ/L5WiWdoStSiyqCLPoyPpQafiU8nTOr1KmY4RgceJNgxIW4OiSMoSvrh"
+      + "c2kqP+skb8A2B4+47Aqjr5fSAVfVfrDMqDGireOguhQ/hf9BOYsM0gs+ROdtyLWP"
+      + "tMjRnFlviD8DBRAz8qQSj6lRT5YOKXIRAntSAJ9StSEMBoFvk8iRWpXb6+LDNLUW"
+      + "zACfT8iY3IxwvMF6jjCHrbuxQkL7chSJARUDBRA0MMO7569NIyeqD3EBATIAB/4t"
+      + "CPZ1sLWO07g2ZCpiP1HlYpf5PENaXtaasFvhWch7eUe3DksuMEPzB5GnauoQZAku"
+      + "hEGkoEfrfL3AXtXH+WMm2t7dIcTBD4p3XkeZ+PgJpKiASXDyul9rumXXvMxSL4KV"
+      + "7ar+F1ZJ0ycCx2r2au0prPao70hDAzLTy16hrWgvdHSK7+wwaYO5TPCL5JDmcB+d"
+      + "HKW72qNUOD0pxbe0uCkkb+gDxeVX28pZEkIIOMMV/eAs5bs/smV+eJqWT/EyfVBD"
+      + "o7heF2aeyJj5ecxNOODr88xKF7qEpqazCQ4xhvFY+Yn6+vNCcYfkoZbOn0XQAvqf"
+      + "a2Vab9woVIVSaDji/mlPiQB1AwUQNDC233FfeD4HYGBJAQFh6QL/XCgm5O3q9kWp"
+      + "gts1MHKoHoh7vxSSQGSP2k7flNP1UB2nv4sKvyGM8eJKApuROIodcTkccM4qXaBu"
+      + "XunMr5kJlvDJPm+NLzKyhtQP2fWI7xGYwiCiB29gm1GFMjdur4amiQEVAwUQNDBR"
+      + "9fjDdqGixRdJAQE+mAf+JyqJZEVFwNwZ2hSIMewekC1r7N97p924nqfZKnzn6weF"
+      + "pE80KIJSWtEVzI0XvHlVCOnS+WRxn7zxwrOTbrcEOy0goVbNgUsP5ypZa2/EM546"
+      + "uyyJTvgD0nwA45Q4bP5sGhjh0G63r9Vwov7itFe4RDBGM8ibGnZTr9hHo469jpom"
+      + "HSNeavcaUYyEqcr4GbpQmdpJTnn/H0A+fMl7ZHRoaclNx9ZksxihuCRrkQvUOb3u"
+      + "RD9lFIhCvNwEardN62dKOKJXmn1TOtyanZvnmWigU5AmGuk6FpsClm3p5vvlid64"
+      + "i49fZt9vW5krs2XfUevR4oL0IyUl+qW2HN0DIlDiAYkAlQMFEDQvbv2wcgJwUPMh"
+      + "JQEBVBID/iOtS8CQfMxtG0EmrfaeVUU8R/pegBmVWDBULAp8CLTtdfxjVzs/6DXw"
+      + "0RogXMRRl2aFfu1Yp0xhBYjII6Kque/FzAFXY9VNF1peqnPt7ADdeptYMppZa8sG"
+      + "n9BBRu9Fsw69z6JkyqvMiVxGcKy3XEpVGr0JHx8Xt6BYdrULiKr2iQB1AwUQNC68"
+      + "n6jZR/ntlUftAQFaYgL+NUYEj/sX9M5xq1ORX0SsVPMpNamHO3JBSmZSIzjiox5M"
+      + "AqoFOCigAkonuzk5aBy/bRHy1cmDBOxf4mNhzrH8N6IkGvPE70cimDnbFvr+hoZS"
+      + "jIqxtELNZsLuLVavLPAXiQCVAwUQNC6vWocCuHlnLQXBAQHb1gQAugp62aVzDCuz"
+      + "4ntfXsmlGbLY7o5oZXYIKdPP4riOj4imcJh6cSgYFL6OMzeIp9VW/PHo2mk8kkdk"
+      + "z5uif5LqOkEuIxgra7p1Yq/LL4YVhWGQeD8hwpmu+ulYoPOw40dVYS36PwrHIH9a"
+      + "fNhl8Or5O2VIHIWnoQ++9r6gwngFQOyJAJUDBRAzHnkh1sNKtX1rroUBAWphBACd"
+      + "huqm7GHoiXptQ/Y5F6BivCjxr9ch+gPSjaLMhq0kBHVO+TbXyVefVVGVgCYvFPjo"
+      + "zM8PEVykQAtY//eJ475aGXjF+BOAhl2z0IMkQKCJMExoEDHbcj0jIIMZ2/+ptgtb"
+      + "FSyJ2DQ3vvCdbw/1kyPHTPfP+L2u40GWMIYVBbyouokAlQMFEDMe7+UZsymln7HG"
+      + "2QEBzMED/3L0DyPK/u6PyAd1AdpjUODTkWTZjZ6XA2ubc6IXXsZWpmCgB/24v8js"
+      + "J3DIsvUD3Ke55kTr6xV+au+mAkwOQqWUTUWfQCkSrSDlbUJ1VPBzhyTpuzjBopte"
+      + "7o3R6XXfcLiC5jY6eCX0QtLGhKpLjTr5uRhf1fYODGsAGXmCByDviQB1AgUQMy6U"
+      + "MB0Z9MEMmFelAQHV4AMAjdFUIyFtpTr5jkyZSd3y//0JGO0z9U9hLVxeBBCwvdEQ"
+      + "xsrpeTtVdqpeKZxHN1GhPCYvgLFZAQlcPh/Gc8u9uO7wVSgJc3zYKFThKpQevdF/"
+      + "rzjTCHfgigf5Iui0qiqBiQCVAwUQMx22bAtzgG/ED06dAQFi0gQAkosqTMWy+1eU"
+      + "Xbi2azFK3RX5ERf9wlN7mqh7TvwcPXvVWzUARnwRv+4kk3uOWI18q5UPis7KH3KY"
+      + "OVeRrPd8bbp6SjhBh82ourTEQUXLBDQiI1V1cZZmwwEdlnAnhFnkXgMBNM2q7oBe"
+      + "fRHADfYDfGo90wXyrVVL+GihDNpzUwOJAJUDBRAzHUFnOWvfULwOR3EBAbOYA/90"
+      + "JIrKmxhwP6quaheFOjjPoxDGEZpGJEOwejEByYj+AgONCRmQS3BydtubA+nm/32D"
+      + "FeG8pe/dnFvGc+QgNW560hK21C2KJj72mhjRlg/na7jz4/MmBAv5k61Q7roWi0rw"
+      + "x+R9NSHxpshC8A92zmvo8w/XzVSogC8pJ04jcnY6YokAlQMFEDMdPtta9LwlvuSC"
+      + "3QEBvPMD/3TJGroHhHYjHhiEpDZZVszeRQ0cvVI/uLLi5yq3W4F6Jy47DF8VckA7"
+      + "mw0bXrOMNACN7Je7uyaU85qvJC2wgoQpFGdFlkjmkAwDAjR+koEysiE8FomiOHhv"
+      + "EpEY/SjSS4jj4IPmgV8Vq66XjPw+i7Z0RsPLOIf67yZHxypNiBiYiQCVAwUQMxxw"
+      + "pKrq6G7/78D5AQHo2QQAjnp6KxOl6Vvv5rLQ/4rj3OemvF7IUUq34xb25i/BSvGB"
+      + "UpDQVUmhv/qIfWvDqWGZedyM+AlNSfUWPWnP41S8OH+lcERH2g2dGKGl7kH1F2Bx"
+      + "ByZlqREHm2q624wPPA35RLXtXIx06yYjLtJ7b+FCAX6PUgZktZYk5gwjdoAGrC2J"
+      + "AJUDBRAzGvcCKC6c7f53PGUBAUozA/9l/qKmcqbi8RtLsKQSh3vHds9d22zcbkuJ"
+      + "PBSoOv2D7i2VLshaQFjq+62uYZGE6nU1WP5sZcBDuWjoX4t4NrffnOG/1R9D0t1t"
+      + "9F47D77HJzjvo+J52SN520YHcbT8VoHdPRoEOXPN4tzhvn2GapVVdaAlWM0MLloh"
+      + "NH3I9jap9okAdQMFEDMZlUAnyXglSykrxQEBnuwC/jXbFL+jzs2HQCuo4gyVrPlU"
+      + "ksQCLYZjNnZtw1ca697GV3NhBhSXR9WHLQH+ZWnpTzg2iL3WYSdi9tbPs78iY1FS"
+      + "d4EG8H9V700oQG8dlICF5W2VjzR7fByNosKM70WSXYkBFQMFEDMWBsGCy1t9eckW"
+      + "HQEBHzMH/jmrsHwSPrA5R055VCTuDzdS0AJ+tuWkqIyqQQpqbost89Hxper3MmjL"
+      + "Jas/VJv8EheuU3vQ9a8sG2SnlWKLtzFqpk7TCkyq/H3blub0agREbNnYhHHTGQFC"
+      + "YJb4lWjWvMjfP+N5jvlLcnDqQPloXfAOgy7W90POoqFrsvhxdpnXgoLrzyNNja1O"
+      + "1NRj+Cdv/GmJYNi6sQe43zmXWeA7syLKMw6058joDqEJFKndgSp3Zy/yXmObOZ/H"
+      + "C2OJwA3gzEaAu8Pqd1svwGIGznqtTNCn9k1+rMvJPaxglg7PXIJS282hmBl9AcJl"
+      + "wmh2GUCswl9/sj+REWTb8SgJUbkFcp6JAJUDBRAwdboVMPfsgxioXMEBAQ/LA/9B"
+      + "FTZ9T95P/TtsxeC7lm9imk2mpNQCBEvXk286FQnGFtDodGfBfcH5SeKHaUNxFaXr"
+      + "39rDGUtoTE98iAX3qgCElf4V2rzgoHLpuQzCg3U35dfs1rIxlpcSDk5ivaHpPV3S"
+      + "v+mlqWL049y+3bGaZeAnwM6kvGMP2uccS9U6cbhpw4hGBBARAgAGBQI3GtRfAAoJ"
+      + "EF3iSZZbA1iikWUAoIpSuXzuN/CI63dZtT7RL7c/KtWUAJ929SAtTr9SlpSgxMC8"
+      + "Vk1T1i5/SYkBFQMFEzccnFnSJilEzmrGwQEBJxwH/2oauG+JlUC3zBUsoWhRQwqo"
+      + "7DdqaPl7sH5oCGDKS4x4CRA23U15NicDI7ox6EizkwCjk0dRr1EeRK+RqL1b/2T4"
+      + "2B6nynOLhRG2A0BPHRRJLcoL4nKfoPSo/6dIC+3iVliGEl90KZZD5bnONrVJQkRj"
+      + "ZL8Ao+9IpmoYh8XjS5xMLEF9oAQqAkA93nVBm56lKmaL1kl+M3dJFtNKtVB8de1Z"
+      + "XifDs8HykD42qYVtcseCKxZXhC3UTG5YLNhPvgZKH8WBCr3zcR13hFDxuecUmu0M"
+      + "VhvEzoKyBYYt0rrqnyWrxwbv4gSTUWH5ZbgsTjc1SYKZxz6hrPQnfYWzNkznlFWJ"
+      + "ARUDBRM0xL43CdxwOTnzf10BATOCB/0Q6WrpzwPMofjHj54MiGLKVP++Yfwzdvns"
+      + "HxVpTZLZ5Ux8ErDsnLmvUGphnLVELZwEkEGRjln7a19h9oL8UYZaV+IcR6tQ06Fb"
+      + "1ldR+q+3nXtBYzGhleXdgJQSKLJkzPF72tvY0DHUB//GUV9IBLQMvfG8If/AFsih"
+      + "4iXi96DOtUAbeuIhnMlWwLJFeGjLLsX1u6HSX33xy4bGX6v/UcHbTSSYaxzb92GR"
+      + "/xpP2Xt332hOFRkDZL52g27HS0UrEJWdAVZbh25KbZEl7C6zX/82OZ5nTEziHo20"
+      + "eOS6Nrt2+gLSeA9X5h/+qUx30kTPz2LUPBQyIqLCJkHM8+0q5j9ciQCiAwUTNMS+"
+      + "HZFeTizbCJMJAQFrGgRlEAkG1FYU4ufTxsaxhFZy7xv18527Yxpls6mSCi1HL55n"
+      + "Joce6TI+Z34MrLOaiZljeQP3EUgzA+cs1sFRago4qz2wS8McmQ9w0FNQQMz4vVg9"
+      + "CVi1JUVd4EWYvJpA8swDd5b9+AodYFEsfxt9Z3aP+AcWFb10RlVVsNw9EhObc6IM"
+      + "nwAOHCEI9vp5FzzFiQCVAwUQNxyr6UyjTSyISdw9AQHf+wP+K+q6hIQ09tkgaYaD"
+      + "LlWKLbuxePXqM4oO72qi70Gkg0PV5nU4l368R6W5xgR8ZkxlQlg85sJ0bL6wW/Sj"
+      + "Mz7pP9hkhNwk0x3IFkGMTYG8i6Gt8Nm7x70dzJoiC+A496PryYC0rvGVf+Om8j5u"
+      + "TexBBjb/jpJhAQ/SGqeDeCHheOC0Lldlcm5lciBLb2NoIChtZWluIGFsdGVyIGtl"
+      + "eSkgPHdrQGNvbXB1dGVyLm9yZz6JAHUDBRM2G2MyHRn0wQyYV6UBASKKAv4wzmK7"
+      + "a9Z+g0KH+6W8ffIhzrQo8wDAU9X1WJKzJjS205tx4mmdnAt58yReBc/+5HXTI8IK"
+      + "R8IgF+LVXKWAGv5P5AqGhnPMeQSCs1JYdf9MPvbe34jD8wA1LTWFXn9e/cWIRgQQ"
+      + "EQIABgUCNxrUaQAKCRBd4kmWWwNYovRiAJ9dJBVfjx9lGARoFXmAieYrMGDrmwCZ"
+      + "AQyO4Wo0ntQ+iq4do9M3/FTFjiCZAaIENu1I6REEAJRGEqcYgXJch5frUYBj2EkD"
+      + "kWAbhRqVXnmiF3PjCEGAPMMYsTddiU7wcKfiCAqKWWXow7BjTJl6Do8RT1jdKpPO"
+      + "lBJXqqPYzsyBxLzE6mLps0K7SLJlSKTQqSVRcx0jx78JWYGlAlP0Kh9sPV2w/rPh"
+      + "0LrPeOKXT7lZt/DrIhfPAKDL/sVqCrmY3QfvrT8kSKJcgtLWfQP/cfbqVNrGjW8a"
+      + "m631N3UVA3tWfpgM/T9OjmKmw44NE5XfPJTAXlCV5j7zNMUkDeoPkrFF8DvbpYQs"
+      + "4XWYHozDjhR2Q+eI6gZ0wfmhLHqqc2eVVkEG7dT57Wp9DAtCMe7RZfhnarTQMqlY"
+      + "tOEa/suiHk0qLo59NsyF8eh68IDNCeYD/Apzonwaq2EQ1OEpfFlp6LcSnS34+UGZ"
+      + "tTO4BgJdmEjr/QrIPp6bJDstgho+/2oR8yQwuHGJwbS/8ADA4IFEpLduSpzrABho"
+      + "7RuNQcm96bceRY+7Hza3zf7pg/JGdWOb+bC3S4TIpK+3sx3YNWs7eURwpGREeJi5"
+      + "/Seic+GXlGzltBpXZXJuZXIgS29jaCA8d2tAZ251cGcub3JnPohjBBMRAgAbBQI3"
+      + "Gs+QBQkMyXyAAwsKAwMVAwIDFgIBAheAABIJEF3iSZZbA1iiB2VHUEcAAQFdwgCe"
+      + "O/s43kCLDMIsHCb2H3LC59clC5UAn1EyrqWk+qcOXLpQIrP6Qa3QSmXIiEYEEBEC"
+      + "AAYFAjca0T0ACgkQbH7huGIcwBOF9ACeNwO8G2G0ei03z0g/n3QZIpjbzvEAnRaE"
+      + "qX2PuBbClWoIP6h9yrRlAEbUiQB1AwUQNxrRYx0Z9MEMmFelAQHRrgL/QDNKPV5J"
+      + "gWziyzbHvEKfTIw/Ewv6El2MadVvQI8kbPN4qkPr2mZWwPzuc9rneCPQ1eL8AOdC"
+      + "8+ZyxWzx2vsrk/FcU5donMObva2ct4kqJN6xl8xjsxDTJhBSFRaiBJjxiEYEEBEC"
+      + "AAYFAjca0aMACgkQaLeriVdUjc0t+ACghK37H2vTYeXXieNJ8aZkiPJSte4An0WH"
+      + "FOotQdTW4NmZJK+Uqk5wbWlgiEYEEBECAAYFAjdPH10ACgkQ9u7fIBhLxNktvgCe"
+      + "LnQ5eOxAJz+Cvkb7FnL/Ko6qc5YAnjhWWW5c1o3onvKEH2Je2wQa8T6iiEYEEBEC"
+      + "AAYFAjenJv4ACgkQmDRl2yFDlCJ+yQCfSy1zLftEfLuIHZsUHis9U0MlqLMAn2EI"
+      + "f7TI1M5OKysQcuFLRC58CfcfiEUEEBECAAYFAjfhQTMACgkQNmdg8X0u14h55wCf"
+      + "d5OZCV3L8Ahi4QW/JoXUU+ZB0M0AmPe2uw7WYDLOzv48H76tm6cy956IRgQQEQIA"
+      + "BgUCOCpiDwAKCRDj8lhUEo8OeRsdAJ9FHupRibBPG2t/4XDqF+xiMLL/8ACfV5F2"
+      + "SR0ITE4k/C+scS1nJ1KZUDW0C1dlcm5lciBLb2NoiGMEExECABsFAjbtSOoFCQzJ"
+      + "fIADCwoDAxUDAgMWAgECF4AAEgkQXeJJllsDWKIHZUdQRwABAbXWAJ9SCW0ieOpL"
+      + "7AY6vF+OIaMmw2ZW1gCgkto0eWfgpjAuVg6jXqR1wHt2pQOJAh4EEBQDAAYFAjcv"
+      + "WdQACgkQbEwxpbHVFWcNxQf/bg14WGJ0GWMNSuuOOR0WYzUaNtzYpiLSVyLrreXt"
+      + "o8LBNwzbgzj2ramW7Ri+tYJAHLhtua8ZgSeibmgBuZasF8db1m5NN1ZcHBXGTysA"
+      + "jp+KnicTZ9Orj75D9o3oSmMyRcisEhr+gkj0tVhGfOAOC6eKbufVuyYFDVIyOyUB"
+      + "GlW7ApemzAzYemfs3DdjHn87lkjHMVESO4fM5rtLuSc7cBfL/e6ljaWQc5W8S0gI"
+      + "Dv0VtL39pMW4BlpKa25r14oJywuUpvWCZusvDm7ZJnqZ/WmgOHQUsyYudTROpGIb"
+      + "lsNg8iqC6huWpGSBRdu3oRQRhkqpfVdszz6BB/nAx01q2wf/Q+U9XId1jyzxUL1S"
+      + "GgaYMf6QdyjHQ1oxuFLNxzM6C/M069twbNgXJ71RsDDXVxFZfSTjSiH100AP9+9h"
+      + "b5mycaXLUOXYDvOSFzHBd/LsjFNVrrFbDs5Xw+cLGVHOIgR5IWAfgu5d1PAZU9uQ"
+      + "VgdGnQfmZg383RSPxvR3fnZz1rHNUGmS6w7x6FVbxa1QU2t38gNacIwHATAPcBpy"
+      + "JLfXoznbpg3ADbgCGyDjBwnuPQEQkYwRakbczRrge8IaPZbt2HYPoUsduXMZyJI8"
+      + "z5tvu7pUDws51nV1EX15BcN3++aY5pUyA1ItaaDymQVmoFbQC0BNMzMO53dMnFko"
+      + "4i42kohGBBARAgAGBQI3OvmjAAoJEHUPZJXInZM+hosAnRntCkj/70shGTPxgpUF"
+      + "74zA+EbzAKCcMkyHXIz2W0Isw3gDt27Z9ggsE4hGBBARAgAGBQI3NyPFAAoJEPbu"
+      + "3yAYS8TZh2UAoJVmzw85yHJzsXQ1vpO2IAPfv59NAJ9WY0oiYqb3q1MSxBRwG0gV"
+      + "iNCJ7YkBFQMFEDdD3tNSgFdEdlNAHQEByHEH/2JMfg71GgiyGJTKxCAymdyf2j2y"
+      + "fH6wI782JK4BWV4c0E/V38q+jpIYslihV9t8s8w1XK5niMaLwlCOyBWOkDP3ech6"
+      + "+GPPtfB3cmlL2hS896PWZ1adQHgCeQpB837n56yj0aTs4L1xarbSVT22lUwMiU6P"
+      + "wYdH2Rh8nh8FvN0IZsbln2nOj73qANQzNflmseUKF1Xh4ck8yLrRd4r6amhxAVAf"
+      + "cYFRJN4zdLL3cmhgkt0ADZlzAwXnEjwdHHy7SvAJk1ecNOA9pFsOJbvnzufd1afs"
+      + "/CbG78I+0JDhg75Z2Nwq8eKjsKqiO0zz/vG5yWSndZvWkTWz3D3b1xr1Id2IRgQQ"
+      + "EQIABgUCOCpiHgAKCRDj8lhUEo8OeQ+QAKCbOTscyUnWHSrDo4fIy0MThEjhOgCe"
+      + "L4Kb7TWkd/OHQScVBO8sTUz0+2g=");
+
+    byte[] pub6check = Base64.decode("62O9");
+
+    //
+    // revoked sub key
+    //
+    byte[] pub7 = Base64.decode(
+        "mQGiBEFOsIwRBADcjRx7nAs4RaWsQU6p8/ECLZD9sSeYc6CN6UDI96RKj0/hCzMs"
+      + "qlA0+9fzGZ7ZEJ34nuvDKlhKGC7co5eOiE0a9EijxgcrZU/LClZWa4YfyNg/ri6I"
+      + "yTyfOfrPQ33GNQt2iImDf3FKp7XKuY9nIxicGQEaW0kkuAmbV3oh0+9q8QCg/+fS"
+      + "epDEqEE/+nKONULGizKUjMED/RtL6RThRftZ9DOSdBytGYd48z35pca/qZ6HA36K"
+      + "PVQwi7V77VKQyKFLTOXPLnVyO85hyYB/Nv4DFHN+vcC7/49lfoyYMZlN+LarckHi"
+      + "NL154wmmzygB/KKysvWBLgkErEBCD0xBDd89iTQNlDtVQAWGORVffl6WWjOAkliG"
+      + "3dL6A/9A288HfFRnywqi3xddriV6wCPmStC3dkCS4vHk2ofS8uw4ZNoRlp1iEPna"
+      + "ai2Xa9DX1tkhaGk2k96MqqbBdGpbW8sMA9otJ9xdMjWEm/CgJUFUFQf3zaVy3mkM"
+      + "S2Lvb6P4Wc2l/diEEIyK8+PqJItSh0OVU3K9oM7ngHwVcalKILQVUkV2b2tlZCA8"
+      + "UmV2b2tlZEB0ZWQ+iQBOBBARAgAOBQJBTrCMBAsDAgECGQEACgkQvglkcFA/c63+"
+      + "QgCguh8rsJbPTtbhZcrqBi5Mo1bntLEAoPZQ0Kjmu2knRUpHBeUemHDB6zQeuQIN"
+      + "BEFOsIwQCAD2Qle3CH8IF3KiutapQvMF6PlTETlPtvFuuUs4INoBp1ajFOmPQFXz"
+      + "0AfGy0OplK33TGSGSfgMg71l6RfUodNQ+PVZX9x2Uk89PY3bzpnhV5JZzf24rnRP"
+      + "xfx2vIPFRzBhznzJZv8V+bv9kV7HAarTW56NoKVyOtQa8L9GAFgr5fSI/VhOSdvN"
+      + "ILSd5JEHNmszbDgNRR0PfIizHHxbLY7288kjwEPwpVsYjY67VYy4XTjTNP18F1dD"
+      + "ox0YbN4zISy1Kv884bEpQBgRjXyEpwpy1obEAxnIByl6ypUM2Zafq9AKUJsCRtMI"
+      + "PWakXUGfnHy9iUsiGSa6q6Jew1XpMgs7AAICB/93zriSvSHqsi1FeEmUBo431Jkh"
+      + "VerIzb6Plb1j6FIq+s3vyvx9K+dMvjotZqylWZj4GXpH+2xLJTjWkrGSfUZVI2Nk"
+      + "nyOFxUCKLLqaqVBFAQIjULfvQfGEWiGQKk9aRLkdG+D+8Y2N9zYoBXoQ9arvvS/t"
+      + "4mlOsiuaTe+BZ4x+BXTpF4b9sKZl7V8QP/TkoJWUdydkvxciHdWp7ssqyiKOFRhG"
+      + "818knDfFQ3cn2w/RnOb+7AF9wDncXDPYLfpPv9b2qZoLrXcyvlLffGDUdWs553ut"
+      + "1F5AprMURs8BGmY9BnjggfVubHdhTUoA4gVvrdaf+D9NwZAl0xK/5Y/oPuMZiQBG"
+      + "BBgRAgAGBQJBTrCMAAoJEL4JZHBQP3Ot09gAoMmLKloVDP+WhDXnsM5VikxysZ4+"
+      + "AKCrJAUO+lYAyPYwEwgK+bKmUGeKrIkARgQoEQIABgUCQU6wpQAKCRC+CWRwUD9z"
+      + "rQK4AJ98kKFxGU6yhHPr6jYBJPWemTNOXgCfeGB3ox4PXeS4DJDuLy9yllytOjo=");
+
+    byte[] pub7check = Base64.decode("f/YQ");
+    
+    byte[] pub8 = Base64.decode(
+              "mQGiBEEcraYRBADFYj+uFOhHz5SdECvJ3Z03P47gzmWLQ5HH8fPYC9rrv7AgqFFX"
+            + "aWlJJVMLua9e6xoCiDWJs/n4BbZ/weL/11ELg6XqUnzFhYyz0H2KFsPgQ/b9lWLY"
+            + "MtcPMFy5jE33hv/ixHgYLFqoNaAIbg0lzYEW/otQ9IhRl16fO1Q/CQZZrQCg/9M2"
+            + "V2BTmm9RYog86CXJtjawRBcD/RIqU0zulxZ2Zt4javKVxrGIwW3iBU935ebmJEIK"
+            + "Y5EVkGKBOCvsApZ+RGzpYeR2uMsTnQi8RJgiAnjaoVPCdsVJE7uQ0h8XuJ5n5mJ2"
+            + "kLCFlF2hj5ViicZzse+crC12CGtgRe8z23ubLRcd6IUGhVutK8/b5knZ22vE14JD"
+            + "ykKdA/96ObzJQdiuuPsEWN799nUUCaYWPAoLAmiXuICSP4GEnxLbYHWo8zhMrVMT"
+            + "9Q5x3h8cszUz7Acu2BXjP1m96msUNoxPOZtt88NlaFz1Q/JSbQTsVOMd9b/IRN6S"
+            + "A/uU0BiKEMHXuT8HUHVPK49oCKhZrGFP3RT8HZxDKLmR/qrgZ7ABh7QhSmlhIFlp"
+            + "eXUgPHl5amlhQG5vd21lZGlhdGVjaC5jb20+sAMD//+JAF0EEBECAB0FAkEcraYH"
+            + "CwkIBwMCCgIZAQUbAwAAAAUeAQAAAAAKCRD0/lb4K/9iFJlhAKCRMifQewiX5o8F"
+            + "U099FG3QnLVUZgCfWpMOsHulGHfNrxdBSkE5Urqh1ymwAWe5Ag0EQRytphAIAPZC"
+            + "V7cIfwgXcqK61qlC8wXo+VMROU+28W65Szgg2gGnVqMU6Y9AVfPQB8bLQ6mUrfdM"
+            + "ZIZJ+AyDvWXpF9Sh01D49Vlf3HZSTz09jdvOmeFXklnN/biudE/F/Ha8g8VHMGHO"
+            + "fMlm/xX5u/2RXscBqtNbno2gpXI61Brwv0YAWCvl9Ij9WE5J280gtJ3kkQc2azNs"
+            + "OA1FHQ98iLMcfFstjvbzySPAQ/ClWxiNjrtVjLhdONM0/XwXV0OjHRhs3jMhLLUq"
+            + "/zzhsSlAGBGNfISnCnLWhsQDGcgHKXrKlQzZlp+r0ApQmwJG0wg9ZqRdQZ+cfL2J"
+            + "SyIZJrqrol7DVekyCzsAAgIH/3K2wKRSzkIpDfZR25+tnQ8brv3TYoDZo3/wN3F/"
+            + "r6PGjx0150Q8g8EAC0bqm4rXWzOqdSxYxvIPOAGm5P4y+884yS6j3vKcXitT7vj+"
+            + "ODc2pVwGDLDjrMRrosSK89ycPCK6R/5pD7Rv4l9DWi2fgLvXqJHS2/ujUf2uda9q"
+            + "i9xNMnBXIietR82Sih4undFUOwh6Mws/o3eed9DIdaqv2Y2Aw43z/rJ6cjSGV3C7"
+            + "Rkf9x85AajYA3LwpS8d99tgFig2u6V/A16oi6/M51oT0aR/ZAk50qUc4WBk9uRUX"
+            + "L3Y+P6v6FCBE/06fgVltwcQHO1oKYKhH532tDL+9mW5/dYGwAYeJAEwEGBECAAwF"
+            + "AkEcraYFGwwAAAAACgkQ9P5W+Cv/YhShrgCg+JW8m5nF3R/oZGuG87bXQBszkjMA"
+            + "oLhGPncuGKowJXMRVc70/8qwXQJLsAFnmQGiBD2K5rYRBADD6kznWZA9nH/pMlk0"
+            + "bsG4nI3ELgyI7KpgRSS+Dr17+CCNExxCetT+fRFpiEvUcSxeW4pOe55h0bQWSqLo"
+            + "MNErXVJEXrm1VPkC08W8D/gZuPIsdtKJu4nowvdoA+WrI473pbeONGjaEDbuIJak"
+            + "yeKM1VMSGhsImdKtxqhndq2/6QCg/xARUIzPRvKr2TJ52K393895X1kEAMCdjSs+"
+            + "vABnhaeNNR5+NNkkIOCCjCS8qZRZ4ZnIayvn9ueG3KrhZeBIHoajUHrlTXBVj7XO"
+            + "wXVfGpW17jCDiqhU8Pu6VwEwX1iFbuUwqBffiRLXKg0zfcN+MyFKToi+VsJi4jiZ"
+            + "zcwUFMb8jE8tvR/muXti7zKPRPCbNBExoCt4A/0TgkzAosG/W4dUkkbc6XoHrjob"
+            + "iYuy6Xbs/JYlV0vf2CyuKCZC6UoznO5x2GkvOyVtAgyG4HSh1WybdrutZ8k0ysks"
+            + "mOthE7n7iczdj9Uwg2h+TfgDUnxcCAwxnOsX5UaBqGdkX1PjCWs+O3ZhUDg6UsZc"
+            + "7O5a3kstf16lHpf4q7ABAIkAYQQfEQIAIQUCPYrmtgIHABcMgBHRi/xlIgI+Q6LT"
+            + "kNJ7zKvTd87NHAAKCRDJM3gHb/sRj7bxAJ9f6mdlXQH7gMaYiY5tBe/FRtPr1gCf"
+            + "UhDJQG0ARvORFWHjwhhBMLxW7j2wAWC0KkRlc21vbmQgS2VlIDxkZXNtb25kLmtl"
+            + "ZUBub3dtZWRpYXRlY2guY29tPrADAQD9iQBYBBARAgAYBQI9iua2CAsDCQgHAgEK"
+            + "AhkBBRsDAAAAAAoJEMkzeAdv+xGP7v4An19iqadBCCgDIe2DTpspOMidwQYPAJ4/"
+            + "5QXbcn4ClhOKTO3ZEZefQvvL27ABYLkCDQQ9iua2EAgA9kJXtwh/CBdyorrWqULz"
+            + "Bej5UxE5T7bxbrlLOCDaAadWoxTpj0BV89AHxstDqZSt90xkhkn4DIO9ZekX1KHT"
+            + "UPj1WV/cdlJPPT2N286Z4VeSWc39uK50T8X8dryDxUcwYc58yWb/Ffm7/ZFexwGq"
+            + "01uejaClcjrUGvC/RgBYK+X0iP1YTknbzSC0neSRBzZrM2w4DUUdD3yIsxx8Wy2O"
+            + "9vPJI8BD8KVbGI2Ou1WMuF040zT9fBdXQ6MdGGzeMyEstSr/POGxKUAYEY18hKcK"
+            + "ctaGxAMZyAcpesqVDNmWn6vQClCbAkbTCD1mpF1Bn5x8vYlLIhkmuquiXsNV6TIL"
+            + "OwACAgf/SO+bbg+owbFKVN5HgOjOElQZVnCsegwCLqTeQzPPzsWmkGX2qZJPDIRN"
+            + "RZfJzti6+oLJwaRA/3krjviUty4VKhZ3lKg8fd9U0jEdnw+ePA7yJ6gZmBHL15U5"
+            + "OKH4Zo+OVgDhO0c+oetFpend+eKcvtoUcRoQoi8VqzYUNG0b/nmZGDlxQe1/ZNbP"
+            + "HpNf1BAtJXivCEKMD6PVzsLPg2L4tFIvD9faeeuKYQ4jcWtTkBLuIaZba3i3a4wG"
+            + "xTN20j9HpISVuLW/EfZAK1ef4DNjLmHEU9dMzDqfi+hPmMbGlFqcKr+VjcYIDuje"
+            + "o+92xm/EWAmlti88r2hZ3MySamHDrLABAIkATAQYEQIADAUCPYrmtgUbDAAAAAAK"
+            + "CRDJM3gHb/sRjzVTAKDVS+OJLMeS9VLAmT8atVCB42MwIQCgoh1j3ccWnhc/h6B7"
+            + "9Uqz3fUvGoewAWA=");
+
+    byte[] sec8 = Base64.decode(
+              "lQHpBEEcraYRBADFYj+uFOhHz5SdECvJ3Z03P47gzmWLQ5HH8fPYC9rrv7AgqFFX"
+            + "aWlJJVMLua9e6xoCiDWJs/n4BbZ/weL/11ELg6XqUnzFhYyz0H2KFsPgQ/b9lWLY"
+            + "MtcPMFy5jE33hv/ixHgYLFqoNaAIbg0lzYEW/otQ9IhRl16fO1Q/CQZZrQCg/9M2"
+            + "V2BTmm9RYog86CXJtjawRBcD/RIqU0zulxZ2Zt4javKVxrGIwW3iBU935ebmJEIK"
+            + "Y5EVkGKBOCvsApZ+RGzpYeR2uMsTnQi8RJgiAnjaoVPCdsVJE7uQ0h8XuJ5n5mJ2"
+            + "kLCFlF2hj5ViicZzse+crC12CGtgRe8z23ubLRcd6IUGhVutK8/b5knZ22vE14JD"
+            + "ykKdA/96ObzJQdiuuPsEWN799nUUCaYWPAoLAmiXuICSP4GEnxLbYHWo8zhMrVMT"
+            + "9Q5x3h8cszUz7Acu2BXjP1m96msUNoxPOZtt88NlaFz1Q/JSbQTsVOMd9b/IRN6S"
+            + "A/uU0BiKEMHXuT8HUHVPK49oCKhZrGFP3RT8HZxDKLmR/qrgZ/4JAwLXyWhb4pf4"
+            + "nmCmD0lDwoYvatLiR7UQVM2MamxClIiT0lCPN9C2AYIFgRWAJNS215Tjx7P/dh7e"
+            + "8sYfh5XEHErT3dMbsAGHtCFKaWEgWWl5dSA8eXlqaWFAbm93bWVkaWF0ZWNoLmNv"
+            + "bT6wAwP//4kAXQQQEQIAHQUCQRytpgcLCQgHAwIKAhkBBRsDAAAABR4BAAAAAAoJ"
+            + "EPT+Vvgr/2IUmWEAoJEyJ9B7CJfmjwVTT30UbdCctVRmAJ9akw6we6UYd82vF0FK"
+            + "QTlSuqHXKbABZ50CawRBHK2mEAgA9kJXtwh/CBdyorrWqULzBej5UxE5T7bxbrlL"
+            + "OCDaAadWoxTpj0BV89AHxstDqZSt90xkhkn4DIO9ZekX1KHTUPj1WV/cdlJPPT2N"
+            + "286Z4VeSWc39uK50T8X8dryDxUcwYc58yWb/Ffm7/ZFexwGq01uejaClcjrUGvC/"
+            + "RgBYK+X0iP1YTknbzSC0neSRBzZrM2w4DUUdD3yIsxx8Wy2O9vPJI8BD8KVbGI2O"
+            + "u1WMuF040zT9fBdXQ6MdGGzeMyEstSr/POGxKUAYEY18hKcKctaGxAMZyAcpesqV"
+            + "DNmWn6vQClCbAkbTCD1mpF1Bn5x8vYlLIhkmuquiXsNV6TILOwACAgf/crbApFLO"
+            + "QikN9lHbn62dDxuu/dNigNmjf/A3cX+vo8aPHTXnRDyDwQALRuqbitdbM6p1LFjG"
+            + "8g84Aabk/jL7zzjJLqPe8pxeK1Pu+P44NzalXAYMsOOsxGuixIrz3Jw8IrpH/mkP"
+            + "tG/iX0NaLZ+Au9eokdLb+6NR/a51r2qL3E0ycFciJ61HzZKKHi6d0VQ7CHozCz+j"
+            + "d5530Mh1qq/ZjYDDjfP+snpyNIZXcLtGR/3HzkBqNgDcvClLx3322AWKDa7pX8DX"
+            + "qiLr8znWhPRpH9kCTnSpRzhYGT25FRcvdj4/q/oUIET/Tp+BWW3BxAc7WgpgqEfn"
+            + "fa0Mv72Zbn91gf4JAwITijME9IlFBGAwH6YmBtWIlnDiRbsq/Pxozuhbnes831il"
+            + "KmdpUKXkiIfHY0MqrEWl3Dfn6PMJGTnhgqXMrDxx3uHrq0Jl2swRnAWIIO8gID7j"
+            + "uPetUqEviPiwAYeJAEwEGBECAAwFAkEcraYFGwwAAAAACgkQ9P5W+Cv/YhShrgCg"
+            + "+JW8m5nF3R/oZGuG87bXQBszkjMAoLhGPncuGKowJXMRVc70/8qwXQJLsAFn");
+    
+    char[]  sec8pass = "qwertyui".toCharArray();
+    
+    byte[] sec9 = Base64.decode(
+              "lQGqBEHCokERBAC9rh5SzC1sX1y1zoFuBB/v0SGhoKMEvLYf8Qv/j4deAMrc"
+            + "w5dxasYoD9oxivIUfTbZKo8cqr+dKLgu8tycigTM5b/T2ms69SUAxSBtj2uR"
+            + "LZrh4vjC/93kF+vzYJ4fNaBs9DGfCnsTouKjXqmfN3SlPMKNcGutO7FaUC3d"
+            + "zcpYfwCg7qyONHvXPhS0Iw4QL3mJ/6wMl0UD/0PaonqW0lfGeSjJSM9Jx5Bt"
+            + "fTSlwl6GmvYmI8HKvOBXAUSTZSbEkMsMVcIgf577iupzgWCgNF6WsNqQpKaq"
+            + "QIq1Kjdd0Y00xU1AKflOkhl6eufTigjviM+RdDlRYsOO5rzgwDTRTu9giErs"
+            + "XIyJAIZIdu2iaBHX1zHTfJ1r7nlAA/9H4T8JIhppUk/fLGsoPNZzypzVip8O"
+            + "mFb9PgvLn5GmuIC2maiocT7ibbPa7XuXTO6+k+323v7PoOUaKD3uD93zHViY"
+            + "Ma4Q5pL5Ajc7isnLXJgJb/hvvB1oo+wSDo9vJX8OCSq1eUPUERs4jm90/oqy"
+            + "3UG2QVqs5gcKKR4o48jTiv4DZQJHTlUBtB1mb28ga2V5IDxmb28ua2V5QGlu"
+            + "dmFsaWQuY29tPoheBBMRAgAeBQJBwqJCAhsDBgsJCAcDAgMVAgMDFgIBAh4B"
+            + "AheAAAoJEOKcXvehtw4ajJMAoK9nLfsrRY6peq56l/KzmjzuaLacAKCXnmiU"
+            + "waI7+uITZ0dihJ3puJgUz50BWARBwqJDEAQA0DPcNIn1BQ4CDEzIiQkegNPY"
+            + "mkYyYWDQjb6QFUXkuk1WEB73TzMoemsA0UKXwNuwrUgVhdpkB1+K0OR/e5ik"
+            + "GhlFdrDCqyT+mw6dRWbJ2i4AmFXZaRKO8AozZeWojsfP1/AMxQoIiBEteMFv"
+            + "iuXnZ3pGxSfZYm2+33IuPAV8KKMAAwUD/0C2xZQXgVWTiVz70HUviOmeTQ+f"
+            + "b1Hj0U9NMXWB383oQRBZCvQDM12cqGsvPZuZZ0fkGehGAIoyXtIjJ9lejzZN"
+            + "1TE9fnXZ9okXI4yCl7XLSE26OAbNsis4EtKTNScNaU9Dk3CS5XD/pkRjrkPN"
+            + "2hdUFtshuGmYkqhb9BIlrwE7/gMDAglbVSwecr9mYJcDYCH62U9TScWDTzsQ"
+            + "NFEfhMez3hGnNHNfHe+7yN3+Q9/LIhbba3IJEN5LsE5BFvudLbArp56EusIn"
+            + "JCxgiEkEGBECAAkFAkHCokMCGwwACgkQ4pxe96G3Dho2UQCeN3VPwx3dROZ+"
+            + "4Od8Qj+cLrBndGEAn0vaQdy6eIGeDw2I9u3Quwy6JnROnQHhBEHCozMRBADH"
+            + "ZBlB6xsAnqFYtYQOHr4pX6Q8TrqXCiHHc/q56G2iGbI9IlbfykQzaPHgWqZw"
+            + "9P0QGgF/QZh8TitiED+imLlGDqj3nhzpazqDh5S6sg6LYkQPqhwG/wT5sZQQ"
+            + "fzdeupxupjI5YN8RdIqkWF+ILOjk0+awZ4z0TSY/f6OSWpOXlwCgjIquR3KR"
+            + "tlCLk+fBlPnOXaOjX+kEAJw7umykNIHNaoY/2sxNhQhjqHVxKyN44y6FCSv9"
+            + "jRyW8Q/Qc8YhqBIHdmlcXoNWkDtlvErjdYMvOKFqKB1e2bGpjvhtIhNVQWdk"
+            + "oHap9ZuM1nV0+fD/7g/NM6D9rOOVCahBG2fEEeIwxa2CQ7zHZYfg9Umn3vbh"
+            + "TYi68R3AmgLOA/wKIVkfFKioI7iX4crQviQHJK3/A90SkrjdMQwLoiUjdgtk"
+            + "s7hJsTP1OPb2RggS1wCsh4sv9nOyDULj0T0ySGv7cpyv5Nq0FY8gw2oogHs5"
+            + "fjUnG4VeYW0zcIzI8KCaJT4UhR9An0A1jF6COrYCcjuzkflFbQLtQb9uNj8a"
+            + "hCpU4/4DAwIUxXlRMYE8uWCranzPo83FnBPRnGJ2aC9SqZWJYVUKIn4Vf2nu"
+            + "pVvCGFja0usl1WfV72hqlNKEONq7lohJBBgRAgAJBQJBwqMzAhsCAAoJEOKc"
+            + "Xvehtw4afisAoME/t8xz/rj/N7QRN9p8Ji8VPGSqAJ9K8eFJ+V0mxR+octJr"
+            + "6neEEX/i1Q==");
+
+    public char[] sec9pass = "foo".toCharArray();
+
+    // version 4 keys with expiry dates
+    byte[] pub10 = Base64.decode(
+          "mQGiBEKqia0RBACc3hkufmscRSC4UvPZqMDsHm4+d/GXIr+3iNMSSEySJu8yk+k0"
+        + "Xs11C/K+n+v1rnn2jGGknv+1lDY6w75TIcTE6o6HGKeIDxsAm8P3MhoGU1GNPamA"
+        + "eTDeNybtrN/g6C65fCY9uI11hsUboYgQZ8ND22PB0VtvdOgq9D85qNUzxwCg1BbJ"
+        + "ycAKd4VqEvQ2Zglp3dCSrFMD/Ambq1kZqYa69sp3b9BPKuAgUgUPoytOArEej3Bk"
+        + "easAgAxNhWJy4GxigES3vk50rVi7w8XBuqbD1mQCzldF0HX0/A7PxLBv6od5uqqF"
+        + "HFxIyxg/KBZLd9ZOrsSaoUWH58jZq98X/sFtJtRi5VuJagMxCIJD4mLgtMv7Unlb"
+        + "/GrsA/9DEnObA/fNTgK70T+ZmPIS5tSt+bio30Aw4YGpPCGqpnm1u73b5kqX3U3B"
+        + "P+vGDvFuqZYpqQA8byAueH0MbaDHI4CFugvShXvgysJxN7ov7/8qsZZUMfK1t2Nr"
+        + "SAsPuKRbcY4gNKXIElKeXbyaET7vX7uAEKuxEwdYGFp/lNTkHLQgdGVzdCBrZXkg"
+        + "KHRlc3QpIDx0ZXN0QHRlc3QudGVzdD6IZAQTEQIAJAUCQqqJrQIbAwUJACTqAAYL"
+        + "CQgHAwIDFQIDAxYCAQIeAQIXgAAKCRDjDROQZRqIzDzLAJ42AeCRIBBjv8r8qw9y"
+        + "laNj2GZ1sACgiWYHVXMA6B1H9I1kS3YsCd3Oq7qwAgAAuM0EQqqJrhADAKWkix8l"
+        + "pJN7MMTXob4xFF1TvGll0UD1bDGOMMbes6aeXSbT9QXee/fH3GnijLY7wB+qTPv9"
+        + "ohubrSpnv3yen3CEBW6Q2YK+NlCskma42Py8YMV2idmYjtJi1ckvHFWt5wADBQL/"
+        + "fkB5Q5xSGgspMaTZmtmX3zG7ZDeZ0avP8e8mRL8UszCTpqs6vMZrXwyQLZPbtMYv"
+        + "PQpuRGEeKj0ysimwYRA5rrLQjnRER3nyuuEUUgc4j+aeRxPf9WVsJ/a1FCHtaAP1"
+        + "iE8EGBECAA8FAkKqia4CGwwFCQAk6gAACgkQ4w0TkGUaiMzdqgCfd66H7DL7kFGd"
+        + "IoS+NIp8JO+noxAAn25si4QAF7og8+4T5YQUuhIhx/NesAIAAA==");
+
+    byte[] sec10 = Base64.decode(
+         "lQHhBEKqia0RBACc3hkufmscRSC4UvPZqMDsHm4+d/GXIr+3iNMSSEySJu8yk+k0"
+       + "Xs11C/K+n+v1rnn2jGGknv+1lDY6w75TIcTE6o6HGKeIDxsAm8P3MhoGU1GNPamA"
+       + "eTDeNybtrN/g6C65fCY9uI11hsUboYgQZ8ND22PB0VtvdOgq9D85qNUzxwCg1BbJ"
+       + "ycAKd4VqEvQ2Zglp3dCSrFMD/Ambq1kZqYa69sp3b9BPKuAgUgUPoytOArEej3Bk"
+       + "easAgAxNhWJy4GxigES3vk50rVi7w8XBuqbD1mQCzldF0HX0/A7PxLBv6od5uqqF"
+       + "HFxIyxg/KBZLd9ZOrsSaoUWH58jZq98X/sFtJtRi5VuJagMxCIJD4mLgtMv7Unlb"
+       + "/GrsA/9DEnObA/fNTgK70T+ZmPIS5tSt+bio30Aw4YGpPCGqpnm1u73b5kqX3U3B"
+       + "P+vGDvFuqZYpqQA8byAueH0MbaDHI4CFugvShXvgysJxN7ov7/8qsZZUMfK1t2Nr"
+       + "SAsPuKRbcY4gNKXIElKeXbyaET7vX7uAEKuxEwdYGFp/lNTkHP4DAwLssmOjVC+d"
+       + "mWB783Lpzjb9evKzsxisTdx8/jHpUSS+r//6/Guyx3aA/zUw5bbftItW57mhuNNb"
+       + "JTu7WrQgdGVzdCBrZXkgKHRlc3QpIDx0ZXN0QHRlc3QudGVzdD6IZAQTEQIAJAUC"
+       + "QqqJrQIbAwUJACTqAAYLCQgHAwIDFQIDAxYCAQIeAQIXgAAKCRDjDROQZRqIzDzL"
+       + "AJ0cYPwKeoSReY14LqJtAjnkX7URHACgsRZWfpbalrSyDnq3TtZeGPUqGX+wAgAA"
+       + "nQEUBEKqia4QAwClpIsfJaSTezDE16G+MRRdU7xpZdFA9WwxjjDG3rOmnl0m0/UF"
+       + "3nv3x9xp4oy2O8Afqkz7/aIbm60qZ798np9whAVukNmCvjZQrJJmuNj8vGDFdonZ"
+       + "mI7SYtXJLxxVrecAAwUC/35AeUOcUhoLKTGk2ZrZl98xu2Q3mdGrz/HvJkS/FLMw"
+       + "k6arOrzGa18MkC2T27TGLz0KbkRhHio9MrIpsGEQOa6y0I50REd58rrhFFIHOI/m"
+       + "nkcT3/VlbCf2tRQh7WgD9f4DAwLssmOjVC+dmWDXVLRopzxbBGOvodp/LZoSDb56"
+       + "gNJjDMJ1aXqWW9qTAg1CFjBq73J3oFpVzInXZ8+Q8inxv7bnWiHbiE8EGBECAA8F"
+       + "AkKqia4CGwwFCQAk6gAACgkQ4w0TkGUaiMzdqgCgl2jw5hfk/JsyjulQqe1Nps1q"
+       + "Lx0AoMdnFMZmTMLHn8scUW2j9XO312tmsAIAAA==");
+
+    public char[] sec10pass = "test".toCharArray();
+   
+    public byte[] subKeyBindingKey = Base64.decode(
+            "mQGiBDWagYwRBAD7UcH4TAIp7tmUoHBNxVxCVz2ZrNo79M6fV63riOiH2uDxfIpr"
+          + "IrL0cM4ehEKoqlhngjDhX60eJrOw1nC5BpYZRnDnyDYT4wTWRguxObzGq9pqA1dM"
+          + "oPTJhkFZVIBgFY99/ULRqaUYIhFGgBtnwS70J8/L/PGVc3DmWRLMkTDjSQCg/5Nh"
+          + "MCjMK++MdYMcMl/ziaKRT6EEAOtw6PnU9afdohbpx9CK4UvCCEagfbnUtkSCQKSk"
+          + "6cUp6VsqyzY0pai/BwJ3h4apFMMMpVrtBAtchVgqo4xTr0Sve2j0k+ase6FSImiB"
+          + "g+AR7hvTUTcBjwtIExBc8TuCTqmn4GG8F7UMdl5Z0AZYj/FfAQYaRVZYP/pRVFNx"
+          + "Lw65BAC/Fi3qgiGCJFvXnHIckTfcAmZnKSEXWY9NJ4YQb4+/nH7Vsw0wR/ZObUHR"
+          + "bWgTc9Vw1uZIMe0XVj6Yk1dhGRehUnrm3mE7UJxu7pgkBCbFECFSlSSqP4MEJwZV"
+          + "09YP/msu50kjoxyoTpt+16uX/8B4at24GF1aTHBxwDLd8X0QWrQsTWVycmlsbCBM"
+          + "eW5jaCBDTEVBUiBzeXN0ZW0gREggPGNsZWFyQG1sLmNvbT6JAEsEEBECAAsFAjWa"
+          + "gYwECwMBAgAKCRDyAGjiP47/XanfAKCs6BPURWVQlGh635VgL+pdkUVNUwCdFcNa"
+          + "1isw+eAcopXPMj6ACOapepu5Ag0ENZqBlBAIAPZCV7cIfwgXcqK61qlC8wXo+VMR"
+          + "OU+28W65Szgg2gGnVqMU6Y9AVfPQB8bLQ6mUrfdMZIZJ+AyDvWXpF9Sh01D49Vlf"
+          + "3HZSTz09jdvOmeFXklnN/biudE/F/Ha8g8VHMGHOfMlm/xX5u/2RXscBqtNbno2g"
+          + "pXI61Brwv0YAWCvl9Ij9WE5J280gtJ3kkQc2azNsOA1FHQ98iLMcfFstjvbzySPA"
+          + "Q/ClWxiNjrtVjLhdONM0/XwXV0OjHRhs3jMhLLUq/zzhsSlAGBGNfISnCnLWhsQD"
+          + "GcgHKXrKlQzZlp+r0ApQmwJG0wg9ZqRdQZ+cfL2JSyIZJrqrol7DVekyCzsAAgIH"
+          + "/RYtVo+HROZ6jrNjrATEwQm1fUQrk6n5+2dniN881lF0CNkB4NkHw1Xxz4Ejnu/0"
+          + "iLg8fkOAsmanOsKpOkRtqUnVpsVL5mLJpFEyCY5jbcfj+KY9/25bs0ga7kLHNZia"
+          + "zbCxJdF+W179z3nudQxRaXG/0XISIH7ziZbSVni69sKc1osk1+OoOMbSuZ86z535"
+          + "Pln4fXclkFE927HxfbWoO+60hkOLKh7x+8fC82b3x9vCETujEaxrscO2xS7/MYXP"
+          + "8t1ffriTDmhuIuQS2q4fLgeWdqrODrMhrD8Dq7e558gzp30ZCqpiS7EmKGczL7B8"
+          + "gXxbBCVSTxYMJheXt2xMXsuJAD8DBRg1moGU8gBo4j+O/10RAgWdAKCPhaFIXuC8"
+          + "/cdiNMxTDw9ug3De5QCfYXmDzRSFUu/nrCi8yz/l09wsnxo=");
+    
+    public byte[] subKeyBindingCheckSum = Base64.decode("3HU+");
+    
+    //
+    // PGP8 with SHA1 checksum.
+    //
+    public byte[] rewrapKey = Base64.decode(
+            "lQOWBEUPOQgBCADdjPTtl8oOwqJFA5WU8p7oDK5KRWfmXeXUZr+ZJipemY5RSvAM"
+          + "rxqsM47LKYbmXOJznXCQ8+PPa+VxXAsI1CXFHIFqrXSwvB/DUmb4Ec9EuvNd18Zl"
+          + "hJAybzmV2KMkaUp9oG/DUvxZJqkpUddNfwqZu0KKKZWF5gwW5Oy05VCpaJxQVXFS"
+          + "whdbRfwEENJiNx4RB3OlWhIjY2p+TgZfgQjiGB9i15R+37sV7TqzBUZF4WWcnIRQ"
+          + "DnpUfxHgxQ0wO/h/aooyRHSpIx5i4oNpMYq9FNIyakEx/Bomdbs5hW9dFxhrE8Es"
+          + "UViAYITgTsyROxmgGatGG09dcmVDJVYF4i7JAAYpAAf/VnVyUDs8HrxYTOIt4rYY"
+          + "jIHToBsV0IiLpA8fEA7k078L1MwSwERVVe6oHVTjeR4A9OxE52Vroh2eOLnF3ftf"
+          + "6QThVVZr+gr5qeG3yvQ36N7PXNEVOlkyBzGmFQNe4oCA+NR2iqnAIspnekVmwJV6"
+          + "xVvPCjWw/A7ZArDARpfthspwNcJAp4SWfoa2eKzvUTznTyqFu2PSS5fwQZUgOB0P"
+          + "Y2FNaKeqV8vEZu4SUWwLOqXBQIZXiaLvdKNgwFvUe3kSHdCNsrVzW7SYxFwaEog2"
+          + "o6YLKPVPqjlGX1cMOponGp+7n9nDYkQjtEsGSSMQkQRDAcBdSVJmLO07kFOQSOhL"
+          + "WQQA49BcgTZyhyH6TnDBMBHsGCYj43FnBigypGT9FrQHoWybfX47yZaZFROAaaMa"
+          + "U6man50YcYZPwzDzXHrK2MoGALY+DzB3mGeXVB45D/KYtlMHPLgntV9T5b14Scbc"
+          + "w1ES2OUtsSIUs0zelkoXqjLuKnSIYK3mMb67Au7AEp6LXM8EAPj2NypvC86VEnn+"
+          + "FH0QHvUwBpmDw0EZe25xQs0brvAG00uIbiZnTH66qsIfRhXV/gbKK9J5DTGIqQ15"
+          + "DuPpz7lcxg/n2+SmjQLNfXCnG8hmtBjhTe+udXAUrmIcfafXyu68SAtebgm1ga56"
+          + "zUfqsgN3FFuMUffLl3myjyGsg5DnA/oCFWL4WCNClOgL6A5VkNIUait8QtSdCACT"
+          + "Y7jdSOguSNXfln0QT5lTv+q1AjU7zjRl/LsFNmIJ5g2qdDyK937FOXM44FEEjZty"
+          + "/4P2dzYpThUI4QUohIj8Qi9f2pZQueC5ztH6rpqANv9geZKcciAeAbZ8Md0K2TEU"
+          + "RD3Lh+RSBzILtBtUZXN0IEtleSA8dGVzdEBleGFtcGxlLmNvbT6JATYEEwECACAF"
+          + "AkUPOQgCGwMGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRDYpknHeQaskD9NB/9W"
+          + "EbFuLaqZAl3yjLU5+vb75BdvcfL1lUs44LZVwobNp3/0XbZdY76xVPNZURtU4u3L"
+          + "sJfGlaF+EqZDE0Mqc+vs5SIb0OnCzNJ00KaUFraUtkByRV32T5ECHK0gMBjCs5RT"
+          + "I0vVv+Qmzl4+X1Y2bJ2mlpBejHIrOzrBD5NTJimTAzyfnNfipmbqL8p/cxXKKzS+"
+          + "OM++ZFNACj6lRM1W9GioXnivBRC88gFSQ4/GXc8yjcrMlKA27JxV+SZ9kRWwKH2f"
+          + "6o6mojUQxnHr+ZFKUpo6ocvTgBDlC57d8IpwJeZ2TvqD6EdA8rZ0YriVjxGMDrX1"
+          + "8esfw+iLchfEwXtBIRwS");
+
+    char[] rewrapPass = "voltage123".toCharArray();
+
+    byte[] pubWithX509 = Base64.decode(
+        "mQENBERabjABCACtmfyo6Nph9MQjv4nmCWjZrRYnhXbivomAdIwYkLZUj1bjqE+j"+
+        "uaLzjZV8xSI59odZvrmOiqlzOc4txitQ1OX7nRgbOJ7qku0dvwjtIn46+HQ+cAFn"+
+        "2mTi81RyXEpO2uiZXfsNTxUtMi+ZuFLufiMc2kdk27GZYWEuasdAPOaPJnA+wW6i"+
+        "ZHlt0NfXIGNz864gRwhD07fmBIr1dMFfATWxCbgMd/rH7Z/j4rvceHD2n9yrhPze"+
+        "YN7W4Nuhsr2w/Ft5Cm9xO7vXT/cpto45uxn8f7jERep6bnUwNOhH8G+6xLQgTLD0"+
+        "qFBGVSIneK3lobs6+xn6VaGN8W0tH3UOaxA1ABEBAAG0D0NOPXFhLWRlZXBzaWdo"+
+        "dIkFDgQQZAIFAQUCRFpuMAUDCWdU0gMF/3gCGwPELGQBAQQwggTkMIIDzKADAgEC"+
+        "AhBVUMV/M6rIiE+IzmnPheQWMA0GCSqGSIb3DQEBBQUAMG4xEzARBgoJkiaJk/Is"+
+        "ZAEZFgNjb20xEjAQBgoJkiaJk/IsZAEZFgJxYTEVMBMGCgmSJomT8ixkARkWBXRt"+
+        "czAxMRUwEwYKCZImiZPyLGQBGRYFV2ViZmUxFTATBgNVBAMTDHFhLWRlZXBzaWdo"+
+        "dDAeFw0wNjA1MDQyMTEyMTZaFw0xMTA1MDQyMTIwMDJaMG4xEzARBgoJkiaJk/Is"+
+        "ZAEZFgNjb20xEjAQBgoJkiaJk/IsZAEZFgJxYTEVMBMGCgmSJomT8ixkARkWBXRt"+
+        "czAxMRUwEwYKCZImiZPyLGQBGRYFV2ViZmUxFTATBgNVBAMTDHFhLWRlZXBzaWdo"+
+        "dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK2Z/Kjo2mH0xCO/ieYJ"+
+        "aNmtFieFduK+iYB0jBiQtlSPVuOoT6O5ovONlXzFIjn2h1m+uY6KqXM5zi3GK1DU"+
+        "5fudGBs4nuqS7R2/CO0ifjr4dD5wAWfaZOLzVHJcSk7a6Jld+w1PFS0yL5m4Uu5+"+
+        "IxzaR2TbsZlhYS5qx0A85o8mcD7BbqJkeW3Q19cgY3PzriBHCEPTt+YEivV0wV8B"+
+        "NbEJuAx3+sftn+Piu9x4cPaf3KuE/N5g3tbg26GyvbD8W3kKb3E7u9dP9ym2jjm7"+
+        "Gfx/uMRF6npudTA06Efwb7rEtCBMsPSoUEZVIid4reWhuzr7GfpVoY3xbS0fdQ5r"+
+        "EDUCAwEAAaOCAXwwggF4MAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0G"+
+        "A1UdDgQWBBSmFTRv5y65DHtTYae48zl0ExNWZzCCASUGA1UdHwSCARwwggEYMIIB"+
+        "FKCCARCgggEMhoHFbGRhcDovLy9DTj1xYS1kZWVwc2lnaHQsQ049cWEtd3VtYW4x"+
+        "LWRjLENOPUNEUCxDTj1QdWJsaWMlMjBLZXklMjBTZXJ2aWNlcyxDTj1TZXJ2aWNl"+
+        "cyxDTj1Db25maWd1cmF0aW9uLERDPVdlYmZlLERDPXRtczAxLERDPXFhLERDPWNv"+
+        "bT9jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0P2Jhc2U/b2JqZWN0Q2xhc3M9Y1JM"+
+        "RGlzdHJpYnV0aW9uUG9pbnSGQmh0dHA6Ly9xYS13dW1hbjEtZGMud2ViZmUudG1z"+
+        "MDEucWEuY29tL0NlcnRFbnJvbGwvcWEtZGVlcHNpZ2h0LmNybDAQBgkrBgEEAYI3"+
+        "FQEEAwIBADANBgkqhkiG9w0BAQUFAAOCAQEAfuZCW3XlB7Eok35zQbvYt9rhAndT"+
+        "DNw3wPNI4ZzD1nXoYWnwhNNvWRpsOt4ExOSNdaHErfgDXAMyyg66Sro0TkAx8eAj"+
+        "fPQsyRAh0nm0glzFmJN6TdOZbj7hqGZjc4opQ6nZo8h/ULnaEwMIUW4gcSkZt0ww"+
+        "CuErl5NUrN3DpkREeCG/fVvQZ8ays3ibQ5ZCZnYBkLYq/i0r3NLW34WfYhjDY48J"+
+        "oQWtvFSAxvRfz2NGmqnrCHPQZxqlfdta97kDa4VQ0zSeBaC70gZkLmD1GJMxWoXW"+
+        "6tmEcgPY5SghInUf+L2u52V55MjyAFzVp7kTK2KY+p7qw35vzckrWkwu8AAAAAAA"+
+        "AQE=");
+
+    private static byte[] secWithPersonalCertificate = Base64.decode(
+        "lQOYBEjGLGsBCACp1I1dZKsK4N/I0/4g02hDVNLdQkDZfefduJgyJUyBGo/I"
+            + "/ZBpc4vT1YwVIdic4ADjtGB4+7WohN4v8siGzwRSeXardSdZVIw2va0JDsQC"
+            + "yeoTnwVkUgn+w/MDgpL0BBhTpr9o3QYoo28/qKMni3eA8JevloZqlAbQ/sYq"
+            + "rToMAqn0EIdeVVh6n2lRQhUJaNkH/kA5qWBpI+eI8ot/Gm9kAy3i4e0Xqr3J"
+            + "Ff1lkGlZuV5H5p/ItZui9BDIRn4IDaeR511NQnKlxFalM/gP9R9yDVI1aXfy"
+            + "STcp3ZcsTOTGNzACtpvMvl6LZyL42DyhlOKlJQJS81wp4dg0LNrhMFOtABEB"
+            + "AAEAB/0QIH5UEg0pTqAG4r/3v1uKmUbKJVJ3KhJB5xeSG3dKWIqy3AaXR5ZN"
+            + "mrJfXK7EfC5ZcSAqx5br1mzVl3PHVBKQVQxvIlmG4r/LKvPVhQYZUFyJWckZ"
+            + "9QMR+EA0Dcran9Ds5fa4hH84jgcwalkj64XWRAKDdVh098g17HDw+IYnQanl"
+            + "7IXbYvh+1Lr2HyPo//vHX8DxXIJBv+E4skvqGoNfCIfwcMeLsrI5EKo+D2pu"
+            + "kAuBYI0VBiZkrJHFXWmQLW71Mc/Bj7wTG8Q1pCpu7YQ7acFSv+/IOCsB9l9S"
+            + "vdB7pNhB3lEjYFGoTgr03VfeixA7/x8uDuSXjnBdTZqmGqkZBADNwCqlzdaQ"
+            + "X6CjS5jc3vzwDSPgM7ovieypEL6NU3QDEUhuP6fVvD2NYOgVnAEbJzgOleZS"
+            + "W2AFXKAf5NDxfqHnBmo/jlYb5yZV5Y+8/poLLj/m8t7sAfAmcZqGXfYMbSbe"
+            + "tr6TGTUXcXgbRyU5oH1e4iq691LOwZ39QjL8lNQQywQA006XYEr/PS9uJkyM"
+            + "Cg+M+nmm40goW4hU/HboFh9Ru6ataHj+CLF42O9sfMAV02UcD3Agj6w4kb5L"
+            + "VswuwfmY+17IryT81d+dSmDLhpo6ufKoAp4qrdP+bzdlbfIim4Rdrw5vF/Yk"
+            + "rC/Nfm3CLJxTimHJhqFx4MG7yEC89lxgdmcD/iJ3m41fwS+bPN2rrCAf7j1u"
+            + "JNr/V/8GAnoXR8VV9150BcOneijftIIYKKyKkV5TGwcTfjaxRKp87LTeC3MV"
+            + "szFDw04MhlIKRA6nBdU0Ay8Yu+EjXHK2VSpLG/Ny+KGuNiFzhqgBxM8KJwYA"
+            + "ISa1UEqWjXoLU3qu1aD7cCvANPVCOASwAYe0GlBHUCBEZXNrdG9wIDxpbmZv"
+            + "QHBncC5jb20+sAMD//+JAW4EEAECAFgFAkjGLGswFIAAAAAAIAAHcHJlZmVy"
+            + "cmVkLWVtYWlsLWVuY29kaW5nQHBncC5jb21wZ3BtaW1lBwsJCAcDAgoCGQEF"
+            + "GwMAAAADFgECBR4BAAAABRUCCAkKAAoJEHHHqp2m1tlWsx8H/icpHl1Nw17A"
+            + "D6MJN6zJm+aGja+5BOFxOsntW+IV6JI+l5WwiIVE8xTDhoXW4zdH3IZTqoyY"
+            + "frtkqLGpvsPtAQmV6eiPgE3+25ahL+MmjXKsceyhbZeCPDtM2M382VCHYCZK"
+            + "DZ4vrHVgK/BpyTeP/mqoWra9+F5xErhody71/cLyIdImLqXgoAny6YywjuAD"
+            + "2TrFnzPEBmZrkISHVEso+V9sge/8HsuDqSI03BAVWnxcg6aipHtxm907sdVo"
+            + "jzl2yFbxCCCaDIKR7XVbmdX7VZgCYDvNSxX3WEOgFq9CYl4ZlXhyik6Vr4XP"
+            + "7EgqadtfwfMcf4XrYoImSQs0gPOd4QqwAWedA5gESMYsawEIALiazFREqBfi"
+            + "WouTjIdLuY09Ks7PCkn0eo/i40/8lEj1R6JKFQ5RlHNnabh+TLvjvb3nOSU0"
+            + "sDg+IKK/JUc8/Fo7TBdZvARX6BmltEGakqToDC3eaF9EQgHLEhyE/4xXiE4H"
+            + "EeIQeCHdC7k0pggEuWUn5lt6oeeiPUWhqdlUOvzjG+jqMPJL0bk9STbImHUR"
+            + "EiugCPTekC0X0Zn0yrwyqlJQMWnh7wbSl/uo4q45K7qOhxcijo+hNNrkRAMi"
+            + "fdNqD4s5qDERqqHdAAgpWqydo7zV5tx0YSz5fjh59Z7FxkUXpcu1WltT6uVn"
+            + "hubiMTWpXzXOQI8wZL2fb12JmRY47BEAEQEAAQAH+wZBeanj4zne+fBHrWAS"
+            + "2vx8LYiRV9EKg8I/PzKBVdGUnUs0vTqtXU1dXGXsAsPtu2r1bFh0TQH06gR1"
+            + "24iq2obgwkr6x54yj+sZlE6SU0SbF/mQc0NCNAXtSKV2hNXvy+7P+sVJR1bn"
+            + "b5ukuvkj1tgEln/0W4r20qJ60F+M5QxXg6kGh8GAlo2tetKEv1NunAyWY6iv"
+            + "FTnSaIJ/YaKQNcudNvOJjeIakkIzfzBL+trUiI5n1LTBB6+u3CF/BdZBTxOy"
+            + "QwjAh6epZr+GnQqeaomFxBc3mU00sjrsB1Loso84UIs6OKfjMkPoZWkQrQQW"
+            + "+xvQ78D33YwqNfXk/5zQAxkEANZxJGNKaAeDpN2GST/tFZg0R5GPC7uWYC7T"
+            + "pG100mir9ugRpdeIFvfAa7IX2jujxo9AJWo/b8hq0q0koUBdNAX3xxUaWy+q"
+            + "KVCRxBifpYVBfEViD3lsbMy+vLYUrXde9087YD0c0/XUrj+oowWJavblmZtS"
+            + "V9OjkQW9zoCigpf5BADcYV+6bkmJtstxJopJG4kD/lr1o35vOEgLkNsMLayc"
+            + "NuzES084qP+8yXPehkzSsDB83kc7rKfQCQMZ54V7KCCz+Rr4wVG7FCrFAw4e"
+            + "4YghfGVU/5whvbJohl/sXXCYGtVljvY/BSQrojRdP+/iZxFbeD4IKiTjV+XL"
+            + "WKSS56Fq2QQAzeoKBJFUq8nqc8/OCmc52WHSOLnB4AuHL5tNfdE9tjqfzZAE"
+            + "tx3QB7YGGP57tPQxPFDFJVRJDqw0YxI2tG9Pum8iriKGjHg+oEfFhxvCmPxf"
+            + "zDKaGibkLeD7I6ATpXq9If+Nqb5QjzPjFbXBIz/q2nGjamZmp4pujKt/aZxF"
+            + "+YRCebABh4kCQQQYAQIBKwUCSMYsbAUbDAAAAMBdIAQZAQgABgUCSMYsawAK"
+            + "CRCrkqZshpdZSNAiB/9+5nAny2O9/lp2K2z5KVXqlNAHUmd4S/dpqtsZCbAo"
+            + "8Lcr/VYayrNojga1U7cyhsvFky3N9wczzPHq3r9Z+R4WnRM1gpRWl+9+xxtd"
+            + "ZxGfGzMRlxX1n5rCqltKKk6IKuBAr2DtTnxThaQiISO2hEw+P1MT2HnSzMXt"
+            + "zse5CZ5OiOd/bm/rdvTRD/JmLqhXmOFaIwzdVP0dR9Ld4Dug2onOlIelIntC"
+            + "cywY6AmnL0DThaTy5J8MiMSPamSmATl4Bicm8YRbHHz58gCYxI5UMLwtwR1+"
+            + "rSEmrB6GwVHZt0/BzOpuGpvFZI5ZmC5yO/waR1hV+VYj025cIz+SNuDPyjy4"
+            + "AAoJEHHHqp2m1tlW/w0H/3w38SkB5n9D9JL3chp+8fex03t7CQowVMdsBYNY"
+            + "qI4QoVQkakkxzCz5eF7rijXt5eC3NE/quWhlMigT8LARiwBROBWgDRFW4WuX"
+            + "6MwYtjKKUkZSkBKxP3lmaqZrJpF6jfhPEN76zr/NxWPC/nHRNldUdqkzSu/r"
+            + "PeJyePMofJevzMkUzw7EVtbtWhZavCz+EZXRTZXub9M4mDMj64BG6JHMbVZI"
+            + "1iDF2yka5RmhXz9tOhYgq80m7UQUb1ttNn86v1zVbe5lmB8NG4Ndv+JaaSuq"
+            + "SBZOYQ0ZxtMAB3vVVLZCWxma1P5HdXloegh+hosqeu/bl0Wh90z5Bspt6eI4"
+            + "imqwAWeVAdgESMYtmwEEAM9ZeMFxor7oSoXnhQAXD9lXLLfBky6IcIWISY4F"
+            + "JWc8sK8+XiVzpOrefKro0QvmEGSYcDFQMHdScBLOTsiVJiqenA7fg1bkBr/M"
+            + "bnD7vTKMJe0DARlU27tE5hsWCDYTluxIFjGcAcecY2UqHkqpctYKY0WY9EIm"
+            + "dBA5TYaw3c0PABEBAAEAA/0Zg6318nC57cWLIp5dZiO/dRhTPZD0hI+BWZrg"
+            + "zJtPT8rXVY+qK3Jwquig8z29/r+nppEE+xQWVWDlv4M28BDJAbGE+qWKAZqT"
+            + "67lyKgc0c50W/lfbGvvs+F7ldCcNpFvlk79GODKxcEeTGDQKb9R6FnHFee/K"
+            + "cZum71O3Ku3vUQIA3B3PNM+tKocIUNDHnInuLyqLORwQBNGfjU/pLMM0MkpP"
+            + "lWeIfgUmn2zL/e0JrRoO0LQqX1LN/TlfcurDM0SEtwIA8Sba9OpDq99Yz360"
+            + "FiePJiGNNlbj9EZsuGJyMVXL1mTLA6WHnz5XZOfYqJXHlmKvaKDbARW4+0U7"
+            + "0/vPdYWSaQIAwYeo2Ce+b7M5ifbGMDWYBisEvGISg5xfvbe6qApmHS4QVQzE"
+            + "Ym81rdJJ8OfvgSbHcgn37S3OBXIQvNdejF4BWqM9sAGHtCBIeW5lay1JbnRy"
+            + "YW5ldCA8aHluZWtAYWxzb2Z0LmN6PrADA///iQDrBBABAgBVBQJIxi2bBQkB"
+            + "mgKAMBSAAAAAACAAB3ByZWZlcnJlZC1lbWFpbC1lbmNvZGluZ0BwZ3AuY29t"
+            + "cGdwbWltZQULBwgJAgIZAQUbAQAAAAUeAQAAAAIVAgAKCRDlTa3BE84gWVKW"
+            + "BACcoCFKvph9r9QiHT1Z3N4wZH36Uxqu/059EFALnBkEdVudX/p6S9mynGRk"
+            + "EfhmWFC1O6dMpnt+ZBEed/4XyFWVSLPwirML+6dxfXogdUsdFF1NCRHc3QGc"
+            + "txnNUT/zcZ9IRIQjUhp6RkIvJPHcyfTXKSbLviI+PxzHU2Padq8pV7ABZ7kA"
+            + "jQRIfg8tAQQAutJR/aRnfZYwlVv+KlUDYjG8YQUfHpTxpnmVu7W6N0tNg/Xr"
+            + "5dg50wq3I4HOamRxUwHpdPkXyNF1szpDSRZmlM+VmiIvJDBnyH5YVlxT6+zO"
+            + "8LUJ2VTbfPxoLFp539SQ0oJOm7IGMAGO7c0n/QV0N3hKUfWgCyJ+sENDa0Ft"
+            + "JycAEQEAAbABj4kEzQQYAQIENwUCSMYtnAUJAeEzgMLFFAAAAAAAFwNleDUw"
+            + "OWNlcnRpZmljYXRlQHBncC5jb20wggNhMIICyqADAgECAgkA1AoCoRKJCgsw"
+            + "DQYJKoZIhvcNAQEFBQAwgakxCzAJBgNVBAYTAkNaMRcwFQYDVQQIEw5DemVj"
+            + "aCBSZXB1YmxpYzESMBAGA1UEChQJQSYmTCBzb2Z0MSAwHgYDVQQLExdJbnRl"
+            + "cm5hbCBEZXZlbG9wbWVudCBDQTEqMCgGA1UEAxQhQSYmTCBzb2Z0IEludGVy"
+            + "bmFsIERldmVsb3BtZW50IENBMR8wHQYJKoZIhvcNAQkBFhBrYWRsZWNAYWxz"
+            + "b2Z0LmN6MB4XDTA4MDcxNjE1MDkzM1oXDTA5MDcxNjE1MDkzM1owaTELMAkG"
+            + "A1UEBhMCQ1oxFzAVBgNVBAgTDkN6ZWNoIFJlcHVibGljMRIwEAYDVQQKFAlB"
+            + "JiZMIHNvZnQxFDASBgNVBAsTC0RldmVsb3BtZW50MRcwFQYDVQQDEw5IeW5l"
+            + "ay1JbnRyYW5ldDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAutJR/aRn"
+            + "fZYwlVv+KlUDYjG8YQUfHpTxpnmVu7W6N0tNg/Xr5dg50wq3I4HOamRxUwHp"
+            + "dPkXyNF1szpDSRZmlM+VmiIvJDBnyH5YVlxT6+zO8LUJ2VTbfPxoLFp539SQ"
+            + "0oJOm7IGMAGO7c0n/QV0N3hKUfWgCyJ+sENDa0FtJycCAwEAAaOBzzCBzDAJ"
+            + "BgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBD"
+            + "ZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUNaw7A6r10PtYZzAvr9CrSKeRYJgwHwYD"
+            + "VR0jBBgwFoAUmqSRM8rN3+T1+tkGiqef8S5suYgwGgYDVR0RBBMwEYEPaHlu"
+            + "ZWtAYWxzb2Z0LmN6MCgGA1UdHwQhMB8wHaAboBmGF2h0dHA6Ly9wZXRyazIv"
+            + "Y2EvY2EuY3JsMAsGA1UdDwQEAwIF4DANBgkqhkiG9w0BAQUFAAOBgQCUdOWd"
+            + "7mBLWj1/GSiYgfwgdTrgk/VZOJvMKBiiFyy1iFEzldz6Xx+mAexnFJKfZXZb"
+            + "EMEGWHfWPmgJzAtuTT0Jz6tUwDmeLH3MP4m8uOZtmyUJ2aq41kciV3rGxF0G"
+            + "BVlZ/bWTaOzHdm6cjylt6xxLt6MJzpPBA/9ZfybSBh1DaAUbDgAAAJ0gBBkB"
+            + "AgAGBQJIxi2bAAoJEAdYkEWLb2R2fJED/RK+JErZ98uGo3Z81cHkdP3rk8is"
+            + "DUL/PR3odBPFH2SIA5wrzklteLK/ZXmBUzcvxqHEgI1F7goXbsBgeTuGgZdx"
+            + "pINErxkNpcMl9FTldWKGiapKrhkZ+G8knDizF/Y7Lg6uGd2nKVxzutLXdHJZ"
+            + "pU89Q5nzq6aJFAZo5TBIcchQAAoJEOVNrcETziBZXvQD/1mvFqBfWqwXxoj3"
+            + "8fHUuFrE2pcp32y3ciO2i+uNVEkNDoaVVNw5eHQaXXWpllI/Pe6LnBl4vkyc"
+            + "n3pjONa4PKrePkEsCUhRbIySqXIHuNwZumDOlKzZHDpCUw72LaC6S6zwuoEf"
+            + "ucOcxTeGIUViANWXyTIKkHfo7HfigixJIL8nsAFn");
+
+    private static final byte[] umlautKeySig = Base64.decode(
+        "mI0ETdvOgQEEALoI2a39TRk1HReEB6DP9Bu3ShZUce+/Oeg9RIL9aUFuCsNdhu02" +
+        "REEHjO29Jz8daPgrnJDfFepNLD6iKKru2m9P30qnhsHMIAshO2Ozfh6wKwuHRqR3" +
+        "L4gBDu7cCB6SLwPoD8AYG0yQSM+Do10Td87RlStxCgxpMK6R3TsRkxcFABEBAAG0" +
+        "OlVNTEFVVFNUQVJUOsOEw6TDlsO2w5zDvMOfOlVNTEFURU5ERSA8YXNkbGFrc2Rs" +
+        "QGFrc2RqLmNvbT6IuAQTAQIAIgUCTdvOgQIbAwYLCQgHAwIGFQgCCQoLBBYCAwEC" +
+        "HgECF4AACgkQP8kDwm8AOFiArAP/ZXrlZJB1jFEjyBb04ckpE6F/aJuSYIXf0Yx5" +
+        "T2eS+lA69vYuqKRC1qNROBrAn/WGNOQBFNEgGoy3F3gV5NgpIphnyIEZdZWGY2rv" +
+        "yjunKWlioZjWc/xbSbvpvJ3Q8RyfDXBOkDEB6uF1ksimw2eJSOUTkF9AQfS5f4rT" +
+        "5gs013G4jQRN286BAQQApVbjd8UhsQLB4TpeKn9+dDXAfikGgxDOb19XisjRiWxA" +
+        "+bKFxu5tRt6fxXl6BGSGT7DhoVbNkcJGVQFYcbR31UGKCVYcWSL3yfz+PiVuf1UB" +
+        "Rp44cXxxqxrLqKp1rk3dGvV4Ayy8lkk3ncDGPez6lIKvj3832yVtAzUOX1QOg9EA" +
+        "EQEAAYifBBgBAgAJBQJN286BAhsMAAoJED/JA8JvADhYQ80D/R3TX0FBMHs/xqEh" +
+        "tiS86XP/8pW6eMm2eaAYINxoDY3jmDMv2HFQ+YgrYXgqGr6eVGqDMNPj4W8VBoOt" +
+        "iYW7+SWY76AAl+gmWIMm2jbN8bZXFk4jmIxpycHCrtoXX8rUk/0+se8NvbmAdMGK" +
+        "POOoD7oxdRmJSU5hSspOCHrCwCa3");
+
+    public void test1()
+        throws Exception
+    {
+        PGPPublicKeyRingCollection    pubRings = new PGPPublicKeyRingCollection(pub1);
+
+        int                                        count = 0;
+
+        Iterator    rIt = pubRings.getKeyRings();
+        
+        while (rIt.hasNext())
+        {
+            PGPPublicKeyRing                    pgpPub = (PGPPublicKeyRing)rIt.next();
+
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpPub.getEncoded();
+            
+            pgpPub = new PGPPublicKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            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, new BcKeyFingerprintCalculator());
+            
+            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, new BcKeyFingerprintCalculator());
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings");
+        }
+        
+        //
+        // exact match
+        //
+        rIt = secretRings.getKeyRings("test (Test key) <test@ubicall.com>");
+        count = 0;
+        while (rIt.hasNext())
+        {
+            count++;
+            rIt.next();
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings on exact match");
+        }
+        
+        //
+        // partial match 1 expected
+        //
+        rIt = secretRings.getKeyRings("test", true);
+        count = 0;
+        while (rIt.hasNext())
+        {
+            count++;
+            rIt.next();
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings on partial match 1");
+        }
+        
+        //
+        // exact match 0 expected
+        //
+        rIt = secretRings.getKeyRings("test", false);
+        count = 0;
+        while (rIt.hasNext())
+        {
+            count++;
+            rIt.next();
+        }
+        
+        if (count != 0)
+        {
+            fail("wrong number of secret keyrings on partial match 0");
+        }
+
+        //
+        // case-insensitive partial match
+        //
+        rIt = secretRings.getKeyRings("TEST@ubicall.com", true, true);
+        count = 0;
+        while (rIt.hasNext())
+        {
+            count++;
+            rIt.next();
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings on case-insensitive partial match");
+        }
+    }
+    
+    public void test2()
+        throws Exception
+    {
+        PGPPublicKeyRingCollection    pubRings = new PGPPublicKeyRingCollection(pub2);
+
+        int                            count = 0;
+
+        byte[]    encRing = pubRings.getEncoded();
+
+        pubRings = new PGPPublicKeyRingCollection(encRing);
+        
+        Iterator    rIt = pubRings.getKeyRings();
+        
+        while (rIt.hasNext())
+        {
+            PGPPublicKeyRing        pgpPub = (PGPPublicKeyRing)rIt.next();
+            
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpPub.getEncoded();
+            
+            pgpPub = new PGPPublicKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                PGPPublicKey    pk = (PGPPublicKey)it.next();
+                
+                byte[] pkBytes = pk.getEncoded();
+                
+                PGPPublicKeyRing  pkR = new PGPPublicKeyRing(pkBytes, new BcKeyFingerprintCalculator());
+                
+                keyCount++;
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of public keys");
+            }
+        }
+        
+        if (count != 2)
+        {
+            fail("wrong number of public keyrings");
+        }
+        
+        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec2);
+
+        rIt = secretRings.getKeyRings();
+        count = 0;
+        
+        encRing = secretRings.getEncoded();
+        
+        secretRings = new PGPSecretKeyRingCollection(encRing);
+        
+        while (rIt.hasNext())
+        {
+            PGPSecretKeyRing                    pgpSec = (PGPSecretKeyRing)rIt.next();
+    
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpSec.getEncoded();
+            
+            pgpSec = new PGPSecretKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpSec.getSecretKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPSecretKey    k = (PGPSecretKey)it.next();
+                PGPPublicKey    pk = k.getPublicKey();
+
+                if (pk.getKeyID() == -1413891222336124627L)
+                {
+                    int         sCount = 0;
+                    Iterator    sIt = pk.getSignaturesOfType(PGPSignature.SUBKEY_BINDING);
+                    while (sIt.hasNext())
+                    {
+                        int type = ((PGPSignature)sIt.next()).getSignatureType();
+                        if (type != PGPSignature.SUBKEY_BINDING)
+                        {
+                            fail("failed to return correct signature type");
+                        }
+                        sCount++;
+                    }
+                    
+                    if (sCount != 1)
+                    {
+                        fail("failed to find binding signature");
+                    }
+                }
+                
+                pk.getSignatures();
+                
+                if (k.getKeyID() == -4049084404703773049L
+                     || k.getKeyID() == -1413891222336124627L)
+                {
+                    k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec2pass1));
+                }
+                else if (k.getKeyID() == -6498553574938125416L
+                    || k.getKeyID() == 59034765524361024L)
+                {
+                    k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec2pass2));
+                }
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 2)
+        {
+            fail("wrong number of secret keyrings");
+        }
+    }
+    
+    public void test3()
+        throws Exception
+    {
+        PGPPublicKeyRingCollection    pubRings = new PGPPublicKeyRingCollection(pub3);
+
+        int                                        count = 0;
+
+        byte[]    encRing = pubRings.getEncoded();
+
+        pubRings = new PGPPublicKeyRingCollection(encRing);
+        
+        Iterator    rIt = pubRings.getKeyRings();
+        
+        while (rIt.hasNext())
+        {
+            PGPPublicKeyRing                    pgpPub = (PGPPublicKeyRing)rIt.next();
+            
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpPub.getEncoded();
+            
+            pgpPub = new PGPPublicKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPPublicKey pubK = (PGPPublicKey)it.next();
+                
+                pubK.getSignatures();
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of public keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of public keyrings");
+        }
+        
+        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec3);
+
+        rIt = secretRings.getKeyRings();
+        count = 0;
+        
+        encRing = secretRings.getEncoded();
+        
+        secretRings = new PGPSecretKeyRingCollection(encRing);
+        
+        while (rIt.hasNext())
+        {
+            PGPSecretKeyRing                    pgpSec = (PGPSecretKeyRing)rIt.next();
+    
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpSec.getEncoded();
+            
+            pgpSec = new PGPSecretKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpSec.getSecretKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPSecretKey    k = (PGPSecretKey)it.next();
+
+                k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec3pass1));
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings");
+        }
+    }
+    
+    public void test4()
+        throws Exception
+    {
+        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec4);
+
+        Iterator    rIt = secretRings.getKeyRings();
+        int            count = 0;
+        
+        byte[]    encRing = secretRings.getEncoded();
+        
+        secretRings = new PGPSecretKeyRingCollection(encRing);
+        
+        while (rIt.hasNext())
+        {
+            PGPSecretKeyRing                    pgpSec = (PGPSecretKeyRing)rIt.next();
+    
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpSec.getEncoded();
+            
+            pgpSec = new PGPSecretKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpSec.getSecretKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPSecretKey    k = (PGPSecretKey)it.next();
+
+                k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec3pass1));
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings");
+        }
+    }
+
+    public void test5()
+        throws Exception
+    {
+        PGPPublicKeyRingCollection    pubRings = new PGPPublicKeyRingCollection(pub5);
+
+        int                           count = 0;
+
+        byte[]    encRing = pubRings.getEncoded();
+
+        pubRings = new PGPPublicKeyRingCollection(encRing);
+        
+        Iterator    rIt = pubRings.getKeyRings();
+        
+        while (rIt.hasNext())
+        {
+            PGPPublicKeyRing                    pgpPub = (PGPPublicKeyRing)rIt.next();
+            
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpPub.getEncoded();
+            
+            pgpPub = new PGPPublicKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                it.next();
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of public keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of public keyrings");
+        }
+
+        if (noIDEA())
+        {
+            return;
+        }
+
+        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec5);
+
+        rIt = secretRings.getKeyRings();
+        count = 0;
+        
+        encRing = secretRings.getEncoded();
+        
+        secretRings = new PGPSecretKeyRingCollection(encRing);
+        
+        while (rIt.hasNext())
+        {
+            PGPSecretKeyRing                    pgpSec = (PGPSecretKeyRing)rIt.next();
+    
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpSec.getEncoded();
+            
+            pgpSec = new PGPSecretKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpSec.getSecretKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPSecretKey    k = (PGPSecretKey)it.next();
+
+                k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec5pass1));
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings");
+        }
+    }
+
+    private boolean noIDEA()
+    {
+        return true;
+    }
+
+    public void test6()
+        throws Exception
+    {
+        PGPPublicKeyRingCollection  pubRings = new PGPPublicKeyRingCollection(pub6);
+        Iterator                    rIt = pubRings.getKeyRings();
+
+        while (rIt.hasNext())
+        {
+            PGPPublicKeyRing    pgpPub = (PGPPublicKeyRing)rIt.next();
+            Iterator            it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                PGPPublicKey    k = (PGPPublicKey)it.next();
+
+                if (k.getKeyID() == 0x5ce086b5b5a18ff4L)
+                {
+                    int             count = 0;
+                    Iterator        sIt = k.getSignaturesOfType(PGPSignature.SUBKEY_REVOCATION);
+                    while (sIt.hasNext())
+                    {
+                        PGPSignature sig = (PGPSignature)sIt.next();
+                        count++;
+                    }
+                    
+                    if (count != 1)
+                    {
+                        fail("wrong number of revocations in test6.");
+                    }
+                }
+            }
+        }
+        
+        byte[]    encRing = pubRings.getEncoded();
+    }
+
+    public void test7()
+        throws Exception
+    {
+        PGPPublicKeyRing    pgpPub = new PGPPublicKeyRing(pub7, new BcKeyFingerprintCalculator());
+        Iterator            it = pgpPub.getPublicKeys();
+        PGPPublicKey        masterKey = null;
+
+        while (it.hasNext())
+        {
+            PGPPublicKey    k = (PGPPublicKey)it.next();
+
+            if (k.isMasterKey())
+            {
+                masterKey = k;
+                continue;
+            }
+            
+            int             count = 0;
+            PGPSignature    sig = null;
+            Iterator        sIt = k.getSignaturesOfType(PGPSignature.SUBKEY_REVOCATION);
+
+            while (sIt.hasNext())
+            {
+                sig = (PGPSignature)sIt.next();
+                count++;
+            }
+                
+            if (count != 1)
+            {
+                fail("wrong number of revocations in test7.");
+            }
+
+            sig.init(new BcPGPContentVerifierBuilderProvider(), masterKey);
+                                                                            
+            if (!sig.verifyCertification(k))
+            {
+                fail("failed to verify revocation certification");
+            }
+        }
+    }
+
+    public void test8()
+        throws Exception
+    {
+        PGPPublicKeyRingCollection    pubRings = new PGPPublicKeyRingCollection(pub8);
+
+        int                           count = 0;
+
+        byte[]    encRing = pubRings.getEncoded();
+
+        pubRings = new PGPPublicKeyRingCollection(encRing);
+        
+        Iterator    rIt = pubRings.getKeyRings();
+        
+        while (rIt.hasNext())
+        {
+            PGPPublicKeyRing          pgpPub = (PGPPublicKeyRing)rIt.next();
+            
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpPub.getEncoded();
+            
+            pgpPub = new PGPPublicKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpPub.getPublicKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                it.next();
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of public keys");
+            }
+        }
+        
+        if (count != 2)
+        {
+            fail("wrong number of public keyrings");
+        }
+        
+        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec8);
+
+        rIt = secretRings.getKeyRings();
+        count = 0;
+        
+        encRing = secretRings.getEncoded();
+        
+        secretRings = new PGPSecretKeyRingCollection(encRing);
+        
+        while (rIt.hasNext())
+        {
+            PGPSecretKeyRing         pgpSec = (PGPSecretKeyRing)rIt.next();
+    
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpSec.getEncoded();
+            
+            pgpSec = new PGPSecretKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpSec.getSecretKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPSecretKey    k = (PGPSecretKey)it.next();
+
+                k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec8pass));
+            }
+            
+            if (keyCount != 2)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings");
+        }
+    }
+    
+    public void test9()
+        throws Exception
+    { 
+        PGPSecretKeyRingCollection    secretRings = new PGPSecretKeyRingCollection(sec9);
+
+        Iterator    rIt = secretRings.getKeyRings();
+        int         count = 0;
+        
+        byte[] encRing = secretRings.getEncoded();
+        
+        secretRings = new PGPSecretKeyRingCollection(encRing);
+        
+        while (rIt.hasNext())
+        {
+            PGPSecretKeyRing         pgpSec = (PGPSecretKeyRing)rIt.next();
+    
+            count++;
+            
+            int    keyCount = 0;
+            
+            byte[]    bytes = pgpSec.getEncoded();
+            
+            pgpSec = new PGPSecretKeyRing(bytes, new BcKeyFingerprintCalculator());
+            
+            Iterator    it = pgpSec.getSecretKeys();
+            while (it.hasNext())
+            {
+                keyCount++;
+
+                PGPSecretKey    k = (PGPSecretKey)it.next();
+
+                PGPPrivateKey   pKey = k.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(sec9pass));
+                if (keyCount == 1 && pKey != null)
+                {
+                    fail("primary secret key found, null expected");
+                }
+            }
+            
+            if (keyCount != 3)
+            {
+                fail("wrong number of secret keys");
+            }
+        }
+        
+        if (count != 1)
+        {
+            fail("wrong number of secret keyrings");
+        }
+    }
+    
+    public void test10()
+        throws Exception
+    { 
+        PGPSecretKeyRing    secretRing = new PGPSecretKeyRing(sec10, new BcKeyFingerprintCalculator());
+        Iterator            secretKeys = secretRing.getSecretKeys();
+        
+        while (secretKeys.hasNext())
+        {
+            PGPPublicKey pubKey = ((PGPSecretKey)secretKeys.next()).getPublicKey();
+            
+            if (pubKey.getValidDays() != 28)
+            {
+                fail("days wrong on secret key ring");
+            }
+            
+            if (pubKey.getValidSeconds() != 28 * 24 * 60 * 60)
+            {
+                fail("seconds wrong on secret key ring");
+            }
+        }
+        
+        PGPPublicKeyRing    publicRing = new PGPPublicKeyRing(pub10, new BcKeyFingerprintCalculator());
+        Iterator            publicKeys = publicRing.getPublicKeys();
+        
+        while (publicKeys.hasNext())
+        {
+            PGPPublicKey pubKey = (PGPPublicKey)publicKeys.next();
+
+            if (pubKey.getValidDays() != 28)
+            {
+                fail("days wrong on public key ring");
+            }
+            
+            if (pubKey.getValidSeconds() != 28 * 24 * 60 * 60)
+            {
+                fail("seconds wrong on public key ring");
+            }
+        }
+    }
+
+    public void generateTest()
+        throws Exception
+    {
+        char[]              passPhrase = "hello".toCharArray();
+        DSAParametersGenerator  dsaPGen = new DSAParametersGenerator();
+
+        dsaPGen.init(512, 10, new SecureRandom());
+
+        DSAKeyPairGenerator    dsaKpg = new DSAKeyPairGenerator();
+    
+        dsaKpg.init(new DSAKeyGenerationParameters(new SecureRandom(), dsaPGen.generateParameters()));
+    
+        //
+        // this takes a while as the key generator has to generate some DSA params
+        // before it generates the key.
+        //
+        AsymmetricCipherKeyPair  dsaKp = dsaKpg.generateKeyPair();
+    
+        ElGamalKeyPairGenerator elgKpg = new ElGamalKeyPairGenerator();
+        BigInteger             g = new BigInteger("153d5d6172adb43045b68ae8e1de1070b6137005686d29d3d73a7749199681ee5b212c9b96bfdcfa5b20cd5e3fd2044895d609cf9b410b7a0f12ca1cb9a428cc", 16);
+        BigInteger             p = new BigInteger("9494fec095f3b85ee286542b3836fc81a5dd0a0349b4c239dd38744d488cf8e31db8bcb7d33b41abb9e5a33cca9144b1cef332c94bf0573bf047a3aca98cdf3b", 16);
+        
+        ElGamalParameters         elParams = new ElGamalParameters(p, g);
+        
+        elgKpg.init(new ElGamalKeyGenerationParameters(new SecureRandom(), elParams));
+    
+        //
+        // this is quicker because we are using pregenerated parameters.
+        //
+        AsymmetricCipherKeyPair           elgKp = elgKpg.generateKeyPair();
+        PGPKeyPair        dsaKeyPair = new BcPGPKeyPair(PGPPublicKey.DSA, dsaKp, new Date());
+        PGPKeyPair        elgKeyPair = new BcPGPKeyPair(PGPPublicKey.ELGAMAL_ENCRYPT, elgKp, new Date());
+    
+        PGPKeyRingGenerator    keyRingGen = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION, dsaKeyPair,
+                "test", null, null, null, new BcPGPContentSignerBuilder(PGPPublicKey.DSA, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256).build(passPhrase));
+    
+        keyRingGen.addSubKey(elgKeyPair);
+    
+        PGPSecretKeyRing       keyRing = keyRingGen.generateSecretKeyRing();
+        
+        keyRing.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase));
+        
+        PGPPublicKeyRing        pubRing = keyRingGen.generatePublicKeyRing();
+        
+        PGPPublicKey            vKey = null;
+        PGPPublicKey            sKey = null;
+        
+        Iterator                    it = pubRing.getPublicKeys();
+        while (it.hasNext())
+        {
+            PGPPublicKey    pk = (PGPPublicKey)it.next();
+            if (pk.isMasterKey())
+            {
+                vKey = pk;
+            }
+            else
+            {
+                sKey = pk;
+            }
+        }
+        
+        Iterator    sIt = sKey.getSignatures();
+        while (sIt.hasNext())
+        {
+            PGPSignature    sig = (PGPSignature)sIt.next();
+            
+            if (sig.getKeyID() == vKey.getKeyID()
+                && sig.getSignatureType() == PGPSignature.SUBKEY_BINDING)
+            {
+                sig.init(new BcPGPContentVerifierBuilderProvider(), vKey);
+
+                if (!sig.verifyCertification(vKey, sKey))
+                {
+                    fail("failed to verify sub-key signature.");
+                }
+            }
+        }
+    }
+
+    private void insertMasterTest()
+        throws Exception
+    {
+        char[]              passPhrase = "hello".toCharArray();
+        RSAKeyPairGenerator    rsaKpg = new RSAKeyPairGenerator();
+
+        rsaKpg.init(new RSAKeyGenerationParameters(BigInteger.valueOf(0x11), new SecureRandom(), 512, 25));
+
+        //
+        // this is quicker because we are using pregenerated parameters.
+        //
+        AsymmetricCipherKeyPair           rsaKp = rsaKpg.generateKeyPair();
+        PGPKeyPair        rsaKeyPair1 = new BcPGPKeyPair(PGPPublicKey.RSA_GENERAL, rsaKp, new Date());
+                          rsaKp = rsaKpg.generateKeyPair();
+        PGPKeyPair        rsaKeyPair2 = new BcPGPKeyPair(PGPPublicKey.RSA_GENERAL, rsaKp, new Date());
+        PGPDigestCalculator chkSumCalc = new BcPGPDigestCalculatorProvider().get(HashAlgorithmTags.SHA1);
+
+        PGPKeyRingGenerator    keyRingGen = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION, rsaKeyPair1,
+                "test", chkSumCalc, null, null, new BcPGPContentSignerBuilder(PGPPublicKey.RSA_GENERAL, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256).build(passPhrase));
+        PGPSecretKeyRing       secRing1 = keyRingGen.generateSecretKeyRing();
+        PGPPublicKeyRing       pubRing1 = keyRingGen.generatePublicKeyRing();
+        keyRingGen = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION, rsaKeyPair2,
+                "test", chkSumCalc, null, null, new BcPGPContentSignerBuilder(PGPPublicKey.RSA_GENERAL, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256).build(passPhrase));
+        PGPSecretKeyRing       secRing2 = keyRingGen.generateSecretKeyRing();
+        PGPPublicKeyRing       pubRing2 = keyRingGen.generatePublicKeyRing();
+
+        try
+        {
+            PGPPublicKeyRing.insertPublicKey(pubRing1, pubRing2.getPublicKey());
+            fail("adding second master key (public) should throw an IllegalArgumentException");
+        }
+        catch (IllegalArgumentException e)
+        {
+            if (!e.getMessage().equals("cannot add a master key to a ring that already has one"))
+            {
+                fail("wrong message in public test");
+            }
+        }
+
+        try
+        {
+            PGPSecretKeyRing.insertSecretKey(secRing1, secRing2.getSecretKey());
+            fail("adding second master key (secret) should throw an IllegalArgumentException");
+        }
+        catch (IllegalArgumentException e)
+        {
+            if (!e.getMessage().equals("cannot add a master key to a ring that already has one"))
+            {
+                fail("wrong message in secret test");
+            }
+        }
+    }
+
+    public void generateSha1Test()
+        throws Exception
+    {
+        char[]              passPhrase = "hello".toCharArray();
+        DSAParametersGenerator  dsaPGen = new DSAParametersGenerator();
+
+        dsaPGen.init(512, 10, new SecureRandom());
+
+        DSAKeyPairGenerator    dsaKpg = new DSAKeyPairGenerator();
+
+        dsaKpg.init(new DSAKeyGenerationParameters(new SecureRandom(), dsaPGen.generateParameters()));
+
+        //
+        // this takes a while as the key generator has to generate some DSA params
+        // before it generates the key.
+        //
+        AsymmetricCipherKeyPair dsaKp = dsaKpg.generateKeyPair();
+    
+        ElGamalKeyPairGenerator    elgKpg = new ElGamalKeyPairGenerator();
+        BigInteger             g = new BigInteger("153d5d6172adb43045b68ae8e1de1070b6137005686d29d3d73a7749199681ee5b212c9b96bfdcfa5b20cd5e3fd2044895d609cf9b410b7a0f12ca1cb9a428cc", 16);
+        BigInteger             p = new BigInteger("9494fec095f3b85ee286542b3836fc81a5dd0a0349b4c239dd38744d488cf8e31db8bcb7d33b41abb9e5a33cca9144b1cef332c94bf0573bf047a3aca98cdf3b", 16);
+        
+        ElGamalParameters         elParams = new ElGamalParameters(p, g);
+        
+        elgKpg.init(new ElGamalKeyGenerationParameters(new SecureRandom(), elParams));
+    
+        //
+        // this is quicker because we are using pregenerated parameters.
+        //
+        AsymmetricCipherKeyPair                   elgKp = elgKpg.generateKeyPair();
+        PGPKeyPair        dsaKeyPair = new BcPGPKeyPair(PGPPublicKey.DSA, dsaKp, new Date());
+        PGPKeyPair        elgKeyPair = new BcPGPKeyPair(PGPPublicKey.ELGAMAL_ENCRYPT, elgKp, new Date());
+        PGPDigestCalculator chkSumCalc = new BcPGPDigestCalculatorProvider().get(HashAlgorithmTags.SHA1);
+
+        PGPKeyRingGenerator    keyRingGen = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION, dsaKeyPair,
+                "test", chkSumCalc, null, null, new BcPGPContentSignerBuilder(PGPPublicKey.DSA, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256).build(passPhrase));
+        keyRingGen.addSubKey(elgKeyPair);
+    
+        PGPSecretKeyRing       keyRing = keyRingGen.generateSecretKeyRing();
+        
+        keyRing.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase));
+        
+        PGPPublicKeyRing        pubRing = keyRingGen.generatePublicKeyRing();
+        
+        PGPPublicKey            vKey = null;
+        PGPPublicKey            sKey = null;
+        
+        Iterator                    it = pubRing.getPublicKeys();
+        while (it.hasNext())
+        {
+            PGPPublicKey    pk = (PGPPublicKey)it.next();
+            if (pk.isMasterKey())
+            {
+                vKey = pk;
+            }
+            else
+            {
+                sKey = pk;
+            }
+        }
+        
+        Iterator    sIt = sKey.getSignatures();
+        while (sIt.hasNext())
+        {
+            PGPSignature    sig = (PGPSignature)sIt.next();
+            
+            if (sig.getKeyID() == vKey.getKeyID()
+                && sig.getSignatureType() == PGPSignature.SUBKEY_BINDING)
+            {
+                sig.init(new BcPGPContentVerifierBuilderProvider(), vKey);
+    
+                if (!sig.verifyCertification(vKey, sKey))
+                {
+                    fail("failed to verify sub-key signature.");
+                }
+            }
+        }
+    }
+    
+    private void test11()
+        throws Exception
+    {
+        PGPPublicKeyRing pubRing = new PGPPublicKeyRing(subKeyBindingKey, new BcKeyFingerprintCalculator());
+        Iterator         it = pubRing.getPublicKeys();
+        
+        while (it.hasNext())
+        {
+            PGPPublicKey key = (PGPPublicKey)it.next();
+            
+            if (key.getValidSeconds() != 0)
+            {
+                fail("expiration time non-zero");
+            }
+        }
+    }
+    
+    private void rewrapTest()
+        throws Exception
+    {
+        SecureRandom rand = new SecureRandom();
+
+        // Read the secret key rings
+        PGPSecretKeyRingCollection privRings = new PGPSecretKeyRingCollection(
+                                                         new ByteArrayInputStream(rewrapKey)); 
+
+        Iterator rIt = privRings.getKeyRings();
+
+        if (rIt.hasNext())
+        {
+            PGPSecretKeyRing pgpPriv = (PGPSecretKeyRing)rIt.next();
+
+            Iterator it = pgpPriv.getSecretKeys();
+
+            while (it.hasNext())
+            {
+                PGPSecretKey pgpKey = (PGPSecretKey)it.next();
+
+                // re-encrypt the key with an empty password
+                pgpPriv = PGPSecretKeyRing.removeSecretKey(pgpPriv, pgpKey);
+                pgpKey = PGPSecretKey.copyWithNewPassword(
+                                    pgpKey,
+                                    new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(rewrapPass),
+                                    null);
+                pgpPriv = PGPSecretKeyRing.insertSecretKey(pgpPriv, pgpKey);
+            
+                // this should succeed
+                PGPPrivateKey privTmp = pgpKey.extractPrivateKey(null);
+            }
+        }
+    }
+
+    private void testPublicKeyRingWithX509()
+        throws Exception
+    {
+        checkPublicKeyRingWithX509(pubWithX509);
+
+        PGPPublicKeyRing pubRing = new PGPPublicKeyRing(pubWithX509, new BcKeyFingerprintCalculator());
+
+        checkPublicKeyRingWithX509(pubRing.getEncoded());
+    }
+
+    private void testSecretKeyRingWithPersonalCertificate()
+        throws Exception
+    {
+        checkSecretKeyRingWithPersonalCertificate(secWithPersonalCertificate);
+        PGPSecretKeyRingCollection secRing = new PGPSecretKeyRingCollection(secWithPersonalCertificate);
+        checkSecretKeyRingWithPersonalCertificate(secRing.getEncoded());
+    }
+
+    private void testUmlaut()
+        throws Exception
+    {
+        PGPPublicKeyRing pubRing = new PGPPublicKeyRing(umlautKeySig, new BcKeyFingerprintCalculator());
+
+        PGPPublicKey pub = pubRing.getPublicKey();
+        String       userID = (String)pub.getUserIDs().next();
+
+        for (Iterator it = pub.getSignatures(); it.hasNext();)
+        {
+            PGPSignature sig = (PGPSignature)it.next();
+
+            if (sig.getSignatureType() == PGPSignature.POSITIVE_CERTIFICATION)
+            {
+                sig.init(new BcPGPContentVerifierBuilderProvider(), pub);
+
+                if (!sig.verifyCertification(userID, pub))
+                {
+                    fail("failed UTF8 userID test");
+                }
+            }
+        }
+
+        //
+        // this is quicker because we are using pregenerated parameters.
+        //
+        RSAKeyPairGenerator  rsaKpg = new RSAKeyPairGenerator();
+
+        rsaKpg.init(new RSAKeyGenerationParameters(BigInteger.valueOf(0x11), new SecureRandom(), 512, 25));
+
+        AsymmetricCipherKeyPair    rsaKp = rsaKpg.generateKeyPair();
+        PGPKeyPair        rsaKeyPair1 = new BcPGPKeyPair(PGPPublicKey.RSA_GENERAL, rsaKp, new Date());
+                          rsaKp = rsaKpg.generateKeyPair();
+        char[]            passPhrase = "passwd".toCharArray();
+
+        PGPKeyRingGenerator    keyRingGen = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION, rsaKeyPair1,
+                userID, null, null, null, new BcPGPContentSignerBuilder(PGPPublicKey.RSA_GENERAL, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256).build(passPhrase));
+        PGPPublicKeyRing       pubRing1 = keyRingGen.generatePublicKeyRing();
+
+        pub = pubRing1.getPublicKey();
+
+        for (Iterator it = pub.getSignatures(); it.hasNext();)
+        {
+            PGPSignature sig = (PGPSignature)it.next();
+
+            if (sig.getSignatureType() == PGPSignature.POSITIVE_CERTIFICATION)
+            {
+                sig.init(new BcPGPContentVerifierBuilderProvider(), pub);
+
+                if (!sig.verifyCertification(userID, pub))
+                {
+                    fail("failed UTF8 userID creation test");
+                }
+            }
+        }
+    }
+
+    private void checkSecretKeyRingWithPersonalCertificate(byte[] keyRing)
+        throws Exception
+    {
+        PGPSecretKeyRingCollection secCol = new PGPSecretKeyRingCollection(keyRing);
+
+
+        int count = 0;
+
+        for (Iterator rIt = secCol.getKeyRings(); rIt.hasNext();)
+        {
+            PGPSecretKeyRing ring = (PGPSecretKeyRing)rIt.next();
+
+            for (Iterator it = ring.getExtraPublicKeys(); it.hasNext();)
+            {
+                it.next();
+                count++;
+            }
+        }
+
+        if (count != 1)
+        {
+            fail("personal certificate data subkey not found - count = " + count);
+        }
+    }
+
+    private void checkPublicKeyRingWithX509(byte[] keyRing)
+        throws Exception
+    {
+        PGPPublicKeyRing pubRing = new PGPPublicKeyRing(keyRing, new BcKeyFingerprintCalculator());
+        Iterator         it = pubRing.getPublicKeys();
+
+        if (it.hasNext())
+        {
+            PGPPublicKey key = (PGPPublicKey)it.next();
+
+            Iterator sIt = key.getSignatures();
+
+            if (sIt.hasNext())
+            {
+                PGPSignature sig = (PGPSignature)sIt.next();
+                if (sig.getKeyAlgorithm() != 100)
+                {
+                    fail("experimental signature not found");
+                }
+                if (!areEqual(sig.getSignature(), Hex.decode("000101")))
+                {
+                    fail("experimental encoding check failed");
+                }
+            }
+            else
+            {
+                fail("no signature found");
+            }
+        }
+        else
+        {
+            fail("no key found");
+        }
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        try
+        {
+            test1();
+            test2();
+            test3();
+            test4();
+            test5();
+            test6();
+    //      test7();
+            test8();
+            test9();
+            test10();
+            test11();
+            generateTest();
+            generateSha1Test();
+            rewrapTest();
+            testPublicKeyRingWithX509();
+            testSecretKeyRingWithPersonalCertificate();
+            insertMasterTest();
+            testUmlaut();
+        }
+        catch (PGPException e)
+        {
+            if (e.getUnderlyingException() != null)
+            {
+                Exception ex = e.getUnderlyingException();
+                fail("exception: " + ex, ex);
+            }
+            else
+            {
+                fail("exception: " + e, e);
+            }
+        }
+    }
+
+    public String getName()
+    {
+        return "PGPKeyRingTest";
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new BcPGPKeyRingTest());
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPPBETest.java b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPPBETest.java
new file mode 100644
index 000000000..2e1da4900
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPPBETest.java
@@ -0,0 +1,382 @@
+package org.bouncycastle.openpgp.test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.SecureRandom;
+import java.util.Date;
+
+import org.bouncycastle.openpgp.PGPEncryptedData;
+import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedDataList;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPObjectFactory;
+import org.bouncycastle.openpgp.PGPPBEEncryptedData;
+import org.bouncycastle.openpgp.operator.bc.BcPBEDataDecryptorFactory;
+import org.bouncycastle.openpgp.operator.bc.BcPBEKeyEncryptionMethodGenerator;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDataEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDigestCalculatorProvider;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.UncloseableOutputStream;
+
+public class BcPGPPBETest
+    extends SimpleTest
+{
+    private static final Date TEST_DATE = new Date(1062200111000L);
+
+    byte[] enc1 = Base64.decode(
+            "jA0EAwMC5M5wWBP2HBZgySvUwWFAmMRLn7dWiZN6AkQMvpE3b6qwN3SSun7zInw2"
+          + "hxxdgFzVGfbjuB8w");
+
+    byte[] enc1crc = Base64.decode("H66L");
+
+    char[] pass = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd' };
+
+    /**
+     * Message with both PBE and symmetric
+     */
+    byte[] testPBEAsym = Base64.decode(
+        "hQIOA/ZlQEFWB5vuEAf/covEUaBve7NlWWdiO5NZubdtTHGElEXzG9hyBycp9At8" +
+        "nZGi27xOZtEGFQo7pfz4JySRc3O0s6w7PpjJSonFJyNSxuze2LuqRwFWBYYcbS8/" +
+        "7YcjB6PqutrT939OWsozfNqivI9/QyZCjBvFU89pp7dtUngiZ6MVv81ds2I+vcvk" +
+        "GlIFcxcE1XoCIB3EvbqWNaoOotgEPT60unnB2BeDV1KD3lDRouMIYHfZ3SzBwOOI" +
+        "6aK39sWnY5sAK7JjFvnDAMBdueOiI0Fy+gxbFD/zFDt4cWAVSAGTC4w371iqppmT" +
+        "25TM7zAtCgpiq5IsELPlUZZnXKmnYQ7OCeysF0eeVwf+OFB9fyvCEv/zVQocJCg8" +
+        "fWxfCBlIVFNeNQpeGygn/ZmRaILvB7IXDWP0oOw7/F2Ym66IdYYIp2HeEZv+jFwa" +
+        "l41w5W4BH/gtbwGjFQ6CvF/m+lfUv6ZZdzsMIeEOwhP5g7rXBxrbcnGBaU+PXbho" +
+        "gjDqaYzAWGlrmAd6aPSj51AGeYXkb2T1T/yoJ++M3GvhH4C4hvitamDkksh/qRnM" +
+        "M/s8Nku6z1+RXO3M6p5QC1nlAVqieU8esT43945eSoC77K8WyujDNbysDyUCUTzt" +
+        "p/aoQwe/HgkeOTJNelKR9y2W3xinZLFzep0SqpNI/e468yB/2/LGsykIyQa7JX6r" +
+        "BYwuBAIDAkOKfv5rK8v0YDfnN+eFqwhTcrfBj5rDH7hER6nW3lNWcMataUiHEaMg" +
+        "o6Q0OO1vptIGxW8jClTD4N1sCNwNu9vKny8dKYDDHbCjE06DNTv7XYVW3+JqTL5E" +
+        "BnidvGgOmA==");
+
+    /**
+     * decrypt the passed in message stream
+     */
+    private byte[] decryptMessage(
+        byte[]    message,
+        Date      date)
+        throws Exception
+    {
+        PGPObjectFactory         pgpF = new PGPObjectFactory(message);
+        PGPEncryptedDataList     enc = (PGPEncryptedDataList)pgpF.nextObject();
+        PGPPBEEncryptedData      pbe = (PGPPBEEncryptedData)enc.get(0);
+
+        InputStream clear = pbe.getDataStream(new BcPBEDataDecryptorFactory(pass, new BcPGPDigestCalculatorProvider()));
+        
+        PGPObjectFactory         pgpFact = new PGPObjectFactory(clear);
+        
+        PGPLiteralData           ld = (PGPLiteralData)pgpFact.nextObject();
+        
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        if (!ld.getFileName().equals("test.txt")
+            && !ld.getFileName().equals("_CONSOLE"))
+        {
+            fail("wrong filename in packet");
+        }
+        if (!ld.getModificationTime().equals(date))
+        {
+            fail("wrong modification time in packet: " + ld.getModificationTime().getTime() + " " + date.getTime());
+        }
+
+        InputStream              unc = ld.getInputStream();
+        int                      ch;
+        
+        while ((ch = unc.read()) >= 0)
+        {
+            bOut.write(ch);
+        }
+
+        if (pbe.isIntegrityProtected() && !pbe.verify())
+        {
+            fail("integrity check failed");
+        }
+
+        return bOut.toByteArray();
+    }
+
+    private byte[] decryptMessageBuffered(
+        byte[]    message,
+        Date      date)
+        throws Exception
+    {
+        PGPObjectFactory         pgpF = new PGPObjectFactory(message);
+        PGPEncryptedDataList     enc = (PGPEncryptedDataList)pgpF.nextObject();
+        PGPPBEEncryptedData      pbe = (PGPPBEEncryptedData)enc.get(0);
+
+        InputStream clear = pbe.getDataStream(new BcPBEDataDecryptorFactory(pass, new BcPGPDigestCalculatorProvider()));
+
+        PGPObjectFactory         pgpFact = new PGPObjectFactory(clear);;
+
+        PGPLiteralData           ld = (PGPLiteralData)pgpFact.nextObject();
+
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        if (!ld.getFileName().equals("test.txt")
+            && !ld.getFileName().equals("_CONSOLE"))
+        {
+            fail("wrong filename in packet");
+        }
+        if (!ld.getModificationTime().equals(date))
+        {
+            fail("wrong modification time in packet: " + ld.getModificationTime().getTime() + " " + date.getTime());
+        }
+
+        InputStream              unc = ld.getInputStream();
+        byte[]                   buf = new byte[1024];
+        int                      len;
+
+        while ((len = unc.read(buf)) >= 0)
+        {
+            bOut.write(buf, 0, len);
+        }
+
+        if (pbe.isIntegrityProtected() && !pbe.verify())
+        {
+            fail("integrity check failed");
+        }
+
+        return bOut.toByteArray();
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        // compressed data not supported
+//        byte[] out = decryptMessage(enc1, TEST_DATE);
+//
+//        if (out[0] != 'h' || out[1] != 'e' || out[2] != 'l')
+//        {
+//            fail("wrong plain text in packet");
+//        }
+//
+        //
+        // create a PBE encrypted message and read it back.
+        //
+        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' };
+        
+        //
+        // encryption step - convert to literal data, compress, encode.
+        //
+        ByteArrayOutputStream bOut = new ByteArrayOutputStream();
+
+        Date                       cDate = new Date((System.currentTimeMillis() / 1000) * 1000);
+        PGPLiteralDataGenerator    lData = new PGPLiteralDataGenerator();
+        OutputStream               comOut = bOut;
+        OutputStream               ldOut = lData.open(
+            new UncloseableOutputStream(comOut),
+            PGPLiteralData.BINARY, 
+            PGPLiteralData.CONSOLE, 
+            text.length,
+            cDate);
+
+        ldOut.write(text);
+
+        ldOut.close();
+        
+        comOut.close();
+
+        //
+        // encrypt - with stream close
+        //
+        ByteArrayOutputStream        cbOut = new ByteArrayOutputStream();
+        PGPEncryptedDataGenerator    cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(PGPEncryptedData.CAST5).setSecureRandom(new SecureRandom()));
+        
+        cPk.addMethod(new BcPBEKeyEncryptionMethodGenerator(pass));
+        
+        OutputStream    cOut = cPk.open(new UncloseableOutputStream(cbOut), bOut.toByteArray().length);
+
+        cOut.write(bOut.toByteArray());
+
+        cOut.close();
+
+        byte[] out = decryptMessage(cbOut.toByteArray(), cDate);
+
+        if (!areEqual(out, text))
+        {
+            fail("wrong plain text in generated packet");
+        }
+
+        //
+        // encrypt - with generator close
+        //
+        cbOut = new ByteArrayOutputStream();
+        cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(PGPEncryptedData.CAST5).setSecureRandom(new SecureRandom()));
+
+        cPk.addMethod(new BcPBEKeyEncryptionMethodGenerator(pass));
+
+        cOut = cPk.open(new UncloseableOutputStream(cbOut), bOut.toByteArray().length);
+
+        cOut.write(bOut.toByteArray());
+
+        cPk.close();
+
+        out = decryptMessage(cbOut.toByteArray(), cDate);
+
+        if (!areEqual(out, text))
+        {
+            fail("wrong plain text in generated packet");
+        }
+
+        //
+        // encrypt - partial packet style.
+        //
+        SecureRandom    rand = new SecureRandom();
+        byte[]    test = new byte[1233];
+        
+        rand.nextBytes(test);
+        
+        bOut = new ByteArrayOutputStream();
+
+        comOut = bOut;
+        lData = new PGPLiteralDataGenerator();
+
+        ldOut = lData.open(new UncloseableOutputStream(comOut),
+            PGPLiteralData.BINARY, PGPLiteralData.CONSOLE, TEST_DATE,
+            new byte[16]);
+
+        
+        ldOut.write(test);
+
+        ldOut.close();
+        
+        comOut.close();
+
+        cbOut = new ByteArrayOutputStream();
+        cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(PGPEncryptedData.CAST5).setSecureRandom(rand));
+        
+        cPk.addMethod(new BcPBEKeyEncryptionMethodGenerator(pass));
+        
+        cOut = cPk.open(new UncloseableOutputStream(cbOut), new byte[16]);
+
+        cOut.write(bOut.toByteArray());
+
+        cOut.close();
+
+        out = decryptMessage(cbOut.toByteArray(), TEST_DATE);
+        if (!areEqual(out, test))
+        {
+            fail("wrong plain text in generated packet");
+        }
+        
+        //
+        // with integrity packet
+        //
+        cbOut = new ByteArrayOutputStream();
+        cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(PGPEncryptedData.CAST5).setWithIntegrityPacket(true).setSecureRandom(rand));
+        
+        cPk.addMethod(new BcPBEKeyEncryptionMethodGenerator(pass));
+        
+        cOut = cPk.open(new UncloseableOutputStream(cbOut), new byte[16]);
+
+        cOut.write(bOut.toByteArray());
+
+        cOut.close();
+
+        out = decryptMessage(cbOut.toByteArray(), TEST_DATE);
+        if (!areEqual(out, test))
+        {
+            fail("wrong plain text in generated packet");
+        }
+
+        //
+        // decrypt with buffering
+        //
+        out = decryptMessageBuffered(cbOut.toByteArray(), TEST_DATE);
+        if (!areEqual(out, test))
+        {
+            fail("wrong plain text in buffer generated packet");
+        }
+
+        //
+        // sample message
+        //
+        PGPObjectFactory pgpFact = new PGPObjectFactory(testPBEAsym);
+
+        PGPEncryptedDataList enc = (PGPEncryptedDataList)pgpFact.nextObject();
+
+        PGPPBEEncryptedData     pbe = (PGPPBEEncryptedData)enc.get(1);
+
+        InputStream clear = pbe.getDataStream(new BcPBEDataDecryptorFactory("password".toCharArray(), new BcPGPDigestCalculatorProvider()));
+
+        pgpFact = new PGPObjectFactory(clear);
+
+        // Compressed data not supported
+//        PGPLiteralData          ld = (PGPLiteralData)pgpFact.nextObject();
+//
+//        bOut = new ByteArrayOutputStream();
+//        InputStream    unc = ld.getInputStream();
+//        int    ch;
+//
+//        while ((ch = unc.read()) >= 0)
+//        {
+//            bOut.write(ch);
+//        }
+//
+//        if (!areEqual(bOut.toByteArray(), Hex.decode("5361742031302e30322e30370d0a")))
+//        {
+//            fail("data mismatch on combined PBE");
+//        }
+
+        //
+        // with integrity packet - one byte message
+        //
+        byte[] msg = new byte[1];
+        bOut = new ByteArrayOutputStream();
+
+        lData = new PGPLiteralDataGenerator();
+        comOut = bOut;
+        ldOut = lData.open(
+            new UncloseableOutputStream(comOut),
+            PGPLiteralData.BINARY,
+            PGPLiteralData.CONSOLE,
+            msg.length,
+            cDate);
+
+        ldOut.write(msg);
+
+        ldOut.close();
+
+        comOut.close();
+        
+        cbOut = new ByteArrayOutputStream();
+        cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(PGPEncryptedData.CAST5).setWithIntegrityPacket(true).setSecureRandom(rand));
+
+        cPk.addMethod(new BcPBEKeyEncryptionMethodGenerator(pass));
+
+        cOut = cPk.open(new UncloseableOutputStream(cbOut), new byte[16]);
+
+        cOut.write(bOut.toByteArray());
+
+        cOut.close();
+
+        out = decryptMessage(cbOut.toByteArray(), cDate);
+        if (!areEqual(out, msg))
+        {
+            fail("wrong plain text in generated packet");
+        }
+
+        //
+        // decrypt with buffering
+        //
+        out = decryptMessageBuffered(cbOut.toByteArray(), cDate);
+        if (!areEqual(out, msg))
+        {
+            fail("wrong plain text in buffer generated packet");
+        }
+    }
+
+    public String getName()
+    {
+        return "BcPGPPBETest";
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new BcPGPPBETest());
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPRSATest.java b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPRSATest.java
new file mode 100644
index 000000000..1f562228f
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/test/BcPGPRSATest.java
@@ -0,0 +1,1354 @@
+package org.bouncycastle.openpgp.test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+import java.util.Date;
+import java.util.Iterator;
+
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.bcpg.CompressionAlgorithmTags;
+import org.bouncycastle.bcpg.HashAlgorithmTags;
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
+import org.bouncycastle.bcpg.attr.ImageAttribute;
+import org.bouncycastle.bcpg.sig.Features;
+import org.bouncycastle.bcpg.sig.KeyFlags;
+
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.BufferedAsymmetricBlockCipher;
+import org.bouncycastle.crypto.KeyGenerationParameters;
+import org.bouncycastle.crypto.engines.RSAEngine;
+import org.bouncycastle.crypto.generators.RSAKeyPairGenerator;
+import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
+import org.bouncycastle.crypto.params.RSAKeyGenerationParameters;
+import org.bouncycastle.openpgp.PGPEncryptedData;
+import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedDataList;
+import org.bouncycastle.openpgp.PGPKeyPair;
+import org.bouncycastle.openpgp.PGPKeyRingGenerator;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPObjectFactory;
+import org.bouncycastle.openpgp.PGPOnePassSignature;
+import org.bouncycastle.openpgp.PGPOnePassSignatureList;
+import org.bouncycastle.openpgp.PGPPBEEncryptedData;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPPublicKey;
+import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
+import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPSecretKey;
+import org.bouncycastle.openpgp.PGPSecretKeyRing;
+import org.bouncycastle.openpgp.PGPSignature;
+import org.bouncycastle.openpgp.PGPSignatureGenerator;
+import org.bouncycastle.openpgp.PGPSignatureList;
+import org.bouncycastle.openpgp.PGPSignatureSubpacketGenerator;
+import org.bouncycastle.openpgp.PGPSignatureSubpacketVector;
+import org.bouncycastle.openpgp.PGPUserAttributeSubpacketVector;
+import org.bouncycastle.openpgp.PGPUserAttributeSubpacketVectorGenerator;
+import org.bouncycastle.openpgp.PGPUtil;
+import org.bouncycastle.openpgp.PGPV3SignatureGenerator;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyPair;
+import org.bouncycastle.openpgp.operator.PublicKeyDataDecryptorFactory;
+import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator;
+import org.bouncycastle.openpgp.operator.bc.BcPBEDataDecryptorFactory;
+import org.bouncycastle.openpgp.operator.bc.BcPBEKeyEncryptionMethodGenerator;
+import org.bouncycastle.openpgp.operator.bc.BcPBESecretKeyDecryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPBESecretKeyEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPContentVerifierBuilderProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDataEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDigestCalculatorProvider;
+import org.bouncycastle.openpgp.operator.bc.BcPGPKeyConverter;
+import org.bouncycastle.openpgp.operator.bc.BcPublicKeyDataDecryptorFactory;
+import org.bouncycastle.openpgp.operator.bc.BcPublicKeyKeyEncryptionMethodGenerator;
+
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.UncloseableOutputStream;
+
+public class BcPGPRSATest
+    extends SimpleTest
+{
+    byte[] testPubKey = Base64.decode(
+        "mIsEPz2nJAEEAOTVqWMvqYE693qTgzKv/TJpIj3hI8LlYPC6m1dk0z3bDLwVVk9F"
+      + "FAB+CWS8RdFOWt/FG3tEv2nzcoNdRvjv9WALyIGNawtae4Ml6oAT06/511yUzXHO"
+      + "k+9xK3wkXN5jdzUhf4cA2oGpLSV/pZlocsIDL+jCUQtumUPwFodmSHhzAAYptC9F"
+      + "cmljIEVjaGlkbmEgKHRlc3Qga2V5KSA8ZXJpY0Bib3VuY3ljYXN0bGUub3JnPoi4"
+      + "BBMBAgAiBQI/PackAhsDBQkAg9YABAsHAwIDFQIDAxYCAQIeAQIXgAAKCRA1WGFG"
+      + "/fPzc8WMA/9BbjuB8E48QAlxoiVf9U8SfNelrz/ONJA/bMvWr/JnOGA9PPmFD5Uc"
+      + "+kV/q+i94dEMjsC5CQ1moUHWSP2xlQhbOzBP2+oPXw3z2fBs9XJgnTH6QWMAAvLs"
+      + "3ug9po0loNHLobT/D/XdXvcrb3wvwvPT2FptZqrtonH/OdzT9JdfrA==");
+
+    byte[] testPrivKey = Base64.decode(
+        "lQH8BD89pyQBBADk1aljL6mBOvd6k4Myr/0yaSI94SPC5WDwuptXZNM92wy8FVZP"
+      + "RRQAfglkvEXRTlrfxRt7RL9p83KDXUb47/VgC8iBjWsLWnuDJeqAE9Ov+ddclM1x"
+      + "zpPvcSt8JFzeY3c1IX+HANqBqS0lf6WZaHLCAy/owlELbplD8BaHZkh4cwAGKf4D"
+      + "AwKbLeIOVYTEdWD5v/YgW8ERs0pDsSIfBTvsJp2qA798KeFuED6jGsHUzdi1M990"
+      + "6PRtplQgnoYmYQrzEc6DXAiAtBR4Kuxi4XHx0ZR2wpVlVxm2Ypgz7pbBNWcWqzvw"
+      + "33inl7tR4IDsRdJOY8cFlN+1tSCf16sDidtKXUVjRjZNYJytH18VfSPlGXMeYgtw"
+      + "3cSGNTERwKaq5E/SozT2MKTiORO0g0Mtyz+9MEB6XVXFavMun/mXURqbZN/k9BFb"
+      + "z+TadpkihrLD1xw3Hp+tpe4CwPQ2GdWKI9KNo5gEnbkJgLrSMGgWalPhknlNHRyY"
+      + "bSq6lbIMJEE3LoOwvYWwweR1+GrV9farJESdunl1mDr5/d6rKru+FFDwZM3na1IF"
+      + "4Ei4FpqhivZ4zG6pN5XqLy+AK85EiW4XH0yAKX1O4YlbmDU4BjxhiwTdwuVMCjLO"
+      + "5++jkz5BBQWdFX8CCMA4FJl36G70IbGzuFfOj07ly7QvRXJpYyBFY2hpZG5hICh0"
+      + "ZXN0IGtleSkgPGVyaWNAYm91bmN5Y2FzdGxlLm9yZz6IuAQTAQIAIgUCPz2nJAIb"
+      + "AwUJAIPWAAQLBwMCAxUCAwMWAgECHgECF4AACgkQNVhhRv3z83PFjAP/QW47gfBO"
+      + "PEAJcaIlX/VPEnzXpa8/zjSQP2zL1q/yZzhgPTz5hQ+VHPpFf6voveHRDI7AuQkN"
+      + "ZqFB1kj9sZUIWzswT9vqD18N89nwbPVyYJ0x+kFjAALy7N7oPaaNJaDRy6G0/w/1"
+      + "3V73K298L8Lz09habWaq7aJx/znc0/SXX6w=");
+
+    byte[] testPubKeyV3 = Base64.decode(
+       "mQCNAz+zvlEAAAEEAMS22jgXbOZ/D3xWgM2kauSdzrwlU7Ms5hDW05ObqQyO"
+      + "FfQoKKMhfupyoa7J3x04VVBKu6Eomvr1es+VImH0esoeWFFahNOYq/I+jRRB"
+      + "woOhAGZ5UB2/hRd7rFmxqp6sCXi8wmLO2tAorlTzAiNNvl7xF4cQZpc0z56F"
+      + "wdi2fBUJAAURtApGSVhDSVRZX1FBiQCVAwUQP7O+UZ6Fwdi2fBUJAQFMwwQA"
+      + "qRnFsdg4xQnB8Y5d4cOpXkIn9AZgYS3cxtuSJB84vG2CgC39nfv4c+nlLkWP"
+      + "4puG+mZuJNgVoE84cuAF4I//1anKjlU7q1M6rFQnt5S4uxPyG3dFXmgyU1b4"
+      + "PBOnA0tIxjPzlIhJAMsPCGGA5+5M2JP0ad6RnzqzE3EENMX+GqY=");
+
+    byte[] testPrivKeyV3 = Base64.decode(
+        "lQHfAz+zvlEAAAEEAMS22jgXbOZ/D3xWgM2kauSdzrwlU7Ms5hDW05ObqQyO"
+      + "FfQoKKMhfupyoa7J3x04VVBKu6Eomvr1es+VImH0esoeWFFahNOYq/I+jRRB"
+      + "woOhAGZ5UB2/hRd7rFmxqp6sCXi8wmLO2tAorlTzAiNNvl7xF4cQZpc0z56F"
+      + "wdi2fBUJAAURAXWwRBZQHNikA/f0ScLLjrXi4s0hgQecg+dkpDow94eu5+AR"
+      + "0DzZnfurpgfUJCNiDi5W/5c3Zj/xyrfMAgkbCgJ1m6FZqAQh7Mq73l7Kfu4/"
+      + "XIkyDF3tDgRuZNezB+JuElX10tV03xumHepp6M6CfhXqNJ15F33F99TA5hXY"
+      + "CPYD7SiSOpIhQkCOAgDAA63imxbpuKE2W7Y4I1BUHB7WQi8ZdkZd04njNTv+"
+      + "rFUuOPapQVfbWG0Vq8ld3YmJB4QWsa2mmqn+qToXbwufAgBpXkjvqK5yPiHF"
+      + "Px2QbFc1VqoCJB6PO5JRIqEiUZBFGdDlLxt3VSyqz7IZ/zEnxZq+tPCGGGSm"
+      + "/sAGiMvENcHVAfy0kTXU42TxEAYJyyNyqjXOobDJpEV1mKhFskRXt7tbMfOS"
+      + "Yf91oX8f6xw6O2Nal+hU8dS0Bmfmk5/enHmvRLHQocO0CkZJWENJVFlfUUE=");
+
+    byte[] sig1 = Base64.decode(
+        "owGbwMvMwMRoGpHo9vfz52LGNTJJnBmpOTn5eiUVJfb23JvAHIXy/KKcFEWuToap"
+      + "zKwMIGG4Bqav0SwMy3yParsEKi2LMGI9xhh65sBxb05n5++ZLcWNJ/eLFKdWbm95"
+      + "tHbDV7GMwj/tUctUpFUXWPYFCLdNsDiVNuXbQvZtdXV/5xzY+9w1nCnijH9JoNiJ"
+      + "22n2jo0zo30/TZLo+jDl2vTzIvPeLEsPM3ZUE/1Ytqs4SG2TxIQbH7xf3uzcYXq2"
+      + "5Fw9AA==");
+      
+    byte[] sig1crc = Base64.decode("+3i0");
+
+    byte[] subKey = Base64.decode(
+        "lQH8BD89pyQBBADk1aljL6mBOvd6k4Myr/0yaSI94SPC5WDwuptXZNM92wy8FVZP"
+      +    "RRQAfglkvEXRTlrfxRt7RL9p83KDXUb47/VgC8iBjWsLWnuDJeqAE9Ov+ddclM1x"
+      +    "zpPvcSt8JFzeY3c1IX+HANqBqS0lf6WZaHLCAy/owlELbplD8BaHZkh4cwAGKf4D"
+      +    "AwKt6ZC7iqsQHGDNn2ZAuhS+ZwiFC+BToW9Vq6rwggWjgM/SThv55rfDk7keiXUT"
+      +    "MyUcZVeYBe4Jttb4fAAm83hNztFu6Jvm9ITcm7YvnasBtVQjppaB+oYZgsTtwK99"
+      +    "LGC3mdexnriCLxPN6tDFkGhzdOcYZfK6py4Ska8Dmq9nOZU9Qtv7Pm3qa5tuBvYw"
+      +    "myTxeaJYifZTu/sky3Gj+REb8WonbgAJX/sLNBPUt+vYko+lxU8uqZpVEMU//hGG"
+      +    "Rns2gIHdbSbIe1vGgIRUEd7Z0b7jfVQLUwqHDyfh5DGvAUhvtJogjUyFIXZzpU+E"
+      +    "9ES9t7LZKdwNZSIdNUjM2eaf4g8BpuQobBVkj/GUcotKyeBjwvKxHlRefL4CCw28"
+      +    "DO3SnLRKxd7uBSqeOGUKxqasgdekM/xIFOrJ85k7p89n6ncLQLHCPGVkzmVeRZro"
+      +    "/T7zE91J57qBGZOUAP1vllcYLty1cs9PCc5oWnj3XbQvRXJpYyBFY2hpZG5hICh0"
+      +    "ZXN0IGtleSkgPGVyaWNAYm91bmN5Y2FzdGxlLm9yZz6IuAQTAQIAIgUCPz2nJAIb"
+      +    "AwUJAIPWAAQLBwMCAxUCAwMWAgECHgECF4AACgkQNVhhRv3z83PFjAP/QW47gfBO"
+      +    "PEAJcaIlX/VPEnzXpa8/zjSQP2zL1q/yZzhgPTz5hQ+VHPpFf6voveHRDI7AuQkN"
+      +    "ZqFB1kj9sZUIWzswT9vqD18N89nwbPVyYJ0x+kFjAALy7N7oPaaNJaDRy6G0/w/1"
+      +    "3V73K298L8Lz09habWaq7aJx/znc0/SXX6y0JEVyaWMgRWNoaWRuYSA8ZXJpY0Bi"
+      +    "b3VuY3ljYXN0bGUub3JnPoi4BBMBAgAiBQI/RxQNAhsDBQkAg9YABAsHAwIDFQID"
+      +    "AxYCAQIeAQIXgAAKCRA1WGFG/fPzc3O6A/49tXFCiiP8vg77OXvnmbnzPBA1G6jC"
+      +    "RZNP1yIXusOjpHqyLN5K9hw6lq/o4pNiCuiq32osqGRX3lv/nDduJU1kn2Ow+I2V"
+      +    "ci+ojMXdCGdEqPwZfv47jHLwRrIUJ22OOoWsORtgvSeRUd4Izg8jruaFM7ufr5hr"
+      +    "jEl1cuLW1Hr8Lp0B/AQ/RxxQAQQA0J2BIdqb8JtDGKjvYxrju0urJVVzyI1CnCjA"
+      +    "p7CtLoHQJUQU7PajnV4Jd12ukfcoK7MRraYydQEjxh2MqPpuQgJS3dgQVrxOParD"
+      +    "QYBFrZNd2tZxOjYakhErvUmRo6yWFaxChwqMgl8XWugBNg1Dva+/YcoGQ+ly+Jg4"
+      +    "RWZoH88ABin+AwMCldD/2v8TyT1ghK70IuFs4MZBhdm6VgyGR8DQ/Ago6IAjA4BY"
+      +    "Sol3lJb7+IIGsZaXwEuMRUvn6dWfa3r2I0p1t75vZb1Ng1YK32RZ5DNzl4Xb3L8V"
+      +    "D+1Fiz9mHO8wiplAwDudB+RmQMlth3DNi/UsjeCTdEJAT+TTC7D40DiHDb1bR86Y"
+      +    "2O5Y7MQ3SZs3/x0D/Ob6PStjfQ1kiqbruAMROKoavG0zVgxvspkoKN7h7BapnwJM"
+      +    "6yf4qN/aByhAx9sFvADxu6z3SVcxiFw3IgAmabyWYb85LP8AsTYAG/HBoC6yob47"
+      +    "Mt+GEDeyPifzzGXBWYIH4heZbSQivvA0eRwY5VZsMsBkbY5VR0FLVWgplbuO21bS"
+      +    "rPS1T0crC+Zfj7FQBAkTfsg8RZQ8MPaHng01+gnFd243DDFvTAHygvm6a2X2fiRw"
+      +    "5epAST4wWfY/BZNOxmfSKH6QS0oQMRscw79He6vGTB7vunLrKQYD4veInwQYAQIA"
+      +    "CQUCP0ccUAIbDAAKCRA1WGFG/fPzczmFA/wMg5HhN5NkqmjnHUFfeXNXdHzmekyw"
+      +    "38RnuCMKmfc43AiDs+FtJ62gpQ6PEsZF4o9S5fxcjVk3VSg00XMDtQ/0BsKBc5Gx"
+      +    "hJTq7G+/SoeM433WG19uoS0+5Lf/31wNoTnpv6npOaYpcTQ7L9LCnzwAF4H0hJPE"
+      +    "6bhmW2CMcsE/IZUB4QQ/Rwc1EQQAs5MUQlRiYOfi3fQ1OF6Z3eCwioDKu2DmOxot"
+      +    "BICvdoG2muvs0KEBas9bbd0FJqc92FZJv8yxEgQbQtQAiFxoIFHRTFK+SPO/tQm+"
+      +    "r83nwLRrfDeVVdRfzF79YCc+Abuh8sS/53H3u9Y7DYWr9IuMgI39nrVhY+d8yukf"
+      +    "jo4OR+sAoKS/f7V1Xxj/Eqhb8qzf+N+zJRUlBACDd1eo/zFJZcq2YJa7a9vkViME"
+      +    "axvwApqxeoU7oDpeHEMWg2DXJ7V24ZU5SbPTMY0x98cc8pcoqwsqux8xicWc0reh"
+      +    "U3odQxWM4Se0LmEdca0nQOmNJlL9IsQ+QOJzx47qUOUAqhxnkXxQ/6B8w+M6gZya"
+      +    "fwSdy70OumxESZipeQP+Lo9x6FcaW9L78hDX0aijJhgSEsnGODKB+bln29txX37E"
+      +    "/a/Si+pyeLMi82kUdIL3G3I5HPWd3qSO4K94062+HfFj8bA20/1tbb/WxvxB2sKJ"
+      +    "i3IobblFOvFHo+v8GaLdVyartp0JZLue/jP1dl9ctulSrIqaJT342uLsgTjsr2z+"
+      +    "AwMCAyAU8Vo5AhhgFkDto8vQk7yxyRKEzu5qB66dRcTlaUPIiR8kamcy5ZTtujs4"
+      +    "KIW4j2M/LvagrpWfV5+0M0VyaWMgRWNoaWRuYSAoRFNBIFRlc3QgS2V5KSA8ZXJp"
+      +    "Y0Bib3VuY3ljYXN0bGUub3JnPohZBBMRAgAZBQI/Rwc1BAsHAwIDFQIDAxYCAQIe"
+      +    "AQIXgAAKCRDNI/XpxMo0QwJcAJ40447eezSiIMspuzkwsMyFN8YBaQCdFTuZuT30"
+      +    "CphiUYWnsC0mQ+J15B4=");
+    
+    byte[] enc1 = Base64.decode(
+        "hIwDKwfQexPJboABA/4/7prhYYMORTiQ5avQKx0XYpCLujzGefYjnyuWZnx3Iev8"
+        +    "Pmsguumm+OLLvtXhhkXQmkJRXbIg6Otj2ubPYWflRPgpJSgOrNOreOl5jeABOrtw"
+        +    "bV6TJb9OTtZuB7cTQSCq2gmYiSZkluIiDjNs3R3mEanILbYzOQ3zKSggKpzlv9JQ"
+        +    "AZUqTyDyJ6/OUbJF5fI5uiv76DCsw1zyMWotUIu5/X01q+AVP5Ly3STzI7xkWg/J"
+        +    "APz4zUHism7kSYz2viAQaJx9/bNnH3AM6qm1Fuyikl4=");        
+
+    byte[] enc1crc = Base64.decode("lv4o");
+    
+    byte[] enc2 = Base64.decode(
+         "hIwDKwfQexPJboABBAC62jcJH8xKnKb1neDVmiovYON04+7VQ2v4BmeHwJrdag1g"
+        + "Ya++6PeBlQ2Q9lSGBwLobVuJmQ7cOnPUJP727JeSGWlMyFtMbBSHekOaTenT5lj7"
+        + "Zk7oRHxMp/hByzlMacIDzOn8LPSh515RHM57eDLCOwqnAxGQwk67GRl8f5dFH9JQ"
+        + "Aa7xx8rjCqPbiIQW6t5LqCNvPZOiSCmftll6+se1XJhFEuq8WS4nXtPfTiJ3vib4"
+        + "3soJdHzGB6AOs+BQ6aKmmNTVAxa5owhtSt1Z/6dfSSk=");
+
+     byte[]    subPubKey = Base64.decode(
+         "mIsEPz2nJAEEAOTVqWMvqYE693qTgzKv/TJpIj3hI8LlYPC6m1dk0z3bDLwVVk9F"
+        + "FAB+CWS8RdFOWt/FG3tEv2nzcoNdRvjv9WALyIGNawtae4Ml6oAT06/511yUzXHO"
+        + "k+9xK3wkXN5jdzUhf4cA2oGpLSV/pZlocsIDL+jCUQtumUPwFodmSHhzAAYptC9F"
+        + "cmljIEVjaGlkbmEgKHRlc3Qga2V5KSA8ZXJpY0Bib3VuY3ljYXN0bGUub3JnPoi4"
+        + "BBMBAgAiBQI/PackAhsDBQkAg9YABAsHAwIDFQIDAxYCAQIeAQIXgAAKCRA1WGFG"
+        + "/fPzc8WMA/9BbjuB8E48QAlxoiVf9U8SfNelrz/ONJA/bMvWr/JnOGA9PPmFD5Uc"
+        + "+kV/q+i94dEMjsC5CQ1moUHWSP2xlQhbOzBP2+oPXw3z2fBs9XJgnTH6QWMAAvLs"
+        + "3ug9po0loNHLobT/D/XdXvcrb3wvwvPT2FptZqrtonH/OdzT9JdfrIhMBBARAgAM"
+        + "BQI/RxooBYMAemL8AAoJEM0j9enEyjRDiBgAn3RcLK+gq90PvnQFTw2DNqdq7KA0"
+        + "AKCS0EEIXCzbV1tfTdCUJ3hVh3btF7QkRXJpYyBFY2hpZG5hIDxlcmljQGJvdW5j"
+        + "eWNhc3RsZS5vcmc+iLgEEwECACIFAj9HFA0CGwMFCQCD1gAECwcDAgMVAgMDFgIB"
+        + "Ah4BAheAAAoJEDVYYUb98/Nzc7oD/j21cUKKI/y+Dvs5e+eZufM8EDUbqMJFk0/X"
+        + "Ihe6w6OkerIs3kr2HDqWr+jik2IK6KrfaiyoZFfeW/+cN24lTWSfY7D4jZVyL6iM"
+        + "xd0IZ0So/Bl+/juMcvBGshQnbY46haw5G2C9J5FR3gjODyOu5oUzu5+vmGuMSXVy"
+        + "4tbUevwuiEwEEBECAAwFAj9HGigFgwB6YvwACgkQzSP16cTKNEPwBQCdHm0Amwza"
+        + "NmVmDHm3rmqI7rp2oQ0An2YbiP/H/kmBNnmTeH55kd253QOhuIsEP0ccUAEEANCd"
+        + "gSHam/CbQxio72Ma47tLqyVVc8iNQpwowKewrS6B0CVEFOz2o51eCXddrpH3KCuz"
+        + "Ea2mMnUBI8YdjKj6bkICUt3YEFa8Tj2qw0GARa2TXdrWcTo2GpIRK71JkaOslhWs"
+        + "QocKjIJfF1roATYNQ72vv2HKBkPpcviYOEVmaB/PAAYpiJ8EGAECAAkFAj9HHFAC"
+        + "GwwACgkQNVhhRv3z83M5hQP8DIOR4TeTZKpo5x1BX3lzV3R85npMsN/EZ7gjCpn3"
+        + "ONwIg7PhbSetoKUOjxLGReKPUuX8XI1ZN1UoNNFzA7UP9AbCgXORsYSU6uxvv0qH"
+        + "jON91htfbqEtPuS3/99cDaE56b+p6TmmKXE0Oy/Swp88ABeB9ISTxOm4ZltgjHLB"
+        + "PyGZAaIEP0cHNREEALOTFEJUYmDn4t30NThemd3gsIqAyrtg5jsaLQSAr3aBtprr"
+        + "7NChAWrPW23dBSanPdhWSb/MsRIEG0LUAIhcaCBR0UxSvkjzv7UJvq/N58C0a3w3"
+        + "lVXUX8xe/WAnPgG7ofLEv+dx97vWOw2Fq/SLjICN/Z61YWPnfMrpH46ODkfrAKCk"
+        + "v3+1dV8Y/xKoW/Ks3/jfsyUVJQQAg3dXqP8xSWXKtmCWu2vb5FYjBGsb8AKasXqF"
+        + "O6A6XhxDFoNg1ye1duGVOUmz0zGNMffHHPKXKKsLKrsfMYnFnNK3oVN6HUMVjOEn"
+        + "tC5hHXGtJ0DpjSZS/SLEPkDic8eO6lDlAKocZ5F8UP+gfMPjOoGcmn8Encu9Drps"
+        + "REmYqXkD/i6PcehXGlvS+/IQ19GooyYYEhLJxjgygfm5Z9vbcV9+xP2v0ovqcniz"
+        + "IvNpFHSC9xtyORz1nd6kjuCveNOtvh3xY/GwNtP9bW2/1sb8QdrCiYtyKG25RTrx"
+        + "R6Pr/Bmi3Vcmq7adCWS7nv4z9XZfXLbpUqyKmiU9+Nri7IE47K9stDNFcmljIEVj"
+        + "aGlkbmEgKERTQSBUZXN0IEtleSkgPGVyaWNAYm91bmN5Y2FzdGxlLm9yZz6IWQQT"
+        + "EQIAGQUCP0cHNQQLBwMCAxUCAwMWAgECHgECF4AACgkQzSP16cTKNEMCXACfauui"
+        + "bSwyG59Yrm8hHCDuCPmqwsQAni+dPl08FVuWh+wb6kOgJV4lcYae");
+         
+    byte[]    subPubCrc = Base64.decode("rikt");
+
+    byte[]    pgp8Key = Base64.decode(
+          "lQIEBEBXUNMBBADScQczBibewnbCzCswc/9ut8R0fwlltBRxMW0NMdKJY2LF"
+        + "7k2COeLOCIU95loJGV6ulbpDCXEO2Jyq8/qGw1qD3SCZNXxKs3GS8Iyh9Uwd"
+        + "VL07nMMYl5NiQRsFB7wOb86+94tYWgvikVA5BRP5y3+O3GItnXnpWSJyREUy"
+        + "6WI2QQAGKf4JAwIVmnRs4jtTX2DD05zy2mepEQ8bsqVAKIx7lEwvMVNcvg4Y"
+        + "8vFLh9Mf/uNciwL4Se/ehfKQ/AT0JmBZduYMqRU2zhiBmxj4cXUQ0s36ysj7"
+        + "fyDngGocDnM3cwPxaTF1ZRBQHSLewP7dqE7M73usFSz8vwD/0xNOHFRLKbsO"
+        + "RqDlLA1Cg2Yd0wWPS0o7+qqk9ndqrjjSwMM8ftnzFGjShAdg4Ca7fFkcNePP"
+        + "/rrwIH472FuRb7RbWzwXA4+4ZBdl8D4An0dwtfvAO+jCZSrLjmSpxEOveJxY"
+        + "GduyR4IA4lemvAG51YHTHd4NXheuEqsIkn1yarwaaj47lFPnxNOElOREMdZb"
+        + "nkWQb1jfgqO24imEZgrLMkK9bJfoDnlF4k6r6hZOp5FSFvc5kJB4cVo1QJl4"
+        + "pwCSdoU6luwCggrlZhDnkGCSuQUUW45NE7Br22NGqn4/gHs0KCsWbAezApGj"
+        + "qYUCfX1bcpPzUMzUlBaD5rz2vPeO58CDtBJ0ZXN0ZXIgPHRlc3RAdGVzdD6I"
+        + "sgQTAQIAHAUCQFdQ0wIbAwQLBwMCAxUCAwMWAgECHgECF4AACgkQs8JyyQfH"
+        + "97I1QgP8Cd+35maM2cbWV9iVRO+c5456KDi3oIUSNdPf1NQrCAtJqEUhmMSt"
+        + "QbdiaFEkPrORISI/2htXruYn0aIpkCfbUheHOu0sef7s6pHmI2kOQPzR+C/j"
+        + "8D9QvWsPOOso81KU2axUY8zIer64Uzqc4szMIlLw06c8vea27RfgjBpSCryw"
+        + "AgAA");
+
+    char[]    pgp8Pass = "2002 Buffalo Sabres".toCharArray();
+
+    char[]    pass = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd' };
+
+    byte[]  fingerprintKey = Base64.decode(
+            "mQEPA0CiJdUAAAEIAMI+znDlPd2kQoEcnxqxLcRz56Z7ttFKHpnYp0UkljZdquVc"
+          + "By1jMfXGVV64xN1IvMcyenLXUE0IUeUBCQs6tHunFRAPSeCxJ3FdFe1B5MpqQG8A"
+          + "BnEpAds/hAUfRDZD5y/lolk1hjvFMrRh6WXckaA/QQ2t00NmTrJ1pYUpkw9tnVQb"
+          + "LUjWJhfZDBBcN0ADtATzgkugxMtcDxR6I5x8Ndn+IilqIm23kxGIcmMd/BHOec4c"
+          + "jRwJXXDb7u8tl+2knAf9cwhPHp3+Zy4uGSQPdzQnXOhBlA+4WDa0RROOevWgq8uq"
+          + "8/9Xp/OlTVL+OoIzjsI6mJP1Joa4qmqAnaHAmXcAEQEAAbQoQk9BM1JTS1kgPEJP"
+          + "QSBNb25pdG9yaW5nIEAgODg4LTI2OS01MjY2PokBFQMFEECiJdWqaoCdocCZdwEB"
+          + "0RsH/3HPxoUZ3G3K7T3jgOnJUckTSHWU3XspHzMVgqOxjTrcexi5IsAM5M+BulfW"
+          + "T2aO+Kqf5w8cKTKgW02DNpHUiPjHx0nzDE+Do95zbIErGeK+Twkc4O/aVsvU9GGO"
+          + "81VFI6WMvDQ4CUAUnAdk03MRrzI2nAuhn4NJ5LQS+uJrnqUJ4HmFAz6CQZQKd/kS"
+          + "Xgq+A6i7aI1LG80YxWa9ooQgaCrb9dwY/kPQ+yC22zQ3FExtv+Fv3VtAKTilO3vn"
+          + "BA4Y9uTHuObHfI+1yxUS2PrlRUX0m48ZjpIX+cEN3QblGBJudI/A1QSd6P0LZeBr"
+          + "7F1Z1aF7ZDo0KzgiAIBvgXkeTpw=");
+
+    byte[] fingerprintCheck = Base64.decode("CTv2");
+
+    byte[]  expiry60and30daysSig13Key = Base64.decode(
+              "mQGiBENZt/URBAC5JccXiwe4g6MuviEC8NI/x0NaVkGFAOY04d5E4jeIycBP"
+            + "SrpOPrjETuigqhrj8oqed2+2yUqfnK4nhTsTAjyeJ3PpWC1pGAKzJgYmJk+K"
+            + "9aTLq0BQWiXDdv5RG6fDmeq1umvOfcXBqGFAguLPZC+U872bSLnfe3lqGNA8"
+            + "jvmY7wCgjhzVQVm10NN5ST8nemPEcSjnBrED/R494gHL6+r5OgUgXnNCDejA"
+            + "4InoDImQCF+g7epp5E1MB6CMYSg2WSY2jHFuHpwnUb7AiOO0ZZ3UBqM9rYnK"
+            + "kDvxkFCxba7Ms+aFj9blRNmy3vG4FewDcTdxzCtjUk6dRfu6UoARpqlTE/q7"
+            + "Xo6EQP1ncwJ+UTlcHkTBvg/usI/yBACGjBqX8glb5VfNaZgNHMeS/UIiUiuV"
+            + "SVFojiSDOHcnCe/6y4M2gVm38zz1W9qhoLfLpiAOFeL0yj6wzXvsjjXQiKQ8"
+            + "nBE4Mf+oeH2qiQ/LfzQrGpI5eNcMXrzK9nigmz2htYO2GjQfupEnu1RHBTH8"
+            + "NjofD2AShL9IO73plRuExrQgVGVzdCBLZXkgPHRlc3RAYm91bmN5Y2FzdGxl"
+            + "Lm9yZz6IZAQTEQIAJAIbAwYLCQgHAwIDFQIDAxYCAQIeAQIXgAUCQ1m4DgUJ"
+            + "AE8aGQAKCRD8QP1QuU7Kqw+eAJ0dZ3ZAqr73X61VmCkbyPoszLQMAQCfdFs2"
+            + "YMDeUvX34Q/8Ba0KgO5f3RSwAgADuM0EQ1m39hADAIHpVGcLqS9UkmQaWBvH"
+            + "WP6TnN7Y1Ha0TJOuxpbFjBW+CmVh/FjcsnavFXDXpo2zc742WT+vrHBSa/0D"
+            + "1QEBsnCaX5SRRVp7Mqs8q+aDhjcHMIP8Sdxf7GozXDORkrRaJwADBQL9HLYm"
+            + "7Rr5iYWDcvs+Pi6O1zUyb1tjkxEGaV/rcozl2MMmr2mzJ6x/Bz8SuhZEJS0m"
+            + "bB2CvAA39aQi9jHlV7q0SV73NOkd2L/Vt2UZhzlUdvrJ37PgYDv+Wd9Ufz6g"
+            + "MzLSiE8EGBECAA8FAkNZt/YCGwwFCQAnjQAACgkQ/ED9ULlOyqsTqQCcDnAZ"
+            + "7YymCfhm1yJiuFQg3qiX6Z4An19OSEgeSKugVcH49g1sxUB0zNdIsAIAAw==");
+
+    byte[] jpegImage = Base64.decode(
+            "/9j/4AAQSkZJRgABAQEASABIAAD/4QAWRXhpZgAATU0AKgAAAAgAAAAAAAD/2wBDAAUDBAQEAwUE"
+          + "BAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/"
+          + "wAALCAA6AFABASIA/8QAHAAAAgMAAwEAAAAAAAAAAAAABQcABAYBAggD/8QAMRAAAgEDBAEDAwME"
+          + "AQUAAAAAAQIDBAURAAYSITEHIkETFFEjYXEVMkKRCCUzQ4Gh/9oACAEBAAA/APX1TdKCmlaOoqoo"
+          + "WXzzbiP9nWaS71lXuA2tqrgopBOxpyGyWLAEEd4GAf3+fOjLPXoVaOcNzYAhl8HskADwAPz37f3z"
+          + "opSvI9Mjypwcr7l/B1XuFwSmoTVooljB9xDYAH51Vor191F9dKGb6Py3yo4huwcHwf8AYP7ZLIyu"
+          + "gZSGBGQQejrnU1NKn1EqVi3sZJOBCwxxIp9xzksfb5PR+Mdga+ljqIKje1TNBBNToYYgU4477HwQ"
+          + "Bn9z8/nW6mqxLR0NzpJkMLx8lJUkOGAIx4I/0f41lJ93UkkrRxVKvNKVjZfpSe6RyqhCp7wCSD89"
+          + "EEDRWppEkgqKdYohGcoZAjAlSMMcZ+PHH/3odsG6VLW2qaoqV+nTyFZpHOFQL0Sc9ADGTnHWtZap"
+          + "EpoamJm/TgYkfgJ5H/zGuKieVJIGkqCgmfCJFFy64s3Z+Oh58fHyNfGavipIJ2BrZcKXA+mzEd9Y"
+          + "OCcHI/gDV62SzvBGKhQHaNWzj8jvP750oN/xM3qkshLPEstOhj7IVyvkY+f7Nd7hf9vbc9QbVb7n"
+          + "dadLldqc00FMCwlmZnCrgL2v/cAySPBPwSD+/wC+3HbWx3rLbaqW81CVHOWnetMZjRm9h7VvClcj"
+          + "oDB7PymPTvem+a6roxvC10sd3ScmlucdEyUtRADxdice9wY3PQGRgj4OnHU3u5RW+op6imo4q+KA"
+          + "1UKGQ/bzrnt0biWxkgFOJK9ZyCCVX6f3T1Rh9RawbltdQNv18CGe2wxBDQyvGrowIJd15HEnHvP+"
+          + "OBjXoGzS0tNTpQipFTIw48Xn5SSBVUMw5e5wMgZ/j86yVNvvZ9TeDR1c9XSV0bl443dmYZXiCSCR"
+          + "jvxkjR1L1b46iWpStpIRLOWkCqyniP8AJjxPIniBjr+etFdu11DVu321WZiFHRjZcA/gsO+seNYf"
+          + "fVpq6n1Eo5KNATIYmb5Bx7csP4z/AKz8aX1N6Q7W3FuWWrS1TRzi+tXSutUESQhCGiVAvJVRgfcc"
+          + "HkeidM6tSmTbps9RHIH4KoqC8j/VC8R0+CSScZLdknPZGgNfYpUUUzfewxxcWpopWbhL715KgBIQ"
+          + "MCQc4A84+dD963X7ywQ0NIVW60qqzkzIfoszAMGUNyUHORkDrHxo3sSaOhtX2hnp3uNRF9b7hqtO"
+          + "DxM3Rcj3dMCPHXLGfOkLuPddp9R/ViOa62KppqK3Vctvsz0UylKtWfgXy3+L8WIZFBGRhs407rTT"
+          + "bcuFDRWmtsNGIZ1MMEU9GPqRorKPcJEzhich8Anz350Wk2zs2OsT7D7RZJpChMEk0MoypJZWVwM9"
+          + "ZzjWw2lbKaioFjQy/U9shLyu7Esi5JLEnsgnQlaSqhqayWSRZ5JaiSSNPoBCiq54jPuJyA2W+QfA"
+          + "+FrSXq4bdulZHRpWRzpArPK0SSNUExh14qB4c5X9ipz41Zud0juVouVooHN6rrZKVaoek/VhYgqE"
+          + "4v7cZPTfPHwT7tZX0e2NVUV5rK2ku9TeY6aFZJ6GuLALKzNnizE4CsqHIyBxJCk4AYFNt2wSUExm"
+          + "pP1lqgq1zkfXUtIgkiOFHQCsCM/kfOtZU7GsNZU1FFc1lrqCSNSlFOQ8SJk8kC4/tJx1rMwbWt0V"
+          + "CW21VW+krVoFTCRrPC0bf+NF8ocqMcT/AIg6EVF5/p9U6zPXLVFGpoKlSpMiEkniSCcqVY+eQIPW"
+          + "NULf/UNxJNS0dhklu8SK9Lco6pUcEr0JOu1HQ7z+R5OndaI5leWV0VQ54kA5KlWIx/Gqd2t6vcqe"
+          + "FIXNJMs71SoCMsQuG5jsN8AAjyTnrGlt6mVlqswtS0SG71NTXpSiCQFpogckll6Y4wvyD/OToVd7"
+          + "3tLedda4Nr3iRK2mqJhW1K0qxSSGJf1OTOAwwVADLkA9fPV2W77msVfPTClNRUyJCla0SqS5dR5J"
+          + "b2kluKlQc5BbHnWu2xTS0G4qmjvSq6RwrPHJUMHkkYDhzJHXIhmBAHnxpaL6j3il3D6g1VLuSz1k"
+          + "1ht//S6SZQ4KoTI6MyMOb9hR85HedM/0wqn3RsC0bhgq/pQV9J9WELEFaNWGARg+04xkd95xjQTe"
+          + "df6c7U+ysl3mtMFJe5JYGkkmAVKgKZCZGzlVbBySemA/OgvpZUQxvaqitgoqSsiX6XKh5RwVCBP0"
+          + "8KCTIoU8VJyDjIA8Bs2e5CprDTR8VXi8pRgyyZMh8qQMDHz850ZOlVv30RsW5blcL5S3a626+1cq"
+          + "TirFQ0qJIgAQCNjgIMeFKn9wQCMA3o2vprca/ctp29Jv6/3aoZ4IRRx08dC5D8nWQv7FJYHByeuv"
+          + "zo5SWn1Z2ttahutFZqbcG6JK5ZLu1TNEzzUq5ASNyVw6pxUMc5Oc5znR6KyXffldUVW4rBcbAqos"
+          + "EUq1qrUzUkwy8bFB+m4ZI2IBbAJAbOdau0+nmybJYqe027atvNHTRlYomhVz+Tln8knyScn50j/+"
+          + "SOyd3VO2oDtmPcNPYqJgDt23xKtOIiTy6gYO/Z5YOcAHGsJ/x39NgbzuDc+0bNt6/wAySmltbXGv"
+          + "flaT8ST07xBjIR30RjsL+dex9uwT/wBKo6i5UtPFdHp4/u/pgECTiOQDYBIByB+w0RVEVmZUUM39"
+          + "xA7P867ampqampqaq09BQwV9RWwUVNFU1AUTTJEoeQLnHJgMnGTjP51a1Nf/2Q==");
+
+    byte[] embeddedJPEGKey = Base64.decode(
+            "mI0ER0JXuwEEAKNqsXwLU6gu6P2Q/HJqEJVt3A7Kp1yucn8HWVeJF9JLAKVjVU8jrvz9Bw4NwaRJ"
+          + "NGYEAgdRq8Hx3WP9FXFCIVfCdi+oQrphcHWzzBFul8sykUGT+LmcBdqQGU9WaWSJyCOmUht4j7t0"
+          + "zk/IXX0YxGmkqR+no5rTj9LMDG8AQQrFABEBAAG0P0VyaWMgSCBFY2hpZG5hIChpbWFnZSB0ZXN0"
+          + "IGtleSkgPGVyaWMuZWNoaWRuYUBib3VuY3ljYXN0bGUub3JnPoi2BBMBAgAgBQJHQle7AhsDBgsJ"
+          + "CAcDAgQVAggDBBYCAwECHgECF4AACgkQ1+RWqFFpjMTKtgP+Okqkn0gVpQyNYXM/hWX6f3UQcyXk"
+          + "2Sd/fWW0XG+LBjhhBo+lXRWK0uYF8OMdZwsSl9HimpgYD5/kNs0Seh417DioP1diOgxkgezyQgMa"
+          + "+ODZfNnIvVaBr1pHLPLeqIBxBVMWBfa4wDXnLLGu8018uvI2yBhz5vByB1ntxwgKMXCwAgAD0cf3"
+          + "x/UBEAABAQAAAAAAAAAAAAAAAP/Y/+AAEEpGSUYAAQEBAEgASAAA/+EAFkV4aWYAAE1NACoAAAAI"
+          + "AAAAAAAA/9sAQwAFAwQEBAMFBAQEBQUFBgcMCAcHBwcPCwsJDBEPEhIRDxERExYcFxMUGhURERgh"
+          + "GBodHR8fHxMXIiQiHiQcHh8e/8AACwgAOgBQAQEiAP/EABwAAAIDAAMBAAAAAAAAAAAAAAUHAAQG"
+          + "AQIIA//EADEQAAIBAwQBAwMDBAEFAAAAAAECAwQFEQAGEiExByJBExRRI2FxFTJCkQglM0OBof/a"
+          + "AAgBAQAAPwD19U3SgppWjqKqKFl8824j/Z1mku9ZV7gNraq4KKQTsachsliwBBHeBgH9/nzoyz16"
+          + "FWjnDc2AIZfB7JAA8AD89+3986KUryPTI8qcHK+5fwdV7hcEpqE1aKJYwfcQ2AB+dVaK9fdRfXSh"
+          + "m+j8t8qOIbsHB8H/AGD+2SyMroGUhgRkEHo651NTSp9RKlYt7GSTgQsMcSKfcc5LH2+T0fjHYGvp"
+          + "Y6iCo3tUzQQTU6GGIFOOO+x8EAZ/c/P51upqsS0dDc6SZDC8fJSVJDhgCMeCP9H+NZSfd1JJK0cV"
+          + "SrzSlY2X6UnukcqoQqe8Akg/PRBA0VqaRJIKinWKIRnKGQIwJUjDHGfjxx/96HbBulS1tqmqKlfp"
+          + "08hWaRzhUC9EnPQAxk5x1rWWqRKaGpiZv04GJH4CeR/8xrionlSSBpKgoJnwiRRcuuLN2fjoefHx"
+          + "8jXxmr4qSCdga2XClwPpsxHfWDgnByP4A1etks7wRioUB2jVs4/I7z++dKDf8TN6pLISzxLLToY+"
+          + "yFcr5GPn+zXe4X/b23PUG1W+53WnS5XanNNBTAsJZmZwq4C9r/3AMkjwT8Eg/v8Avtx21sd6y22q"
+          + "lvNQlRzlp3rTGY0ZvYe1bwpXI6Awez8pj073pvmuq6MbwtdLHd0nJpbnHRMlLUQA8XYnHvcGNz0B"
+          + "kYI+Dpx1N7uUVvqKeopqOKvigNVChkP28657dG4lsZIBTiSvWcgglV+n909UYfUWsG5bXUDb9fAh"
+          + "ntsMQQ0Mrxq6MCCXdeRxJx7z/jgY16Bs0tLTU6UIqRUyMOPF5+UkgVVDMOXucDIGf4/OslTb72fU"
+          + "3g0dXPV0ldG5eON3ZmGV4gkgkY78ZI0dS9W+OolqUraSESzlpAqsp4j/ACY8TyJ4gY6/nrRXbtdQ"
+          + "1bt9tVmYhR0Y2XAP4LDvrHjWH31aaup9RKOSjQEyGJm+Qce3LD+M/wCs/Gl9TekO1txbllq0tU0c"
+          + "4vrV0rrVBEkIQholQLyVUYH3HB5HonTOrUpk26bPURyB+CqKgvI/1QvEdPgkknGS3ZJz2RoDX2KV"
+          + "FFM33sMcXFqaKVm4S+9eSoASEDAkHOAPOPnQ/et1+8sENDSFVutKqs5MyH6LMwDBlDclBzkZA6x8"
+          + "aN7EmjobV9oZ6d7jURfW+4arTg8TN0XI93TAjx1yxnzpC7j3XafUf1Yjmutiqaait1XLb7M9FMpS"
+          + "rVn4F8t/i/FiGRQRkYbONO60023LhQ0VprbDRiGdTDBFPRj6kaKyj3CRM4YnIfAJ89+dFpNs7Njr"
+          + "E+w+0WSaQoTBJNDKMqSWVlcDPWc41sNpWymoqBY0Mv1PbIS8ruxLIuSSxJ7IJ0JWkqoamslkkWeS"
+          + "WokkjT6AQoqueIz7icgNlvkHwPha0l6uG3bpWR0aVkc6QKzytEkjVBMYdeKgeHOV/Yqc+NWbndI7"
+          + "laLlaKBzeq62SlWqHpP1YWIKhOL+3GT03zx8E+7WV9HtjVVFeaytpLvU3mOmhWSehriwCyszZ4sx"
+          + "OArKhyMgcSQpOAGBTbdsElBMZqT9ZaoKtc5H11LSIJIjhR0ArAjP5HzrWVOxrDWVNRRXNZa6gkjU"
+          + "pRTkPEiZPJAuP7ScdazMG1rdFQlttVVvpK1aBUwkazwtG3/jRfKHKjHE/wCIOhFRef6fVOsz1y1R"
+          + "RqaCpUqTIhJJ4kgnKlWPnkCD1jVC3/1DcSTUtHYZJbvEivS3KOqVHBK9CTrtR0O8/keTp3WiOZXl"
+          + "ldFUOeJAOSpViMfxqndrer3KnhSFzSTLO9UqAjLELhuY7DfAAI8k56xpbeplZarMLUtEhu9TU16U"
+          + "ogkBaaIHJJZemOML8g/zk6FXe97S3nXWuDa94kStpqiYVtStKsUkhiX9TkzgMMFQAy5APXz1dlu+"
+          + "5rFXz0wpTUVMiQpWtEqkuXUeSW9pJbipUHOQWx51rtsU0tBuKpo70qukcKzxyVDB5JGA4cyR1yIZ"
+          + "gQB58aWi+o94pdw+oNVS7ks9ZNYbf/0ukmUOCqEyOjMjDm/YUfOR3nTP9MKp90bAtG4YKv6UFfSf"
+          + "VhCxBWjVhgEYPtOMZHfecY0E3nX+nO1PsrJd5rTBSXuSWBpJJgFSoCmQmRs5VWwcknpgPzoL6WVE"
+          + "Mb2qorYKKkrIl+lyoeUcFQgT9PCgkyKFPFScg4yAPAbNnuQqaw00fFV4vKUYMsmTIfKkDAx8/OdG"
+          + "TpVb99EbFuW5XC+Ut2utuvtXKk4qxUNKiSIAEAjY4CDHhSp/cEAjAN6Nr6a3Gv3LadvSb+v92qGe"
+          + "CEUcdPHQuQ/J1kL+xSWBwcnrr86OUlp9WdrbWobrRWam3BuiSuWS7tUzRM81KuQEjclcOqcVDHOT"
+          + "nOc50eisl335XVFVuKwXGwKqLBFKtaq1M1JMMvGxQfpuGSNiAWwCQGznWrtPp5smyWKntNu2rbzR"
+          + "00ZWKJoVc/k5Z/JJ8knJ+dI//kjsnd1TtqA7Zj3DT2KiYA7dt8SrTiIk8uoGDv2eWDnABxrCf8d/"
+          + "TYG87g3PtGzbev8AMkppbW1xr35Wk/Ek9O8QYyEd9EY7C/nXsfbsE/8ASqOouVLTxXR6eP7v6YBA"
+          + "k4jkA2ASAcgfsNEVRFZmVFDN/cQOz/Ou2pqampqamqtPQUMFfUVsFFTRVNQFE0yRKHkC5xyYDJxk"
+          + "4z+dWtTX/9mItgQTAQIAIAUCR0JYkAIbAwYLCQgHAwIEFQIIAwQWAgMBAh4BAheAAAoJENfkVqhR"
+          + "aYzEAPYD/iHdLOAE8r8HHF3F4z28vtIT8iiRB9aPC/YH0xqV1qeEKG8+VosBaQAOCEquONtRWsww"
+          + "gO3XB0d6VAq2kMOKc2YiB4ZtZcFvvmP9KdmVIZxVjpa9ozjP5j9zFso1HOpFcsn/VDBEqy5TvsNx"
+          + "Qvmtc8X7lqK/zLRVkSSBItik2IIhsAIAAw==");
+
+    
+    private void fingerPrintTest()
+        throws Exception
+    {
+        //
+        // version 3
+        //
+        PGPPublicKeyRing        pgpPub = new PGPPublicKeyRing(fingerprintKey, new BcKeyFingerprintCalculator());
+
+        PGPPublicKey            pubKey = pgpPub.getPublicKey();
+
+        if (!areEqual(pubKey.getFingerprint(), Hex.decode("4FFB9F0884266C715D1CEAC804A3BBFA")))
+        {
+            fail("version 3 fingerprint test failed");
+        }
+        
+        //
+        // version 4
+        //
+        pgpPub = new PGPPublicKeyRing(testPubKey, new BcKeyFingerprintCalculator());
+
+        pubKey = pgpPub.getPublicKey();
+
+        if (!areEqual(pubKey.getFingerprint(), Hex.decode("3062363c1046a01a751946bb35586146fdf3f373")))
+        {
+            fail("version 4 fingerprint test failed");
+        }
+    }
+
+    private void mixedTest(PGPPrivateKey pgpPrivKey, PGPPublicKey pgpPubKey)
+        throws Exception
+    {
+        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' };
+
+        //
+        // literal data
+        //
+        ByteArrayOutputStream bOut = new ByteArrayOutputStream();
+        PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();
+        OutputStream lOut = lGen.open(bOut, PGPLiteralData.BINARY, PGPLiteralData.CONSOLE, text.length, new Date());
+
+        lOut.write(text);
+
+        lGen.close();
+
+        byte[] bytes = bOut.toByteArray();
+
+        PGPObjectFactory f = new PGPObjectFactory(bytes);
+        checkLiteralData((PGPLiteralData)f.nextObject(), text);
+
+        ByteArrayOutputStream bcOut = new ByteArrayOutputStream();
+
+        PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.AES_128).setWithIntegrityPacket(true).setSecureRandom(new SecureRandom()));
+
+        encGen.addMethod(new BcPublicKeyKeyEncryptionMethodGenerator(pgpPubKey));
+
+        encGen.addMethod(new BcPBEKeyEncryptionMethodGenerator("password".toCharArray()));
+
+        OutputStream cOut = encGen.open(bcOut, bytes.length);
+
+        cOut.write(bytes);
+
+        cOut.close();
+
+        byte[] encData = bcOut.toByteArray();
+
+        //
+        // asymmetric
+        //
+        PGPObjectFactory pgpF = new PGPObjectFactory(encData);
+
+        PGPEncryptedDataList       encList = (PGPEncryptedDataList)pgpF.nextObject();
+
+        PGPPublicKeyEncryptedData  encP = (PGPPublicKeyEncryptedData)encList.get(0);
+
+        InputStream clear = encP.getDataStream(new BcPublicKeyDataDecryptorFactory(pgpPrivKey));
+
+        PGPObjectFactory pgpFact = new PGPObjectFactory(clear);
+
+        checkLiteralData((PGPLiteralData)pgpFact.nextObject(), text);
+
+        //
+        // PBE
+        //
+        pgpF = new PGPObjectFactory(encData);
+
+        encList = (PGPEncryptedDataList)pgpF.nextObject();
+
+        PGPPBEEncryptedData encPbe = (PGPPBEEncryptedData)encList.get(1);
+
+        clear = encPbe.getDataStream(new BcPBEDataDecryptorFactory("password".toCharArray(), new BcPGPDigestCalculatorProvider()));
+
+        pgpF = new PGPObjectFactory(clear);
+
+        checkLiteralData((PGPLiteralData)pgpF.nextObject(), text);
+    }
+
+    private void checkLiteralData(PGPLiteralData ld, byte[] data)
+        throws IOException
+    {
+        ByteArrayOutputStream bOut = new ByteArrayOutputStream();
+
+        if (!ld.getFileName().equals(PGPLiteralData.CONSOLE))
+        {
+            throw new RuntimeException("wrong filename in packet");
+        }
+
+        InputStream    inLd = ld.getDataStream();
+        int ch;
+
+        while ((ch = inLd.read()) >= 0)
+        {
+            bOut.write(ch);
+        }
+
+        if (!areEqual(bOut.toByteArray(), data))
+        {
+            fail("wrong plain text in decrypted packet");
+        }
+    }
+
+    private void existingEmbeddedJpegTest()
+        throws Exception
+    {
+        PGPPublicKeyRing pgpPub = new PGPPublicKeyRing(embeddedJPEGKey, new BcKeyFingerprintCalculator());
+
+        PGPPublicKey pubKey = pgpPub.getPublicKey();
+
+        Iterator it = pubKey.getUserAttributes();
+        int      count = 0;
+        while (it.hasNext())
+        {
+            PGPUserAttributeSubpacketVector attributes = (PGPUserAttributeSubpacketVector)it.next();
+
+            Iterator    sigs = pubKey.getSignaturesForUserAttribute(attributes);
+            int sigCount = 0;
+            while (sigs.hasNext())
+            {
+                PGPSignature sig = (PGPSignature)sigs.next();
+
+                sig.init(new BcPGPContentVerifierBuilderProvider(), pubKey);
+
+                if (!sig.verifyCertification(attributes, pubKey))
+                {
+                    fail("signature failed verification");
+                }
+
+                sigCount++;
+            }
+
+            if (sigCount != 1)
+            {
+                fail("Failed user attributes signature check");
+            }
+            count++;
+        }
+
+        if (count != 1)
+        {
+            fail("didn't find user attributes");
+        }
+    }
+
+    private void embeddedJpegTest()
+        throws Exception
+    {
+        PGPPublicKeyRing pgpPub = new PGPPublicKeyRing(testPubKey, new BcKeyFingerprintCalculator());
+        PGPSecretKeyRing pgpSec = new PGPSecretKeyRing(testPrivKey, new BcKeyFingerprintCalculator());
+
+        PGPPublicKey pubKey = pgpPub.getPublicKey();
+
+        PGPUserAttributeSubpacketVectorGenerator vGen = new PGPUserAttributeSubpacketVectorGenerator();
+
+        vGen.setImageAttribute(ImageAttribute.JPEG, jpegImage);
+
+        PGPUserAttributeSubpacketVector uVec = vGen.generate();
+
+        PGPSignatureGenerator sGen = new PGPSignatureGenerator(new BcPGPContentSignerBuilder(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1));
+
+        sGen.init(PGPSignature.POSITIVE_CERTIFICATION, pgpSec.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass)));
+
+        PGPSignature sig = sGen.generateCertification(uVec, pubKey);
+
+        PGPPublicKey nKey = PGPPublicKey.addCertification(pubKey, uVec, sig);
+
+        Iterator it = nKey.getUserAttributes();
+        int count = 0;
+        while (it.hasNext())
+        {
+            PGPUserAttributeSubpacketVector attributes = (PGPUserAttributeSubpacketVector)it.next();
+
+            Iterator    sigs = nKey.getSignaturesForUserAttribute(attributes);
+            int sigCount = 0;
+            while (sigs.hasNext())
+            {
+                PGPSignature s = (PGPSignature)sigs.next();
+
+                s.init(new BcPGPContentVerifierBuilderProvider(), pubKey);
+
+                if (!s.verifyCertification(attributes, pubKey))
+                {
+                    fail("added signature failed verification");
+                }
+
+                sigCount++;
+            }
+
+            if (sigCount != 1)
+            {
+                fail("Failed added user attributes signature check");
+            }
+            count++;
+        }
+
+        if (count != 1)
+        {
+            fail("didn't find added user attributes");
+        }
+
+        nKey = PGPPublicKey.removeCertification(nKey, uVec);
+        count = 0;
+        for (it = nKey.getUserAttributes(); it.hasNext();)
+        {
+            count++;
+        }
+        if (count != 0)
+        {
+            fail("found attributes where none expected");
+        }
+    }
+
+    private void sigsubpacketTest()
+        throws Exception
+    {
+        char[] passPhrase = "test".toCharArray();
+        String identity = "TEST <test@test.org>";
+        Date date = new Date();
+
+        RSAKeyPairGenerator kpg = new RSAKeyPairGenerator();
+        kpg.init(new RSAKeyGenerationParameters(BigInteger.valueOf(0x11), new SecureRandom(), 2048, 25));
+        AsymmetricCipherKeyPair kpSgn = kpg.generateKeyPair();
+        AsymmetricCipherKeyPair kpEnc = kpg.generateKeyPair();
+
+        PGPKeyPair sgnKeyPair = new BcPGPKeyPair(PGPPublicKey.RSA_SIGN, kpSgn, date);
+        PGPKeyPair encKeyPair = new BcPGPKeyPair(PGPPublicKey.RSA_GENERAL, kpEnc, date);
+
+        PGPSignatureSubpacketVector unhashedPcks = null;
+        PGPSignatureSubpacketGenerator svg = new PGPSignatureSubpacketGenerator();
+        svg.setKeyExpirationTime(true, 86400L * 366 * 2);
+        svg.setPrimaryUserID(true, true);
+        int[] encAlgs = {SymmetricKeyAlgorithmTags.AES_256,
+            SymmetricKeyAlgorithmTags.AES_192,
+            SymmetricKeyAlgorithmTags.TRIPLE_DES};
+        svg.setPreferredSymmetricAlgorithms(true, encAlgs);
+        int[] hashAlgs = {HashAlgorithmTags.SHA1,
+            HashAlgorithmTags.SHA512,
+            HashAlgorithmTags.SHA384,
+            HashAlgorithmTags.SHA256,
+            HashAlgorithmTags.RIPEMD160};
+        svg.setPreferredHashAlgorithms(true, hashAlgs);
+        int[] comprAlgs = {CompressionAlgorithmTags.ZLIB,
+            CompressionAlgorithmTags.BZIP2,
+            CompressionAlgorithmTags.ZIP};
+        svg.setPreferredCompressionAlgorithms(true, comprAlgs);
+        svg.setFeature(true, Features.FEATURE_MODIFICATION_DETECTION);
+        svg.setKeyFlags(true, KeyFlags.CERTIFY_OTHER + KeyFlags.SIGN_DATA);
+        PGPSignatureSubpacketVector hashedPcks = svg.generate();
+
+        PGPKeyRingGenerator keyRingGen = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION,
+            sgnKeyPair, identity, new BcPGPDigestCalculatorProvider().get(HashAlgorithmTags.SHA1),
+            hashedPcks, unhashedPcks, new BcPGPContentSignerBuilder(PGPPublicKey.RSA_GENERAL, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256).build(passPhrase));
+
+        svg = new PGPSignatureSubpacketGenerator();
+        svg.setKeyExpirationTime(true, 86400L * 366 * 2);
+        svg.setKeyFlags(true, KeyFlags.ENCRYPT_COMMS + KeyFlags.ENCRYPT_STORAGE);
+        svg.setPrimaryUserID(true, false);
+        svg.setFeature(true, Features.FEATURE_MODIFICATION_DETECTION);
+        hashedPcks = svg.generate();
+
+        keyRingGen.addSubKey(encKeyPair, hashedPcks, unhashedPcks);
+
+        byte[] encodedKeyRing = keyRingGen.generatePublicKeyRing().getEncoded();
+
+        PGPPublicKeyRing keyRing = new PGPPublicKeyRing(encodedKeyRing, new BcKeyFingerprintCalculator());
+
+        for (Iterator it = keyRing.getPublicKeys(); it.hasNext();)
+        {
+            PGPPublicKey pKey = (PGPPublicKey)it.next();
+
+            if (pKey.isEncryptionKey())
+            {
+                for (Iterator sit = pKey.getSignatures(); sit.hasNext();)
+                {
+                    PGPSignature sig = (PGPSignature)sit.next();
+                    PGPSignatureSubpacketVector v = sig.getHashedSubPackets();
+
+                    if (v.getKeyExpirationTime() != 86400L * 366 * 2)
+                    {
+                        fail("key expiration time wrong");
+                    }
+                    if (!v.getFeatures().supportsFeature(Features.FEATURE_MODIFICATION_DETECTION))
+                    {
+                        fail("features wrong");
+                    }
+                    if (v.isPrimaryUserID())
+                    {
+                        fail("primary userID flag wrong");
+                    }
+                    if (v.getKeyFlags() != KeyFlags.ENCRYPT_COMMS + KeyFlags.ENCRYPT_STORAGE)
+                    {
+                        fail("keyFlags wrong");
+                    }
+                }
+            }
+            else
+            {
+                for (Iterator sit = pKey.getSignatures(); sit.hasNext();)
+                {
+                    PGPSignature sig = (PGPSignature)sit.next();
+                    PGPSignatureSubpacketVector v = sig.getHashedSubPackets();
+
+                    if (!Arrays.areEqual(v.getPreferredSymmetricAlgorithms(), encAlgs))
+                    {
+                        fail("preferred encryption algs don't match");
+                    }
+                    if (!Arrays.areEqual(v.getPreferredHashAlgorithms(), hashAlgs))
+                    {
+                        fail("preferred hash algs don't match");
+                    }
+                    if (!Arrays.areEqual(v.getPreferredCompressionAlgorithms(), comprAlgs))
+                    {
+                        fail("preferred compression algs don't match");
+                    }
+                    if (!v.getFeatures().supportsFeature(Features.FEATURE_MODIFICATION_DETECTION))
+                    {
+                        fail("features wrong");
+                    }
+                    if (v.getKeyFlags() != KeyFlags.CERTIFY_OTHER + KeyFlags.SIGN_DATA)
+                    {
+                        fail("keyFlags wrong");
+                    }
+                }
+            }
+        }
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        //
+        // Read the public key
+        //
+        PGPPublicKeyRing        pgpPub = new PGPPublicKeyRing(testPubKey, new BcKeyFingerprintCalculator());
+        AsymmetricKeyParameter  pubKey = new BcPGPKeyConverter().getPublicKey(pgpPub.getPublicKey());
+
+        Iterator    it = pgpPub.getPublicKey().getUserIDs();
+        
+        String    uid = (String)it.next();
+
+        it = pgpPub.getPublicKey().getSignaturesForID(uid);
+        
+        PGPSignature    sig = (PGPSignature)it.next();
+        
+        sig.init(new BcPGPContentVerifierBuilderProvider(), pgpPub.getPublicKey());
+        
+        if (!sig.verifyCertification(uid, pgpPub.getPublicKey()))
+        {
+            fail("failed to verify certification");
+        }
+        
+        //
+        // write a public key
+        //
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        BCPGOutputStream         pOut = new BCPGOutputStream(bOut);
+        
+        pgpPub.encode(pOut);
+
+        if (!areEqual(bOut.toByteArray(), testPubKey))    
+        {
+            fail("public key rewrite failed");
+        }
+        
+        //
+        // Read the public key
+        //
+        PGPPublicKeyRing        pgpPubV3 = new PGPPublicKeyRing(testPubKeyV3, new BcKeyFingerprintCalculator());
+        AsymmetricKeyParameter  pubKeyV3 = new BcPGPKeyConverter().getPublicKey(pgpPub.getPublicKey());
+
+        //
+        // write a V3 public key
+        //
+        bOut = new ByteArrayOutputStream();
+        pOut = new BCPGOutputStream(bOut);
+        
+        pgpPubV3.encode(pOut);
+
+        //
+        // Read a v3 private key
+        //
+        char[]                  passP = "FIXCITY_QA".toCharArray();
+
+        if (!noIDEA())
+        {
+            PGPSecretKeyRing        pgpPriv = new PGPSecretKeyRing(testPrivKeyV3, new BcKeyFingerprintCalculator());
+            PGPPrivateKey           pgpPrivKey = pgpPriv.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passP));
+
+            //
+            // write a v3 private key
+            //
+            bOut = new ByteArrayOutputStream();
+            pOut = new BCPGOutputStream(bOut);
+
+            pgpPriv.encode(pOut);
+
+            if (!areEqual(bOut.toByteArray(), testPrivKeyV3))
+            {
+                fail("private key V3 rewrite failed");
+            }
+        }
+
+        //
+        // Read the private key
+        //
+        PGPSecretKeyRing pgpPriv = new PGPSecretKeyRing(testPrivKey, new BcKeyFingerprintCalculator());
+        PGPPrivateKey pgpPrivKey = pgpPriv.getSecretKey().extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+        
+        //
+        // write a private key
+        //
+        bOut = new ByteArrayOutputStream();
+        pOut = new BCPGOutputStream(bOut);
+        
+        pgpPriv.encode(pOut);
+
+        if (!areEqual(bOut.toByteArray(), testPrivKey))    
+        {
+            fail("private key rewrite failed");
+        }
+        
+
+        //
+        // test encryption
+        //
+        BufferedAsymmetricBlockCipher c = new BufferedAsymmetricBlockCipher(new RSAEngine());
+
+        c.init(true, pubKey);
+        
+        byte[]  in = "hello world".getBytes();
+
+        c.processBytes(in, 0, in.length);
+
+        byte[]  out = c.doFinal();
+        
+        c.init(false, new BcPGPKeyConverter().getPrivateKey(pgpPrivKey));
+
+        c.processBytes(out, 0, out.length);
+
+        out = c.doFinal();
+        
+        if (!areEqual(in, out))
+        {
+            fail("decryption failed.");
+        }
+
+        //
+        // test signature message
+        //
+        PGPObjectFactory           pgpFact = new PGPObjectFactory(sig1, new BcKeyFingerprintCalculator());
+
+//        PGPOnePassSignatureList    p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
+        
+//        PGPOnePassSignature        ops = p1.get(0);
+
+        // compression not supported
+//        PGPLiteralData             p2 = (PGPLiteralData)pgpFact.nextObject();
+//
+//        InputStream                dIn = p2.getInputStream();
+//        int                        ch;
+//
+//        ops.init(new BcPGPContentVerifierBuilderProvider(), pgpPub.getPublicKey(ops.getKeyID()));
+//
+//        while ((ch = dIn.read()) >= 0)
+//        {
+//            ops.update((byte)ch);
+//        }
+//
+//        PGPSignatureList                        p3 = (PGPSignatureList)pgpFact.nextObject();
+//
+//        if (!ops.verify(p3.get(0)))
+//        {
+//            fail("Failed signature check");
+//        }
+//
+        //
+        // encrypted message - read subkey
+        //
+        pgpPriv = new PGPSecretKeyRing(subKey, new BcKeyFingerprintCalculator());
+
+        //
+        // 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(enc1, new BcKeyFingerprintCalculator());
+
+        PGPEncryptedDataList            encList = (PGPEncryptedDataList)pgpF.nextObject();
+    
+        PGPPublicKeyEncryptedData    encP = (PGPPublicKeyEncryptedData)encList.get(0);
+        
+        pgpPrivKey = pgpPriv.getSecretKey(encP.getKeyID()).extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+
+        InputStream clear = encP.getDataStream(new BcPublicKeyDataDecryptorFactory(pgpPrivKey));
+                 
+        pgpFact = new PGPObjectFactory(clear, new BcKeyFingerprintCalculator());
+
+        // compressed data not supported
+//        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();
+//        int ch;
+//
+//        while ((ch = inLd.read()) >= 0)
+//        {
+//            bOut.write(ch);
+//        }
+//
+//        if (!areEqual(bOut.toByteArray(), text))
+//        {
+//            fail("wrong plain text in decrypted packet");
+//        }
+
+        //
+        // encrypt - short message
+        //
+        byte[]    shortText = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' };
+    
+        ByteArrayOutputStream        cbOut = new ByteArrayOutputStream();
+        PGPEncryptedDataGenerator    cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.CAST5).setSecureRandom(new SecureRandom()));
+        PGPPublicKey                 puK = pgpPriv.getSecretKey(encP.getKeyID()).getPublicKey();
+        
+        cPk.addMethod(new BcPublicKeyKeyEncryptionMethodGenerator(puK));
+        
+        OutputStream    cOut = cPk.open(new UncloseableOutputStream(cbOut), shortText.length);
+
+        cOut.write(shortText);
+
+        cOut.close();
+
+        pgpF = new PGPObjectFactory(cbOut.toByteArray(), new BcKeyFingerprintCalculator());
+
+        encList = (PGPEncryptedDataList)pgpF.nextObject();
+    
+        encP = (PGPPublicKeyEncryptedData)encList.get(0);
+        
+        pgpPrivKey = pgpPriv.getSecretKey(encP.getKeyID()).extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+
+        PublicKeyDataDecryptorFactory dataDecryptorFactory = new BcPublicKeyDataDecryptorFactory(pgpPrivKey);
+
+        if (encP.getSymmetricAlgorithm(dataDecryptorFactory) != SymmetricKeyAlgorithmTags.CAST5)
+        {
+            fail("symmetric algorithm mismatch");
+        }
+
+        clear = encP.getDataStream(dataDecryptorFactory);
+        
+        bOut.reset();
+
+        int ch;
+        while ((ch = clear.read()) >= 0)
+        {
+            bOut.write(ch);
+        }
+
+        out = bOut.toByteArray();
+
+        if (!areEqual(out, shortText))
+        {
+            fail("wrong plain text in generated short text packet");
+        }
+        
+        //
+        // encrypt
+        //
+        cbOut = new ByteArrayOutputStream();
+        cPk = new PGPEncryptedDataGenerator(new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.CAST5).setSecureRandom(new SecureRandom()));
+        puK = pgpPriv.getSecretKey(encP.getKeyID()).getPublicKey();
+        
+        cPk.addMethod(new BcPublicKeyKeyEncryptionMethodGenerator(puK));
+
+        cOut = cPk.open(new UncloseableOutputStream(cbOut), text.length);
+
+        cOut.write(text);
+
+        cOut.close();
+
+        pgpF = new PGPObjectFactory(cbOut.toByteArray());
+
+        encList = (PGPEncryptedDataList)pgpF.nextObject();
+    
+        encP = (PGPPublicKeyEncryptedData)encList.get(0);
+        
+        pgpPrivKey = pgpPriv.getSecretKey(encP.getKeyID()).extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pass));
+
+        clear = encP.getDataStream(new BcPublicKeyDataDecryptorFactory(pgpPrivKey));
+        
+        bOut.reset();
+        
+        while ((ch = clear.read()) >= 0)
+        {
+            bOut.write(ch);
+        }
+
+        out = bOut.toByteArray();
+
+        if (!areEqual(out, text))
+        {
+            fail("wrong plain text in generated packet");
+        }
+        
+        //
+        // read public key with sub key.
+        //
+        pgpF = new PGPObjectFactory(subPubKey, new BcKeyFingerprintCalculator());
+        Object    o;
+        
+//        while ((o = pgpFact.nextObject()) != null)
+//        {
+//            // System.out.println(o);
+//        }
+
+        //
+        // key pair generation - CAST5 encryption
+        //
+        char[]                    passPhrase = "hello".toCharArray();
+        
+        RSAKeyPairGenerator       kpg = new RSAKeyPairGenerator();
+    
+        kpg.init(new RSAKeyGenerationParameters(BigInteger.valueOf(0x11), new SecureRandom(), 1024, 25));
+    
+        AsymmetricCipherKeyPair   kp = kpg.generateKeyPair();
+
+        PGPSecretKey    secretKey = new PGPSecretKey(PGPSignature.DEFAULT_CERTIFICATION, new BcPGPKeyPair(PublicKeyAlgorithmTags.RSA_GENERAL, kp, new Date()), "fred", null, null, new BcPGPContentSignerBuilder(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(SymmetricKeyAlgorithmTags.CAST5).build(passPhrase));
+    
+        PGPPublicKey    key = secretKey.getPublicKey();
+
+        it = key.getUserIDs();
+
+        uid = (String)it.next();
+
+        it = key.getSignaturesForID(uid);
+
+        sig = (PGPSignature)it.next();
+
+        sig.init(new BcPGPContentVerifierBuilderProvider(), key);
+
+        if (!sig.verifyCertification(uid, key))
+        {
+            fail("failed to verify certification");
+        }
+
+        pgpPrivKey = secretKey.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase));
+        
+        key = PGPPublicKey.removeCertification(key, uid, sig);
+        
+        if (key == null)
+        {
+            fail("failed certification removal");
+        }
+        
+        byte[]    keyEnc = key.getEncoded();
+        
+        key = PGPPublicKey.addCertification(key, uid, sig);
+        
+        keyEnc = key.getEncoded();
+
+        PGPSignatureGenerator sGen = new PGPSignatureGenerator(new BcPGPContentSignerBuilder(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1));
+        
+        sGen.init(PGPSignature.KEY_REVOCATION, secretKey.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase)));
+
+        sig = sGen.generateCertification(key);
+
+        key = PGPPublicKey.addCertification(key, sig);
+
+        keyEnc = key.getEncoded();
+
+        PGPPublicKeyRing    tmpRing = new PGPPublicKeyRing(keyEnc, new BcKeyFingerprintCalculator());
+
+        key = tmpRing.getPublicKey();
+
+        Iterator            sgIt = key.getSignaturesOfType(PGPSignature.KEY_REVOCATION);
+
+        sig = (PGPSignature)sgIt.next();
+
+        sig.init(new BcPGPContentVerifierBuilderProvider(), key);
+
+        if (!sig.verifyCertification(key))
+        {
+            fail("failed to verify revocation certification");
+        }
+
+        //
+        // use of PGPKeyPair
+        //
+        PGPKeyPair    pgpKp = new BcPGPKeyPair(PGPPublicKey.RSA_GENERAL , kp, new Date());
+        
+        PGPPublicKey k1 = pgpKp.getPublicKey();
+        
+        PGPPrivateKey k2 = pgpKp.getPrivateKey();
+        
+        k1.getEncoded();
+
+        mixedTest(k2, k1);
+
+        //
+        // key pair generation - AES_256 encryption.
+        //
+        kp = kpg.generateKeyPair();
+
+        secretKey = new PGPSecretKey(PGPSignature.DEFAULT_CERTIFICATION, pgpKp, "fred", null, null, new BcPGPContentSignerBuilder(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1), new BcPBESecretKeyEncryptorBuilder(SymmetricKeyAlgorithmTags.AES_256).build(passPhrase));
+    
+        secretKey.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase));
+        
+        secretKey.encode(new ByteArrayOutputStream());
+        
+        //
+        // secret key password changing.
+        //
+        String  newPass = "newPass";
+        
+        secretKey = PGPSecretKey.copyWithNewPassword(secretKey, new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(passPhrase), new BcPBESecretKeyEncryptorBuilder(secretKey.getKeyEncryptionAlgorithm()).build(newPass.toCharArray()));
+        
+        secretKey.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(newPass.toCharArray()));
+        
+        secretKey.encode(new ByteArrayOutputStream());
+        
+        key = secretKey.getPublicKey();
+
+        key.encode(new ByteArrayOutputStream());
+        
+        it = key.getUserIDs();
+
+        uid = (String)it.next();
+
+        it = key.getSignaturesForID(uid);
+
+        sig = (PGPSignature)it.next();
+
+        sig.init(new BcPGPContentVerifierBuilderProvider(), key);
+
+        if (!sig.verifyCertification(uid, key))
+        {
+            fail("failed to verify certification");
+        }
+
+        pgpPrivKey = secretKey.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(newPass.toCharArray()));
+        
+        //
+        // signature generation
+        //
+        String                                data = "hello world!";
+        
+        bOut = new ByteArrayOutputStream();
+        
+        ByteArrayInputStream        testIn = new ByteArrayInputStream(data.getBytes());
+        
+        sGen = new PGPSignatureGenerator(new BcPGPContentSignerBuilder(PublicKeyAlgorithmTags.RSA_GENERAL, HashAlgorithmTags.SHA1));
+    
+        sGen.init(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);
+
+        sGen.generateOnePassVersion(false).encode(bOut);
+
+        PGPLiteralDataGenerator    lGen = new PGPLiteralDataGenerator();
+
+        Date testDate = new Date((System.currentTimeMillis() / 1000) * 1000);
+        OutputStream lOut = lGen.open(
+            new UncloseableOutputStream(bOut),
+            PGPLiteralData.BINARY,
+            "_CONSOLE",
+            data.getBytes().length,
+            testDate);
+
+        while ((ch = testIn.read()) >= 0)
+        {
+            lOut.write(ch);
+            sGen.update((byte)ch);
+        }
+
+        lOut.close();
+
+        sGen.generate().encode(bOut);
+
+        bOut.close();
+
+        //
+        // verify generated signature
+        //
+        pgpFact = new PGPObjectFactory(bOut.toByteArray());
+
+        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: " + p2.getModificationTime() + " " + testDate);
+        }
+
+        InputStream dIn = p2.getInputStream();
+
+        ops.init(new BcPGPContentVerifierBuilderProvider(), secretKey.getPublicKey());
+        
+        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");
+        }
+        
+        //
+        // signature generation - version 3
+        //
+        bOut = new ByteArrayOutputStream();
+        
+        testIn = new ByteArrayInputStream(data.getBytes());
+        PGPV3SignatureGenerator    sGenV3 = new PGPV3SignatureGenerator(new BcPGPContentSignerBuilder(PGPPublicKey.RSA_GENERAL, PGPUtil.SHA1));
+    
+        sGen.init(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);
+
+        sGen.generateOnePassVersion(false).encode(bOut);
+
+        lGen = new PGPLiteralDataGenerator();
+        lOut = lGen.open(
+            new UncloseableOutputStream(bOut),
+            PGPLiteralData.BINARY,
+            "_CONSOLE",
+            data.getBytes().length,
+            testDate);
+
+        while ((ch = testIn.read()) >= 0)
+        {
+            lOut.write(ch);
+            sGen.update((byte)ch);
+        }
+
+        lOut.close();
+
+        sGen.generate().encode(bOut);
+
+        bOut.close();
+
+        //
+        // verify generated signature
+        //
+        pgpFact = new PGPObjectFactory(bOut.toByteArray());
+
+        p1 = (PGPOnePassSignatureList)pgpFact.nextObject();
+        
+        ops = p1.get(0);
+        
+        p2 = (PGPLiteralData)pgpFact.nextObject();
+        if (!p2.getModificationTime().equals(testDate))
+        {
+            fail("Modification time not preserved");
+        }
+
+        dIn = p2.getInputStream();
+
+        ops.init(new BcPGPContentVerifierBuilderProvider(), secretKey.getPublicKey());
+        
+        while ((ch = dIn.read()) >= 0)
+        {
+            ops.update((byte)ch);
+        }
+
+        p3 = (PGPSignatureList)pgpFact.nextObject();
+
+        if (!ops.verify(p3.get(0)))
+        {
+            fail("Failed v3 generated signature check");
+        }
+        
+        //
+        // extract PGP 8 private key
+        //
+        pgpPriv = new PGPSecretKeyRing(pgp8Key, new BcKeyFingerprintCalculator());
+        
+        secretKey = pgpPriv.getSecretKey();
+        
+        pgpPrivKey = secretKey.extractPrivateKey(new BcPBESecretKeyDecryptorBuilder(new BcPGPDigestCalculatorProvider()).build(pgp8Pass));
+
+        //
+        // expiry
+        //
+        testExpiry(expiry60and30daysSig13Key, 60, 30);
+        
+        fingerPrintTest();
+        existingEmbeddedJpegTest();
+        embeddedJpegTest();
+        sigsubpacketTest();
+    }
+    
+    private void testExpiry(
+        byte[]        encodedRing,
+        int           masterDays,
+        int           subKeyDays)
+        throws Exception
+    {            
+        PGPPublicKeyRing pubRing = new PGPPublicKeyRing(encodedRing, new BcKeyFingerprintCalculator());
+        PGPPublicKey k = pubRing.getPublicKey();
+        
+        if (k.getValidDays() != masterDays)
+        {
+            fail("mismatch on master valid days.");
+        }
+        
+        Iterator it = pubRing.getPublicKeys();
+        
+        it.next();
+        
+        k = (PGPPublicKey)it.next();
+        
+        if (k.getValidDays() != subKeyDays)
+        {
+            fail("mismatch on subkey valid days.");
+        }
+    }
+
+    private boolean noIDEA()
+    {
+        return true;
+    }
+
+    public String getName()
+    {
+        return "BcPGPRSATest";
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new BcPGPRSATest());
+    }
+}
diff --git a/crypto/j2me/org/bouncycastle/openpgp/test/RegressionTest.java b/crypto/j2me/org/bouncycastle/openpgp/test/RegressionTest.java
new file mode 100644
index 000000000..23337ce9d
--- /dev/null
+++ b/crypto/j2me/org/bouncycastle/openpgp/test/RegressionTest.java
@@ -0,0 +1,32 @@
+package org.bouncycastle.openpgp.test;
+
+import org.bouncycastle.util.test.Test;
+import org.bouncycastle.util.test.TestResult;
+
+public class RegressionTest
+{
+    public static Test[]    tests = {
+        new BcPGPDSAElGamalTest(),
+        new BcPGPDSATest(),
+        new BcPGPKeyRingTest(),
+        new BcPGPPBETest(),
+        new BcPGPRSATest()
+    };
+
+    public static void main(
+        String[]    args)
+    {
+        for (int i = 0; i != tests.length; i++)
+        {
+            TestResult  result = tests[i].perform();
+            
+            if (result.getException() != null)
+            {
+                result.getException().printStackTrace();
+            }
+            
+            System.out.println(result);
+        }
+    }
+}
+