diff --git a/bcpkix/src/main/java/org/bouncycastle/cert/CertUtils.java b/bcpkix/src/main/java/org/bouncycastle/cert/CertUtils.java
index 9e2e488..87cddd9 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cert/CertUtils.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cert/CertUtils.java
@@ -15,6 +15,7 @@
 import org.bouncycastle.asn1.ASN1EncodableVector;
 import org.bouncycastle.asn1.ASN1GeneralizedTime;
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
 import org.bouncycastle.asn1.DERBitString;
 import org.bouncycastle.asn1.DERNull;
 import org.bouncycastle.asn1.DEROutputStream;
@@ -35,6 +36,18 @@
     private static Set EMPTY_SET = Collections.unmodifiableSet(new HashSet());
     private static List EMPTY_LIST = Collections.unmodifiableList(new ArrayList());
 
+    static ASN1Primitive parseNonEmptyASN1(byte[] encoding)
+        throws IOException
+    {
+        ASN1Primitive p = ASN1Primitive.fromByteArray(encoding);
+
+        if (p == null)
+        {
+            throw new IOException("no content found");
+        }
+        return p;
+    }
+
     static X509CertificateHolder generateFullCert(ContentSigner signer, TBSCertificate tbsCert)
     {
         try
diff --git a/bcpkix/src/main/java/org/bouncycastle/cert/X509AttributeCertificateHolder.java b/bcpkix/src/main/java/org/bouncycastle/cert/X509AttributeCertificateHolder.java
index e6b0d7e..fac9b44 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cert/X509AttributeCertificateHolder.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cert/X509AttributeCertificateHolder.java
@@ -9,7 +9,6 @@
 import java.util.Set;
 
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
-import org.bouncycastle.asn1.ASN1Primitive;
 import org.bouncycastle.asn1.ASN1Sequence;
 import org.bouncycastle.asn1.DEROutputStream;
 import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
@@ -39,7 +38,7 @@
     {
         try
         {
-            return AttributeCertificate.getInstance(ASN1Primitive.fromByteArray(certEncoding));
+            return AttributeCertificate.getInstance(CertUtils.parseNonEmptyASN1(certEncoding));
         }
         catch (ClassCastException e)
         {
diff --git a/bcpkix/src/main/java/org/bouncycastle/cert/X509CRLHolder.java b/bcpkix/src/main/java/org/bouncycastle/cert/X509CRLHolder.java
index 4b773e2..67abd31 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cert/X509CRLHolder.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cert/X509CRLHolder.java
@@ -13,6 +13,7 @@
 
 import org.bouncycastle.asn1.ASN1InputStream;
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
 import org.bouncycastle.asn1.DEROutputStream;
 import org.bouncycastle.asn1.x500.X500Name;
 import org.bouncycastle.asn1.x509.CertificateList;
@@ -42,7 +43,12 @@
     {
         try
         {
-            return CertificateList.getInstance(new ASN1InputStream(stream, true).readObject());
+            ASN1Primitive obj = new ASN1InputStream(stream, true).readObject();
+            if (obj == null)
+            {
+                throw new IOException("no content found");
+            }
+            return CertificateList.getInstance(obj);
         }
         catch (ClassCastException e)
         {
diff --git a/bcpkix/src/main/java/org/bouncycastle/cert/X509CertificateHolder.java b/bcpkix/src/main/java/org/bouncycastle/cert/X509CertificateHolder.java
index b5ad578..2396aac 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cert/X509CertificateHolder.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cert/X509CertificateHolder.java
@@ -8,7 +8,6 @@
 import java.util.Set;
 
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
-import org.bouncycastle.asn1.ASN1Primitive;
 import org.bouncycastle.asn1.DEROutputStream;
 import org.bouncycastle.asn1.x500.X500Name;
 import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
@@ -35,7 +34,7 @@
     {
         try
         {
-            return Certificate.getInstance(ASN1Primitive.fromByteArray(certEncoding));
+            return Certificate.getInstance(CertUtils.parseNonEmptyASN1(certEncoding));
         }
         catch (ClassCastException e)
         {
diff --git a/bcpkix/src/main/java/org/bouncycastle/cert/test/CertPathLoopTest.java b/bcpkix/src/main/java/org/bouncycastle/cert/test/CertPathLoopTest.java
index b7d1fd2..91314b1 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cert/test/CertPathLoopTest.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cert/test/CertPathLoopTest.java
@@ -1,304 +1,304 @@
-package org.bouncycastle.cert.test;
-
-import java.math.BigInteger;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
-import java.security.NoSuchAlgorithmException;
-import java.security.PublicKey;
-import java.security.Security;
-import java.security.cert.CertPathBuilder;
-import java.security.cert.CertPathBuilderException;
-import java.security.cert.CertPathBuilderResult;
-import java.security.cert.CertStore;
-import java.security.cert.CertStoreParameters;
-import java.security.cert.CollectionCertStoreParameters;
-import java.security.cert.PKIXBuilderParameters;
-import java.security.cert.TrustAnchor;
-import java.security.cert.X509CRL;
-import java.security.cert.X509CertSelector;
-import java.security.cert.X509Certificate;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.GregorianCalendar;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.bouncycastle.asn1.x500.X500Name;
-import org.bouncycastle.asn1.x509.BasicConstraints;
-import org.bouncycastle.asn1.x509.Extension;
-import org.bouncycastle.asn1.x509.KeyUsage;
-import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
-import org.bouncycastle.cert.X509CRLHolder;
-import org.bouncycastle.cert.X509CertificateHolder;
-import org.bouncycastle.cert.X509v2CRLBuilder;
-import org.bouncycastle.cert.X509v3CertificateBuilder;
-import org.bouncycastle.cert.jcajce.JcaX509CRLConverter;
-import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
-import org.bouncycastle.jce.provider.BouncyCastleProvider;
-import org.bouncycastle.operator.ContentSigner;
-import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
-import org.bouncycastle.util.test.SimpleTest;
-
-
-/**
- * BC bug test case.
- */
-public class CertPathLoopTest
-    extends SimpleTest
-{
-    /**
-     * List of trust anchors
-     */
-    private static Set<TrustAnchor> taSet;
-    /**
-     * List of certificates and CRLs
-     */
-    private static List<Object> otherList;
-
-    /**
-     * Asks the user about the configuration he want's to test
-     *
-     * @param caA
-     * @param caB
-     */
-    private static void checkUseDistinctCAs(CA caA, CA caB)
-    {
-        //Standard configuration : everything in caA
-        taSet = new HashSet<TrustAnchor>();
-        taSet.add(caA.ta);
-        otherList = new ArrayList<Object>();
-        otherList.add(caA.acCertCrl);
-        otherList.add(caA.crl);
-        //User specified configuration : parts of caB
-
-        taSet.add(caB.ta);
-        otherList.add(caB.acCertCrl);
-        otherList.add(caB.crl);
-    }
-
-    /**
-     * Creates a collection cert store
-     */
-    static CertStore getStore(Collection col)
-        throws InvalidAlgorithmParameterException, NoSuchAlgorithmException
-    {
-        CertStoreParameters csp = new CollectionCertStoreParameters(col);
-        return CertStore.getInstance("Collection", csp);
-    }
-
-    public String getName()
-    {
-        return "CertPath Loop Test";
-    }
-
-    public void performTest()
-        throws Exception
-    {
-              //Add the provider
-        Security.addProvider(new BouncyCastleProvider());
-        //Generate two Cert authorities
-        CA caA = new CA();
-        CA caB = new CA();
-        //Ask the user the conf he want's to test
-        checkUseDistinctCAs(caA, caB);
-
-        //Let's create a target cert under caA
-        X509CertSelector target = new X509CertSelector();
-        target.setCertificate(caA.makeNewCert());
-        //create control parameters
-        PKIXBuilderParameters params = new PKIXBuilderParameters(taSet, target);
-        params.addCertStore(getStore(Collections.singleton(target.getCertificate())));
-        params.addCertStore(getStore(otherList));
-        //enable revocation check
-        params.setRevocationEnabled(true);
-
-        //Lets Build the path
-        try
-        {
-            CertPathBuilderResult cpbr = CertPathBuilder.getInstance("PKIX", "BC").build(params);
-
-            fail("invalid path build");
-        }
-        catch (CertPathBuilderException e)
-        {
-            if (!e.getCause().getMessage().equals("CertPath for CRL signer failed to validate."))
-            {
-                fail("Exception thrown, but wrong one", e.getCause());
-            }
-        }
-    }
-
-    /**
-     * Class simulating a certification authority
-     */
-    private static class CA
-    {
-        /**
-         * key pair generator
-         */
-        final static KeyPairGenerator kpg;
-
-        static
-        {
-            try
-            {
-                kpg = KeyPairGenerator.getInstance("RSA");
-                //Key size doesn't matter, smaller == Faster
-                kpg.initialize(512);
-            }
-            catch (NoSuchAlgorithmException e)
-            {
-                throw new RuntimeException(e);
-            }
-        }
-
-        /**
-         * KeyPair signing certificates
-         */
-        private KeyPair caCertKp;
-        /**
-         * KeyPair signing CRLs
-         */
-        private KeyPair caCrlKp;
-        TrustAnchor ta;
-        /**
-         * Subject of this CA
-         */
-        X500Name acSubject;
-        /**
-         * Certificate signing certificates
-         */
-        X509Certificate acCertAc;
-        /**
-         * Certificate signing CRLs
-         */
-        X509Certificate acCertCrl;
-        /**
-         * the CRL
-         */
-        X509CRL crl;
-        /**
-         * Signers
-         */
-        private ContentSigner caCrlSigner, caCertSigner;
-        /**
-         * Serial number counter
-         */
-        private int counter = 1;
-
-        /**
-         * Constructor
-         */
-        public CA()
-            throws Exception
-        {
-            //Init both keypairs
-            caCertKp = kpg.generateKeyPair();
-            caCrlKp = kpg.generateKeyPair();
-            //subject
-            acSubject = new X500Name("CN=AC_0");
-            //validity
-            GregorianCalendar gc = new GregorianCalendar();
-            Date notBefore = gc.getTime();
-            gc.add(GregorianCalendar.DAY_OF_YEAR, 1);
-            Date notAfter = gc.getTime();
-            //first signer
-            caCertSigner = new JcaContentSignerBuilder("SHA1withRSA").build(caCertKp.getPrivate());
-            //top level : issuer is self
-            X500Name issuer = acSubject;
-            //reserved for future use (another test case)
-            ContentSigner thisAcSigner = caCertSigner;
-            //reserved for future use (another test case)
-            //First certificate: Certificate authority (BasicConstraints=true) but not CRLSigner
-            X509CertificateHolder certH = new X509v3CertificateBuilder(
-                issuer, BigInteger.valueOf(counter++), notBefore, notAfter, acSubject, getPublicKeyInfo(caCertKp.getPublic()))
-                .addExtension(Extension.basicConstraints, true, new BasicConstraints(true))
-                .addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.keyCertSign))
-                .build(thisAcSigner);
-            //lets convert to X509Certificate
-            acCertAc = convert(certH);
-            //and build a trust Anchor
-            ta = new TrustAnchor(acCertAc, null);
-
-            //Second signer
-            caCrlSigner = new JcaContentSignerBuilder("SHA1withRSA").build(caCrlKp.getPrivate());
-            //second certificate: CRLSigner but not Certificate authority (BasicConstraints=false)
-            certH = new X509v3CertificateBuilder(
-                issuer, BigInteger.valueOf(counter++), notBefore, notAfter, acSubject, getPublicKeyInfo(caCrlKp.getPublic()))
-                .addExtension(Extension.basicConstraints, false, new BasicConstraints(false))
-                .addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.cRLSign))
-                .build(thisAcSigner);
-            //lets convert to X509Certificate
-            acCertCrl = convert(certH);
-            //And create the CRL
-            X509CRLHolder crlH = new X509v2CRLBuilder(acSubject, notBefore).setNextUpdate(notAfter).build(caCrlSigner);
-            //lets convert to X509CRL
-            crl = convert(crlH);
-        }
-
-        /**
-         * Creates a child certificate
-         */
-        public X509Certificate makeNewCert()
-            throws Exception
-        {
-            //private key doesn't matter for the test
-            PublicKey publicKey = kpg.generateKeyPair().getPublic();
-            //Validity
-            GregorianCalendar gc = new GregorianCalendar();
-            Date notBefore = gc.getTime();
-            gc.add(GregorianCalendar.DAY_OF_YEAR, 1);
-            Date notAfter = gc.getTime();
-            //serial
-            BigInteger certSerial = BigInteger.valueOf(counter++);
-            //Distinct name based on the serial
-            X500Name subject = new X500Name("CN=EU_" + certSerial.toString());
-            //End user certificate, not allowed to do anything
-            X509CertificateHolder enUserCertH = new X509v3CertificateBuilder(
-                acSubject, certSerial, notBefore, notAfter, subject, getPublicKeyInfo(publicKey))
-                .addExtension(Extension.basicConstraints, false, new BasicConstraints(false))
-                .addExtension(Extension.keyUsage, true, new KeyUsage(0))
-                .build(caCertSigner);
-
-            //lets convert to X509Certificate
-            return convert(enUserCertH);
-        }
-
-
-        /**
-         * convert to X509Certificate
-         */
-        static X509Certificate convert(X509CertificateHolder h)
-            throws Exception
-        {
-            return new JcaX509CertificateConverter().getCertificate(h);
-        }
-
-        /**
-         * convert to X509CRL
-         */
-        static X509CRL convert(X509CRLHolder h)
-            throws Exception
-        {
-            return new JcaX509CRLConverter().getCRL(h);
-        }
-
-        /**
-         * convert to SubjectPublicKeyInfo
-         */
-        static SubjectPublicKeyInfo getPublicKeyInfo(PublicKey k)
-            throws Exception
-        {
-            return SubjectPublicKeyInfo.getInstance(k.getEncoded());
-        }
-    }
-
-    public static void main(String[] args)
-    {
-        runTest(new CertPathLoopTest());
-    }
-}
+package org.bouncycastle.cert.test;
+
+import java.math.BigInteger;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.security.PublicKey;
+import java.security.Security;
+import java.security.cert.CertPathBuilder;
+import java.security.cert.CertPathBuilderException;
+import java.security.cert.CertPathBuilderResult;
+import java.security.cert.CertStore;
+import java.security.cert.CertStoreParameters;
+import java.security.cert.CollectionCertStoreParameters;
+import java.security.cert.PKIXBuilderParameters;
+import java.security.cert.TrustAnchor;
+import java.security.cert.X509CRL;
+import java.security.cert.X509CertSelector;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x509.BasicConstraints;
+import org.bouncycastle.asn1.x509.Extension;
+import org.bouncycastle.asn1.x509.KeyUsage;
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
+import org.bouncycastle.cert.X509CRLHolder;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cert.X509v2CRLBuilder;
+import org.bouncycastle.cert.X509v3CertificateBuilder;
+import org.bouncycastle.cert.jcajce.JcaX509CRLConverter;
+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+/**
+ * BC bug test case.
+ */
+public class CertPathLoopTest
+    extends SimpleTest
+{
+    /**
+     * List of trust anchors
+     */
+    private static Set<TrustAnchor> taSet;
+    /**
+     * List of certificates and CRLs
+     */
+    private static List<Object> otherList;
+
+    /**
+     * Asks the user about the configuration he want's to test
+     *
+     * @param caA
+     * @param caB
+     */
+    private static void checkUseDistinctCAs(CA caA, CA caB)
+    {
+        //Standard configuration : everything in caA
+        taSet = new HashSet<TrustAnchor>();
+        taSet.add(caA.ta);
+        otherList = new ArrayList<Object>();
+        otherList.add(caA.acCertCrl);
+        otherList.add(caA.crl);
+        //User specified configuration : parts of caB
+
+        taSet.add(caB.ta);
+        otherList.add(caB.acCertCrl);
+        otherList.add(caB.crl);
+    }
+
+    /**
+     * Creates a collection cert store
+     */
+    static CertStore getStore(Collection col)
+        throws InvalidAlgorithmParameterException, NoSuchAlgorithmException
+    {
+        CertStoreParameters csp = new CollectionCertStoreParameters(col);
+        return CertStore.getInstance("Collection", csp);
+    }
+
+    public String getName()
+    {
+        return "CertPath Loop Test";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+              //Add the provider
+        Security.addProvider(new BouncyCastleProvider());
+        //Generate two Cert authorities
+        CA caA = new CA();
+        CA caB = new CA();
+        //Ask the user the conf he want's to test
+        checkUseDistinctCAs(caA, caB);
+
+        //Let's create a target cert under caA
+        X509CertSelector target = new X509CertSelector();
+        target.setCertificate(caA.makeNewCert());
+        //create control parameters
+        PKIXBuilderParameters params = new PKIXBuilderParameters(taSet, target);
+        params.addCertStore(getStore(Collections.singleton(target.getCertificate())));
+        params.addCertStore(getStore(otherList));
+        //enable revocation check
+        params.setRevocationEnabled(true);
+
+        //Lets Build the path
+        try
+        {
+            CertPathBuilderResult cpbr = CertPathBuilder.getInstance("PKIX", "BC").build(params);
+
+            fail("invalid path build");
+        }
+        catch (CertPathBuilderException e)
+        {
+            if (!e.getCause().getMessage().equals("CertPath for CRL signer failed to validate."))
+            {
+                fail("Exception thrown, but wrong one", e.getCause());
+            }
+        }
+    }
+
+    /**
+     * Class simulating a certification authority
+     */
+    private static class CA
+    {
+        /**
+         * key pair generator
+         */
+        final static KeyPairGenerator kpg;
+
+        static
+        {
+            try
+            {
+                kpg = KeyPairGenerator.getInstance("RSA");
+                //Key size doesn't matter, smaller == Faster
+                kpg.initialize(512);
+            }
+            catch (NoSuchAlgorithmException e)
+            {
+                throw new RuntimeException(e);
+            }
+        }
+
+        /**
+         * KeyPair signing certificates
+         */
+        private KeyPair caCertKp;
+        /**
+         * KeyPair signing CRLs
+         */
+        private KeyPair caCrlKp;
+        TrustAnchor ta;
+        /**
+         * Subject of this CA
+         */
+        X500Name acSubject;
+        /**
+         * Certificate signing certificates
+         */
+        X509Certificate acCertAc;
+        /**
+         * Certificate signing CRLs
+         */
+        X509Certificate acCertCrl;
+        /**
+         * the CRL
+         */
+        X509CRL crl;
+        /**
+         * Signers
+         */
+        private ContentSigner caCrlSigner, caCertSigner;
+        /**
+         * Serial number counter
+         */
+        private int counter = 1;
+
+        /**
+         * Constructor
+         */
+        public CA()
+            throws Exception
+        {
+            //Init both keypairs
+            caCertKp = kpg.generateKeyPair();
+            caCrlKp = kpg.generateKeyPair();
+            //subject
+            acSubject = new X500Name("CN=AC_0");
+            //validity
+            GregorianCalendar gc = new GregorianCalendar();
+            Date notBefore = gc.getTime();
+            gc.add(GregorianCalendar.DAY_OF_YEAR, 1);
+            Date notAfter = gc.getTime();
+            //first signer
+            caCertSigner = new JcaContentSignerBuilder("SHA1withRSA").build(caCertKp.getPrivate());
+            //top level : issuer is self
+            X500Name issuer = acSubject;
+            //reserved for future use (another test case)
+            ContentSigner thisAcSigner = caCertSigner;
+            //reserved for future use (another test case)
+            //First certificate: Certificate authority (BasicConstraints=true) but not CRLSigner
+            X509CertificateHolder certH = new X509v3CertificateBuilder(
+                issuer, BigInteger.valueOf(counter++), notBefore, notAfter, acSubject, getPublicKeyInfo(caCertKp.getPublic()))
+                .addExtension(Extension.basicConstraints, true, new BasicConstraints(true))
+                .addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.keyCertSign))
+                .build(thisAcSigner);
+            //lets convert to X509Certificate
+            acCertAc = convert(certH);
+            //and build a trust Anchor
+            ta = new TrustAnchor(acCertAc, null);
+
+            //Second signer
+            caCrlSigner = new JcaContentSignerBuilder("SHA1withRSA").build(caCrlKp.getPrivate());
+            //second certificate: CRLSigner but not Certificate authority (BasicConstraints=false)
+            certH = new X509v3CertificateBuilder(
+                issuer, BigInteger.valueOf(counter++), notBefore, notAfter, acSubject, getPublicKeyInfo(caCrlKp.getPublic()))
+                .addExtension(Extension.basicConstraints, false, new BasicConstraints(false))
+                .addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.cRLSign))
+                .build(thisAcSigner);
+            //lets convert to X509Certificate
+            acCertCrl = convert(certH);
+            //And create the CRL
+            X509CRLHolder crlH = new X509v2CRLBuilder(acSubject, notBefore).setNextUpdate(notAfter).build(caCrlSigner);
+            //lets convert to X509CRL
+            crl = convert(crlH);
+        }
+
+        /**
+         * Creates a child certificate
+         */
+        public X509Certificate makeNewCert()
+            throws Exception
+        {
+            //private key doesn't matter for the test
+            PublicKey publicKey = kpg.generateKeyPair().getPublic();
+            //Validity
+            GregorianCalendar gc = new GregorianCalendar();
+            Date notBefore = gc.getTime();
+            gc.add(GregorianCalendar.DAY_OF_YEAR, 1);
+            Date notAfter = gc.getTime();
+            //serial
+            BigInteger certSerial = BigInteger.valueOf(counter++);
+            //Distinct name based on the serial
+            X500Name subject = new X500Name("CN=EU_" + certSerial.toString());
+            //End user certificate, not allowed to do anything
+            X509CertificateHolder enUserCertH = new X509v3CertificateBuilder(
+                acSubject, certSerial, notBefore, notAfter, subject, getPublicKeyInfo(publicKey))
+                .addExtension(Extension.basicConstraints, false, new BasicConstraints(false))
+                .addExtension(Extension.keyUsage, true, new KeyUsage(0))
+                .build(caCertSigner);
+
+            //lets convert to X509Certificate
+            return convert(enUserCertH);
+        }
+
+
+        /**
+         * convert to X509Certificate
+         */
+        static X509Certificate convert(X509CertificateHolder h)
+            throws Exception
+        {
+            return new JcaX509CertificateConverter().getCertificate(h);
+        }
+
+        /**
+         * convert to X509CRL
+         */
+        static X509CRL convert(X509CRLHolder h)
+            throws Exception
+        {
+            return new JcaX509CRLConverter().getCRL(h);
+        }
+
+        /**
+         * convert to SubjectPublicKeyInfo
+         */
+        static SubjectPublicKeyInfo getPublicKeyInfo(PublicKey k)
+            throws Exception
+        {
+            return SubjectPublicKeyInfo.getInstance(k.getEncoded());
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new CertPathLoopTest());
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/cert/test/CertTest.java b/bcpkix/src/main/java/org/bouncycastle/cert/test/CertTest.java
index 9706af2..2b0af04 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cert/test/CertTest.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cert/test/CertTest.java
@@ -61,6 +61,7 @@
 import org.bouncycastle.asn1.x509.KeyPurposeId;
 import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
 import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;
+import org.bouncycastle.cert.X509AttributeCertificateHolder;
 import org.bouncycastle.cert.X509CRLEntryHolder;
 import org.bouncycastle.cert.X509CRLHolder;
 import org.bouncycastle.cert.X509CertificateHolder;
@@ -81,6 +82,7 @@
 import org.bouncycastle.jce.X509Principal;
 import org.bouncycastle.jce.interfaces.ECPointEncoder;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jce.spec.ECNamedCurveGenParameterSpec;
 import org.bouncycastle.jce.spec.ECParameterSpec;
 import org.bouncycastle.jce.spec.ECPrivateKeySpec;
 import org.bouncycastle.jce.spec.ECPublicKeySpec;
@@ -1184,6 +1186,47 @@
       + "hlkk5VbZb4D/Cv4HxrdxpJfy/ewUZR7uHlzDx0/m4qjzNzWgq+sh3ZbveDrV"
       + "wd/FDMFOxSIno9qgHtdfgXRwZJ+l07fF");
 
+    private static byte[] sm_root = Base64.decode(
+        "MIICwzCCAmmgAwIBAgIIIBQGIgAAAAMwCgYIKoEcz1UBg3UwgdgxCzAJBgNVBAYT" +
+            "AkNOMRIwEAYDVQQIDAnmsZ/oi4/nnIExEjAQBgNVBAcMCeWNl+S6rOW4gjE8MDoG" +
+            "A1UECgwz5rGf6IuP55yB55S15a2Q5ZWG5Yqh5pyN5Yqh5Lit5b+D5pyJ6ZmQ6LSj" +
+            "5Lu75YWs5Y+4MUswSQYDVQQLDELmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHk" +
+            "uK3lv4PmnInpmZDotKPku7vlhazlj7jlronlhajkuovkuJrpg6gxFjAUBgNVBAMM" +
+            "DUpTQ0FfUk9PVF9TTTIwHhcNMTQwNjIyMDQ1MzAyWhcNMzQwNjIyMDQ1MzAyWjCB" +
+            "1jELMAkGA1UEBhMCQ04xEjAQBgNVBAgMCeaxn+iLj+ecgTESMBAGA1UEBwwJ5Y2X" +
+            "5Lqs5biCMTwwOgYDVQQKDDPmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHkuK3l" +
+            "v4PmnInpmZDotKPku7vlhazlj7gxSzBJBgNVBAsMQuaxn+iLj+ecgeeUteWtkOWV" +
+            "huWKoeacjeWKoeS4reW/g+aciemZkOi0o+S7u+WFrOWPuOWuieWFqOS6i+S4mumD" +
+            "qDEUMBIGA1UEAwwLSlNDQV9DQV9TTTIwWTATBgcqhkjOPQIBBggqgRzPVQGCLQNC" +
+            "AAS/gvW90+LvyXPgpR7L0pwlVoZQdan7V5YQMEpxt47tzer31/8WJIfldx9NL/1A" +
+            "swkk6ItveCVW5k0u+IIk6crLox0wGzAMBgNVHRMEBTADAQH/MAsGA1UdDwQEAwIB" +
+            "BjAKBggqgRzPVQGDdQNIADBFAiEAy9NkogihHCj9Jx0ZiHdkMyCHF0wHWX58KZco" +
+            "CW5mjbgCIC9cAyuVV91ygLWk14PDuIAPFWKm6rJPXbiZL6KzwHQA");
+
+    private static byte[] sm_sign = Base64.decode(
+        "MIID9zCCA5ygAwIBAgIIIBcEJwKSCCMwCgYIKoEcz1UBg3UwgccxCzAJBgNVBAYT" +
+        "AkNOMRIwEAYDVQQIDAnmsZ/oi4/nnIExEjAQBgNVBAcMCeWNl+S6rOW4gjE8MDoG" +
+        "A1UECgwz5rGf6IuP55yB55S15a2Q5ZWG5Yqh5pyN5Yqh5Lit5b+D5pyJ6ZmQ6LSj" +
+        "5Lu75YWs5Y+4MTwwOgYDVQQLDDPmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHk" +
+        "uK3lv4PmnInpmZDotKPku7vlhazlj7gxFDASBgNVBAMMC0pTQ0FfQ0FfU00yMB4X" +
+        "DTE3MDQyNzAwMzkwNVoXDTE4MDQyNzAwMzkwNVowggEdMQ4wDAYDVQRYDAUwMDAw" +
+        "MTESMBAGA1UEGgwJ5biC6L6W5Yy6MRswGQYDVQQBDBIzMjAxMTIxOTgxMDUxMTAw" +
+        "MTQxDTALBgRVBIhYDAM0NTYxDTALBgRVBIhXDAMxMjMxEjAQBgNVBC0MCXVzZXJD" +
+        "ZXJ0MjELMAkGA1UEBhMCQ04xEjAQBgNVBAgMCeaxn+iLj+ecgTESMBAGA1UEBwwJ" +
+        "5Y2X5Lqs5biCMQwwCgYDVQQLDAMwMDgxHzAdBgkqhkiG9w0BCQEWEDMyNzMyMTU2" +
+        "OEBxcS5jb20xITAfBgNVBCoMGOa1i+ivlee9keWFs1NNMueul+azlTEyMzEhMB8G" +
+        "A1UEAwwY5rWL6K+V572R5YWzU00y566X5rOVMTIzMFkwEwYHKoZIzj0CAQYIKoEc" +
+        "z1UBgi0DQgAEdbrBzy2y8Gz4grOF23iaDipPhRPQRApAMIAP0cAuL1tATFjFuWJs" +
+        "pBc1cnCZmsOJnVpV4W7VF8hNOaqv3Tq4NqOCARcwggETMAkGA1UdEwQCMAAwCwYD" +
+        "VR0PBAQDAgbAMB0GA1UdDgQWBBRsWSOQDniy75t7UEvTXugwfq0HpzAfBgNVHSME" +
+        "GDAWgBT/02hyCI7lesT55ixTRU6RpLF6AzAxBgNVHSUEKjAoBggrBgEFBQcDAgYI" +
+        "KwYBBQUHAwgGCCsGAQUFBwMEBggrBgEFBQcDCDA9BgNVHR8ENjA0MDKgMKAuhixo" +
+        "dHRwOi8vY3JsLmpzY2EuY29tLmNuL2NybC9TTTJDUkxfRU5USVRZLmNybDBHBggr" +
+        "BgEFBQcBAQQ7MDkwNwYIKwYBBQUHMAKBK2h0dHA6Ly8xMC4xMDguNS4yOjg4ODAv" +
+        "ZG93bmxvYWQvSlNDQV9DQS5jZXIwCgYIKoEcz1UBg3UDSQAwRgIhALFoMoA1+uO4" +
+        "tXfmoyePz1pmv0CWPBgEP1EfDeS6FPitAiEAjHJYq7ryHKULqpRg6ph9r+xUDoWd" +
+        "0TPMOQ9jj4XJPO4=");
+
     private PublicKey dudPublicKey = new PublicKey()
     {
         public String getAlgorithm()
@@ -1656,6 +1699,72 @@
         }
     }
 
+    /**
+     * we generate a self signed certificate for the sake of testing - DSA
+     */
+    public void checkSm3WithSm2Creation()
+        throws Exception
+    {
+        //
+        // set up the keys
+        //
+        PrivateKey privKey;
+        PublicKey pubKey;
+
+        try
+        {
+            KeyPairGenerator g = KeyPairGenerator.getInstance("EC", "BC");
+
+            g.initialize(new ECNamedCurveGenParameterSpec("sm2p256v1"));
+
+            KeyPair p = g.generateKeyPair();
+
+            privKey = p.getPrivate();
+            pubKey = p.getPublic();
+        }
+        catch (Exception e)
+        {
+            fail("error setting up keys - " + e.toString());
+            return;
+        }
+
+        //
+        // distinguished name table.
+        //
+        X500NameBuilder builder = createStdBuilder();
+
+        //
+        // extensions
+        //
+
+        //
+        // create the certificate - version 1
+        //
+
+        ContentSigner sigGen = new JcaContentSignerBuilder("SM3withSM2").setProvider(BC).build(privKey);
+        JcaX509v1CertificateBuilder certGen = new JcaX509v1CertificateBuilder(
+            builder.build(),
+            BigInteger.valueOf(1),
+            new Date(System.currentTimeMillis() - 50000),
+            new Date(System.currentTimeMillis() + 50000),
+            builder.build(),
+            pubKey);
+
+
+        X509Certificate cert = new JcaX509CertificateConverter().setProvider(BC).getCertificate(certGen.build(sigGen));
+
+        cert.checkValidity(new Date());
+
+        cert.verify(pubKey);
+
+        ByteArrayInputStream bIn = new ByteArrayInputStream(cert.getEncoded());
+        CertificateFactory fact = CertificateFactory.getInstance("X.509", BC);
+
+        cert = (X509Certificate)fact.generateCertificate(bIn);
+
+        // System.out.println(cert);
+    }
+
     private void checkComparison(byte[] encCert)
         throws NoSuchProviderException, CertificateException
     {
@@ -3042,6 +3151,37 @@
         }
     }
 
+    private void zeroDataTest()
+        throws Exception
+    {
+        try
+        {
+            new X509CertificateHolder(new byte[0]);
+        }
+        catch (IOException e)
+        {
+            isTrue("no content found".equals(e.getMessage()));
+        }
+
+        try
+        {
+            new X509AttributeCertificateHolder(new byte[0]);
+        }
+        catch (IOException e)
+        {
+            isTrue("no content found".equals(e.getMessage()));
+        }
+
+        try
+        {
+            new X509CRLHolder(new byte[0]);
+        }
+        catch (IOException e)
+        {
+            isTrue("no content found".equals(e.getMessage()));
+        }
+    }
+
     public void performTest()
         throws Exception
     {
@@ -3085,6 +3225,8 @@
 
         checkCreation6();
 
+        checkSm3WithSm2Creation();
+
         createECCert("SHA1withECDSA", X9ObjectIdentifiers.ecdsa_with_SHA1);
         createECCert("SHA224withECDSA", X9ObjectIdentifiers.ecdsa_with_SHA224);
         createECCert("SHA256withECDSA", X9ObjectIdentifiers.ecdsa_with_SHA256);
@@ -3109,6 +3251,8 @@
         testNullDerNullCert();
 
         checkCertificate(18, emptyDNCert);
+
+        zeroDataTest();
     }
 
     private Extensions generateExtensions(Vector oids, Vector values)
diff --git a/bcpkix/src/main/java/org/bouncycastle/cmc/CMCException.java b/bcpkix/src/main/java/org/bouncycastle/cmc/CMCException.java
new file mode 100644
index 0000000..eaa1294
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/cmc/CMCException.java
@@ -0,0 +1,23 @@
+package org.bouncycastle.cmc;
+
+public class CMCException
+    extends Exception
+{
+    private final Throwable cause;
+
+    public CMCException(String msg)
+    {
+        this(msg, null);
+    }
+
+    public CMCException(String msg, Throwable cause)
+    {
+        super(msg);
+        this.cause = cause;
+    }
+
+    public Throwable getCause()
+    {
+        return cause;
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/cmc/SimplePKIResponse.java b/bcpkix/src/main/java/org/bouncycastle/cmc/SimplePKIResponse.java
new file mode 100644
index 0000000..23f70d6
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/cmc/SimplePKIResponse.java
@@ -0,0 +1,106 @@
+package org.bouncycastle.cmc;
+
+import java.io.IOException;
+
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.cert.X509CRLHolder;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cms.CMSException;
+import org.bouncycastle.cms.CMSSignedData;
+import org.bouncycastle.util.Encodable;
+import org.bouncycastle.util.Store;
+
+/**
+ * Carrier for a Simple PKI Response.
+ * <p>
+ * A Simple PKI Response is defined in RFC 5272 as a CMS SignedData object with no EncapsulatedContentInfo
+ * and no SignerInfos attached.
+ * </p>
+ */
+public class SimplePKIResponse
+    implements Encodable
+{
+    private final CMSSignedData certificateResponse;
+
+    private static ContentInfo parseBytes(byte[] responseEncoding)
+        throws CMCException
+    {
+        try
+        {
+            return ContentInfo.getInstance(ASN1Primitive.fromByteArray(responseEncoding));
+        }
+        catch (Exception e)
+        {
+            throw new CMCException("malformed data: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Create a SimplePKIResponse from the passed in bytes.
+     *
+     * @param responseEncoding BER/DER encoding of the certificate.
+     * @throws IOException in the event of corrupted data, or an incorrect structure.
+     */
+    public SimplePKIResponse(byte[] responseEncoding)
+        throws CMCException
+    {
+        this(parseBytes(responseEncoding));
+    }
+
+    /**
+     * Create a SimplePKIResponse from the passed in ASN.1 structure.
+     *
+     * @param signedData a ContentInfo containing a SignedData.
+     */
+    public SimplePKIResponse(ContentInfo signedData)
+        throws CMCException
+    {
+        try
+        {
+            this.certificateResponse = new CMSSignedData(signedData);
+        }
+        catch (CMSException e)
+        {
+            throw new CMCException("malformed response: " + e.getMessage(), e);
+        }
+
+        if (certificateResponse.getSignerInfos().size() != 0)
+        {
+            throw new CMCException("malformed response: SignerInfo structures found");
+        }
+        if (certificateResponse.getSignedContent() != null)
+        {
+            throw new CMCException("malformed response: Signed Content found");
+        }
+    }
+
+    /**
+     * Return any X.509 certificate objects in this SimplePKIResponse structure as a Store of X509CertificateHolder objects.
+     *
+     * @return a Store of X509CertificateHolder objects.
+     */
+    public Store<X509CertificateHolder> getCertificates()
+    {
+        return certificateResponse.getCertificates();
+    }
+
+    /**
+     * Return any X.509 CRL objects in this SimplePKIResponse structure as a Store of X509CRLHolder objects.
+     *
+     * @return a Store of X509CRLHolder objects.
+     */
+    public Store<X509CRLHolder> getCRLs()
+    {
+        return certificateResponse.getCRLs();
+    }
+
+    /**
+     * return the ASN.1 encoded representation of this object.
+     */
+    public byte[] getEncoded()
+        throws IOException
+    {
+        return certificateResponse.getEncoded();
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/CMSContentInfoParser.java b/bcpkix/src/main/java/org/bouncycastle/cms/CMSContentInfoParser.java
index a8e5a8d..9edcda2 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/CMSContentInfoParser.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/CMSContentInfoParser.java
@@ -21,8 +21,14 @@
         try
         {
             ASN1StreamParser in = new ASN1StreamParser(data);
-    
-            _contentInfo = new ContentInfoParser((ASN1SequenceParser)in.readObject());
+            ASN1SequenceParser seqParser = (ASN1SequenceParser)in.readObject();
+
+            if (seqParser == null)
+            {
+                throw new CMSException("No content found.");
+            }
+
+            _contentInfo = new ContentInfoParser(seqParser);
         }
         catch (IOException e)
         {
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/CMSEncryptedDataGenerator.java b/bcpkix/src/main/java/org/bouncycastle/cms/CMSEncryptedDataGenerator.java
index d12097e..6f2f42b 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/CMSEncryptedDataGenerator.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/CMSEncryptedDataGenerator.java
@@ -18,14 +18,14 @@
 import org.bouncycastle.operator.OutputEncryptor;
 
 /**
- * General class for generating a CMS enveloped-data message.
+ * General class for generating a CMS encrypted-data message.
  *
  * A simple example of usage.
  *
  * <pre>
  *       CMSTypedData msg     = new CMSProcessableByteArray("Hello World!".getBytes());
  *
- *       CMSEncryptedDataGenerator edGen = new CMSEnvelopedDataGenerator();
+ *       CMSEncryptedDataGenerator edGen = new CMSEncryptedDataGenerator();
  *
  *       CMSEncryptedData ed = edGen.generate(
  *                                       msg,
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedData.java b/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedData.java
index 84b5edc..98b4ee1 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedData.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedData.java
@@ -26,6 +26,9 @@
 import org.bouncycastle.asn1.cms.SignedData;
 import org.bouncycastle.asn1.cms.SignerInfo;
 import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.cert.X509AttributeCertificateHolder;
+import org.bouncycastle.cert.X509CRLHolder;
+import org.bouncycastle.cert.X509CertificateHolder;
 import org.bouncycastle.operator.OperatorCreationException;
 import org.bouncycastle.util.Encodable;
 import org.bouncycastle.util.Store;
@@ -292,7 +295,7 @@
      *
      * @return a Store of X509CertificateHolder objects.
      */
-    public Store getCertificates()
+    public Store<X509CertificateHolder> getCertificates()
     {
         return HELPER.getCertificates(signedData.getCertificates());
     }
@@ -302,7 +305,7 @@
      *
      * @return a Store of X509CRLHolder objects.
      */
-    public Store getCRLs()
+    public Store<X509CRLHolder> getCRLs()
     {
         return HELPER.getCRLs(signedData.getCRLs());
     }
@@ -312,7 +315,7 @@
      *
      * @return a Store of X509AttributeCertificateHolder objects.
      */
-    public Store getAttributeCertificates()
+    public Store<X509AttributeCertificateHolder> getAttributeCertificates()
     {
         return HELPER.getAttributeCertificates(signedData.getCertificates());
     }
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedDataParser.java b/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedDataParser.java
index 2cf40d0..267fde3 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedDataParser.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/CMSSignedDataParser.java
@@ -185,22 +185,19 @@
             {
                 ASN1OctetStringParser octs = (ASN1OctetStringParser)contentParser;
 
-                if (octs != null)
-                {
-                    CMSTypedStream ctStr = new CMSTypedStream(
-                        cont.getContentType(), octs.getOctetStream());
+                CMSTypedStream ctStr = new CMSTypedStream(
+                    cont.getContentType(), octs.getOctetStream());
 
-                    if (_signedContent == null)
-                    {
-                        _signedContent = ctStr;
-                    }
-                    else
-                    {
-                        //
-                        // content passed in, need to read past empty encapsulated content info object if present
-                        //
-                        ctStr.drain();
-                    }
+                if (_signedContent == null)
+                {
+                    _signedContent = ctStr;
+                }
+                else
+                {
+                    //
+                    // content passed in, need to read past empty encapsulated content info object if present
+                    //
+                    ctStr.drain();
                 }
             }
             else if (contentParser != null)
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/CMSUtils.java b/bcpkix/src/main/java/org/bouncycastle/cms/CMSUtils.java
index d0e7d49..f63bf3c 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/CMSUtils.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/CMSUtils.java
@@ -255,7 +255,13 @@
     {
         try
         {
-            return ContentInfo.getInstance(in.readObject());
+            ContentInfo info = ContentInfo.getInstance(in.readObject());
+            if (info == null)
+            {
+                throw new CMSException("No content found.");
+            }
+
+            return info;
         }
         catch (IOException e)
         {
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/SignerInformationVerifier.java b/bcpkix/src/main/java/org/bouncycastle/cms/SignerInformationVerifier.java
index ada4d0e..06d2c1b 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/SignerInformationVerifier.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/SignerInformationVerifier.java
@@ -37,9 +37,10 @@
     public ContentVerifier getContentVerifier(AlgorithmIdentifier signingAlgorithm, AlgorithmIdentifier digestAlgorithm)
         throws OperatorCreationException
     {
-        String          signatureName = sigNameGenerator.getSignatureName(digestAlgorithm, signingAlgorithm);
+        String              signatureName = sigNameGenerator.getSignatureName(digestAlgorithm, signingAlgorithm);
+        AlgorithmIdentifier baseAlgID = sigAlgorithmFinder.find(signatureName);
 
-        return verifierProvider.get(sigAlgorithmFinder.find(signatureName));
+        return verifierProvider.get(new AlgorithmIdentifier(baseAlgID.getAlgorithm(), signingAlgorithm.getParameters()));
     }
 
     public DigestCalculator getDigestCalculator(AlgorithmIdentifier algorithmIdentifier)
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/bc/package.html b/bcpkix/src/main/java/org/bouncycastle/cms/bc/package.html
new file mode 100644
index 0000000..7182ae3
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/bc/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+CMS operator implementations for doing message encryption, signing, digesting, and MACing operations using the BC lightweight API.
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/jcajce/package.html b/bcpkix/src/main/java/org/bouncycastle/cms/jcajce/package.html
new file mode 100644
index 0000000..5221afe
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/jcajce/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+CMS operator implementations for doing message encryption, signing, digesting, and MACing operations using the JCA and the JCE.
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/test/NewSignedDataTest.java b/bcpkix/src/main/java/org/bouncycastle/cms/test/NewSignedDataTest.java
index 8b7b54e..7277098 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/test/NewSignedDataTest.java
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/test/NewSignedDataTest.java
@@ -743,6 +743,29 @@
         verifySignatures(s, null);
     }
 
+    public void testEmptyContent()
+        throws Exception
+    {
+        
+        try
+        {
+            new CMSSignedData(new byte[0]);
+        }
+        catch (CMSException e)
+        {
+            assertEquals("No content found.", e.getMessage());
+        }
+
+        try
+        {
+            new CMSSignedDataParser(new JcaDigestCalculatorProviderBuilder().build(), new byte[0]);
+        }
+        catch (CMSException e)
+        {
+            assertEquals("No content found.", e.getMessage());
+        }
+    }
+
     public void testSHA1AndMD5WithRSAEncapsulatedRepeated()
         throws Exception
     {
diff --git a/bcpkix/src/main/java/org/bouncycastle/cms/test/package.html b/bcpkix/src/main/java/org/bouncycastle/cms/test/package.html
index 153bbd0..70b39d7 100644
--- a/bcpkix/src/main/java/org/bouncycastle/cms/test/package.html
+++ b/bcpkix/src/main/java/org/bouncycastle/cms/test/package.html
@@ -1,6 +1,6 @@
 <html>
 <body bgcolor="#ffffff">
-Regression tests for the org.bouncycastle.cms package. 
+Regression tests for the Cryptographic Message Syntax (CMS) packages. 
 <p>
 <b>Note</b>: The classes in this package are also a useful source of example code.
 </body>
diff --git a/bcpkix/src/main/java/org/bouncycastle/eac/test/AllTests.java b/bcpkix/src/main/java/org/bouncycastle/eac/test/AllTests.java
index f819855..4cfdf28 100644
--- a/bcpkix/src/main/java/org/bouncycastle/eac/test/AllTests.java
+++ b/bcpkix/src/main/java/org/bouncycastle/eac/test/AllTests.java
@@ -29,6 +29,7 @@
 import org.bouncycastle.jce.ECNamedCurveTable;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
 import org.bouncycastle.jce.spec.ECParameterSpec;
+import org.bouncycastle.util.Arrays;
 import org.bouncycastle.util.io.Streams;
 
 public class AllTests
@@ -77,6 +78,20 @@
         }
     }
 
+    public void testLoadCSR() throws Exception
+    {
+        // this request contains invalid unsigned integers (see D 2.1.1)
+        byte[] input = getInput("UTIS00100072.csr");
+   
+        EACCertificateRequestHolder requestHolder = new EACCertificateRequestHolder(input);
+
+        PublicKey pubKey = new JcaPublicKeyConverter().setProvider(BC).getKey(requestHolder.getPublicKeyDataObject());
+        EACSignatureVerifier verifier = new JcaEACSignatureVerifierBuilder().build(requestHolder.getPublicKeyDataObject().getUsage(), pubKey);
+
+        TestCase.assertTrue("signature test failed", requestHolder.isInnerSignatureValid(verifier));
+        TestCase.assertTrue("comparison failed", Arrays.areEqual(input, requestHolder.toASN1Structure().getEncoded()));
+    }
+
     public void testLoadRefCert() throws Exception
     {
         EACCertificateHolder certHolder = new EACCertificateHolder(getInput("at_cert_19a.cvcert"));
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/CACertsResponse.java b/bcpkix/src/main/java/org/bouncycastle/est/CACertsResponse.java
new file mode 100644
index 0000000..1992687
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/CACertsResponse.java
@@ -0,0 +1,75 @@
+package org.bouncycastle.est;
+
+import org.bouncycastle.cert.X509CRLHolder;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.util.Store;
+
+/**
+ * Holder class for a SimplePKIResponse containing the details making up /cacerts response.
+ */
+public class CACertsResponse
+{
+    private final Store<X509CertificateHolder> store;
+    private Store<X509CRLHolder> crlHolderStore;
+    private final ESTRequest requestToRetry;
+    private final Source session;
+    private final boolean trusted;
+
+    public CACertsResponse(
+        Store<X509CertificateHolder> store,
+        Store<X509CRLHolder> crlHolderStore,
+        ESTRequest requestToRetry,
+        Source session, boolean trusted)
+    {
+        this.store = store;
+        this.requestToRetry = requestToRetry;
+        this.session = session;
+        this.trusted = trusted;
+        this.crlHolderStore = crlHolderStore;
+    }
+
+    public boolean hasCertificates()
+    {
+        return store != null;
+    }
+
+    public Store<X509CertificateHolder> getCertificateStore()
+    {
+        if (store == null)
+        {
+            throw new IllegalStateException("Response has no certificates.");
+        }
+        return store;
+    }
+
+
+    public boolean hasCRLs()
+    {
+        return crlHolderStore != null;
+    }
+
+    public Store<X509CRLHolder> getCrlStore()
+    {
+        if (crlHolderStore == null)
+        {
+            throw new IllegalStateException("Response has no CRLs.");
+        }
+        return crlHolderStore;
+    }
+
+
+    public ESTRequest getRequestToRetry()
+    {
+        return requestToRetry;
+    }
+
+    public Object getSession()
+    {
+        return session.getSession();
+    }
+
+    public boolean isTrusted()
+    {
+        return trusted;
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/CSRAttributesResponse.java b/bcpkix/src/main/java/org/bouncycastle/est/CSRAttributesResponse.java
new file mode 100644
index 0000000..0250983
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/CSRAttributesResponse.java
@@ -0,0 +1,104 @@
+package org.bouncycastle.est;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.est.AttrOrOID;
+import org.bouncycastle.asn1.est.CsrAttrs;
+import org.bouncycastle.util.Encodable;
+
+/**
+ * Wrapper class around a CsrAttrs structure.
+ */
+public class CSRAttributesResponse
+    implements Encodable
+{
+    private final CsrAttrs csrAttrs;
+    private final HashMap<ASN1ObjectIdentifier, AttrOrOID> index;
+
+    /**
+     * Create a CSRAttributesResponse from the passed in bytes.
+     *
+     * @param responseEncoding BER/DER encoding of the certificate.
+     * @throws IOException in the event of corrupted data, or an incorrect structure.
+     */
+    public CSRAttributesResponse(byte[] responseEncoding)
+        throws ESTException
+    {
+        this(parseBytes(responseEncoding));
+    }
+
+    /**
+     * Create a CSRAttributesResponse from the passed in ASN.1 structure.
+     *
+     * @param csrAttrs an RFC 7030 CsrAttrs structure.
+     */
+    public CSRAttributesResponse(CsrAttrs csrAttrs)
+        throws ESTException
+    {
+        this.csrAttrs = csrAttrs;
+        this.index = new HashMap<ASN1ObjectIdentifier, AttrOrOID>(csrAttrs.size());
+
+        AttrOrOID[] attrOrOIDs = csrAttrs.getAttrOrOIDs();
+        for (int i = 0; i != attrOrOIDs.length; i++)
+        {
+            AttrOrOID attrOrOID = attrOrOIDs[i];
+
+            if (attrOrOID.isOid())
+            {
+                index.put(attrOrOID.getOid(), attrOrOID);
+            }
+            else
+            {
+                index.put(attrOrOID.getAttribute().getAttrType(), attrOrOID);
+            }
+        }
+    }
+
+    private static CsrAttrs parseBytes(byte[] responseEncoding)
+        throws ESTException
+    {
+        try
+        {
+            return CsrAttrs.getInstance(ASN1Primitive.fromByteArray(responseEncoding));
+        }
+        catch (Exception e)
+        {
+            throw new ESTException("malformed data: " + e.getMessage(), e);
+        }
+    }
+
+    public boolean hasRequirement(ASN1ObjectIdentifier requirementOid)
+    {
+        return index.containsKey(requirementOid);
+    }
+
+    public boolean isAttribute(ASN1ObjectIdentifier requirementOid)
+    {
+        if (index.containsKey(requirementOid))
+        {
+            return !(((AttrOrOID)index.get(requirementOid)).isOid());
+        }
+
+        return false;
+    }
+
+    public boolean isEmpty()
+    {
+        return csrAttrs.size() == 0;
+    }
+
+    public Collection<ASN1ObjectIdentifier> getRequirements()
+    {
+        return index.keySet();
+    }
+
+    public byte[] getEncoded()
+        throws IOException
+    {
+        return csrAttrs.getEncoded();
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/CSRRequestResponse.java b/bcpkix/src/main/java/org/bouncycastle/est/CSRRequestResponse.java
new file mode 100644
index 0000000..e95b22f
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/CSRRequestResponse.java
@@ -0,0 +1,40 @@
+package org.bouncycastle.est;
+
+/**
+ * Holder class for a response containing the details making up /csrattrs response.
+ */
+public class CSRRequestResponse
+{
+    private final CSRAttributesResponse attributesResponse;
+    private final Source source;
+
+    public CSRRequestResponse(CSRAttributesResponse attributesResponse, Source session)
+    {
+        this.attributesResponse = attributesResponse;
+        this.source = session;
+    }
+
+    public boolean hasAttributesResponse()
+    {
+        return attributesResponse != null;
+    }
+
+    public CSRAttributesResponse getAttributesResponse()
+    {
+        if (attributesResponse == null)
+        {
+            throw new IllegalStateException("Response has no CSRAttributesResponse.");
+        }
+        return attributesResponse;
+    }
+
+    public Object getSession()
+    {
+        return source.getSession();
+    }
+
+    public Source getSource()
+    {
+        return source;
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/CTEBase64InputStream.java b/bcpkix/src/main/java/org/bouncycastle/est/CTEBase64InputStream.java
new file mode 100644
index 0000000..2b1c427
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/CTEBase64InputStream.java
@@ -0,0 +1,118 @@
+package org.bouncycastle.est;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.bouncycastle.util.encoders.Base64;
+
+
+class CTEBase64InputStream
+    extends InputStream
+{
+    protected final InputStream src;
+    protected final byte[] rawBuf = new byte[1024];
+    protected final byte[] data = new byte[768];
+    protected final OutputStream dataOutputStream;
+    protected final Long max;
+    protected int rp;
+    protected int wp;
+    protected boolean end;
+    protected long read;
+
+    public CTEBase64InputStream(InputStream src, Long limit)
+    {
+        this.src = src;
+        this.dataOutputStream = new OutputStream()
+        {
+            public void write(int b)
+                throws IOException
+            {
+                data[wp++] = (byte)b;
+            }
+        };
+        this.max = limit;
+    }
+
+    // Pulls a line from the source, decodes it and returns the decoded length.
+    // Or returns -1 if there is nothing more to read and nothing was read in this pass.
+    protected int pullFromSrc()
+        throws IOException
+    {
+
+        if (this.read >= this.max)
+        {
+            return -1;
+        }
+
+        int j = 0;
+        int c = 0;
+        do
+        {
+            j = src.read();
+            /*
+             * RFC2045 All line breaks or other characters not
+             * found in Table 1 must be ignored by decoding software.
+             * https://tools.ietf.org/html/rfc2045#section-6.8
+             * This uses the line brakes to to stop reading data and to decode a chunk.
+             */
+            if (j >= 33 || (j == '\r' || j == '\n'))
+            {
+                if (c >= rawBuf.length)
+                {
+                    throw new IOException("Content Transfer Encoding, base64 line length > 1024");
+                }
+                rawBuf[c++] = (byte)j;
+                read += 1;
+            }
+            else if (j >= 0)
+            {
+                read += 1;
+            }
+        }
+        while (j > -1 && c < rawBuf.length && j != 10 && this.read < this.max);
+
+        if (c > 0)
+        {
+            try
+            {
+                Base64.decode(rawBuf, 0, c, dataOutputStream);
+            }
+            catch (Exception ex)
+            {
+                throw new IOException("Decode Base64 Content-Transfer-Encoding: " + ex);
+            }
+        }
+        else
+        {
+            if (j == -1)
+            {
+                return -1;
+            }
+        }
+        return wp;
+    }
+
+    public int read()
+        throws IOException
+    {
+        // When we have read up to the write pointer (wp) pull some more.
+        if (rp == wp)
+        {
+            rp = 0;
+            wp = 0;
+            int i = pullFromSrc();
+            if (i == -1)
+            {
+                return i;
+            }
+        }
+        return data[rp++] & 0xFF;
+    }
+
+    public void close()
+        throws IOException
+    {
+        src.close();
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTAuth.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTAuth.java
new file mode 100644
index 0000000..e7cdd9e
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTAuth.java
@@ -0,0 +1,15 @@
+package org.bouncycastle.est;
+
+
+/**
+ * Base interface for an object with adds HTTP Auth attributes to an ESTRequest
+ */
+public interface ESTAuth
+{
+    /**
+     * Add the Auth attributes to the passed in request builder.
+     *
+     * @param reqBldr the builder for the request needing the Auth attributes.
+     */
+    void applyAuth(ESTRequestBuilder reqBldr);
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTClient.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTClient.java
new file mode 100644
index 0000000..f9452bf
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTClient.java
@@ -0,0 +1,16 @@
+package org.bouncycastle.est;
+
+import java.io.IOException;
+
+/**
+ * ESTClient implement connection to the server.
+ * <p>
+ * Implementations should be aware that they are responsible for
+ * satisfying <a hrref="https://tools.ietf.org/html/rfc7030#section-3.3">RFC7030 3.3 - TLS Layer</a>
+ * including SRP modes.
+ */
+public interface ESTClient
+{
+    public ESTResponse doRequest(ESTRequest c)
+        throws IOException;
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTClientProvider.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTClientProvider.java
new file mode 100644
index 0000000..61a24b7
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTClientProvider.java
@@ -0,0 +1,18 @@
+package org.bouncycastle.est;
+
+
+/**
+ * A client provider is responsible for creating an ESTClient instance.
+ */
+public interface ESTClientProvider
+{
+    ESTClient makeClient()
+        throws ESTException;
+
+    /**
+     * Return true if the client is presently configured to verify the server.
+     *
+     * @return true = verifying server.
+     */
+    boolean isTrusted();
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTClientSourceProvider.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTClientSourceProvider.java
new file mode 100644
index 0000000..3aefa39
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTClientSourceProvider.java
@@ -0,0 +1,12 @@
+package org.bouncycastle.est;
+
+import java.io.IOException;
+
+/**
+ * ESTClientSourceProvider, implementations of this are expected to return a source.
+ */
+public interface ESTClientSourceProvider
+{
+    Source makeSource(String host, int port)
+        throws IOException;
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTException.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTException.java
new file mode 100644
index 0000000..b9b8e18
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTException.java
@@ -0,0 +1,93 @@
+package org.bouncycastle.est;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Exception emitted by EST classes.
+ */
+public class ESTException
+    extends IOException
+{
+    private Throwable cause;
+
+    private InputStream body;
+    private int statusCode;
+
+    private static final long MAX_ERROR_BODY = 8192;
+
+    public ESTException(String msg)
+    {
+        this(msg, null);
+    }
+
+    public ESTException(String msg, Throwable cause)
+    {
+        super(msg);
+        this.cause = cause;
+        body = null;
+        statusCode = 0;
+    }
+
+    public ESTException(String message, Throwable cause, int statusCode, InputStream body)
+    {
+        super(message);
+        this.cause = cause;
+        this.statusCode = statusCode;
+        if (body != null)
+        {
+            byte[] b = new byte[8192];
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            try
+            {
+                int i = body.read(b);
+                while (i >= 0)
+                {
+                    if (bos.size() + i > MAX_ERROR_BODY)
+                    {
+                        i = (int)MAX_ERROR_BODY - bos.size();
+                        bos.write(b, 0, i);
+                        break;
+                    }
+                    bos.write(b, 0, i);
+                    i = body.read(b);
+                }
+                bos.flush();
+                bos.close();
+                this.body = new ByteArrayInputStream(bos.toByteArray());
+                body.close();
+            }
+            catch (Exception ex)
+            {
+                // This is a best effort read, input stream could be dead by this point.
+            }
+        }
+        else
+        {
+            this.body = null;
+        }
+    }
+
+    public Throwable getCause()
+    {
+        return cause;
+    }
+    
+    public String getMessage()
+    {
+        return super.getMessage() + " HTTP Status Code: " + statusCode;
+    }
+
+    public InputStream getBody()
+    {
+        return body;
+    }
+
+    public int getStatusCode()
+    {
+        return statusCode;
+    }
+
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTHijacker.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTHijacker.java
new file mode 100644
index 0000000..28fda58
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTHijacker.java
@@ -0,0 +1,18 @@
+package org.bouncycastle.est;
+
+
+import java.io.IOException;
+
+/**
+ * ESTHijacker can take control of the source after the initial http request
+ * has been sent and a response received.
+ * A hijacker is then able to send more request or be able to modify the response before returning a response
+ * to the original caller.
+ * <p>
+ * See DigestAuth and BasicAuth.
+ */
+public interface ESTHijacker
+{
+    ESTResponse hijack(ESTRequest req, Source sock)
+        throws IOException;
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTRequest.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTRequest.java
new file mode 100644
index 0000000..4b8af1d
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTRequest.java
@@ -0,0 +1,77 @@
+package org.bouncycastle.est;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URL;
+import java.util.Map;
+
+/**
+ * Implements a basic http request.
+ */
+public class ESTRequest
+{
+    final String method;
+    final URL url;
+    HttpUtil.Headers headers = new HttpUtil.Headers();
+    final byte[] data;
+    final ESTHijacker hijacker;
+    final ESTClient estClient;
+    final ESTSourceConnectionListener listener;
+
+    ESTRequest(
+        String method,
+        URL url,
+        byte[] data,
+        ESTHijacker hijacker,
+        ESTSourceConnectionListener listener,
+        HttpUtil.Headers headers,
+        ESTClient estClient)
+    {
+        this.method = method;
+        this.url = url;
+        this.data = data;
+        this.hijacker = hijacker;
+        this.listener = listener;
+        this.headers = headers;
+        this.estClient = estClient;
+    }
+
+    public String getMethod()
+    {
+        return method;
+    }
+
+    public URL getURL()
+    {
+        return url;
+    }
+
+    public Map<String, String[]> getHeaders()
+    {
+        return (Map<String, String[]>)headers.clone();
+    }
+
+    public ESTHijacker getHijacker()
+    {
+        return hijacker;
+    }
+
+    public ESTClient getClient()
+    {
+        return estClient;
+    }
+
+    public ESTSourceConnectionListener getListener()
+    {
+        return listener;
+    }
+
+    public void writeData(OutputStream os)
+        throws IOException
+    {
+        if (data != null)
+        {
+            os.write(data);
+        }
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTRequestBuilder.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTRequestBuilder.java
new file mode 100644
index 0000000..d7e52ac
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTRequestBuilder.java
@@ -0,0 +1,90 @@
+package org.bouncycastle.est;
+
+import java.net.URL;
+
+import org.bouncycastle.util.Arrays;
+
+/**
+ * Builder for basic EST requests
+ */
+public class ESTRequestBuilder
+{
+    private final String method;
+    private URL url;
+
+    private HttpUtil.Headers headers;
+    ESTHijacker hijacker;
+    ESTSourceConnectionListener listener;
+    ESTClient client;
+    private byte[] data;
+
+    public ESTRequestBuilder(ESTRequest request)
+    {
+
+        this.method = request.method;
+        this.url = request.url;
+        this.listener = request.listener;
+        this.data = request.data;
+        this.hijacker = request.hijacker;
+        this.headers = (HttpUtil.Headers)request.headers.clone();
+        this.client = request.getClient();
+    }
+
+    public ESTRequestBuilder(String method, URL url)
+    {
+        this.method = method;
+        this.url = url;
+        this.headers = new HttpUtil.Headers();
+    }
+
+    public ESTRequestBuilder withConnectionListener(ESTSourceConnectionListener listener)
+    {
+        this.listener = listener;
+
+        return this;
+    }
+
+    public ESTRequestBuilder withHijacker(ESTHijacker hijacker)
+    {
+        this.hijacker = hijacker;
+
+        return this;
+    }
+
+    public ESTRequestBuilder withURL(URL url)
+    {
+        this.url = url;
+
+        return this;
+    }
+
+    public ESTRequestBuilder withData(byte[] data)
+    {
+        this.data = Arrays.clone(data);
+
+        return this;
+    }
+
+    public ESTRequestBuilder addHeader(String key, String value)
+    {
+        headers.add(key, value);
+        return this;
+    }
+
+    public ESTRequestBuilder setHeader(String key, String value)
+    {
+        headers.set(key, value);
+        return this;
+    }
+
+    public ESTRequestBuilder withClient(ESTClient client)
+    {
+        this.client = client;
+        return this;
+    }
+
+    public ESTRequest build()
+    {
+        return new ESTRequest(method, url, data, hijacker, listener, headers, client);
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTResponse.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTResponse.java
new file mode 100644
index 0000000..efcc272
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTResponse.java
@@ -0,0 +1,317 @@
+package org.bouncycastle.est;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Set;
+
+import org.bouncycastle.util.Properties;
+import org.bouncycastle.util.Strings;
+
+/**
+ * A basic http response.
+ */
+public class ESTResponse
+{
+    private final ESTRequest originalRequest;
+    private final HttpUtil.Headers headers;
+    private final byte[] lineBuffer;
+    private final Source source;
+    private String HttpVersion;
+    private int statusCode;
+    private String statusMessage;
+    private InputStream inputStream;
+    private Long contentLength;
+    private long read = 0;
+    private Long absoluteReadLimit;
+
+    private static final Long ZERO = 0L;
+
+    public ESTResponse(ESTRequest originalRequest, Source source)
+        throws IOException
+    {
+        this.originalRequest = originalRequest;
+        this.source = source;
+
+        if (source instanceof LimitedSource)
+        {
+            this.absoluteReadLimit = ((LimitedSource)source).getAbsoluteReadLimit();
+        }
+
+        Set<String> opts = Properties.asKeySet("org.bouncycastle.debug.est");
+        if (opts.contains("input") ||
+            opts.contains("all"))
+        {
+            this.inputStream = new PrintingInputStream(source.getInputStream());
+        }
+        else
+        {
+            this.inputStream = source.getInputStream();
+        }
+
+        this.headers = new HttpUtil.Headers();
+        this.lineBuffer = new byte[1024];
+
+        process();
+    }
+
+    private void process()
+        throws IOException
+    {
+        //
+        // Status line.
+        //
+        HttpVersion = readStringIncluding(' ');
+        this.statusCode = Integer.parseInt(readStringIncluding(' '));
+        this.statusMessage = readStringIncluding('\n');
+
+
+        //
+        // Headers.
+        //
+        String line = readStringIncluding('\n');
+        int i;
+        while (line.length() > 0)
+        {
+            i = line.indexOf(':');
+            if (i > -1)
+            {
+                String k = Strings.toLowerCase(line.substring(0, i).trim()); // Header keys are case insensitive
+                headers.add(k, line.substring(i + 1).trim());
+            }
+            line = readStringIncluding('\n');
+        }
+
+
+        contentLength = getContentLength();
+
+        //
+        // Concerned that different servers may or may not set a Content-length
+        // for these success types. In this case we will arbitrarily set content length
+        // to zero.
+        //
+        if (statusCode == 204 || statusCode == 202)
+        {
+            if (contentLength == null)
+            {
+                contentLength = 0L;
+            }
+            else
+            {
+                if (statusCode == 204 && contentLength > 0)
+                {
+                    throw new IOException("Got HTTP status 204 but Content-length > 0.");
+                }
+            }
+        }
+
+        if (contentLength == null)
+        {
+            throw new IOException("No Content-length header.");
+        }
+
+        if (contentLength.equals(ZERO))
+        {
+
+            //
+            // The server is likely to hang up the socket and any attempt to read can
+            // result in a broken pipe rather than an eof.
+            // So we will return a dummy input stream that will return eof to anything that reads from it.
+            //
+
+            inputStream = new InputStream()
+            {
+                public int read()
+                    throws IOException
+                {
+                    return -1;
+                }
+            };
+        }
+
+        if (contentLength != null)
+        {
+            if (contentLength < 0)
+            {
+                throw new IOException("Server returned negative content length: " + absoluteReadLimit);
+            }
+
+            if (absoluteReadLimit != null && contentLength >= absoluteReadLimit)
+            {
+                throw new IOException("Content length longer than absolute read limit: " + absoluteReadLimit + " Content-Length: " + contentLength);
+            }
+        }
+
+
+        inputStream = wrapWithCounter(inputStream, absoluteReadLimit);
+        //
+        // Observed that some
+        //
+        if ("base64".equalsIgnoreCase(getHeader("content-transfer-encoding")))
+        {
+            inputStream = new CTEBase64InputStream(inputStream, getContentLength());
+        }
+    }
+
+    public String getHeader(String key)
+    {
+        return headers.getFirstValue(key);
+    }
+
+
+    protected InputStream wrapWithCounter(final InputStream in, final Long absoluteReadLimit)
+    {
+        return new InputStream()
+        {
+            public int read()
+                throws IOException
+            {
+                int i = in.read();
+                if (i > -1)
+                {
+                    read++;
+                    if (absoluteReadLimit != null && read >= absoluteReadLimit)
+                    {
+                        throw new IOException("Absolute Read Limit exceeded: " + absoluteReadLimit);
+                    }
+                }
+                return i;
+            }
+
+            public void close()
+                throws IOException
+            {
+                if (contentLength != null && contentLength - 1 > read)
+                {
+                    throw new IOException("Stream closed before limit fully read, Read: " + read + " ContentLength: " + contentLength);
+                }
+
+                if (in.available() > 0)
+                {
+                    throw new IOException("Stream closed with extra content in pipe that exceeds content length.");
+                }
+
+                in.close();
+            }
+        };
+    }
+
+
+    protected String readStringIncluding(char until)
+        throws IOException
+    {
+        int c = 0;
+        int j;
+        do
+        {
+            j = inputStream.read();
+            lineBuffer[c++] = (byte)j;
+            if (c >= lineBuffer.length)
+            {
+                throw new IOException("Server sent line > " + lineBuffer.length);
+            }
+        }
+        while (j != until && j > -1);
+        if (j == -1)
+        {
+            throw new EOFException();
+        }
+
+        return new String(lineBuffer, 0, c).trim();
+    }
+
+    public ESTRequest getOriginalRequest()
+    {
+        return originalRequest;
+    }
+
+    public HttpUtil.Headers getHeaders()
+    {
+        return headers;
+    }
+
+    public String getHttpVersion()
+    {
+        return HttpVersion;
+    }
+
+    public int getStatusCode()
+    {
+        return statusCode;
+    }
+
+    public String getStatusMessage()
+    {
+        return statusMessage;
+    }
+
+    public InputStream getInputStream()
+    {
+        return inputStream;
+    }
+
+
+    public Source getSource()
+    {
+        return source;
+    }
+
+    public Long getContentLength()
+    {
+        String v = headers.getFirstValue("Content-Length");
+        if (v == null)
+        {
+            return null;
+        }
+        try
+        {
+            return Long.parseLong(v);
+        }
+        catch (RuntimeException nfe)
+        {
+            throw new RuntimeException("Content Length: '" + v + "' invalid. " + nfe.getMessage());
+        }
+    }
+
+    public void close()
+        throws IOException
+    {
+        if (inputStream != null)
+        {
+            inputStream.close();
+        }
+        this.source.close();
+    }
+
+
+    private class PrintingInputStream
+        extends InputStream
+    {
+        private final InputStream src;
+
+        private PrintingInputStream(InputStream src)
+        {
+            this.src = src;
+        }
+
+        public int read()
+            throws IOException
+        {
+            int i = src.read();
+            System.out.print(String.valueOf((char)i));
+            return i;
+        }
+
+        public int available()
+            throws IOException
+        {
+            return src.available();
+        }
+
+        public void close()
+            throws IOException
+        {
+            src.close();
+        }
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTService.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTService.java
new file mode 100644
index 0000000..0dca634
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTService.java
@@ -0,0 +1,682 @@
+package org.bouncycastle.est;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.URL;
+import java.text.SimpleDateFormat;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+import java.util.TimeZone;
+import java.util.regex.Pattern;
+
+import org.bouncycastle.asn1.ASN1InputStream;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERPrintableString;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.asn1.est.CsrAttrs;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.cert.X509CRLHolder;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cmc.CMCException;
+import org.bouncycastle.cmc.SimplePKIResponse;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.pkcs.PKCS10CertificationRequest;
+import org.bouncycastle.pkcs.PKCS10CertificationRequestBuilder;
+import org.bouncycastle.util.Selector;
+import org.bouncycastle.util.Store;
+import org.bouncycastle.util.encoders.Base64;
+
+/**
+ * ESTService provides unified access to an EST server which is defined as implementing
+ * RFC7030.
+ */
+public class ESTService
+{
+    protected static final String CACERTS = "/cacerts";
+    protected static final String SIMPLE_ENROLL = "/simpleenroll";
+    protected static final String SIMPLE_REENROLL = "/simplereenroll";
+    protected static final String FULLCMC = "/fullcmc";
+    protected static final String SERVERGEN = "/serverkeygen";
+    protected static final String CSRATTRS = "/csrattrs";
+
+    protected static final Set<String> illegalParts = new HashSet<String>();
+
+    static
+    {
+        illegalParts.add(CACERTS.substring(1));
+        illegalParts.add(SIMPLE_ENROLL.substring(1));
+        illegalParts.add(SIMPLE_REENROLL.substring(1));
+        illegalParts.add(FULLCMC.substring(1));
+        illegalParts.add(SERVERGEN.substring(1));
+        illegalParts.add(CSRATTRS.substring(1));
+    }
+
+
+    private final String server;
+    private final ESTClientProvider clientProvider;
+
+    private static final Pattern pathInvalid = Pattern.compile("^[0-9a-zA-Z_\\-.~!$&'()*+,;=]+");
+
+    ESTService(
+        String serverAuthority, String label,
+        ESTClientProvider clientProvider)
+    {
+
+        serverAuthority = verifyServer(serverAuthority);
+
+        if (label != null)
+        {
+            label = verifyLabel(label);
+            server = "https://" + serverAuthority + "/.well-known/est/" + label;
+        }
+        else
+        {
+            server = "https://" + serverAuthority + "/.well-known/est";
+        }
+
+        this.clientProvider = clientProvider;
+    }
+
+    /**
+     * Utility method to extract all the X509Certificates from a store and return them in an array.
+     *
+     * @param store The store.
+     * @return An arrar of certificates/
+     */
+    public static X509CertificateHolder[] storeToArray(Store<X509CertificateHolder> store)
+    {
+        return storeToArray(store, null);
+    }
+
+    /**
+     * Utility method to extract all the X509Certificates from a store using a filter and to return them
+     * as an array.
+     *
+     * @param store    The store.
+     * @param selector The selector.
+     * @return An array of X509Certificates.
+     */
+    public static X509CertificateHolder[] storeToArray(Store<X509CertificateHolder> store, Selector<X509CertificateHolder> selector)
+    {
+        Collection<X509CertificateHolder> c = store.getMatches(selector);
+        return c.toArray(new X509CertificateHolder[c.size()]);
+    }
+
+    /**
+     * Query the EST server for ca certificates.
+     * <p>
+     * RFC7030 leans heavily on the verification phases of TLS for both client and server verification.
+     * <p>
+     * It does however define a bootstrapping mode where if the client does not have the necessary ca certificates to
+     * validate the server it can defer to an external source, such as a human, to formally accept the ca certs.
+     * <p>
+     * If callers are using bootstrapping they must examine the CACertsResponse and validate it externally.
+     *
+     * @return A store of X509Certificates.
+     */
+    public CACertsResponse getCACerts()
+        throws Exception
+    {
+        ESTResponse resp = null;
+        Exception finalThrowable = null;
+        CACertsResponse caCertsResponse = null;
+        URL url = null;
+        boolean failedBeforeClose = false;
+        try
+        {
+            url = new URL(server + CACERTS);
+
+            ESTClient client = clientProvider.makeClient();
+            ESTRequest req = new ESTRequestBuilder("GET", url).withClient(client).build();
+            resp = client.doRequest(req);
+
+            Store<X509CertificateHolder> caCerts = null;
+            Store<X509CRLHolder> crlHolderStore = null;
+
+
+            if (resp.getStatusCode() == 200)
+            {
+                if (!"application/pkcs7-mime".equals(resp.getHeaders().getFirstValue("Content-Type")))
+                {
+                    String j = resp.getHeaders().getFirstValue("Content-Type") != null ? " got " + resp.getHeaders().getFirstValue("Content-Type") : " but was not present.";
+                    throw new ESTException(("Response : " + url.toString() + "Expecting application/pkcs7-mime ") + j, null, resp.getStatusCode(), resp.getInputStream());
+                }
+
+                try
+                {
+                    if (resp.getContentLength() != null && resp.getContentLength() > 0)
+                    {
+                        ASN1InputStream ain = new ASN1InputStream(resp.getInputStream());
+                        SimplePKIResponse spkr = new SimplePKIResponse(ContentInfo.getInstance((ASN1Sequence)ain.readObject()));
+                        caCerts = spkr.getCertificates();
+                        crlHolderStore = spkr.getCRLs();
+                    }
+                }
+                catch (Throwable ex)
+                {
+                    throw new ESTException("Decoding CACerts: " + url.toString() + " " + ex.getMessage(), ex, resp.getStatusCode(), resp.getInputStream());
+                }
+
+            }
+            else if (resp.getStatusCode() != 204) // 204 are No Content
+            {
+                throw new ESTException("Get CACerts: " + url.toString(), null, resp.getStatusCode(), resp.getInputStream());
+            }
+
+            caCertsResponse = new CACertsResponse(caCerts, crlHolderStore, req, resp.getSource(), clientProvider.isTrusted());
+
+        }
+        catch (Throwable t)
+        {
+            failedBeforeClose = true;
+            if (t instanceof ESTException)
+            {
+                throw (ESTException)t;
+            }
+            else
+            {
+                throw new ESTException(t.getMessage(), t);
+            }
+        }
+        finally
+        {
+            if (resp != null)
+            {
+                try
+                {
+                    resp.close();
+                }
+                catch (Exception t)
+                {
+                    finalThrowable = t;
+                }
+            }
+        }
+
+        if (finalThrowable != null)
+        {
+            if (finalThrowable instanceof ESTException)
+            {
+                throw finalThrowable;
+            }
+            throw new ESTException("Get CACerts: " + url.toString(), finalThrowable, resp.getStatusCode(), null);
+        }
+
+        return caCertsResponse;
+
+
+    }
+
+    /**
+     * Reissue an existing request where the server had previously returned a 202.
+     *
+     * @param priorResponse The prior response.
+     * @return A new ESTEnrollmentResponse
+     * @throws Exception
+     */
+    public EnrollmentResponse simpleEnroll(EnrollmentResponse priorResponse)
+        throws Exception
+    {
+        if (!clientProvider.isTrusted())
+        {
+            throw new IllegalStateException("No trust anchors.");
+        }
+
+        ESTResponse resp = null;
+
+        try
+        {
+            ESTClient client = clientProvider.makeClient();
+            resp = client.doRequest(new ESTRequestBuilder(priorResponse.getRequestToRetry()).withClient(client).build());
+            return handleEnrollResponse(resp);
+        }
+        catch (Throwable t)
+        {
+            if (t instanceof ESTException)
+            {
+                throw (ESTException)t;
+            }
+            else
+            {
+                throw new ESTException(t.getMessage(), t);
+            }
+        }
+        finally
+        {
+            if (resp != null)
+            {
+                resp.close();
+            }
+        }
+    }
+
+    /**
+     * Perform a simple enrollment operation.
+     * <p>
+     * This method accepts an ESPHttpAuth instance to provide basic or digest authentication.
+     * <p>
+     * If authentication is to be performed as part of TLS then this instances client keystore and their keystore
+     * password need to be specified.
+     *
+     * @param certificationRequest The certification request.
+     * @param auth                 The http auth provider, basic auth or digest auth, can be null.
+     * @return The enrolled certificate.
+     */
+    public EnrollmentResponse simpleEnroll(boolean reenroll, PKCS10CertificationRequest certificationRequest, ESTAuth auth)
+        throws IOException
+    {
+        if (!clientProvider.isTrusted())
+        {
+            throw new IllegalStateException("No trust anchors.");
+        }
+
+        ESTResponse resp = null;
+        try
+        {
+            final byte[] data = annotateRequest(certificationRequest.getEncoded()).getBytes();
+
+            URL url = new URL(server + (reenroll ? SIMPLE_REENROLL : SIMPLE_ENROLL));
+
+
+            ESTClient client = clientProvider.makeClient();
+            ESTRequestBuilder req = new ESTRequestBuilder("POST", url).withData(data).withClient(client);
+
+            req.addHeader("Content-Type", "application/pkcs10");
+            req.addHeader("Content-Length", "" + data.length);
+            req.addHeader("Content-Transfer-Encoding", "base64");
+
+            if (auth != null)
+            {
+                auth.applyAuth(req);
+            }
+
+            resp = client.doRequest(req.build());
+
+            return handleEnrollResponse(resp);
+
+        }
+        catch (Throwable t)
+        {
+            if (t instanceof ESTException)
+            {
+                throw (ESTException)t;
+            }
+            else
+            {
+                throw new ESTException(t.getMessage(), t);
+            }
+        }
+        finally
+        {
+            if (resp != null)
+            {
+                resp.close();
+            }
+        }
+
+    }
+
+
+    /**
+     * Implements Enroll with PoP.
+     * Request will have the tls-unique attribute added to it before it is signed and completed.
+     *
+     * @param reEnroll      True = re enroll.
+     * @param builder       The request builder.
+     * @param contentSigner The content signer.
+     * @param auth          Auth modes.
+     * @return Enrollment response.
+     * @throws IOException
+     */
+    public EnrollmentResponse simpleEnrollPoP(boolean reEnroll, final PKCS10CertificationRequestBuilder builder, final ContentSigner contentSigner, ESTAuth auth)
+        throws IOException
+    {
+        if (!clientProvider.isTrusted())
+        {
+            throw new IllegalStateException("No trust anchors.");
+        }
+
+        ESTResponse resp = null;
+        try
+        {
+            URL url = new URL(server + (reEnroll ? SIMPLE_REENROLL : SIMPLE_ENROLL));
+            ESTClient client = clientProvider.makeClient();
+
+            //
+            // Connect supplying a source listener.
+            // The source listener is responsible for completing the PCS10 Cert request and encoding it.
+            //
+            ESTRequestBuilder reqBldr = new ESTRequestBuilder("POST", url).withClient(client).withConnectionListener(new ESTSourceConnectionListener()
+            {
+                public ESTRequest onConnection(Source source, ESTRequest request)
+                    throws IOException
+                {
+                    //
+                    // Add challenge password from tls unique
+                    //
+
+                    if (source instanceof TLSUniqueProvider && ((TLSUniqueProvider)source).isTLSUniqueAvailable())
+                    {
+                        PKCS10CertificationRequestBuilder localBuilder = new PKCS10CertificationRequestBuilder(builder);
+
+                        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                        byte[] tlsUnique = ((TLSUniqueProvider)source).getTLSUnique();
+
+                        localBuilder.setAttribute(PKCSObjectIdentifiers.pkcs_9_at_challengePassword, new DERPrintableString(Base64.toBase64String(tlsUnique)));
+                        bos.write(annotateRequest(localBuilder.build(contentSigner).getEncoded()).getBytes());
+                        bos.flush();
+
+                        ESTRequestBuilder reqBuilder = new ESTRequestBuilder(request).withData(bos.toByteArray());
+
+                        reqBuilder.setHeader("Content-Type", "application/pkcs10");
+                        reqBuilder.setHeader("Content-Transfer-Encoding", "base64");
+                        reqBuilder.setHeader("Content-Length", Long.toString(bos.size()));
+
+                        return reqBuilder.build();
+                    }
+                    else
+                    {
+                        throw new IOException("Source does not supply TLS unique.");
+                    }
+                }
+            });
+
+            if (auth != null)
+            {
+                auth.applyAuth(reqBldr);
+            }
+
+            resp = client.doRequest(reqBldr.build());
+
+            return handleEnrollResponse(resp);
+
+        }
+        catch (Throwable t)
+        {
+            if (t instanceof ESTException)
+            {
+                throw (ESTException)t;
+            }
+            else
+            {
+                throw new ESTException(t.getMessage(), t);
+            }
+        }
+        finally
+        {
+            if (resp != null)
+            {
+                resp.close();
+            }
+        }
+
+    }
+
+
+    /**
+     * Handles the enroll response, deals with status codes and setting of delays.
+     *
+     * @param resp The response.
+     * @return An EnrollmentResponse.
+     * @throws IOException
+     */
+    protected EnrollmentResponse handleEnrollResponse(ESTResponse resp)
+        throws IOException
+    {
+
+        ESTRequest req = resp.getOriginalRequest();
+        Store<X509CertificateHolder> enrolled = null;
+        if (resp.getStatusCode() == 202)
+        {
+            // Received but not ready.
+            String rt = resp.getHeader("Retry-After");
+
+            if (rt == null)
+            {
+                throw new ESTException("Got Status 202 but not Retry-After header from: " + req.getURL().toString());
+            }
+
+            long notBefore = -1;
+
+
+            try
+            {
+                notBefore = System.currentTimeMillis() + (Long.parseLong(rt) * 1000);
+            }
+            catch (NumberFormatException nfe)
+            {
+                try
+                {
+                    SimpleDateFormat dateFormat = new SimpleDateFormat(
+                        "EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
+                    dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
+                    notBefore = dateFormat.parse(rt).getTime();
+                }
+                catch (Exception ex)
+                {
+                    throw new ESTException(
+                        "Unable to parse Retry-After header:" + req.getURL().toString() + " " + ex.getMessage(), null,
+                        resp.getStatusCode(), resp.getInputStream());
+                }
+            }
+
+            return new EnrollmentResponse(null, notBefore, req, resp.getSource());
+
+        }
+        else if (resp.getStatusCode() == 200)
+        {
+            ASN1InputStream ain = new ASN1InputStream(resp.getInputStream());
+            SimplePKIResponse spkr = null;
+            try
+            {
+                spkr = new SimplePKIResponse(ContentInfo.getInstance(ain.readObject()));
+            }
+            catch (CMCException e)
+            {
+                throw new ESTException(e.getMessage(), e.getCause());
+            }
+            enrolled = spkr.getCertificates();
+            return new EnrollmentResponse(enrolled, -1, null, resp.getSource());
+        }
+
+        throw new ESTException(
+            "Simple Enroll: " + req.getURL().toString(), null,
+            resp.getStatusCode(), resp.getInputStream());
+
+    }
+
+    /**
+     * Fetch he CSR Attributes from the server.
+     *
+     * @return A CSRRequestResponse with the attributes.
+     * @throws ESTException
+     */
+    public CSRRequestResponse getCSRAttributes()
+        throws ESTException
+    {
+
+        if (!clientProvider.isTrusted())
+        {
+            throw new IllegalStateException("No trust anchors.");
+        }
+
+        ESTResponse resp = null;
+        CSRAttributesResponse response = null;
+        Exception finalThrowable = null;
+        URL url = null;
+        try
+        {
+            url = new URL(server + CSRATTRS);
+
+            ESTClient client = clientProvider.makeClient();
+            ESTRequest req = new ESTRequestBuilder("GET", url).withClient(client).build(); //    new ESTRequest("GET", url, null);
+            resp = client.doRequest(req);
+
+
+            switch (resp.getStatusCode())
+            {
+            case 200:
+                try
+                {
+                    if (resp.getContentLength() != null && resp.getContentLength() > 0)
+                    {
+                        ASN1InputStream ain = new ASN1InputStream(resp.getInputStream());
+                        ASN1Sequence seq = (ASN1Sequence)ain.readObject();
+                        response = new CSRAttributesResponse(CsrAttrs.getInstance(seq));
+                    }
+                }
+                catch (Throwable ex)
+                {
+                    throw new ESTException("Decoding CACerts: " + url.toString() + " " + ex.getMessage(), ex, resp.getStatusCode(), resp.getInputStream());
+                }
+
+                break;
+            case 204:
+                response = null;
+                break;
+            case 404:
+                response = null;
+                break;
+            default:
+                throw new ESTException(
+                    "CSR Attribute request: " + req.getURL().toString(), null,
+                    resp.getStatusCode(), resp.getInputStream());
+            }
+        }
+        catch (Throwable t)
+        {
+
+            if (t instanceof ESTException)
+            {
+                throw (ESTException)t;
+            }
+            else
+            {
+                throw new ESTException(t.getMessage(), t);
+            }
+        }
+        finally
+        {
+            if (resp != null)
+            {
+                try
+                {
+                    resp.close();
+                }
+                catch (Exception ex)
+                {
+                    finalThrowable = ex;
+                }
+            }
+        }
+
+        if (finalThrowable != null)
+        {
+            if (finalThrowable instanceof ESTException)
+            {
+                throw (ESTException)finalThrowable;
+            }
+            throw new ESTException(finalThrowable.getMessage(), finalThrowable, resp.getStatusCode(), null);
+        }
+
+        return new CSRRequestResponse(response, resp.getSource());
+    }
+
+    private String annotateRequest(byte[] data)
+    {
+        int i = 0;
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        // pw.print("-----BEGIN CERTIFICATE REQUEST-----\n");
+        do
+        {
+            if (i + 48 < data.length)
+            {
+                pw.print(Base64.toBase64String(data, i, 48));
+                i += 48;
+            }
+            else
+            {
+                pw.print(Base64.toBase64String(data, i, data.length - i));
+                i = data.length;
+            }
+            pw.print('\n');
+        }
+        while (i < data.length);
+        //  pw.print("-----END CERTIFICATE REQUEST-----\n");
+        pw.flush();
+        return sw.toString();
+    }
+
+
+    private String verifyLabel(String label)
+    {
+        while (label.endsWith("/") && label.length() > 0)
+        {
+            label = label.substring(0, label.length() - 1);
+        }
+
+        while (label.startsWith("/") && label.length() > 0)
+        {
+            label = label.substring(1);
+        }
+
+        if (label.length() == 0)
+        {
+            throw new IllegalArgumentException("Label set but after trimming '/' is not zero length string.");
+        }
+
+        if (!pathInvalid.matcher(label).matches())
+        {
+            throw new IllegalArgumentException("Server path " + label + " contains invalid characters");
+        }
+
+        if (illegalParts.contains(label))
+        {
+            throw new IllegalArgumentException("Label " + label + " is a reserved path segment.");
+        }
+
+        return label;
+
+    }
+
+
+    private String verifyServer(String server)
+    {
+        try
+        {
+
+            while (server.endsWith("/") && server.length() > 0)
+            {
+                server = server.substring(0, server.length() - 1);
+            }
+
+            if (server.contains("://"))
+            {
+                throw new IllegalArgumentException("Server contains scheme, must only be <dnsname/ipaddress>:port, https:// will be added arbitrarily.");
+            }
+
+            URL u = new URL("https://" + server);
+            if (u.getPath().length() == 0 || u.getPath().equals("/"))
+            {
+                return server;
+            }
+
+            throw new IllegalArgumentException("Server contains path, must only be <dnsname/ipaddress>:port, a path of '/.well-known/est/<label>' will be added arbitrarily.");
+
+        }
+        catch (Exception ex)
+        {
+            if (ex instanceof IllegalArgumentException)
+            {
+                throw (IllegalArgumentException)ex;
+            }
+            throw new IllegalArgumentException("Scheme and host is invalid: " + ex.getMessage(), ex);
+        }
+
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTServiceBuilder.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTServiceBuilder.java
new file mode 100644
index 0000000..ed2a861
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTServiceBuilder.java
@@ -0,0 +1,63 @@
+package org.bouncycastle.est;
+
+
+/**
+ * Build an RFC7030 (EST) service.
+ */
+public class ESTServiceBuilder
+{
+    protected final String server;
+    protected ESTClientProvider clientProvider;
+    protected String label;
+
+    /**
+     * With scheme and host..
+     *
+     * @param server The authority name, eg estserver.co.au
+     */
+    public ESTServiceBuilder(String server)
+    {
+        this.server = server;
+    }
+
+    /**
+     * Set the label as per https://tools.ietf.org/html/rfc7030#section-3.2.2
+     *
+     * @param label The label.
+     * @return this builder.
+     */
+    public ESTServiceBuilder withLabel(String label)
+    {
+        this.label = label;
+        return this;
+    }
+
+    /**
+     * Set the client provider.
+     *
+     * @param clientProvider The client provider.
+     * @return
+     */
+    public ESTServiceBuilder withClientProvider(ESTClientProvider clientProvider)
+    {
+        this.clientProvider = clientProvider;
+        return this;
+    }
+
+    /**
+     * Build the service.
+     *
+     * @return an ESTService.
+     */
+    public ESTService build()
+    {
+        return new ESTService(
+            server,
+            label,
+            clientProvider);
+    }
+
+}
+
+
+
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/ESTSourceConnectionListener.java b/bcpkix/src/main/java/org/bouncycastle/est/ESTSourceConnectionListener.java
new file mode 100644
index 0000000..7c2c813
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/ESTSourceConnectionListener.java
@@ -0,0 +1,14 @@
+package org.bouncycastle.est;
+
+import java.io.IOException;
+
+/**
+ * ESTSourceConnectionListener is called when the source is
+ * is connected to the remote end point but no application
+ * data has been sent.
+ */
+public interface ESTSourceConnectionListener<T, I>
+{
+    ESTRequest onConnection(Source<T> source, ESTRequest request)
+        throws IOException;
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/EnrollmentResponse.java b/bcpkix/src/main/java/org/bouncycastle/est/EnrollmentResponse.java
new file mode 100644
index 0000000..d2785ee
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/EnrollmentResponse.java
@@ -0,0 +1,59 @@
+package org.bouncycastle.est;
+
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.util.Store;
+
+
+/**
+ * Holder class for a response containing the details making up a /simpleenroll response.
+ */
+public class EnrollmentResponse
+{
+    private final Store<X509CertificateHolder> store;
+    private final long notBefore;
+    private final ESTRequest requestToRetry;
+    private final Source source;
+
+    public EnrollmentResponse(Store<X509CertificateHolder> store, long notBefore, ESTRequest requestToRetry, Source session)
+    {
+        this.store = store;
+        this.notBefore = notBefore;
+        this.requestToRetry = requestToRetry;
+        this.source = session;
+    }
+
+    public boolean canRetry()
+    {
+        return notBefore < System.currentTimeMillis();
+    }
+
+    public Store<X509CertificateHolder> getStore()
+    {
+        return store;
+    }
+
+    public long getNotBefore()
+    {
+        return notBefore;
+    }
+
+    public ESTRequest getRequestToRetry()
+    {
+        return requestToRetry;
+    }
+
+    public Object getSession()
+    {
+        return source.getSession();
+    }
+
+    public Source getSource()
+    {
+        return source;
+    }
+
+    public boolean isCompleted()
+    {
+        return requestToRetry == null;
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/HttpAuth.java b/bcpkix/src/main/java/org/bouncycastle/est/HttpAuth.java
new file mode 100644
index 0000000..b4b2ade
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/HttpAuth.java
@@ -0,0 +1,478 @@
+package org.bouncycastle.est;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.bouncycastle.asn1.DERNull;
+import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.operator.DefaultDigestAlgorithmIdentifierFinder;
+import org.bouncycastle.operator.DigestAlgorithmIdentifierFinder;
+import org.bouncycastle.operator.DigestCalculator;
+import org.bouncycastle.operator.DigestCalculatorProvider;
+import org.bouncycastle.operator.OperatorCreationException;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.Hex;
+
+/**
+ * Provides stock implementations for basic auth and digest auth.
+ */
+public class HttpAuth
+    implements ESTAuth
+{
+    private static final DigestAlgorithmIdentifierFinder digestAlgorithmIdentifierFinder = new DefaultDigestAlgorithmIdentifierFinder();
+
+    private final String realm;
+    private final String username;
+    private final char[] password;
+    private final SecureRandom nonceGenerator;
+    private final DigestCalculatorProvider digestCalculatorProvider;
+
+    private static final Set<String> validParts;
+
+    static
+    {
+        HashSet<String> s = new HashSet<String>();
+        s.add("realm");
+        s.add("nonce");
+        s.add("opaque");
+        s.add("algorithm");
+        s.add("qop");
+        validParts = Collections.unmodifiableSet(s);
+    }
+
+    /**
+     * Base constructor for basic auth.
+     *
+     * @param username user id.
+     * @param password user's password.
+     */
+    public HttpAuth(String username, char[] password)
+    {
+        this(null, username, password, null, null);
+    }
+
+    /**
+     * Constructor for basic auth with a specified realm.
+     *
+     * @param realm    expected server realm.
+     * @param username user id.
+     * @param password user's password.
+     */
+    public HttpAuth(String realm, String username, char[] password)
+    {
+        this(realm, username, password, null, null);
+    }
+
+    /**
+     * Base constructor for digest auth. The realm will be set by
+     *
+     * @param username                 user id.
+     * @param password                 user's password.
+     * @param nonceGenerator           random source for generating nonces.
+     * @param digestCalculatorProvider provider for digest calculators needed for calculating hashes.
+     */
+    public HttpAuth(String username, char[] password, SecureRandom nonceGenerator, DigestCalculatorProvider digestCalculatorProvider)
+    {
+        this(null, username, password, nonceGenerator, digestCalculatorProvider);
+    }
+
+    /**
+     * Constructor for digest auth with a specified realm.
+     *
+     * @param realm                    expected server realm.
+     * @param username                 user id.
+     * @param password                 user's password.
+     * @param nonceGenerator           random source for generating nonces.
+     * @param digestCalculatorProvider provider for digest calculators needed for calculating hashes.
+     */
+    public HttpAuth(String realm, String username, char[] password, SecureRandom nonceGenerator, DigestCalculatorProvider digestCalculatorProvider)
+    {
+        this.realm = realm;
+        this.username = username;
+        this.password = password;
+        this.nonceGenerator = nonceGenerator;
+        this.digestCalculatorProvider = digestCalculatorProvider;
+    }
+
+    public void applyAuth(final ESTRequestBuilder reqBldr)
+    {
+        reqBldr.withHijacker(new ESTHijacker()
+        {
+            public ESTResponse hijack(ESTRequest req, Source sock)
+                throws IOException
+            {
+                ESTResponse res = new ESTResponse(req, sock);
+
+                if (res.getStatusCode() == 401)
+                {
+                    String authHeader = res.getHeader("WWW-Authenticate");
+                    if (authHeader == null)
+                    {
+                        throw new ESTException("Status of 401 but no WWW-Authenticate header");
+                    }
+
+                    authHeader = Strings.toLowerCase(authHeader);
+
+                    if (authHeader.startsWith("digest"))
+                    {
+                        res = doDigestFunction(res);
+                    }
+                    else if (authHeader.startsWith("basic"))
+                    {
+                        res.close(); // Close off the last reqBldr.
+
+                        //
+                        // Check realm field from header.
+                        //
+                        Map<String, String> s = HttpUtil.splitCSL("Basic", res.getHeader("WWW-Authenticate"));
+
+                        //
+                        // If no realm supplied it will not check the server realm. TODO elaborate in documentation.
+                        //
+                        if (realm != null)
+                        {
+                            if (!realm.equals(s.get("realm")))
+                            {
+                                // Not equal then fail.
+                                throw new ESTException("Supplied realm '" + realm + "' does not match server realm '" + s.get("realm") + "'", null, 401, null);
+                            }
+                        }
+
+                        //
+                        // Prepare basic auth answer.
+                        //
+                        ESTRequestBuilder answer = new ESTRequestBuilder(req).withHijacker(null);
+
+                        if (realm != null && realm.length() > 0)
+                        {
+                            answer.setHeader("WWW-Authenticate", "Basic realm=\"" + realm + "\"");
+                        }
+                        if (username.contains(":"))
+                        {
+                            throw new IllegalArgumentException("User must not contain a ':'");
+                        }
+                        String userPass = username + ":" + new String(password);
+                        answer.setHeader("Authorization", "Basic " + Base64.toBase64String(userPass.getBytes()));
+
+                        res = req.getClient().doRequest(answer.build());
+                    }
+                    else
+                    {
+                        throw new ESTException("Unknown auth mode: " + authHeader);
+                    }
+
+
+                    return res;
+                }
+                return res;
+            }
+        });
+    }
+
+    private ESTResponse doDigestFunction(ESTResponse res)
+        throws IOException
+    {
+        res.close(); // Close off the last request.
+        ESTRequest req = res.getOriginalRequest();
+
+
+        Map<String, String> parts = null;
+        try
+        {
+            parts = HttpUtil.splitCSL("Digest", res.getHeader("WWW-Authenticate"));
+        }
+        catch (Throwable t)
+        {
+            throw new ESTException(
+                "Parsing WWW-Authentication header: " + t.getMessage(),
+                t,
+                res.getStatusCode(),
+                new ByteArrayInputStream(res.getHeader("WWW-Authenticate").getBytes()));
+        }
+
+
+        String uri = null;
+        try
+        {
+            uri = req.getURL().toURI().getPath();
+        }
+        catch (Exception e)
+        {
+            throw new IOException("unable to process URL in request: " + e.getMessage());
+        }
+
+        for (Iterator it = parts.keySet().iterator(); it.hasNext();)
+        {
+            Object k = it.next();
+            if (!validParts.contains(k))
+            {
+                throw new ESTException("Unrecognised entry in WWW-Authenticate header: '" + k + "'");
+            }
+        }
+
+        String method = req.getMethod();
+        String realm = parts.get("realm");
+        String nonce = parts.get("nonce");
+        String opaque = parts.get("opaque");
+        String algorithm = parts.get("algorithm");
+        String qop = parts.get("qop");
+
+
+        List<String> qopMods = new ArrayList<String>(); // Preserve ordering.
+
+        if (this.realm != null)
+        {
+            if (!this.realm.equals(realm))
+            {
+                // Not equal then fail.
+                throw new ESTException("Supplied realm '" + this.realm + "' does not match server realm '" + realm + "'", null, 401, null);
+            }
+        }
+
+        // If an algorithm is not specified, default to MD5.
+        if (algorithm == null)
+        {
+            algorithm = "MD5";
+        }
+
+        if (algorithm.length() == 0)
+        {
+            throw new ESTException("WWW-Authenticate no algorithm defined.");
+        }
+
+        algorithm = Strings.toUpperCase(algorithm);
+
+        if (qop != null)
+        {
+            if (qop.length() == 0)
+            {
+                throw new ESTException("QoP value is empty.");
+            }
+
+            qop = Strings.toLowerCase(qop);
+            String[] s = qop.split(",");
+            for (int j = 0; j != s.length; j++)
+            {
+                if (!s[j].equals("auth") && !s[j].equals("auth-int"))
+                {
+                    throw new ESTException("QoP value unknown: '" + j + "'");
+                }
+
+                String jt = s[j].trim();
+                if (qopMods.contains(jt))
+                {
+                    continue;
+                }
+                qopMods.add(jt);
+            }
+        }
+        else
+        {
+            throw new ESTException("Qop is not defined in WWW-Authenticate header.");
+        }
+
+
+        AlgorithmIdentifier digestAlg = lookupDigest(algorithm);
+        if (digestAlg == null || digestAlg.getAlgorithm() == null)
+        {
+            throw new IOException("auth digest algorithm unknown: " + algorithm);
+        }
+
+        DigestCalculator dCalc = getDigestCalculator(algorithm, digestAlg);
+        OutputStream dOut = dCalc.getOutputStream();
+
+        String crnonce = makeNonce(10); // TODO arbitrary?
+
+        update(dOut, username);
+        update(dOut, ":");
+        update(dOut, realm);
+        update(dOut, ":");
+        update(dOut, password);
+
+        dOut.close();
+
+        byte[] ha1 = dCalc.getDigest();
+
+        if (algorithm.endsWith("-SESS"))
+        {
+            DigestCalculator sessCalc = getDigestCalculator(algorithm, digestAlg);
+            OutputStream sessOut = sessCalc.getOutputStream();
+
+            String cs = Hex.toHexString(ha1);
+
+            update(sessOut, cs);
+            update(sessOut, ":");
+            update(sessOut, nonce);
+            update(sessOut, ":");
+            update(sessOut, crnonce);
+
+            sessOut.close();
+
+            ha1 = sessCalc.getDigest();
+        }
+
+        String hashHa1 = Hex.toHexString(ha1);
+
+        DigestCalculator authCalc = getDigestCalculator(algorithm, digestAlg);
+        OutputStream authOut = authCalc.getOutputStream();
+
+        if (qopMods.get(0).equals("auth-int"))
+        {
+            DigestCalculator reqCalc = getDigestCalculator(algorithm, digestAlg);
+            OutputStream reqOut = reqCalc.getOutputStream();
+
+            req.writeData(reqOut);
+
+            reqOut.close();
+
+            byte[] b = reqCalc.getDigest();
+
+            update(authOut, method);
+            update(authOut, ":");
+            update(authOut, uri);
+            update(authOut, ":");
+            update(authOut, Hex.toHexString(b));
+        }
+        else if (qopMods.get(0).equals("auth"))
+        {
+            update(authOut, method);
+            update(authOut, ":");
+            update(authOut, uri);
+        }
+
+        authOut.close();
+
+        String hashHa2 = Hex.toHexString(authCalc.getDigest());
+
+        DigestCalculator responseCalc = getDigestCalculator(algorithm, digestAlg);
+        OutputStream responseOut = responseCalc.getOutputStream();
+
+        if (qopMods.contains("missing"))
+        {
+            update(responseOut, hashHa1);
+            update(responseOut, ":");
+            update(responseOut, nonce);
+            update(responseOut, ":");
+            update(responseOut, hashHa2);
+        }
+        else
+        {
+            update(responseOut, hashHa1);
+            update(responseOut, ":");
+            update(responseOut, nonce);
+            update(responseOut, ":");
+            update(responseOut, "00000001");
+            update(responseOut, ":");
+            update(responseOut, crnonce);
+            update(responseOut, ":");
+
+            if (qopMods.get(0).equals("auth-int"))
+            {
+                update(responseOut, "auth-int");
+            }
+            else
+            {
+                update(responseOut, "auth");
+            }
+
+            update(responseOut, ":");
+            update(responseOut, hashHa2);
+        }
+
+        responseOut.close();
+
+        String digest = Hex.toHexString(responseCalc.getDigest());
+
+        Map<String, String> hdr = new HashMap<String, String>();
+        hdr.put("username", username);
+        hdr.put("realm", realm);
+        hdr.put("nonce", nonce);
+        hdr.put("uri", uri);
+        hdr.put("response", digest);
+        if (qopMods.get(0).equals("auth-int"))
+        {
+            hdr.put("qop", "auth-int");
+            hdr.put("nc", "00000001");
+            hdr.put("cnonce", crnonce);
+        }
+        else if (qopMods.get(0).equals("auth"))
+        {
+            hdr.put("qop", "auth");
+            hdr.put("nc", "00000001");
+            hdr.put("cnonce", crnonce);
+        }
+        hdr.put("algorithm", algorithm);
+
+        if (opaque == null || opaque.length() == 0)
+        {
+            hdr.put("opaque", makeNonce(20));
+        }
+
+        ESTRequestBuilder answer = new ESTRequestBuilder(req).withHijacker(null);
+
+        answer.setHeader("Authorization", HttpUtil.mergeCSL("Digest", hdr));
+
+        return req.getClient().doRequest(answer.build());
+    }
+
+    private DigestCalculator getDigestCalculator(String algorithm, AlgorithmIdentifier digestAlg)
+        throws IOException
+    {
+        DigestCalculator dCalc;
+        try
+        {
+            dCalc = digestCalculatorProvider.get(digestAlg);
+        }
+        catch (OperatorCreationException e)
+        {
+            throw new IOException("cannot create digest calculator for " + algorithm + ": " + e.getMessage());
+        }
+        return dCalc;
+    }
+
+    private AlgorithmIdentifier lookupDigest(String algorithm)
+    {
+        if (algorithm.endsWith("-SESS"))
+        {
+            algorithm = algorithm.substring(0, algorithm.length() - "-SESS".length());
+        }
+
+        if (algorithm.equals("SHA-512-256"))
+        {
+            return new AlgorithmIdentifier(NISTObjectIdentifiers.id_sha512_256, DERNull.INSTANCE);
+        }
+
+        return digestAlgorithmIdentifierFinder.find(algorithm);
+    }
+
+    private void update(OutputStream dOut, char[] value)
+        throws IOException
+    {
+        dOut.write(Strings.toUTF8ByteArray(value));
+    }
+
+    private void update(OutputStream dOut, String value)
+        throws IOException
+    {
+        dOut.write(Strings.toUTF8ByteArray(value));
+    }
+
+    private String makeNonce(int len)
+    {
+        byte[] b = new byte[len];
+        nonceGenerator.nextBytes(b);
+        return Hex.toHexString(b);
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/HttpUtil.java b/bcpkix/src/main/java/org/bouncycastle/est/HttpUtil.java
new file mode 100644
index 0000000..ecd09e3
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/HttpUtil.java
@@ -0,0 +1,281 @@
+package org.bouncycastle.est;
+
+
+import java.io.StringWriter;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+class HttpUtil
+{
+
+    /**
+     * Merge kv into comma separated set of key="value" pairs.
+     *
+     * @param prefix Optional prefix to apply, eg:  prefix key="value" (,key="value")
+     * @param kv
+     * @return
+     */
+    static String mergeCSL(String prefix, Map<String, String> kv)
+    {
+        StringWriter sw = new StringWriter();
+        sw.write(prefix);
+        sw.write(' ');
+        boolean comma = false;
+        for (Iterator it = kv.entrySet().iterator(); it.hasNext();)
+        {
+            Map.Entry<String, String> ent = (Map.Entry<String, String>)it.next();
+
+            if (!comma)
+            {
+                comma = true;
+            }
+            else
+            {
+                sw.write(',');
+            }
+
+            sw.write(ent.getKey());
+            sw.write("=\"");
+            sw.write(ent.getValue());
+            sw.write('"');
+        }
+
+        return sw.toString();
+    }
+
+
+    static Map<String, String> splitCSL(String skip, String src)
+    {
+        src = src.trim();
+        if (src.startsWith(skip))
+        {
+            src = src.substring(skip.length());
+        }
+
+        return new PartLexer(src).Parse();
+    }
+
+
+    static class PartLexer
+    {
+        private final String src;
+        int last = 0;
+        int p = 0;
+
+        PartLexer(String src)
+        {
+            this.src = src;
+        }
+
+
+        Map<String, String> Parse()
+        {
+            Map<String, String> out = new HashMap<String, String>();
+            String key = null;
+            String value = null;
+            while (p < src.length())
+            {
+                skipWhiteSpace();
+
+                key = consumeAlpha();
+                if (key.length() == 0)
+                {
+                    throw new IllegalArgumentException("Expecting alpha label.");
+                }
+                skipWhiteSpace();
+                if (!consumeIf('='))
+                {
+                    throw new IllegalArgumentException("Expecting assign: '='");
+                }
+
+
+                skipWhiteSpace();
+                if (!consumeIf('"'))
+                {
+                    throw new IllegalArgumentException("Expecting start quote: '\"'");
+                }
+                discard();
+
+                value = consumeUntil('"');
+                discard(1);
+                out.put(key, value);
+
+                skipWhiteSpace();
+                if (!consumeIf(','))
+                {
+                    break;
+                }
+                discard();
+            }
+
+            return out;
+        }
+
+
+        private String consumeAlpha()
+        {
+            char c = src.charAt(p);
+            while (p < src.length() && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
+            {
+                p++;
+                c = src.charAt(p);
+            }
+            String s = src.substring(last, p);
+            last = p;
+            return s;
+        }
+
+        private void skipWhiteSpace()
+        {
+            while (p < src.length() && (src.charAt(p) < 33))
+            {
+                p++;
+            }
+            last = p;
+        }
+
+        private boolean consumeIf(char c)
+        {
+
+            if (p < src.length() && src.charAt(p) == c)
+            {
+                p++;
+                return true;
+            }
+            return false;
+        }
+
+        private String consumeUntil(char c)
+        {
+            while (p < src.length() && (src.charAt(p) != c))
+            {
+                p++;
+            }
+            String s = src.substring(last, p);
+            last = p;
+            return s;
+        }
+
+        private void discard()
+        {
+            last = p;
+        }
+
+        private void discard(int i)
+        {
+            p += i;
+            last = p;
+        }
+
+    }
+
+    static class Headers
+        extends HashMap<String, String[]>
+    {
+        public Headers()
+        {
+            super();
+        }
+
+        public String getFirstValue(String key)
+        {
+            String[] j = getValues(key);
+            if (j != null && j.length > 0)
+            {
+                return j[0];
+            }
+            return null;
+        }
+
+        public String[] getValues(String key)
+        {
+            key = actualKey(key);
+            if (key == null)
+            {
+                return null;
+            }
+            return get(key);
+        }
+
+        private String actualKey(String header)
+        {
+            if (containsKey(header))
+            {
+                return header;
+            }
+
+            for (Iterator it = keySet().iterator(); it.hasNext();)
+            {
+                String k = (String)it.next();
+                if (header.equalsIgnoreCase(k))
+                {
+                    return k;
+                }
+            }
+
+            return null;
+        }
+
+        private boolean hasHeader(String header)
+        {
+            return actualKey(header) != null;
+        }
+
+
+        public void set(String key, String value)
+        {
+            put(key, new String[]{value});
+        }
+
+        public void add(String key, String value)
+        {
+            put(key, append(get(key), value));
+        }
+
+        public void ensureHeader(String key, String value)
+        {
+            if (!containsKey(key))
+            {
+                set(key, value);
+            }
+        }
+        
+        public Object clone()
+        {
+            Headers n = new Headers();
+            for (Iterator it = entrySet().iterator(); it.hasNext();)
+            {
+                Map.Entry v = (Map.Entry)it.next();
+
+                n.put((String)v.getKey(), copy((String[])v.getValue()));
+            }
+            return n;
+        }
+
+        private String[] copy(String[] vs)
+        {
+            String[] rv = new String[vs.length];
+
+            System.arraycopy(vs, 0, rv, 0, rv.length);
+            
+            return rv;
+        }
+    }
+
+
+    public static String[] append(String[] a, String b)
+    {
+        if (a == null)
+        {
+            return new String[]{b};
+        }
+
+        int length = a.length;
+        String[] result = new String[length + 1];
+        System.arraycopy(a, 0, result, 0, length);
+        result[length] = b;
+        return result;
+    }
+
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/LimitedSource.java b/bcpkix/src/main/java/org/bouncycastle/est/LimitedSource.java
new file mode 100644
index 0000000..5309a3e
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/LimitedSource.java
@@ -0,0 +1,15 @@
+package org.bouncycastle.est;
+
+
+/**
+ * Interface for a Source which can only produce up to a certain number of bytes.
+ */
+public interface LimitedSource
+{
+    /**
+     * Return the maximum number of bytes available from this source.
+     *
+     * @return the max bytes this source can produce.
+     */
+    Long getAbsoluteReadLimit();
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/Source.java b/bcpkix/src/main/java/org/bouncycastle/est/Source.java
new file mode 100644
index 0000000..ecb8eb4
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/Source.java
@@ -0,0 +1,26 @@
+package org.bouncycastle.est;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Used to Wrap a socket and to provide access to the underlying session.
+ *
+ * @param <T> Is the type of session that is returned. Eg For JSSE would be SSLSession.
+ */
+public interface Source<T>
+{
+    InputStream getInputStream()
+        throws IOException;
+
+    OutputStream getOutputStream()
+        throws IOException;
+
+    T getSession();
+
+    void close()
+        throws IOException;
+
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/TLSUniqueProvider.java b/bcpkix/src/main/java/org/bouncycastle/est/TLSUniqueProvider.java
new file mode 100644
index 0000000..7e0973f
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/TLSUniqueProvider.java
@@ -0,0 +1,21 @@
+package org.bouncycastle.est;
+
+/**
+ * TLSUniqueProvider implementation of this can provide the TLS unique value.
+ */
+public interface TLSUniqueProvider
+{
+    /**
+     * Return true if a TLS unique value should be available.
+     *
+     * @return true if a TLS unique should be available, false otherwise.
+     */
+    boolean isTLSUniqueAvailable();
+
+    /**
+     * Return the TLS unique value.
+     *
+     * @return a TLS unique value.
+     */
+    byte[] getTLSUnique();
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/ChannelBindingProvider.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/ChannelBindingProvider.java
new file mode 100644
index 0000000..fe8e374
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/ChannelBindingProvider.java
@@ -0,0 +1,18 @@
+package org.bouncycastle.est.jcajce;
+
+
+import java.net.Socket;
+
+/**
+ * Channel Binding Provider provides a method of extracting the
+ * ChannelBinding that can be customised specifically for the provider.
+ * Presently JSSE does not support RFC 5920.
+ *
+ * @See https://bugs.openjdk.java.net/browse/JDK-6491070
+ */
+public interface ChannelBindingProvider
+{
+    boolean canAccessChannelBinding(Socket sock);
+
+    byte[] getChannelBinding(Socket sock, String binding);
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTClient.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTClient.java
new file mode 100644
index 0000000..a3a5fb4
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTClient.java
@@ -0,0 +1,223 @@
+package org.bouncycastle.est.jcajce;
+
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import org.bouncycastle.est.ESTClient;
+import org.bouncycastle.est.ESTClientSourceProvider;
+import org.bouncycastle.est.ESTException;
+import org.bouncycastle.est.ESTRequest;
+import org.bouncycastle.est.ESTRequestBuilder;
+import org.bouncycastle.est.ESTResponse;
+import org.bouncycastle.est.Source;
+import org.bouncycastle.util.Properties;
+
+class DefaultESTClient
+    implements ESTClient
+{
+    private static final Charset utf8 = Charset.forName("UTF-8");
+    private static byte[] CRLF = new byte[]{'\r', '\n'};
+    private final ESTClientSourceProvider sslSocketProvider;
+
+    public DefaultESTClient(ESTClientSourceProvider sslSocketProvider)
+    {
+        this.sslSocketProvider = sslSocketProvider;
+    }
+
+    private static void writeLine(OutputStream os, String s)
+        throws IOException
+    {
+        os.write(s.getBytes());
+        os.write(CRLF);
+    }
+
+    public ESTResponse doRequest(ESTRequest req)
+        throws IOException
+    {
+        ESTResponse resp = null;
+        ESTRequest r = req;
+        int rcCount = 15;
+        do
+        {
+            resp = performRequest(r);
+            r = redirectURL(resp);
+        }
+        while (r != null && --rcCount > 0); // Follow redirects.
+
+        if (rcCount == 0)
+        {
+            throw new ESTException("Too many redirects..");
+        }
+
+        return resp;
+    }
+
+    protected ESTRequest redirectURL(ESTResponse response)
+        throws IOException
+    {
+        ESTRequest redirectingRequest = null;
+
+        if (response.getStatusCode() >= 300 && response.getStatusCode() <= 399)
+        {
+
+            switch (response.getStatusCode())
+            {
+            case 301:
+            case 302:
+            case 303:
+            case 306:
+            case 307:
+                String loc = response.getHeader("Location");
+                if ("".equals(loc))
+                {
+                    throw new ESTException("Redirect status type: " + response.getStatusCode() + " but no location header");
+                }
+
+                ESTRequestBuilder requestBuilder = new ESTRequestBuilder(response.getOriginalRequest());
+                if (loc.startsWith("http"))
+                {
+                    redirectingRequest = requestBuilder.withURL(new URL(loc)).build();
+                }
+                else
+                {
+                    URL u = response.getOriginalRequest().getURL();
+                    redirectingRequest = requestBuilder.withURL(new URL(u.getProtocol(), u.getHost(), u.getPort(), loc)).build();
+                }
+                break;
+            default:
+                throw new ESTException("Client does not handle http status code: " + response.getStatusCode());
+            }
+        }
+
+        if (redirectingRequest != null)
+        {
+            response.close(); // Close original request.
+        }
+
+        return redirectingRequest;
+    }
+
+    public ESTResponse performRequest(ESTRequest c)
+        throws IOException
+    {
+
+
+        ESTResponse res = null;
+        Source socketSource = null;
+        try
+        {
+            socketSource = sslSocketProvider.makeSource(c.getURL().getHost(), c.getURL().getPort());
+            if (c.getListener() != null)
+            {
+                c = c.getListener().onConnection(socketSource, c);
+            }
+
+            //  socketSource = new SSLSocketSource((SSLSocket)sock);
+
+            OutputStream os = null;
+
+            Set<String> opts = Properties.asKeySet("org.bouncycastle.debug.est");
+            if (opts.contains("output") ||
+                opts.contains("all"))
+            {
+                os = new PrintingOutputStream(socketSource.getOutputStream());
+            }
+            else
+            {
+                os = socketSource.getOutputStream();
+            }
+
+            String req = c.getURL().getPath() + ((c.getURL().getQuery() != null) ? c.getURL().getQuery() : "");
+
+            ESTRequestBuilder rb = new ESTRequestBuilder(c);
+
+            Map<String, String[]> headers = c.getHeaders();
+
+            if (!headers.containsKey("Connection"))
+            {
+                rb.addHeader("Connection",  "close" );
+            }
+
+            // Replace host header.
+            URL u = c.getURL();
+            if (u.getPort() > -1)
+            {
+                rb.setHeader("Host", String.format("%s:%d", u.getHost(), u.getPort()));
+            }
+            else
+            {
+                rb.setHeader("Host", u.getHost());
+            }
+
+
+            ESTRequest rc = rb.build();
+
+            writeLine(os, rc.getMethod() + " " + req + " HTTP/1.1");
+
+
+            for (Iterator it = rc.getHeaders().entrySet().iterator(); it.hasNext();)
+            {
+                Map.Entry<String, String[]> ent = (Map.Entry<String, String[]>)it.next();
+                String[] vs = (String[])ent.getValue();
+
+                for (int i = 0; i != vs.length; i++)
+                {
+                    writeLine(os, ent.getKey() + ": " + vs[i]);
+                }
+            }
+
+            os.write(CRLF);
+            os.flush();
+
+            rc.writeData(os);
+
+            os.flush();
+
+            if (rc.getHijacker() != null)
+            {
+                res = rc.getHijacker().hijack(rc, socketSource);
+                return res;
+            }
+            else
+            {
+                res = new ESTResponse(rc, socketSource);
+            }
+
+            return res;
+
+        }
+        finally
+        {
+            // Close only if response not generated.
+            if (socketSource != null && res == null)
+            {
+                socketSource.close();
+            }
+        }
+
+    }
+
+    private class PrintingOutputStream
+        extends OutputStream
+    {
+        private final OutputStream tgt;
+
+        public PrintingOutputStream(OutputStream tgt)
+        {
+            this.tgt = tgt;
+        }
+
+        public void write(int b)
+            throws IOException
+        {
+            System.out.print(String.valueOf((char)b));
+            tgt.write(b);
+        }
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTClientSourceProvider.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTClientSourceProvider.java
new file mode 100644
index 0000000..3154145
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTClientSourceProvider.java
@@ -0,0 +1,148 @@
+package org.bouncycastle.est.jcajce;
+
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+import org.bouncycastle.est.ESTClientSourceProvider;
+import org.bouncycastle.est.Source;
+import org.bouncycastle.util.Strings;
+
+class DefaultESTClientSourceProvider
+    implements ESTClientSourceProvider
+{
+
+    private final SSLSocketFactory sslSocketFactory;
+    private final JsseHostnameAuthorizer hostNameAuthorizer;
+    private final int timeout;
+    private final ChannelBindingProvider bindingProvider;
+    private final Set<String> cipherSuites;
+    private final Long absoluteLimit;
+    private final boolean filterSupportedSuites;
+
+
+    public DefaultESTClientSourceProvider(
+        SSLSocketFactory socketFactory,
+        JsseHostnameAuthorizer hostNameAuthorizer,
+        int timeout, ChannelBindingProvider bindingProvider,
+        Set<String> cipherSuites, Long absoluteLimit,
+        boolean filterSupportedSuites)
+        throws GeneralSecurityException
+    {
+        this.sslSocketFactory = socketFactory;
+        this.hostNameAuthorizer = hostNameAuthorizer;
+        this.timeout = timeout;
+        this.bindingProvider = bindingProvider;
+        this.cipherSuites = cipherSuites;
+        this.absoluteLimit = absoluteLimit;
+        this.filterSupportedSuites = filterSupportedSuites;
+    }
+
+
+    public Source makeSource(String host, int port)
+        throws IOException
+    {
+        SSLSocket sock = (SSLSocket)sslSocketFactory.createSocket(host, port);
+        sock.setSoTimeout(timeout);
+
+        if (cipherSuites != null && !cipherSuites.isEmpty())
+        {
+            // Filter supplied list with what is actually supported.
+            if (filterSupportedSuites)
+            {
+                HashSet<String> fs = new HashSet<String>();
+                String[] supportedCipherSuites = sock.getSupportedCipherSuites();
+                for (int i = 0; i != supportedCipherSuites.length; i++)
+                {
+                    fs.add(supportedCipherSuites[i]);
+                }
+
+                List<String> j = new ArrayList<String>();
+                for (Iterator it = cipherSuites.iterator(); it.hasNext();)
+                {
+                    String s = (String)it.next();
+                    if (fs.contains(s))
+                    {
+                        j.add(s);
+                    }
+                }
+
+                if (j.isEmpty())
+                {
+                    throw new IllegalStateException("No supplied cipher suite is supported by the provider.");
+                }
+
+                sock.setEnabledCipherSuites(j.toArray(new String[j.size()]));
+            }
+            else
+            {
+                sock.setEnabledCipherSuites(cipherSuites.toArray(new String[cipherSuites.size()]));
+            }
+        }
+
+
+        sock.startHandshake();
+
+        if (hostNameAuthorizer != null)
+        {
+            if (!hostNameAuthorizer.verified(host, sock.getSession()))
+            {
+                throw new IOException("Host name could not be verified.");
+            }
+        }
+
+        {
+            String t = Strings.toLowerCase(sock.getSession().getCipherSuite());
+            if (t.contains("_des_") || t.contains("_des40_") || t.contains("_3des_"))
+            {
+                throw new IOException("EST clients must not use DES ciphers");
+            }
+        }
+
+        // check for use of null cipher and fail.
+        if (Strings.toLowerCase(sock.getSession().getCipherSuite()).contains("null"))
+        {
+            throw new IOException("EST clients must not use NULL ciphers");
+        }
+
+        // check for use of anon cipher and fail.
+        if (Strings.toLowerCase(sock.getSession().getCipherSuite()).contains("anon"))
+        {
+            throw new IOException("EST clients must not use anon ciphers");
+        }
+
+        // check for use of export cipher.
+        if (Strings.toLowerCase(sock.getSession().getCipherSuite()).contains("export"))
+        {
+            throw new IOException("EST clients must not use export ciphers");
+        }
+
+        if (sock.getSession().getProtocol().equalsIgnoreCase("tlsv1"))
+        {
+            try
+            {
+                sock.close();
+            }
+            catch (Exception ex)
+            {
+                // Deliberately ignored.
+            }
+            throw new IOException("EST clients must not use TLSv1");
+        }
+
+
+        if (hostNameAuthorizer != null && !hostNameAuthorizer.verified(host, sock.getSession()))
+        {
+            throw new IOException("Hostname was not verified: " + host);
+        }
+        return new LimitedSSLSocketSource(sock, bindingProvider, absoluteLimit);
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTHttpClientProvider.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTHttpClientProvider.java
new file mode 100644
index 0000000..15a5330
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/DefaultESTHttpClientProvider.java
@@ -0,0 +1,61 @@
+package org.bouncycastle.est.jcajce;
+
+import java.util.Set;
+
+import javax.net.ssl.SSLSocketFactory;
+
+import org.bouncycastle.est.ESTClient;
+import org.bouncycastle.est.ESTClientProvider;
+import org.bouncycastle.est.ESTException;
+
+class DefaultESTHttpClientProvider
+    implements ESTClientProvider
+{
+
+    private final JsseHostnameAuthorizer hostNameAuthorizer;
+    private final SSLSocketFactoryCreator socketFactoryCreator;
+
+    private final int timeout;
+    private final ChannelBindingProvider bindingProvider;
+    private final Set<String> cipherSuites;
+    private final Long absoluteLimit;
+    private final boolean filterCipherSuites;
+
+
+    public DefaultESTHttpClientProvider(
+        JsseHostnameAuthorizer hostNameAuthorizer,
+        SSLSocketFactoryCreator socketFactoryCreator, int timeout,
+        ChannelBindingProvider bindingProvider,
+        Set<String> cipherSuites, Long absoluteLimit, boolean filterCipherSuites)
+    {
+
+        this.hostNameAuthorizer = hostNameAuthorizer;
+        this.socketFactoryCreator = socketFactoryCreator;
+        this.timeout = timeout;
+        this.bindingProvider = bindingProvider;
+        this.cipherSuites = cipherSuites;
+        this.absoluteLimit = absoluteLimit;
+        this.filterCipherSuites = filterCipherSuites;
+    }
+
+    public ESTClient makeClient()
+        throws ESTException
+    {
+        try
+        {
+            SSLSocketFactory socketFactory = socketFactoryCreator.createFactory();
+            return new DefaultESTClient(
+                new DefaultESTClientSourceProvider(socketFactory, hostNameAuthorizer, timeout, bindingProvider, cipherSuites, absoluteLimit, filterCipherSuites));
+        }
+        catch (Exception e)
+        {
+            throw new ESTException(e.getMessage(), e.getCause());
+        }
+    }
+
+
+    public boolean isTrusted()
+    {
+        return socketFactoryCreator.isTrusted();
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JcaHttpAuthBuilder.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JcaHttpAuthBuilder.java
new file mode 100644
index 0000000..84e527c
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JcaHttpAuthBuilder.java
@@ -0,0 +1,97 @@
+package org.bouncycastle.est.jcajce;
+
+import java.security.Provider;
+import java.security.SecureRandom;
+
+import org.bouncycastle.est.HttpAuth;
+import org.bouncycastle.operator.OperatorCreationException;
+import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
+
+/**
+ * Builder for HttpAuth operator that handles digest auth using a JCA provider.
+ */
+public class JcaHttpAuthBuilder
+{
+    private JcaDigestCalculatorProviderBuilder providerBuilder = new JcaDigestCalculatorProviderBuilder();
+
+    private final String realm;
+    private final String username;
+    private final char[] password;
+    private SecureRandom random = new SecureRandom();
+
+    /**
+     * Base constructor for digest auth.
+     *
+     * @param username user id.
+     * @param password user's password.
+     */
+    public JcaHttpAuthBuilder(String username, char[] password)
+    {
+        this(null, username, password);
+    }
+
+    /**
+     * Base constructor for digest auth with an expected realm.
+     *
+     * @param realm    expected server realm.
+     * @param username user id.
+     * @param password user's password.
+     */
+    public JcaHttpAuthBuilder(String realm, String username, char[] password)
+    {
+        this.realm = realm;
+        this.username = username;
+        this.password = password;
+    }
+
+    /**
+     * Set the provider to use to provide the needed message digests.
+     *
+     * @param provider provider to use.
+     * @return this builder instance.
+     */
+    public JcaHttpAuthBuilder setProvider(Provider provider)
+    {
+        this.providerBuilder.setProvider(provider);
+
+        return this;
+    }
+
+    /**
+     * Set the provider to use to provide the needed message digests.
+     *
+     * @param providerName the name provider to use.
+     * @return this builder instance.
+     */
+    public JcaHttpAuthBuilder setProvider(String providerName)
+    {
+        this.providerBuilder.setProvider(providerName);
+
+        return this;
+    }
+
+    /**
+     * Set the SecureRandom to be used as a source of nonces.
+     *
+     * @param random the secure random to use as a nonce generator.
+     * @return this builder instance.
+     */
+    public JcaHttpAuthBuilder setNonceGenerator(SecureRandom random)
+    {
+        this.random = random;
+
+        return this;
+    }
+
+    /**
+     * Return a HttpAuth implementing digest auth for the user, password, and realm combination.
+     *
+     * @return a HttpAuth object.
+     * @throws OperatorCreationException if there is an issue setting up access to digest operators.
+     */
+    public HttpAuth build()
+        throws OperatorCreationException
+    {
+        return new HttpAuth(realm, username, password, random, providerBuilder.build());
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JcaJceUtils.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JcaJceUtils.java
new file mode 100644
index 0000000..cadcd92
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JcaJceUtils.java
@@ -0,0 +1,217 @@
+package org.bouncycastle.est.jcajce;
+
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.CRL;
+import java.security.cert.CertPathBuilder;
+import java.security.cert.CertStore;
+import java.security.cert.CertificateException;
+import java.security.cert.CollectionCertStoreParameters;
+import java.security.cert.PKIXBuilderParameters;
+import java.security.cert.PKIXCertPathValidatorResult;
+import java.security.cert.TrustAnchor;
+import java.security.cert.X509CertSelector;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Set;
+
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+import org.bouncycastle.asn1.x509.ExtendedKeyUsage;
+import org.bouncycastle.asn1.x509.KeyPurposeId;
+import org.bouncycastle.asn1.x509.KeyUsage;
+import org.bouncycastle.cert.X509CertificateHolder;
+
+
+/**
+ * General utility methods for building common objects for supporting the JCA/JCE/JSSE.
+ */
+public class JcaJceUtils
+{
+
+    public static X509TrustManager getTrustAllTrustManager()
+    {
+
+        //
+        // Trust manager signal distrust by throwing exceptions.
+        // This one trust all by doing nothing.
+        //
+
+        return new X509TrustManager()
+        {
+            public void checkClientTrusted(java.security.cert.X509Certificate[] x509Certificates, String s)
+                throws java.security.cert.CertificateException
+            {
+
+            }
+
+            public void checkServerTrusted(java.security.cert.X509Certificate[] x509Certificates, String s)
+                throws java.security.cert.CertificateException
+            {
+
+            }
+
+            public java.security.cert.X509Certificate[] getAcceptedIssuers()
+            {
+                return new java.security.cert.X509Certificate[0];
+            }
+        };
+
+    }
+
+    public static X509TrustManager[] getCertPathTrustManager(final Set<TrustAnchor> anchors, final CRL[] revocationLists)
+    {
+        final X509Certificate[] x509CertificateTrustAnchors = new X509Certificate[anchors.size()];
+        int c = 0;
+        for (Iterator it = anchors.iterator(); it.hasNext();)
+        {
+            TrustAnchor ta = (TrustAnchor)it.next();
+
+            x509CertificateTrustAnchors[c++] = ta.getTrustedCert();
+        }
+
+        return new X509TrustManager[]{new X509TrustManager()
+        {
+            public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
+                throws CertificateException
+            {
+
+            }
+
+            public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
+                throws CertificateException
+            {
+                try
+                {
+                    CertStore certStore = CertStore.getInstance("Collection",
+                        new CollectionCertStoreParameters(Arrays.asList(x509Certificates)), "BC");
+
+                    CertPathBuilder pathBuilder = CertPathBuilder.getInstance("PKIX", "BC");
+
+                    X509CertSelector constraints = new X509CertSelector();
+
+                    constraints.setCertificate(x509Certificates[0]);
+
+
+                    PKIXBuilderParameters param = new PKIXBuilderParameters(anchors, constraints);
+                    param.addCertStore(certStore);
+                    if (revocationLists != null)
+                    {
+                        param.setRevocationEnabled(true);
+                        param.addCertStore(
+                            CertStore.getInstance(
+                                "Collection",
+                                new CollectionCertStoreParameters(Arrays.asList(revocationLists)
+                                )));
+                    }
+                    else
+                    {
+                        param.setRevocationEnabled(false);
+                    }
+
+                    PKIXCertPathValidatorResult result = (PKIXCertPathValidatorResult)pathBuilder.build(param);
+
+                    validateServerCertUsage(x509Certificates[0]);
+
+                }
+                catch (CertificateException e)
+                {
+                    throw e;
+                }
+                catch (GeneralSecurityException e)
+                {
+                    throw new CertificateException("unable to process certificates: " + e.getMessage(), e);
+                }
+            }
+
+            public X509Certificate[] getAcceptedIssuers()
+            {
+                X509Certificate[] rv = new X509Certificate[x509CertificateTrustAnchors.length];
+
+                System.arraycopy(x509CertificateTrustAnchors, 0, rv, 0, rv.length);
+
+                return rv;
+            }
+        }
+        };
+    }
+
+    public static void validateServerCertUsage(X509Certificate x509Certificate)
+        throws CertificateException
+    {
+        try
+        {
+            X509CertificateHolder cert = new X509CertificateHolder(x509Certificate.getEncoded());
+
+            KeyUsage keyUsage = KeyUsage.fromExtensions(cert.getExtensions());
+
+            if (keyUsage != null)
+            {
+                if (keyUsage.hasUsages(KeyUsage.keyCertSign))
+                {
+                    throw new CertificateException("Key usage must not contain keyCertSign");
+                }
+
+                if (!(keyUsage.hasUsages(KeyUsage.digitalSignature) || keyUsage.hasUsages(KeyUsage.keyEncipherment)))
+                {
+                    throw new CertificateException("Key usage must be none, digitalSignature or keyEncipherment");
+                }
+            }
+
+            //
+            // Check extended key usage.
+            //
+            ExtendedKeyUsage extendedKeyUsage = ExtendedKeyUsage.fromExtensions(cert.getExtensions());
+
+            if (extendedKeyUsage != null)
+            {
+                if (!(extendedKeyUsage.hasKeyPurposeId(KeyPurposeId.id_kp_serverAuth) ||
+                    extendedKeyUsage.hasKeyPurposeId(KeyPurposeId.id_kp_msSGC) ||
+                    extendedKeyUsage.hasKeyPurposeId(KeyPurposeId.id_kp_nsSGC)))
+                {
+                    throw new CertificateException("Certificate extended key usage must include serverAuth, msSGC or nsSGC");
+                }
+            }
+
+        }
+        catch (CertificateException c)
+        {
+            throw c;
+        }
+        catch (Exception e)
+        {
+            throw new CertificateException(e.getMessage(), e);
+        }
+    }
+
+
+    public static KeyManagerFactory createKeyManagerFactory(
+        String type,
+        String provider,
+        KeyStore clientKeyStore,
+        char[] clientKeyStorePass)
+        throws UnrecoverableKeyException, NoSuchAlgorithmException, KeyStoreException, NoSuchProviderException
+    {
+        KeyManagerFactory keyManagerFactory = null;
+        if (type == null && provider == null)
+        {
+            keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+        }
+        else if (provider == null)
+        {
+            keyManagerFactory = KeyManagerFactory.getInstance(type);
+        }
+        else
+        {
+            keyManagerFactory = KeyManagerFactory.getInstance(type, provider);
+        }
+        keyManagerFactory.init(clientKeyStore, clientKeyStorePass);
+        return keyManagerFactory;
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseDefaultHostnameAuthorizer.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseDefaultHostnameAuthorizer.java
new file mode 100644
index 0000000..2dec2c6
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseDefaultHostnameAuthorizer.java
@@ -0,0 +1,211 @@
+package org.bouncycastle.est.jcajce;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import javax.net.ssl.SSLSession;
+
+import org.bouncycastle.asn1.x500.AttributeTypeAndValue;
+import org.bouncycastle.asn1.x500.RDN;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.est.ESTException;
+import org.bouncycastle.util.Strings;
+
+
+/**
+ * A typical hostname authorizer for verifying a hostname against the available certificates.
+ */
+public class JsseDefaultHostnameAuthorizer
+    implements JsseHostnameAuthorizer
+{
+
+    private final Set<String> knownSuffixes;
+
+    /**
+     * Base constructor.
+     * <p>
+     * The authorizer attempts to perform matching (including the use of the wildcard) in accordance with RFC 6125.
+     * </p>
+     * <p>
+     * Known suffixes is a list of public domain suffixes that can't be used as wild cards for
+     * example *.com, or c*c.com, as a dns wildcard could match every/most .com domains if a registrar were issue it.
+     * If *.com is in the known suffixes list will not be allowed to match.
+     * </p>
+     *
+     * @param knownSuffixes a set of suffixes that cannot be wild-carded, e.g. { ".com", ".net", ".org" }
+     */
+    public JsseDefaultHostnameAuthorizer(Set<String> knownSuffixes)
+    {
+        this.knownSuffixes = knownSuffixes;
+    }
+
+    public boolean verified(String name, SSLSession context)
+        throws IOException
+    {
+
+        try
+        {
+            CertificateFactory fac = CertificateFactory.getInstance("X509");
+            X509Certificate cert = (
+                java.security.cert.X509Certificate)fac.generateCertificate(
+                new ByteArrayInputStream((context.getPeerCertificates()[0]).getEncoded()));
+
+            return verify(name, cert);
+        }
+        catch (Exception ex)
+        {
+            if (ex instanceof ESTException)
+            {
+                throw (ESTException)ex;
+            }
+            throw new ESTException(ex.getMessage(), ex);
+        }
+    }
+
+    public boolean verify(String name, X509Certificate cert)
+        throws IOException
+    {
+        //
+        // Test against san.
+        //
+        try
+        {
+            Collection n = cert.getSubjectAlternativeNames();
+            if (n != null)
+            {
+                for (Iterator it = n.iterator(); it.hasNext();)
+                {
+                    List l = (List)it.next();
+                    switch (((Number)l.get(0)).intValue())
+                    {
+                    case 2:
+                        if (isValidNameMatch(name, l.get(1).toString(), knownSuffixes))
+                        {
+                            return true;
+                        }
+                        break;
+                    case 7:
+                        if (InetAddress.getByName(name).equals(InetAddress.getByName(l.get(1).toString())))
+                        {
+                            return true;
+                        }
+                        break;
+                    default:
+                        throw new RuntimeException("Unable to handle ");
+                    }
+                }
+
+                //
+                // As we had subject alternative names, we must not attempt to match against the CN.
+                //
+
+                return false;
+            }
+        }
+        catch (Exception ex)
+        {
+            throw new ESTException(ex.getMessage(), ex);
+        }
+
+        // can't match - would need to check subjectAltName
+        if (cert.getSubjectX500Principal() == null)
+        {
+            return false;
+        }
+
+        // Common Name match only.
+        RDN[] rdNs = X500Name.getInstance(cert.getSubjectX500Principal().getEncoded()).getRDNs();
+        for (int i = 0; i != rdNs.length; i++)
+        {
+            RDN rdn = rdNs[i];
+            AttributeTypeAndValue[] typesAndValues = rdn.getTypesAndValues();
+            for (int j = 0; j != typesAndValues.length; j++)
+            {
+                AttributeTypeAndValue atv = typesAndValues[j];
+                if (atv.getType().equals(BCStyle.CN))
+                {
+                    return isValidNameMatch(name, rdn.getFirst().getValue().toString(), knownSuffixes);
+                }
+            }
+        }
+        return false;
+    }
+
+
+    public static boolean isValidNameMatch(String name, String dnsName, Set<String> suffixes)
+        throws IOException
+    {
+
+        //
+        // Wild card matching.
+        //
+        if (dnsName.contains("*"))
+        {
+            // Only one astrix 
+            int wildIndex = dnsName.indexOf('*');
+            if (wildIndex == dnsName.lastIndexOf("*"))
+            {
+                if (dnsName.contains("..") || dnsName.charAt(dnsName.length() - 1) == '*')
+                {
+                    return false;
+                }
+
+                int dnsDotIndex = dnsName.indexOf('.', wildIndex);
+
+                if (suffixes != null && suffixes.contains(Strings.toLowerCase(dnsName.substring(dnsDotIndex))))
+                {
+                    throw new IOException("Wildcard `" + dnsName + "` matches known public suffix.");
+                }
+
+                String end = Strings.toLowerCase(dnsName.substring(wildIndex + 1));
+                String loweredName = Strings.toLowerCase(name);
+
+                if (loweredName.equals(end))
+                {
+                    return false; // Must not match wild card exactly there must content to the left of the wildcard.
+                }
+
+                if (end.length() > loweredName.length())
+                {
+                    return false;
+                }
+
+                if (wildIndex > 0)
+                {
+                    if (loweredName.startsWith(dnsName.substring(0, wildIndex - 1)) && loweredName.endsWith(end))
+                    {
+                        return loweredName.substring(wildIndex, loweredName.length() - end.length()).indexOf('.') < 0;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+
+                // Must be only one '*' and it must be at position 0.
+                String prefix = loweredName.substring(0, loweredName.length() - end.length());
+                if (prefix.indexOf('.') > 0)
+                {
+                    return false;
+                }
+
+                return loweredName.endsWith(end);
+            }
+
+            return false;
+        }
+
+        //
+        // No wild card full equality but ignore case.
+        //
+        return name.equalsIgnoreCase(dnsName);
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseESTServiceBuilder.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseESTServiceBuilder.java
new file mode 100644
index 0000000..cdb5564
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseESTServiceBuilder.java
@@ -0,0 +1,267 @@
+package org.bouncycastle.est.jcajce;
+
+
+import java.net.Socket;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.X509TrustManager;
+
+import org.bouncycastle.est.ESTClientProvider;
+import org.bouncycastle.est.ESTService;
+import org.bouncycastle.est.ESTServiceBuilder;
+
+
+/**
+ * Build an RFC7030 (EST) service based on the JSSE.
+ */
+public class JsseESTServiceBuilder
+    extends ESTServiceBuilder
+{
+    protected SSLSocketFactoryCreator socketFactoryCreator;
+    protected JsseHostnameAuthorizer hostNameAuthorizer = new JsseDefaultHostnameAuthorizer(null);
+    protected int timeoutMillis = 0;
+    protected ChannelBindingProvider bindingProvider;
+    protected Set<String> supportedSuites = new HashSet<String>();
+    protected Long absoluteLimit;
+    protected SSLSocketFactoryCreatorBuilder sslSocketFactoryCreatorBuilder;
+    protected boolean filterCipherSuites = true;
+
+    /**
+     * Create a builder for a client using a custom SSLSocketFactoryCreator.
+     *
+     * @param server               name of the server to talk to (URL format).
+     * @param socketFactoryCreator a custom creator of socket factories.
+     */
+    public JsseESTServiceBuilder(String server, SSLSocketFactoryCreator socketFactoryCreator)
+    {
+        super(server);
+        if (socketFactoryCreator == null)
+        {
+            throw new NullPointerException("No socket factory creator.");
+        }
+        this.socketFactoryCreator = socketFactoryCreator;
+
+    }
+
+    /**
+     * Create a builder for a client talking to a server that is not yet trusted.
+     *
+     * @param server name of the server to talk to (URL format).
+     */
+    public JsseESTServiceBuilder(String server)
+    {
+        super(server);
+        sslSocketFactoryCreatorBuilder = new SSLSocketFactoryCreatorBuilder(JcaJceUtils.getTrustAllTrustManager());
+    }
+
+    /**
+     * Create a builder for a client talking to a trusted server.
+     *
+     * @param server       name of the server to talk to (URL format).
+     * @param trustManager
+     */
+    public JsseESTServiceBuilder(String server, X509TrustManager trustManager)
+    {
+        super(server);
+        sslSocketFactoryCreatorBuilder = new SSLSocketFactoryCreatorBuilder(trustManager);
+    }
+
+    /**
+     * Create a builder for a client talking to a trusted server.
+     *
+     * @param server       name of the server to talk to (URL format).
+     * @param trustManager
+     */
+    public JsseESTServiceBuilder(String server, X509TrustManager[] trustManager)
+    {
+        super(server);
+        sslSocketFactoryCreatorBuilder = new SSLSocketFactoryCreatorBuilder(trustManager);
+    }
+
+    public JsseESTServiceBuilder withHostNameAuthorizer(JsseHostnameAuthorizer hostNameAuthorizer)
+    {
+        this.hostNameAuthorizer = hostNameAuthorizer;
+        return this;
+    }
+
+    public JsseESTServiceBuilder withClientProvider(ESTClientProvider clientProvider)
+    {
+        this.clientProvider = clientProvider;
+        return this;
+    }
+
+    public JsseESTServiceBuilder withTimeout(int timeoutMillis)
+    {
+        this.timeoutMillis = timeoutMillis;
+        return this;
+    }
+
+    public JsseESTServiceBuilder withReadLimit(long absoluteLimit)
+    {
+        this.absoluteLimit = absoluteLimit;
+        return this;
+    }
+
+
+    public JsseESTServiceBuilder withChannelBindingProvider(ChannelBindingProvider channelBindingProvider)
+    {
+        this.bindingProvider = channelBindingProvider;
+        return this;
+    }
+
+    public JsseESTServiceBuilder addCipherSuites(String name)
+    {
+        this.supportedSuites.add(name);
+        return this;
+    }
+
+    public JsseESTServiceBuilder addCipherSuites(String[] names)
+    {
+        this.supportedSuites.addAll(Arrays.asList(names));
+        return this;
+    }
+
+    public JsseESTServiceBuilder withTLSVersion(String tlsVersion)
+    {
+        if (this.socketFactoryCreator != null)
+        {
+            throw new IllegalStateException("Socket Factory Creator was defined in the constructor.");
+        }
+
+        this.sslSocketFactoryCreatorBuilder.withTLSVersion(tlsVersion);
+
+
+        return this;
+    }
+
+    public JsseESTServiceBuilder withSecureRandom(SecureRandom secureRandom)
+    {
+        if (this.socketFactoryCreator != null)
+        {
+            throw new IllegalStateException("Socket Factory Creator was defined in the constructor.");
+        }
+
+        this.sslSocketFactoryCreatorBuilder.withSecureRandom(secureRandom);
+
+
+        return this;
+    }
+
+    /**
+     * Configure this builder to use the provider with the passed in name.
+     *
+     * @param tlsProviderName the name JSSE Provider to use.
+     * @return the current builder instance.
+     * @throws NoSuchProviderException if the specified provider does not exist.
+     */
+    public JsseESTServiceBuilder withProvider(String tlsProviderName)
+        throws NoSuchProviderException
+    {
+        if (this.socketFactoryCreator != null)
+        {
+            throw new IllegalStateException("Socket Factory Creator was defined in the constructor.");
+        }
+
+        this.sslSocketFactoryCreatorBuilder.withProvider(tlsProviderName);
+
+        return this;
+    }
+
+    /**
+     * Configure this builder to use the passed in provider.
+     *
+     * @param tlsProvider the JSSE Provider to use.
+     * @return the current builder instance.
+     */
+    public JsseESTServiceBuilder withProvider(Provider tlsProvider)
+    {
+        if (this.socketFactoryCreator != null)
+        {
+            throw new IllegalStateException("Socket Factory Creator was defined in the constructor.");
+        }
+
+        this.sslSocketFactoryCreatorBuilder.withProvider(tlsProvider);
+        return this;
+    }
+
+    public JsseESTServiceBuilder withKeyManager(KeyManager keyManager)
+    {
+        if (this.socketFactoryCreator != null)
+        {
+            throw new IllegalStateException("Socket Factory Creator was defined in the constructor.");
+        }
+
+        this.sslSocketFactoryCreatorBuilder.withKeyManager(keyManager);
+        return this;
+    }
+
+    public JsseESTServiceBuilder withKeyManagers(KeyManager[] keyManagers)
+    {
+        if (this.socketFactoryCreator != null)
+        {
+            throw new IllegalStateException("Socket Factory Creator was defined in the constructor.");
+        }
+        this.sslSocketFactoryCreatorBuilder.withKeyManagers(keyManagers);
+        return this;
+    }
+
+    /**
+     * Filter cipher suites with supported before passing to JSSE provider.
+     *
+     * @param filter true, supplied cipher suites will be filtered with supported before passing to the JSSE provider.
+     * @return this;
+     */
+    public JsseESTServiceBuilder withFilterCipherSuites(boolean filter)
+    {
+        this.filterCipherSuites = filter;
+        return this;
+    }
+
+    public ESTService build()
+    {
+        if (bindingProvider == null)
+        {
+            bindingProvider = new ChannelBindingProvider()
+            {
+                public boolean canAccessChannelBinding(Socket sock)
+                {
+                    return false;
+                }
+
+                public byte[] getChannelBinding(Socket sock, String binding)
+                {
+                    return null;
+                }
+            };
+        }
+
+        if (socketFactoryCreator == null)
+        {
+            socketFactoryCreator = sslSocketFactoryCreatorBuilder.build();
+        }
+
+
+        if (clientProvider == null)
+        {
+            clientProvider = new DefaultESTHttpClientProvider(
+                hostNameAuthorizer,
+                socketFactoryCreator,
+                timeoutMillis,
+                bindingProvider,
+                supportedSuites,
+                absoluteLimit, filterCipherSuites);
+        }
+
+        return super.build();
+    }
+
+}
+
+
+
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseHostnameAuthorizer.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseHostnameAuthorizer.java
new file mode 100644
index 0000000..0584568
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/JsseHostnameAuthorizer.java
@@ -0,0 +1,21 @@
+package org.bouncycastle.est.jcajce;
+
+import java.io.IOException;
+
+import javax.net.ssl.SSLSession;
+
+/**
+ * Verify the host name is as expected after the SSL Handshake has been completed.
+ */
+public interface JsseHostnameAuthorizer
+{
+    /**
+     * Verify the passed in host name according to the context object.
+     *
+     * @param name    name of the host to be verified.
+     * @param context context object to do the verification under.
+     * @return true if name verified, false otherwise.
+     */
+    boolean verified(String name, SSLSession context)
+        throws IOException;
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/LimitedSSLSocketSource.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/LimitedSSLSocketSource.java
new file mode 100644
index 0000000..53f699a
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/LimitedSSLSocketSource.java
@@ -0,0 +1,70 @@
+package org.bouncycastle.est.jcajce;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+
+import org.bouncycastle.est.LimitedSource;
+import org.bouncycastle.est.Source;
+import org.bouncycastle.est.TLSUniqueProvider;
+
+
+class LimitedSSLSocketSource
+    implements Source<SSLSession>, TLSUniqueProvider, LimitedSource
+{
+    protected final SSLSocket socket;
+    private final ChannelBindingProvider bindingProvider;
+    private final Long absoluteReadLimit;
+
+    public LimitedSSLSocketSource(SSLSocket sock, ChannelBindingProvider bindingProvider, Long absoluteReadLimit)
+    {
+        this.socket = sock;
+        this.bindingProvider = bindingProvider;
+        this.absoluteReadLimit = absoluteReadLimit;
+    }
+
+    public InputStream getInputStream()
+        throws IOException
+    {
+        return socket.getInputStream();
+    }
+
+    public OutputStream getOutputStream()
+        throws IOException
+    {
+        return socket.getOutputStream();
+    }
+
+    public SSLSession getSession()
+    {
+        return socket.getSession();
+    }
+
+    public byte[] getTLSUnique()
+    {
+        if (isTLSUniqueAvailable())
+        {
+            return bindingProvider.getChannelBinding(socket, "tls-unique");
+        }
+        throw new IllegalStateException("No binding provider.");
+    }
+
+    public boolean isTLSUniqueAvailable()
+    {
+        return bindingProvider.canAccessChannelBinding(socket);
+    }
+
+    public void close()
+        throws IOException
+    {
+        socket.close();
+    }
+
+    public Long getAbsoluteReadLimit()
+    {
+        return absoluteReadLimit;
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/SSLSocketFactoryCreator.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/SSLSocketFactoryCreator.java
new file mode 100644
index 0000000..277a2b5
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/SSLSocketFactoryCreator.java
@@ -0,0 +1,15 @@
+package org.bouncycastle.est.jcajce;
+
+
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * Implementations provide SSL socket factories.
+ */
+public interface SSLSocketFactoryCreator
+{
+    SSLSocketFactory createFactory()
+        throws Exception;
+
+    boolean isTrusted();
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/SSLSocketFactoryCreatorBuilder.java b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/SSLSocketFactoryCreatorBuilder.java
new file mode 100644
index 0000000..81e65a2
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/SSLSocketFactoryCreatorBuilder.java
@@ -0,0 +1,145 @@
+package org.bouncycastle.est.jcajce;
+
+
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.Security;
+
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * A basic builder to allow configuration of an SSLContext used to create an SSLSocketFactory.
+ */
+class SSLSocketFactoryCreatorBuilder
+{
+    protected String tlsVersion = "TLS";
+    protected Provider tlsProvider;
+    protected KeyManager[] keyManagers;
+    protected X509TrustManager[] trustManagers;
+    protected SecureRandom secureRandom = new SecureRandom();
+
+    public SSLSocketFactoryCreatorBuilder(X509TrustManager trustManager)
+    {
+        if (trustManager == null)
+        {
+            throw new NullPointerException("Trust managers can not be null");
+        }
+        this.trustManagers = new X509TrustManager[]{trustManager};
+    }
+
+    public SSLSocketFactoryCreatorBuilder(X509TrustManager[] trustManagers)
+    {
+        if (trustManagers == null)
+        {
+            throw new NullPointerException("Trust managers can not be null");
+        }
+        this.trustManagers = trustManagers;
+    }
+
+    public SSLSocketFactoryCreatorBuilder withTLSVersion(String tlsVersion)
+    {
+        this.tlsVersion = tlsVersion;
+        return this;
+    }
+
+    public SSLSocketFactoryCreatorBuilder withSecureRandom(SecureRandom secureRandom)
+    {
+        this.secureRandom = secureRandom;
+        return this;
+    }
+
+    /**
+     * Configure this builder to use the provider with the passed in name.
+     *
+     * @param tlsProviderName the name JSSE Provider to use.
+     * @return the current builder instance.
+     * @throws NoSuchProviderException if the specified provider does not exist.
+     */
+    public SSLSocketFactoryCreatorBuilder withProvider(String tlsProviderName)
+        throws NoSuchProviderException
+    {
+        this.tlsProvider = Security.getProvider(tlsProviderName);
+        if (this.tlsProvider == null)
+        {
+            throw new NoSuchProviderException("JSSE provider not found: " + tlsProviderName);
+        }
+        return this;
+    }
+
+    /**
+     * Configure this builder to use the passed in provider.
+     *
+     * @param tlsProvider the JSSE Provider to use.
+     * @return the current builder instance.
+     */
+    public SSLSocketFactoryCreatorBuilder withProvider(Provider tlsProvider)
+    {
+        this.tlsProvider = tlsProvider;
+        return this;
+    }
+
+    public SSLSocketFactoryCreatorBuilder withKeyManager(KeyManager keyManager)
+    {
+        if (keyManager == null)
+        {
+            this.keyManagers = null;
+        }
+        else
+        {
+            this.keyManagers = new KeyManager[]{keyManager};
+        }
+        return this;
+    }
+
+    public SSLSocketFactoryCreatorBuilder withKeyManagers(KeyManager[] keyManagers)
+    {
+        this.keyManagers = keyManagers;
+
+        return this;
+    }
+
+    public SSLSocketFactoryCreator build()
+    {
+        return new SSLSocketFactoryCreator()
+        {
+            public boolean isTrusted()
+            {
+                for (int i = 0; i != trustManagers.length; i++)
+                {
+                    X509TrustManager tm = trustManagers[i];
+                    if (tm.getAcceptedIssuers().length > 0)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            public SSLSocketFactory createFactory()
+                throws NoSuchAlgorithmException, NoSuchProviderException, KeyManagementException
+            {
+                SSLContext ctx;
+
+                if (tlsProvider != null)
+                {
+                    ctx = SSLContext.getInstance(tlsVersion, tlsProvider);
+                }
+                else
+                {
+                    ctx = SSLContext.getInstance(tlsVersion);
+                }
+
+                ctx.init(keyManagers, trustManagers, secureRandom);
+
+                return ctx.getSocketFactory();
+            }
+        };
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/jcajce/package.html b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/package.html
new file mode 100644
index 0000000..5b4f5b4
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/jcajce/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+JCA/JCE/JSSE support Enrollment over Secure Transport.
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/package.html b/bcpkix/src/main/java/org/bouncycastle/est/package.html
new file mode 100644
index 0000000..de12c55
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+A package for processing messages for RFC 7030 "Enrollment over Secure Transport".
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/test/AllTests.java b/bcpkix/src/main/java/org/bouncycastle/est/test/AllTests.java
new file mode 100644
index 0000000..a1d50eb
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/test/AllTests.java
@@ -0,0 +1,41 @@
+package org.bouncycastle.est.test;
+
+import java.security.Security;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+
+public class AllTests
+    extends TestCase
+{
+    private static final String BC = BouncyCastleProvider.PROVIDER_NAME;
+
+    public void setUp()
+    {
+        if (Security.getProvider(BC) != null)
+        {
+            Security.addProvider(new BouncyCastleProvider());
+        }
+    }
+
+    public static void main(String[] args)
+        throws Exception
+    {
+        Security.addProvider(new BouncyCastleProvider());
+
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite()
+        throws Exception
+    {
+        TestSuite suite = new TestSuite("EST tests");
+
+        suite.addTestSuite(ESTParsingTest.class);
+        suite.addTestSuite(HostNameAuthorizerMatchTest.class);
+
+        return new ESTTestSetup(suite);
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/test/ESTParsingTest.java b/bcpkix/src/main/java/org/bouncycastle/est/test/ESTParsingTest.java
new file mode 100644
index 0000000..a690eb4
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/test/ESTParsingTest.java
@@ -0,0 +1,217 @@
+package org.bouncycastle.est.test;
+
+import java.math.BigInteger;
+import java.util.Collection;
+
+import junit.framework.TestCase;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1String;
+import org.bouncycastle.asn1.pkcs.Attribute;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cert.selector.X509CertificateHolderSelector;
+import org.bouncycastle.cmc.SimplePKIResponse;
+import org.bouncycastle.est.CSRAttributesResponse;
+import org.bouncycastle.pkcs.PKCS10CertificationRequest;
+import org.bouncycastle.util.Store;
+import org.bouncycastle.util.encoders.Base64;
+
+public class ESTParsingTest
+    extends TestCase
+{
+    private static byte[] cacertsResponse = Base64.decode(
+        "MIIMOQYJKoZIhvcNAQcCoIIMKjCCDCYCAQExADALBgkqhkiG9w0BBwGgggwMMIIC" +
+            "+zCCAeOgAwIBAgIJAJpY3nUZO3qcMA0GCSqGSIb3DQEBBQUAMBsxGTAXBgNVBAMT" +
+            "EGVzdEV4YW1wbGVDQSBPd08wHhcNMTMwNTA5MDM1MzMxWhcNMTQwNTA5MDM1MzMx" +
+            "WjAbMRkwFwYDVQQDExBlc3RFeGFtcGxlQ0EgT3dPMIIBIjANBgkqhkiG9w0BAQEF" +
+            "AAOCAQ8AMIIBCgKCAQEAwDqpiHopaICubpRqbpEN7LqTIqWELFIA9qDDheHIKuyO" +
+            "HW/ZAP7Rl4S5ZU6gaLW/ksseBUxdmox3KNyvtyjehIofTu28eZWhgy6/LCEGWR3P" +
+            "K+fgPBA0l0JfJR/8oeXZa70oLVQc3hI4kCeqjFMs+biYH0vp/RluhftyZ5kzQyH1" +
+            "EGsRkw1/qUKkTZ8PCF8VFlYfqmUoqsaRTyZbjII4J+Y6/jEG+p7QreW9zcz4sPe8" +
+            "3c/uhwMLOWQkZtKsQtgo5CpfYMjuAmk4Q2joQq2vcxlc+WNKHf+wbrDb11ORZril" +
+            "9ISlI94oumcRz3uBG1Yg7z83hdDfasmdfbp8gOSNFQIDAQABo0IwQDAPBgNVHRMB" +
+            "Af8EBTADAQH/MB0GA1UdDgQWBBQITTKxMqATXrfc4ffpCIbt6Gsz0jAOBgNVHQ8B" +
+            "Af8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBACPnQPu5WReUGuCMS0nBOGa2tXh6" +
+            "uZP4mS3J1qEfDePam/IiU9ssyYdcDwhVvKMoP4gI/yu4XFqhdpIoy/PyD4T15MT7" +
+            "KADCxXkh5rM1IqMui7FvBKLWYGdy9sjEf90wAkBjHBe/TMO1NNw3uELyONSkHIvo" +
+            "X0pu6aPmm/moIMyGi46niFse1iWlXXldGLkOQsh0e7U+wpBX07QpOr2KB2+Yf+uA" +
+            "KY1SWzEG23bUxXlvcbUMgANDGj5r6z+niKL0VlApip/iCuVEEOcZ91UlmJjVLQWA" +
+            "x6ie+v84oM+pIojiGM0C4XWcVlKKEgcMOsN3S4lvm8Ptpq0GLoIJY8NTD20wggMD" +
+            "MIIB66ADAgECAgEBMA0GCSqGSIb3DQEBBQUAMBsxGTAXBgNVBAMTEGVzdEV4YW1w" +
+            "bGVDQSBPd08wHhcNMTMwNTA5MDM1MzMyWhcNMTQwNTA5MDM1MzMyWjAbMRkwFwYD" +
+            "VQQDExBlc3RFeGFtcGxlQ0EgTndPMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB" +
+            "CgKCAQEAnn3rZ3rMJHwf7MD9K4mubxHAvtdnrsQf5OfgtMhRIL4aePNhAdgPyj8C" +
+            "loxOgD3UTV+dQ1ViOzVxPN7acikoOnkIdRpjpOpkyMo+KkvHMQXGnQTbsMAv1qWt" +
+            "9S12DMpo0GOA1e4Ge3ud5YPOTR/q6PvjN51IEwYKksG7CglwZwB+5JbwhYr2D/0u" +
+            "btGltriRVixPWrvt+wz/ITp5rcjh/8RS3LE8tQy3kTNhJF3Y/esR2sSgOiPNgIto" +
+            "CATysbaINEPr4MemqML4tDpR/aG9y+8Qe7s1LyMFvDletp2mmBykAC/7nOat/pwU" +
+            "lB0sN524D1XAgz8ZKvWrkh+ZaOr3hwIDAQABo1IwUDAOBgNVHQ8BAf8EBAMCBLAw" +
+            "HQYDVR0OBBYEFLHEaeZbowSn2Jejizu/uWqyMkI8MB8GA1UdIwQYMBaAFAhNMrEy" +
+            "oBNet9zh9+kIhu3oazPSMA0GCSqGSIb3DQEBBQUAA4IBAQCLDkL7aLNV6hSOkIqH" +
+            "q+shV9YLO56/tj00vY/jV5skgDHk5d0B+OGortKVuGa57+v0avTrlJns3bNW8Ntv" +
+            "zkDEhmd00Ak02aPsi4wRHLFgttUf9HdEHAuTkAESPTU43DiptjkfHhtBMfsFrCkd" +
+            "sxWzCz+prDOMHYfUEkhRVV++1zyGEX6ov1Ap2IU2p3E+ASihL/amxTEQAsbwjUTI" +
+            "R52zoL6nMPzpbKeZi2M0eEBVF8sDueA9Hjo6woLjgJqV0/yc5vC2HAxUOhx0cWTY" +
+            "GcRBgL/yOyQLKiY5TKBH951OjQ4vhF2HmcoO7DkcNLYJOge16ssx4ogBHul20VgF" +
+            "XJJjMIIDAzCCAeugAwIBAgIBAjANBgkqhkiG9w0BAQUFADAbMRkwFwYDVQQDExBl" +
+            "c3RFeGFtcGxlQ0EgTndOMB4XDTEzMDUwOTAzNTMzMloXDTE0MDUwOTAzNTMzMlow" +
+            "GzEZMBcGA1UEAxMQZXN0RXhhbXBsZUNBIE93TjCCASIwDQYJKoZIhvcNAQEBBQAD" +
+            "ggEPADCCAQoCggEBAMA6qYh6KWiArm6Uam6RDey6kyKlhCxSAPagw4XhyCrsjh1v" +
+            "2QD+0ZeEuWVOoGi1v5LLHgVMXZqMdyjcr7co3oSKH07tvHmVoYMuvywhBlkdzyvn" +
+            "4DwQNJdCXyUf/KHl2Wu9KC1UHN4SOJAnqoxTLPm4mB9L6f0ZboX7cmeZM0Mh9RBr" +
+            "EZMNf6lCpE2fDwhfFRZWH6plKKrGkU8mW4yCOCfmOv4xBvqe0K3lvc3M+LD3vN3P" +
+            "7ocDCzlkJGbSrELYKOQqX2DI7gJpOENo6EKtr3MZXPljSh3/sG6w29dTkWa4pfSE" +
+            "pSPeKLpnEc97gRtWIO8/N4XQ32rJnX26fIDkjRUCAwEAAaNSMFAwDgYDVR0PAQH/" +
+            "BAQDAgSwMB0GA1UdDgQWBBQITTKxMqATXrfc4ffpCIbt6Gsz0jAfBgNVHSMEGDAW" +
+            "gBSxxGnmW6MEp9iXo4s7v7lqsjJCPDANBgkqhkiG9w0BAQUFAAOCAQEALhDaE6Mp" +
+            "BINBsJozdbXlijrWxL1CSv8f4GwpUFk3CgZjibt/qW9UoaNR4E58yRopuEhjwFZK" +
+            "2w8YtRqx8IZoFhcoLkpBDfgLLwhoztzbYvOVKQMidjBlkBEVNR5MWdrs7F/AxWuy" +
+            "iZ2+8AnR8GwqEIbCD0A7xIghmWEMh/BVI9C7GLqd6PxKrTAjuDfEpfdWhU/uYKmK" +
+            "cL3XDbSwr30j2EQyaTV/3W0Tn2UfuxdwDQ4ZJs9G+Mw50s7AG6CpISyOIFmX6/bU" +
+            "DpJXGLiLwfJ9C/aum9nylYuGCJ68BuTrCs9567KGfXEXI0mdFFCL7TaVR43kjsg3" +
+            "c43kZ7369MeEZzCCAvswggHjoAMCAQICCQDprp3DmjOyETANBgkqhkiG9w0BAQUF" +
+            "ADAbMRkwFwYDVQQDExBlc3RFeGFtcGxlQ0EgTndOMB4XDTEzMDUwOTAzNTMzMloX" +
+            "DTE0MDUwOTAzNTMzMlowGzEZMBcGA1UEAxMQZXN0RXhhbXBsZUNBIE53TjCCASIw" +
+            "DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ5962d6zCR8H+zA/SuJrm8RwL7X" +
+            "Z67EH+Tn4LTIUSC+GnjzYQHYD8o/ApaMToA91E1fnUNVYjs1cTze2nIpKDp5CHUa" +
+            "Y6TqZMjKPipLxzEFxp0E27DAL9alrfUtdgzKaNBjgNXuBnt7neWDzk0f6uj74zed" +
+            "SBMGCpLBuwoJcGcAfuSW8IWK9g/9Lm7Rpba4kVYsT1q77fsM/yE6ea3I4f/EUtyx" +
+            "PLUMt5EzYSRd2P3rEdrEoDojzYCLaAgE8rG2iDRD6+DHpqjC+LQ6Uf2hvcvvEHu7" +
+            "NS8jBbw5XradppgcpAAv+5zmrf6cFJQdLDeduA9VwIM/GSr1q5IfmWjq94cCAwEA" +
+            "AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUscRp5lujBKfYl6OLO7+5" +
+            "arIyQjwwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQBCz/CWdYvn" +
+            "GM/SdCdEiom5A1VxaW8nKgCWg/EyWtAIiaHQuViB+jTUAE9lona2MbJoFHW8U5e8" +
+            "9dCP0rJpA9UYXXhWvFQzd5ZWpms4wUYt1j3gqqd36KorJIAuPigVng13yKytxM7c" +
+            "VmxQnh0aux3aEnEyRGAhGalHp0RaKdgPRzUaGtipJTNBkSV5S4kD4yDCPHMNbBu+" +
+            "OcluerwEpbz6GvE7CpXl2jrTBZSqBsFelq0iz4kk9++9CnwZwrVgdzklhRfJ1Z4j" +
+            "NkLruwbQ+o4NvBZsXiKxNfn3K2o3SK8AuaEyDWkq18+5rjcfprRO8x4YTW+6mXPq" +
+            "jM0MAGNDEW+1oQAxAA=="
+    );
+
+    private static byte[] csrattrs1 = Base64.decode(
+        "MEEGCSqGSIb3DQEJBzASBgcqhkjOPQIBMQcGBSuBBAAiMBYGCSqGSIb3DQEJDjEJ" +
+            "BgcrBgEBAQEWBggqhkjOPQQDAw=="
+    );
+
+    private static byte[] csrattrs2 = Base64.decode(
+        "MHwGBysGAQEBARYwIgYDiDcBMRsTGVBhcnNlIFNFVCBhcyAyLjk5OS4xIGRhdGEG" +
+            "CSqGSIb3DQEJBzAsBgOINwIxJQYDiDcDBgOINwQTGVBhcnNlIFNFVCBhcyAyLjk5" +
+            "OS4yIGRhdGEGCSskAwMCCAEBCwYJYIZIAWUDBAIC"
+    );
+
+    private static byte[] clientSimpleEnrol = Base64.decode(
+            "MIIChTCCAW0CAQAwHzEdMBsGA1UEAxMUZGVtb3N0ZXA0IDEzNjgxNDEzNTIwggEi" +
+            "MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQClNp+kdz+Nj8XpEp9kaumWxDZ3" +
+            "eFYJpQKz9ddD5e5OzUeCm103ZIXQIxc0eVtMCatnRr3dnZRCAxGjwbqoB3eKt29/" +
+            "XSQffVv+odbyw0WdkQOIbntCQry8YdcBZ+8LjI/N7M2krmjmoSLmLwU2V4aNKf0Y" +
+            "MLR5Krmah3Ik31jmYCSvwTnv6mx6pr2pTJ82JavhTEIIt/fAYq1RYhkM1CXoBL+y" +
+            "hEoDanN7TzC94skfS3VV+f53J9SkUxTYcy1Rw0k3VXfxWwy+cSKEPREl7I6k0YeK" +
+            "tDEVAgBIEYM/L1S69RXTLujirwnqSRjOquzkAkD31BE961KZCxeYGrhxaR4PAgMB" +
+            "AAGgITAfBgkqhkiG9w0BCQcxEhMQK3JyQ2lyLzcrRVl1NTBUNDANBgkqhkiG9w0B" +
+            "AQUFAAOCAQEARBv0AJeXaHpl1MFIdzWqoi1dOCf6U+qaYWcBzpLADvJrPK1qx5pq" +
+            "wXM830A1O+7RvrFv+nyd6VF2rl/MrNp+IsKuA9LYWIBjVe/LXoBO8dB/KxrYl16c" +
+            "VUS+Yydi1m/a+DaftYSRGolMLtWeiqbc2SDBr2kHXW1TR130hIcpwmr29kC2Kzur" +
+            "5thsuj276FGL1vPu0dRfGQfx4WWa9uAHBgz6tW37CepZsrUKe/0pfVhr2oHxApYh" +
+            "cHGBQDQHVTFVjHccdUjAXicrtbsVhU5o1lPv7f4lEApv3SBQmJcaq5O832BzHw7n" +
+            "PyMFcM15E9gtUVee5C62bVwuk/tbnGsbwQ=="
+    );
+
+    private static byte[] serverSimpleEnrolResponse = Base64.decode(
+        "MIIDOAYJKoZIhvcNAQcCoIIDKTCCAyUCAQExADALBgkqhkiG9w0BBwGgggMLMIID" +
+            "BzCCAe+gAwIBAgIBFTANBgkqhkiG9w0BAQUFADAbMRkwFwYDVQQDExBlc3RFeGFt" +
+            "cGxlQ0EgTndOMB4XDTEzMDUwOTIzMTU1M1oXDTE0MDUwOTIzMTU1M1owHzEdMBsG" +
+            "A1UEAxMUZGVtb3N0ZXA0IDEzNjgxNDEzNTIwggEiMA0GCSqGSIb3DQEBAQUAA4IB" +
+            "DwAwggEKAoIBAQClNp+kdz+Nj8XpEp9kaumWxDZ3eFYJpQKz9ddD5e5OzUeCm103" +
+            "ZIXQIxc0eVtMCatnRr3dnZRCAxGjwbqoB3eKt29/XSQffVv+odbyw0WdkQOIbntC" +
+            "Qry8YdcBZ+8LjI/N7M2krmjmoSLmLwU2V4aNKf0YMLR5Krmah3Ik31jmYCSvwTnv" +
+            "6mx6pr2pTJ82JavhTEIIt/fAYq1RYhkM1CXoBL+yhEoDanN7TzC94skfS3VV+f53" +
+            "J9SkUxTYcy1Rw0k3VXfxWwy+cSKEPREl7I6k0YeKtDEVAgBIEYM/L1S69RXTLuji" +
+            "rwnqSRjOquzkAkD31BE961KZCxeYGrhxaR4PAgMBAAGjUjBQMA4GA1UdDwEB/wQE" +
+            "AwIEsDAdBgNVHQ4EFgQU/qDdB6ii6icQ8wGMXvy1jfE4xtUwHwYDVR0jBBgwFoAU" +
+            "scRp5lujBKfYl6OLO7+5arIyQjwwDQYJKoZIhvcNAQEFBQADggEBACmxg1hvL6+7" +
+            "a+lFTARoxainBx5gxdZ9omSb0L+qL+4PDvg/+KHzKsDnMCrcU6M4YP5n0EDKmGa6" +
+            "4lY8fbET4tt7juJg6ixb95/760Th0vuctwkGr6+D6ETTfqyHnrbhX3lAhnB+0Ja7" +
+            "o1gv4CWxh1I8aRaTXdpOHORvN0SMXdcrlCys2vrtOl+LjR2a3kajJO6eQ5leOdzF" +
+            "QlZfOPhaLWen0e2BLNJI0vsC2Fa+2LMCnfC38XfGALa5A8e7fNHXWZBjXZLBCza3" +
+            "rEs9Mlh2CjA/ocSC/WxmMvd+Eqnt/FpggRy+F8IZSRvBaRUCtGE1lgDmu6AFUxce" +
+            "R4POrT2xz8ChADEA"
+    );
+
+    public void testParsingCacertsResponse()
+        throws Exception
+    {
+        SimplePKIResponse response = new SimplePKIResponse(cacertsResponse);
+
+        Store<X509CertificateHolder> certs = response.getCertificates();
+
+        assertEquals(4, certs.getMatches(null).size());
+
+        assertEquals(1, certs.getMatches(new X509CertificateHolderSelector(new X500Name("CN=estExampleCA OwO"), new BigInteger("11121883874307308188"))).size());
+        assertEquals(1, certs.getMatches(new X509CertificateHolderSelector(new X500Name("CN=estExampleCA OwO"), new BigInteger("1"))).size());
+        assertEquals(1, certs.getMatches(new X509CertificateHolderSelector(new X500Name("CN=estExampleCA NwN"), new BigInteger("2"))).size());
+        assertEquals(1, certs.getMatches(new X509CertificateHolderSelector(new X500Name("CN=estExampleCA NwN"), new BigInteger("16838569520216125969"))).size());
+    }
+
+    public void testParsingCsrattrs1()
+        throws Exception
+    {
+        CSRAttributesResponse response = new CSRAttributesResponse(csrattrs1);
+
+        assertTrue(response.hasRequirement(PKCSObjectIdentifiers.pkcs_9_at_challengePassword));
+        assertTrue(response.hasRequirement(X9ObjectIdentifiers.ecdsa_with_SHA384));
+        assertFalse(response.isAttribute(X9ObjectIdentifiers.ecdsa_with_SHA384));
+        assertTrue(response.isAttribute(X9ObjectIdentifiers.id_ecPublicKey));
+        assertTrue(response.isAttribute(PKCSObjectIdentifiers.pkcs_9_at_extensionRequest));
+
+        Collection<ASN1ObjectIdentifier> requirements = response.getRequirements();
+
+        assertEquals(4, requirements.size());
+    }
+
+    public void testParsingCsrattrs2()
+        throws Exception
+    {
+        CSRAttributesResponse response = new CSRAttributesResponse(csrattrs2);
+
+        Collection<ASN1ObjectIdentifier> requirements = response.getRequirements();
+
+        assertEquals(6, requirements.size());
+
+        assertTrue(response.hasRequirement(new ASN1ObjectIdentifier("1.3.36.3.3.2.8.1.1.11")));
+        assertFalse(response.isAttribute(new ASN1ObjectIdentifier("1.3.36.3.3.2.8.1.1.11")));
+        assertTrue(response.hasRequirement(new ASN1ObjectIdentifier("2.16.840.1.101.3.4.2.2")));
+        assertFalse(response.isAttribute(new ASN1ObjectIdentifier("2.16.840.1.101.3.4.2.2")));
+        assertTrue(response.hasRequirement(new ASN1ObjectIdentifier("1.2.840.113549.1.9.7")));
+        assertFalse(response.isAttribute(new ASN1ObjectIdentifier("1.2.840.113549.1.9.7")));
+        assertTrue(response.hasRequirement(new ASN1ObjectIdentifier("1.3.6.1.1.1.1.22")));
+        assertFalse(response.isAttribute(new ASN1ObjectIdentifier("1.3.6.1.1.1.1.22")));
+        assertTrue(response.isAttribute(new ASN1ObjectIdentifier("2.999.1")));
+        assertTrue(response.isAttribute(new ASN1ObjectIdentifier("2.999.2")));
+    }
+
+    public void testParsingSimpleEnrolRequest()
+        throws Exception
+    {
+        PKCS10CertificationRequest request = new PKCS10CertificationRequest(clientSimpleEnrol);
+
+        Attribute challenge = request.getAttributes(PKCSObjectIdentifiers.pkcs_9_at_challengePassword)[0];
+
+        ASN1String passwd = (ASN1String)challenge.getAttributeValues()[0];
+
+        assertEquals("+rrCir/7+EYu50T4", passwd.getString());
+    }
+
+    public void testParsingSimpleEnrolResponse()
+        throws Exception
+    {
+        SimplePKIResponse response = new SimplePKIResponse(serverSimpleEnrolResponse);
+
+        Store<X509CertificateHolder> certs = response.getCertificates();
+
+        assertEquals(1, certs.getMatches(null).size());
+
+        assertEquals(1, certs.getMatches(new X509CertificateHolderSelector(new X500Name("CN=estExampleCA NwN"), new BigInteger("21"))).size());
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/test/ESTTestSetup.java b/bcpkix/src/main/java/org/bouncycastle/est/test/ESTTestSetup.java
new file mode 100644
index 0000000..92fd837
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/test/ESTTestSetup.java
@@ -0,0 +1,28 @@
+
+package org.bouncycastle.est.test;
+
+import java.security.Security;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+
+class ESTTestSetup
+    extends TestSetup
+{
+    public ESTTestSetup(Test test)
+    {
+        super(test);
+    }
+
+    protected void setUp()
+    {
+        Security.addProvider(new BouncyCastleProvider());
+    }
+
+    protected void tearDown()
+    {
+        Security.removeProvider(BouncyCastleProvider.PROVIDER_NAME);
+    }
+
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/test/HostNameAuthorizerMatchTest.java b/bcpkix/src/main/java/org/bouncycastle/est/test/HostNameAuthorizerMatchTest.java
new file mode 100644
index 0000000..32b0618
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/test/HostNameAuthorizerMatchTest.java
@@ -0,0 +1,71 @@
+package org.bouncycastle.est.test;
+
+import java.io.IOException;
+import java.util.HashSet;
+
+import junit.framework.TestCase;
+import org.bouncycastle.est.jcajce.JsseDefaultHostnameAuthorizer;
+
+public class HostNameAuthorizerMatchTest
+    extends TestCase
+{
+    public void testWildcardMatcher()
+        throws Exception
+    {
+
+        Object[][] v = new Object[][]{
+            //   {"Too wide a match", "foo.com","*.com",false}, // too wide a match
+            {"Exact", "a.foo.com", "a.foo.com", true},
+            {"Left most", "abacus.foo.com", "*s.foo.com", true}, // Match the left most.
+            {"Invalid 1","localhost.cisco.com","localhost.*.com",true},
+            {"Invalid 2", "localhost.cisco.com", "localhost.cisco.*", false},
+            {"Invalid 3 - subdomain","localhost.cisco.com","*.com",false},
+            {"Invalid 4", "localhost.cisco.com", "*.localhost.cisco.com", false},
+            {"Invalid 5", "localhost.cisco.com", "*", false},
+            {"Invalid 6", "localhost.cisco.com", "localhost*.cisco.com", true},
+            {"Invalid 7", "localhost.cisco.com", "*localhost.cisco.com", false},
+            {"Invalid 8", "localhost.cisco.com", "local*host.cisco.com", true},
+            {"Invalid 9", "localhost.cisco.com", "localhost.c*.com", true},
+            {"Invalid 10", "localhost.cisco.com", "localhost.*o.com", true},
+            {"Invalid 11", "localhost.cisco.com", "localhost.c*o.com", true},
+            {"Invalid 12", "localhost.cisco.com", "*..com", false},
+            {"Invalid 13", "foo.example.com","*.example.com",true},
+            {"Invalid 14", "bar.foo.example.com", "*.example.com", false},
+            {"Invalid 15", "example.com", "*.example.com", false},
+        };
+
+        for (Object[] j : v)
+        {
+            assertEquals(j[0].toString(), j[3], JsseDefaultHostnameAuthorizer.isValidNameMatch((String)j[1], (String)j[2], null));
+        }
+    }
+
+    public void testWildcardPublicSuffix()
+        throws Exception
+    {
+
+        Object[][] v = new Object[][]{
+
+            {"Invalid 3", "localhost.cisco.com", "*.com", false},
+            {"Invalid 9", "localhost.cisco.com", "localhost.c*.com", false},
+            {"Invalid 10", "localhost.cisco.com", "localhost.*o.com", false},
+            {"Invalid 11", "localhost.cisco.com", "localhost.c*o.com", false},
+        };
+
+        HashSet<String> suf = new HashSet<String>();
+        suf.add(".com");
+
+        for (Object[] j : v)
+        {
+            try
+            {
+                assertEquals(j[0].toString(), j[3], JsseDefaultHostnameAuthorizer.isValidNameMatch((String)j[1], (String)j[2], suf));
+                fail("known suffix not caught");
+            }
+            catch (IOException e)
+            {
+                // expected
+            }
+        }
+    }
+}
diff --git a/bcpkix/src/main/java/org/bouncycastle/est/test/package.html b/bcpkix/src/main/java/org/bouncycastle/est/test/package.html
new file mode 100644
index 0000000..c249c45
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/est/test/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+Test classes for RFC 7030 "Enrollment over Secure Transport".
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/mozilla/test/package.html b/bcpkix/src/main/java/org/bouncycastle/mozilla/test/package.html
index 54047ad..9a17109 100644
--- a/bcpkix/src/main/java/org/bouncycastle/mozilla/test/package.html
+++ b/bcpkix/src/main/java/org/bouncycastle/mozilla/test/package.html
@@ -1,5 +1,5 @@
 <html>
 <body bgcolor="#ffffff">
-Test class for mozilla signed public key and challenge.
+Test classes for Mozilla signed public key and challenge.
 </body>
 </html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/openssl/test/package.html b/bcpkix/src/main/java/org/bouncycastle/openssl/test/package.html
index 368d709..cdc329a 100644
--- a/bcpkix/src/main/java/org/bouncycastle/openssl/test/package.html
+++ b/bcpkix/src/main/java/org/bouncycastle/openssl/test/package.html
@@ -1,5 +1,5 @@
 <html>
 <body bgcolor="#ffffff">
-Test class for OpenSSL PEMReader.
+Test classes for the OpenSSL PEMReader.
 </body>
 </html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/operator/DefaultDigestAlgorithmIdentifierFinder.java b/bcpkix/src/main/java/org/bouncycastle/operator/DefaultDigestAlgorithmIdentifierFinder.java
index ccf4fc2..fbe8797 100644
--- a/bcpkix/src/main/java/org/bouncycastle/operator/DefaultDigestAlgorithmIdentifierFinder.java
+++ b/bcpkix/src/main/java/org/bouncycastle/operator/DefaultDigestAlgorithmIdentifierFinder.java
@@ -86,12 +86,16 @@
         digestNameToOids.put("SHA-256", NISTObjectIdentifiers.id_sha256);
         digestNameToOids.put("SHA-384", NISTObjectIdentifiers.id_sha384);
         digestNameToOids.put("SHA-512", NISTObjectIdentifiers.id_sha512);
+        digestNameToOids.put("SHA-512-224", NISTObjectIdentifiers.id_sha512_224);
+        digestNameToOids.put("SHA-512-256", NISTObjectIdentifiers.id_sha512_256);
 
         digestNameToOids.put("SHA1", OIWObjectIdentifiers.idSHA1);
         digestNameToOids.put("SHA224", NISTObjectIdentifiers.id_sha224);
         digestNameToOids.put("SHA256", NISTObjectIdentifiers.id_sha256);
         digestNameToOids.put("SHA384", NISTObjectIdentifiers.id_sha384);
         digestNameToOids.put("SHA512", NISTObjectIdentifiers.id_sha512);
+        digestNameToOids.put("SHA512-224", NISTObjectIdentifiers.id_sha512_224);
+        digestNameToOids.put("SHA512-256", NISTObjectIdentifiers.id_sha512_256);
 
         digestNameToOids.put("SHA3-224", NISTObjectIdentifiers.id_sha3_224);
         digestNameToOids.put("SHA3-256", NISTObjectIdentifiers.id_sha3_256);
diff --git a/bcpkix/src/main/java/org/bouncycastle/operator/DefaultSignatureAlgorithmIdentifierFinder.java b/bcpkix/src/main/java/org/bouncycastle/operator/DefaultSignatureAlgorithmIdentifierFinder.java
index c7eef85..b428e0d 100644
--- a/bcpkix/src/main/java/org/bouncycastle/operator/DefaultSignatureAlgorithmIdentifierFinder.java
+++ b/bcpkix/src/main/java/org/bouncycastle/operator/DefaultSignatureAlgorithmIdentifierFinder.java
@@ -13,6 +13,7 @@
 import org.bouncycastle.asn1.bsi.BSIObjectIdentifiers;
 import org.bouncycastle.asn1.cryptopro.CryptoProObjectIdentifiers;
 import org.bouncycastle.asn1.eac.EACObjectIdentifiers;
+import org.bouncycastle.asn1.gm.GMObjectIdentifiers;
 import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
 import org.bouncycastle.asn1.oiw.OIWObjectIdentifiers;
 import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
@@ -95,7 +96,7 @@
         algorithms.put("SHA512WITHCVC-ECDSA", EACObjectIdentifiers.id_TA_ECDSA_SHA_512);
         algorithms.put("SHA3-512WITHSPHINCS256", BCObjectIdentifiers.sphincs256_with_SHA3_512);
         algorithms.put("SHA512WITHSPHINCS256", BCObjectIdentifiers.sphincs256_with_SHA512);
-
+        algorithms.put("SM3WITHSM2", GMObjectIdentifiers.sm2sign_with_sm3);
         //
         // According to RFC 3279, the ASN.1 encoding SHALL (id-dsa-with-sha1) or MUST (ecdsa-with-SHA*) omit the parameters field.
         // The parameters field SHALL be NULL for RSA based signature algorithms.
@@ -124,6 +125,11 @@
         noParams.add(BCObjectIdentifiers.sphincs256_with_SHA3_512);
 
         //
+        // SM2
+        //
+        noParams.add(GMObjectIdentifiers.sm2sign_with_sm3);
+
+        //
         // PKCS 1.5 encrypted  algorithms
         //
         pkcs15RsaEncryption.add(PKCSObjectIdentifiers.sha1WithRSAEncryption);
diff --git a/bcpkix/src/main/java/org/bouncycastle/operator/bc/package.html b/bcpkix/src/main/java/org/bouncycastle/operator/bc/package.html
new file mode 100644
index 0000000..6d7ebba
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/operator/bc/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+Basic operator implementations for doing encryption, signing, and digest operations using the BC lightweight API.
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/OperatorHelper.java b/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/OperatorHelper.java
index f4c9c03..9431ad3 100644
--- a/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/OperatorHelper.java
+++ b/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/OperatorHelper.java
@@ -23,6 +23,7 @@
 
 import org.bouncycastle.asn1.ASN1Encodable;
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Sequence;
 import org.bouncycastle.asn1.DERNull;
 import org.bouncycastle.asn1.bsi.BSIObjectIdentifiers;
 import org.bouncycastle.asn1.cryptopro.CryptoProObjectIdentifiers;
@@ -313,6 +314,27 @@
             }
         }
 
+        if (sigAlgId.getAlgorithm().equals(PKCSObjectIdentifiers.id_RSASSA_PSS))
+        {
+            ASN1Sequence seq = ASN1Sequence.getInstance(sigAlgId.getParameters());
+          
+            if (notDefaultPSSParams(seq))
+            {
+                try
+                {
+                    AlgorithmParameters algParams = helper.createAlgorithmParameters("PSS");
+
+                    algParams.init(seq.getEncoded());
+
+                    sig.setParameter(algParams.getParameterSpec(PSSParameterSpec.class));
+                }
+                catch (IOException e)
+                {
+                    throw new GeneralSecurityException("unable to process PSS parameters: " + e.getMessage());
+                }
+            }
+        }
+
         return sig;
     }
 
@@ -462,4 +484,31 @@
 
         return oid.getId();
     }
+
+    // for our purposes default includes varient digest with salt the same size as digest
+    private boolean notDefaultPSSParams(ASN1Sequence seq)
+        throws GeneralSecurityException
+    {
+        if (seq == null || seq.size() == 0)
+        {
+            return false;
+        }
+
+        RSASSAPSSparams pssParams = RSASSAPSSparams.getInstance(seq);
+
+        if (!pssParams.getMaskGenAlgorithm().getAlgorithm().equals(PKCSObjectIdentifiers.id_mgf1))
+        {
+            return true;
+        }
+
+        // same digest for sig and MGF1
+        if (!pssParams.getHashAlgorithm().equals(AlgorithmIdentifier.getInstance(pssParams.getMaskGenAlgorithm().getParameters())))
+        {
+            return true;
+        }
+
+        MessageDigest digest = createDigest(pssParams.getHashAlgorithm());
+
+        return pssParams.getSaltLength().intValue() != digest.getDigestLength();
+    }
 }
diff --git a/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/package.html b/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/package.html
new file mode 100644
index 0000000..5a7fa1c
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/operator/jcajce/package.html
@@ -0,0 +1,5 @@
+<html>
+<body bgcolor="#ffffff">
+Basic operator implementations for doing encryption, signing, and digest operations using the JCA and the JCE.
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/operator/package.html b/bcpkix/src/main/java/org/bouncycastle/operator/package.html
index b64343a..241c05b 100644
--- a/bcpkix/src/main/java/org/bouncycastle/operator/package.html
+++ b/bcpkix/src/main/java/org/bouncycastle/operator/package.html
@@ -1,5 +1,5 @@
 <html>
 <body bgcolor="#ffffff">
-Basic operators for doing encryption, signing, and digest operations.
+Basic operator definitions for doing encryption, signing, and digest operations.
 </body>
 </html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/pkcs/PKCS10CertificationRequestBuilder.java b/bcpkix/src/main/java/org/bouncycastle/pkcs/PKCS10CertificationRequestBuilder.java
index 851e697..c4785f6 100644
--- a/bcpkix/src/main/java/org/bouncycastle/pkcs/PKCS10CertificationRequestBuilder.java
+++ b/bcpkix/src/main/java/org/bouncycastle/pkcs/PKCS10CertificationRequestBuilder.java
@@ -50,10 +50,20 @@
     private List attributes = new ArrayList();
     private boolean leaveOffEmpty = false;
 
+
+    public PKCS10CertificationRequestBuilder(PKCS10CertificationRequestBuilder original)
+    {
+        this.publicKeyInfo = original.publicKeyInfo;
+        this.subject = original.subject;
+        this.leaveOffEmpty = original.leaveOffEmpty;
+        this.attributes = new ArrayList(original.attributes);
+    }
+
+
     /**
      * Basic constructor.
      *
-     * @param subject the X.500 Name defining the certificate subject this request is for.
+     * @param subject       the X.500 Name defining the certificate subject this request is for.
      * @param publicKeyInfo the info structure for the public key to be associated with this subject.
      */
     public PKCS10CertificationRequestBuilder(X500Name subject, SubjectPublicKeyInfo publicKeyInfo)
@@ -63,30 +73,73 @@
     }
 
     /**
+     * Set an attribute to the certification request we are building.
+     * Removed existing attributes with the same attrType.
+     *
+     * @param attrType  the OID giving the type of the attribute.
+     * @param attrValue the ASN.1 structure that forms the value of the attribute.
+     * @return this builder object.
+     */
+    public PKCS10CertificationRequestBuilder setAttribute(ASN1ObjectIdentifier attrType, ASN1Encodable attrValue)
+    {
+        // Remove existing copies of the attribute.
+        for (Iterator it = attributes.iterator(); it.hasNext(); )
+        {
+            if (((Attribute)it.next()).getAttrType().equals(attrType))
+            {
+                throw new IllegalStateException("Attribute " + attrType.toString() + " is already set");
+            }
+        }
+        addAttribute(attrType, attrValue);
+        return this;
+    }
+
+    /**
+     * Add an attribute with multiple values to the certification request we are building.
+     * Removed existing attributes with the same attrType.
+     *
+     * @param attrType  the OID giving the type of the attribute.
+     * @param attrValue the ASN.1 structure that forms the value of the attribute.
+     * @return this builder object.
+     */
+    public PKCS10CertificationRequestBuilder setAttribute(ASN1ObjectIdentifier attrType, ASN1Encodable[] attrValue)
+    {
+        // Remove existing copies of the attribute.
+        for (Iterator it = attributes.iterator(); it.hasNext(); )
+        {
+            if (((Attribute)it.next()).getAttrType().equals(attrType))
+            {
+                throw new IllegalStateException("Attribute " + attrType.toString() + " is already set");
+            }
+        }
+        addAttribute(attrType, attrValue);
+        return this;
+    }
+
+
+    /**
      * Add an attribute to the certification request we are building.
      *
-     * @param attrType the OID giving the type of the attribute.
+     * @param attrType  the OID giving the type of the attribute.
      * @param attrValue the ASN.1 structure that forms the value of the attribute.
      * @return this builder object.
      */
     public PKCS10CertificationRequestBuilder addAttribute(ASN1ObjectIdentifier attrType, ASN1Encodable attrValue)
     {
         attributes.add(new Attribute(attrType, new DERSet(attrValue)));
-
         return this;
     }
 
     /**
      * Add an attribute with multiple values to the certification request we are building.
      *
-     * @param attrType the OID giving the type of the attribute.
+     * @param attrType   the OID giving the type of the attribute.
      * @param attrValues an array of ASN.1 structures that form the value of the attribute.
      * @return this builder object.
      */
     public PKCS10CertificationRequestBuilder addAttribute(ASN1ObjectIdentifier attrType, ASN1Encodable[] attrValues)
     {
         attributes.add(new Attribute(attrType, new DERSet(attrValues)));
-
         return this;
     }
 
@@ -130,7 +183,7 @@
         {
             ASN1EncodableVector v = new ASN1EncodableVector();
 
-            for (Iterator it = attributes.iterator(); it.hasNext();)
+            for (Iterator it = attributes.iterator(); it.hasNext(); )
             {
                 v.add(Attribute.getInstance(it.next()));
             }
diff --git a/bcpkix/src/main/java/org/bouncycastle/pkcs/bc/package.html b/bcpkix/src/main/java/org/bouncycastle/pkcs/bc/package.html
new file mode 100644
index 0000000..bb47e1a
--- /dev/null
+++ b/bcpkix/src/main/java/org/bouncycastle/pkcs/bc/package.html
@@ -0,0 +1,7 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+        "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body bgcolor="#ffffff">
+BC lightweight API extensions and operators for the PKCS#10 certification request package.
+</body>
+</html>
diff --git a/bcpkix/src/main/java/org/bouncycastle/pkcs/jcajce/package.html b/bcpkix/src/main/java/org/bouncycastle/pkcs/jcajce/package.html
index 9b10dc4..5305be4 100644
--- a/bcpkix/src/main/java/org/bouncycastle/pkcs/jcajce/package.html
+++ b/bcpkix/src/main/java/org/bouncycastle/pkcs/jcajce/package.html
@@ -2,6 +2,6 @@
         "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <body bgcolor="#ffffff">
-JCA extensions to the PKCS#10 certification request package.
+JCA extensions and operators for the PKCS#10 certification request package.
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/anssi/ANSSINamedCurves.java b/bcprov/src/main/java/org/bouncycastle/asn1/anssi/ANSSINamedCurves.java
index 87f0a25..52ad55a 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/anssi/ANSSINamedCurves.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/anssi/ANSSINamedCurves.java
@@ -58,7 +58,7 @@
 
     static void defineCurve(String name, ASN1ObjectIdentifier oid, X9ECParametersHolder holder)
     {
-        objIds.put(name.toLowerCase(), oid);
+        objIds.put(Strings.toLowerCase(name), oid);
         names.put(oid, name);
         curves.put(oid, holder);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartID.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartID.java
new file mode 100644
index 0000000..5d09025
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartID.java
@@ -0,0 +1,71 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+
+/**
+ * <pre>
+ *       bodyIdMax INTEGER ::= 4294967295
+ *
+ *       BodyPartID ::= INTEGER(0..bodyIdMax)
+ * </pre>
+ */
+public class BodyPartID
+    extends ASN1Object
+{
+    public static final long bodyIdMax = 4294967295L;
+
+    private final long id;
+
+    public BodyPartID(long id)
+    {
+        if (id < 0 || id > bodyIdMax)
+        {
+            throw new IllegalArgumentException("id out of range");
+        }
+
+        this.id = id;
+    }
+
+    private static long convert(BigInteger value)
+    {
+        if (value.bitLength() > 32)
+        {
+            throw new IllegalArgumentException("id out of range");
+        }
+        return value.longValue();
+    }
+
+    private BodyPartID(ASN1Integer id)
+    {
+        this(convert(id.getValue()));
+    }
+
+    public static BodyPartID getInstance(Object o)
+    {
+        if (o instanceof BodyPartID)
+        {
+            return (BodyPartID)o;
+        }
+
+        if (o != null)
+        {
+            return new BodyPartID(ASN1Integer.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public long getID()
+    {
+        return id;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new ASN1Integer(id);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartList.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartList.java
new file mode 100644
index 0000000..beda49b
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartList.java
@@ -0,0 +1,75 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ *   BodyPartList ::= SEQUENCE SIZE (1..MAX) OF BodyPartID
+ * </pre>
+ */
+public class BodyPartList
+    extends ASN1Object
+{
+    private final BodyPartID[] bodyPartIDs;
+
+    public static BodyPartList getInstance(
+        Object  obj)
+    {
+        if (obj instanceof BodyPartList)
+        {
+            return (BodyPartList)obj;
+        }
+
+        if (obj != null)
+        {
+            return new BodyPartList(ASN1Sequence.getInstance(obj));
+        }
+
+        return null;
+    }
+
+    public static BodyPartList getInstance(
+        ASN1TaggedObject obj,
+        boolean          explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    /**
+     * Construct a BodyPartList object containing one BodyPartID.
+     *
+     * @param bodyPartID the BodyPartID to be contained.
+     */
+    public BodyPartList(
+        BodyPartID  bodyPartID)
+    {
+        this.bodyPartIDs = new BodyPartID[] { bodyPartID };
+    }
+
+
+    public BodyPartList(
+        BodyPartID[] bodyPartIDs)
+    {
+        this.bodyPartIDs = Utils.clone(bodyPartIDs);
+    }
+
+    private BodyPartList(
+        ASN1Sequence  seq)
+    {
+        this.bodyPartIDs = Utils.toBodyPartIDArray(seq);
+    }
+
+    public BodyPartID[] getBodyPartIDs()
+    {
+        return Utils.clone(bodyPartIDs);
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(bodyPartIDs);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartPath.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartPath.java
new file mode 100644
index 0000000..aac9ec0
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartPath.java
@@ -0,0 +1,75 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ *    BodyPartPath ::= SEQUENCE SIZE (1..MAX) OF BodyPartID
+ * </pre>
+ */
+public class BodyPartPath
+    extends ASN1Object
+{
+    private final BodyPartID[] bodyPartIDs;
+
+    public static BodyPartPath getInstance(
+        Object  obj)
+    {
+        if (obj instanceof BodyPartPath)
+        {
+            return (BodyPartPath)obj;
+        }
+
+        if (obj != null)
+        {
+            return new BodyPartPath(ASN1Sequence.getInstance(obj));
+        }
+
+        return null;
+    }
+
+    public static BodyPartPath getInstance(
+        ASN1TaggedObject obj,
+        boolean          explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    /**
+     * Construct a BodyPartPath object containing one BodyPartID.
+     *
+     * @param bodyPartID the BodyPartID to be contained.
+     */
+    public BodyPartPath(
+        BodyPartID  bodyPartID)
+    {
+        this.bodyPartIDs = new BodyPartID[] { bodyPartID };
+    }
+
+
+    public BodyPartPath(
+        BodyPartID[] bodyPartIDs)
+    {
+        this.bodyPartIDs = Utils.clone(bodyPartIDs);
+    }
+
+    private BodyPartPath(
+        ASN1Sequence  seq)
+    {
+        this.bodyPartIDs = Utils.toBodyPartIDArray(seq);
+    }
+
+    public BodyPartID[] getBodyPartIDs()
+    {
+        return Utils.clone(bodyPartIDs);
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(bodyPartIDs);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartReference.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartReference.java
new file mode 100644
index 0000000..de2ff47
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/BodyPartReference.java
@@ -0,0 +1,105 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.io.IOException;
+
+import org.bouncycastle.asn1.ASN1Choice;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+
+/**
+ * <pre>
+ * BodyPartReference ::= CHOICE {
+ *    bodyPartID           BodyPartID,
+ *    bodyPartPath         BodyPartPath
+ * }
+ * </pre>
+ */
+public class BodyPartReference
+    extends ASN1Object
+    implements ASN1Choice
+{
+    private final BodyPartID bodyPartID;
+    private final BodyPartPath bodyPartPath;
+
+    public BodyPartReference(BodyPartID bodyPartID)
+    {
+        this.bodyPartID = bodyPartID;
+        this.bodyPartPath = null;
+    }
+
+    public BodyPartReference(BodyPartPath bodyPartPath)
+    {
+        this.bodyPartID = null;
+        this.bodyPartPath = bodyPartPath;
+    }
+
+    public static BodyPartReference getInstance(
+        Object  obj)
+    {
+        if (obj instanceof BodyPartReference)
+        {
+            return (BodyPartReference)obj;
+        }
+
+        if (obj != null)
+        {
+            if (obj instanceof ASN1Encodable)
+            {
+                ASN1Encodable asn1Prim = ((ASN1Encodable)obj).toASN1Primitive();
+
+                if (asn1Prim instanceof ASN1Integer)
+                {
+                    return new BodyPartReference(BodyPartID.getInstance(asn1Prim));
+                }
+                if (asn1Prim instanceof ASN1Sequence)
+                {
+                    return new BodyPartReference(BodyPartPath.getInstance(asn1Prim));
+                }
+            }
+            if (obj instanceof byte[])
+            {
+                try
+                {
+                    return getInstance(ASN1Primitive.fromByteArray((byte[])obj));
+                }
+                catch (IOException e)
+                {
+                    throw new IllegalArgumentException("unknown encoding in getInstance()");
+                }
+            }
+            throw new IllegalArgumentException("unknown object in getInstance(): " + obj.getClass().getName());
+        }
+
+        return null;
+    }
+
+    public boolean isBodyPartID()
+    {
+        return bodyPartID != null;
+    }
+
+    public BodyPartID getBodyPartID()
+    {
+        return bodyPartID;
+    }
+
+    public BodyPartPath getBodyPartPath()
+    {
+        return bodyPartPath;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        if (bodyPartID != null)
+        {
+            return bodyPartID.toASN1Primitive();
+        }
+        else
+        {
+            return bodyPartPath.toASN1Primitive();
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCFailInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCFailInfo.java
new file mode 100644
index 0000000..b71dd14
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCFailInfo.java
@@ -0,0 +1,104 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+
+/**
+ * <pre>
+ * CMCFailInfo ::= INTEGER {
+ *     badAlg          (0),
+ *     badMessageCheck (1),
+ *     badRequest      (2),
+ *     badTime         (3),
+ *     badCertId       (4),
+ *     unsupportedExt  (5),
+ *     mustArchiveKeys (6),
+ *     badIdentity     (7),
+ *     popRequired     (8),
+ *     popFailed       (9),
+ *     noKeyReuse      (10),
+ *     internalCAError (11),
+ *     tryLater        (12),
+ *     authDataFail    (13)
+ * }
+ * </pre>
+ */
+public class CMCFailInfo
+    extends ASN1Object
+{
+    public static final CMCFailInfo badAlg = new CMCFailInfo(new ASN1Integer(0));
+    public static final CMCFailInfo badMessageCheck = new CMCFailInfo(new ASN1Integer(1));
+    public static final CMCFailInfo badRequest = new CMCFailInfo(new ASN1Integer(2));
+    public static final CMCFailInfo badTime = new CMCFailInfo(new ASN1Integer(3));
+    public static final CMCFailInfo badCertId = new CMCFailInfo(new ASN1Integer(4));
+    public static final CMCFailInfo unsupportedExt = new CMCFailInfo(new ASN1Integer(5));
+    public static final CMCFailInfo mustArchiveKeys = new CMCFailInfo(new ASN1Integer(6));
+    public static final CMCFailInfo badIdentity = new CMCFailInfo(new ASN1Integer(7));
+    public static final CMCFailInfo popRequired = new CMCFailInfo(new ASN1Integer(8));
+    public static final CMCFailInfo popFailed = new CMCFailInfo(new ASN1Integer(9));
+    public static final CMCFailInfo noKeyReuse = new CMCFailInfo(new ASN1Integer(10));
+    public static final CMCFailInfo internalCAError = new CMCFailInfo(new ASN1Integer(11));
+    public static final CMCFailInfo tryLater = new CMCFailInfo(new ASN1Integer(12));
+    public static final CMCFailInfo authDataFail = new CMCFailInfo(new ASN1Integer(13));
+
+    private static Map range = new HashMap();
+
+    static
+    {
+        range.put(badAlg.value, badAlg);
+        range.put(badMessageCheck.value, badMessageCheck);
+        range.put(badRequest.value, badRequest);
+        range.put(badTime.value, badTime);
+        range.put(badCertId.value, badCertId);
+        range.put(popRequired.value, popRequired);
+        range.put(unsupportedExt.value, unsupportedExt);
+        range.put(mustArchiveKeys.value, mustArchiveKeys);
+        range.put(badIdentity.value, badIdentity);
+        range.put(popRequired.value, popRequired);
+        range.put(popFailed.value, popFailed);
+        range.put(badCertId.value, badCertId);
+        range.put(popRequired.value, popRequired);
+        range.put(noKeyReuse.value, noKeyReuse);
+        range.put(internalCAError.value, internalCAError);
+        range.put(tryLater.value, tryLater);
+        range.put(authDataFail.value, authDataFail);
+    }
+
+    private final ASN1Integer value;
+
+    private CMCFailInfo(ASN1Integer value)
+    {
+         this.value = value;
+    }
+
+    public static CMCFailInfo getInstance(Object o)
+    {
+        if (o instanceof CMCFailInfo)
+        {
+            return (CMCFailInfo)o;
+        }
+
+        if (o != null)
+        {
+            CMCFailInfo status = (CMCFailInfo)range.get(ASN1Integer.getInstance(o));
+
+            if (status != null)
+            {
+                return status;
+            }
+
+            throw new IllegalArgumentException("unknown object in getInstance(): " + o.getClass().getName());
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return value;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCObjectIdentifiers.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCObjectIdentifiers.java
new file mode 100644
index 0000000..c1c5a03
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCObjectIdentifiers.java
@@ -0,0 +1,101 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+
+/**
+ * Object Identifiers from RFC 5272
+ */
+public interface CMCObjectIdentifiers
+{
+    //   id_pkix OBJECT IDENTIFIER  ::= { iso(1) identified_organization(3)
+    //       dod(6) internet(1) security(5) mechanisms(5) pkix(7) }
+   ASN1ObjectIdentifier id_pkix = new ASN1ObjectIdentifier("1.3.6.1.5.5.7");
+        
+   ASN1ObjectIdentifier id_cmc =  id_pkix.branch("7");   // CMC controls
+   ASN1ObjectIdentifier id_cct =  id_pkix.branch("12");  // CMC content types
+  
+   // The following controls have the type OCTET STRING
+  
+   ASN1ObjectIdentifier id_cmc_identityProof =  id_cmc.branch("3");
+   ASN1ObjectIdentifier id_cmc_dataReturn =  id_cmc.branch("4");
+   ASN1ObjectIdentifier id_cmc_regInfo =  id_cmc.branch("18");
+   ASN1ObjectIdentifier id_cmc_responseInfo =  id_cmc.branch("19");
+   ASN1ObjectIdentifier id_cmc_queryPending =  id_cmc.branch("21");
+   ASN1ObjectIdentifier id_cmc_popLinkRandom =  id_cmc.branch("22");
+   ASN1ObjectIdentifier id_cmc_popLinkWitness =  id_cmc.branch("23");
+  
+   // The following controls have the type UTF8String
+  
+   ASN1ObjectIdentifier id_cmc_identification =  id_cmc.branch("2");
+  
+   // The following controls have the type INTEGER
+  
+   ASN1ObjectIdentifier id_cmc_transactionId =  id_cmc.branch("5");
+  
+   // The following controls have the type OCTET STRING
+  
+   ASN1ObjectIdentifier id_cmc_senderNonce =  id_cmc.branch("6");
+   ASN1ObjectIdentifier id_cmc_recipientNonce =  id_cmc.branch("7");
+  
+    // This is the content type used for a request message in the protocol
+  
+   ASN1ObjectIdentifier id_cct_PKIData =  id_cct.branch("2");
+
+    //  This defines the response message in the protocol
+    ASN1ObjectIdentifier id_cct_PKIResponse = id_cct.branch("3");
+
+    // Used to return status state in a response
+
+    ASN1ObjectIdentifier id_cmc_statusInfo = id_cmc.branch("1");
+
+
+    // Used for RAs to add extensions to certification requests
+    ASN1ObjectIdentifier id_cmc_addExtensions = id_cmc.branch("8");
+
+    ASN1ObjectIdentifier id_cmc_encryptedPOP = id_cmc.branch("9");
+    ASN1ObjectIdentifier id_cmc_decryptedPOP = id_cmc.branch("10");
+
+
+    ASN1ObjectIdentifier id_cmc_lraPOPWitness = id_cmc.branch("11");
+
+    ASN1ObjectIdentifier id_cmc_getCert = id_cmc.branch("15");
+
+    ASN1ObjectIdentifier id_cmc_getCRL = id_cmc.branch("16");
+
+    ASN1ObjectIdentifier id_cmc_revokeRequest = id_cmc.branch("17");
+
+
+    ASN1ObjectIdentifier id_cmc_confirmCertAcceptance = id_cmc.branch("24");
+
+    //  Replaces CMC Status Info
+    //
+
+    ASN1ObjectIdentifier id_cmc_statusInfoV2 = id_cmc.branch("25");
+
+
+    //  Allow for distribution of trust anchors
+    //
+
+    ASN1ObjectIdentifier id_cmc_trustedAnchors = id_cmc.branch("26");
+
+    ASN1ObjectIdentifier id_cmc_authData = id_cmc.branch("27");
+
+    //   These two items use BodyPartList
+    ASN1ObjectIdentifier id_cmc_batchRequests = id_cmc.branch("28");
+    ASN1ObjectIdentifier id_cmc_batchResponses = id_cmc.branch("29");
+
+    ASN1ObjectIdentifier id_cmc_publishCert = id_cmc.branch("30");
+
+    ASN1ObjectIdentifier id_cmc_modCertTemplate = id_cmc.branch("31");
+
+    // Inform follow on servers that one or more controls have already been
+    // processed
+
+    ASN1ObjectIdentifier id_cmc_controlProcessed = id_cmc.branch("32");
+
+    //  Identity Proof control w/ algorithm agility
+
+    ASN1ObjectIdentifier id_cmc_identityProofV2 = id_cmc.branch("34");
+    
+    ASN1ObjectIdentifier id_cmc_popLinkWitnessV2 = id_cmc.branch("33");
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCPublicationInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCPublicationInfo.java
new file mode 100644
index 0000000..c8c08c2
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCPublicationInfo.java
@@ -0,0 +1,103 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.crmf.PKIPublicationInfo;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+
+/**
+ *<pre>
+ *      CMCPublicationInfo ::= SEQUENCE {
+ *           hashAlg                      AlgorithmIdentifier,
+ *           certHashes                   SEQUENCE OF OCTET STRING,
+ *           pubInfo                      PKIPublicationInfo
+ * }
+ *
+ *</pre>
+ */
+public class CMCPublicationInfo
+    extends ASN1Object
+{
+    private final AlgorithmIdentifier hashAlg;
+    private final ASN1Sequence certHashes;
+    private final PKIPublicationInfo pubInfo;
+
+    public CMCPublicationInfo(AlgorithmIdentifier hashAlg, byte[][] anchorHashes, PKIPublicationInfo pubInfo)
+    {
+        this.hashAlg = hashAlg;
+
+        ASN1EncodableVector v = new ASN1EncodableVector();
+        for (int i = 0; i != anchorHashes.length; i++)
+        {
+             v.add(new DEROctetString(Arrays.clone(anchorHashes[i])));
+        }
+        this.certHashes = new DERSequence(v);
+
+        this.pubInfo = pubInfo;
+    }
+
+    private CMCPublicationInfo(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.hashAlg = AlgorithmIdentifier.getInstance(seq.getObjectAt(0));
+        this.certHashes = ASN1Sequence.getInstance(seq.getObjectAt(1));
+        this.pubInfo = PKIPublicationInfo.getInstance(seq.getObjectAt(2));
+    }
+
+    public static CMCPublicationInfo getInstance(Object o)
+    {
+        if (o instanceof CMCPublicationInfo)
+        {
+            return (CMCPublicationInfo)o;
+        }
+
+        if (o != null)
+        {
+            return new CMCPublicationInfo(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public AlgorithmIdentifier getHashAlg()
+    {
+        return hashAlg;
+    }
+
+    public byte[][] getCertHashes()
+    {
+        byte[][] hashes = new byte[certHashes.size()][];
+
+        for (int i = 0; i != hashes.length; i++)
+        {
+            hashes[i] = Arrays.clone(ASN1OctetString.getInstance(certHashes.getObjectAt(i)).getOctets());
+        }
+
+        return hashes;
+    }
+
+    public PKIPublicationInfo getPubInfo()
+    {
+        return pubInfo;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(hashAlg);
+        v.add(certHashes);
+        v.add(pubInfo);
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatus.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatus.java
new file mode 100644
index 0000000..8aa8c85
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatus.java
@@ -0,0 +1,81 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+
+/**
+ * <pre>
+ *
+ * CMCStatus ::= INTEGER {
+ *    success         (0),
+ *    failed          (2),
+ *    pending         (3),
+ *    noSupport       (4),
+ *    confirmRequired (5),
+ *    popRequired     (6),
+ *    partial         (7)
+ * }
+ * </pre>
+ */
+public class CMCStatus
+    extends ASN1Object
+{
+    public static final CMCStatus success = new CMCStatus(new ASN1Integer(0));
+    public static final CMCStatus failed = new CMCStatus(new ASN1Integer(2));
+    public static final CMCStatus pending = new CMCStatus(new ASN1Integer(3));
+    public static final CMCStatus noSupport = new CMCStatus(new ASN1Integer(4));
+    public static final CMCStatus confirmRequired = new CMCStatus(new ASN1Integer(5));
+    public static final CMCStatus popRequired = new CMCStatus(new ASN1Integer(6));
+    public static final CMCStatus partial = new CMCStatus(new ASN1Integer(7));
+
+    private static Map range = new HashMap();
+
+    static
+    {
+        range.put(success.value, success);
+        range.put(failed.value, failed);
+        range.put(pending.value, pending);
+        range.put(noSupport.value, noSupport);
+        range.put(confirmRequired.value, confirmRequired);
+        range.put(popRequired.value, popRequired);
+        range.put(partial.value, partial);
+    }
+
+    private final ASN1Integer value;
+
+    private CMCStatus(ASN1Integer value)
+    {
+         this.value = value;
+    }
+
+    public static CMCStatus getInstance(Object o)
+    {
+        if (o instanceof CMCStatus)
+        {
+            return (CMCStatus)o;
+        }
+
+        if (o != null)
+        {
+            CMCStatus status = (CMCStatus)range.get(ASN1Integer.getInstance(o));
+
+            if (status != null)
+            {
+                return status;
+            }
+
+            throw new IllegalArgumentException("unknown object in getInstance(): " + o.getClass().getName());
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return value;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfo.java
new file mode 100644
index 0000000..e26e611
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfo.java
@@ -0,0 +1,198 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Choice;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+
+/**
+ * <pre>
+ * -- Used to return status state in a response
+ *
+ * id-cmc-statusInfo OBJECT IDENTIFIER ::= {id-cmc 1}
+ *
+ * CMCStatusInfo ::= SEQUENCE {
+ *     cMCStatus       CMCStatus,
+ *     bodyList        SEQUENCE SIZE (1..MAX) OF BodyPartID,
+ *     statusString    UTF8String OPTIONAL,
+ *     otherInfo        CHOICE {
+ *       failInfo         CMCFailInfo,
+ *       pendInfo         PendInfo } OPTIONAL
+ * }
+ * </pre>
+ */
+public class CMCStatusInfo
+    extends ASN1Object
+{
+    private final CMCStatus cMCStatus;
+    private final ASN1Sequence bodyList;
+    private final DERUTF8String statusString;
+    private final OtherInfo otherInfo;
+
+    CMCStatusInfo(CMCStatus cMCStatus, ASN1Sequence bodyList, DERUTF8String statusString, OtherInfo otherInfo)
+    {
+        this.cMCStatus = cMCStatus;
+        this.bodyList = bodyList;
+        this.statusString = statusString;
+        this.otherInfo = otherInfo;
+    }
+
+    private CMCStatusInfo(ASN1Sequence seq)
+    {
+        if (seq.size() < 2 || seq.size() > 4)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.cMCStatus = CMCStatus.getInstance(seq.getObjectAt(0));
+        this.bodyList = ASN1Sequence.getInstance(seq.getObjectAt(1));
+
+        if (seq.size() > 3)
+        {
+            this.statusString = DERUTF8String.getInstance(seq.getObjectAt(2));
+            this.otherInfo = OtherInfo.getInstance(seq.getObjectAt(3));
+        }
+        else if (seq.size() > 2)
+        {
+            if (seq.getObjectAt(2) instanceof  DERUTF8String)
+            {
+                this.statusString = DERUTF8String.getInstance(seq.getObjectAt(2));
+                this.otherInfo = null;
+            }
+            else
+            {
+                this.statusString = null;
+                this.otherInfo = OtherInfo.getInstance(seq.getObjectAt(2));
+            }
+        }
+        else
+        {
+            this.statusString = null;
+            this.otherInfo = null;
+        }
+    }
+
+    public static CMCStatusInfo getInstance(Object o)
+    {
+        if (o instanceof CMCStatusInfo)
+        {
+            return (CMCStatusInfo)o;
+        }
+
+        if (o != null)
+        {
+            return new CMCStatusInfo(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+        v.add(cMCStatus);
+        v.add(bodyList);
+        if (statusString != null)
+        {
+            v.add(statusString);
+        }
+        if (otherInfo != null)
+        {
+            v.add(otherInfo);
+        }
+        return new DERSequence(v);
+    }
+
+    public CMCStatus getCMCStatus()
+    {
+        return cMCStatus;
+    }
+
+    public BodyPartID[] getBodyList()
+    {
+        return Utils.toBodyPartIDArray(bodyList);
+    }
+
+    public DERUTF8String getStatusString()
+    {
+        return statusString;
+    }
+
+    public boolean hasOtherInfo()
+    {
+        return otherInfo != null;
+    }
+
+    public OtherInfo getOtherInfo()
+    {
+        return otherInfo;
+    }
+
+    /**
+     * Other info implements the choice component of CMCStatusInfo.
+     */
+    public static class OtherInfo
+        extends ASN1Object
+        implements ASN1Choice
+    {
+        private final CMCFailInfo failInfo;
+        private final PendInfo pendInfo;
+
+        private static OtherInfo getInstance(Object obj)
+        {
+            if (obj instanceof OtherInfo)
+            {
+                return (OtherInfo)obj;
+            }
+
+            if (obj instanceof ASN1Encodable)
+            {
+                ASN1Encodable asn1Value = ((ASN1Encodable)obj).toASN1Primitive();
+
+                if (asn1Value instanceof ASN1Integer) // CMCFail info is an asn1 integer.
+                {
+                    return new OtherInfo(CMCFailInfo.getInstance(asn1Value));
+                }
+                else if (asn1Value instanceof ASN1Sequence) // PendInfo is a sequence.
+                {
+                    return new OtherInfo(PendInfo.getInstance(asn1Value));
+                }
+            }
+            throw new IllegalArgumentException("unknown object in getInstance(): " + obj.getClass().getName());
+        }
+
+        OtherInfo(CMCFailInfo failInfo)
+        {
+            this(failInfo, null);
+        }
+
+        OtherInfo(PendInfo pendInfo)
+        {
+            this(null, pendInfo);
+        }
+
+        private OtherInfo(CMCFailInfo failInfo, PendInfo pendInfo)
+        {
+            this.failInfo = failInfo;
+            this.pendInfo = pendInfo;
+        }
+
+        public boolean isFailInfo()
+        {
+            return failInfo != null;
+        }
+
+        public ASN1Primitive toASN1Primitive()
+        {
+            if (pendInfo != null)
+            {
+                return pendInfo.toASN1Primitive();
+            }
+            return failInfo.toASN1Primitive();
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoBuilder.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoBuilder.java
new file mode 100644
index 0000000..e7c9205
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoBuilder.java
@@ -0,0 +1,52 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+
+public class CMCStatusInfoBuilder
+{
+    private final CMCStatus cMCStatus;
+    private final ASN1Sequence bodyList;
+
+    private DERUTF8String statusString;
+    private CMCStatusInfo.OtherInfo otherInfo;
+
+    public CMCStatusInfoBuilder(CMCStatus cMCStatus, BodyPartID bodyPartID)
+    {
+        this.cMCStatus = cMCStatus;
+        this.bodyList = new DERSequence(bodyPartID);
+    }
+
+    public CMCStatusInfoBuilder(CMCStatus cMCStatus, BodyPartID[] bodyList)
+    {
+        this.cMCStatus = cMCStatus;
+        this.bodyList = new DERSequence(bodyList);
+    }
+
+    public CMCStatusInfoBuilder setStatusString(String statusString)
+    {
+        this.statusString = new DERUTF8String(statusString);
+
+        return this;
+    }
+
+    public CMCStatusInfoBuilder setOtherInfo(CMCFailInfo failInfo)
+    {
+        this.otherInfo = new CMCStatusInfo.OtherInfo(failInfo);
+
+        return this;
+    }
+
+    public CMCStatusInfoBuilder setOtherInfo(PendInfo pendInfo)
+    {
+        this.otherInfo = new CMCStatusInfo.OtherInfo(pendInfo);
+
+        return this;
+    }
+
+    public CMCStatusInfo build()
+    {
+        return new CMCStatusInfo(cMCStatus, bodyList, statusString, otherInfo);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoV2.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoV2.java
new file mode 100644
index 0000000..b3ce962
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoV2.java
@@ -0,0 +1,151 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+
+/**
+ * <pre>
+ * --  Replaces CMC Status Info
+ * --
+ *
+ * id-cmc-statusInfoV2 OBJECT IDENTIFIER ::= {id-cmc 25}
+ *
+ * CMCStatusInfoV2 ::= SEQUENCE {
+ *  cMCStatus             CMCStatus,
+ *  bodyList              SEQUENCE SIZE (1..MAX) OF BodyPartReference,
+ *  statusString          UTF8String OPTIONAL,
+ *  otherStatusInfo             OtherStatusInfo OPTIONAL
+ * }
+ *
+ * OtherStatusInfo ::= CHOICE {
+ *  failInfo              CMCFailInfo,
+ *  pendInfo              PendInfo,
+ *  extendedFailInfo      ExtendedFailInfo
+ * }
+ *
+ * PendInfo ::= SEQUENCE {
+ * pendToken           OCTET STRING,
+ * pendTime            GeneralizedTime
+ * }
+ *
+ * ExtendedFailInfo ::= SEQUENCE {
+ * failInfoOID            OBJECT IDENTIFIER,
+ * failInfoValue          ANY DEFINED BY failInfoOID
+ * }
+ * </pre>
+ */
+public class CMCStatusInfoV2
+    extends ASN1Object
+{
+    private final CMCStatus cMCStatus;
+    private final ASN1Sequence bodyList;
+    private final DERUTF8String statusString;
+    private final OtherStatusInfo otherStatusInfo;
+
+    CMCStatusInfoV2(CMCStatus cMCStatus, ASN1Sequence bodyList, DERUTF8String statusString, OtherStatusInfo otherStatusInfo)
+    {
+        this.cMCStatus = cMCStatus;
+        this.bodyList = bodyList;
+        this.statusString = statusString;
+        this.otherStatusInfo = otherStatusInfo;
+    }
+
+    private CMCStatusInfoV2(ASN1Sequence seq)
+    {
+        if (seq.size() < 2 || seq.size() > 4)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.cMCStatus = CMCStatus.getInstance(seq.getObjectAt(0));
+        this.bodyList = ASN1Sequence.getInstance(seq.getObjectAt(1));
+
+        if (seq.size() > 2)
+        {
+            if (seq.size() == 4)
+            {
+                this.statusString = DERUTF8String.getInstance(seq.getObjectAt(2));
+                this.otherStatusInfo = OtherStatusInfo.getInstance(seq.getObjectAt(3));
+            }
+            else if (seq.getObjectAt(2) instanceof DERUTF8String)
+            {
+                this.statusString = DERUTF8String.getInstance(seq.getObjectAt(2));
+                this.otherStatusInfo = null;
+            }
+            else
+            {
+                this.statusString = null;
+                this.otherStatusInfo = OtherStatusInfo.getInstance(seq.getObjectAt(2));
+            }
+        }
+        else
+        {
+            this.statusString = null;
+            this.otherStatusInfo = null;
+        }
+    }
+
+
+    public CMCStatus getcMCStatus()
+    {
+        return cMCStatus;
+    }
+
+    public BodyPartID[] getBodyList()
+    {
+        return Utils.toBodyPartIDArray(bodyList);
+    }
+
+    public DERUTF8String getStatusString()
+    {
+        return statusString;
+    }
+
+    public OtherStatusInfo getOtherStatusInfo()
+    {
+        return otherStatusInfo;
+    }
+
+    public boolean hasOtherInfo()
+    {
+        return otherStatusInfo != null;
+    }
+
+    public static CMCStatusInfoV2 getInstance(Object o)
+    {
+        if (o instanceof CMCStatusInfoV2)
+        {
+            return (CMCStatusInfoV2)o;
+        }
+
+        if (o != null)
+        {
+            return new CMCStatusInfoV2(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(cMCStatus);
+        v.add(bodyList);
+
+        if (statusString != null)
+        {
+            v.add(statusString);
+        }
+
+        if (otherStatusInfo != null)
+        {
+            v.add(otherStatusInfo);
+        }
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoV2Builder.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoV2Builder.java
new file mode 100644
index 0000000..b36912a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCStatusInfoV2Builder.java
@@ -0,0 +1,59 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+
+public class CMCStatusInfoV2Builder
+{
+    private final CMCStatus cMCStatus;
+    private final ASN1Sequence bodyList;
+
+    private DERUTF8String statusString;
+    private OtherStatusInfo otherInfo;
+
+    public CMCStatusInfoV2Builder(CMCStatus cMCStatus, BodyPartID bodyPartID)
+    {
+        this.cMCStatus = cMCStatus;
+        this.bodyList = new DERSequence(bodyPartID);
+    }
+
+    public CMCStatusInfoV2Builder(CMCStatus cMCStatus, BodyPartID[] bodyList)
+    {
+        this.cMCStatus = cMCStatus;
+        this.bodyList = new DERSequence(bodyList);
+    }
+
+    public CMCStatusInfoV2Builder setStatusString(String statusString)
+    {
+        this.statusString = new DERUTF8String(statusString);
+
+        return this;
+    }
+
+    public CMCStatusInfoV2Builder setOtherInfo(CMCFailInfo failInfo)
+    {
+        this.otherInfo = new OtherStatusInfo(failInfo);
+
+        return this;
+    }
+
+    public CMCStatusInfoV2Builder setOtherInfo(ExtendedFailInfo extendedFailInfo)
+    {
+        this.otherInfo = new OtherStatusInfo(extendedFailInfo);
+
+        return this;
+    }
+
+    public CMCStatusInfoV2Builder setOtherInfo(PendInfo pendInfo)
+    {
+        this.otherInfo = new OtherStatusInfo(pendInfo);
+
+        return this;
+    }
+
+    public CMCStatusInfoV2 build()
+    {
+        return new CMCStatusInfoV2(cMCStatus, bodyList, statusString, otherInfo);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCUnsignedData.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCUnsignedData.java
new file mode 100644
index 0000000..2ea2a2a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CMCUnsignedData.java
@@ -0,0 +1,87 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ *      id-aa-cmc-unsignedData OBJECT IDENTIFIER ::= {id-aa 34}
+ *
+ *      CMCUnsignedData ::= SEQUENCE {
+ *             bodyPartPath        BodyPartPath,
+ *             identifier          OBJECT IDENTIFIER,
+ *             content             ANY DEFINED BY identifier
+ *      }
+ * </pre>
+ */
+public class CMCUnsignedData
+    extends ASN1Object
+{
+    private final BodyPartPath bodyPartPath;
+    private final ASN1ObjectIdentifier identifier;
+    private final ASN1Encodable content;
+
+    public CMCUnsignedData(BodyPartPath bodyPartPath, ASN1ObjectIdentifier identifier, ASN1Encodable content)
+    {
+        this.bodyPartPath = bodyPartPath;
+        this.identifier = identifier;
+        this.content = content;
+    }
+
+    private CMCUnsignedData(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartPath = BodyPartPath.getInstance(seq.getObjectAt(0));
+        this.identifier = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(1));
+        this.content = seq.getObjectAt(2);
+    }
+
+    public static CMCUnsignedData getInstance(Object o)
+    {
+        if (o instanceof CMCUnsignedData)
+        {
+            return (CMCUnsignedData)o;
+        }
+
+        if (o != null)
+        {
+            return new CMCUnsignedData(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(bodyPartPath);
+        v.add(identifier);
+        v.add(content);
+
+        return new DERSequence(v);
+    }
+
+    public BodyPartPath getBodyPartPath()
+    {
+        return bodyPartPath;
+    }
+
+    public ASN1ObjectIdentifier getIdentifier()
+    {
+        return identifier;
+    }
+
+    public ASN1Encodable getContent()
+    {
+        return content;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CertificationRequest.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CertificationRequest.java
new file mode 100644
index 0000000..fc9aa29
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/CertificationRequest.java
@@ -0,0 +1,214 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.io.IOException;
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1Set;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERBitString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERTaggedObject;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+
+/**
+ * <pre>
+ *   CertificationRequest ::= SEQUENCE {
+ *     certificationRequestInfo  SEQUENCE {
+ *       version                   INTEGER,
+ *       subject                   Name,
+ *       subjectPublicKeyInfo      SEQUENCE {
+ *          algorithm                 AlgorithmIdentifier,
+ *          subjectPublicKey          BIT STRING },
+ *       attributes                [0] IMPLICIT SET OF Attribute },
+ *    signatureAlgorithm        AlgorithmIdentifier,
+ *    signature                 BIT STRING
+ *  }
+ * </pre>
+ */
+public class CertificationRequest
+    extends ASN1Object
+{
+    private static final ASN1Integer ZERO = new ASN1Integer(0);
+
+    private final CertificationRequestInfo certificationRequestInfo;
+    private final AlgorithmIdentifier signatureAlgorithm;
+    private final DERBitString signature;
+
+    public CertificationRequest(
+        X500Name                subject,
+        AlgorithmIdentifier     subjectPublicAlgorithm,
+        DERBitString            subjectPublicKey,
+        ASN1Set                 attributes,
+        AlgorithmIdentifier     signatureAlgorithm,
+        DERBitString            signature)
+    {
+        this.certificationRequestInfo = new CertificationRequestInfo(subject, subjectPublicAlgorithm, subjectPublicKey, attributes);
+        this.signatureAlgorithm = signatureAlgorithm;
+        this.signature = signature;
+    }
+
+    private CertificationRequest(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.certificationRequestInfo = new CertificationRequestInfo(ASN1Sequence.getInstance(seq.getObjectAt(0)));
+        this.signatureAlgorithm = AlgorithmIdentifier.getInstance(seq.getObjectAt(1));
+        this.signature = DERBitString.getInstance(seq.getObjectAt(2));
+    }
+
+    public static CertificationRequest getInstance(Object o)
+    {
+        if (o instanceof CertificationRequest)
+        {
+            return (CertificationRequest)o;
+        }
+
+        if (o != null)
+        {
+            return new CertificationRequest(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public BigInteger getVersion()
+    {
+        return certificationRequestInfo.getVersion().getValue();
+    }
+
+    public X500Name getSubject()
+    {
+        return certificationRequestInfo.getSubject();
+    }
+
+    public ASN1Set getAttributes()
+    {
+        return certificationRequestInfo.getAttributes();
+    }
+
+    public AlgorithmIdentifier getSubjectPublicKeyAlgorithm()
+    {
+        return AlgorithmIdentifier.getInstance(certificationRequestInfo.getSubjectPublicKeyInfo().getObjectAt(0));
+    }
+
+    public DERBitString getSubjectPublicKey()
+    {
+        return DERBitString.getInstance(certificationRequestInfo.getSubjectPublicKeyInfo().getObjectAt(1));
+    }
+
+    /**
+     * If the public key is an encoded object this will return the ASN.1 primitives encoded - if the bitstring
+     * can't be decoded this routine throws an IOException.
+     *
+     * @exception IOException - if the bit string doesn't represent a DER encoded object.
+     * @return the public key as an ASN.1 primitive.
+     */
+    public ASN1Primitive parsePublicKey()
+        throws IOException
+    {
+        return ASN1Primitive.fromByteArray(getSubjectPublicKey().getOctets());
+    }
+
+    public AlgorithmIdentifier getSignatureAlgorithm()
+    {
+        return signatureAlgorithm;
+    }
+
+    public DERBitString getSignature()
+    {
+        return signature;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(certificationRequestInfo);
+        v.add(signatureAlgorithm);
+        v.add(signature);
+
+        return new DERSequence(v);
+    }
+
+    private class CertificationRequestInfo
+        extends ASN1Object
+    {
+        private final ASN1Integer version;
+        private final X500Name subject;
+        private final ASN1Sequence subjectPublicKeyInfo;
+        private final ASN1Set attributes;
+
+        private CertificationRequestInfo(
+            ASN1Sequence  seq)
+        {
+            if (seq.size() != 4)
+            {
+                throw new IllegalArgumentException("incorrect sequence size for CertificationRequestInfo");
+            }
+            version = ASN1Integer.getInstance(seq.getObjectAt(0));
+
+            subject = X500Name.getInstance(seq.getObjectAt(1));
+            subjectPublicKeyInfo = ASN1Sequence.getInstance(seq.getObjectAt(2));
+            if (subjectPublicKeyInfo.size() != 2)
+            {
+                throw new IllegalArgumentException("incorrect subjectPublicKeyInfo size for CertificationRequestInfo");
+            }
+
+            ASN1TaggedObject tagobj = (ASN1TaggedObject)seq.getObjectAt(3);
+            if (tagobj.getTagNo() != 0)
+            {
+                throw new IllegalArgumentException("incorrect tag number on attributes for CertificationRequestInfo");
+            }
+            attributes = ASN1Set.getInstance(tagobj, false);
+        }
+
+        private CertificationRequestInfo(X500Name subject, AlgorithmIdentifier algorithm, DERBitString subjectPublicKey, ASN1Set attributes)
+        {
+            this.version = ZERO;
+            this.subject = subject;
+            this.subjectPublicKeyInfo = new DERSequence(new ASN1Encodable[] { algorithm, subjectPublicKey });
+            this.attributes = attributes;
+        }
+
+        private ASN1Integer getVersion()
+        {
+            return version;
+        }
+
+        private X500Name getSubject()
+        {
+            return subject;
+        }
+
+        private ASN1Sequence getSubjectPublicKeyInfo()
+        {
+            return subjectPublicKeyInfo;
+        }
+
+        private ASN1Set getAttributes()
+        {
+            return attributes;
+        }
+
+        public ASN1Primitive toASN1Primitive()
+        {
+            ASN1EncodableVector v = new ASN1EncodableVector();
+
+            v.add(version);
+            v.add(subject);
+            v.add(subjectPublicKeyInfo);
+            v.add(new DERTaggedObject(false, 0, attributes));
+
+            return new DERSequence(v);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ControlsProcessed.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ControlsProcessed.java
new file mode 100644
index 0000000..4c82545
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ControlsProcessed.java
@@ -0,0 +1,84 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ * -- Inform follow on servers that one or more controls have already been
+ * -- processed
+ *
+ * id-cmc-controlProcessed OBJECT IDENTIFIER ::= {id-cmc 32}
+ *
+ * ControlsProcessed ::= SEQUENCE {
+ *     bodyList              SEQUENCE SIZE(1..MAX) OF BodyPartReference
+ * }
+ * </pre>
+ */
+public class ControlsProcessed
+    extends ASN1Object
+{
+    private final ASN1Sequence bodyPartReferences;
+
+    /**
+     * Construct a ControlsProcessed object containing one BodyPartReference.
+     *
+     * @param bodyPartRef the BodyPartReference to be contained.
+     */
+    public ControlsProcessed(
+        BodyPartReference bodyPartRef)
+    {
+        this.bodyPartReferences = new DERSequence(bodyPartRef);
+    }
+
+
+    public ControlsProcessed(
+        BodyPartReference[] bodyList)
+    {
+        this.bodyPartReferences = new DERSequence(bodyList);
+    }
+
+
+    public static ControlsProcessed getInstance(Object src)
+    {
+        if (src instanceof ControlsProcessed)
+        {
+            return (ControlsProcessed)src;
+        }
+        else if (src != null)
+        {
+            return new ControlsProcessed(ASN1Sequence.getInstance(src));
+        }
+
+        return null;
+    }
+
+    private ControlsProcessed(
+        ASN1Sequence seq)
+    {
+        if (seq.size() != 1)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartReferences = ASN1Sequence.getInstance(seq.getObjectAt(0));
+    }
+
+    public BodyPartReference[] getBodyList()
+    {
+        BodyPartReference[] tmp = new BodyPartReference[bodyPartReferences.size()];
+
+        for (int i = 0; i != bodyPartReferences.size(); i++)
+        {
+            tmp[i] = BodyPartReference.getInstance(bodyPartReferences.getObjectAt(i));
+        }
+
+        return tmp;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(bodyPartReferences);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/DecryptedPOP.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/DecryptedPOP.java
new file mode 100644
index 0000000..e5de83b
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/DecryptedPOP.java
@@ -0,0 +1,90 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ *      id-cmc-decryptedPOP OBJECT IDENTIFIER ::= {id-cmc 10}
+ *
+ *       DecryptedPOP ::= SEQUENCE {
+ *            bodyPartID      BodyPartID,
+ *            thePOPAlgID     AlgorithmIdentifier,
+ *            thePOP          OCTET STRING
+ *       }
+ * </pre>
+ */
+public class DecryptedPOP
+    extends ASN1Object
+{
+    private final BodyPartID bodyPartID;
+    private final AlgorithmIdentifier thePOPAlgID;
+    private final byte[] thePOP;
+
+    public DecryptedPOP(BodyPartID bodyPartID, AlgorithmIdentifier thePOPAlgID, byte[] thePOP)
+    {
+        this.bodyPartID = bodyPartID;
+        this.thePOPAlgID = thePOPAlgID;
+        this.thePOP = Arrays.clone(thePOP);
+    }
+
+    private DecryptedPOP(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartID = BodyPartID.getInstance(seq.getObjectAt(0));
+        this.thePOPAlgID = AlgorithmIdentifier.getInstance(seq.getObjectAt(1));
+        this.thePOP = Arrays.clone(ASN1OctetString.getInstance(seq.getObjectAt(2)).getOctets());
+    }
+
+
+    public static DecryptedPOP getInstance(Object o)
+    {
+        if (o instanceof DecryptedPOP)
+        {
+            return (DecryptedPOP)o;
+        }
+
+        if (o != null)
+        {
+            return new DecryptedPOP(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public BodyPartID getBodyPartID()
+    {
+        return bodyPartID;
+    }
+
+    public AlgorithmIdentifier getThePOPAlgID()
+    {
+        return thePOPAlgID;
+    }
+
+    public byte[] getThePOP()
+    {
+        return Arrays.clone(thePOP);
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(bodyPartID);
+        v.add(thePOPAlgID);
+        v.add(new DEROctetString(thePOP));
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/EncryptedPOP.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/EncryptedPOP.java
new file mode 100644
index 0000000..cd297f6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/EncryptedPOP.java
@@ -0,0 +1,116 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ *      id-cmc-encryptedPOP OBJECT IDENTIFIER ::= {id-cmc 9}
+ *
+ *      EncryptedPOP ::= SEQUENCE {
+ *              request       TaggedRequest,
+ *              cms             ContentInfo,
+ *              thePOPAlgID     AlgorithmIdentifier,
+ *              witnessAlgID    AlgorithmIdentifier,
+ *              witness         OCTET STRING
+ *      }
+ * </pre>
+ */
+public class EncryptedPOP
+    extends ASN1Object
+{
+    private final TaggedRequest request;
+    private final ContentInfo cms;
+    private final AlgorithmIdentifier thePOPAlgID;
+    private final AlgorithmIdentifier witnessAlgID;
+    private final byte[] witness;
+
+    private EncryptedPOP(ASN1Sequence seq)
+    {
+        if (seq.size() != 5)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.request = TaggedRequest.getInstance(seq.getObjectAt(0));
+        this.cms = ContentInfo.getInstance(seq.getObjectAt(1));
+        this.thePOPAlgID = AlgorithmIdentifier.getInstance(seq.getObjectAt(2));
+        this.witnessAlgID = AlgorithmIdentifier.getInstance(seq.getObjectAt(3));
+        this.witness = Arrays.clone(ASN1OctetString.getInstance(seq.getObjectAt(4)).getOctets());
+    }
+
+    public EncryptedPOP(
+        TaggedRequest request,
+        ContentInfo cms,
+        AlgorithmIdentifier thePOPAlgID,
+        AlgorithmIdentifier witnessAlgID,
+        byte[] witness)
+    {
+        this.request = request;
+        this.cms = cms;
+        this.thePOPAlgID = thePOPAlgID;
+        this.witnessAlgID = witnessAlgID;
+        this.witness = Arrays.clone(witness);
+    }
+
+    public static EncryptedPOP getInstance(Object o)
+    {
+        if (o instanceof EncryptedPOP)
+        {
+            return (EncryptedPOP)o;
+        }
+
+        if (o != null)
+        {
+            return new EncryptedPOP(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+
+    public TaggedRequest getRequest()
+    {
+        return request;
+    }
+
+    public ContentInfo getCms()
+    {
+        return cms;
+    }
+
+    public AlgorithmIdentifier getThePOPAlgID()
+    {
+        return thePOPAlgID;
+    }
+
+    public AlgorithmIdentifier getWitnessAlgID()
+    {
+        return witnessAlgID;
+    }
+
+    public byte[] getWitness()
+    {
+        return Arrays.clone(witness);
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(request);
+        v.add(cms);
+        v.add(thePOPAlgID);
+        v.add(witnessAlgID);
+        v.add(new DEROctetString(witness));
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ExtendedFailInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ExtendedFailInfo.java
new file mode 100644
index 0000000..2ec15fe
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ExtendedFailInfo.java
@@ -0,0 +1,79 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * ExtendedFailInfo ::= SEQUENCE {
+ * failInfoOID            OBJECT IDENTIFIER,
+ * failInfoValue          ANY DEFINED BY failInfoOID
+ * }
+ */
+public class ExtendedFailInfo
+    extends ASN1Object
+{
+
+    private final ASN1ObjectIdentifier failInfoOID;
+    private final ASN1Encodable failInfoValue;
+
+    public ExtendedFailInfo(ASN1ObjectIdentifier failInfoOID, ASN1Encodable failInfoValue)
+    {
+        this.failInfoOID = failInfoOID;
+        this.failInfoValue = failInfoValue;
+    }
+
+    private ExtendedFailInfo(ASN1Sequence s)
+    {
+        if (s.size() != 2)
+        {
+            throw new IllegalArgumentException("Sequence must be 2 elements.");
+        }
+
+        failInfoOID = ASN1ObjectIdentifier.getInstance(s.getObjectAt(0));
+        failInfoValue = s.getObjectAt(1);
+    }
+
+    public static ExtendedFailInfo getInstance(Object obj)
+    {
+        if (obj instanceof ExtendedFailInfo)
+        {
+            return (ExtendedFailInfo)obj;
+        }
+
+        if (obj instanceof ASN1Encodable)
+        {
+            ASN1Encodable asn1Value = ((ASN1Encodable)obj).toASN1Primitive();
+            if (asn1Value instanceof ASN1Sequence)
+            {
+                return new ExtendedFailInfo(
+                    (ASN1Sequence)asn1Value
+                );
+            }
+        }
+        else if (obj instanceof byte[])
+        {
+            return getInstance(ASN1Sequence.getInstance(obj));
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(new ASN1Encodable[]{failInfoOID, failInfoValue});
+    }
+
+    public ASN1ObjectIdentifier getFailInfoOID()
+    {
+        return failInfoOID;
+    }
+
+    public ASN1Encodable getFailInfoValue()
+    {
+        return failInfoValue;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ExtensionReq.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ExtensionReq.java
new file mode 100644
index 0000000..9623ce7
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ExtensionReq.java
@@ -0,0 +1,83 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x509.Extension;
+
+/**
+ * <pre>
+ *   ExtensionReq ::= SEQUENCE SIZE (1..MAX) OF Extension
+ * </pre>
+ */
+public class ExtensionReq
+    extends ASN1Object
+{
+    private final Extension[] extensions;
+
+    public static ExtensionReq getInstance(
+        Object obj)
+    {
+        if (obj instanceof ExtensionReq)
+        {
+            return (ExtensionReq)obj;
+        }
+
+        if (obj != null)
+        {
+            return new ExtensionReq(ASN1Sequence.getInstance(obj));
+        }
+
+        return null;
+    }
+
+    public static ExtensionReq getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    /**
+     * Construct a ExtensionReq object containing one Extension.
+     *
+     * @param Extension the Extension to be contained.
+     */
+    public ExtensionReq(
+        Extension Extension)
+    {
+        this.extensions = new Extension[]{Extension};
+    }
+
+
+    public ExtensionReq(
+        Extension[] extensions)
+    {
+        this.extensions = Utils.clone(extensions);
+    }
+
+    private ExtensionReq(
+        ASN1Sequence seq)
+    {
+        this.extensions = new Extension[seq.size()];
+
+        for (int i = 0; i != seq.size(); i++)
+        {
+            extensions[i] = Extension.getInstance(seq.getObjectAt(i));
+        }
+    }
+
+    public Extension[] getExtensions()
+    {
+        return Utils.clone(extensions);
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(extensions);
+    }
+
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/GetCRL.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/GetCRL.java
new file mode 100644
index 0000000..5087af8
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/GetCRL.java
@@ -0,0 +1,121 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERBitString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.asn1.x509.ReasonFlags;
+
+/**
+ * <pre>
+ * id-cmc-getCRL OBJECT IDENTIFIER ::= {id-cmc 16}
+ *
+ * GetCRL ::= SEQUENCE {
+ *    issuerName    Name,
+ *    cRLName       GeneralName OPTIONAL,
+ *    time          GeneralizedTime OPTIONAL,
+ *    reasons       ReasonFlags OPTIONAL }
+ * </pre>
+ */
+public class GetCRL
+    extends ASN1Object
+{
+    private final X500Name issuerName;
+    private GeneralName cRLName;
+    private ASN1GeneralizedTime time;
+    private ReasonFlags reasons;
+
+    public GetCRL(X500Name issuerName, GeneralName cRLName, ASN1GeneralizedTime time, ReasonFlags reasons)
+    {
+        this.issuerName = issuerName;
+        this.cRLName = cRLName;
+        this.time = time;
+        this.reasons = reasons;
+    }
+
+
+    private GetCRL(ASN1Sequence seq)
+    {
+        if (seq.size() < 1 || seq.size() > 4)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.issuerName = X500Name.getInstance(seq.getObjectAt(0));
+
+        int index = 1;
+        if (seq.size() > index && seq.getObjectAt(index).toASN1Primitive() instanceof ASN1TaggedObject)
+        {
+            this.cRLName = GeneralName.getInstance(seq.getObjectAt(index++));
+        }
+        if (seq.size() > index && seq.getObjectAt(index).toASN1Primitive() instanceof ASN1GeneralizedTime)
+        {
+            this.time = ASN1GeneralizedTime.getInstance(seq.getObjectAt(index++));
+        }
+        if (seq.size() > index && seq.getObjectAt(index).toASN1Primitive() instanceof DERBitString)
+        {
+            this.reasons = new ReasonFlags(DERBitString.getInstance(seq.getObjectAt(index)));
+        }
+    }
+
+    public static GetCRL getInstance(Object o)
+    {
+        if (o instanceof GetCRL)
+        {
+            return (GetCRL)o;
+        }
+
+        if (o != null)
+        {
+            return new GetCRL(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public X500Name getIssuerName()
+    {
+        return issuerName;
+    }
+
+    public GeneralName getcRLName()
+    {
+        return cRLName;
+    }
+
+    public ASN1GeneralizedTime getTime()
+    {
+        return time;
+    }
+
+    public ReasonFlags getReasons()
+    {
+        return reasons;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(issuerName);
+        if (cRLName != null)
+        {
+            v.add(cRLName);
+        }
+        if (time != null)
+        {
+            v.add(time);
+        }
+        if (reasons != null)
+        {
+            v.add(reasons);
+        }
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/GetCert.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/GetCert.java
new file mode 100644
index 0000000..8522616
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/GetCert.java
@@ -0,0 +1,77 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x509.GeneralName;
+
+/**
+ * <pre>
+ *      id-cmc-getCert OBJECT IDENTIFIER ::= {id-cmc 15}
+ *
+ *      GetCert ::= SEQUENCE {
+ *           issuerName      GeneralName,
+ *           serialNumber    INTEGER }
+ * </pre>
+ */
+public class GetCert extends ASN1Object
+{
+    private final GeneralName issuerName;
+    private final BigInteger serialNumber;
+
+    private GetCert(ASN1Sequence seq)
+    {
+        if (seq.size() != 2)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.issuerName = GeneralName.getInstance(seq.getObjectAt(0));
+        this.serialNumber = ASN1Integer.getInstance(seq.getObjectAt(1)).getValue();
+    }
+
+    public GetCert(GeneralName issuerName, BigInteger serialNumber)
+    {
+        this.issuerName = issuerName;
+        this.serialNumber = serialNumber;
+    }
+
+    public static GetCert getInstance(Object o)
+    {
+        if (o instanceof GetCert)
+        {
+            return (GetCert)o;
+        }
+
+        if (o != null)
+        {
+            return new GetCert(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public GeneralName getIssuerName()
+    {
+        return issuerName;
+    }
+
+    public BigInteger getSerialNumber()
+    {
+        return serialNumber;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(issuerName);
+        v.add(new ASN1Integer(serialNumber));
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/IdentityProofV2.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/IdentityProofV2.java
new file mode 100644
index 0000000..3451629
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/IdentityProofV2.java
@@ -0,0 +1,88 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ *      id-cmc-identityProofV2 OBJECT IDENTIFIER ::= { id-cmc 34 }
+ *      identityProofV2 ::= SEQUENCE {
+ *          proofAlgID       AlgorithmIdentifier,
+ *          macAlgId         AlgorithmIdentifier,
+ *          witness          OCTET STRING
+ *      }
+ * </pre>
+ */
+public class IdentityProofV2
+    extends ASN1Object
+{
+    private final AlgorithmIdentifier proofAlgID;
+    private final AlgorithmIdentifier macAlgId;
+    private final byte[] witness;
+    
+    public IdentityProofV2(AlgorithmIdentifier proofAlgID, AlgorithmIdentifier macAlgId, byte[] witness)
+    {
+        this.proofAlgID = proofAlgID;
+        this.macAlgId = macAlgId;
+        this.witness = Arrays.clone(witness);
+    }
+        
+    private IdentityProofV2(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.proofAlgID = AlgorithmIdentifier.getInstance(seq.getObjectAt(0));
+        this.macAlgId = AlgorithmIdentifier.getInstance(seq.getObjectAt(1));
+        this.witness = Arrays.clone(ASN1OctetString.getInstance(seq.getObjectAt(2)).getOctets());
+    }
+
+    public static IdentityProofV2 getInstance(Object o)
+    {
+        if (o instanceof IdentityProofV2)
+        {
+            return (IdentityProofV2)o;
+        }
+
+        if (o != null)
+        {
+            return new IdentityProofV2(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+    
+    public AlgorithmIdentifier getProofAlgID()
+    {
+        return proofAlgID;
+    }
+
+    public AlgorithmIdentifier getMacAlgId()
+    {
+        return macAlgId;
+    }
+
+    public byte[] getWitness()
+    {
+        return Arrays.clone(witness);
+    }
+    
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+        
+        v.add(proofAlgID);
+        v.add(macAlgId);
+        v.add(new DEROctetString(getWitness()));
+        
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/LraPopWitness.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/LraPopWitness.java
new file mode 100644
index 0000000..8119ba7
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/LraPopWitness.java
@@ -0,0 +1,83 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ * id-cmc-lraPOPWitness OBJECT IDENTIFIER ::= {id-cmc 11}
+ *
+ * LraPopWitness ::= SEQUENCE {
+ *     pkiDataBodyid   BodyPartID,
+ *     bodyIds         SEQUENCE OF BodyPartID
+ * }
+ * </pre>
+ */
+public class LraPopWitness
+    extends ASN1Object
+{
+    private final BodyPartID pkiDataBodyid;
+    private final ASN1Sequence bodyIds;
+
+    public LraPopWitness(BodyPartID pkiDataBodyid, ASN1Sequence bodyIds)
+    {
+        this.pkiDataBodyid = pkiDataBodyid;
+        this.bodyIds = bodyIds;
+    }
+
+    private LraPopWitness(ASN1Sequence seq)
+    {
+        if (seq.size() != 2)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.pkiDataBodyid = BodyPartID.getInstance(seq.getObjectAt(0));
+        this.bodyIds = ASN1Sequence.getInstance(seq.getObjectAt(1));
+    }
+
+    public static LraPopWitness getInstance(Object o)
+    {
+        if (o instanceof LraPopWitness)
+        {
+            return (LraPopWitness)o;
+        }
+
+        if (o != null)
+        {
+            return new LraPopWitness(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public BodyPartID getPkiDataBodyid()
+    {
+        return pkiDataBodyid;
+    }
+
+
+    public BodyPartID[] getBodyIds()
+    {
+        BodyPartID[] rv = new BodyPartID[bodyIds.size()];
+
+        for (int i = 0; i != bodyIds.size(); i++)
+        {
+            rv[i] = BodyPartID.getInstance(bodyIds.getObjectAt(i));
+        }
+
+        return rv;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(pkiDataBodyid);
+        v.add(bodyIds);
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ModCertTemplate.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ModCertTemplate.java
new file mode 100644
index 0000000..a3e4de2
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/ModCertTemplate.java
@@ -0,0 +1,109 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Boolean;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.crmf.CertTemplate;
+
+/**
+ * <pre>
+ * id-cmc-modCertTemplate OBJECT IDENTIFIER ::= {id-cmc 31}
+ *
+ * ModCertTemplate ::= SEQUENCE {
+ *    pkiDataReference             BodyPartPath,
+ *    certReferences               BodyPartList,
+ *    replace                      BOOLEAN DEFAULT TRUE,
+ *    certTemplate                 CertTemplate
+ * }
+ * </pre>
+ */
+public class ModCertTemplate
+    extends ASN1Object
+{
+    private final BodyPartPath pkiDataReference;
+    private final BodyPartList certReferences;
+    private final boolean replace;
+    private final CertTemplate certTemplate;
+
+    public ModCertTemplate(BodyPartPath pkiDataReference, BodyPartList certReferences, boolean replace, CertTemplate certTemplate)
+    {
+        this.pkiDataReference = pkiDataReference;
+        this.certReferences = certReferences;
+        this.replace = replace;
+        this.certTemplate = certTemplate;
+    }
+
+    private ModCertTemplate(ASN1Sequence seq)
+    {
+        if (seq.size() != 4 && seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.pkiDataReference = BodyPartPath.getInstance(seq.getObjectAt(0));
+        this.certReferences = BodyPartList.getInstance(seq.getObjectAt(1));
+
+        if (seq.size() == 4)
+        {
+            this.replace = ASN1Boolean.getInstance(seq.getObjectAt(2)).isTrue();
+            this.certTemplate = CertTemplate.getInstance(seq.getObjectAt(3));
+        }
+        else
+        {
+            this.replace = true;
+            this.certTemplate = CertTemplate.getInstance(seq.getObjectAt(2));
+        }
+    }
+
+    public static ModCertTemplate getInstance(Object o)
+    {
+        if (o instanceof ModCertTemplate)
+        {
+            return (ModCertTemplate)o;
+        }
+
+        if (o != null)
+        {
+            return new ModCertTemplate(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public BodyPartPath getPkiDataReference()
+    {
+        return pkiDataReference;
+    }
+
+    public BodyPartList getCertReferences()
+    {
+        return certReferences;
+    }
+
+    public boolean isReplacingFields()
+    {
+        return replace;
+    }
+
+    public CertTemplate getCertTemplate()
+    {
+        return certTemplate;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(pkiDataReference);
+        v.add(certReferences);
+        if (!replace)
+        {
+            v.add(ASN1Boolean.getInstance(replace));
+        }
+        v.add(certTemplate);
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/OtherMsg.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/OtherMsg.java
new file mode 100644
index 0000000..8402f57
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/OtherMsg.java
@@ -0,0 +1,92 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ * OtherMsg ::= SEQUENCE {
+ *     bodyPartID        BodyPartID,
+ *     otherMsgType      OBJECT IDENTIFIER,
+ *     otherMsgValue     ANY DEFINED BY otherMsgType }
+ * </pre>
+ */
+public class OtherMsg
+    extends ASN1Object
+{
+    private final BodyPartID bodyPartID;
+    private final ASN1ObjectIdentifier otherMsgType;
+    private final ASN1Encodable otherMsgValue;
+
+    public OtherMsg(BodyPartID bodyPartID, ASN1ObjectIdentifier otherMsgType, ASN1Encodable otherMsgValue)
+    {
+        this.bodyPartID = bodyPartID;
+        this.otherMsgType = otherMsgType;
+        this.otherMsgValue = otherMsgValue;
+    }
+
+    private OtherMsg(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartID = BodyPartID.getInstance(seq.getObjectAt(0));
+        this.otherMsgType = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(1));
+        this.otherMsgValue = seq.getObjectAt(2);
+    }
+
+    public static OtherMsg getInstance(Object o)
+    {
+        if (o instanceof OtherMsg)
+        {
+            return (OtherMsg)o;
+        }
+
+        if (o != null)
+        {
+            return new OtherMsg(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public static OtherMsg getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(bodyPartID);
+        v.add(otherMsgType);
+        v.add(otherMsgValue);
+
+        return new DERSequence(v);
+    }
+
+    public BodyPartID getBodyPartID()
+    {
+        return bodyPartID;
+    }
+
+    public ASN1ObjectIdentifier getOtherMsgType()
+    {
+        return otherMsgType;
+    }
+
+    public ASN1Encodable getOtherMsgValue()
+    {
+        return otherMsgValue;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/OtherStatusInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/OtherStatusInfo.java
new file mode 100644
index 0000000..46ef16a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/OtherStatusInfo.java
@@ -0,0 +1,119 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.io.IOException;
+
+import org.bouncycastle.asn1.ASN1Choice;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+
+/**
+ * Other info implements the choice component of CMCStatusInfoV2.
+ * <p>
+ * OtherStatusInfo ::= CHOICE {
+ * failInfo              CMCFailInfo,
+ * pendInfo              PendInfo,
+ * extendedFailInfo      ExtendedFailInfo
+ * }
+ */
+public class OtherStatusInfo
+    extends ASN1Object
+    implements ASN1Choice
+{
+    private final CMCFailInfo failInfo;
+    private final PendInfo pendInfo;
+    private final ExtendedFailInfo extendedFailInfo;
+
+    public static OtherStatusInfo getInstance(Object obj)
+    {
+        if (obj instanceof OtherStatusInfo)
+        {
+            return (OtherStatusInfo)obj;
+        }
+
+        if (obj instanceof ASN1Encodable)
+        {
+            ASN1Encodable asn1Value = ((ASN1Encodable)obj).toASN1Primitive();
+
+            if (asn1Value instanceof ASN1Integer) // CMCFail info is an asn1 integer.
+            {
+                return new OtherStatusInfo(CMCFailInfo.getInstance(asn1Value));
+            }
+            else if (asn1Value instanceof ASN1Sequence) // PendInfo is a sequence.
+            {
+                if (((ASN1Sequence)asn1Value).getObjectAt(0) instanceof ASN1ObjectIdentifier)
+                {
+                    return new OtherStatusInfo(ExtendedFailInfo.getInstance(asn1Value));
+                }
+                return new OtherStatusInfo(PendInfo.getInstance(asn1Value));
+            }
+        }
+        else if (obj instanceof byte[])
+        {
+            try
+            {
+                return getInstance(ASN1Primitive.fromByteArray((byte[])obj));
+            }
+            catch (IOException e)
+            {
+                throw new IllegalArgumentException("parsing error: " + e.getMessage());
+            }
+        }                          
+        throw new IllegalArgumentException("unknown object in getInstance(): " + obj.getClass().getName());
+    }
+
+    OtherStatusInfo(CMCFailInfo failInfo)
+    {
+        this(failInfo, null, null);
+    }
+
+    OtherStatusInfo(PendInfo pendInfo)
+    {
+        this(null, pendInfo, null);
+    }
+
+    OtherStatusInfo(ExtendedFailInfo extendedFailInfo)
+    {
+        this(null, null, extendedFailInfo);
+    }
+
+    private OtherStatusInfo(CMCFailInfo failInfo, PendInfo pendInfo, ExtendedFailInfo extendedFailInfo)
+    {
+        this.failInfo = failInfo;
+        this.pendInfo = pendInfo;
+        this.extendedFailInfo = extendedFailInfo;
+    }
+
+    public boolean isPendingInfo()
+    {
+        return pendInfo != null;
+    }
+
+    public boolean isFailInfo()
+    {
+        return failInfo != null;
+    }
+
+
+    public boolean isExtendedFailInfo()
+    {
+        return extendedFailInfo != null;
+    }
+
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        if (pendInfo != null)
+        {
+            return pendInfo.toASN1Primitive();
+        }
+        else if (failInfo != null)
+        {
+            return failInfo.toASN1Primitive();
+        }
+        return extendedFailInfo.toASN1Primitive();
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PKIData.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PKIData.java
new file mode 100644
index 0000000..cd75ace
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PKIData.java
@@ -0,0 +1,119 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ * PKIData ::= SEQUENCE {
+ * controlSequence    SEQUENCE SIZE(0..MAX) OF TaggedAttribute,
+ * reqSequence        SEQUENCE SIZE(0..MAX) OF TaggedRequest,
+ * cmsSequence        SEQUENCE SIZE(0..MAX) OF TaggedContentInfo,
+ * otherMsgSequence   SEQUENCE SIZE(0..MAX) OF OtherMsg
+ * }
+ * </pre>
+ */
+public class PKIData
+    extends ASN1Object
+{
+    private final TaggedAttribute[] controlSequence;
+    private final TaggedRequest[] reqSequence;
+    private final TaggedContentInfo[] cmsSequence;
+    private final OtherMsg[] otherMsgSequence;
+
+
+    public PKIData(
+        TaggedAttribute[] controlSequence,
+        TaggedRequest[] reqSequence,
+        TaggedContentInfo[] cmsSequence,
+        OtherMsg[] otherMsgSequence)
+    {
+        this.controlSequence = controlSequence;
+        this.reqSequence = reqSequence;
+        this.cmsSequence = cmsSequence;
+        this.otherMsgSequence = otherMsgSequence;
+    }
+
+    private PKIData(ASN1Sequence seq)
+    {
+        if (seq.size() != 4)
+        {
+            throw new IllegalArgumentException("Sequence not 4 elements.");
+        }
+
+        ASN1Sequence s = ((ASN1Sequence)seq.getObjectAt(0));
+        controlSequence = new TaggedAttribute[s.size()];
+        for (int t = 0; t < controlSequence.length; t++)
+        {
+            controlSequence[t] = TaggedAttribute.getInstance(s.getObjectAt(t));
+        }
+
+        s = ((ASN1Sequence)seq.getObjectAt(1));
+        reqSequence = new TaggedRequest[s.size()];
+        for (int t = 0; t < reqSequence.length; t++)
+        {
+            reqSequence[t] = TaggedRequest.getInstance(s.getObjectAt(t));
+        }
+
+        s = ((ASN1Sequence)seq.getObjectAt(2));
+        cmsSequence = new TaggedContentInfo[s.size()];
+        for (int t = 0; t < cmsSequence.length; t++)
+        {
+            cmsSequence[t] = TaggedContentInfo.getInstance(s.getObjectAt(t));
+        }
+
+        s = ((ASN1Sequence)seq.getObjectAt(3));
+        otherMsgSequence = new OtherMsg[s.size()];
+        for (int t = 0; t < otherMsgSequence.length; t++)
+        {
+            otherMsgSequence[t] = OtherMsg.getInstance(s.getObjectAt(t));
+        }
+    }
+
+    public static PKIData getInstance(Object src)
+    {
+        if (src instanceof PKIData)
+        {
+            return (PKIData)src;
+        }
+        if (src != null)
+        {
+            return new PKIData(ASN1Sequence.getInstance(src));
+        }
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(new ASN1Encodable[]{
+            new DERSequence(controlSequence),
+            new DERSequence(reqSequence),
+            new DERSequence(cmsSequence),
+            new DERSequence(otherMsgSequence)
+        });
+
+    }
+
+    public TaggedAttribute[] getControlSequence()
+    {
+        return controlSequence;
+    }
+
+    public TaggedRequest[] getReqSequence()
+    {
+        return reqSequence;
+    }
+
+    public TaggedContentInfo[] getCmsSequence()
+    {
+        return cmsSequence;
+    }
+
+    public OtherMsg[] getOtherMsgSequence()
+    {
+        return otherMsgSequence;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PKIResponse.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PKIResponse.java
new file mode 100644
index 0000000..c975d3e
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PKIResponse.java
@@ -0,0 +1,90 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ *    --  This defines the response message in the protocol
+ *  id-cct-PKIResponse OBJECT IDENTIFIER ::= { id-cct 3 }
+ *
+ * ResponseBody ::= PKIResponse
+ *
+ * PKIResponse ::= SEQUENCE {
+ *     controlSequence   SEQUENCE SIZE(0..MAX) OF TaggedAttribute,
+ *     cmsSequence       SEQUENCE SIZE(0..MAX) OF TaggedContentInfo,
+ *     otherMsgSequence  SEQUENCE SIZE(0..MAX) OF OtherMsg
+ * }
+ * </pre>
+ */
+public class PKIResponse
+    extends ASN1Object
+{
+    private final ASN1Sequence controlSequence;
+    private final ASN1Sequence cmsSequence;
+    private final ASN1Sequence otherMsgSequence;
+
+    private PKIResponse(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.controlSequence = ASN1Sequence.getInstance(seq.getObjectAt(0));
+        this.cmsSequence = ASN1Sequence.getInstance(seq.getObjectAt(1));
+        this.otherMsgSequence = ASN1Sequence.getInstance(seq.getObjectAt(2));
+    }
+
+
+    public static PKIResponse getInstance(Object o)
+    {
+        if (o instanceof PKIResponse)
+        {
+            return (PKIResponse)o;
+        }
+
+        if (o != null)
+        {
+            return new PKIResponse(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public static PKIResponse getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(controlSequence);
+        v.add(cmsSequence);
+        v.add(otherMsgSequence);
+
+        return new DERSequence(v);
+    }
+
+    public ASN1Sequence getControlSequence()
+    {
+        return controlSequence;
+    }
+
+    public ASN1Sequence getCmsSequence()
+    {
+        return cmsSequence;
+    }
+
+    public ASN1Sequence getOtherMsgSequence()
+    {
+        return otherMsgSequence;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PendInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PendInfo.java
new file mode 100644
index 0000000..2d65efb
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PendInfo.java
@@ -0,0 +1,77 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ * PendInfo ::= SEQUENCE {
+ *    pendToken        OCTET STRING,
+ *    pendTime         GeneralizedTime
+ * }
+ * </pre>
+ */
+public class PendInfo
+    extends ASN1Object
+{
+    private final byte[] pendToken;
+    private final ASN1GeneralizedTime pendTime;
+
+    public PendInfo(byte[] pendToken, ASN1GeneralizedTime pendTime)
+    {
+        this.pendToken = Arrays.clone(pendToken);
+        this.pendTime = pendTime;
+    }
+
+    private PendInfo(ASN1Sequence seq)
+    {
+        if (seq.size() != 2)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.pendToken = Arrays.clone(ASN1OctetString.getInstance(seq.getObjectAt(0)).getOctets());
+        this.pendTime = ASN1GeneralizedTime.getInstance(seq.getObjectAt(1));
+    }
+
+    public static PendInfo getInstance(Object o)
+    {
+        if (o instanceof PendInfo)
+        {
+            return (PendInfo)o;
+        }
+
+        if (o != null)
+        {
+            return new PendInfo(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(new DEROctetString(pendToken));
+        v.add(pendTime);
+
+        return new DERSequence(v);
+    }
+
+    public byte[] getPendToken()
+    {
+        return pendToken;
+    }
+
+    public ASN1GeneralizedTime getPendTime()
+    {
+        return pendTime;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PopLinkWitnessV2.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PopLinkWitnessV2.java
new file mode 100644
index 0000000..4ec2cd1
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PopLinkWitnessV2.java
@@ -0,0 +1,88 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ *      id-cmc-popLinkWitnessV2 OBJECT IDENTIFIER ::= { id-cmc 33 }
+ *      PopLinkWitnessV2 ::= SEQUENCE {
+ *           keyGenAlgorithm   AlgorithmIdentifier,
+ *           macAlgorithm      AlgorithmIdentifier,
+ *           witness           OCTET STRING
+ *      }
+ * </pre>
+ */
+public class PopLinkWitnessV2
+    extends ASN1Object
+{
+    private final AlgorithmIdentifier keyGenAlgorithm;
+    private final AlgorithmIdentifier macAlgorithm;
+    private final byte[] witness;
+
+    public PopLinkWitnessV2(AlgorithmIdentifier keyGenAlgorithm, AlgorithmIdentifier macAlgorithm, byte[] witness)
+    {
+        this.keyGenAlgorithm = keyGenAlgorithm;
+        this.macAlgorithm = macAlgorithm;
+        this.witness = Arrays.clone(witness);
+    }
+
+    private PopLinkWitnessV2(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.keyGenAlgorithm = AlgorithmIdentifier.getInstance(seq.getObjectAt(0));
+        this.macAlgorithm = AlgorithmIdentifier.getInstance(seq.getObjectAt(1));
+        this.witness = Arrays.clone(ASN1OctetString.getInstance(seq.getObjectAt(2)).getOctets());
+    }
+
+    public static PopLinkWitnessV2 getInstance(Object o)
+    {
+        if (o instanceof PopLinkWitnessV2)
+        {
+            return (PopLinkWitnessV2)o;
+        }
+
+        if (o != null)
+        {
+            return new PopLinkWitnessV2(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public AlgorithmIdentifier getKeyGenAlgorithm()
+    {
+        return keyGenAlgorithm;
+    }
+
+    public AlgorithmIdentifier getMacAlgorithm()
+    {
+        return macAlgorithm;
+    }
+
+    public byte[] getWitness()
+    {
+        return Arrays.clone(witness);
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(keyGenAlgorithm);
+        v.add(macAlgorithm);
+        v.add(new DEROctetString(getWitness()));
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PublishTrustAnchors.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PublishTrustAnchors.java
new file mode 100644
index 0000000..1c91110
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/PublishTrustAnchors.java
@@ -0,0 +1,104 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ *
+ * PublishTrustAnchors ::= SEQUENCE {
+ *     seqNumber      INTEGER,
+ *     hashAlgorithm  AlgorithmIdentifier,
+ *     anchorHashes     SEQUENCE OF OCTET STRING
+ * }
+ * </pre>
+ */
+public class PublishTrustAnchors
+    extends ASN1Object
+{
+    private final ASN1Integer seqNumber;
+    private final AlgorithmIdentifier hashAlgorithm;
+    private final ASN1Sequence anchorHashes;
+
+    public PublishTrustAnchors(BigInteger seqNumber, AlgorithmIdentifier hashAlgorithm, byte[][] anchorHashes)
+    {
+        this.seqNumber = new ASN1Integer(seqNumber);
+        this.hashAlgorithm = hashAlgorithm;
+
+        ASN1EncodableVector v = new ASN1EncodableVector();
+        for (int i = 0; i != anchorHashes.length; i++)
+        {
+             v.add(new DEROctetString(Arrays.clone(anchorHashes[i])));
+        }
+        this.anchorHashes = new DERSequence(v);
+    }
+
+    private PublishTrustAnchors(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.seqNumber = ASN1Integer.getInstance(seq.getObjectAt(0));
+        this.hashAlgorithm = AlgorithmIdentifier.getInstance(seq.getObjectAt(1));
+        this.anchorHashes = ASN1Sequence.getInstance(seq.getObjectAt(2));
+    }
+
+    public static PublishTrustAnchors getInstance(Object o)
+    {
+        if (o instanceof PublishTrustAnchors)
+        {
+            return (PublishTrustAnchors)o;
+        }
+
+        if (o != null)
+        {
+            return new PublishTrustAnchors(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public BigInteger getSeqNumber()
+    {
+        return seqNumber.getValue();
+    }
+
+    public AlgorithmIdentifier getHashAlgorithm()
+    {
+        return hashAlgorithm;
+    }
+
+    public byte[][] getAnchorHashes()
+    {
+        byte[][] hashes = new byte[anchorHashes.size()][];
+
+        for (int i = 0; i != hashes.length; i++)
+        {
+            hashes[i] = Arrays.clone(ASN1OctetString.getInstance(anchorHashes.getObjectAt(i)).getOctets());
+        }
+
+        return hashes;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(seqNumber);
+        v.add(hashAlgorithm);
+        v.add(anchorHashes);
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/RevokeRequest.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/RevokeRequest.java
new file mode 100644
index 0000000..231be26
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/RevokeRequest.java
@@ -0,0 +1,172 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x509.CRLReason;
+import org.bouncycastle.util.Arrays;
+
+/**
+ * <pre>
+ * RevokeRequest ::= SEQUENCE {
+ *     issuerName            Name,
+ *     serialNumber          INTEGER,
+ *     reason                CRLReason,
+ *     invalidityDate         GeneralizedTime OPTIONAL,
+ *     passphrase            OCTET STRING OPTIONAL,
+ *     comment               UTF8String OPTIONAL }
+ * </pre>
+ */
+public class RevokeRequest
+    extends ASN1Object
+{
+    private final X500Name name;
+    private final ASN1Integer serialNumber;
+    private final CRLReason reason;
+
+    private ASN1GeneralizedTime invalidityDate;
+    private ASN1OctetString passphrase;
+    private DERUTF8String comment;
+
+    public RevokeRequest(X500Name name,
+                         ASN1Integer serialNumber,
+                         CRLReason reason,
+                         ASN1GeneralizedTime invalidityDate,
+                         ASN1OctetString passphrase,
+                         DERUTF8String comment)
+    {
+        this.name = name;
+        this.serialNumber = serialNumber;
+        this.reason = reason;
+        this.invalidityDate = invalidityDate;
+        this.passphrase = passphrase;
+        this.comment = comment;
+    }
+
+    private RevokeRequest(ASN1Sequence seq)
+    {
+        if (seq.size() < 3 || seq.size() > 6)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.name = X500Name.getInstance(seq.getObjectAt(0));
+        this.serialNumber = ASN1Integer.getInstance(seq.getObjectAt(1));
+        this.reason = CRLReason.getInstance(seq.getObjectAt(2));
+
+        int index = 3;
+        if (seq.size() > index && seq.getObjectAt(index).toASN1Primitive() instanceof ASN1GeneralizedTime)
+        {
+            this.invalidityDate = ASN1GeneralizedTime.getInstance(seq.getObjectAt(index++));
+        }
+        if (seq.size() > index && seq.getObjectAt(index).toASN1Primitive() instanceof ASN1OctetString)
+        {
+            this.passphrase = ASN1OctetString.getInstance(seq.getObjectAt(index++));
+        }
+        if (seq.size() > index && seq.getObjectAt(index).toASN1Primitive() instanceof DERUTF8String)
+        {
+            this.comment = DERUTF8String.getInstance(seq.getObjectAt(index));
+        }
+    }
+
+    public static RevokeRequest getInstance(Object o)
+    {
+        if (o instanceof RevokeRequest)
+        {
+            return (RevokeRequest)o;
+        }
+
+        if (o != null)
+        {
+            return new RevokeRequest(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public X500Name getName()
+    {
+        return name;
+    }
+
+    public BigInteger getSerialNumber()
+    {
+        return serialNumber.getValue();
+    }
+
+    public CRLReason getReason()
+    {
+        return reason;
+    }
+
+    public ASN1GeneralizedTime getInvalidityDate()
+    {
+        return invalidityDate;
+    }
+
+    public void setInvalidityDate(ASN1GeneralizedTime invalidityDate)
+    {
+        this.invalidityDate = invalidityDate;
+    }
+
+    public ASN1OctetString getPassphrase()
+    {
+        return passphrase;
+    }
+
+    public void setPassphrase(ASN1OctetString passphrase)
+    {
+        this.passphrase = passphrase;
+    }
+
+    public DERUTF8String getComment()
+    {
+        return comment;
+    }
+
+    public void setComment(DERUTF8String comment)
+    {
+        this.comment = comment;
+    }
+
+    public byte[] getPassPhrase()
+    {
+        if (passphrase != null)
+        {
+            return Arrays.clone(passphrase.getOctets());
+        }
+        return null;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(name);
+        v.add(serialNumber);
+        v.add(reason);
+
+        if (invalidityDate != null)
+        {
+            v.add(invalidityDate);
+        }
+        if (passphrase != null)
+        {
+            v.add(passphrase);
+        }
+        if (comment != null)
+        {
+            v.add(comment);
+        }
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedAttribute.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedAttribute.java
new file mode 100644
index 0000000..468f06e
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedAttribute.java
@@ -0,0 +1,81 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1Set;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * TaggedAttribute from RFC5272
+ * <pre>
+ * TaggedAttribute ::= SEQUENCE {
+ * bodyPartID         BodyPartID,
+ * attrType           OBJECT IDENTIFIER,
+ * attrValues         SET OF AttributeValue
+ * }
+ * </pre>
+ */
+public class TaggedAttribute
+    extends ASN1Object
+{
+    private final BodyPartID bodyPartID;
+    private final ASN1ObjectIdentifier attrType;
+    private final ASN1Set attrValues;
+
+    public static TaggedAttribute getInstance(Object o)
+    {
+        if (o instanceof TaggedAttribute)
+        {
+            return (TaggedAttribute)o;
+        }
+
+        if (o != null)
+        {
+            return new TaggedAttribute(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    private TaggedAttribute(ASN1Sequence seq)
+    {
+        if (seq.size() != 3)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartID = BodyPartID.getInstance(seq.getObjectAt(0));
+        this.attrType = ASN1ObjectIdentifier.getInstance(seq.getObjectAt(1));
+        this.attrValues = ASN1Set.getInstance(seq.getObjectAt(2));
+    }
+
+    public TaggedAttribute(BodyPartID bodyPartID, ASN1ObjectIdentifier attrType, ASN1Set attrValues)
+    {
+        this.bodyPartID = bodyPartID;
+        this.attrType = attrType;
+        this.attrValues = attrValues;
+    }
+
+    public BodyPartID getBodyPartID()
+    {
+        return bodyPartID;
+    }
+
+    public ASN1ObjectIdentifier getAttrType()
+    {
+        return attrType;
+    }
+
+    public ASN1Set getAttrValues()
+    {
+        return attrValues;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(new ASN1Encodable[]{bodyPartID, attrType, attrValues});
+    }
+}
+
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedCertificationRequest.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedCertificationRequest.java
new file mode 100644
index 0000000..902b323
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedCertificationRequest.java
@@ -0,0 +1,71 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ *       TaggedCertificationRequest ::= SEQUENCE {
+ *                  bodyPartID            BodyPartID,
+ *                  certificationRequest  CertificationRequest
+ *       }
+ * </pre>
+ */
+public class TaggedCertificationRequest
+    extends ASN1Object
+{
+    private final BodyPartID bodyPartID;
+    private final CertificationRequest certificationRequest;
+
+    public TaggedCertificationRequest(BodyPartID bodyPartID, CertificationRequest certificationRequest)
+    {
+        this.bodyPartID = bodyPartID;
+        this.certificationRequest = certificationRequest;
+    }
+
+    private TaggedCertificationRequest(ASN1Sequence seq)
+    {
+        if (seq.size() != 2)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartID = BodyPartID.getInstance(seq.getObjectAt(0));
+        this.certificationRequest = CertificationRequest.getInstance(seq.getObjectAt(1));
+    }
+
+    public static TaggedCertificationRequest getInstance(Object o)
+    {
+        if (o instanceof TaggedCertificationRequest)
+        {
+            return (TaggedCertificationRequest)o;
+        }
+
+        if (o != null)
+        {
+            return new TaggedCertificationRequest(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public static TaggedCertificationRequest getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(bodyPartID);
+        v.add(certificationRequest);
+
+        return new DERSequence(v);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedContentInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedContentInfo.java
new file mode 100644
index 0000000..ffe39b6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedContentInfo.java
@@ -0,0 +1,82 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cms.ContentInfo;
+
+/**
+ * <pre>
+ * TaggedContentInfo ::= SEQUENCE {
+ *       bodyPartID              BodyPartID,
+ *       contentInfo             ContentInfo
+ * }
+ * </pre>
+ */
+public class TaggedContentInfo
+    extends ASN1Object
+{
+    private final BodyPartID bodyPartID;
+    private final ContentInfo contentInfo;
+
+    public TaggedContentInfo(BodyPartID bodyPartID, ContentInfo contentInfo)
+    {
+        this.bodyPartID = bodyPartID;
+        this.contentInfo = contentInfo;
+    }
+
+    private TaggedContentInfo(ASN1Sequence seq)
+    {
+        if (seq.size() != 2)
+        {
+            throw new IllegalArgumentException("incorrect sequence size");
+        }
+        this.bodyPartID = BodyPartID.getInstance(seq.getObjectAt(0));
+        this.contentInfo = ContentInfo.getInstance(seq.getObjectAt(1));
+    }
+
+    public static TaggedContentInfo getInstance(Object o)
+    {
+        if (o instanceof TaggedContentInfo)
+        {
+            return (TaggedContentInfo)o;
+        }
+
+        if (o != null)
+        {
+            return new TaggedContentInfo(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public static TaggedContentInfo getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        v.add(bodyPartID);
+        v.add(contentInfo);
+
+        return new DERSequence(v);
+    }
+
+    public BodyPartID getBodyPartID()
+    {
+        return bodyPartID;
+    }
+
+    public ContentInfo getContentInfo()
+    {
+        return contentInfo;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedRequest.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedRequest.java
new file mode 100644
index 0000000..4762a42
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/TaggedRequest.java
@@ -0,0 +1,112 @@
+package org.bouncycastle.asn1.cmc;
+
+import java.io.IOException;
+
+import org.bouncycastle.asn1.ASN1Choice;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERTaggedObject;
+import org.bouncycastle.asn1.crmf.CertReqMsg;
+
+/**
+ * <pre>
+ *       TaggedRequest ::= CHOICE {
+ *             tcr               [0] TaggedCertificationRequest,
+ *             crm               [1] CertReqMsg,
+ *             orm               [2] SEQUENCE {
+ *             bodyPartID            BodyPartID,
+ *             requestMessageType    OBJECT IDENTIFIER,
+ *             requestMessageValue   ANY DEFINED BY requestMessageType
+ *      }
+ *  }
+ * </pre>
+ */
+public class TaggedRequest
+    extends ASN1Object
+    implements ASN1Choice
+{
+    public static final int TCR = 0;
+    public static final int CRM = 1;
+    public static final int ORM = 2;
+
+    private final int tagNo;
+    private final ASN1Encodable value;
+
+    public TaggedRequest(TaggedCertificationRequest tcr)
+    {
+        this.tagNo = TCR;
+        this.value = tcr;
+    }
+
+    public TaggedRequest(CertReqMsg crm)
+    {
+        this.tagNo = CRM;
+        this.value = crm;
+    }
+
+    private TaggedRequest(ASN1Sequence orm)
+    {
+        this.tagNo = ORM;
+        this.value = orm;
+    }
+
+    public static TaggedRequest getInstance(Object obj)
+    {
+        if (obj instanceof TaggedRequest)
+        {
+            return (TaggedRequest)obj;
+        }
+
+        if (obj != null)
+        {
+            if (obj instanceof ASN1Encodable)
+            {
+                ASN1TaggedObject asn1Prim = ASN1TaggedObject.getInstance(((ASN1Encodable)obj).toASN1Primitive());
+
+                switch (asn1Prim.getTagNo())
+                {
+                case 0:
+                    return new TaggedRequest(TaggedCertificationRequest.getInstance(asn1Prim, false));
+                case 1:
+                    return new TaggedRequest(CertReqMsg.getInstance(asn1Prim, false));
+                case 2:
+                    return new TaggedRequest(ASN1Sequence.getInstance(asn1Prim, false));
+                default:
+                    throw new IllegalArgumentException("unknown tag in getInstance(): " + asn1Prim.getTagNo());
+                }
+            }
+            if (obj instanceof byte[])
+            {
+                try
+                {
+                    return getInstance(ASN1Primitive.fromByteArray((byte[])obj));
+                }
+                catch (IOException e)
+                {
+                    throw new IllegalArgumentException("unknown encoding in getInstance()");
+                }
+            }
+            throw new IllegalArgumentException("unknown object in getInstance(): " + obj.getClass().getName());
+        }
+
+        return null;
+    }
+
+    public int getTagNo()
+    {
+        return tagNo;
+    }
+
+    public ASN1Encodable getValue()
+    {
+        return value;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERTaggedObject(false, tagNo, value);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/cmc/Utils.java b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/Utils.java
new file mode 100644
index 0000000..3b00d29
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/cmc/Utils.java
@@ -0,0 +1,37 @@
+package org.bouncycastle.asn1.cmc;
+
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.x509.Extension;
+
+class Utils
+{
+    static BodyPartID[] toBodyPartIDArray(ASN1Sequence bodyPartIDs)
+    {
+        BodyPartID[] ids = new BodyPartID[bodyPartIDs.size()];
+
+        for (int i = 0; i != bodyPartIDs.size(); i++)
+        {
+            ids[i] = BodyPartID.getInstance(bodyPartIDs.getObjectAt(i));
+        }
+
+        return ids;
+    }
+
+    static BodyPartID[] clone(BodyPartID[] ids)
+    {
+        BodyPartID[] tmp = new BodyPartID[ids.length];
+
+        System.arraycopy(ids, 0, tmp, 0, ids.length);
+
+        return tmp;
+    }
+
+    static Extension[] clone(Extension[] ids)
+    {
+        Extension[] tmp = new Extension[ids.length];
+
+        System.arraycopy(ids, 0, tmp, 0, ids.length);
+
+        return tmp;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/crmf/CertReqMsg.java b/bcprov/src/main/java/org/bouncycastle/asn1/crmf/CertReqMsg.java
index 3893663..1ea22eb 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/crmf/CertReqMsg.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/crmf/CertReqMsg.java
@@ -51,6 +51,13 @@
         return null;
     }
 
+    public static CertReqMsg getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
     /**
      * Creates a new CertReqMsg.
      * @param certReq CertRequest
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/eac/CVCertificateRequest.java b/bcprov/src/main/java/org/bouncycastle/asn1/eac/CVCertificateRequest.java
index c07deba..699d482 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/eac/CVCertificateRequest.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/eac/CVCertificateRequest.java
@@ -17,6 +17,8 @@
 public class CVCertificateRequest
     extends ASN1Object
 {
+    private final ASN1ApplicationSpecific original;
+
     private CertificateBody certificateBody;
 
     private byte[] innerSignature = null;
@@ -28,7 +30,9 @@
     private CVCertificateRequest(ASN1ApplicationSpecific request)
         throws IOException
     {
-        if (request.getApplicationTag() == EACTags.AUTHENTIFICATION_DATA)
+        this.original = request;
+
+        if (request.isConstructed() && request.getApplicationTag() == EACTags.AUTHENTIFICATION_DATA)
         {
             ASN1Sequence seq = ASN1Sequence.getInstance(request.getObject(BERTags.SEQUENCE));
 
@@ -134,19 +138,26 @@
 
     public ASN1Primitive toASN1Primitive()
     {
-        ASN1EncodableVector v = new ASN1EncodableVector();
-
-        v.add(certificateBody);
-
-        try
+        if (original != null)
         {
-            v.add(new DERApplicationSpecific(false, EACTags.STATIC_INTERNAL_AUTHENTIFICATION_ONE_STEP, new DEROctetString(innerSignature)));
+            return original;
         }
-        catch (IOException e)
+        else
         {
-            throw new IllegalStateException("unable to convert signature!");
-        }
+            ASN1EncodableVector v = new ASN1EncodableVector();
 
-        return new DERApplicationSpecific(EACTags.CARDHOLDER_CERTIFICATE, v);
+            v.add(certificateBody);
+
+            try
+            {
+                v.add(new DERApplicationSpecific(false, EACTags.STATIC_INTERNAL_AUTHENTIFICATION_ONE_STEP, new DEROctetString(innerSignature)));
+            }
+            catch (IOException e)
+            {
+                throw new IllegalStateException("unable to convert signature!");
+            }
+
+            return new DERApplicationSpecific(EACTags.CARDHOLDER_CERTIFICATE, v);
+        }
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/eac/CertificateHolderAuthorization.java b/bcprov/src/main/java/org/bouncycastle/asn1/eac/CertificateHolderAuthorization.java
index 1f1831e..e4b7d57 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/eac/CertificateHolderAuthorization.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/eac/CertificateHolderAuthorization.java
@@ -147,8 +147,7 @@
     {
         byte[] accessRights = new byte[1];
         accessRights[0] = rights;
-        this.accessRights = new DERApplicationSpecific(
-            EACTags.getTag(EACTags.DISCRETIONARY_DATA), accessRights);
+        this.accessRights = new DERApplicationSpecific(EACTags.DISCRETIONARY_DATA, accessRights);
     }
 
     /**
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/eac/EACTags.java b/bcprov/src/main/java/org/bouncycastle/asn1/eac/EACTags.java
index dfe246e..c536193 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/eac/EACTags.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/eac/EACTags.java
@@ -5,115 +5,114 @@
 
 public class EACTags
 {
-    public static final int OBJECT_IDENTIFIER = 0x06;
-    public static final int COUNTRY_CODE_NATIONAL_DATA = 0x41;
+    public static final int COUNTRY_CODE_NATIONAL_DATA = 0x01;
     public static final int ISSUER_IDENTIFICATION_NUMBER = 0x02; //0x42;
-    public static final int CARD_SERVICE_DATA = 0x43;
-    public static final int INITIAL_ACCESS_DATA = 0x44;
-    public static final int CARD_ISSUER_DATA = 0x45;
-    public static final int PRE_ISSUING_DATA = 0x46;
-    public static final int CARD_CAPABILITIES = 0x47;
-    public static final int STATUS_INFORMATION = 0x48;
-    public static final int EXTENDED_HEADER_LIST = 0x4D;
-    public static final int APPLICATION_IDENTIFIER = 0x4F;
-    public static final int APPLICATION_LABEL = 0x50;
-    public static final int FILE_REFERENCE = 0x51;
-    public static final int COMMAND_TO_PERFORM = 0x52;
-    public static final int DISCRETIONARY_DATA = 0x53;
-    public static final int OFFSET_DATA_OBJECT = 0x54;
-    public static final int TRACK1_APPLICATION = 0x56;
-    public static final int TRACK2_APPLICATION = 0x57;
-    public static final int TRACK3_APPLICATION = 0x58;
-    public static final int CARD_EXPIRATION_DATA = 0x59;
-    public static final int PRIMARY_ACCOUNT_NUMBER = 0x5A;// PAN
-    public static final int NAME = 0x5B;
-    public static final int TAG_LIST = 0x5C;
-    public static final int HEADER_LIST = 0x5D;
-    public static final int LOGIN_DATA = 0x5E;
+    public static final int CARD_SERVICE_DATA = 0x03;
+    public static final int INITIAL_ACCESS_DATA = 0x04;
+    public static final int CARD_ISSUER_DATA = 0x05;
+    public static final int PRE_ISSUING_DATA = 0x06;
+    public static final int CARD_CAPABILITIES = 0x07;
+    public static final int STATUS_INFORMATION = 0x08;
+    public static final int EXTENDED_HEADER_LIST = 0x0D;
+    public static final int APPLICATION_IDENTIFIER = 0x0F;
+    public static final int APPLICATION_LABEL = 0x10;
+    public static final int FILE_REFERENCE = 0x11;           // 0x51
+    public static final int COMMAND_TO_PERFORM = 0x12;
+    public static final int DISCRETIONARY_DATA = 0x13;
+    public static final int OFFSET_DATA_OBJECT = 0x14;
+    public static final int TRACK1_APPLICATION = 0x16;
+    public static final int TRACK2_APPLICATION = 0x17;
+    public static final int TRACK3_APPLICATION = 0x18;
+    public static final int CARD_EXPIRATION_DATA = 0x19;
+    public static final int PRIMARY_ACCOUNT_NUMBER = 0x1A;// PAN
+    public static final int NAME = 0x1B;
+    public static final int TAG_LIST = 0x1C;
+    public static final int HEADER_LIST = 0x1D;
+    public static final int LOGIN_DATA = 0x1E;
     public static final int CARDHOLDER_NAME = 0x20; // 0x5F20;
-    public static final int TRACK1_CARD = 0x5F21;
-    public static final int TRACK2_CARD = 0x5F22;
-    public static final int TRACK3_CARD = 0x5F23;
+    public static final int TRACK1_CARD = 0x21;
+    public static final int TRACK2_CARD = 0x22;
+    public static final int TRACK3_CARD = 0x23;
     public static final int APPLICATION_EXPIRATION_DATE = 0x24; // 0x5F24;
     public static final int APPLICATION_EFFECTIVE_DATE = 0x25; // 0x5F25;
-    public static final int CARD_EFFECTIVE_DATE = 0x5F26;
-    public static final int INTERCHANGE_CONTROL = 0x5F27;
-    public static final int COUNTRY_CODE = 0x5F28;
+    public static final int CARD_EFFECTIVE_DATE = 0x26;
+    public static final int INTERCHANGE_CONTROL = 0x27;
+    public static final int COUNTRY_CODE = 0x28;
     public static final int INTERCHANGE_PROFILE = 0x29; // 0x5F29;
-    public static final int CURRENCY_CODE = 0x5F2A;
-    public static final int DATE_OF_BIRTH = 0x5F2B;
-    public static final int CARDHOLDER_NATIONALITY = 0x5F2C;
-    public static final int LANGUAGE_PREFERENCES = 0x5F2D;
-    public static final int CARDHOLDER_BIOMETRIC_DATA = 0x5F2E;
-    public static final int PIN_USAGE_POLICY = 0x5F2F;
-    public static final int SERVICE_CODE = 0x5F30;
-    public static final int TRANSACTION_COUNTER = 0x5F32;
-    public static final int TRANSACTION_DATE = 0x5F33;
-    public static final int CARD_SEQUENCE_NUMBER = 0x5F34;
-    public static final int SEX = 0x5F35;
-    public static final int CURRENCY_EXPONENT = 0x5F36;
-    public static final int STATIC_INTERNAL_AUTHENTIFICATION_ONE_STEP = 0x37; // 0x5F37;
-    public static final int SIGNATURE = 0x5F37;
-    public static final int STATIC_INTERNAL_AUTHENTIFICATION_FIRST_DATA = 0x5F38;
-    public static final int STATIC_INTERNAL_AUTHENTIFICATION_SECOND_DATA = 0x5F39;
-    public static final int DYNAMIC_INTERNAL_AUTHENTIFICATION = 0x5F3A;
-    public static final int DYNAMIC_EXTERNAL_AUTHENTIFICATION = 0x5F3B;
-    public static final int DYNAMIC_MUTUAL_AUTHENTIFICATION = 0x5F3C;
-    public static final int CARDHOLDER_PORTRAIT_IMAGE = 0x5F40;
-    public static final int ELEMENT_LIST = 0x5F41;
-    public static final int ADDRESS = 0x5F42;
-    public static final int CARDHOLDER_HANDWRITTEN_SIGNATURE = 0x5F43;
-    public static final int APPLICATION_IMAGE = 0x5F44;
-    public static final int DISPLAY_IMAGE = 0x5F45;
-    public static final int TIMER = 0x5F46;
-    public static final int MESSAGE_REFERENCE = 0x5F47;
-    public static final int CARDHOLDER_PRIVATE_KEY = 0x5F48;
-    public static final int CARDHOLDER_PUBLIC_KEY = 0x5F49;
-    public static final int CERTIFICATION_AUTHORITY_PUBLIC_KEY = 0x5F4A;
-    public static final int DEPRECATED = 0x5F4B;
-    public static final int CERTIFICATE_HOLDER_AUTHORIZATION = 0x5F4C;// Not yet defined in iso7816. The allocation is requested
-    public static final int INTEGRATED_CIRCUIT_MANUFACTURER_ID = 0x5F4D;
-    public static final int CERTIFICATE_CONTENT = 0x5F4E;
-    public static final int UNIFORM_RESOURCE_LOCATOR = 0x5F50;
-    public static final int ANSWER_TO_RESET = 0x5F51;
-    public static final int HISTORICAL_BYTES = 0x5F52;
-    public static final int DIGITAL_SIGNATURE = 0x5F3D;
-    public static final int APPLICATION_TEMPLATE = 0x61;
-    public static final int FCP_TEMPLATE = 0x62;
-    public static final int WRAPPER = 0x63;
-    public static final int FMD_TEMPLATE = 0x64;
-    public static final int CARDHOLDER_RELATIVE_DATA = 0x65;
-    public static final int CARD_DATA = 0x66;
-    public static final int AUTHENTIFICATION_DATA = 0x67;
-    public static final int SPECIAL_USER_REQUIREMENTS = 0x68;
-    public static final int LOGIN_TEMPLATE = 0x6A;
-    public static final int QUALIFIED_NAME = 0x6B;
-    public static final int CARDHOLDER_IMAGE_TEMPLATE = 0x6C;
-    public static final int APPLICATION_IMAGE_TEMPLATE = 0x6D;
-    public static final int APPLICATION_RELATED_DATA = 0x6E;
-    public static final int FCI_TEMPLATE = 0x6F;
-    public static final int DISCRETIONARY_DATA_OBJECTS = 0x73;
-    public static final int COMPATIBLE_TAG_ALLOCATION_AUTHORITY = 0x78;
-    public static final int COEXISTANT_TAG_ALLOCATION_AUTHORITY = 0x79;
-    public static final int SECURITY_SUPPORT_TEMPLATE = 0x7A;
-    public static final int SECURITY_ENVIRONMENT_TEMPLATE = 0x7B;
-    public static final int DYNAMIC_AUTHENTIFICATION_TEMPLATE = 0x7C;
-    public static final int SECURE_MESSAGING_TEMPLATE = 0x7D;
-    public static final int NON_INTERINDUSTRY_DATA_OBJECT_NESTING_TEMPLATE = 0x7E;
-    public static final int DISPLAY_CONTROL = 0x7F20;
-    public static final int CARDHOLDER_CERTIFICATE = 0x21; // 0x7F21;
-    public static final int CV_CERTIFICATE = 0x7F21;
-    public static final int CARDHOLER_REQUIREMENTS_INCLUDED_FEATURES = 0x7F22;
-    public static final int CARDHOLER_REQUIREMENTS_EXCLUDED_FEATURES = 0x7F23;
-    public static final int BIOMETRIC_DATA_TEMPLATE = 0x7F2E;
-    public static final int DIGITAL_SIGNATURE_BLOCK = 0x7F3D;
-    public static final int CARDHOLDER_PRIVATE_KEY_TEMPLATE = 0x7F48;
-    public static final int CARDHOLDER_PUBLIC_KEY_TEMPLATE = 0x49; // 0x7F49;
+    public static final int CURRENCY_CODE = 0x2A;
+    public static final int DATE_OF_BIRTH = 0x2B;
+    public static final int CARDHOLDER_NATIONALITY = 0x2C;
+    public static final int LANGUAGE_PREFERENCES = 0x2D;
+    public static final int CARDHOLDER_BIOMETRIC_DATA = 0x2E;
+    public static final int PIN_USAGE_POLICY = 0x2F;
+    public static final int SERVICE_CODE = 0x30;
+    public static final int TRANSACTION_COUNTER = 0x32;
+    public static final int TRANSACTION_DATE = 0x33;
+    public static final int CARD_SEQUENCE_NUMBER = 0x34;
+    public static final int SEX = 0x35;
+    public static final int CURRENCY_EXPONENT = 0x36;
+    public static final int STATIC_INTERNAL_AUTHENTIFICATION_ONE_STEP = 0x37;    // 0x5F37;
+    public static final int SIGNATURE = 0x37;                                    // 0x5F37
+    public static final int STATIC_INTERNAL_AUTHENTIFICATION_FIRST_DATA = 0x38;  // 0x5F38
+    public static final int STATIC_INTERNAL_AUTHENTIFICATION_SECOND_DATA = 0x39; // 0x5F39
+    public static final int DYNAMIC_INTERNAL_AUTHENTIFICATION = 0x3A;            // 0x5F3A
+    public static final int DYNAMIC_EXTERNAL_AUTHENTIFICATION = 0x3B;            // 0x5F3B
+    public static final int DYNAMIC_MUTUAL_AUTHENTIFICATION = 0x3C;              // 0x5F3C
+    public static final int CARDHOLDER_PORTRAIT_IMAGE = 0x40;                    // 0x5F40
+    public static final int ELEMENT_LIST = 0x41;                                 // 0x5F41
+    public static final int ADDRESS = 0x42;                                      // 0x5F42
+    public static final int CARDHOLDER_HANDWRITTEN_SIGNATURE = 0x43;             // 0x5F43
+    public static final int APPLICATION_IMAGE = 0x44;                            // 0x5F44
+    public static final int DISPLAY_IMAGE = 0x45;                                // 0x5F45
+    public static final int TIMER = 0x46;                                        // 0x5F46
+    public static final int MESSAGE_REFERENCE = 0x47;                            // 0x5F47
+    public static final int CARDHOLDER_PRIVATE_KEY = 0x48;                       // 0x5F48
+    public static final int CARDHOLDER_PUBLIC_KEY = 0x49;                        // 0x5F49
+    public static final int CERTIFICATION_AUTHORITY_PUBLIC_KEY = 0x4A;           // 0x5F4A
+    public static final int DEPRECATED = 0x4B;                                   // 0x5F4B
+    public static final int CERTIFICATE_HOLDER_AUTHORIZATION = 0x4C;    // 0x5F4C Not yet defined in iso7816. The allocation is requested
+    public static final int INTEGRATED_CIRCUIT_MANUFACTURER_ID = 0x4D;  // 0x5F4D
+    public static final int CERTIFICATE_CONTENT = 0x4E;                 // 0x5F4E
+    public static final int UNIFORM_RESOURCE_LOCATOR = 0x50;            // 0x5F50
+    public static final int ANSWER_TO_RESET = 0x51;                     // 0x5F51
+    public static final int HISTORICAL_BYTES = 0x52;                    // 0x5F52
+    public static final int DIGITAL_SIGNATURE = 0x3D;                   // 0x5F3D
+    public static final int APPLICATION_TEMPLATE = 0x01;                // 0x61
+    public static final int FCP_TEMPLATE = 0x02;                        // 0x62
+    public static final int WRAPPER = 0x03;                             // 0x63
+    public static final int FMD_TEMPLATE = 0x04;                        // 0x64
+    public static final int CARDHOLDER_RELATIVE_DATA = 0x05;            // 0x65
+    public static final int CARD_DATA = 0x06;                           // 0x66
+    public static final int AUTHENTIFICATION_DATA = 0x07;               // 0x67
+    public static final int SPECIAL_USER_REQUIREMENTS = 0x08;           // 0x68
+    public static final int LOGIN_TEMPLATE = 0x0A;                      // 0x6A
+    public static final int QUALIFIED_NAME = 0x0B;                      // 0x6B
+    public static final int CARDHOLDER_IMAGE_TEMPLATE = 0x0C;           // 0x6C
+    public static final int APPLICATION_IMAGE_TEMPLATE = 0x0D;          // 0x6D
+    public static final int APPLICATION_RELATED_DATA = 0x0E;            // 0x6E
+    public static final int FCI_TEMPLATE = 0x0F;                        // 0x6F
+    public static final int DISCRETIONARY_DATA_OBJECTS = 0x13;          // 0x73
+    public static final int COMPATIBLE_TAG_ALLOCATION_AUTHORITY = 0x18; // 0x78
+    public static final int COEXISTANT_TAG_ALLOCATION_AUTHORITY = 0x19; // 0x79
+    public static final int SECURITY_SUPPORT_TEMPLATE = 0x1A;           // 0x7A
+    public static final int SECURITY_ENVIRONMENT_TEMPLATE = 0x1B;       // 0x7B
+    public static final int DYNAMIC_AUTHENTIFICATION_TEMPLATE = 0x1C;   // 0x7C
+    public static final int SECURE_MESSAGING_TEMPLATE = 0x1D;           // 0x7D
+    public static final int NON_INTERINDUSTRY_DATA_OBJECT_NESTING_TEMPLATE = 0x1E; // 0x7E
+    public static final int DISPLAY_CONTROL = 0x20;                           // 0x7F20
+    public static final int CARDHOLDER_CERTIFICATE = 0x21;                    // 0x7F21;
+    public static final int CV_CERTIFICATE = 0x21;                            // 0x7F21;
+    public static final int CARDHOLER_REQUIREMENTS_INCLUDED_FEATURES = 0x22;  // 0x7F22;
+    public static final int CARDHOLER_REQUIREMENTS_EXCLUDED_FEATURES = 0x23;  // 0x7F23;
+    public static final int BIOMETRIC_DATA_TEMPLATE = 0x2E;                   // 0x7F2E;
+    public static final int DIGITAL_SIGNATURE_BLOCK = 0x3D;                   // 0x7F3D;
+    public static final int CARDHOLDER_PRIVATE_KEY_TEMPLATE = 0x48;           // 0x7F48;
+    public static final int CARDHOLDER_PUBLIC_KEY_TEMPLATE = 0x49;            // 0x7F49;
     public static final int CERTIFICATE_HOLDER_AUTHORIZATION_TEMPLATE = 0x4C; // 0x7F4C;
-    public static final int CERTIFICATE_CONTENT_TEMPLATE = 0x4E; // 0x7F4E;
-    public static final int CERTIFICATE_BODY = 0x4E; // 0x7F4E;
-    public static final int BIOMETRIC_INFORMATION_TEMPLATE = 0x7F60;
-    public static final int BIOMETRIC_INFORMATION_GROUP_TEMPLATE = 0x7F61;
+    public static final int CERTIFICATE_CONTENT_TEMPLATE = 0x4E;              // 0x7F4E;
+    public static final int CERTIFICATE_BODY = 0x4E;                          // 0x7F4E;
+    public static final int BIOMETRIC_INFORMATION_TEMPLATE = 0x00;            // 0x60
+    public static final int BIOMETRIC_INFORMATION_GROUP_TEMPLATE = 0x01;      // 0x61
 
     public static int getTag(int encodedTag)
     {
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/eac/ECDSAPublicKey.java b/bcprov/src/main/java/org/bouncycastle/asn1/eac/ECDSAPublicKey.java
index 255cf23..9ccf08f 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/eac/ECDSAPublicKey.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/eac/ECDSAPublicKey.java
@@ -336,6 +336,6 @@
 
     public ASN1Primitive toASN1Primitive()
     {
-        return new DERSequence(getASN1EncodableVector(usage, false));
+        return new DERSequence(getASN1EncodableVector(usage, !hasParameters()));
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/est/AttrOrOID.java b/bcprov/src/main/java/org/bouncycastle/asn1/est/AttrOrOID.java
new file mode 100644
index 0000000..456e655
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/est/AttrOrOID.java
@@ -0,0 +1,100 @@
+package org.bouncycastle.asn1.est;
+
+import java.io.IOException;
+
+import org.bouncycastle.asn1.ASN1Choice;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.pkcs.Attribute;
+
+/**
+ * <pre>
+ *    AttrOrOID ::= CHOICE (oid OBJECT IDENTIFIER, attribute Attribute }
+ * </pre>
+ */
+public class AttrOrOID
+    extends ASN1Object
+    implements ASN1Choice
+{
+    private final ASN1ObjectIdentifier oid;
+    private final Attribute attribute;
+
+    public AttrOrOID(ASN1ObjectIdentifier oid)
+    {
+        this.oid = oid;
+        attribute = null;
+    }
+
+    public AttrOrOID(Attribute attribute)
+    {
+        this.oid = null;
+        this.attribute = attribute;
+    }
+
+    public static AttrOrOID getInstance(
+        Object obj)
+    {
+        if (obj instanceof AttrOrOID)
+        {
+            return (AttrOrOID)obj;
+        }
+
+        if (obj != null)
+        {
+            if (obj instanceof ASN1Encodable)
+            {
+                ASN1Encodable asn1Prim = ((ASN1Encodable)obj).toASN1Primitive();
+
+                if (asn1Prim instanceof ASN1ObjectIdentifier)
+                {
+                    return new AttrOrOID(ASN1ObjectIdentifier.getInstance(asn1Prim));
+                }
+                if (asn1Prim instanceof ASN1Sequence)
+                {
+                    return new AttrOrOID(Attribute.getInstance(asn1Prim));
+                }
+            }
+            if (obj instanceof byte[])
+            {
+                try
+                {
+                    return getInstance(ASN1Primitive.fromByteArray((byte[])obj));
+                }
+                catch (IOException e)
+                {
+                    throw new IllegalArgumentException("unknown encoding in getInstance()");
+                }
+            }
+            throw new IllegalArgumentException("unknown object in getInstance(): " + obj.getClass().getName());
+        }
+
+        return null;
+    }
+
+    public boolean isOid()
+    {
+        return oid != null;
+    }
+
+    public ASN1ObjectIdentifier getOid()
+    {
+        return oid;
+    }
+
+    public Attribute getAttribute()
+    {
+        return attribute;
+    }
+    public ASN1Primitive toASN1Primitive()
+    {
+        if (oid != null)
+        {
+            return oid;
+        }
+
+        return attribute.toASN1Primitive();
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/est/CsrAttrs.java b/bcprov/src/main/java/org/bouncycastle/asn1/est/CsrAttrs.java
new file mode 100644
index 0000000..a1ceeb4
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/est/CsrAttrs.java
@@ -0,0 +1,85 @@
+package org.bouncycastle.asn1.est;
+
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.ASN1TaggedObject;
+import org.bouncycastle.asn1.DERSequence;
+
+/**
+ * <pre>
+ *      CsrAttrs ::= SEQUENCE SIZE (0..MAX) OF AttrOrOID
+ * </pre>
+ */
+public class CsrAttrs
+    extends ASN1Object
+{
+    private final AttrOrOID[] attrOrOIDs;
+
+    public static CsrAttrs getInstance(
+        Object obj)
+    {
+        if (obj instanceof CsrAttrs)
+        {
+            return (CsrAttrs)obj;
+        }
+
+        if (obj != null)
+        {
+            return new CsrAttrs(ASN1Sequence.getInstance(obj));
+        }
+
+        return null;
+    }
+
+    public static CsrAttrs getInstance(
+        ASN1TaggedObject obj,
+        boolean explicit)
+    {
+        return getInstance(ASN1Sequence.getInstance(obj, explicit));
+    }
+
+    /**
+     * Construct a CsrAttrs object containing one AttrOrOID.
+     *
+     * @param attrOrOID the AttrOrOID to be contained.
+     */
+    public CsrAttrs(
+        AttrOrOID attrOrOID)
+    {
+        this.attrOrOIDs = new AttrOrOID[]{attrOrOID};
+    }
+
+
+    public CsrAttrs(
+        AttrOrOID[] attrOrOIDs)
+    {
+        this.attrOrOIDs = Utils.clone(attrOrOIDs);
+    }
+
+    private CsrAttrs(
+        ASN1Sequence seq)
+    {
+        this.attrOrOIDs = new AttrOrOID[seq.size()];
+
+        for (int i = 0; i != seq.size(); i++)
+        {
+            attrOrOIDs[i] = AttrOrOID.getInstance(seq.getObjectAt(i));
+        }
+    }
+
+    public AttrOrOID[] getAttrOrOIDs()
+    {
+        return Utils.clone(attrOrOIDs);
+    }
+
+    public int size()
+    {
+        return attrOrOIDs.length;
+    }
+
+    public ASN1Primitive toASN1Primitive()
+    {
+        return new DERSequence(attrOrOIDs);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/est/Utils.java b/bcprov/src/main/java/org/bouncycastle/asn1/est/Utils.java
new file mode 100644
index 0000000..43a406a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/est/Utils.java
@@ -0,0 +1,13 @@
+package org.bouncycastle.asn1.est;
+
+class Utils
+{
+    static AttrOrOID[] clone(AttrOrOID[] ids)
+    {
+        AttrOrOID[] tmp = new AttrOrOID[ids.length];
+
+        System.arraycopy(ids, 0, tmp, 0, ids.length);
+
+        return tmp;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/gm/GMNamedCurves.java b/bcprov/src/main/java/org/bouncycastle/asn1/gm/GMNamedCurves.java
new file mode 100644
index 0000000..a0e65e5
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/gm/GMNamedCurves.java
@@ -0,0 +1,142 @@
+package org.bouncycastle.asn1.gm;
+
+import java.math.BigInteger;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.x9.X9ECParameters;
+import org.bouncycastle.asn1.x9.X9ECParametersHolder;
+import org.bouncycastle.asn1.x9.X9ECPoint;
+import org.bouncycastle.math.ec.ECCurve;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.encoders.Hex;
+
+/**
+ * Chinese standard GM named curves.
+ */
+public class GMNamedCurves
+{
+    private static ECCurve configureCurve(ECCurve curve)
+    {
+        return curve;
+    }
+
+    private static BigInteger fromHex(
+        String hex)
+    {
+        return new BigInteger(1, Hex.decode(hex));
+    }
+
+    /*
+     * SM2SysParams
+     */
+    static X9ECParametersHolder sm2p256v1 = new X9ECParametersHolder()
+    {
+        protected X9ECParameters createParameters()
+        {
+
+            BigInteger p = fromHex("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF");
+            BigInteger a = fromHex("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC");
+            BigInteger b = fromHex("28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93");
+            byte[] S = null;
+            BigInteger n = fromHex("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123");
+            BigInteger h = BigInteger.valueOf(1);
+
+            ECCurve curve = configureCurve(new ECCurve.Fp(p, a, b, n, h));
+            X9ECPoint G = new X9ECPoint(curve, Hex.decode("04"
+                + "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7"
+                + "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"));
+
+            return new X9ECParameters(curve, G, n, h, S);
+        }
+    };
+
+    static X9ECParametersHolder wapip192v1 = new X9ECParametersHolder()
+    {
+        protected X9ECParameters createParameters()
+        {
+            BigInteger p = fromHex("BDB6F4FE3E8B1D9E0DA8C0D46F4C318CEFE4AFE3B6B8551F");
+            BigInteger a = fromHex("BB8E5E8FBC115E139FE6A814FE48AAA6F0ADA1AA5DF91985");
+            BigInteger b = fromHex("1854BEBDC31B21B7AEFC80AB0ECD10D5B1B3308E6DBF11C1");
+            byte[] S = null;
+            BigInteger n = fromHex("BDB6F4FE3E8B1D9E0DA8C0D40FC962195DFAE76F56564677");
+            BigInteger h = BigInteger.valueOf(1);
+
+            ECCurve curve = configureCurve(new ECCurve.Fp(p, a, b, n, h));
+            X9ECPoint G = new X9ECPoint(curve, Hex.decode("04"
+                + "4AD5F7048DE709AD51236DE6" + "5E4D4B482C836DC6E4106640"
+                + "02BB3A02D4AAADACAE24817A" + "4CA3A1B014B5270432DB27D2"));
+
+            return new X9ECParameters(curve, G, n, h, S);
+        }
+    };
+    
+    static final Hashtable objIds = new Hashtable();
+    static final Hashtable curves = new Hashtable();
+    static final Hashtable names = new Hashtable();
+
+    static void defineCurve(String name, ASN1ObjectIdentifier oid, X9ECParametersHolder holder)
+    {
+        objIds.put(Strings.toLowerCase(name), oid);
+        names.put(oid, name);
+        curves.put(oid, holder);
+    }
+
+    static
+    {
+        defineCurve("wapip192v1", GMObjectIdentifiers.wapip192v1, wapip192v1);
+        defineCurve("sm2p256v1", GMObjectIdentifiers.sm2p256v1, sm2p256v1);
+    }
+
+    public static X9ECParameters getByName(
+        String name)
+    {
+        ASN1ObjectIdentifier oid = getOID(name);
+        return oid == null ? null : getByOID(oid);
+    }
+
+    /**
+     * return the X9ECParameters object for the named curve represented by
+     * the passed in object identifier. Null if the curve isn't present.
+     *
+     * @param oid an object identifier representing a named curve, if present.
+     */
+    public static X9ECParameters getByOID(
+        ASN1ObjectIdentifier oid)
+    {
+        X9ECParametersHolder holder = (X9ECParametersHolder)curves.get(oid);
+        return holder == null ? null : holder.getParameters();
+    }
+
+    /**
+     * return the object identifier signified by the passed in name. Null
+     * if there is no object identifier associated with name.
+     *
+     * @return the object identifier associated with name, if present.
+     */
+    public static ASN1ObjectIdentifier getOID(
+        String name)
+    {
+        return (ASN1ObjectIdentifier)objIds.get(Strings.toLowerCase(name));
+    }
+
+    /**
+     * return the named curve name represented by the given object identifier.
+     */
+    public static String getName(
+        ASN1ObjectIdentifier oid)
+    {
+        return (String)names.get(oid);
+    }
+
+    /**
+     * returns an enumeration containing the name strings for curves
+     * contained in this structure.
+     */
+    public static Enumeration getNames()
+    {
+        return names.elements();
+    }
+}
+
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/gm/GMObjectIdentifiers.java b/bcprov/src/main/java/org/bouncycastle/asn1/gm/GMObjectIdentifiers.java
new file mode 100644
index 0000000..ade6782
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/gm/GMObjectIdentifiers.java
@@ -0,0 +1,84 @@
+package org.bouncycastle.asn1.gm;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+
+public interface GMObjectIdentifiers
+{
+    ASN1ObjectIdentifier sm_scheme = new ASN1ObjectIdentifier("1.2.156.10197.1");
+
+    ASN1ObjectIdentifier sm6_ecb = sm_scheme.branch("101.1");
+    ASN1ObjectIdentifier sm6_cbc = sm_scheme.branch("101.2");
+    ASN1ObjectIdentifier sm6_ofb128 = sm_scheme.branch("101.3");
+    ASN1ObjectIdentifier sm6_cfb128 = sm_scheme.branch("101.4");
+
+    ASN1ObjectIdentifier sm1_ecb = sm_scheme.branch("102.1");
+    ASN1ObjectIdentifier sm1_cbc = sm_scheme.branch("102.2");
+    ASN1ObjectIdentifier sm1_ofb128 = sm_scheme.branch("102.3");
+    ASN1ObjectIdentifier sm1_cfb128 = sm_scheme.branch("102.4");
+    ASN1ObjectIdentifier sm1_cfb1 = sm_scheme.branch("102.5");
+    ASN1ObjectIdentifier sm1_cfb8 = sm_scheme.branch("102.6");
+
+    ASN1ObjectIdentifier ssf33_ecb = sm_scheme.branch("103.1");
+    ASN1ObjectIdentifier ssf33_cbc = sm_scheme.branch("103.2");
+    ASN1ObjectIdentifier ssf33_ofb128 = sm_scheme.branch("103.3");
+    ASN1ObjectIdentifier ssf33_cfb128 = sm_scheme.branch("103.4");
+    ASN1ObjectIdentifier ssf33_cfb1 = sm_scheme.branch("103.5");
+    ASN1ObjectIdentifier ssf33_cfb8 = sm_scheme.branch("103.6");
+
+    ASN1ObjectIdentifier sms4_ecb = sm_scheme.branch("104.1");
+    ASN1ObjectIdentifier sms4_cbc = sm_scheme.branch("104.2");
+    ASN1ObjectIdentifier sms4_ofb128 = sm_scheme.branch("104.3");
+    ASN1ObjectIdentifier sms4_cfb128 = sm_scheme.branch("104.4");
+    ASN1ObjectIdentifier sms4_cfb1 = sm_scheme.branch("104.5");
+    ASN1ObjectIdentifier sms4_cfb8 = sm_scheme.branch("104.6");
+    ASN1ObjectIdentifier sms4_ctr = sm_scheme.branch("104.7");
+    ASN1ObjectIdentifier sms4_gcm = sm_scheme.branch("104.8");
+    ASN1ObjectIdentifier sms4_ccm = sm_scheme.branch("104.9");
+    ASN1ObjectIdentifier sms4_xts = sm_scheme.branch("104.10");
+    ASN1ObjectIdentifier sms4_wrap = sm_scheme.branch("104.11");
+    ASN1ObjectIdentifier sms4_wrap_pad = sm_scheme.branch("104.12");
+    ASN1ObjectIdentifier sms4_ocb = sm_scheme.branch("104.100");
+
+    ASN1ObjectIdentifier sm5 = sm_scheme.branch("201");
+
+    ASN1ObjectIdentifier sm2p256v1 = sm_scheme.branch("301");
+    ASN1ObjectIdentifier sm2sign = sm_scheme.branch("301.1");
+    ASN1ObjectIdentifier sm2exchange = sm_scheme.branch("301.2");
+    ASN1ObjectIdentifier sm2encrypt = sm_scheme.branch("301.3");
+
+    ASN1ObjectIdentifier wapip192v1 = sm_scheme.branch("301.101");
+
+    ASN1ObjectIdentifier sm2encrypt_recommendedParameters = sm2encrypt.branch("1");
+    ASN1ObjectIdentifier sm2encrypt_specifiedParameters = sm2encrypt.branch("2");
+    ASN1ObjectIdentifier sm2encrypt_with_sm3 = sm2encrypt.branch("2.1");
+    ASN1ObjectIdentifier sm2encrypt_with_sha1 = sm2encrypt.branch("2.2");
+    ASN1ObjectIdentifier sm2encrypt_with_sha224 = sm2encrypt.branch("2.3");
+    ASN1ObjectIdentifier sm2encrypt_with_sha256 = sm2encrypt.branch("2.4");
+    ASN1ObjectIdentifier sm2encrypt_with_sha384 = sm2encrypt.branch("2.5");
+    ASN1ObjectIdentifier sm2encrypt_with_sha512 = sm2encrypt.branch("2.6");
+    ASN1ObjectIdentifier sm2encrypt_with_rmd160 =  sm2encrypt.branch("2.7");
+    ASN1ObjectIdentifier sm2encrypt_with_whirlpool =sm2encrypt.branch("2.8");
+    ASN1ObjectIdentifier sm2encrypt_with_blake2b512 = sm2encrypt.branch("2.9");
+    ASN1ObjectIdentifier sm2encrypt_with_blake2s256 = sm2encrypt.branch("2.10");
+    ASN1ObjectIdentifier sm2encrypt_with_md5 = sm2encrypt.branch("2.11");
+
+    ASN1ObjectIdentifier id_sm9PublicKey = sm_scheme.branch("302");
+    ASN1ObjectIdentifier sm9sign = sm_scheme.branch("302.1");
+    ASN1ObjectIdentifier sm9keyagreement = sm_scheme.branch("302.2");
+    ASN1ObjectIdentifier sm9encrypt = sm_scheme.branch("302.3");
+
+    ASN1ObjectIdentifier sm3 = sm_scheme.branch("401");
+
+    ASN1ObjectIdentifier hmac_sm3 = sm3.branch("2");
+
+    ASN1ObjectIdentifier sm2sign_with_sm3 = sm_scheme.branch("501");
+    ASN1ObjectIdentifier sm2sign_with_sha1 = sm_scheme.branch("502");
+    ASN1ObjectIdentifier sm2sign_with_sha256 = sm_scheme.branch("503");
+    ASN1ObjectIdentifier sm2sign_with_sha512 = sm_scheme.branch("504");
+    ASN1ObjectIdentifier sm2sign_with_sha224 = sm_scheme.branch("505");
+    ASN1ObjectIdentifier sm2sign_with_sha384 = sm_scheme.branch("506");
+    ASN1ObjectIdentifier sm2sign_with_rmd160 = sm_scheme.branch("507");
+    ASN1ObjectIdentifier sm2sign_with_whirlpool = sm_scheme.branch("520");
+    ASN1ObjectIdentifier sm2sign_with_blake2b512 = sm_scheme.branch("521");
+    ASN1ObjectIdentifier sm2sign_with_blake2s256 = sm_scheme.branch("522");
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/gnu/GNUObjectIdentifiers.java b/bcprov/src/main/java/org/bouncycastle/asn1/gnu/GNUObjectIdentifiers.java
index a329e63..9eb3885 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/gnu/GNUObjectIdentifiers.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/gnu/GNUObjectIdentifiers.java
@@ -55,4 +55,9 @@
     public static final ASN1ObjectIdentifier CRC = new ASN1ObjectIdentifier("1.3.6.1.4.1.11591.14"); // CRC algorithms
     /** 1.3.6.1.4.1.11591.14,1 -- CRC32 */
     public static final ASN1ObjectIdentifier CRC32 = new ASN1ObjectIdentifier("1.3.6.1.4.1.11591.14.1"); // CRC 32
+
+    /** 1.3.6.1.4.1.11591.15 - ellipticCurve */
+    public static final ASN1ObjectIdentifier ellipticCurve = new ASN1ObjectIdentifier("1.3.6.1.4.1.11591.15");
+
+    public static final ASN1ObjectIdentifier Ed25519   = ellipticCurve.branch("1");
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/nsri/NSRIObjectIdentifiers.java b/bcprov/src/main/java/org/bouncycastle/asn1/nsri/NSRIObjectIdentifiers.java
new file mode 100644
index 0000000..4ef8148
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/nsri/NSRIObjectIdentifiers.java
@@ -0,0 +1,58 @@
+package org.bouncycastle.asn1.nsri;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+
+public interface NSRIObjectIdentifiers
+{
+    static final ASN1ObjectIdentifier   nsri                = new ASN1ObjectIdentifier("1.2.410.200046");
+
+    static final ASN1ObjectIdentifier   id_algorithm        = nsri.branch("1");
+
+    static final ASN1ObjectIdentifier   id_sea              = id_algorithm.branch("1");
+    static final ASN1ObjectIdentifier   id_pad              = id_algorithm.branch("2");
+
+    static final ASN1ObjectIdentifier   id_pad_null         = id_algorithm.branch("0");
+    static final ASN1ObjectIdentifier   id_pad_1            = id_algorithm.branch("1");
+
+    static final ASN1ObjectIdentifier   id_aria128_ecb      = id_sea.branch("1");
+    static final ASN1ObjectIdentifier   id_aria128_cbc      = id_sea.branch("2");
+    static final ASN1ObjectIdentifier   id_aria128_cfb      = id_sea.branch("3");
+    static final ASN1ObjectIdentifier   id_aria128_ofb      = id_sea.branch("4");
+    static final ASN1ObjectIdentifier   id_aria128_ctr      = id_sea.branch("5");
+
+    static final ASN1ObjectIdentifier   id_aria192_ecb      = id_sea.branch("6");
+    static final ASN1ObjectIdentifier   id_aria192_cbc      = id_sea.branch("7");
+    static final ASN1ObjectIdentifier   id_aria192_cfb      = id_sea.branch("8");
+    static final ASN1ObjectIdentifier   id_aria192_ofb      = id_sea.branch("9");
+    static final ASN1ObjectIdentifier   id_aria192_ctr      = id_sea.branch("10");
+
+    static final ASN1ObjectIdentifier   id_aria256_ecb      = id_sea.branch("11");
+    static final ASN1ObjectIdentifier   id_aria256_cbc      = id_sea.branch("12");
+    static final ASN1ObjectIdentifier   id_aria256_cfb      = id_sea.branch("13");
+    static final ASN1ObjectIdentifier   id_aria256_ofb      = id_sea.branch("14");
+    static final ASN1ObjectIdentifier   id_aria256_ctr      = id_sea.branch("15");
+
+    static final ASN1ObjectIdentifier   id_aria128_cmac     = id_sea.branch("21");
+    static final ASN1ObjectIdentifier   id_aria192_cmac     = id_sea.branch("22");
+    static final ASN1ObjectIdentifier   id_aria256_cmac     = id_sea.branch("23");
+
+    static final ASN1ObjectIdentifier   id_aria128_ocb2     = id_sea.branch("31");
+    static final ASN1ObjectIdentifier   id_aria192_ocb2     = id_sea.branch("32");
+    static final ASN1ObjectIdentifier   id_aria256_ocb2     = id_sea.branch("33");
+
+    static final ASN1ObjectIdentifier   id_aria128_gcm      = id_sea.branch("34");
+    static final ASN1ObjectIdentifier   id_aria192_gcm      = id_sea.branch("35");
+    static final ASN1ObjectIdentifier   id_aria256_gcm      = id_sea.branch("36");
+
+    static final ASN1ObjectIdentifier   id_aria128_ccm      = id_sea.branch("37");
+    static final ASN1ObjectIdentifier   id_aria192_ccm      = id_sea.branch("38");
+    static final ASN1ObjectIdentifier   id_aria256_ccm      = id_sea.branch("39");
+
+    static final ASN1ObjectIdentifier   id_aria128_kw       = id_sea.branch("40");
+    static final ASN1ObjectIdentifier   id_aria192_kw       = id_sea.branch("41");
+    static final ASN1ObjectIdentifier   id_aria256_kw       = id_sea.branch("42");
+
+    static final ASN1ObjectIdentifier   id_aria128_kwp      = id_sea.branch("43");
+    static final ASN1ObjectIdentifier   id_aria192_kwp      = id_sea.branch("44");
+    static final ASN1ObjectIdentifier   id_aria256_kwp      = id_sea.branch("45");
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequest.java b/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequest.java
index 987d4eb..e089cbc 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequest.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequest.java
@@ -54,6 +54,9 @@
         this.sigBits = signature;
     }
 
+    /**
+     * @deprecated use getInstance()
+     */
     public CertificationRequest(
         ASN1Sequence seq)
     {
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequestInfo.java b/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequestInfo.java
index dca0719..25e6286 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequestInfo.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/CertificationRequestInfo.java
@@ -1,5 +1,7 @@
 package org.bouncycastle.asn1.pkcs;
 
+import java.util.Enumeration;
+
 import org.bouncycastle.asn1.ASN1EncodableVector;
 import org.bouncycastle.asn1.ASN1Integer;
 import org.bouncycastle.asn1.ASN1Object;
@@ -77,6 +79,8 @@
             throw new IllegalArgumentException("Not all mandatory fields set in CertificationRequestInfo generator.");
         }
 
+        validateAttributes(attributes);
+
         this.subject = subject;
         this.subjectPKInfo = pkInfo;
         this.attributes = attributes;
@@ -90,14 +94,7 @@
         SubjectPublicKeyInfo    pkInfo,
         ASN1Set                 attributes)
     {
-        if ((subject == null) || (pkInfo == null))
-        {
-            throw new IllegalArgumentException("Not all mandatory fields set in CertificationRequestInfo generator.");
-        }
-        
-        this.subject = X500Name.getInstance(subject.toASN1Primitive());
-        this.subjectPKInfo = pkInfo;
-        this.attributes = attributes;
+        this(X500Name.getInstance(subject.toASN1Primitive()), pkInfo, attributes);
     }
 
     /**
@@ -121,6 +118,8 @@
             attributes = ASN1Set.getInstance(tagobj, false);
         }
 
+        validateAttributes(attributes);
+
         if ((subject == null) || (version == null) || (subjectPKInfo == null))
         {
             throw new IllegalArgumentException("Not all mandatory fields set in CertificationRequestInfo generator.");
@@ -162,4 +161,24 @@
 
         return new DERSequence(v);
     }
+
+    private static void validateAttributes(ASN1Set attributes)
+    {
+        if (attributes == null)
+        {
+            return;
+        }
+
+        for (Enumeration en = attributes.getObjects(); en.hasMoreElements();)
+        {
+            Attribute attr = Attribute.getInstance(en.nextElement());
+            if (attr.getAttrType().equals(PKCSObjectIdentifiers.pkcs_9_at_challengePassword))
+            {
+                if (attr.getAttrValues().size() != 1)
+                {
+                    throw new IllegalArgumentException("challengePassword attribute must have one value");
+                }
+            }
+        }
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/PKCSObjectIdentifiers.java b/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/PKCSObjectIdentifiers.java
index ba22274..bb81a4f 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/PKCSObjectIdentifiers.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/pkcs/PKCSObjectIdentifiers.java
@@ -337,6 +337,20 @@
     /** PKCS#9: 1.2.840.113549.1.9.16.6.2.27 - <a href="http://tools.ietf.org/html/rfc3126">RFC 3126</a> */
     static final ASN1ObjectIdentifier id_aa_ets_archiveTimestamp = id_aa.branch("27");
 
+    /** PKCS#9: 1.2.840.113549.1.9.16.6.2.37 - <a href="https://tools.ietf.org/html/rfc4108#section-2.2.5">RFC 4108</a> */
+    static final ASN1ObjectIdentifier id_aa_decryptKeyID = id_aa.branch("37");
+
+    /** PKCS#9: 1.2.840.113549.1.9.16.6.2.38 - <a href="https://tools.ietf.org/html/rfc4108#section-2.2.6">RFC 4108</a> */
+    static final ASN1ObjectIdentifier id_aa_implCryptoAlgs = id_aa.branch("38");
+
+    /** PKCS#9: 1.2.840.113549.1.9.16.2.54 <a href="https://tools.ietf.org/html/rfc7030">RFC7030</a>*/
+    static final ASN1ObjectIdentifier id_aa_asymmDecryptKeyID = id_aa.branch("54");
+
+    /** PKCS#9: 1.2.840.113549.1.9.16.2.43   <a href="https://tools.ietf.org/html/rfc7030">RFC7030</a>*/
+    static final ASN1ObjectIdentifier id_aa_implCompressAlgs = id_aa.branch("43");
+    /** PKCS#9: 1.2.840.113549.1.9.16.2.40   <a href="https://tools.ietf.org/html/rfc7030">RFC7030</a>*/
+    static final ASN1ObjectIdentifier id_aa_communityIdentifiers = id_aa.branch("40");
+
     /** @deprecated use id_aa_ets_sigPolicyId instead */
     static final ASN1ObjectIdentifier id_aa_sigPolicyId    = id_aa_ets_sigPolicyId;
     /** @deprecated use id_aa_ets_commitmentType instead */
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartIDTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartIDTest.java
new file mode 100644
index 0000000..5cfd7a7
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartIDTest.java
@@ -0,0 +1,97 @@
+package org.bouncycastle.asn1.test;
+
+
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class BodyPartIDTest
+    extends SimpleTest
+{
+
+
+    public void performTest()
+        throws Exception
+    {
+        // Test correct encode / decode
+
+
+        {
+            // Test encode and decode from Long and from other instance of BodyPartID
+            BodyPartID bpd = new BodyPartID(10L);
+            byte[] b = bpd.getEncoded();
+            BodyPartID resBpd = BodyPartID.getInstance(b);
+            isEquals("Correct / Encode byte array", resBpd.getID(), bpd.getID());
+
+            BodyPartID rootPartID = new BodyPartID(12L);
+            bpd = BodyPartID.getInstance(rootPartID);
+            b = bpd.getEncoded();
+            resBpd = BodyPartID.getInstance(b);
+            isEquals("Correct / Encode byte array", resBpd.getID(), rootPartID.getID());
+        }
+
+
+        {
+            // Test lower limit, should not throw exception
+            try
+            {
+                new BodyPartID(0);
+            }
+            catch (Throwable t)
+            {
+                fail("Unexpected exception: " + t.getMessage(), t);
+            }
+
+            // Test below lower range
+            try
+            {
+                new BodyPartID(-1);
+                fail("Expecting IllegalArgumentException because of outside lower range");
+            }
+            catch (Throwable e)
+            {
+                if (!(e instanceof IllegalArgumentException))
+                {
+                    fail("Expecting only IllegalArgumentException, got:" + e.getMessage(), e);
+                }
+            }
+        }
+
+        {
+            // Test upper limit, should not throw exception.
+            try
+            {
+                new BodyPartID(4294967295L);
+            }
+            catch (Throwable t)
+            {
+                fail("Unexpected exception: " + t.getMessage(), t);
+            }
+
+            // Test above upper range
+            try
+            {
+                new BodyPartID(4294967296L);
+                fail("Expecting IllegalArgumentException because of outside upper range");
+            }
+            catch (Throwable e)
+            {
+                if (!(e instanceof IllegalArgumentException))
+                {
+                    fail("Expecting only IllegalArgumentException, got:" + e.getMessage(), e);
+                }
+            }
+        }
+    }
+
+    public String getName()
+    {
+        return "BodyPartIDTest";
+    }
+
+    public static void main(String[] args)
+        throws Exception
+    {
+        runTest(new BodyPartIDTest());
+    }
+}
+
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartListTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartListTest.java
new file mode 100644
index 0000000..9feed1f
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartListTest.java
@@ -0,0 +1,71 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Random;
+
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.BodyPartList;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+/**
+ * Test the creation of BodyPartListTest and encoding and decoding.
+ */
+public class BodyPartListTest
+    extends SimpleTest
+{
+
+    public void performTest()
+        throws Exception
+    {
+        Random rand = new Random();
+        {
+            BodyPartID[] bpid = new BodyPartID[Math.abs(rand.nextInt()) % 20];
+            for (int t = 0; t < bpid.length; t++)
+            {
+                bpid[t] = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+            }
+            BodyPartList bpl = new BodyPartList(bpid);
+            DERSequence _bpl = (DERSequence)bpl.toASN1Primitive();
+            byte[] b = bpl.getEncoded();
+
+            //
+            // Decode and compare results.
+            //
+
+            BodyPartList resList = BodyPartList.getInstance(b);
+            DERSequence _resList = (DERSequence)resList.toASN1Primitive();
+
+            isEquals(_bpl.size(), _resList.size());
+
+            for (int j = 0; j < _bpl.size(); j++)
+            {
+                isEquals(_resList.getObjectAt(j), _bpl.getObjectAt(j));
+            }
+        }
+        {
+            //
+            // Compare when same thing instantiated via different constructors.
+            //
+
+            BodyPartID bpid = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+            BodyPartList bpidList = new BodyPartList(bpid); // Single entry constructor.
+            BodyPartList resList = new BodyPartList(new BodyPartID[]{bpid}); // Array constructor.
+
+            DERSequence _bpidList = (DERSequence)bpidList.toASN1Primitive();
+            DERSequence _resList = (DERSequence)resList.toASN1Primitive();
+
+            isEquals(_bpidList, _resList);
+        }
+    }
+
+    public String getName()
+    {
+        return "BodyPartListTest";
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new BodyPartListTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartPathTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartPathTest.java
new file mode 100644
index 0000000..f5fc24a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartPathTest.java
@@ -0,0 +1,69 @@
+package org.bouncycastle.asn1.test;
+
+
+import java.util.Random;
+
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.BodyPartPath;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class BodyPartPathTest
+    extends SimpleTest
+{
+
+    public void performTest()
+        throws Exception
+    {
+        Random rand = new Random();
+        {
+            BodyPartID[] bpid = new BodyPartID[Math.abs(rand.nextInt()) % 20];
+            for (int t = 0; t < bpid.length; t++)
+            {
+                bpid[t] = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+            }
+            BodyPartPath bpp = new BodyPartPath(bpid);
+            DERSequence _bpp = (DERSequence)bpp.toASN1Primitive();
+            byte[] b = bpp.getEncoded();
+
+            //
+            // Decode and compare results.
+            //
+
+            BodyPartPath resList = BodyPartPath.getInstance(b);
+            DERSequence _resList = (DERSequence)resList.toASN1Primitive();
+
+            isEquals(_bpp.size(), _resList.size());
+
+            for (int j = 0; j < _bpp.size(); j++)
+            {
+                isEquals(_resList.getObjectAt(j), _bpp.getObjectAt(j));
+            }
+        }
+        {
+            //
+            // Compare when same thing instantiated via different constructors.
+            //
+
+            BodyPartID bpid = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+            BodyPartPath bpidList = new BodyPartPath(bpid); // Single entry constructor.
+            BodyPartPath resList = new BodyPartPath(new BodyPartID[]{bpid}); // Array constructor.
+
+            DERSequence _bpidList = (DERSequence)bpidList.toASN1Primitive();
+            DERSequence _resList = (DERSequence)resList.toASN1Primitive();
+
+            isEquals(_bpidList, _resList);
+        }
+    }
+
+    public String getName()
+    {
+        return "BodyPartPathTest";
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new BodyPartPathTest());
+    }
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartReferenceTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartReferenceTest.java
new file mode 100644
index 0000000..5a56f00
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/BodyPartReferenceTest.java
@@ -0,0 +1,79 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Random;
+
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.BodyPartPath;
+import org.bouncycastle.asn1.cmc.BodyPartReference;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class BodyPartReferenceTest
+    extends SimpleTest
+{
+
+    public String getName()
+    {
+        return "BodyPartReferenceTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        Random rand = new Random();
+        BodyPartReference ch0 = null;
+        BodyPartReference ch1 = null;
+        {
+            // Choice 1
+            BodyPartID id = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+
+            ch0 = new BodyPartReference(id);
+            byte[] b = ch0.getEncoded();
+
+            BodyPartReference brRes = BodyPartReference.getInstance(b);
+            isEquals(brRes, ch0);
+        }
+
+        {
+            // Choice 2
+
+            BodyPartID[] bpid = new BodyPartID[Math.abs(rand.nextInt()) % 20];
+            for (int t = 0; t < bpid.length; t++)
+            {
+                bpid[t] = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+            }
+
+            ch1 = new BodyPartReference(new BodyPartPath(bpid));
+            byte[] b = ch1.getEncoded();
+
+            BodyPartReference brRes = BodyPartReference.getInstance(b);
+            isEquals(brRes, ch1);
+        }
+
+
+        {
+            // Test choice alternatives are not equal.
+            BodyPartID id = new BodyPartID(Math.abs(rand.nextLong() % 4294967295L));
+
+            ch0 = new BodyPartReference(id);
+            ch1 = new BodyPartReference(new BodyPartPath(id));
+
+            try
+            {
+                isEquals(ch0, ch1);
+                fail("Must not be equal.");
+            }
+            catch (Throwable t)
+            {
+                // Ignored
+            }
+        }
+
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new BodyPartReferenceTest());
+    }
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCCertificationRequestTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCCertificationRequestTest.java
new file mode 100644
index 0000000..57e23b4
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCCertificationRequestTest.java
@@ -0,0 +1,83 @@
+package org.bouncycastle.asn1.test;
+
+import java.io.ByteArrayOutputStream;
+
+import org.bouncycastle.asn1.DEROutputStream;
+import org.bouncycastle.asn1.cmc.CertificationRequest;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class CMCCertificationRequestTest
+    extends SimpleTest
+{
+    byte[]    req1 = Base64.decode(
+                "MIHoMIGTAgEAMC4xDjAMBgNVBAMTBVRlc3QyMQ8wDQYDVQQKEwZBbmFUb20xCzAJBgNVBAYTAlNF"
+            +   "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALlEt31Tzt2MlcOljvacJgzQVhmlMoqAOgqJ9Pgd3Gux"
+            +   "Z7/WcIlgW4QCB7WZT21O1YoghwBhPDMcNGrHei9kHQkCAwEAAaAAMA0GCSqGSIb3DQEBBQUAA0EA"
+            +   "NDEI4ecNtJ3uHwGGlitNFq9WxcoZ0djbQJ5hABMotav6gtqlrwKXY2evaIrsNwkJtNdwwH18aQDU"
+            +   "KCjOuBL38Q==");
+
+    byte[]    req2 = Base64.decode(
+               "MIIB6TCCAVICAQAwgagxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRQwEgYDVQQH"
+            +  "EwtTYW50YSBDbGFyYTEMMAoGA1UEChMDQUJCMVEwTwYDVQQLHEhQAAAAAAAAAG8AAAAAAAAAdwAA"
+            +  "AAAAAABlAAAAAAAAAHIAAAAAAAAAIAAAAAAAAABUAAAAAAAAABxIAAAAAAAARAAAAAAAAAAxDTAL"
+            +  "BgNVBAMTBGJsdWUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANETRZ+6occCOrFxNhfKIp4C"
+            +  "mMkxwhBNb7TnnahpbM9O0r4hrBPcfYuL7u9YX/jN0YNUP+/CiT39HhSe/bikaBPDEyNsl988I8vX"
+            +  "piEdgxYq/+LTgGHbjRsRYCkPtmzwBbuBldNF8bV7pu0v4UScSsExmGqqDlX1TbPU8KkPU1iTAgMB"
+            +  "AAGgADANBgkqhkiG9w0BAQQFAAOBgQAFbrs9qUwh93CtETk7DeUD5HcdCnxauo1bck44snSV6MZV"
+            +  "OCIGaYu1501kmhEvAtVVRr6SEHwimfQDDIjnrWwYsEr/DT6tkTZAbfRd3qUu3iKjT0H0vlUZp0hJ"
+            +  "66mINtBM84uZFBfoXiWY8M3FuAnGmvy6ah/dYtJorTxLKiGkew==");
+
+    public String getName()
+    {
+        return "CMCCertificationRequestTest";
+    }
+    
+    public void certReqTest(
+        String  testName,
+        byte[]  req)
+        throws Exception
+    {
+        CertificationRequest    r = CertificationRequest.getInstance(req);
+
+        ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
+        DEROutputStream          dOut = new DEROutputStream(bOut);
+
+        dOut.writeObject(r.toASN1Primitive());
+
+        byte[]                    bytes = bOut.toByteArray();
+
+        if (bytes.length != req.length)
+        {
+            fail(testName + " failed length test");
+        }
+
+        for (int i = 0; i != req.length; i++)
+        {
+            if (bytes[i] != req[i])
+            {
+                fail(testName + " failed comparison test");
+            }
+        }
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        certReqTest("req1", req1);
+        certReqTest("req2", req2);
+
+        CertificationRequest    a = CertificationRequest.getInstance(req1);
+        CertificationRequest    b = new CertificationRequest(a.getSubject(), a.getSubjectPublicKeyAlgorithm(), a.getSubjectPublicKey(), a.getAttributes(), a.getSignatureAlgorithm(), a.getSignature());
+
+        isTrue(Arrays.areEqual(a.getEncoded(), b.getEncoded()));
+    }
+
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new CMCCertificationRequestTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCFailInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCFailInfoTest.java
new file mode 100644
index 0000000..d134a8c
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCFailInfoTest.java
@@ -0,0 +1,96 @@
+package org.bouncycastle.asn1.test;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.cmc.CMCFailInfo;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class CMCFailInfoTest
+    extends SimpleTest
+{
+
+    // From Page 68, CMC: Structures RFC 5272
+    private static Object[][] types = new Object[][]{
+        {"badAlg", new Long(0L) },
+        {"badMessageCheck", new Long(1L) },
+        {"badRequest", new Long(2L) },
+        {"badTime", new Long(3L) },
+        {"badCertId", new Long(4L) },
+        {"unsupportedExt", new Long(5L) },
+        {"mustArchiveKeys", new Long(6L) },
+        {"badIdentity", new Long(7L) },
+        {"popRequired", new Long(8L) },
+        {"popFailed", new Long(9L) },
+        {"noKeyReuse", new Long(10L) },
+        {"internalCAError", new Long(11L) },
+        {"tryLater", new Long(12L) },
+        {"authDataFail", new Long(13L)}
+    };
+    private static Map typesMap = new HashMap();
+
+    static
+    {
+        for (int t = 0; t < types.length; t++)
+        {
+            typesMap.put(types[t][1], types[t][0]);
+        }
+    }
+
+
+    public void performTest()
+        throws Exception
+    {
+
+        //
+        // Check that range has changed and this test has not been updated or vice versa.
+        // It is intended to act as a double check on the addition of CMCFailInfo presets by
+        // requiring this test to be updated equally to ensure it will pass.
+        //
+
+        Field rangeField = CMCFailInfo.class.getDeclaredField("range");
+        rangeField.setAccessible(true);
+
+        Map range = (Map)rangeField.get(null);
+
+        isEquals("Range in CMCFailInfo does not match test data.",range.size(), types.length);
+
+        for (Iterator rangeKeys = range.keySet().iterator(); rangeKeys.hasNext(); )
+        {   Object j = rangeKeys.next();
+            if (!typesMap.containsKey(new Long(((ASN1Integer)j).getValue().longValue())))  {
+                fail("The 'range' map in CMCFailInfo contains a value not in the test ('typesMap') map, value was: "+j.toString());
+            }
+        }
+
+
+        for (Iterator typeKeys = typesMap.keySet().iterator(); typeKeys.hasNext(); )
+        {   Object j = typeKeys.next();
+            if (!range.containsKey(new ASN1Integer(((Long)j).longValue())))  {
+                fail("The 'typesMap' map in CMCFailInfoTest contains a value not in the CMCFailInfo ('range') map, value was: "+j.toString());
+            }
+        }
+
+
+        //
+        // Test encoding / decoding
+        //
+
+        byte[] b = CMCFailInfo.authDataFail.getEncoded();
+        CMCFailInfo r = CMCFailInfo.getInstance(b);
+        isEquals(r,CMCFailInfo.authDataFail);
+
+    }
+
+    public String getName()
+    {
+        return "CMCFailInfoTest";
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new CMCFailInfoTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCPublicationInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCPublicationInfoTest.java
new file mode 100644
index 0000000..b6682f2
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCPublicationInfoTest.java
@@ -0,0 +1,70 @@
+package org.bouncycastle.asn1.test;
+
+
+import java.security.SecureRandom;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.DERNull;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.CMCPublicationInfo;
+import org.bouncycastle.asn1.crmf.PKIPublicationInfo;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class CMCPublicationInfoTest
+    extends SimpleTest
+{
+
+    public void performTest()
+        throws Exception
+    {
+        SecureRandom secureRandom = new SecureRandom();
+
+        //
+        // Test encode and decode.
+        //
+
+        // Not a real AlgorithmIdentifier
+        AlgorithmIdentifier testIA = new AlgorithmIdentifier(new ASN1ObjectIdentifier("1.1.2.3"), DERNull.INSTANCE);
+        byte[][] hashes = new byte[5][64];
+        for(int i =0; i<hashes.length; i++) {
+            secureRandom.nextBytes(hashes[i]);
+        }
+
+        PKIPublicationInfo pinfo = PKIPublicationInfo.getInstance(
+            new DERSequence(
+                new ASN1Encodable[]{new ASN1Integer(1L),  new DERSequence(new ASN1Integer(0L)) })
+        );
+
+        CMCPublicationInfo cmcPublicationInfo = new CMCPublicationInfo(testIA,hashes,pinfo);
+        byte[] b = cmcPublicationInfo.getEncoded();
+        CMCPublicationInfo resCmcPublicationInfo = CMCPublicationInfo.getInstance(b);
+
+        isEquals(resCmcPublicationInfo,cmcPublicationInfo);
+
+        //
+        // Test fail on small sequence.
+        //
+
+        try
+        {
+            CMCPublicationInfo.getInstance(new DERSequence(new ASN1Encodable[]{testIA}));
+            fail("Expecting exception.");
+        } catch (Exception t) {
+            isEquals("Wrong exception: "+t.getMessage(), t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+
+    public String getName()
+    {
+        return "CMCPublicationInfo";
+    }
+
+    public static void main(String[] args) {
+        runTest(new CMCPublicationInfoTest());
+    }
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusInfoTest.java
new file mode 100644
index 0000000..3ace794
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusInfoTest.java
@@ -0,0 +1,115 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Date;
+
+import org.bouncycastle.asn1.DERGeneralizedTime;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CMCFailInfo;
+import org.bouncycastle.asn1.cmc.CMCStatus;
+import org.bouncycastle.asn1.cmc.CMCStatusInfo;
+import org.bouncycastle.asn1.cmc.CMCStatusInfoBuilder;
+import org.bouncycastle.asn1.cmc.PendInfo;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class CMCStatusInfoTest
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new CMCStatusInfoTest());
+    }
+
+    public String getName()
+    {
+        return "CMCStatusInfoTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        { // Without optional status String
+
+             CMCStatusInfoBuilder bldr =
+                 new CMCStatusInfoBuilder(CMCStatus.confirmRequired, new BodyPartID(10));
+
+             CMCStatusInfo cmsInfo = bldr.build();
+
+             isTrue("Has statusString", null == cmsInfo.getStatusString());
+             isEquals("Has other info", false, cmsInfo.hasOtherInfo());
+
+             byte[] b = cmsInfo.getEncoded();
+             CMCStatusInfo res = CMCStatusInfo.getInstance(b);
+
+             // Same
+             isEquals("CMCStatus with no optional part",cmsInfo, res);
+
+             isEquals("Has other info", false, res.hasOtherInfo());
+
+         }
+
+        { // Without optional other info.
+
+            CMCStatusInfoBuilder bldr =
+                new CMCStatusInfoBuilder(CMCStatus.confirmRequired, new BodyPartID(10)).setStatusString("Cats");
+
+            CMCStatusInfo cmsInfo = bldr.build();
+
+            isEquals("Has other info", false, cmsInfo.hasOtherInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfo res = CMCStatusInfo.getInstance(b);
+
+            // Same
+            isEquals("CMCStatus with no optional part",cmsInfo, res);
+
+            isEquals("Has other info", false, res.hasOtherInfo());
+
+        }
+
+
+        { // With optional info: PendInfo
+            CMCStatusInfoBuilder bldr =
+                new CMCStatusInfoBuilder(CMCStatus.confirmRequired, new BodyPartID(10))
+                    .setStatusString("Cats")
+                    .setOtherInfo(new PendInfo(Strings.toByteArray("fish"), new DERGeneralizedTime(new Date())));
+
+            CMCStatusInfo cmsInfo = bldr.build();
+
+            isEquals("Must have other info", true, cmsInfo.hasOtherInfo());
+            isEquals("Other is NOT fail info", false, cmsInfo.getOtherInfo().isFailInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfo res = CMCStatusInfo.getInstance(b);
+
+            isEquals("With optional info: PendInfo",cmsInfo, res);
+
+            isEquals("Must have other info", true, res.hasOtherInfo());
+            isEquals("Other is NOT fail info", false, res.getOtherInfo().isFailInfo());
+        }
+
+
+        { // With optional info: CMCFailInfo
+            CMCStatusInfoBuilder bldr =
+                new CMCStatusInfoBuilder(CMCStatus.confirmRequired, new BodyPartID(10))
+                    .setStatusString("Cats")
+                    .setOtherInfo(CMCFailInfo.authDataFail);
+
+            CMCStatusInfo cmsInfo = bldr.build();
+
+            isEquals("Must have other info", true, cmsInfo.hasOtherInfo());
+            isEquals("Other is fail info", true, cmsInfo.getOtherInfo().isFailInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfo res = CMCStatusInfo.getInstance(b);
+
+            isEquals("With optional info: CMCFailInfo",cmsInfo, res);
+
+            isEquals("Must have other info", true, res.hasOtherInfo());
+            isEquals("Other is fail info", true, res.getOtherInfo().isFailInfo());
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusInfoV2Test.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusInfoV2Test.java
new file mode 100644
index 0000000..b5c396d
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusInfoV2Test.java
@@ -0,0 +1,141 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Date;
+
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.DERGeneralizedTime;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CMCFailInfo;
+import org.bouncycastle.asn1.cmc.CMCStatus;
+import org.bouncycastle.asn1.cmc.CMCStatusInfoV2;
+import org.bouncycastle.asn1.cmc.CMCStatusInfoV2Builder;
+import org.bouncycastle.asn1.cmc.ExtendedFailInfo;
+import org.bouncycastle.asn1.cmc.PendInfo;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class CMCStatusInfoV2Test
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new CMCStatusInfoV2Test());
+    }
+
+    public String getName()
+    {
+        return "CMCStatusInfoV2Test";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        { // Without optional status String
+
+            CMCStatusInfoV2Builder bldr =
+                new CMCStatusInfoV2Builder(CMCStatus.confirmRequired, new BodyPartID(10));
+
+            CMCStatusInfoV2 cmsInfo = bldr.build();
+
+            isTrue("Has statusString", null == cmsInfo.getStatusString());
+            isEquals("Has other info", false, cmsInfo.hasOtherInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfoV2 res = CMCStatusInfoV2.getInstance(b);
+
+            // Same
+            isEquals("CMCStatus with no optional part", cmsInfo, res);
+
+            isEquals("Has other info", false, res.hasOtherInfo());
+
+        }
+
+        { // Without optional other info.
+
+            CMCStatusInfoV2Builder bldr =
+                new CMCStatusInfoV2Builder(CMCStatus.confirmRequired, new BodyPartID(10)).setStatusString("Cats");
+
+            CMCStatusInfoV2 cmsInfo = bldr.build();
+
+            isEquals("Has other info", false, cmsInfo.hasOtherInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfoV2 res = CMCStatusInfoV2.getInstance(b);
+
+            // Same
+            isEquals("CMCStatus with no optional part", cmsInfo, res);
+
+            isEquals("Has other info", false, res.hasOtherInfo());
+
+        }
+
+
+        { // With optional info: PendInfo
+            CMCStatusInfoV2Builder bldr =
+                new CMCStatusInfoV2Builder(CMCStatus.confirmRequired, new BodyPartID(10))
+                    .setStatusString("Cats")
+                    .setOtherInfo(new PendInfo(Strings.toByteArray("fish"), new DERGeneralizedTime(new Date())));
+
+            CMCStatusInfoV2 cmsInfo = bldr.build();
+
+            isEquals("Must have other info", true, cmsInfo.hasOtherInfo());
+            isEquals("Other is NOT fail info", false, cmsInfo.getOtherStatusInfo().isFailInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfoV2 res = CMCStatusInfoV2.getInstance(b);
+
+            isEquals("With optional info: PendInfo", cmsInfo, res);
+
+            isEquals("Must have other info", true, res.hasOtherInfo());
+            isEquals("Other is NOT fail info", false, res.getOtherStatusInfo().isFailInfo());
+        }
+
+
+        { // With optional info: CMCFailInfo
+            CMCStatusInfoV2Builder bldr =
+                new CMCStatusInfoV2Builder(CMCStatus.confirmRequired, new BodyPartID(10))
+                    .setStatusString("Cats")
+                    .setOtherInfo(CMCFailInfo.authDataFail);
+
+            CMCStatusInfoV2 cmsInfo = bldr.build();
+
+            isEquals("Must have other info", true, cmsInfo.hasOtherInfo());
+            isEquals("Other is fail info", true, cmsInfo.getOtherStatusInfo().isFailInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfoV2 res = CMCStatusInfoV2.getInstance(b);
+
+            isEquals("With optional info: CMCFailInfo", cmsInfo, res);
+
+            isEquals("Must have other info", true, res.hasOtherInfo());
+            isEquals("Other is fail info", true, res.getOtherStatusInfo().isFailInfo());
+        }
+
+
+        { // With optional info: ExtendedFailInfo
+            CMCStatusInfoV2Builder bldr =
+                new CMCStatusInfoV2Builder(CMCStatus.confirmRequired, new BodyPartID(10))
+                    .setStatusString("Cats")
+                    .setOtherInfo(new ExtendedFailInfo(PKCSObjectIdentifiers.bagtypes, new DEROctetString("fish".getBytes())));
+
+            CMCStatusInfoV2 cmsInfo = bldr.build();
+
+            isEquals("Must have other info", true, cmsInfo.hasOtherInfo());
+            isEquals("Other is extended fail info", true, cmsInfo.getOtherStatusInfo().isExtendedFailInfo());
+
+            byte[] b = cmsInfo.getEncoded();
+            CMCStatusInfoV2 res = CMCStatusInfoV2.getInstance(b);
+
+            isEquals("With optional info: ExtendedFailInfo", cmsInfo, res);
+
+            isEquals("Must have other info", true, res.hasOtherInfo());
+            isEquals("Other is extended fail info", true, res.getOtherStatusInfo().isExtendedFailInfo());
+        }
+
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusTest.java
new file mode 100644
index 0000000..3d17e8c
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCStatusTest.java
@@ -0,0 +1,96 @@
+package org.bouncycastle.asn1.test;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.cmc.CMCStatus;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class CMCStatusTest
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new CMCStatusTest());
+    }
+
+    public String getName()
+    {
+        return "CMCStatusTest";
+    }
+
+    // From Page 68, CMC: Structures RFC 5272
+    private static Object[][] types = new Object[][]{
+        {"success", new Long(0L) },
+        // -- reserved            (1),
+        {"failed", new Long(2L) },
+        {"pending", new Long(3L) },
+        {"noSupport", new Long(4L) },
+        {"confirmRequired", new Long(5L) },
+        {"popRequired", new Long(6L) },
+        {"partial", new Long(7L) }
+    };
+    private static Map typesMap = new HashMap();
+
+    static
+    {
+        for (int t = 0; t < types.length; t++)
+        {
+            typesMap.put(types[t][1], types[t][0]);
+        }
+    }
+
+
+    public void performTest()
+        throws Exception
+    {
+
+        //
+        // Check that range has changed and this test has not been updated or vice versa.
+        // It is intended to act as a double check on the addition of CMCStatus presets by
+        // requiring this test to be updated equally to ensure it will pass.
+        //
+
+        Field rangeField = CMCStatus.class.getDeclaredField("range");
+        rangeField.setAccessible(true);
+
+        Map range = (Map)rangeField.get(null);
+
+        isEquals("Range in CMCStatus does not match test data.", range.size(), types.length);
+
+        for (Iterator rangeKeys = range.keySet().iterator(); rangeKeys.hasNext(); )
+        {
+            Object j = rangeKeys.next();
+            if (!typesMap.containsKey(new Long(((ASN1Integer)j).getValue().longValue())))
+            {
+                fail("The 'range' map in CMCStatus contains a value not in the test ('typesMap') map, value was: " + j.toString());
+            }
+        }
+
+
+        for (Iterator typeKeys = typesMap.keySet().iterator(); typeKeys.hasNext(); )
+        {
+            Object j = typeKeys.next();
+            if (!range.containsKey(new ASN1Integer(((Long)j).longValue())))
+            {
+                fail("The 'typesMap' map in CMCStatusTest contains a value not in the CMCStatus ('range') map, value was: " + j.toString());
+            }
+        }
+
+
+        //
+        // Test encoding / decoding
+        //
+
+        byte[] b = CMCStatus.failed.getEncoded();
+        CMCStatus r = CMCStatus.getInstance(b);
+        isEquals(r, CMCStatus.failed);
+
+    }
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCUnsignedDataTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCUnsignedDataTest.java
new file mode 100644
index 0000000..a1095ae
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/CMCUnsignedDataTest.java
@@ -0,0 +1,63 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.BodyPartPath;
+import org.bouncycastle.asn1.cmc.CMCUnsignedData;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class CMCUnsignedDataTest
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new CMCUnsignedDataTest());
+    }
+
+    public String getName()
+    {
+        return "CMCUnsignedDataTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        // Encode then decode
+        CMCUnsignedData data = new CMCUnsignedData(new BodyPartPath(new BodyPartID(10L)), PKCSObjectIdentifiers.certBag, new DEROctetString("Cats".getBytes()));
+        byte[] b = data.getEncoded();
+        CMCUnsignedData result = CMCUnsignedData.getInstance(data);
+
+        isEquals(data.getBodyPartPath(), result.getBodyPartPath());
+        isEquals(data.getIdentifier(), result.getIdentifier());
+        isEquals(data.getContent(), result.getContent());
+
+        // Sequence length must be 3
+
+        try
+        {
+            CMCUnsignedData.getInstance(new DERSequence(new ASN1Integer(10)));
+            fail("Must fail, sequence must be 3");
+        }
+        catch (Exception ex)
+        {
+            isEquals(ex.getClass(), IllegalArgumentException.class);
+        }
+
+        try
+        {
+            CMCUnsignedData.getInstance(new DERSequence(new ASN1Encodable[]{new ASN1Integer(10), new ASN1Integer(10), new ASN1Integer(10), new ASN1Integer(10)}));
+            fail("Must fail, sequence must be 3");
+        }
+        catch (Exception ex)
+        {
+            isEquals(ex.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/ControlsProcessedTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/ControlsProcessedTest.java
new file mode 100644
index 0000000..8434023
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/ControlsProcessedTest.java
@@ -0,0 +1,52 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.BodyPartReference;
+import org.bouncycastle.asn1.cmc.ControlsProcessed;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class ControlsProcessedTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new ControlsProcessedTest());
+    }
+
+    public String getName()
+    {
+        return "ControlsProcessedTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        ControlsProcessed cp = new ControlsProcessed(new BodyPartReference[]{new BodyPartReference(new BodyPartID(12L)), new BodyPartReference(new BodyPartID(14L))});
+        byte[] b = cp.getEncoded();
+        ControlsProcessed cpResult = ControlsProcessed.getInstance(b);
+        isTrue(cpResult.getBodyList().length == cp.getBodyList().length);
+        isEquals(cpResult.getBodyList()[0], cp.getBodyList()[0]);
+        isEquals(cpResult.getBodyList()[1], cp.getBodyList()[1]);
+
+        //
+        // Incorrect sequence size.
+        //
+
+        try
+        {
+            ControlsProcessed.getInstance(new DERSequence(
+                new ASN1Encodable[]{new ASN1Integer(12L), new DERUTF8String("Monkeys")
+                }));
+            fail("Must accept only sequence length of 1");
+        }
+        catch (Throwable t)
+        {
+            isEquals(t.getClass(), IllegalArgumentException.class);
+        }
+    }
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/DecryptedPOPTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/DecryptedPOPTest.java
new file mode 100644
index 0000000..cf04729
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/DecryptedPOPTest.java
@@ -0,0 +1,45 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.DecryptedPOP;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class DecryptedPOPTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new DecryptedPOPTest());
+    }
+
+    public String getName()
+    {
+        return "DecryptedPOPTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        AlgorithmIdentifier algId = new AlgorithmIdentifier(new ASN1ObjectIdentifier("1.9.8.7.6")); // Not real!
+        DecryptedPOP pop = new DecryptedPOP(new BodyPartID(10L), algId, "cats".getBytes());
+        byte[] b = pop.getEncoded();
+        DecryptedPOP popResult = DecryptedPOP.getInstance(b);
+        isEquals("Bodypart id", popResult.getBodyPartID(), pop.getBodyPartID());
+        isTrue("The POP", Arrays.areEqual(popResult.getThePOP(), pop.getThePOP()));
+        isEquals("POP Result", popResult.getThePOPAlgID(), pop.getThePOPAlgID());
+
+        try
+        {
+            DecryptedPOP.getInstance(new DERSequence(new BodyPartID(10L)));
+            fail("Sequence must be 3 elements long");
+        }
+        catch (Throwable t)
+        {
+            isEquals(t.getClass(), IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/EncryptedPOPTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/EncryptedPOPTest.java
new file mode 100644
index 0000000..df130f7
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/EncryptedPOPTest.java
@@ -0,0 +1,69 @@
+package org.bouncycastle.asn1.test;
+
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CertificationRequest;
+import org.bouncycastle.asn1.cmc.EncryptedPOP;
+import org.bouncycastle.asn1.cmc.TaggedCertificationRequest;
+import org.bouncycastle.asn1.cmc.TaggedRequest;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class EncryptedPOPTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "EncryptedPOPTest";
+    }
+
+    private byte[] req1 = Base64.decode(
+        "MIHoMIGTAgEAMC4xDjAMBgNVBAMTBVRlc3QyMQ8wDQYDVQQKEwZBbmFUb20xCzAJBgNVBAYTAlNF"
+            + "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALlEt31Tzt2MlcOljvacJgzQVhmlMoqAOgqJ9Pgd3Gux"
+            + "Z7/WcIlgW4QCB7WZT21O1YoghwBhPDMcNGrHei9kHQkCAwEAAaAAMA0GCSqGSIb3DQEBBQUAA0EA"
+            + "NDEI4ecNtJ3uHwGGlitNFq9WxcoZ0djbQJ5hABMotav6gtqlrwKXY2evaIrsNwkJtNdwwH18aQDU"
+            + "KCjOuBL38Q==");
+
+    public void performTest()
+        throws Exception
+    {
+        // All Object Identifiers are not real!
+        TaggedRequest taggedRequest = new TaggedRequest(new TaggedCertificationRequest(new BodyPartID(10L), CertificationRequest.getInstance(req1)));
+        ContentInfo cms = new ContentInfo(new ASN1ObjectIdentifier("1.2.3"), new ASN1Integer(12L));
+        AlgorithmIdentifier thePopID = new AlgorithmIdentifier(new ASN1ObjectIdentifier("2.2.5.2"));
+        AlgorithmIdentifier whitenessID = new AlgorithmIdentifier(new ASN1ObjectIdentifier("1.2.5.2.5"));
+        byte[] whiteness = "Fish and Chips".getBytes();
+
+        EncryptedPOP ep = new EncryptedPOP(taggedRequest, cms, thePopID, whitenessID, whiteness);
+        byte[] b = ep.getEncoded();
+        EncryptedPOP epResult = EncryptedPOP.getInstance(b);
+
+        isEquals("TaggedRequest", epResult.getRequest(), taggedRequest);
+        isEquals("ContentInfo (cms)", epResult.getCms(), cms);
+        isEquals("Pop Algorithm ID", epResult.getThePOPAlgID(), thePopID);
+        isEquals("Whiteness ID", epResult.getWitnessAlgID(), whitenessID);
+        isTrue("Whiteness", areEqual(epResult.getWitness(), whiteness));
+
+        // Test sequence length
+
+        try
+        {
+            EncryptedPOP.getInstance(new DERSequence(new ASN1Integer(1L)));
+            fail("Sequence must be 5 items long.");
+        }
+        catch (Throwable t)
+        {
+            isEquals(t.getClass(), IllegalArgumentException.class);
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new EncryptedPOPTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/ExtendedFailInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/ExtendedFailInfoTest.java
new file mode 100644
index 0000000..b55b51d
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/ExtendedFailInfoTest.java
@@ -0,0 +1,48 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.ExtendedFailInfo;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class ExtendedFailInfoTest
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new ExtendedFailInfoTest());
+    }
+
+    public String getName()
+    {
+        return "ExtendedFailInfo";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        // OID not real
+        ExtendedFailInfo extendedFailInfo = new ExtendedFailInfo(
+            new ASN1ObjectIdentifier("1.2.3.2"),
+            new ASN1Integer(10L));
+        byte[] b = extendedFailInfo.getEncoded();
+        ExtendedFailInfo extendedFailInfoResult = ExtendedFailInfo.getInstance(b);
+
+        isEquals("failInfoOID", extendedFailInfo.getFailInfoOID(), extendedFailInfoResult.getFailInfoOID());
+        isEquals("failInfoValue", extendedFailInfo.getFailInfoValue(), extendedFailInfoResult.getFailInfoValue());
+
+        try
+        {
+            ExtendedFailInfo.getInstance(new DERSequence(new ASN1Integer(10L)));
+            fail("Sequence must be 2 elements.");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Wrong exception type",t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/ExtensionReqTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/ExtensionReqTest.java
new file mode 100644
index 0000000..a54c4da
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/ExtensionReqTest.java
@@ -0,0 +1,39 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Boolean;
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.cmc.ExtensionReq;
+import org.bouncycastle.asn1.x509.Extension;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class ExtensionReqTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "ExtensionReqTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        ExtensionReq extensionReq = new ExtensionReq(
+            new Extension(
+                new ASN1ObjectIdentifier("1.2.4"), ASN1Boolean.FALSE, new DEROctetString("abcdef".getBytes())
+            ));
+        byte[] b = extensionReq.getEncoded();
+
+        ExtensionReq extensionReqResult = ExtensionReq.getInstance(b);
+
+        isEquals("Extensions", extensionReq.getExtensions()[0], extensionReqResult.getExtensions()[0]);
+
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new ExtensionReqTest());
+    }
+
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/GetCRLTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/GetCRLTest.java
new file mode 100644
index 0000000..eed531e
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/GetCRLTest.java
@@ -0,0 +1,122 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Date;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.GetCRL;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x500.X500NameBuilder;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.asn1.x509.ReasonFlags;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class GetCRLTest
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new GetCRLTest());
+    }
+
+    public String getName()
+    {
+        return "GetCRLTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+
+        {
+            X500NameBuilder builder = new X500NameBuilder(BCStyle.INSTANCE);
+            builder.addRDN(BCStyle.C, "AU");
+            X500Name name = new X500Name(builder.build().toString());
+
+            GetCRL crl = new GetCRL(
+                name,
+                new GeneralName(GeneralName.rfc822Name, "/"),
+                new ASN1GeneralizedTime(new Date()),
+                new ReasonFlags(ReasonFlags.affiliationChanged)
+            );
+
+            byte[] b = crl.getEncoded();
+
+            GetCRL crlResp = GetCRL.getInstance(b);
+
+            isEquals("IssuerName", crl.getIssuerName(), crlResp.getIssuerName());
+            isEquals("cRLName", crl.getcRLName(), crlResp.getcRLName());
+            isEquals("time", crl.getTime(), crlResp.getTime());
+            isEquals("reasons", crl.getReasons(), crlResp.getReasons());
+
+            try
+            {
+                GetCRL.getInstance(new DERSequence(new ASN1Encodable[0]));
+                fail("Must not accept sequence less than 1");
+            }
+            catch (Throwable t)
+            {
+                isEquals("", t.getClass(), IllegalArgumentException.class);
+            }
+
+            try
+            {
+                GetCRL.getInstance(new DERSequence(new ASN1Encodable[5]));
+                fail("Must not accept sequence larger than 5");
+            }
+            catch (Throwable t)
+            {
+                isEquals("", t.getClass(), IllegalArgumentException.class);
+            }
+        }
+
+        { // Permutate on options test all possible combinations.
+
+            X500NameBuilder builder = new X500NameBuilder(BCStyle.INSTANCE);
+            builder.addRDN(BCStyle.C, "AU");
+            X500Name name = new X500Name(builder.build().toString());
+            GeneralName generalName = null;
+            ASN1GeneralizedTime generalizedTime = null;
+            ReasonFlags flags = null;
+
+            for (int t = 0; t < 8; t++)
+            {
+                if ((t & 1) == 1)
+                {
+                    generalName = new GeneralName(GeneralName.rfc822Name, "/");
+                }
+                if ((t & 2) == 2)
+                {
+                    generalizedTime = new ASN1GeneralizedTime(new Date());
+                }
+
+                if ((t & 4) == 4)
+                {
+                    flags = new ReasonFlags(ReasonFlags.affiliationChanged);
+                }
+
+
+                GetCRL crl = new GetCRL(
+                    name,
+                    generalName,
+                    generalizedTime,
+                    flags
+                );
+
+                byte[] b = crl.getEncoded();
+
+                GetCRL crlResp = GetCRL.getInstance(b);
+
+                isEquals("IssuerName", crl.getIssuerName(), crlResp.getIssuerName());
+                isEquals("cRLName", crl.getcRLName(), crlResp.getcRLName());
+                isEquals("time", crl.getTime(), crlResp.getTime());
+                isEquals("reasons", crl.getReasons(), crlResp.getReasons());
+
+            }
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/GetCertTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/GetCertTest.java
new file mode 100644
index 0000000..1dd5e7e
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/GetCertTest.java
@@ -0,0 +1,41 @@
+package org.bouncycastle.asn1.test;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.GetCert;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class GetCertTest extends SimpleTest
+{
+    public static void main(String[] args) {
+        runTest(new GetCertTest());
+    }
+
+    public String getName()
+    {
+        return "GetCertTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        GetCert gs = new GetCert(new GeneralName(GeneralName.dNSName,"fish"),new BigInteger("109"));
+        byte[] b = gs.getEncoded();
+        GetCert gsResp = GetCert.getInstance(b);
+
+        isEquals("Issuer Name",gs.getIssuerName(), gsResp.getIssuerName());
+        isEquals("Serial Number",gs.getSerialNumber(), gsResp.getSerialNumber());
+
+        try {
+            GetCert.getInstance(new DERSequence(new ASN1Integer(1L)));
+            fail("Sequence must be length of 2");
+        } catch (Throwable t) {
+            isEquals("Wrong exception",t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/IdentityProofV2Test.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/IdentityProofV2Test.java
new file mode 100644
index 0000000..ced7443
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/IdentityProofV2Test.java
@@ -0,0 +1,52 @@
+package org.bouncycastle.asn1.test;
+
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.IdentityProofV2;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class IdentityProofV2Test
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new IdentityProofV2Test());
+    }
+
+    public String getName()
+    {
+        return "IdentityProofV2";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        IdentityProofV2 proofV2 = new IdentityProofV2(
+            new AlgorithmIdentifier(PKCSObjectIdentifiers.encryptionAlgorithm, new ASN1Integer(10L)),
+            new AlgorithmIdentifier(PKCSObjectIdentifiers.bagtypes, new ASN1Integer(10L)),
+            "Cats".getBytes()
+        );
+
+        byte[] b = proofV2.getEncoded();
+        IdentityProofV2 proofV2Res = IdentityProofV2.getInstance(b);
+
+        isEquals("proofAldID", proofV2.getProofAlgID(), proofV2Res.getProofAlgID());
+        isEquals("macAlgId", proofV2.getMacAlgId(), proofV2Res.getMacAlgId());
+        isTrue("witness",  areEqual(proofV2.getWitness(), proofV2Res.getWitness()));
+
+
+        try
+        {
+            IdentityProofV2.getInstance(new DERSequence(new ASN1Encodable[0]));
+            fail("Sequence must be length of 3");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Exception incorrect", t.getClass(), IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/LraPopWitnessTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/LraPopWitnessTest.java
new file mode 100644
index 0000000..85a52b6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/LraPopWitnessTest.java
@@ -0,0 +1,42 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.LraPopWitness;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class LraPopWitnessTest
+    extends SimpleTest
+{
+
+    public static void main(String[] args)
+    {
+        runTest(new LraPopWitnessTest());
+    }
+
+    public String getName()
+    {
+        return "LraPopWitnessTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        LraPopWitness popWitness = new LraPopWitness(new BodyPartID(10L), new DERSequence(new ASN1Integer(20L)));
+        byte[] b = popWitness.getEncoded();
+        LraPopWitness popWitnessResult = LraPopWitness.getInstance(b);
+
+        isTrue("BodyIds", Arrays.areEqual(popWitness.getBodyIds(), popWitnessResult.getBodyIds()));
+        isEquals("PkiDataBody", popWitness.getPkiDataBodyid(), popWitnessResult.getPkiDataBodyid());
+
+        try {
+            LraPopWitness.getInstance(new DERSequence());
+            fail("Sequence length must be 2");
+        } catch (Throwable t) {
+            isEquals("Exception class",t.getClass(), IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/ModCertTemplateTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/ModCertTemplateTest.java
new file mode 100644
index 0000000..3c09b90
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/ModCertTemplateTest.java
@@ -0,0 +1,83 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERTaggedObject;
+import org.bouncycastle.asn1.DLSequence;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.BodyPartList;
+import org.bouncycastle.asn1.cmc.BodyPartPath;
+import org.bouncycastle.asn1.cmc.ModCertTemplate;
+import org.bouncycastle.asn1.crmf.CertTemplate;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class ModCertTemplateTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new ModCertTemplateTest());
+    }
+
+    public String getName()
+    {
+        return "ModCertTemplateTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+
+        BodyPartPath pkiDataReference = new BodyPartPath(new BodyPartID(10L));
+        BodyPartList certReferences = new BodyPartList(new BodyPartID(12L));
+        boolean replace = false;
+        CertTemplate certTemplate = CertTemplate.getInstance(new DLSequence(new DERTaggedObject(false, 1, new ASN1Integer(34L))));
+        {
+            ModCertTemplate modCertTemplate = new ModCertTemplate(
+                pkiDataReference,
+                certReferences,
+                replace,
+                certTemplate
+            );
+
+            byte[] b = modCertTemplate.getEncoded();
+
+            ModCertTemplate modCertTemplateResult = ModCertTemplate.getInstance(b);
+
+            isEquals("pkiDataReference", modCertTemplate.getPkiDataReference(), modCertTemplateResult.getPkiDataReference());
+            isEquals("certReference", modCertTemplate.getCertReferences(), modCertTemplateResult.getCertReferences());
+            isEquals("replacingFields", modCertTemplate.isReplacingFields(), modCertTemplateResult.isReplacingFields());
+            isEquals("certTemplate", modCertTemplate.getCertTemplate().getSerialNumber(), modCertTemplateResult.getCertTemplate().getSerialNumber());
+        }
+
+
+        {
+            // Test default 'result'
+            ModCertTemplate mct = ModCertTemplate.getInstance(new DERSequence(new ASN1Encodable[]{
+                pkiDataReference,
+                certReferences,
+                certTemplate
+            }));
+
+            isEquals("pkiDataReference", mct.getPkiDataReference(), pkiDataReference);
+            isEquals("certReference", mct.getCertReferences(), certReferences);
+            isEquals("DEFAULT TRUE on replacingFields", mct.isReplacingFields(), true);
+            isEquals("certTemplate", mct.getCertTemplate().getSerialNumber(), certTemplate.getSerialNumber());
+        }
+
+
+        try
+        {
+            ModCertTemplate.getInstance(new DERSequence());
+            fail("Sequence must be 3 or 4.");
+        }
+        catch (Throwable t)
+        {
+            isEquals(t.getClass(), IllegalArgumentException.class);
+        }
+
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/OtherMsgTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/OtherMsgTest.java
new file mode 100644
index 0000000..e212936
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/OtherMsgTest.java
@@ -0,0 +1,42 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.OtherMsg;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class OtherMsgTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new OtherMsgTest());
+    }
+
+    public String getName()
+    {
+        return "OtherMsgTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        OtherMsg otherMsg = new OtherMsg(new BodyPartID(10L), PKCSObjectIdentifiers.id_aa, new DERUTF8String("Cats"));
+        byte[] b = otherMsg.getEncoded();
+        OtherMsg otherMsgResult = OtherMsg.getInstance(b);
+
+        isEquals("bodyPartID", otherMsg.getBodyPartID(), otherMsgResult.getBodyPartID());
+        isEquals("otherMsgType", otherMsg.getOtherMsgType(), otherMsgResult.getOtherMsgType());
+        isEquals("otherMsgValue", otherMsg.getOtherMsgValue(), otherMsgResult.getOtherMsgValue());
+
+        try {
+            OtherMsg.getInstance(new DERSequence());
+            fail("Sequence should be 3 elements long.");
+        } catch (Throwable t) {
+            isEquals("Sequence size",t.getClass(), IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/OtherStatusInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/OtherStatusInfoTest.java
new file mode 100644
index 0000000..1034c51
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/OtherStatusInfoTest.java
@@ -0,0 +1,68 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Date;
+
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.cmc.CMCFailInfo;
+import org.bouncycastle.asn1.cmc.ExtendedFailInfo;
+import org.bouncycastle.asn1.cmc.OtherStatusInfo;
+import org.bouncycastle.asn1.cmc.PendInfo;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class OtherStatusInfoTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new OtherStatusInfoTest());
+    }
+
+    public String getName()
+    {
+        return "OtherStatusInfoTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        {
+            OtherStatusInfo ose = OtherStatusInfo.getInstance(CMCFailInfo.badCertId.toASN1Primitive());
+            byte[] b = ose.getEncoded();
+            OtherStatusInfo oseResult = OtherStatusInfo.getInstance(b);
+
+            isEquals("isFailInfo", oseResult.isFailInfo(), true);
+            isEquals("isPendInfo", oseResult.isPendingInfo(), false);
+            isEquals("isExtendedFailInfo", oseResult.isExtendedFailInfo(), false);
+
+            isEquals(ose, oseResult);
+        }
+
+        {
+            OtherStatusInfo ose = OtherStatusInfo.getInstance(new PendInfo("Fish".getBytes(), new ASN1GeneralizedTime(new Date())));
+            byte[] b = ose.getEncoded();
+            OtherStatusInfo oseResult = OtherStatusInfo.getInstance(b);
+
+            isEquals("isFailInfo", oseResult.isFailInfo(), false);
+            isEquals("isPendInfo", oseResult.isPendingInfo(), true);
+            isEquals("isExtendedFailInfo", oseResult.isExtendedFailInfo(), false);
+
+            isEquals(ose, oseResult);
+        }
+
+        {
+            OtherStatusInfo ose = OtherStatusInfo.getInstance(
+                new ExtendedFailInfo(PKCSObjectIdentifiers.canNotDecryptAny, new ASN1Integer(10L)));
+            byte[] b = ose.getEncoded();
+            OtherStatusInfo oseResult = OtherStatusInfo.getInstance(b);
+
+            isEquals("isFailInfo", oseResult.isFailInfo(), false);
+            isEquals("isPendInfo", oseResult.isPendingInfo(), false);
+            isEquals("isExtendedFailInfo", oseResult.isExtendedFailInfo(), true);
+
+            isEquals(ose, oseResult);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/PKIDataTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/PKIDataTest.java
new file mode 100644
index 0000000..6fd2339
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/PKIDataTest.java
@@ -0,0 +1,73 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERSet;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CertificationRequest;
+import org.bouncycastle.asn1.cmc.OtherMsg;
+import org.bouncycastle.asn1.cmc.PKIData;
+import org.bouncycastle.asn1.cmc.TaggedAttribute;
+import org.bouncycastle.asn1.cmc.TaggedCertificationRequest;
+import org.bouncycastle.asn1.cmc.TaggedContentInfo;
+import org.bouncycastle.asn1.cmc.TaggedRequest;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class PKIDataTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new PKIDataTest());
+    }
+
+    public String getName()
+    {
+        return "PKIDataTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+
+        byte[] req1 = Base64.decode(
+            "MIHoMIGTAgEAMC4xDjAMBgNVBAMTBVRlc3QyMQ8wDQYDVQQKEwZBbmFUb20xCzAJBgNVBAYTAlNF"
+                + "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALlEt31Tzt2MlcOljvacJgzQVhmlMoqAOgqJ9Pgd3Gux"
+                + "Z7/WcIlgW4QCB7WZT21O1YoghwBhPDMcNGrHei9kHQkCAwEAAaAAMA0GCSqGSIb3DQEBBQUAA0EA"
+                + "NDEI4ecNtJ3uHwGGlitNFq9WxcoZ0djbQJ5hABMotav6gtqlrwKXY2evaIrsNwkJtNdwwH18aQDU"
+                + "KCjOuBL38Q==");
+
+
+        PKIData pkiData = new PKIData(
+            new TaggedAttribute[]{new TaggedAttribute(new BodyPartID(10L), PKCSObjectIdentifiers.id_aa, new DERSet())},
+            new TaggedRequest[]{new TaggedRequest(new TaggedCertificationRequest(new BodyPartID(10L), CertificationRequest.getInstance(req1)))},
+            new TaggedContentInfo[]{new TaggedContentInfo(new BodyPartID(10L), new ContentInfo(PKCSObjectIdentifiers.id_aa_ets_commitmentType, new ASN1Integer(10L)))},
+            new OtherMsg[]{new OtherMsg(new BodyPartID(10L), PKCSObjectIdentifiers.pkcs_9, new ASN1Integer(10L))});
+
+
+        byte[] b = pkiData.getEncoded();
+
+        PKIData pkiDataResult = PKIData.getInstance(b);
+
+        isTrue("controlSequence", Arrays.areEqual(pkiData.getControlSequence(), pkiDataResult.getControlSequence()));
+        isTrue("reqSequence", Arrays.areEqual(pkiData.getReqSequence(), pkiDataResult.getReqSequence()));
+        isTrue("cmsSequence", Arrays.areEqual(pkiData.getCmsSequence(), pkiDataResult.getCmsSequence()));
+        isTrue("otherMsgSequence", Arrays.areEqual(pkiData.getOtherMsgSequence(), pkiDataResult.getOtherMsgSequence()));
+
+        try
+        {
+            PKIData.getInstance(new DERSequence());
+            fail("Sequence must be 4.");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Exception type", t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/PKIResponseTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/PKIResponseTest.java
new file mode 100644
index 0000000..7e5fe97
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/PKIResponseTest.java
@@ -0,0 +1,47 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERSet;
+import org.bouncycastle.asn1.DERUTF8String;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.OtherMsg;
+import org.bouncycastle.asn1.cmc.PKIResponse;
+import org.bouncycastle.asn1.cmc.TaggedAttribute;
+import org.bouncycastle.asn1.cmc.TaggedContentInfo;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class PKIResponseTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new PKIResponseTest());
+    }
+
+    public String getName()
+    {
+        return "PKIResponseTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        PKIResponse pkiResponse = PKIResponse.getInstance(new DERSequence(new ASN1Encodable[]{
+            new DERSequence(new TaggedAttribute(new BodyPartID(10L), PKCSObjectIdentifiers.bagtypes, new DERSet())),
+            new DERSequence(new TaggedContentInfo(new BodyPartID(12L), new ContentInfo(PKCSObjectIdentifiers.id_aa, new ASN1Integer(10L)))),
+            new DERSequence(new OtherMsg(new BodyPartID(12), PKCSObjectIdentifiers.id_aa_msgSigDigest, new DERUTF8String("foo")))
+        }));
+
+        byte[] b = pkiResponse.getEncoded();
+
+        PKIResponse pkiResponseResult = PKIResponse.getInstance(b);
+
+        isEquals(pkiResponse, pkiResponseResult);
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/PendInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/PendInfoTest.java
new file mode 100644
index 0000000..990c9c6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/PendInfoTest.java
@@ -0,0 +1,45 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Date;
+
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.PendInfo;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class PendInfoTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new PendInfoTest());
+    }
+
+    public String getName()
+    {
+        return "PendInfoTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        PendInfo info = new PendInfo("".getBytes(), new ASN1GeneralizedTime(new Date()));
+        byte[] b = info.getEncoded();
+        PendInfo infoResult = PendInfo.getInstance(b);
+
+        isTrue("pendToken", areEqual(info.getPendToken(), infoResult.getPendToken()));
+        isEquals("pendTime", info.getPendTime(), infoResult.getPendTime());
+
+        try
+        {
+            PendInfo.getInstance(new DERSequence());
+            fail("Sequence length not 2");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Exception type", t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/PolicyConstraintsTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/PolicyConstraintsTest.java
new file mode 100644
index 0000000..bc0d2f0
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/PolicyConstraintsTest.java
@@ -0,0 +1,55 @@
+package org.bouncycastle.asn1.test;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERTaggedObject;
+import org.bouncycastle.asn1.x509.PolicyConstraints;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class PolicyConstraintsTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "PolicyConstraints";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        PolicyConstraints constraints = new PolicyConstraints(BigInteger.valueOf(1), BigInteger.valueOf(2));
+
+        PolicyConstraints c = PolicyConstraints.getInstance(constraints.getEncoded());
+
+        isTrue("1 requireExplicitPolicyMapping", c.getRequireExplicitPolicyMapping().equals(BigInteger.valueOf(1)));
+        isTrue("2 inhibitPolicyMapping", c.getInhibitPolicyMapping().equals(BigInteger.valueOf(2)));
+
+        constraints = new PolicyConstraints(BigInteger.valueOf(3), null);
+
+        c = PolicyConstraints.getInstance(constraints.getEncoded());
+
+        isTrue("3 requireExplicitPolicyMapping", c.getRequireExplicitPolicyMapping().equals(BigInteger.valueOf(3)));
+        isTrue("4 inhibitPolicyMapping", c.getInhibitPolicyMapping() == null);
+
+
+        constraints = new PolicyConstraints(null, BigInteger.valueOf(4));
+
+        c = PolicyConstraints.getInstance(constraints.getEncoded());
+
+        isTrue("5 inhibitPolicyMapping", c.getInhibitPolicyMapping().equals(BigInteger.valueOf(4)));
+        isTrue("6 requireExplicitPolicyMapping", c.getRequireExplicitPolicyMapping() == null);
+
+        isTrue("encoding test", Arrays.areEqual(
+            new PolicyConstraints(BigInteger.valueOf(1), null).getEncoded(),
+            new DERSequence(new DERTaggedObject(false, 0, new ASN1Integer(1))).getEncoded()));
+    }
+
+    public static void main(
+        String[] args)
+    {
+        runTest(new PolicyConstraintsTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/PopLinkWitnessV2Test.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/PopLinkWitnessV2Test.java
new file mode 100644
index 0000000..e8cbeb4
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/PopLinkWitnessV2Test.java
@@ -0,0 +1,49 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.PopLinkWitnessV2;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class PopLinkWitnessV2Test
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new PopLinkWitnessV2Test());
+    }
+
+    public String getName()
+    {
+        return "PopLinkWitnessV2Test";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        // Object identifiers real but not correct in this context.
+        PopLinkWitnessV2 popLinkWitnessV2 = new PopLinkWitnessV2(
+            new AlgorithmIdentifier(PKCSObjectIdentifiers.bagtypes, new ASN1Integer(10L)),
+            new AlgorithmIdentifier(PKCSObjectIdentifiers.crlTypes, new ASN1Integer(12L)),
+            "cats".getBytes()
+        );
+
+        byte[] b = popLinkWitnessV2.getEncoded();
+        PopLinkWitnessV2 popLinkWitnessV2Result = PopLinkWitnessV2.getInstance(b);
+
+        isEquals(popLinkWitnessV2, popLinkWitnessV2Result);
+
+        try
+        {
+            PopLinkWitnessV2.getInstance(new DERSequence());
+            fail("Length must be 3");
+        }
+        catch (Throwable t)
+        {
+            isEquals(t.getClass(), IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/PublishTrustAnchorsTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/PublishTrustAnchorsTest.java
new file mode 100644
index 0000000..19a1480
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/PublishTrustAnchorsTest.java
@@ -0,0 +1,51 @@
+package org.bouncycastle.asn1.test;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.cmc.PublishTrustAnchors;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class PublishTrustAnchorsTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new PublishTrustAnchorsTest());
+    }
+
+    public String getName()
+    {
+        return "PublishTrustAnchorsTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        PublishTrustAnchors publishTrustAnchors = new PublishTrustAnchors(
+            new BigInteger("10"), new AlgorithmIdentifier(PKCSObjectIdentifiers.crlTypes,
+            new ASN1Integer(5L)), new byte[][]{"cats".getBytes()});
+
+        byte[] b = publishTrustAnchors.getEncoded();
+
+        PublishTrustAnchors publishTrustAnchorsResult = PublishTrustAnchors.getInstance(b);
+
+        isEquals("seqNumber", publishTrustAnchors.getSeqNumber(), publishTrustAnchorsResult.getSeqNumber());
+        isEquals("hashAlgorithm", publishTrustAnchors.getHashAlgorithm(), publishTrustAnchorsResult.getHashAlgorithm());
+        isTrue("anchorHashes", areEqual(publishTrustAnchors.getAnchorHashes(), publishTrustAnchorsResult.getAnchorHashes()));
+
+        try
+        {
+            PublishTrustAnchors.getInstance(new DERSequence());
+            fail("Sequence must be 3");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Expect IllegalArgumentException", t.getClass(), IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/RegressionTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/RegressionTest.java
index e442729..f4a9eff 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/test/RegressionTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/RegressionTest.java
@@ -70,7 +70,8 @@
         new ParsingTest(),
         new GeneralNameTest(),
         new ObjectIdentifierTest(),
-        new RFC4519Test()
+        new RFC4519Test(),
+        new PolicyConstraintsTest()
     };
 
     public static void main(
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/RevokeRequestTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/RevokeRequestTest.java
new file mode 100644
index 0000000..ef03771
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/RevokeRequestTest.java
@@ -0,0 +1,93 @@
+package org.bouncycastle.asn1.test;
+
+import java.util.Date;
+
+import org.bouncycastle.asn1.ASN1Enumerated;
+import org.bouncycastle.asn1.ASN1GeneralizedTime;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1OctetString;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+import org.bouncycastle.asn1.cmc.RevokeRequest;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x500.X500NameBuilder;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.asn1.x509.CRLReason;
+import org.bouncycastle.util.Pack;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class RevokeRequestTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new RevokeRequestTest());
+    }
+
+    public String getName()
+    {
+        return "RevokeRequestTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+
+
+        X500NameBuilder builder = new X500NameBuilder();
+        builder.addRDN(BCStyle.OU, "Bouncycastle");
+
+        X500Name name = builder.build();
+
+        for (int t = 0; t < 8; t++)
+        {
+            ASN1GeneralizedTime invalidityDate = null;
+            ASN1OctetString passphrase = null;
+            DERUTF8String comment = null;
+
+            if ((t & 1) == 1)
+            {
+                invalidityDate = new ASN1GeneralizedTime(new Date());
+            }
+            if ((t & 2) == 2)
+            {
+                passphrase = new DEROctetString(Pack.longToBigEndian(System.currentTimeMillis()));
+            }
+            if ((t & 4) == 4)
+            {
+                comment = new DERUTF8String("T" + Long.toOctalString(System.currentTimeMillis()));
+            }
+
+            RevokeRequest rr = new RevokeRequest(
+                name,
+                new ASN1Integer(12L),
+                CRLReason.getInstance(new ASN1Enumerated(CRLReason.certificateHold)),
+                invalidityDate,
+                passphrase,
+                comment);
+            byte[] b = rr.getEncoded();
+            RevokeRequest rrResp = RevokeRequest.getInstance(b);
+
+            isEquals("issuerName", rr.getName(), rrResp.getName());
+            isEquals("serialNumber", rr.getSerialNumber(), rrResp.getSerialNumber());
+            isEquals("reason", rr.getReason(), rrResp.getReason());
+            isEquals("invalidityDate", rr.getInvalidityDate(), rrResp.getInvalidityDate());
+            isTrue("passphrase", areEqual(rr.getPassPhrase(), rrResp.getPassPhrase()));
+            isEquals("comment", rr.getComment(), rrResp.getComment());
+
+        }
+
+        try
+        {
+            RevokeRequest.getInstance(new DERSequence());
+            fail("Sequence is less that 3");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Exception type", t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedAttributeTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedAttributeTest.java
new file mode 100644
index 0000000..a185399
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedAttributeTest.java
@@ -0,0 +1,82 @@
+package org.bouncycastle.asn1.test;
+
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERIA5String;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERSet;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CMCObjectIdentifiers;
+import org.bouncycastle.asn1.cmc.TaggedAttribute;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class TaggedAttributeTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "TaggedAttributeTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        //
+        // This creates and tests the various get instance  methods.
+        //
+        TaggedAttribute ta = new TaggedAttribute(
+            new BodyPartID(10L),
+            CMCObjectIdentifiers.id_cct_PKIData,
+            new DERSet(new DERIA5String("Cats")));
+
+        byte[] d = ta.getEncoded();
+
+        {
+            TaggedAttribute res1 = TaggedAttribute.getInstance(d);
+            isEquals(ta.getBodyPartID(), res1.getBodyPartID());
+            isEquals(ta.getAttrType(), res1.getAttrType());
+            isEquals(ta.getAttrValues().getObjectAt(0), res1.getAttrValues().getObjectAt(0));
+            isTrue(Arrays.areEqual(res1.getEncoded(), d));
+        }
+
+        //
+        // Where sequence is too short.
+        //
+        try
+        {
+            ASN1Sequence seq = new DERSequence(new ASN1Encodable[] { new BodyPartID(10) });
+
+            TaggedAttribute.getInstance(seq);
+            fail("no exception");
+        }
+        catch (IllegalArgumentException e)
+        {
+            isEquals("incorrect sequence size", e.getMessage());
+        }
+
+        //
+        // Where sequence is too long.
+        //
+        try
+        {
+            ASN1Sequence seq = new DERSequence(new ASN1Encodable[] { ta.getBodyPartID(), ta.getAttrType(), ta.getAttrValues(), new ASN1Integer(0)});
+
+            TaggedAttribute.getInstance(seq);
+            fail("no exception");
+        }
+        catch (IllegalArgumentException e)
+        {
+            isEquals("incorrect sequence size", e.getMessage());
+        }
+    }
+
+    public static void main(String[] args)
+        throws Exception
+    {
+        runTest(new TaggedAttributeTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedCertificationRequestTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedCertificationRequestTest.java
new file mode 100644
index 0000000..d205588
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedCertificationRequestTest.java
@@ -0,0 +1,41 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CertificationRequest;
+import org.bouncycastle.asn1.cmc.TaggedCertificationRequest;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+
+
+public class TaggedCertificationRequestTest extends SimpleTest
+{
+    public static void main(String[] args) {
+        runTest(new TaggedCertificationRequestTest());
+    }
+
+    public String getName()
+    {
+        return "TaggedCertificationRequestTest";
+    }
+
+
+    private static byte[]    req1 = Base64.decode(
+        "MIHoMIGTAgEAMC4xDjAMBgNVBAMTBVRlc3QyMQ8wDQYDVQQKEwZBbmFUb20xCzAJBgNVBAYTAlNF"
+            +   "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALlEt31Tzt2MlcOljvacJgzQVhmlMoqAOgqJ9Pgd3Gux"
+            +   "Z7/WcIlgW4QCB7WZT21O1YoghwBhPDMcNGrHei9kHQkCAwEAAaAAMA0GCSqGSIb3DQEBBQUAA0EA"
+            +   "NDEI4ecNtJ3uHwGGlitNFq9WxcoZ0djbQJ5hABMotav6gtqlrwKXY2evaIrsNwkJtNdwwH18aQDU"
+            +   "KCjOuBL38Q==");
+
+
+    public void performTest()
+        throws Exception
+    {
+        CertificationRequest    r = CertificationRequest.getInstance(req1);
+        TaggedCertificationRequest tcr = new TaggedCertificationRequest(new BodyPartID(10L), r);
+
+        byte[] b = tcr.getEncoded();
+        TaggedCertificationRequest tcrResp = TaggedCertificationRequest.getInstance(b);
+
+        isEquals(tcrResp,tcr);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedContentInfoTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedContentInfoTest.java
new file mode 100644
index 0000000..699c5c6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedContentInfoTest.java
@@ -0,0 +1,49 @@
+package org.bouncycastle.asn1.test;
+
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERUTF8String;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.TaggedContentInfo;
+import org.bouncycastle.asn1.cms.ContentInfo;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class TaggedContentInfoTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new TaggedContentInfoTest());
+    }
+
+    public String getName()
+    {
+        return "TaggedContentInfoTest";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        TaggedContentInfo tci = new TaggedContentInfo(
+            new BodyPartID(10L),
+            new ContentInfo(PKCSObjectIdentifiers.pkcs_9_at_contentType, new DERUTF8String("Cats")));
+
+        byte[] b = tci.getEncoded();
+
+        TaggedContentInfo tciResp = TaggedContentInfo.getInstance(b);
+
+        isEquals("bodyPartID", tci.getBodyPartID(), tciResp.getBodyPartID());
+        isEquals("contentInfo", tci.getContentInfo(), tciResp.getContentInfo());
+
+        try
+        {
+            TaggedContentInfo.getInstance(new DERSequence());
+            fail("Sequence must be 2");
+        }
+        catch (Throwable t)
+        {
+            isEquals("Exception type", t.getClass(), IllegalArgumentException.class);
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedRequestTest.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedRequestTest.java
new file mode 100644
index 0000000..0a3d3cf
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/TaggedRequestTest.java
@@ -0,0 +1,111 @@
+package org.bouncycastle.asn1.test;
+
+
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.DERBitString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.DERSet;
+import org.bouncycastle.asn1.DERTaggedObject;
+import org.bouncycastle.asn1.cmc.BodyPartID;
+import org.bouncycastle.asn1.cmc.CertificationRequest;
+import org.bouncycastle.asn1.cmc.TaggedCertificationRequest;
+import org.bouncycastle.asn1.cmc.TaggedRequest;
+import org.bouncycastle.asn1.crmf.AttributeTypeAndValue;
+import org.bouncycastle.asn1.crmf.CertReqMsg;
+import org.bouncycastle.asn1.crmf.CertRequest;
+import org.bouncycastle.asn1.crmf.CertTemplate;
+import org.bouncycastle.asn1.crmf.Controls;
+import org.bouncycastle.asn1.crmf.POPOSigningKey;
+import org.bouncycastle.asn1.crmf.POPOSigningKeyInput;
+import org.bouncycastle.asn1.crmf.ProofOfPossession;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class TaggedRequestTest
+    extends SimpleTest
+{
+    public static void main(String[] args)
+    {
+        runTest(new TaggedRequestTest());
+    }
+
+    public String getName()
+    {
+        return "TaggedRequestTest";
+    }
+
+    private static byte[] req1 = Base64.decode(
+        "MIHoMIGTAgEAMC4xDjAMBgNVBAMTBVRlc3QyMQ8wDQYDVQQKEwZBbmFUb20xCzAJBgNVBAYTAlNF"
+            + "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALlEt31Tzt2MlcOljvacJgzQVhmlMoqAOgqJ9Pgd3Gux"
+            + "Z7/WcIlgW4QCB7WZT21O1YoghwBhPDMcNGrHei9kHQkCAwEAAaAAMA0GCSqGSIb3DQEBBQUAA0EA"
+            + "NDEI4ecNtJ3uHwGGlitNFq9WxcoZ0djbQJ5hABMotav6gtqlrwKXY2evaIrsNwkJtNdwwH18aQDU"
+            + "KCjOuBL38Q==");
+
+
+    public void performTest()
+        throws Exception
+    {
+        { // TaggedCertificationRequest
+            TaggedRequest tr = new TaggedRequest(
+                new TaggedCertificationRequest(
+                    new BodyPartID(10L),
+                    CertificationRequest.getInstance(req1))
+            );
+            byte[] b = tr.getEncoded();
+            TaggedRequest trResult = TaggedRequest.getInstance(b);
+            isEquals("Tag", tr.getTagNo(), trResult.getTagNo());
+            isEquals("Is TCR tag", TaggedRequest.TCR, tr.getTagNo());
+            isEquals("Value", tr.getValue(), trResult.getValue());
+        }
+
+        { // CertReqMsg
+
+            POPOSigningKeyInput pski = new POPOSigningKeyInput(
+                new GeneralName(GeneralName.rfc822Name, "fish"),
+                new SubjectPublicKeyInfo(new AlgorithmIdentifier(
+                    PKCSObjectIdentifiers.certBag,
+                    new ASN1Integer(5L)), new ASN1Integer(4L)
+                ));
+
+            AlgorithmIdentifier aid = new AlgorithmIdentifier(PKCSObjectIdentifiers.crlTypes, new ASN1Integer(1L));
+            DERBitString dbi = new DERBitString(2);
+
+            POPOSigningKey popoSigningKey = new POPOSigningKey(pski, aid, dbi);
+            ProofOfPossession proofOfPossession = new ProofOfPossession(new POPOSigningKey(pski, aid, dbi));
+
+            TaggedRequest tr = new TaggedRequest(
+                new CertReqMsg(new CertRequest(
+                    new ASN1Integer(1L),
+                    CertTemplate.getInstance(new DERSequence(new DERTaggedObject(0,new ASN1Integer(3L)))),
+                    new Controls(new AttributeTypeAndValue(PKCSObjectIdentifiers.pkcs_9,new ASN1Integer(3)))),
+                    proofOfPossession,
+                    new AttributeTypeAndValue[0])
+            );
+            byte[] b = tr.getEncoded();
+            TaggedRequest trResult = TaggedRequest.getInstance(b);
+            isEquals("Tag", tr.getTagNo(), trResult.getTagNo());
+            isEquals("Is CRM tag", TaggedRequest.CRM, tr.getTagNo());
+            isEquals("Value", tr.getValue(), trResult.getValue());
+        }
+
+
+        { // ORM
+            TaggedRequest tr = TaggedRequest.getInstance( new DERTaggedObject(TaggedRequest.ORM, new DERSequence(new ASN1Encodable[]{
+                new BodyPartID(1L),
+                PKCSObjectIdentifiers.data,
+                new DERSet(new ASN1Encodable[]{new ASN1Integer(5L)})
+            })));
+            byte[] b = tr.getEncoded();
+            TaggedRequest trResult = TaggedRequest.getInstance(b);
+            isEquals("Tag", tr.getTagNo(), trResult.getTagNo());
+            isEquals("Is ORM tag", TaggedRequest.ORM, tr.getTagNo());
+            isEquals("Value", tr.getValue(), trResult.getValue());
+        }
+
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/test/X9Test.java b/bcprov/src/main/java/org/bouncycastle/asn1/test/X9Test.java
index 343e459..d5b7f4b 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/test/X9Test.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/test/X9Test.java
@@ -18,7 +18,6 @@
 import org.bouncycastle.math.ec.ECPoint;
 import org.bouncycastle.util.Arrays;
 import org.bouncycastle.util.encoders.Base64;
-import org.bouncycastle.util.encoders.Hex;
 import org.bouncycastle.util.test.SimpleTest;
 
 public class X9Test
@@ -166,7 +165,7 @@
     {
         return "X9";
     }
-
+                                                      
     public static void main(
         String[]    args)
     {
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/x509/KeyPurposeId.java b/bcprov/src/main/java/org/bouncycastle/asn1/x509/KeyPurposeId.java
index 01c9aa2..f545d0b 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/x509/KeyPurposeId.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/x509/KeyPurposeId.java
@@ -9,7 +9,7 @@
  * <pre>
  *     KeyPurposeId ::= OBJECT IDENTIFIER
  *
- *     id-kp ::= OBJECT IDENTIFIER { iso(1) identified-organization(3) 
+ *     id-kp ::= OBJECT IDENTIFIER { iso(1) identified-organization(3)
  *          dod(6) internet(1) security(5) mechanisms(5) pkix(7) 3}
  *
  * </pre>
@@ -115,6 +115,24 @@
      */
     public static final KeyPurposeId id_kp_smartcardlogon = new KeyPurposeId(new ASN1ObjectIdentifier("1.3.6.1.4.1.311.20.2.2"));
 
+
+    /**
+     *
+     */
+    public static final KeyPurposeId id_kp_macAddress = new KeyPurposeId(new ASN1ObjectIdentifier("1.3.6.1.1.1.1.22"));
+
+
+    /**
+     * Microsoft Server Gated Crypto (msSGC) see http://www.alvestrand.no/objectid/1.3.6.1.4.1.311.10.3.3.html
+     */
+    public static final KeyPurposeId id_kp_msSGC = new KeyPurposeId(new ASN1ObjectIdentifier("1.3.6.1.4.1.311.10.3.3"));
+
+    /**
+     * Netscape Server Gated Crypto (nsSGC) see http://www.alvestrand.no/objectid/2.16.840.1.113730.4.1.html
+     */
+    public static final KeyPurposeId id_kp_nsSGC = new KeyPurposeId(new ASN1ObjectIdentifier("2.16.840.1.113730.4.1"));
+
+
     private ASN1ObjectIdentifier id;
 
     private KeyPurposeId(ASN1ObjectIdentifier id)
@@ -123,8 +141,8 @@
     }
 
     /**
-     * @deprecated use getInstance and an OID or one of the constants above.
      * @param id string representation of an OID.
+     * @deprecated use getInstance and an OID or one of the constants above.
      */
     public KeyPurposeId(String id)
     {
diff --git a/bcprov/src/main/java/org/bouncycastle/asn1/x509/PolicyConstraints.java b/bcprov/src/main/java/org/bouncycastle/asn1/x509/PolicyConstraints.java
index aeb53f0..e2d22a7 100644
--- a/bcprov/src/main/java/org/bouncycastle/asn1/x509/PolicyConstraints.java
+++ b/bcprov/src/main/java/org/bouncycastle/asn1/x509/PolicyConstraints.java
@@ -93,12 +93,12 @@
 
         if (requireExplicitPolicyMapping != null)
         {
-            v.add(new DERTaggedObject(0, new ASN1Integer(requireExplicitPolicyMapping)));
+            v.add(new DERTaggedObject(false,0, new ASN1Integer(requireExplicitPolicyMapping)));
         }
 
         if (inhibitPolicyMapping != null)
         {
-            v.add(new DERTaggedObject(1, new ASN1Integer(inhibitPolicyMapping)));
+            v.add(new DERTaggedObject(false, 1, new ASN1Integer(inhibitPolicyMapping)));
         }
 
         return new DERSequence(v);
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/PasswordConverter.java b/bcprov/src/main/java/org/bouncycastle/crypto/PasswordConverter.java
new file mode 100644
index 0000000..4cde0fc
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/PasswordConverter.java
@@ -0,0 +1,54 @@
+package org.bouncycastle.crypto;
+
+/**
+ * Standard char[] to byte[] converters for password based derivation algorithms.
+ */
+public enum PasswordConverter
+    implements CharToByteConverter
+{
+    /**
+     * Do a straight char[] to 8 bit conversion.
+     */
+    ASCII
+        {
+            public String getType()
+            {
+                return "ASCII";
+            }
+
+            public byte[] convert(char[] password)
+            {
+                return PBEParametersGenerator.PKCS5PasswordToBytes(password);
+            }
+        },
+    /**
+     * Do a char[] conversion by producing UTF-8 data.
+     */
+    UTF8
+        {
+            public String getType()
+            {
+                return "UTF8";
+            }
+
+            public byte[] convert(char[] password)
+            {
+                return PBEParametersGenerator.PKCS5PasswordToUTF8Bytes(password);
+            }
+        },
+    /**
+     * Do char[] to BMP conversion (i.e. 2 bytes per character).
+     */
+    PKCS12
+        {
+            public String getType()
+            {
+                return "PKCS12";
+            }
+
+            public byte[] convert(char[] password)
+            {
+                return PBEParametersGenerator.PKCS12PasswordToBytes(password);
+            }
+        };
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/agreement/SM2KeyExchange.java b/bcprov/src/main/java/org/bouncycastle/crypto/agreement/SM2KeyExchange.java
new file mode 100644
index 0000000..9d2ee46
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/agreement/SM2KeyExchange.java
@@ -0,0 +1,297 @@
+package org.bouncycastle.crypto.agreement;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.crypto.digests.SM3Digest;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
+import org.bouncycastle.crypto.params.ParametersWithID;
+import org.bouncycastle.crypto.params.SM2KeyExchangePrivateParameters;
+import org.bouncycastle.crypto.params.SM2KeyExchangePublicParameters;
+import org.bouncycastle.math.ec.ECFieldElement;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.BigIntegers;
+
+/**
+ * SM2 Key Exchange protocol - based on https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02
+ */
+public class SM2KeyExchange
+{
+    private final Digest digest;
+
+    private byte[] userID;
+    private ECPrivateKeyParameters staticKey;
+    private ECPoint staticPubPoint;
+    private ECPoint ephemeralPubPoint;
+    private ECDomainParameters ecParams;
+    private int curveLength;
+    private int w;
+    private ECPrivateKeyParameters ephemeralKey;
+    private boolean initiator;
+
+    public SM2KeyExchange()
+    {
+        this(new SM3Digest());
+    }
+
+    public SM2KeyExchange(Digest digest)
+    {
+        this.digest = digest;
+    }
+
+    public void init(
+        CipherParameters privParam)
+    {
+        SM2KeyExchangePrivateParameters baseParam;
+
+        if (privParam instanceof ParametersWithID)
+        {
+            baseParam = (SM2KeyExchangePrivateParameters)((ParametersWithID)privParam).getParameters();
+            userID = ((ParametersWithID)privParam).getID();
+        }
+        else
+        {
+            baseParam = (SM2KeyExchangePrivateParameters)privParam;
+            userID = new byte[0];
+        }
+
+        initiator = baseParam.isInitiator();
+        staticKey = baseParam.getStaticPrivateKey();
+        ephemeralKey = baseParam.getEphemeralPrivateKey();
+        ecParams = staticKey.getParameters();
+        staticPubPoint = baseParam.getStaticPublicPoint();
+        ephemeralPubPoint = baseParam.getEphemeralPublicPoint();
+
+        curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;
+        w = ecParams.getCurve().getFieldSize() / 2 - 1;
+    }
+
+    public int getFieldSize()
+    {
+        return (staticKey.getParameters().getCurve().getFieldSize() + 7) / 8;
+    }
+
+    public byte[] calculateKey(int kLen, CipherParameters pubParam)
+    {
+        SM2KeyExchangePublicParameters otherPub;
+        byte[] otherUserID;
+
+        if (pubParam instanceof ParametersWithID)
+        {
+            otherPub = (SM2KeyExchangePublicParameters)((ParametersWithID)pubParam).getParameters();
+            otherUserID = ((ParametersWithID)pubParam).getID();
+        }
+        else
+        {
+            otherPub = (SM2KeyExchangePublicParameters)pubParam;
+            otherUserID = new byte[0];
+        }
+
+        byte[] za = getZ(digest, userID, staticPubPoint);
+        byte[] zb = getZ(digest, otherUserID, otherPub.getStaticPublicKey().getQ());
+
+        ECPoint U = calculateU(otherPub);
+
+        byte[] rv;
+        if (initiator)
+        {
+            rv = kdf(U, za, zb, kLen);
+        }
+        else
+        {
+            rv = kdf(U, zb, za, kLen);
+        }
+
+        return rv;
+    }
+
+    public byte[][] calculateKeyWithConfirmation(int kLen, byte[] confirmationTag, CipherParameters pubParam)
+    {
+        SM2KeyExchangePublicParameters otherPub;
+        byte[] otherUserID;
+
+        if (pubParam instanceof ParametersWithID)
+        {
+            otherPub = (SM2KeyExchangePublicParameters)((ParametersWithID)pubParam).getParameters();
+            otherUserID = ((ParametersWithID)pubParam).getID();
+        }
+        else
+        {
+            otherPub = (SM2KeyExchangePublicParameters)pubParam;
+            otherUserID = new byte[0];
+        }
+
+        if (initiator && confirmationTag == null)
+        {
+            throw new IllegalArgumentException("if initiating, confirmationTag must be set");
+        }
+        
+        byte[] za = getZ(digest, userID, staticPubPoint);
+        byte[] zb = getZ(digest, otherUserID, otherPub.getStaticPublicKey().getQ());
+
+        ECPoint U = calculateU(otherPub);
+
+        byte[] rv;
+        if (initiator)
+        {
+            rv = kdf(U, za, zb, kLen);
+
+            byte[] inner = calculateInnerHash(digest, U, za, zb, ephemeralPubPoint, otherPub.getEphemeralPublicKey().getQ());
+
+            byte[] s1 = S1(digest, U, inner);
+
+            if (!Arrays.constantTimeAreEqual(s1, confirmationTag))
+            {
+                throw new IllegalStateException("confirmation tag mismatch");
+            }
+            
+            return new byte[][] { rv, S2(digest, U, inner)};
+        }
+        else
+        {
+            rv = kdf(U, zb, za, kLen);
+
+            byte[] inner = calculateInnerHash(digest, U, zb, za, otherPub.getEphemeralPublicKey().getQ(), ephemeralPubPoint);
+
+            return new byte[][] { rv, S1(digest, U, inner), S2(digest, U, inner) };
+        }
+    }
+
+    private ECPoint calculateU(SM2KeyExchangePublicParameters otherPub)
+    {
+        BigInteger x1 = reduce(ephemeralPubPoint.getAffineXCoord().toBigInteger());
+
+        BigInteger tA = staticKey.getD().add(x1.multiply(ephemeralKey.getD())).mod(ecParams.getN());
+
+        BigInteger x2 = reduce(otherPub.getEphemeralPublicKey().getQ().getAffineXCoord().toBigInteger());
+
+        ECPoint B0 = otherPub.getEphemeralPublicKey().getQ().multiply(x2).normalize();
+
+        ECPoint B1 = otherPub.getStaticPublicKey().getQ().add(B0).normalize();
+
+        return B1.multiply(ecParams.getH().multiply(tA)).normalize();
+    }
+
+    private byte[] kdf(ECPoint u, byte[] za, byte[] zb, int klen)
+    {
+         int ct = 1;
+         int v = digest.getDigestSize() * 8;
+
+         byte[] buf = new byte[digest.getDigestSize()];
+         byte[] rv = new byte[(klen + 7) / 8];
+         int off = 0;
+
+         for (int i = 1; i <= ((klen + v - 1) / v); i++)
+         {
+             addFieldElement(digest, u.getAffineXCoord());
+             addFieldElement(digest, u.getAffineYCoord());
+             digest.update(za, 0, za.length);
+             digest.update(zb, 0, zb.length);
+             digest.update((byte)(ct >> 24));
+             digest.update((byte)(ct >> 16));
+             digest.update((byte)(ct >> 8));
+             digest.update((byte)ct);
+
+             digest.doFinal(buf, 0);
+
+             if (off + buf.length < rv.length)
+             {
+                 System.arraycopy(buf, 0, rv, off, buf.length);
+             }
+             else
+             {
+                 System.arraycopy(buf, 0, rv, off, rv.length - off);
+             }
+
+             off += buf.length;
+             ct++;
+         }
+
+         return rv;
+    }
+
+    //x1~=2^w+(x1 AND (2^w-1))
+    private BigInteger reduce(BigInteger x)
+    {
+        return x.and(BigInteger.valueOf(1).shiftLeft(w).subtract(BigInteger.valueOf(1))).setBit(w);
+    }
+
+    private byte[] S1(Digest digest, ECPoint u, byte[] inner)
+    {
+        byte[] rv = new byte[digest.getDigestSize()];
+
+        digest.update((byte)0x02);
+        addFieldElement(digest, u.getAffineYCoord());
+        digest.update(inner, 0, inner.length);
+
+        digest.doFinal(rv, 0);
+
+        return rv;
+    }
+
+    private byte[] calculateInnerHash(Digest digest, ECPoint u, byte[] za, byte[] zb, ECPoint p1, ECPoint p2)
+    {
+        addFieldElement(digest, u.getAffineXCoord());
+        digest.update(za, 0, za.length);
+        digest.update(zb, 0, zb.length);
+        addFieldElement(digest, p1.getAffineXCoord());
+        addFieldElement(digest, p1.getAffineYCoord());
+        addFieldElement(digest, p2.getAffineXCoord());
+        addFieldElement(digest, p2.getAffineYCoord());
+
+        byte[] rv = new byte[digest.getDigestSize()];
+
+        digest.doFinal(rv, 0);
+        return rv;
+    }
+
+    private byte[] S2(Digest digest, ECPoint u, byte[] inner)
+    {
+        byte[] rv = new byte[digest.getDigestSize()];
+
+        digest.update((byte)0x03);
+        addFieldElement(digest, u.getAffineYCoord());
+        digest.update(inner, 0, inner.length);
+
+        digest.doFinal(rv, 0);
+
+        return rv;
+    }
+
+    private byte[] getZ(Digest digest, byte[] userID, ECPoint pubPoint)
+    {
+        addUserID(digest, userID);
+
+        addFieldElement(digest, ecParams.getCurve().getA());
+        addFieldElement(digest, ecParams.getCurve().getB());
+        addFieldElement(digest, ecParams.getG().getAffineXCoord());
+        addFieldElement(digest, ecParams.getG().getAffineYCoord());
+        addFieldElement(digest, pubPoint.getAffineXCoord());
+        addFieldElement(digest, pubPoint.getAffineYCoord());
+
+        byte[] rv = new byte[digest.getDigestSize()];
+
+        digest.doFinal(rv, 0);
+
+        return rv;
+    }
+
+    private void addUserID(Digest digest, byte[] userID)
+    {
+        int len = userID.length * 8;
+
+        digest.update((byte)(len >> 8 & 0xFF));
+        digest.update((byte)(len & 0xFF));
+        digest.update(userID, 0, userID.length);
+    }
+
+    private void addFieldElement(Digest digest, ECFieldElement v)
+    {
+        byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());
+
+        digest.update(p, 0, p.length);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/digests/Blake2bDigest.java b/bcprov/src/main/java/org/bouncycastle/crypto/digests/Blake2bDigest.java
index 04af0ae..fe7aae0 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/digests/Blake2bDigest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/digests/Blake2bDigest.java
@@ -29,378 +29,381 @@
 
 /**
  * Implementation of the cryptographic hash function Blakbe2b.
- *
+ * <p>
  * Blake2b offers a built-in keying mechanism to be used directly
  * for authentication ("Prefix-MAC") rather than a HMAC construction.
- *
+ * <p>
  * Blake2b offers a built-in support for a salt for randomized hashing
  * and a personal string for defining a unique hash function for each application.
- *
+ * <p>
  * BLAKE2b is optimized for 64-bit platforms and produces digests of any size
  * between 1 and 64 bytes.
  */
 public class Blake2bDigest
-	implements ExtendedDigest
+    implements ExtendedDigest
 {
-	// Blake2b Initialization Vector:
-	private final static long blake2b_IV[] =
-	// Produced from the square root of primes 2, 3, 5, 7, 11, 13, 17, 19.
-	// The same as SHA-512 IV.
-	{ 
-		0x6a09e667f3bcc908L, 0xbb67ae8584caa73bL, 0x3c6ef372fe94f82bL,
-		0xa54ff53a5f1d36f1L, 0x510e527fade682d1L, 0x9b05688c2b3e6c1fL,
-		0x1f83d9abfb41bd6bL, 0x5be0cd19137e2179L 
-	};
+    // Blake2b Initialization Vector:
+    private final static long blake2b_IV[] =
+        // Produced from the square root of primes 2, 3, 5, 7, 11, 13, 17, 19.
+        // The same as SHA-512 IV.
+        {
+            0x6a09e667f3bcc908L, 0xbb67ae8584caa73bL, 0x3c6ef372fe94f82bL,
+            0xa54ff53a5f1d36f1L, 0x510e527fade682d1L, 0x9b05688c2b3e6c1fL,
+            0x1f83d9abfb41bd6bL, 0x5be0cd19137e2179L
+        };
 
-	// Message word permutations:
-	private final static byte[][] blake2b_sigma =
-	{
-		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
-		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
-		{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
-		{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
-		{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
-		{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
-		{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
-		{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
-		{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
-		{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
-		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
-		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } 
-	};
+    // Message word permutations:
+    private final static byte[][] blake2b_sigma =
+        {
+            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+            {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
+            {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
+            {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
+            {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
+            {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
+            {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
+            {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
+            {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
+            {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
+            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+            {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}
+        };
 
-	private static int rOUNDS = 12; // to use for Catenas H'
-	private final static int BLOCK_LENGTH_BYTES = 128;// bytes
+    private static int rOUNDS = 12; // to use for Catenas H'
+    private final static int BLOCK_LENGTH_BYTES = 128;// bytes
 
-	// General parameters:
-	private int digestLength = 64; // 1- 64 bytes
-	private int keyLength = 0; // 0 - 64 bytes for keyed hashing for MAC
-	private byte[] salt = null;// new byte[16];
-	private byte[] personalization = null;// new byte[16];
-	
-	// the key
-	private byte[] key = null;
+    // General parameters:
+    private int digestLength = 64; // 1- 64 bytes
+    private int keyLength = 0; // 0 - 64 bytes for keyed hashing for MAC
+    private byte[] salt = null;// new byte[16];
+    private byte[] personalization = null;// new byte[16];
 
-	// Tree hashing parameters:
-	// Because this class does not implement the Tree Hashing Mode,
-	// these parameters can be treated as constants (see init() function)
+    // the key
+    private byte[] key = null;
+
+    // Tree hashing parameters:
+    // Because this class does not implement the Tree Hashing Mode,
+    // these parameters can be treated as constants (see init() function)
 	/*
 	 * private int fanout = 1; // 0-255 private int depth = 1; // 1 - 255
 	 * private int leafLength= 0; private long nodeOffset = 0L; private int
 	 * nodeDepth = 0; private int innerHashLength = 0;
 	 */
 
-	// whenever this buffer overflows, it will be processed
-	// in the compress() function.
-	// For performance issues, long messages will not use this buffer.
-	private byte[] buffer = null;// new byte[BLOCK_LENGTH_BYTES];
-	// Position of last inserted byte:
-	private int bufferPos = 0;// a value from 0 up to 128
+    // whenever this buffer overflows, it will be processed
+    // in the compress() function.
+    // For performance issues, long messages will not use this buffer.
+    private byte[] buffer = null;// new byte[BLOCK_LENGTH_BYTES];
+    // Position of last inserted byte:
+    private int bufferPos = 0;// a value from 0 up to 128
 
-	private long[] internalState = new long[16]; // In the Blake2b paper it is
-													// called: v
-	private long[] chainValue = null; // state vector, in the Blake2b paper it
-										// is called: h
+    private long[] internalState = new long[16]; // In the Blake2b paper it is
+    // called: v
+    private long[] chainValue = null; // state vector, in the Blake2b paper it
+    // is called: h
 
-	private long t0 = 0L; // holds last significant bits, counter (counts bytes)
-	private long t1 = 0L; // counter: Length up to 2^128 are supported
-	private long f0 = 0L; // finalization flag, for last block: ~0L
+    private long t0 = 0L; // holds last significant bits, counter (counts bytes)
+    private long t1 = 0L; // counter: Length up to 2^128 are supported
+    private long f0 = 0L; // finalization flag, for last block: ~0L
 
-	// For Tree Hashing Mode, not used here:
-	// private long f1 = 0L; // finalization flag, for last node: ~0L
+    // For Tree Hashing Mode, not used here:
+    // private long f1 = 0L; // finalization flag, for last node: ~0L
 
-	public Blake2bDigest()
-	{
-		this(512);
-	}
+    public Blake2bDigest()
+    {
+        this(512);
+    }
 
-	public Blake2bDigest(Blake2bDigest digest)
-	{
-		this.bufferPos = digest.bufferPos;
-		this.buffer = Arrays.clone(digest.buffer);
-		this.keyLength = digest.keyLength;
-		this.key = Arrays.clone(digest.key);
-		this.digestLength = digest.digestLength;
-		this.chainValue = Arrays.clone(digest.chainValue);
-		this.personalization = Arrays.clone(digest.personalization);
-		this.salt = Arrays.clone(digest.salt);
-		this.t0 = digest.t0;
-		this.t1 = digest.t1;
-		this.f0 = digest.f0;
-	}
+    public Blake2bDigest(Blake2bDigest digest)
+    {
+        this.bufferPos = digest.bufferPos;
+        this.buffer = Arrays.clone(digest.buffer);
+        this.keyLength = digest.keyLength;
+        this.key = Arrays.clone(digest.key);
+        this.digestLength = digest.digestLength;
+        this.chainValue = Arrays.clone(digest.chainValue);
+        this.personalization = Arrays.clone(digest.personalization);
+        this.salt = Arrays.clone(digest.salt);
+        this.t0 = digest.t0;
+        this.t1 = digest.t1;
+        this.f0 = digest.f0;
+    }
 
-	/**
-	 * Basic sized constructor - size in bits.
-	 *
-	 * @param digestSize size of the digest in bits
+    /**
+     * Basic sized constructor - size in bits.
+     *
+     * @param digestSize size of the digest in bits
      */
-	public Blake2bDigest(int digestSize)
-	{
-		if (digestSize != 160 && digestSize != 256 && digestSize != 384 && digestSize != 512)
-		{
-			throw new IllegalArgumentException("Blake2b digest restricted to one of [160, 256, 384, 512]");
-		}
+    public Blake2bDigest(int digestSize)
+    {
+        if (digestSize != 160 && digestSize != 256 && digestSize != 384 && digestSize != 512)
+        {
+            throw new IllegalArgumentException("Blake2b digest restricted to one of [160, 256, 384, 512]");
+        }
 
-		buffer = new byte[BLOCK_LENGTH_BYTES];
-		keyLength = 0;
-		this.digestLength = digestSize / 8;
-		init();
-	}
+        buffer = new byte[BLOCK_LENGTH_BYTES];
+        keyLength = 0;
+        this.digestLength = digestSize / 8;
+        init();
+    }
 
-	/**
-	 * Blake2b for authentication ("Prefix-MAC mode"). 
-	 * After calling the doFinal() method, the key will
-	 * remain to be used for further computations of
-	 * this instance. 
-	 * The key can be overwritten using the clearKey() method. 
-	 * 
-	 * @param key A key up to 64 bytes or null
-	 */
-	public Blake2bDigest(byte[] key)
-	{
-		buffer = new byte[BLOCK_LENGTH_BYTES];
-		if (key != null)
-		{
-			this.key = new byte[key.length];
-			System.arraycopy(key, 0, this.key, 0, key.length);
-			
-			if (key.length > 64)
-			{
-				throw new IllegalArgumentException(
-						"Keys > 64 are not supported");
-			}
-			keyLength = key.length;
-			System.arraycopy(key, 0, buffer, 0, key.length);
-			bufferPos = BLOCK_LENGTH_BYTES; // zero padding
-		}
-		digestLength = 64;
-		init();
-	}
+    /**
+     * Blake2b for authentication ("Prefix-MAC mode").
+     * After calling the doFinal() method, the key will
+     * remain to be used for further computations of
+     * this instance.
+     * The key can be overwritten using the clearKey() method.
+     *
+     * @param key A key up to 64 bytes or null
+     */
+    public Blake2bDigest(byte[] key)
+    {
+        buffer = new byte[BLOCK_LENGTH_BYTES];
+        if (key != null)
+        {
+            this.key = new byte[key.length];
+            System.arraycopy(key, 0, this.key, 0, key.length);
 
-	/**
-	 * Blake2b with key, required digest length (in bytes), salt and personalization.
-	 * After calling the doFinal() method, the key, the salt and the personal string
-	 * will remain and might be used for further computations with this instance.
-	 * The key can be overwritten using the clearKey() method, the salt (pepper)
-	 * can be overwritten using the clearSalt() method.
-	 * 
-	 * @param key A key up to 64 bytes or null
-	 * @param digestLength from 1 up to 64 bytes
-	 * @param salt 16 bytes or null
-	 * @param personalization 16 bytes or null
-	 */
-	public Blake2bDigest(byte[] key, int digestLength, byte[] salt, byte[] personalization)
-	{
+            if (key.length > 64)
+            {
+                throw new IllegalArgumentException(
+                    "Keys > 64 are not supported");
+            }
+            keyLength = key.length;
+            System.arraycopy(key, 0, buffer, 0, key.length);
+            bufferPos = BLOCK_LENGTH_BYTES; // zero padding
+        }
+        digestLength = 64;
+        init();
+    }
 
-		buffer = new byte[BLOCK_LENGTH_BYTES];
-		if (digestLength < 1 || digestLength > 64)
-		{
-			throw new IllegalArgumentException(
-					"Invalid digest length (required: 1 - 64)");
-		}
-		this.digestLength = digestLength;
-		if (salt != null)
-		{
-			if (salt.length != 16)
-			{
-				throw new IllegalArgumentException(
-						"salt length must be exactly 16 bytes");
-			}
-			this.salt = new byte[16];
-			System.arraycopy(salt, 0, this.salt, 0, salt.length);
-		}
-		if (personalization != null)
-		{
-			if (personalization.length != 16)
-			{
-				throw new IllegalArgumentException(
-						"personalization length must be exactly 16 bytes");
-			}
-			this.personalization = new byte[16];
-			System.arraycopy(personalization, 0, this.personalization, 0,
-					personalization.length);
-		}
-		if (key != null)
-		{
-			this.key = new byte[key.length];
-			System.arraycopy(key, 0, this.key, 0, key.length);
-			
-			if (key.length > 64)
-			{
-				throw new IllegalArgumentException(
-						"Keys > 64 are not supported");
-			}
-			keyLength = key.length;
-			System.arraycopy(key, 0, buffer, 0, key.length);
-			bufferPos = BLOCK_LENGTH_BYTES; // zero padding
-		}
-		init();
-	}
+    /**
+     * Blake2b with key, required digest length (in bytes), salt and personalization.
+     * After calling the doFinal() method, the key, the salt and the personal string
+     * will remain and might be used for further computations with this instance.
+     * The key can be overwritten using the clearKey() method, the salt (pepper)
+     * can be overwritten using the clearSalt() method.
+     *
+     * @param key             A key up to 64 bytes or null
+     * @param digestLength    from 1 up to 64 bytes
+     * @param salt            16 bytes or null
+     * @param personalization 16 bytes or null
+     */
+    public Blake2bDigest(byte[] key, int digestLength, byte[] salt, byte[] personalization)
+    {
 
-	// initialize chainValue
-	private void init()
-	{
+        buffer = new byte[BLOCK_LENGTH_BYTES];
+        if (digestLength < 1 || digestLength > 64)
+        {
+            throw new IllegalArgumentException(
+                "Invalid digest length (required: 1 - 64)");
+        }
+        this.digestLength = digestLength;
+        if (salt != null)
+        {
+            if (salt.length != 16)
+            {
+                throw new IllegalArgumentException(
+                    "salt length must be exactly 16 bytes");
+            }
+            this.salt = new byte[16];
+            System.arraycopy(salt, 0, this.salt, 0, salt.length);
+        }
+        if (personalization != null)
+        {
+            if (personalization.length != 16)
+            {
+                throw new IllegalArgumentException(
+                    "personalization length must be exactly 16 bytes");
+            }
+            this.personalization = new byte[16];
+            System.arraycopy(personalization, 0, this.personalization, 0,
+                personalization.length);
+        }
+        if (key != null)
+        {
+            this.key = new byte[key.length];
+            System.arraycopy(key, 0, this.key, 0, key.length);
 
-		if (chainValue == null)
-		{
-			chainValue = new long[8];
+            if (key.length > 64)
+            {
+                throw new IllegalArgumentException(
+                    "Keys > 64 are not supported");
+            }
+            keyLength = key.length;
+            System.arraycopy(key, 0, buffer, 0, key.length);
+            bufferPos = BLOCK_LENGTH_BYTES; // zero padding
+        }
+        init();
+    }
 
-			chainValue[0] = blake2b_IV[0]
-					^ (digestLength | (keyLength << 8) | 0x1010000);
-			// 0x1010000 = ((fanout << 16) | (depth << 24) | (leafLength <<
-			// 32));
-			// with fanout = 1; depth = 0; leafLength = 0;
-			chainValue[1] = blake2b_IV[1];// ^ nodeOffset; with nodeOffset = 0;
-			chainValue[2] = blake2b_IV[2];// ^ ( nodeDepth | (innerHashLength <<
-											// 8) );
-			// with nodeDepth = 0; innerHashLength = 0;
+    // initialize chainValue
+    private void init()
+    {
+        if (chainValue == null)
+        {
+            chainValue = new long[8];
 
-			chainValue[3] = blake2b_IV[3];
+            chainValue[0] = blake2b_IV[0]
+                ^ (digestLength | (keyLength << 8) | 0x1010000);
+            // 0x1010000 = ((fanout << 16) | (depth << 24) | (leafLength <<
+            // 32));
+            // with fanout = 1; depth = 0; leafLength = 0;
+            chainValue[1] = blake2b_IV[1];// ^ nodeOffset; with nodeOffset = 0;
+            chainValue[2] = blake2b_IV[2];// ^ ( nodeDepth | (innerHashLength <<
+            // 8) );
+            // with nodeDepth = 0; innerHashLength = 0;
 
-			chainValue[4] = blake2b_IV[4];
-			chainValue[5] = blake2b_IV[5];
-			if (salt != null)
-			{
-				chainValue[4] ^= (bytes2long(salt, 0));
-				chainValue[5] ^= (bytes2long(salt, 8));
-			}
+            chainValue[3] = blake2b_IV[3];
 
-			chainValue[6] = blake2b_IV[6];
-			chainValue[7] = blake2b_IV[7];
-			if (personalization != null)
-			{
-				chainValue[6] ^= (bytes2long(personalization, 0));
-				chainValue[7] ^= (bytes2long(personalization, 8));
-			}
-		}
-	}
+            chainValue[4] = blake2b_IV[4];
+            chainValue[5] = blake2b_IV[5];
+            if (salt != null)
+            {
+                chainValue[4] ^= (bytes2long(salt, 0));
+                chainValue[5] ^= (bytes2long(salt, 8));
+            }
 
-	private void initializeInternalState()
-	{
-		// initialize v:
-		System.arraycopy(chainValue, 0, internalState, 0, chainValue.length);
-		System.arraycopy(blake2b_IV, 0, internalState, chainValue.length, 4);
-		internalState[12] = t0 ^ blake2b_IV[4];
-		internalState[13] = t1 ^ blake2b_IV[5];
-		internalState[14] = f0 ^ blake2b_IV[6];
-		internalState[15] = blake2b_IV[7];// ^ f1 with f1 = 0
-	}
+            chainValue[6] = blake2b_IV[6];
+            chainValue[7] = blake2b_IV[7];
+            if (personalization != null)
+            {
+                chainValue[6] ^= (bytes2long(personalization, 0));
+                chainValue[7] ^= (bytes2long(personalization, 8));
+            }
+        }
+    }
+
+    private void initializeInternalState()
+    {
+        // initialize v:
+        System.arraycopy(chainValue, 0, internalState, 0, chainValue.length);
+        System.arraycopy(blake2b_IV, 0, internalState, chainValue.length, 4);
+        internalState[12] = t0 ^ blake2b_IV[4];
+        internalState[13] = t1 ^ blake2b_IV[5];
+        internalState[14] = f0 ^ blake2b_IV[6];
+        internalState[15] = blake2b_IV[7];// ^ f1 with f1 = 0
+    }
 
     /**
      * update the message digest with a single byte.
      *
      * @param b the input byte to be entered.
      */
-	public void update(byte b)
-	{
-		int remainingLength = 0; // left bytes of buffer
+    public void update(byte b)
+    {
+        int remainingLength = 0; // left bytes of buffer
 
-		// process the buffer if full else add to buffer:
-		remainingLength = BLOCK_LENGTH_BYTES - bufferPos;
-		if (remainingLength == 0)
-		{ // full buffer
-			t0 += BLOCK_LENGTH_BYTES;
-			if (t0 == 0)
-			{ // if message > 2^64
-				t1++;
-			}
-			compress(buffer, 0);
-			Arrays.fill(buffer, (byte)0);// clear buffer
-			buffer[0] = b;
-			bufferPos = 1;
-		} else
-		{
-			buffer[bufferPos] = b;
-			bufferPos++;
-			return;
-		}
-	}
+        // process the buffer if full else add to buffer:
+        remainingLength = BLOCK_LENGTH_BYTES - bufferPos;
+        if (remainingLength == 0)
+        { // full buffer
+            t0 += BLOCK_LENGTH_BYTES;
+            if (t0 == 0)
+            { // if message > 2^64
+                t1++;
+            }
+            compress(buffer, 0);
+            Arrays.fill(buffer, (byte)0);// clear buffer
+            buffer[0] = b;
+            bufferPos = 1;
+        }
+        else
+        {
+            buffer[bufferPos] = b;
+            bufferPos++;
+            return;
+        }
+    }
 
     /**
      * update the message digest with a block of bytes.
      *
      * @param message the byte array containing the data.
-     * @param offset the offset into the byte array where the data starts.
-     * @param len the length of the data.
+     * @param offset  the offset into the byte array where the data starts.
+     * @param len     the length of the data.
      */
-	public void update(byte[] message, int offset, int len)
-	{
+    public void update(byte[] message, int offset, int len)
+    {
 
-		if (message == null || len == 0)
-			return;
+        if (message == null || len == 0)
+        {
+            return;
+        }
 
-		int remainingLength = 0; // left bytes of buffer
+        int remainingLength = 0; // left bytes of buffer
 
-		if (bufferPos != 0)
-		{ // commenced, incomplete buffer
+        if (bufferPos != 0)
+        { // commenced, incomplete buffer
 
-			// complete the buffer:
-			remainingLength = BLOCK_LENGTH_BYTES - bufferPos;
-			if (remainingLength < len)
-			{ // full buffer + at least 1 byte
-				System.arraycopy(message, offset, buffer, bufferPos,
-						remainingLength);
-				t0 += BLOCK_LENGTH_BYTES;
-				if (t0 == 0)
-				{ // if message > 2^64
-					t1++;
-				}
-				compress(buffer, 0);
-				bufferPos = 0;
-				Arrays.fill(buffer, (byte) 0);// clear buffer
-			} else
-			{
-				System.arraycopy(message, offset, buffer, bufferPos, len);
-				bufferPos += len;
-				return;
-			}
-		}
+            // complete the buffer:
+            remainingLength = BLOCK_LENGTH_BYTES - bufferPos;
+            if (remainingLength < len)
+            { // full buffer + at least 1 byte
+                System.arraycopy(message, offset, buffer, bufferPos,
+                    remainingLength);
+                t0 += BLOCK_LENGTH_BYTES;
+                if (t0 == 0)
+                { // if message > 2^64
+                    t1++;
+                }
+                compress(buffer, 0);
+                bufferPos = 0;
+                Arrays.fill(buffer, (byte)0);// clear buffer
+            }
+            else
+            {
+                System.arraycopy(message, offset, buffer, bufferPos, len);
+                bufferPos += len;
+                return;
+            }
+        }
 
-		// process blocks except last block (also if last block is full)
-		int messagePos;
-		int blockWiseLastPos = offset + len - BLOCK_LENGTH_BYTES;
-		for (messagePos = offset + remainingLength; messagePos < blockWiseLastPos; messagePos += BLOCK_LENGTH_BYTES)
-		{ // block wise 128 bytes
-			// without buffer:
-			t0 += BLOCK_LENGTH_BYTES;
-			if (t0 == 0)
-			{
-				t1++;
-			}
-			compress(message, messagePos);
-		}
+        // process blocks except last block (also if last block is full)
+        int messagePos;
+        int blockWiseLastPos = offset + len - BLOCK_LENGTH_BYTES;
+        for (messagePos = offset + remainingLength; messagePos < blockWiseLastPos; messagePos += BLOCK_LENGTH_BYTES)
+        { // block wise 128 bytes
+            // without buffer:
+            t0 += BLOCK_LENGTH_BYTES;
+            if (t0 == 0)
+            {
+                t1++;
+            }
+            compress(message, messagePos);
+        }
 
-		// fill the buffer with left bytes, this might be a full block
-		System.arraycopy(message, messagePos, buffer, 0, offset + len
-				- messagePos);
-		bufferPos += offset + len - messagePos;
-	}
+        // fill the buffer with left bytes, this might be a full block
+        System.arraycopy(message, messagePos, buffer, 0, offset + len
+            - messagePos);
+        bufferPos += offset + len - messagePos;
+    }
 
     /**
      * close the digest, producing the final digest value. The doFinal
      * call leaves the digest reset.
-     * Key, salt and personal string remain. 
+     * Key, salt and personal string remain.
      *
-     * @param out the array the digest is to be copied into.
+     * @param out       the array the digest is to be copied into.
      * @param outOffset the offset into the out array the digest is to start at.
      */
-	public int doFinal(byte[] out, int outOffset)
-	{
+    public int doFinal(byte[] out, int outOffset)
+    {
 
-		f0 = 0xFFFFFFFFFFFFFFFFL;
-		t0 += bufferPos;
-		// bufferPos may be < 128, so (t0 == 0) does not work
-		// for 2^64 < message length > 2^64 - 127
-		if ((t0 < 0) && (bufferPos > -t0))
-		{
-			t1++;
-		}
-		compress(buffer, 0);
-		Arrays.fill(buffer, (byte) 0);// Holds eventually the key if input is null
-		Arrays.fill(internalState, 0L);
+        f0 = 0xFFFFFFFFFFFFFFFFL;
+        t0 += bufferPos;
+        // bufferPos may be < 128, so (t0 == 0) does not work
+        // for 2^64 < message length > 2^64 - 127
+        if ((t0 < 0) && (bufferPos > -t0))
+        {
+            t1++;
+        }
+        compress(buffer, 0);
+        Arrays.fill(buffer, (byte)0);// Holds eventually the key if input is null
+        Arrays.fill(internalState, 0L);
 
-		for (int i = 0; i < chainValue.length && (i * 8 < digestLength); i++)
-		{
+        for (int i = 0; i < chainValue.length && (i * 8 < digestLength); i++)
+        {
             byte[] bytes = long2bytes(chainValue[i]);
 
             if (i * 8 < digestLength - 8)
@@ -411,179 +414,179 @@
             {
                 System.arraycopy(bytes, 0, out, outOffset + i * 8, digestLength - (i * 8));
             }
-		}
+        }
 
-		Arrays.fill(chainValue, 0L);
-		
-		reset();
-		
-		return digestLength;
-	}
+        Arrays.fill(chainValue, 0L);
 
-	/**
-	 * Reset the digest back to it's initial state.
-	 * The key, the salt and the personal string will
-	 * remain for further computations. 
-	 */
-	public void reset()
-	{
-		bufferPos = 0;
-		f0 = 0L;
-		t0 = 0L;
-		t1 = 0L;
-		chainValue = null;
-		if (key != null)
-		{
-			Arrays.fill(buffer, (byte) 0);
-			System.arraycopy(key, 0, buffer, 0, key.length);
-			bufferPos = BLOCK_LENGTH_BYTES; // zero padding
-		}
-		init();
-	}
+        reset();
 
-	private void compress(byte[] message, int messagePos)
-	{
+        return digestLength;
+    }
 
-		initializeInternalState();
+    /**
+     * Reset the digest back to it's initial state.
+     * The key, the salt and the personal string will
+     * remain for further computations.
+     */
+    public void reset()
+    {
+        bufferPos = 0;
+        f0 = 0L;
+        t0 = 0L;
+        t1 = 0L;
+        chainValue = null;
+        Arrays.fill(buffer, (byte)0);
+        if (key != null)
+        {
+            System.arraycopy(key, 0, buffer, 0, key.length);
+            bufferPos = BLOCK_LENGTH_BYTES; // zero padding
+        }
+        init();
+    }
 
-		long[] m = new long[16];
-		for (int j = 0; j < 16; j++)
-		{
-			m[j] = bytes2long(message, messagePos + j * 8);
-		}
+    private void compress(byte[] message, int messagePos)
+    {
 
-		for (int round = 0; round < rOUNDS; round++)
-		{
+        initializeInternalState();
 
-			// G apply to columns of internalState:m[blake2b_sigma[round][2 *
-			// blockPos]] /+1
-			G(m[blake2b_sigma[round][0]], m[blake2b_sigma[round][1]], 0, 4, 8,
-					12);
-			G(m[blake2b_sigma[round][2]], m[blake2b_sigma[round][3]], 1, 5, 9,
-					13);
-			G(m[blake2b_sigma[round][4]], m[blake2b_sigma[round][5]], 2, 6, 10,
-					14);
-			G(m[blake2b_sigma[round][6]], m[blake2b_sigma[round][7]], 3, 7, 11,
-					15);
-			// G apply to diagonals of internalState:
-			G(m[blake2b_sigma[round][8]], m[blake2b_sigma[round][9]], 0, 5, 10,
-					15);
-			G(m[blake2b_sigma[round][10]], m[blake2b_sigma[round][11]], 1, 6,
-					11, 12);
-			G(m[blake2b_sigma[round][12]], m[blake2b_sigma[round][13]], 2, 7,
-					8, 13);
-			G(m[blake2b_sigma[round][14]], m[blake2b_sigma[round][15]], 3, 4,
-					9, 14);
-		}
+        long[] m = new long[16];
+        for (int j = 0; j < 16; j++)
+        {
+            m[j] = bytes2long(message, messagePos + j * 8);
+        }
 
-		// update chain values:
-		for (int offset = 0; offset < chainValue.length; offset++)
-		{
-			chainValue[offset] = chainValue[offset] ^ internalState[offset]
-					^ internalState[offset + 8];
-		}
-	}
+        for (int round = 0; round < rOUNDS; round++)
+        {
 
-	private void G(long m1, long m2, int posA, int posB, int posC, int posD)
-	{
+            // G apply to columns of internalState:m[blake2b_sigma[round][2 *
+            // blockPos]] /+1
+            G(m[blake2b_sigma[round][0]], m[blake2b_sigma[round][1]], 0, 4, 8,
+                12);
+            G(m[blake2b_sigma[round][2]], m[blake2b_sigma[round][3]], 1, 5, 9,
+                13);
+            G(m[blake2b_sigma[round][4]], m[blake2b_sigma[round][5]], 2, 6, 10,
+                14);
+            G(m[blake2b_sigma[round][6]], m[blake2b_sigma[round][7]], 3, 7, 11,
+                15);
+            // G apply to diagonals of internalState:
+            G(m[blake2b_sigma[round][8]], m[blake2b_sigma[round][9]], 0, 5, 10,
+                15);
+            G(m[blake2b_sigma[round][10]], m[blake2b_sigma[round][11]], 1, 6,
+                11, 12);
+            G(m[blake2b_sigma[round][12]], m[blake2b_sigma[round][13]], 2, 7,
+                8, 13);
+            G(m[blake2b_sigma[round][14]], m[blake2b_sigma[round][15]], 3, 4,
+                9, 14);
+        }
 
-		internalState[posA] = internalState[posA] + internalState[posB] + m1;
-		internalState[posD] = rotr64(internalState[posD] ^ internalState[posA],
-				32);
-		internalState[posC] = internalState[posC] + internalState[posD];
-		internalState[posB] = rotr64(internalState[posB] ^ internalState[posC],
-				24); // replaces 25 of BLAKE
-		internalState[posA] = internalState[posA] + internalState[posB] + m2;
-		internalState[posD] = rotr64(internalState[posD] ^ internalState[posA],
-				16);
-		internalState[posC] = internalState[posC] + internalState[posD];
-		internalState[posB] = rotr64(internalState[posB] ^ internalState[posC],
-				63); // replaces 11 of BLAKE
-	}
+        // update chain values:
+        for (int offset = 0; offset < chainValue.length; offset++)
+        {
+            chainValue[offset] = chainValue[offset] ^ internalState[offset]
+                ^ internalState[offset + 8];
+        }
+    }
 
-	private long rotr64(long x, int rot)
-	{
-		return x >>> rot | (x << (64 - rot));
-	}
+    private void G(long m1, long m2, int posA, int posB, int posC, int posD)
+    {
 
-	// convert one long value in byte array
-	// little-endian byte order!
-	private final byte[] long2bytes(long longValue)
-	{
-		return new byte[]
-		{ 	(byte) longValue, (byte) (longValue >> 8), 
-			(byte) (longValue >> 16), (byte) (longValue >> 24), 
-			(byte) (longValue >> 32), (byte) (longValue >> 40), 
-			(byte) (longValue >> 48), (byte) (longValue >> 56) 
-		};
-	}
+        internalState[posA] = internalState[posA] + internalState[posB] + m1;
+        internalState[posD] = rotr64(internalState[posD] ^ internalState[posA],
+            32);
+        internalState[posC] = internalState[posC] + internalState[posD];
+        internalState[posB] = rotr64(internalState[posB] ^ internalState[posC],
+            24); // replaces 25 of BLAKE
+        internalState[posA] = internalState[posA] + internalState[posB] + m2;
+        internalState[posD] = rotr64(internalState[posD] ^ internalState[posA],
+            16);
+        internalState[posC] = internalState[posC] + internalState[posD];
+        internalState[posB] = rotr64(internalState[posB] ^ internalState[posC],
+            63); // replaces 11 of BLAKE
+    }
 
-	// little-endian byte order!
-	private final long bytes2long(byte[] byteArray, int offset)
-	{
-		return (((long) byteArray[offset] & 0xFF)
-				| (((long) byteArray[offset + 1] & 0xFF) << 8)
-				| (((long) byteArray[offset + 2] & 0xFF) << 16)
-				| (((long) byteArray[offset + 3] & 0xFF) << 24)
-				| (((long) byteArray[offset + 4] & 0xFF) << 32)
-				| (((long) byteArray[offset + 5] & 0xFF) << 40)
-				| (((long) byteArray[offset + 6] & 0xFF) << 48) 
-				| (((long) byteArray[offset + 7] & 0xFF) << 56));
-	}
+    private long rotr64(long x, int rot)
+    {
+        return x >>> rot | (x << (64 - rot));
+    }
+
+    // convert one long value in byte array
+    // little-endian byte order!
+    private final byte[] long2bytes(long longValue)
+    {
+        return new byte[]
+            {(byte)longValue, (byte)(longValue >> 8),
+                (byte)(longValue >> 16), (byte)(longValue >> 24),
+                (byte)(longValue >> 32), (byte)(longValue >> 40),
+                (byte)(longValue >> 48), (byte)(longValue >> 56)
+            };
+    }
+
+    // little-endian byte order!
+    private final long bytes2long(byte[] byteArray, int offset)
+    {
+        return (((long)byteArray[offset] & 0xFF)
+            | (((long)byteArray[offset + 1] & 0xFF) << 8)
+            | (((long)byteArray[offset + 2] & 0xFF) << 16)
+            | (((long)byteArray[offset + 3] & 0xFF) << 24)
+            | (((long)byteArray[offset + 4] & 0xFF) << 32)
+            | (((long)byteArray[offset + 5] & 0xFF) << 40)
+            | (((long)byteArray[offset + 6] & 0xFF) << 48)
+            | (((long)byteArray[offset + 7] & 0xFF) << 56));
+    }
 
     /**
      * return the algorithm name
      *
      * @return the algorithm name
      */
-	public String getAlgorithmName()
-	{
-		return "Blake2b";
-	}
+    public String getAlgorithmName()
+    {
+        return "Blake2b";
+    }
 
     /**
      * return the size, in bytes, of the digest produced by this message digest.
      *
      * @return the size, in bytes, of the digest produced by this message digest.
      */
-	public int getDigestSize()
-	{
-		return digestLength;
-	}
+    public int getDigestSize()
+    {
+        return digestLength;
+    }
 
     /**
      * Return the size in bytes of the internal buffer the digest applies it's compression
      * function to.
-     * 
+     *
      * @return byte length of the digests internal buffer.
      */
-	public int getByteLength()
-	{
-		return BLOCK_LENGTH_BYTES;
-	}
-	
-	/**
-	 * Overwrite the key 
-	 * if it is no longer used (zeroization)
-	 */
-	public void clearKey()
-	{
-		if (key != null) 
-		{
-			Arrays.fill(key, (byte) 0);
-			Arrays.fill(buffer,  (byte) 0);
-		}
-	}
-	
-	/**
-	 * Overwrite the salt (pepper) if it
-	 * is secret and no longer used (zeroization)
-	 */
-	public void clearSalt()
-	{
-		if (salt != null) 
-		{
-			Arrays.fill(salt, (byte) 0);
-		}
-	}
+    public int getByteLength()
+    {
+        return BLOCK_LENGTH_BYTES;
+    }
+
+    /**
+     * Overwrite the key
+     * if it is no longer used (zeroization)
+     */
+    public void clearKey()
+    {
+        if (key != null)
+        {
+            Arrays.fill(key, (byte)0);
+            Arrays.fill(buffer, (byte)0);
+        }
+    }
+
+    /**
+     * Overwrite the salt (pepper) if it
+     * is secret and no longer used (zeroization)
+     */
+    public void clearSalt()
+    {
+        if (salt != null)
+        {
+            Arrays.fill(salt, (byte)0);
+        }
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAEngine.java b/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAEngine.java
new file mode 100644
index 0000000..6854f50
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAEngine.java
@@ -0,0 +1,424 @@
+package org.bouncycastle.crypto.engines;
+
+import org.bouncycastle.crypto.BlockCipher;
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.crypto.DataLengthException;
+import org.bouncycastle.crypto.OutputLengthException;
+import org.bouncycastle.crypto.params.KeyParameter;
+import org.bouncycastle.util.encoders.Hex;
+
+/**
+ * RFC 5794.
+ * 
+ * ARIA is a 128-bit block cipher with 128-, 192-, and 256-bit keys.
+ */
+public class ARIAEngine
+    implements BlockCipher
+{
+    private static final byte[][] C = { Hex.decode("517cc1b727220a94fe13abe8fa9a6ee0"),
+        Hex.decode("6db14acc9e21c820ff28b1d5ef5de2b0"), Hex.decode("db92371d2126e9700324977504e8c90e") };
+
+    private static final byte[] SB1_sbox = { (byte)0x63, (byte)0x7c, (byte)0x77, (byte)0x7b, (byte)0xf2, (byte)0x6b,
+        (byte)0x6f, (byte)0xc5, (byte)0x30, (byte)0x01, (byte)0x67, (byte)0x2b, (byte)0xfe, (byte)0xd7, (byte)0xab,
+        (byte)0x76, (byte)0xca, (byte)0x82, (byte)0xc9, (byte)0x7d, (byte)0xfa, (byte)0x59, (byte)0x47, (byte)0xf0,
+        (byte)0xad, (byte)0xd4, (byte)0xa2, (byte)0xaf, (byte)0x9c, (byte)0xa4, (byte)0x72, (byte)0xc0, (byte)0xb7,
+        (byte)0xfd, (byte)0x93, (byte)0x26, (byte)0x36, (byte)0x3f, (byte)0xf7, (byte)0xcc, (byte)0x34, (byte)0xa5,
+        (byte)0xe5, (byte)0xf1, (byte)0x71, (byte)0xd8, (byte)0x31, (byte)0x15, (byte)0x04, (byte)0xc7, (byte)0x23,
+        (byte)0xc3, (byte)0x18, (byte)0x96, (byte)0x05, (byte)0x9a, (byte)0x07, (byte)0x12, (byte)0x80, (byte)0xe2,
+        (byte)0xeb, (byte)0x27, (byte)0xb2, (byte)0x75, (byte)0x09, (byte)0x83, (byte)0x2c, (byte)0x1a, (byte)0x1b,
+        (byte)0x6e, (byte)0x5a, (byte)0xa0, (byte)0x52, (byte)0x3b, (byte)0xd6, (byte)0xb3, (byte)0x29, (byte)0xe3,
+        (byte)0x2f, (byte)0x84, (byte)0x53, (byte)0xd1, (byte)0x00, (byte)0xed, (byte)0x20, (byte)0xfc, (byte)0xb1,
+        (byte)0x5b, (byte)0x6a, (byte)0xcb, (byte)0xbe, (byte)0x39, (byte)0x4a, (byte)0x4c, (byte)0x58, (byte)0xcf,
+        (byte)0xd0, (byte)0xef, (byte)0xaa, (byte)0xfb, (byte)0x43, (byte)0x4d, (byte)0x33, (byte)0x85, (byte)0x45,
+        (byte)0xf9, (byte)0x02, (byte)0x7f, (byte)0x50, (byte)0x3c, (byte)0x9f, (byte)0xa8, (byte)0x51, (byte)0xa3,
+        (byte)0x40, (byte)0x8f, (byte)0x92, (byte)0x9d, (byte)0x38, (byte)0xf5, (byte)0xbc, (byte)0xb6, (byte)0xda,
+        (byte)0x21, (byte)0x10, (byte)0xff, (byte)0xf3, (byte)0xd2, (byte)0xcd, (byte)0x0c, (byte)0x13, (byte)0xec,
+        (byte)0x5f, (byte)0x97, (byte)0x44, (byte)0x17, (byte)0xc4, (byte)0xa7, (byte)0x7e, (byte)0x3d, (byte)0x64,
+        (byte)0x5d, (byte)0x19, (byte)0x73, (byte)0x60, (byte)0x81, (byte)0x4f, (byte)0xdc, (byte)0x22, (byte)0x2a,
+        (byte)0x90, (byte)0x88, (byte)0x46, (byte)0xee, (byte)0xb8, (byte)0x14, (byte)0xde, (byte)0x5e, (byte)0x0b,
+        (byte)0xdb, (byte)0xe0, (byte)0x32, (byte)0x3a, (byte)0x0a, (byte)0x49, (byte)0x06, (byte)0x24, (byte)0x5c,
+        (byte)0xc2, (byte)0xd3, (byte)0xac, (byte)0x62, (byte)0x91, (byte)0x95, (byte)0xe4, (byte)0x79, (byte)0xe7,
+        (byte)0xc8, (byte)0x37, (byte)0x6d, (byte)0x8d, (byte)0xd5, (byte)0x4e, (byte)0xa9, (byte)0x6c, (byte)0x56,
+        (byte)0xf4, (byte)0xea, (byte)0x65, (byte)0x7a, (byte)0xae, (byte)0x08, (byte)0xba, (byte)0x78, (byte)0x25,
+        (byte)0x2e, (byte)0x1c, (byte)0xa6, (byte)0xb4, (byte)0xc6, (byte)0xe8, (byte)0xdd, (byte)0x74, (byte)0x1f,
+        (byte)0x4b, (byte)0xbd, (byte)0x8b, (byte)0x8a, (byte)0x70, (byte)0x3e, (byte)0xb5, (byte)0x66, (byte)0x48,
+        (byte)0x03, (byte)0xf6, (byte)0x0e, (byte)0x61, (byte)0x35, (byte)0x57, (byte)0xb9, (byte)0x86, (byte)0xc1,
+        (byte)0x1d, (byte)0x9e, (byte)0xe1, (byte)0xf8, (byte)0x98, (byte)0x11, (byte)0x69, (byte)0xd9, (byte)0x8e,
+        (byte)0x94, (byte)0x9b, (byte)0x1e, (byte)0x87, (byte)0xe9, (byte)0xce, (byte)0x55, (byte)0x28, (byte)0xdf,
+        (byte)0x8c, (byte)0xa1, (byte)0x89, (byte)0x0d, (byte)0xbf, (byte)0xe6, (byte)0x42, (byte)0x68, (byte)0x41,
+        (byte)0x99, (byte)0x2d, (byte)0x0f, (byte)0xb0, (byte)0x54, (byte)0xbb, (byte)0x16 };
+
+    private static final byte[] SB2_sbox = { (byte)0xe2, (byte)0x4e, (byte)0x54, (byte)0xfc, (byte)0x94, (byte)0xc2,
+        (byte)0x4a, (byte)0xcc, (byte)0x62, (byte)0x0d, (byte)0x6a, (byte)0x46, (byte)0x3c, (byte)0x4d, (byte)0x8b,
+        (byte)0xd1, (byte)0x5e, (byte)0xfa, (byte)0x64, (byte)0xcb, (byte)0xb4, (byte)0x97, (byte)0xbe, (byte)0x2b,
+        (byte)0xbc, (byte)0x77, (byte)0x2e, (byte)0x03, (byte)0xd3, (byte)0x19, (byte)0x59, (byte)0xc1, (byte)0x1d,
+        (byte)0x06, (byte)0x41, (byte)0x6b, (byte)0x55, (byte)0xf0, (byte)0x99, (byte)0x69, (byte)0xea, (byte)0x9c,
+        (byte)0x18, (byte)0xae, (byte)0x63, (byte)0xdf, (byte)0xe7, (byte)0xbb, (byte)0x00, (byte)0x73, (byte)0x66,
+        (byte)0xfb, (byte)0x96, (byte)0x4c, (byte)0x85, (byte)0xe4, (byte)0x3a, (byte)0x09, (byte)0x45, (byte)0xaa,
+        (byte)0x0f, (byte)0xee, (byte)0x10, (byte)0xeb, (byte)0x2d, (byte)0x7f, (byte)0xf4, (byte)0x29, (byte)0xac,
+        (byte)0xcf, (byte)0xad, (byte)0x91, (byte)0x8d, (byte)0x78, (byte)0xc8, (byte)0x95, (byte)0xf9, (byte)0x2f,
+        (byte)0xce, (byte)0xcd, (byte)0x08, (byte)0x7a, (byte)0x88, (byte)0x38, (byte)0x5c, (byte)0x83, (byte)0x2a,
+        (byte)0x28, (byte)0x47, (byte)0xdb, (byte)0xb8, (byte)0xc7, (byte)0x93, (byte)0xa4, (byte)0x12, (byte)0x53,
+        (byte)0xff, (byte)0x87, (byte)0x0e, (byte)0x31, (byte)0x36, (byte)0x21, (byte)0x58, (byte)0x48, (byte)0x01,
+        (byte)0x8e, (byte)0x37, (byte)0x74, (byte)0x32, (byte)0xca, (byte)0xe9, (byte)0xb1, (byte)0xb7, (byte)0xab,
+        (byte)0x0c, (byte)0xd7, (byte)0xc4, (byte)0x56, (byte)0x42, (byte)0x26, (byte)0x07, (byte)0x98, (byte)0x60,
+        (byte)0xd9, (byte)0xb6, (byte)0xb9, (byte)0x11, (byte)0x40, (byte)0xec, (byte)0x20, (byte)0x8c, (byte)0xbd,
+        (byte)0xa0, (byte)0xc9, (byte)0x84, (byte)0x04, (byte)0x49, (byte)0x23, (byte)0xf1, (byte)0x4f, (byte)0x50,
+        (byte)0x1f, (byte)0x13, (byte)0xdc, (byte)0xd8, (byte)0xc0, (byte)0x9e, (byte)0x57, (byte)0xe3, (byte)0xc3,
+        (byte)0x7b, (byte)0x65, (byte)0x3b, (byte)0x02, (byte)0x8f, (byte)0x3e, (byte)0xe8, (byte)0x25, (byte)0x92,
+        (byte)0xe5, (byte)0x15, (byte)0xdd, (byte)0xfd, (byte)0x17, (byte)0xa9, (byte)0xbf, (byte)0xd4, (byte)0x9a,
+        (byte)0x7e, (byte)0xc5, (byte)0x39, (byte)0x67, (byte)0xfe, (byte)0x76, (byte)0x9d, (byte)0x43, (byte)0xa7,
+        (byte)0xe1, (byte)0xd0, (byte)0xf5, (byte)0x68, (byte)0xf2, (byte)0x1b, (byte)0x34, (byte)0x70, (byte)0x05,
+        (byte)0xa3, (byte)0x8a, (byte)0xd5, (byte)0x79, (byte)0x86, (byte)0xa8, (byte)0x30, (byte)0xc6, (byte)0x51,
+        (byte)0x4b, (byte)0x1e, (byte)0xa6, (byte)0x27, (byte)0xf6, (byte)0x35, (byte)0xd2, (byte)0x6e, (byte)0x24,
+        (byte)0x16, (byte)0x82, (byte)0x5f, (byte)0xda, (byte)0xe6, (byte)0x75, (byte)0xa2, (byte)0xef, (byte)0x2c,
+        (byte)0xb2, (byte)0x1c, (byte)0x9f, (byte)0x5d, (byte)0x6f, (byte)0x80, (byte)0x0a, (byte)0x72, (byte)0x44,
+        (byte)0x9b, (byte)0x6c, (byte)0x90, (byte)0x0b, (byte)0x5b, (byte)0x33, (byte)0x7d, (byte)0x5a, (byte)0x52,
+        (byte)0xf3, (byte)0x61, (byte)0xa1, (byte)0xf7, (byte)0xb0, (byte)0xd6, (byte)0x3f, (byte)0x7c, (byte)0x6d,
+        (byte)0xed, (byte)0x14, (byte)0xe0, (byte)0xa5, (byte)0x3d, (byte)0x22, (byte)0xb3, (byte)0xf8, (byte)0x89,
+        (byte)0xde, (byte)0x71, (byte)0x1a, (byte)0xaf, (byte)0xba, (byte)0xb5, (byte)0x81 };
+
+    private static final byte[] SB3_sbox = { (byte)0x52, (byte)0x09, (byte)0x6a, (byte)0xd5, (byte)0x30, (byte)0x36,
+        (byte)0xa5, (byte)0x38, (byte)0xbf, (byte)0x40, (byte)0xa3, (byte)0x9e, (byte)0x81, (byte)0xf3, (byte)0xd7,
+        (byte)0xfb, (byte)0x7c, (byte)0xe3, (byte)0x39, (byte)0x82, (byte)0x9b, (byte)0x2f, (byte)0xff, (byte)0x87,
+        (byte)0x34, (byte)0x8e, (byte)0x43, (byte)0x44, (byte)0xc4, (byte)0xde, (byte)0xe9, (byte)0xcb, (byte)0x54,
+        (byte)0x7b, (byte)0x94, (byte)0x32, (byte)0xa6, (byte)0xc2, (byte)0x23, (byte)0x3d, (byte)0xee, (byte)0x4c,
+        (byte)0x95, (byte)0x0b, (byte)0x42, (byte)0xfa, (byte)0xc3, (byte)0x4e, (byte)0x08, (byte)0x2e, (byte)0xa1,
+        (byte)0x66, (byte)0x28, (byte)0xd9, (byte)0x24, (byte)0xb2, (byte)0x76, (byte)0x5b, (byte)0xa2, (byte)0x49,
+        (byte)0x6d, (byte)0x8b, (byte)0xd1, (byte)0x25, (byte)0x72, (byte)0xf8, (byte)0xf6, (byte)0x64, (byte)0x86,
+        (byte)0x68, (byte)0x98, (byte)0x16, (byte)0xd4, (byte)0xa4, (byte)0x5c, (byte)0xcc, (byte)0x5d, (byte)0x65,
+        (byte)0xb6, (byte)0x92, (byte)0x6c, (byte)0x70, (byte)0x48, (byte)0x50, (byte)0xfd, (byte)0xed, (byte)0xb9,
+        (byte)0xda, (byte)0x5e, (byte)0x15, (byte)0x46, (byte)0x57, (byte)0xa7, (byte)0x8d, (byte)0x9d, (byte)0x84,
+        (byte)0x90, (byte)0xd8, (byte)0xab, (byte)0x00, (byte)0x8c, (byte)0xbc, (byte)0xd3, (byte)0x0a, (byte)0xf7,
+        (byte)0xe4, (byte)0x58, (byte)0x05, (byte)0xb8, (byte)0xb3, (byte)0x45, (byte)0x06, (byte)0xd0, (byte)0x2c,
+        (byte)0x1e, (byte)0x8f, (byte)0xca, (byte)0x3f, (byte)0x0f, (byte)0x02, (byte)0xc1, (byte)0xaf, (byte)0xbd,
+        (byte)0x03, (byte)0x01, (byte)0x13, (byte)0x8a, (byte)0x6b, (byte)0x3a, (byte)0x91, (byte)0x11, (byte)0x41,
+        (byte)0x4f, (byte)0x67, (byte)0xdc, (byte)0xea, (byte)0x97, (byte)0xf2, (byte)0xcf, (byte)0xce, (byte)0xf0,
+        (byte)0xb4, (byte)0xe6, (byte)0x73, (byte)0x96, (byte)0xac, (byte)0x74, (byte)0x22, (byte)0xe7, (byte)0xad,
+        (byte)0x35, (byte)0x85, (byte)0xe2, (byte)0xf9, (byte)0x37, (byte)0xe8, (byte)0x1c, (byte)0x75, (byte)0xdf,
+        (byte)0x6e, (byte)0x47, (byte)0xf1, (byte)0x1a, (byte)0x71, (byte)0x1d, (byte)0x29, (byte)0xc5, (byte)0x89,
+        (byte)0x6f, (byte)0xb7, (byte)0x62, (byte)0x0e, (byte)0xaa, (byte)0x18, (byte)0xbe, (byte)0x1b, (byte)0xfc,
+        (byte)0x56, (byte)0x3e, (byte)0x4b, (byte)0xc6, (byte)0xd2, (byte)0x79, (byte)0x20, (byte)0x9a, (byte)0xdb,
+        (byte)0xc0, (byte)0xfe, (byte)0x78, (byte)0xcd, (byte)0x5a, (byte)0xf4, (byte)0x1f, (byte)0xdd, (byte)0xa8,
+        (byte)0x33, (byte)0x88, (byte)0x07, (byte)0xc7, (byte)0x31, (byte)0xb1, (byte)0x12, (byte)0x10, (byte)0x59,
+        (byte)0x27, (byte)0x80, (byte)0xec, (byte)0x5f, (byte)0x60, (byte)0x51, (byte)0x7f, (byte)0xa9, (byte)0x19,
+        (byte)0xb5, (byte)0x4a, (byte)0x0d, (byte)0x2d, (byte)0xe5, (byte)0x7a, (byte)0x9f, (byte)0x93, (byte)0xc9,
+        (byte)0x9c, (byte)0xef, (byte)0xa0, (byte)0xe0, (byte)0x3b, (byte)0x4d, (byte)0xae, (byte)0x2a, (byte)0xf5,
+        (byte)0xb0, (byte)0xc8, (byte)0xeb, (byte)0xbb, (byte)0x3c, (byte)0x83, (byte)0x53, (byte)0x99, (byte)0x61,
+        (byte)0x17, (byte)0x2b, (byte)0x04, (byte)0x7e, (byte)0xba, (byte)0x77, (byte)0xd6, (byte)0x26, (byte)0xe1,
+        (byte)0x69, (byte)0x14, (byte)0x63, (byte)0x55, (byte)0x21, (byte)0x0c, (byte)0x7d };
+
+    private static final byte[] SB4_sbox = { (byte)0x30, (byte)0x68, (byte)0x99, (byte)0x1b, (byte)0x87, (byte)0xb9,
+        (byte)0x21, (byte)0x78, (byte)0x50, (byte)0x39, (byte)0xdb, (byte)0xe1, (byte)0x72, (byte)0x9, (byte)0x62,
+        (byte)0x3c, (byte)0x3e, (byte)0x7e, (byte)0x5e, (byte)0x8e, (byte)0xf1, (byte)0xa0, (byte)0xcc, (byte)0xa3,
+        (byte)0x2a, (byte)0x1d, (byte)0xfb, (byte)0xb6, (byte)0xd6, (byte)0x20, (byte)0xc4, (byte)0x8d, (byte)0x81,
+        (byte)0x65, (byte)0xf5, (byte)0x89, (byte)0xcb, (byte)0x9d, (byte)0x77, (byte)0xc6, (byte)0x57, (byte)0x43,
+        (byte)0x56, (byte)0x17, (byte)0xd4, (byte)0x40, (byte)0x1a, (byte)0x4d, (byte)0xc0, (byte)0x63, (byte)0x6c,
+        (byte)0xe3, (byte)0xb7, (byte)0xc8, (byte)0x64, (byte)0x6a, (byte)0x53, (byte)0xaa, (byte)0x38, (byte)0x98,
+        (byte)0x0c, (byte)0xf4, (byte)0x9b, (byte)0xed, (byte)0x7f, (byte)0x22, (byte)0x76, (byte)0xaf, (byte)0xdd,
+        (byte)0x3a, (byte)0x0b, (byte)0x58, (byte)0x67, (byte)0x88, (byte)0x06, (byte)0xc3, (byte)0x35, (byte)0x0d,
+        (byte)0x01, (byte)0x8b, (byte)0x8c, (byte)0xc2, (byte)0xe6, (byte)0x5f, (byte)0x02, (byte)0x24, (byte)0x75,
+        (byte)0x93, (byte)0x66, (byte)0x1e, (byte)0xe5, (byte)0xe2, (byte)0x54, (byte)0xd8, (byte)0x10, (byte)0xce,
+        (byte)0x7a, (byte)0xe8, (byte)0x08, (byte)0x2c, (byte)0x12, (byte)0x97, (byte)0x32, (byte)0xab, (byte)0xb4,
+        (byte)0x27, (byte)0x0a, (byte)0x23, (byte)0xdf, (byte)0xef, (byte)0xca, (byte)0xd9, (byte)0xb8, (byte)0xfa,
+        (byte)0xdc, (byte)0x31, (byte)0x6b, (byte)0xd1, (byte)0xad, (byte)0x19, (byte)0x49, (byte)0xbd, (byte)0x51,
+        (byte)0x96, (byte)0xee, (byte)0xe4, (byte)0xa8, (byte)0x41, (byte)0xda, (byte)0xff, (byte)0xcd, (byte)0x55,
+        (byte)0x86, (byte)0x36, (byte)0xbe, (byte)0x61, (byte)0x52, (byte)0xf8, (byte)0xbb, (byte)0x0e, (byte)0x82,
+        (byte)0x48, (byte)0x69, (byte)0x9a, (byte)0xe0, (byte)0x47, (byte)0x9e, (byte)0x5c, (byte)0x04, (byte)0x4b,
+        (byte)0x34, (byte)0x15, (byte)0x79, (byte)0x26, (byte)0xa7, (byte)0xde, (byte)0x29, (byte)0xae, (byte)0x92,
+        (byte)0xd7, (byte)0x84, (byte)0xe9, (byte)0xd2, (byte)0xba, (byte)0x5d, (byte)0xf3, (byte)0xc5, (byte)0xb0,
+        (byte)0xbf, (byte)0xa4, (byte)0x3b, (byte)0x71, (byte)0x44, (byte)0x46, (byte)0x2b, (byte)0xfc, (byte)0xeb,
+        (byte)0x6f, (byte)0xd5, (byte)0xf6, (byte)0x14, (byte)0xfe, (byte)0x7c, (byte)0x70, (byte)0x5a, (byte)0x7d,
+        (byte)0xfd, (byte)0x2f, (byte)0x18, (byte)0x83, (byte)0x16, (byte)0xa5, (byte)0x91, (byte)0x1f, (byte)0x05,
+        (byte)0x95, (byte)0x74, (byte)0xa9, (byte)0xc1, (byte)0x5b, (byte)0x4a, (byte)0x85, (byte)0x6d, (byte)0x13,
+        (byte)0x07, (byte)0x4f, (byte)0x4e, (byte)0x45, (byte)0xb2, (byte)0x0f, (byte)0xc9, (byte)0x1c, (byte)0xa6,
+        (byte)0xbc, (byte)0xec, (byte)0x73, (byte)0x90, (byte)0x7b, (byte)0xcf, (byte)0x59, (byte)0x8f, (byte)0xa1,
+        (byte)0xf9, (byte)0x2d, (byte)0xf2, (byte)0xb1, (byte)0x00, (byte)0x94, (byte)0x37, (byte)0x9f, (byte)0xd0,
+        (byte)0x2e, (byte)0x9c, (byte)0x6e, (byte)0x28, (byte)0x3f, (byte)0x80, (byte)0xf0, (byte)0x3d, (byte)0xd3,
+        (byte)0x25, (byte)0x8a, (byte)0xb5, (byte)0xe7, (byte)0x42, (byte)0xb3, (byte)0xc7, (byte)0xea, (byte)0xf7,
+        (byte)0x4c, (byte)0x11, (byte)0x33, (byte)0x03, (byte)0xa2, (byte)0xac, (byte)0x60 };
+
+    protected static final int BLOCK_SIZE = 16;
+
+    private byte[][] roundKeys;
+    //private boolean forEncryption;
+
+    public void init(boolean forEncryption, CipherParameters params) throws IllegalArgumentException
+    {
+        if (!(params instanceof KeyParameter))
+        {
+            throw new IllegalArgumentException(
+                "invalid parameter passed to ARIA init - " + params.getClass().getName());
+        }
+
+        //this.forEncryption = forEncryption;
+        this.roundKeys = keySchedule(forEncryption, ((KeyParameter)params).getKey());
+    }
+
+    public String getAlgorithmName()
+    {
+        return "ARIA";
+    }
+
+    public int getBlockSize()
+    {
+        return BLOCK_SIZE;
+    }
+
+    public int processBlock(byte[] in, int inOff, byte[] out, int outOff)
+        throws DataLengthException, IllegalStateException
+    {
+        if (roundKeys == null)
+        {
+            throw new IllegalStateException("ARIA engine not initialised");
+        }
+        if (inOff > (in.length - BLOCK_SIZE))
+        {
+            throw new DataLengthException("input buffer too short");
+        }
+        if (outOff > (out.length - BLOCK_SIZE))
+        {
+            throw new OutputLengthException("output buffer too short");
+        }
+
+        byte[] z = new byte[BLOCK_SIZE];
+        System.arraycopy(in, inOff, z, 0, BLOCK_SIZE);
+
+        int i = 0, rounds = roundKeys.length - 3;
+        while (i < rounds)
+        {
+            FO(z, roundKeys[i++]);
+            FE(z, roundKeys[i++]);
+        }
+
+        FO(z, roundKeys[i++]);
+        xor(z, roundKeys[i++]);
+        SL2(z);
+        xor(z, roundKeys[i]);
+
+        System.arraycopy(z, 0, out, outOff, BLOCK_SIZE);
+
+        return BLOCK_SIZE;
+    }
+
+    public void reset()
+    {
+        // Empty
+    }
+
+    protected static void A(byte[] z)
+    {
+        byte x0 = z[0], x1 = z[1], x2 = z[2], x3 = z[3], x4 = z[4], x5 = z[5], x6 = z[6], x7 = z[7], x8 = z[8],
+            x9 = z[9], x10 = z[10], x11 = z[11], x12 = z[12], x13 = z[13], x14 = z[14], x15 = z[15];
+
+        z[0] = (byte)(x3 ^ x4 ^ x6 ^ x8 ^ x9 ^ x13 ^ x14);
+        z[1] = (byte)(x2 ^ x5 ^ x7 ^ x8 ^ x9 ^ x12 ^ x15);
+        z[2] = (byte)(x1 ^ x4 ^ x6 ^ x10 ^ x11 ^ x12 ^ x15);
+        z[3] = (byte)(x0 ^ x5 ^ x7 ^ x10 ^ x11 ^ x13 ^ x14);
+        z[4] = (byte)(x0 ^ x2 ^ x5 ^ x8 ^ x11 ^ x14 ^ x15);
+        z[5] = (byte)(x1 ^ x3 ^ x4 ^ x9 ^ x10 ^ x14 ^ x15);
+        z[6] = (byte)(x0 ^ x2 ^ x7 ^ x9 ^ x10 ^ x12 ^ x13);
+        z[7] = (byte)(x1 ^ x3 ^ x6 ^ x8 ^ x11 ^ x12 ^ x13);
+        z[8] = (byte)(x0 ^ x1 ^ x4 ^ x7 ^ x10 ^ x13 ^ x15);
+        z[9] = (byte)(x0 ^ x1 ^ x5 ^ x6 ^ x11 ^ x12 ^ x14);
+        z[10] = (byte)(x2 ^ x3 ^ x5 ^ x6 ^ x8 ^ x13 ^ x15);
+        z[11] = (byte)(x2 ^ x3 ^ x4 ^ x7 ^ x9 ^ x12 ^ x14);
+        z[12] = (byte)(x1 ^ x2 ^ x6 ^ x7 ^ x9 ^ x11 ^ x12);
+        z[13] = (byte)(x0 ^ x3 ^ x6 ^ x7 ^ x8 ^ x10 ^ x13);
+        z[14] = (byte)(x0 ^ x3 ^ x4 ^ x5 ^ x9 ^ x11 ^ x14);
+        z[15] = (byte)(x1 ^ x2 ^ x4 ^ x5 ^ x8 ^ x10 ^ x15);
+    }
+
+    protected static void FE(byte[] D, byte[] RK)
+    {
+        xor(D, RK);
+        SL2(D);
+        A(D);
+    }
+
+    protected static void FO(byte[] D, byte[] RK)
+    {
+        xor(D, RK);
+        SL1(D);
+        A(D);
+    }
+
+    protected static byte[][] keySchedule(boolean forEncryption, byte[] K)
+    {
+        int keyLen = K.length;
+        if (keyLen < 16 || keyLen > 32 || (keyLen & 7) != 0)
+        {
+            throw new IllegalArgumentException("Key length not 128/192/256 bits.");
+        }
+
+        int keyLenIdx = (keyLen >>> 3) - 2;
+
+        byte[] CK1 = C[keyLenIdx];
+        byte[] CK2 = C[(keyLenIdx + 1) % 3];
+        byte[] CK3 = C[(keyLenIdx + 2) % 3];
+
+        byte[] KL = new byte[16], KR = new byte[16];
+        System.arraycopy(K, 0, KL, 0, 16);
+        System.arraycopy(K, 16, KR, 0, keyLen - 16);
+
+        byte[] W0 = new byte[16];
+        byte[] W1 = new byte[16];
+        byte[] W2 = new byte[16];
+        byte[] W3 = new byte[16];
+
+        System.arraycopy(KL, 0, W0, 0, 16);
+
+        System.arraycopy(W0, 0, W1, 0, 16);
+        FO(W1, CK1);
+        xor(W1, KR);
+
+        System.arraycopy(W1, 0, W2, 0, 16);
+        FE(W2, CK2);
+        xor(W2, W0);
+
+        System.arraycopy(W2, 0, W3, 0, 16);
+        FO(W3, CK3);
+        xor(W3, W1);
+
+        int numRounds = 12 + (keyLenIdx * 2);
+        byte[][] rks = new byte[numRounds + 1][16];
+
+        keyScheduleRound(rks[0], W0, W1, 19);
+        keyScheduleRound(rks[1], W1, W2, 19);
+        keyScheduleRound(rks[2], W2, W3, 19);
+        keyScheduleRound(rks[3], W3, W0, 19);
+
+        keyScheduleRound(rks[4], W0, W1, 31);
+        keyScheduleRound(rks[5], W1, W2, 31);
+        keyScheduleRound(rks[6], W2, W3, 31);
+        keyScheduleRound(rks[7], W3, W0, 31);
+
+        keyScheduleRound(rks[8], W0, W1, 67);
+        keyScheduleRound(rks[9], W1, W2, 67);
+        keyScheduleRound(rks[10], W2, W3, 67);
+        keyScheduleRound(rks[11], W3, W0, 67);
+
+        keyScheduleRound(rks[12], W0, W1, 97);
+        if (numRounds > 12)
+        {
+            keyScheduleRound(rks[13], W1, W2, 97);
+            keyScheduleRound(rks[14], W2, W3, 97);
+            if (numRounds > 14)
+            {
+                keyScheduleRound(rks[15], W3, W0, 97);
+
+                keyScheduleRound(rks[16], W0, W1, 109);
+            }
+        }
+
+        if (!forEncryption)
+        {
+            reverseKeys(rks);
+
+            for (int i = 1; i < numRounds; ++i)
+            {
+                A(rks[i]);
+            }
+        }
+
+        return rks;
+    }
+
+    protected static void keyScheduleRound(byte[] rk, byte[] w, byte[] wr, int n)
+    {
+        int off = n >>> 3, right = n & 7, left = 8 - right;
+
+        int hi = wr[15 - off] & 0xFF;
+
+        for (int to = 0; to < 16; ++to)
+        {
+            int lo = wr[(to - off) & 0xF] & 0xFF;
+
+            int b = (hi << left) | (lo >>> right);
+            b ^= (w[to] & 0xFF);
+
+            rk[to] = (byte)b;
+
+            hi = lo;
+        }
+    }
+
+    protected static void reverseKeys(byte[][] keys)
+    {
+        int length = keys.length, limit = length / 2, last = length - 1;
+        for (int i = 0; i < limit; ++i)
+        {
+            byte[] t = keys[i];
+            keys[i] = keys[last - i];
+            keys[last - i] = t;
+        }
+    }
+
+    protected static byte SB1(byte x)
+    {
+        return SB1_sbox[x & 0xFF];
+    }
+
+    protected static byte SB2(byte x)
+    {
+        return SB2_sbox[x & 0xFF];
+    }
+
+    protected static byte SB3(byte x)
+    {
+        return SB3_sbox[x & 0xFF];
+    }
+
+    protected static byte SB4(byte x)
+    {
+        return SB4_sbox[x & 0xFF];
+    }
+
+    protected static void SL1(byte[] z)
+    {
+        z[0] = SB1(z[0]);
+        z[1] = SB2(z[1]);
+        z[2] = SB3(z[2]);
+        z[3] = SB4(z[3]);
+        z[4] = SB1(z[4]);
+        z[5] = SB2(z[5]);
+        z[6] = SB3(z[6]);
+        z[7] = SB4(z[7]);
+        z[8] = SB1(z[8]);
+        z[9] = SB2(z[9]);
+        z[10] = SB3(z[10]);
+        z[11] = SB4(z[11]);
+        z[12] = SB1(z[12]);
+        z[13] = SB2(z[13]);
+        z[14] = SB3(z[14]);
+        z[15] = SB4(z[15]);
+    }
+
+    protected static void SL2(byte[] z)
+    {
+        z[0] = SB3(z[0]);
+        z[1] = SB4(z[1]);
+        z[2] = SB1(z[2]);
+        z[3] = SB2(z[3]);
+        z[4] = SB3(z[4]);
+        z[5] = SB4(z[5]);
+        z[6] = SB1(z[6]);
+        z[7] = SB2(z[7]);
+        z[8] = SB3(z[8]);
+        z[9] = SB4(z[9]);
+        z[10] = SB1(z[10]);
+        z[11] = SB2(z[11]);
+        z[12] = SB3(z[12]);
+        z[13] = SB4(z[13]);
+        z[14] = SB1(z[14]);
+        z[15] = SB2(z[15]);
+    }
+
+    protected static void xor(byte[] z, byte[] x)
+    {
+        for (int i = 0; i < 16; ++i)
+        {
+            z[i] ^= x[i];
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAWrapEngine.java b/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAWrapEngine.java
new file mode 100644
index 0000000..8630c89
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAWrapEngine.java
@@ -0,0 +1,29 @@
+package org.bouncycastle.crypto.engines;
+
+/**
+ * an implementation of the ARIA Key Wrapper from the NIST Key Wrap
+ * Specification.
+ * <p>
+ * For further details see: <a href="http://csrc.nist.gov/encryption/kms/key-wrap.pdf">http://csrc.nist.gov/encryption/kms/key-wrap.pdf</a>.
+ */
+public class ARIAWrapEngine
+    extends RFC3394WrapEngine
+{
+    /**
+     * Create a regular AESWrapEngine specifying the encrypt for wrapping, decrypt for unwrapping.
+     */
+    public ARIAWrapEngine()
+    {
+        super(new ARIAEngine());
+    }
+
+    /**
+     * Create an AESWrapEngine where the underlying cipher is set to decrypt for wrapping, encrypt for unwrapping.
+     *
+     * @param useReverseDirection true if underlying cipher should be used in decryption mode, false otherwise.
+     */
+    public ARIAWrapEngine(boolean useReverseDirection)
+    {
+        super(new ARIAEngine(), useReverseDirection);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAWrapPadEngine.java b/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAWrapPadEngine.java
new file mode 100644
index 0000000..ac2b06b
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/engines/ARIAWrapPadEngine.java
@@ -0,0 +1,10 @@
+package org.bouncycastle.crypto.engines;
+
+public class ARIAWrapPadEngine
+    extends RFC5649WrapEngine
+{
+    public ARIAWrapPadEngine()
+    {
+        super(new ARIAEngine());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/engines/SM2Engine.java b/bcprov/src/main/java/org/bouncycastle/crypto/engines/SM2Engine.java
new file mode 100644
index 0000000..64a2a2d
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/engines/SM2Engine.java
@@ -0,0 +1,257 @@
+package org.bouncycastle.crypto.engines;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.crypto.InvalidCipherTextException;
+import org.bouncycastle.crypto.digests.SM3Digest;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECKeyParameters;
+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
+import org.bouncycastle.crypto.params.ECPublicKeyParameters;
+import org.bouncycastle.crypto.params.ParametersWithRandom;
+import org.bouncycastle.math.ec.ECConstants;
+import org.bouncycastle.math.ec.ECFieldElement;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.BigIntegers;
+
+/**
+ * SM2 public key encryption engine - based on https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02.
+ */
+public class SM2Engine
+{
+    private final Digest digest;
+    
+    private boolean forEncryption;
+    private ECKeyParameters ecKey;
+    private ECDomainParameters ecParams;
+    private int curveLength;
+    private SecureRandom random;
+
+    public SM2Engine()
+    {
+        this(new SM3Digest());
+    }
+
+    public SM2Engine(Digest digest)
+    {
+        this.digest = digest;
+    }
+
+    public void init(boolean forEncryption, CipherParameters param)
+    {
+        this.forEncryption = forEncryption;
+
+        if (forEncryption)
+        {
+            ParametersWithRandom rParam = (ParametersWithRandom)param;
+
+            ecKey = (ECKeyParameters)rParam.getParameters();
+            ecParams = ecKey.getParameters();
+
+            ECPoint s = ((ECPublicKeyParameters)ecKey).getQ().multiply(ecParams.getH());
+            if (s.isInfinity())
+            {
+                throw new IllegalArgumentException("invalid key: [h]Q at infinity");
+            }
+
+            random = rParam.getRandom();
+        }
+        else
+        {
+            ecKey = (ECKeyParameters)param;
+            ecParams = ecKey.getParameters();
+        }
+
+        curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;
+    }
+
+    public byte[] processBlock(
+        byte[] in,
+        int inOff,
+        int inLen)
+        throws InvalidCipherTextException
+    {
+        if (forEncryption)
+        {
+            return encrypt(in, inOff, inLen);
+        }
+        else
+        {
+            return decrypt(in, inOff, inLen);
+        }
+    }
+
+    private byte[] encrypt(byte[] in, int inOff, int inLen)
+        throws InvalidCipherTextException
+    {
+        byte[] c2 = new byte[inLen];
+
+        System.arraycopy(in, inOff, c2, 0, c2.length);
+
+        byte[] c1;
+        ECPoint kPB;
+        do
+        {
+            BigInteger k = nextK();
+
+            ECPoint c1P = ecParams.getG().multiply(k).normalize();
+
+            c1 = c1P.getEncoded(false);
+
+            kPB = ((ECPublicKeyParameters)ecKey).getQ().multiply(k).normalize();
+
+            kdf(digest, kPB, c2);
+        }
+        while (notEncrypted(c2, in, inOff));
+
+        byte[] c3 = new byte[digest.getDigestSize()];
+
+        addFieldElement(digest, kPB.getAffineXCoord());
+        digest.update(in, inOff, inLen);
+        addFieldElement(digest, kPB.getAffineYCoord());
+
+        digest.doFinal(c3, 0);
+        
+        return Arrays.concatenate(c1, c2, c3);
+    }
+
+    private byte[] decrypt(byte[] in, int inOff, int inLen)
+        throws InvalidCipherTextException
+    {
+        byte[] c1 = new byte[curveLength * 2 + 1];
+
+        System.arraycopy(in, inOff, c1, 0, c1.length);
+
+        ECPoint c1P = ecParams.getCurve().decodePoint(c1);
+
+        ECPoint s = c1P.multiply(ecParams.getH());
+        if (s.isInfinity())
+        {
+            throw new InvalidCipherTextException("[h]C1 at infinity");
+        }
+
+        c1P = c1P.multiply(((ECPrivateKeyParameters)ecKey).getD()).normalize();
+
+        byte[] c2 = new byte[inLen - c1.length - digest.getDigestSize()];
+
+        System.arraycopy(in, inOff + c1.length, c2, 0, c2.length);
+
+        kdf(digest, c1P, c2);
+
+        byte[] c3 = new byte[digest.getDigestSize()];
+
+        addFieldElement(digest, c1P.getAffineXCoord());
+        digest.update(c2, 0, c2.length);
+        addFieldElement(digest, c1P.getAffineYCoord());
+
+        digest.doFinal(c3, 0);
+
+        int check = 0;
+        for (int i = 0; i != c3.length; i++)
+        {
+            check |= c3[i] ^ in[c1.length + c2.length + i];
+        }
+
+        clearBlock(c1);
+        clearBlock(c3);
+
+        if (check != 0)
+        {
+           clearBlock(c2);
+           throw new InvalidCipherTextException("invalid cipher text");
+        }
+
+        return c2;
+    }
+
+    private boolean notEncrypted(byte[] encData, byte[] in, int inOff)
+    {
+        for (int i = 0; i != encData.length; i++)
+        {
+            if (encData[i] != in[inOff])
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private void kdf(Digest digest, ECPoint c1, byte[] encData)
+    {
+        int ct = 1;
+        int v = digest.getDigestSize();
+
+        byte[] buf = new byte[digest.getDigestSize()];
+        int off = 0;
+
+        for (int i = 1; i <= ((encData.length + v - 1) / v); i++)
+        {
+            addFieldElement(digest, c1.getAffineXCoord());
+            addFieldElement(digest, c1.getAffineYCoord());
+            digest.update((byte)(ct >> 24));
+            digest.update((byte)(ct >> 16));
+            digest.update((byte)(ct >> 8));
+            digest.update((byte)ct);
+
+            digest.doFinal(buf, 0);
+
+            if (off + buf.length < encData.length)
+            {
+                xor(encData, buf, off, buf.length);
+            }
+            else
+            {
+                xor(encData, buf, off, encData.length - off);
+            }
+
+            off += buf.length;
+            ct++;
+        }
+    }
+
+    private void xor(byte[] data, byte[] kdfOut, int dOff, int dRemaining)
+    {
+        for (int i = 0; i != dRemaining; i++)
+        {
+            data[dOff + i] ^= kdfOut[i];
+        }
+    }
+
+    private BigInteger nextK()
+    {
+        int qBitLength = ecParams.getN().bitLength();
+
+        BigInteger k;
+        do
+        {
+            k = new BigInteger(qBitLength, random);
+        }
+        while (k.equals(ECConstants.ZERO) || k.compareTo(ecParams.getN()) >= 0);
+
+        return k;
+    }
+
+    private void addFieldElement(Digest digest, ECFieldElement v)
+    {
+        byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());
+
+        digest.update(p, 0, p.length);
+    }
+
+    /**
+     * clear possible sensitive data
+     */
+    private void clearBlock(
+        byte[]  block)
+    {
+        for (int i = 0; i != block.length; i++)
+        {
+            block[i] = 0;
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/generators/HKDFBytesGenerator.java b/bcprov/src/main/java/org/bouncycastle/crypto/generators/HKDFBytesGenerator.java
index 75915cf..ada204f 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/generators/HKDFBytesGenerator.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/generators/HKDFBytesGenerator.java
@@ -72,7 +72,6 @@
      */
     private KeyParameter extract(byte[] salt, byte[] ikm)
     {
-        hMacHash.init(new KeyParameter(ikm));
         if (salt == null)
         {
             // TODO check if hashLen is indeed same as HMAC size
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/modes/GCMBlockCipher.java b/bcprov/src/main/java/org/bouncycastle/crypto/modes/GCMBlockCipher.java
index ca609ed..e9235c4 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/modes/GCMBlockCipher.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/modes/GCMBlockCipher.java
@@ -32,6 +32,7 @@
 
     // These fields are set by init and not modified by processing
     private boolean             forEncryption;
+    private boolean             initialised;
     private int                 macSize;
     private byte[]              lastKey;
     private byte[]              nonce;
@@ -94,6 +95,7 @@
     {
         this.forEncryption = forEncryption;
         this.macBlock = null;
+        this.initialised = true;
 
         KeyParameter keyParam;
         byte[] newNonce = null;
@@ -247,6 +249,7 @@
 
     public void processAADByte(byte in)
     {
+        checkStatus();
         atBlock[atBlockPos] = in;
         if (++atBlockPos == BLOCK_SIZE)
         {
@@ -296,6 +299,8 @@
     public int processByte(byte in, byte[] out, int outOff)
         throws DataLengthException
     {
+        checkStatus();
+        
         bufBlock[bufOff] = in;
         if (++bufOff == bufBlock.length)
         {
@@ -308,6 +313,8 @@
     public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff)
         throws DataLengthException
     {
+        checkStatus();
+
         if (in.length < (inOff + len))
         {
             throw new DataLengthException("Input buffer too short");
@@ -352,6 +359,8 @@
     public int doFinal(byte[] out, int outOff)
         throws IllegalStateException, InvalidCipherTextException
     {
+        checkStatus();
+
         if (totalLength == 0)
         {
             initCipher();
@@ -501,9 +510,16 @@
             macBlock = null;
         }
 
-        if (initialAssociatedText != null)
+        if (forEncryption)
         {
-            processAADBytes(initialAssociatedText, 0, initialAssociatedText.length);
+            initialised = false;
+        }
+        else
+        {
+            if (initialAssociatedText != null)
+            {
+                processAADBytes(initialAssociatedText, 0, initialAssociatedText.length);
+            }
         }
     }
 
@@ -571,4 +587,16 @@
         cipher.processBlock(counter, 0, tmp, 0);
         return tmp;
     }
+
+    private void checkStatus()
+    {
+        if (!initialised)
+        {
+            if (forEncryption)
+            {
+                throw new IllegalStateException("GCM cipher cannot be reused for encryption");
+            }
+            throw new IllegalStateException("GCM cipher needs to be initialised");
+        }
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/modes/GOFBBlockCipher.java b/bcprov/src/main/java/org/bouncycastle/crypto/modes/GOFBBlockCipher.java
index b025a1b..0e0e1dc 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/modes/GOFBBlockCipher.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/modes/GOFBBlockCipher.java
@@ -204,6 +204,13 @@
             }
             N3 += C2;
             N4 += C1;
+            if (N4 < C1)  // addition is mod (2**32 - 1)
+            {
+                if (N4 > 0)
+                {
+                    N4++;
+                }
+            }
             intTobytes(N3, ofbV, 0);
             intTobytes(N4, ofbV, 4);
 
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/params/ParametersWithID.java b/bcprov/src/main/java/org/bouncycastle/crypto/params/ParametersWithID.java
new file mode 100644
index 0000000..e942a5a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/params/ParametersWithID.java
@@ -0,0 +1,28 @@
+package org.bouncycastle.crypto.params;
+
+import org.bouncycastle.crypto.CipherParameters;
+
+public class ParametersWithID
+    implements CipherParameters
+{
+    private CipherParameters  parameters;
+    private byte[] id;
+
+    public ParametersWithID(
+        CipherParameters parameters,
+        byte[] id)
+    {
+        this.parameters = parameters;
+        this.id = id;
+    }
+
+    public byte[] getID()
+    {
+        return id;
+    }
+
+    public CipherParameters getParameters()
+    {
+        return parameters;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/params/SM2KeyExchangePrivateParameters.java b/bcprov/src/main/java/org/bouncycastle/crypto/params/SM2KeyExchangePrivateParameters.java
new file mode 100644
index 0000000..fe8038c
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/params/SM2KeyExchangePrivateParameters.java
@@ -0,0 +1,68 @@
+package org.bouncycastle.crypto.params;
+
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.math.ec.ECPoint;
+
+/**
+ * Public parameters for an SM2 key exchange. The ephemeralPrivateKey is used to calculate the random point used in the algorithm.
+ */
+public class SM2KeyExchangePrivateParameters
+    implements CipherParameters
+{
+    private final boolean initiator;
+    private final ECPrivateKeyParameters staticPrivateKey;
+    private final ECPoint staticPublicPoint;
+    private final ECPrivateKeyParameters ephemeralPrivateKey;
+    private final ECPoint ephemeralPublicPoint;
+
+    public SM2KeyExchangePrivateParameters(
+        boolean initiator,
+        ECPrivateKeyParameters staticPrivateKey,
+        ECPrivateKeyParameters ephemeralPrivateKey)
+    {
+        if (staticPrivateKey == null)
+        {
+            throw new NullPointerException("staticPrivateKey cannot be null");
+        }
+        if (ephemeralPrivateKey == null)
+        {
+            throw new NullPointerException("ephemeralPrivateKey cannot be null");
+        }
+
+        ECDomainParameters parameters = staticPrivateKey.getParameters();
+        if (!parameters.equals(ephemeralPrivateKey.getParameters()))
+        {
+            throw new IllegalArgumentException("Static and ephemeral private keys have different domain parameters");
+        }
+
+        this.initiator = initiator;
+        this.staticPrivateKey = staticPrivateKey;
+        this.staticPublicPoint = parameters.getG().multiply(staticPrivateKey.getD()).normalize();
+        this.ephemeralPrivateKey = ephemeralPrivateKey;
+        this.ephemeralPublicPoint = parameters.getG().multiply(ephemeralPrivateKey.getD()).normalize();
+    }
+
+    public boolean isInitiator()
+    {
+        return initiator;
+    }
+    public ECPrivateKeyParameters getStaticPrivateKey()
+    {
+        return staticPrivateKey;
+    }
+
+    public ECPoint getStaticPublicPoint()
+    {
+        return staticPublicPoint;
+    }
+
+    public ECPrivateKeyParameters getEphemeralPrivateKey()
+    {
+        return ephemeralPrivateKey;
+    }
+
+    public ECPoint getEphemeralPublicPoint()
+    {
+        return ephemeralPublicPoint;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/params/SM2KeyExchangePublicParameters.java b/bcprov/src/main/java/org/bouncycastle/crypto/params/SM2KeyExchangePublicParameters.java
new file mode 100644
index 0000000..dadcee9
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/params/SM2KeyExchangePublicParameters.java
@@ -0,0 +1,44 @@
+package org.bouncycastle.crypto.params;
+
+import org.bouncycastle.crypto.CipherParameters;
+
+/**
+ * Public parameters for an SM2 key exchange. In this case the ephemeralPublicKey provides the random point used in the algorithm.
+ */
+public class SM2KeyExchangePublicParameters
+    implements CipherParameters
+{
+    private ECPublicKeyParameters staticPublicKey;
+    private ECPublicKeyParameters ephemeralPublicKey;
+
+    public SM2KeyExchangePublicParameters(
+        ECPublicKeyParameters   staticPublicKey,
+        ECPublicKeyParameters   ephemeralPublicKey)
+    {
+        if (staticPublicKey == null)
+        {
+            throw new NullPointerException("staticPublicKey cannot be null");
+        }
+        if (ephemeralPublicKey == null)
+        {
+            throw new NullPointerException("ephemeralPublicKey cannot be null");
+        }
+        if (!staticPublicKey.getParameters().equals(ephemeralPublicKey.getParameters()))
+        {
+            throw new IllegalArgumentException("Static and ephemeral public keys have different domain parameters");
+        }
+
+        this.staticPublicKey = staticPublicKey;
+        this.ephemeralPublicKey = ephemeralPublicKey;
+    }
+
+    public ECPublicKeyParameters getStaticPublicKey()
+    {
+        return staticPublicKey;
+    }
+
+    public ECPublicKeyParameters getEphemeralPublicKey()
+    {
+        return ephemeralPublicKey;
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/prng/SP800SecureRandom.java b/bcprov/src/main/java/org/bouncycastle/crypto/prng/SP800SecureRandom.java
index 4d861c6..7ebeece 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/prng/SP800SecureRandom.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/prng/SP800SecureRandom.java
@@ -67,4 +67,14 @@
     {
         return EntropyUtil.generateSeed(entropySource, numBytes);
     }
+
+    /**
+     * Force a reseed of the DRBG
+     *
+     * @param additionalInput optional additional input
+     */
+    public void reseed(byte[] additionalInput)
+    {
+        drbg.reseed(additionalInput);
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2PSSSigner.java b/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2PSSSigner.java
index cc2ed0f..1c56142 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2PSSSigner.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2PSSSigner.java
@@ -551,6 +551,7 @@
         if (!isOkay)
         {
             fullMessage = false;
+            messageLength = 0;
             clearBlock(recoveredMessage);
             return false;
         }
@@ -563,11 +564,14 @@
         {
             if (!isSameAs(mBuf, recoveredMessage))
             {
+                messageLength = 0;
                 clearBlock(mBuf);
                 return false;
             }
-            messageLength = 0;
+
         }
+        
+        messageLength = 0;
 
         clearBlock(mBuf);
         return true;
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2Signer.java b/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2Signer.java
index 32ed423..dd63a21 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2Signer.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/signers/ISO9796d2Signer.java
@@ -397,6 +397,8 @@
         fullMessage = (header & 0x20) == 0;
         System.arraycopy(mBuf, 0, recoveredMessage, 0, recoveredMessage.length);
 
+        messageLength = 0;
+        
         clearBlock(mBuf);
         clearBlock(block);
 
@@ -579,11 +581,15 @@
         clearBlock(mBuf);
         clearBlock(block);
 
+        messageLength = 0;
+
         return true;
     }
 
     private boolean returnFalse(byte[] block)
     {
+        messageLength = 0;
+
         clearBlock(mBuf);
         clearBlock(block);
 
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/signers/SM2Signer.java b/bcprov/src/main/java/org/bouncycastle/crypto/signers/SM2Signer.java
new file mode 100644
index 0000000..ce1b9a4
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/signers/SM2Signer.java
@@ -0,0 +1,222 @@
+package org.bouncycastle.crypto.signers;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.crypto.DSA;
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.crypto.digests.SM3Digest;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECKeyParameters;
+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
+import org.bouncycastle.crypto.params.ECPublicKeyParameters;
+import org.bouncycastle.crypto.params.ParametersWithID;
+import org.bouncycastle.crypto.params.ParametersWithRandom;
+import org.bouncycastle.math.ec.ECConstants;
+import org.bouncycastle.math.ec.ECFieldElement;
+import org.bouncycastle.math.ec.ECMultiplier;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.math.ec.FixedPointCombMultiplier;
+import org.bouncycastle.util.BigIntegers;
+
+public class SM2Signer
+    implements DSA, ECConstants
+{
+    private final DSAKCalculator kCalculator = new RandomDSAKCalculator();
+
+    private byte[] userID;
+
+    private int curveLength;
+    private ECDomainParameters ecParams;
+    private ECPoint pubPoint;
+    private ECKeyParameters ecKey;
+
+    private SecureRandom random;
+
+    public void init(boolean forSigning, CipherParameters param)
+    {
+        CipherParameters baseParam;
+
+        if (param instanceof ParametersWithID)
+        {
+            baseParam = ((ParametersWithID)param).getParameters();
+            userID = ((ParametersWithID)param).getID();
+        }
+        else
+        {
+            baseParam = param;
+            userID = new byte[0];
+        }
+
+        if (forSigning)
+        {
+            if (baseParam instanceof ParametersWithRandom)
+            {
+                ParametersWithRandom rParam = (ParametersWithRandom)baseParam;
+
+                ecKey = (ECKeyParameters)rParam.getParameters();
+                ecParams = ecKey.getParameters();
+                kCalculator.init(ecParams.getN(), rParam.getRandom());
+            }
+            else
+            {
+                ecKey = (ECKeyParameters)baseParam;
+                ecParams = ecKey.getParameters();
+                kCalculator.init(ecParams.getN(), new SecureRandom());
+            }
+            pubPoint = ecParams.getG().multiply(((ECPrivateKeyParameters)ecKey).getD()).normalize();
+        }
+        else
+        {
+            ecKey = (ECKeyParameters)baseParam;
+            ecParams = ecKey.getParameters();
+            pubPoint = ((ECPublicKeyParameters)ecKey).getQ();
+        }
+
+        curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;
+    }
+
+    public BigInteger[] generateSignature(byte[] message)
+    {
+        SM3Digest digest = new SM3Digest();
+
+        byte[] z = getZ(digest);
+
+        digest.update(z, 0, z.length);
+        digest.update(message, 0, message.length);
+
+        byte[] eHash = new byte[digest.getDigestSize()];
+
+        digest.doFinal(eHash, 0);
+
+        BigInteger n = ecParams.getN();
+        BigInteger e = calculateE(eHash);
+        BigInteger d = ((ECPrivateKeyParameters)ecKey).getD();
+
+        BigInteger r, s;
+
+        ECMultiplier basePointMultiplier = createBasePointMultiplier();
+
+        // 5.2.1 Draft RFC:  SM2 Public Key Algorithms
+        do // generate s
+        {
+            BigInteger k;
+            do // generate r
+            {
+                // A3
+                k = kCalculator.nextK();
+
+                // A4
+                ECPoint p = basePointMultiplier.multiply(ecParams.getG(), k).normalize();
+
+                // A5
+                r = e.add(p.getAffineXCoord().toBigInteger()).mod(n);
+            }
+            while (r.equals(ZERO) || r.add(k).equals(n));
+
+            // A6
+            BigInteger dPlus1ModN = d.add(ONE).modInverse(n);
+
+            s = k.subtract(r.multiply(d)).mod(n);
+            s = dPlus1ModN.multiply(s).mod(n);
+        }
+        while (s.equals(ZERO));
+
+        // A7
+        return new BigInteger[]{ r, s };
+    }
+
+    public boolean verifySignature(byte[] message, BigInteger r, BigInteger s)
+    {
+        BigInteger n = ecParams.getN();
+
+        // 5.3.1 Draft RFC:  SM2 Public Key Algorithms
+        // B1
+        if (r.compareTo(ONE) < 0 || r.compareTo(n) > 0)
+        {
+            return false;
+        }
+
+        // B2
+        if (s.compareTo(ONE) < 0 || s.compareTo(n) > 0)
+        {
+            return false;
+        }
+
+        ECPoint q = ((ECPublicKeyParameters)ecKey).getQ();
+
+        SM3Digest digest = new SM3Digest();
+
+        byte[] z = getZ(digest);
+
+        digest.update(z, 0, z.length);
+        digest.update(message, 0, message.length);
+
+        byte[] eHash = new byte[digest.getDigestSize()];
+
+        // B3
+        digest.doFinal(eHash, 0);
+
+        // B4
+        BigInteger e = calculateE(eHash);
+
+        // B5
+        BigInteger t = r.add(s).mod(n);
+        if (t.equals(ZERO))
+        {
+            return false;
+        }
+        else
+        {
+            // B6
+            ECPoint x1y1 = ecParams.getG().multiply(s);
+            x1y1 = x1y1.add(q.multiply(t)).normalize();
+
+            // B7
+            return r.equals(e.add(x1y1.getAffineXCoord().toBigInteger()).mod(n));
+        }
+    }
+
+    private byte[] getZ(Digest digest)
+    {
+        addUserID(digest, userID);
+
+        addFieldElement(digest, ecParams.getCurve().getA());
+        addFieldElement(digest, ecParams.getCurve().getB());
+        addFieldElement(digest, ecParams.getG().getAffineXCoord());
+        addFieldElement(digest, ecParams.getG().getAffineYCoord());
+        addFieldElement(digest, pubPoint.getAffineXCoord());
+        addFieldElement(digest, pubPoint.getAffineYCoord());
+
+        byte[] rv = new byte[digest.getDigestSize()];
+
+        digest.doFinal(rv, 0);
+
+        return rv;
+    }
+
+    private void addUserID(Digest digest, byte[] userID)
+    {
+        int len = userID.length * 8;
+        digest.update((byte)(len >> 8 & 0xFF));
+        digest.update((byte)(len & 0xFF));
+        digest.update(userID, 0, userID.length);
+    }
+
+    private void addFieldElement(Digest digest, ECFieldElement v)
+    {
+        byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());
+        digest.update(p, 0, p.length);
+    }
+
+    protected ECMultiplier createBasePointMultiplier()
+    {
+        return new FixedPointCombMultiplier();
+    }
+
+    protected BigInteger calculateE(byte[] message)
+    {
+        return new BigInteger(1, message);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/AESWrapPadTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/AESWrapPadTest.java
index f8769e8..93342cb 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/test/AESWrapPadTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/AESWrapPadTest.java
@@ -1,173 +1,173 @@
-package org.bouncycastle.crypto.test;
-
-import java.security.SecureRandom;
-
-import org.bouncycastle.crypto.Wrapper;
-import org.bouncycastle.crypto.engines.AESWrapPadEngine;
-import org.bouncycastle.crypto.params.KeyParameter;
-import org.bouncycastle.crypto.params.ParametersWithIV;
-import org.bouncycastle.util.Arrays;
-import org.bouncycastle.util.encoders.Hex;
-import org.bouncycastle.util.test.SimpleTest;
-
-/**
- * This is a test harness I use because I cannot modify the BC test harness without
- * invalidating the signature on their signed provider library. The code here is not
- * high quality but it does test the RFC vectors as well as randomly generated values.
- * The RFC test vectors are tested by making sure both the ciphertext and decrypted
- * values match the expected values whereas the random values are just checked to make
- * sure that:
- * <p>unwrap(wrap(random_value, random_kek), random_kek) == random_value.</p>
- */
-
-public class AESWrapPadTest
-    extends SimpleTest
-{
-
-    private final int numOfRandomIterations = 100;
-
-    public AESWrapPadTest()
-    {
-
-    }
-
-    private void wrapAndUnwrap(byte[] kek, byte[] key, byte[] expected)
-        throws Exception
-    {
-        Wrapper wrapper = new AESWrapPadEngine();
-
-        wrapper.init(true, new KeyParameter(kek));
-
-        byte[] cipherText = wrapper.wrap(key, 0, key.length);
-        if (!areEqual(cipherText, expected))
-        {
-            fail("Wrapped value does not match expected.");
-        }
-        wrapper.init(false, new KeyParameter(kek));
-        byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);
-
-        if (!areEqual(key, plainText))
-        {
-            fail("Unwrapped value does not match original.");
-        }
-    }
-
-    private void wrapAndUnwrap(byte[] kek, byte[] key)
-        throws Exception
-    {
-        Wrapper wrapper = new AESWrapPadEngine();
-
-        wrapper.init(true, new KeyParameter(kek));
-
-        byte[] cipherText = wrapper.wrap(key, 0, key.length);
-
-        wrapper.init(false, new KeyParameter(kek));
-        byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);
-
-        if (!areEqual(key, plainText))
-        {
-            fail("Unwrapped value does not match original.");
-        }
-    }
-
-    private void wrapWithIVTest()
-        throws Exception
-    {
-        byte[] kek = Hex.decode("5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8");
-        byte[] key = Hex.decode("c37b7e6492584340bed12207808941155068f738");
-        byte[] expected = Hex.decode("5cbdb3fb71351d0e628b85dbcba1a1890d4db26d1335e11d1aabea11124caad0");
-
-        Wrapper wrapper = new AESWrapPadEngine();
-
-        wrapper.init(true, new ParametersWithIV(new KeyParameter(kek), Hex.decode("33333333")));
-
-        byte[] cipherText = wrapper.wrap(key, 0, key.length);
-        if (!areEqual(cipherText, expected))
-        {
-            fail("Wrapped value does not match expected.");
-        }
-        wrapper.init(false, new ParametersWithIV(new KeyParameter(kek), Hex.decode("33333333")));
-        byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);
-
-        if (!areEqual(key, plainText))
-        {
-            fail("Unwrapped value does not match original.");
-        }
-    }
-
-    public String getName()
-    {
-        return "AESWrapPad";
-    }
-
-    public void performTest()
-        throws Exception
-    {
-        // test RFC 5649 test vectors
-        byte[] kek = Hex.decode("5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8");
-        byte[] key = Hex.decode("c37b7e6492584340bed12207808941155068f738");
-        byte[] wrap = Hex.decode("138bdeaa9b8fa7fc61f97742e72248ee5ae6ae5360d1ae6a5f54f373fa543b6a");
-
-        wrapAndUnwrap(kek, key, wrap);
-
-        wrap = Hex.decode("afbeb0f07dfbf5419200f2ccb50bb24f");
-        key = Hex.decode("466f7250617369");
-        wrapAndUnwrap(kek, key, wrap);
-
-        wrapWithIVTest();
-
-        //
-        // offset test
-        //
-        Wrapper wrapper = new AESWrapPadEngine();
-
-        byte[] pText = new byte[5 + key.length];
-        byte[]  cText;
-
-        System.arraycopy(key, 0, pText, 5, key.length);
-
-        wrapper.init(true, new KeyParameter(kek));
-
-        cText = wrapper.wrap(pText, 5, key.length);
-        if (!Arrays.areEqual(cText, wrap))
-        {
-            fail("failed offset wrap test expected " + new String(Hex.encode(wrap)) + " got " + new String(Hex.encode(cText)));
-        }
-
-        wrapper.init(false, new KeyParameter(kek));
-
-        cText = new byte[6 + wrap.length];
-        System.arraycopy(wrap, 0, cText, 6, wrap.length);
-
-        pText = wrapper.unwrap(cText, 6, wrap.length);
-        if (!Arrays.areEqual(pText, key))
-        {
-            fail("failed offset unwrap test expected " + new String(Hex.encode(key)) + " got " + new String(Hex.encode(pText)));
-        }
-
-        // test random values
-        SecureRandom rnd = new SecureRandom();
-        for (int i = 0; i < numOfRandomIterations; i++)
-        {
-            int kekLength = 128;
-            boolean shouldIncrease = (rnd.nextInt() & 0x01) != 0;
-            if (shouldIncrease)
-            {
-                kekLength = 256;
-            }
-            kek = new byte[kekLength / 8];
-            rnd.nextBytes(kek);
-            int keyToWrapSize = RNGUtils.nextInt(rnd, 256 / 8 - 8) + 8;
-            byte[] keyToWrap = new byte[keyToWrapSize];
-            rnd.nextBytes(keyToWrap);
-            wrapAndUnwrap(kek, keyToWrap);
-        }
-    }
-
-    public static void main(
-        String[]    args)
-    {
-        runTest(new AESWrapPadTest());
-    }
-}
-
+package org.bouncycastle.crypto.test;
+
+import java.security.SecureRandom;
+
+import org.bouncycastle.crypto.Wrapper;
+import org.bouncycastle.crypto.engines.AESWrapPadEngine;
+import org.bouncycastle.crypto.params.KeyParameter;
+import org.bouncycastle.crypto.params.ParametersWithIV;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+
+/**
+ * This is a test harness I use because I cannot modify the BC test harness without
+ * invalidating the signature on their signed provider library. The code here is not
+ * high quality but it does test the RFC vectors as well as randomly generated values.
+ * The RFC test vectors are tested by making sure both the ciphertext and decrypted
+ * values match the expected values whereas the random values are just checked to make
+ * sure that:
+ * <p>unwrap(wrap(random_value, random_kek), random_kek) == random_value.</p>
+ */
+
+public class AESWrapPadTest
+    extends SimpleTest
+{
+
+    private final int numOfRandomIterations = 100;
+
+    public AESWrapPadTest()
+    {
+
+    }
+
+    private void wrapAndUnwrap(byte[] kek, byte[] key, byte[] expected)
+        throws Exception
+    {
+        Wrapper wrapper = new AESWrapPadEngine();
+
+        wrapper.init(true, new KeyParameter(kek));
+
+        byte[] cipherText = wrapper.wrap(key, 0, key.length);
+        if (!areEqual(cipherText, expected))
+        {
+            fail("Wrapped value does not match expected.");
+        }
+        wrapper.init(false, new KeyParameter(kek));
+        byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);
+
+        if (!areEqual(key, plainText))
+        {
+            fail("Unwrapped value does not match original.");
+        }
+    }
+
+    private void wrapAndUnwrap(byte[] kek, byte[] key)
+        throws Exception
+    {
+        Wrapper wrapper = new AESWrapPadEngine();
+
+        wrapper.init(true, new KeyParameter(kek));
+
+        byte[] cipherText = wrapper.wrap(key, 0, key.length);
+
+        wrapper.init(false, new KeyParameter(kek));
+        byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);
+
+        if (!areEqual(key, plainText))
+        {
+            fail("Unwrapped value does not match original.");
+        }
+    }
+
+    private void wrapWithIVTest()
+        throws Exception
+    {
+        byte[] kek = Hex.decode("5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8");
+        byte[] key = Hex.decode("c37b7e6492584340bed12207808941155068f738");
+        byte[] expected = Hex.decode("5cbdb3fb71351d0e628b85dbcba1a1890d4db26d1335e11d1aabea11124caad0");
+
+        Wrapper wrapper = new AESWrapPadEngine();
+
+        wrapper.init(true, new ParametersWithIV(new KeyParameter(kek), Hex.decode("33333333")));
+
+        byte[] cipherText = wrapper.wrap(key, 0, key.length);
+        if (!areEqual(cipherText, expected))
+        {
+            fail("Wrapped value does not match expected.");
+        }
+        wrapper.init(false, new ParametersWithIV(new KeyParameter(kek), Hex.decode("33333333")));
+        byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);
+
+        if (!areEqual(key, plainText))
+        {
+            fail("Unwrapped value does not match original.");
+        }
+    }
+
+    public String getName()
+    {
+        return "AESWrapPad";
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        // test RFC 5649 test vectors
+        byte[] kek = Hex.decode("5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8");
+        byte[] key = Hex.decode("c37b7e6492584340bed12207808941155068f738");
+        byte[] wrap = Hex.decode("138bdeaa9b8fa7fc61f97742e72248ee5ae6ae5360d1ae6a5f54f373fa543b6a");
+
+        wrapAndUnwrap(kek, key, wrap);
+
+        wrap = Hex.decode("afbeb0f07dfbf5419200f2ccb50bb24f");
+        key = Hex.decode("466f7250617369");
+        wrapAndUnwrap(kek, key, wrap);
+
+        wrapWithIVTest();
+
+        //
+        // offset test
+        //
+        Wrapper wrapper = new AESWrapPadEngine();
+
+        byte[] pText = new byte[5 + key.length];
+        byte[]  cText;
+
+        System.arraycopy(key, 0, pText, 5, key.length);
+
+        wrapper.init(true, new KeyParameter(kek));
+
+        cText = wrapper.wrap(pText, 5, key.length);
+        if (!Arrays.areEqual(cText, wrap))
+        {
+            fail("failed offset wrap test expected " + new String(Hex.encode(wrap)) + " got " + new String(Hex.encode(cText)));
+        }
+
+        wrapper.init(false, new KeyParameter(kek));
+
+        cText = new byte[6 + wrap.length];
+        System.arraycopy(wrap, 0, cText, 6, wrap.length);
+
+        pText = wrapper.unwrap(cText, 6, wrap.length);
+        if (!Arrays.areEqual(pText, key))
+        {
+            fail("failed offset unwrap test expected " + new String(Hex.encode(key)) + " got " + new String(Hex.encode(pText)));
+        }
+
+        // test random values
+        SecureRandom rnd = new SecureRandom();
+        for (int i = 0; i < numOfRandomIterations; i++)
+        {
+            int kekLength = 128;
+            boolean shouldIncrease = (rnd.nextInt() & 0x01) != 0;
+            if (shouldIncrease)
+            {
+                kekLength = 256;
+            }
+            kek = new byte[kekLength / 8];
+            rnd.nextBytes(kek);
+            int keyToWrapSize = RNGUtils.nextInt(rnd, 256 / 8 - 8) + 8;
+            byte[] keyToWrap = new byte[keyToWrapSize];
+            rnd.nextBytes(keyToWrap);
+            wrapAndUnwrap(kek, keyToWrap);
+        }
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        runTest(new AESWrapPadTest());
+    }
+}
+
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/ARIATest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/ARIATest.java
new file mode 100644
index 0000000..027e6bd
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/ARIATest.java
@@ -0,0 +1,170 @@
+package org.bouncycastle.crypto.test;
+
+import java.security.SecureRandom;
+
+import org.bouncycastle.crypto.BlockCipher;
+import org.bouncycastle.crypto.engines.ARIAEngine;
+import org.bouncycastle.crypto.params.KeyParameter;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class ARIATest
+    extends SimpleTest
+{
+    private static SecureRandom R = new SecureRandom();
+
+    private static final String[][] TEST_VECTORS_RFC5794 = {
+        {
+            "128-Bit Key",
+            "000102030405060708090a0b0c0d0e0f",
+            "00112233445566778899aabbccddeeff",
+            "d718fbd6ab644c739da95f3be6451778"
+        },
+        {
+            "192-Bit Key",
+            "000102030405060708090a0b0c0d0e0f1011121314151617",
+            "00112233445566778899aabbccddeeff",
+            "26449c1805dbe7aa25a468ce263a9e79"
+        },
+        {
+            "256-Bit Key",
+            "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+            "00112233445566778899aabbccddeeff",
+            "f92bd7c79fb72e2f2b8f80c1972d24fc"
+        },
+    };
+
+    public String getName()
+    {
+        return "ARIA";
+    }
+
+    public void performTest() throws Exception
+    {
+        checkTestVectors_RFC5794();
+        long before = System.currentTimeMillis();
+        for (int i = 0; i < 10000; ++i)
+        {
+        checkRandomRoundtrips();
+        }
+        long after = System.currentTimeMillis();
+        long elapsed = after - before;
+        System.out.println("Elapsed: " + elapsed + "ms.");
+
+        new MyARIAEngine().checkImplementation();
+    }
+
+    private void checkRandomRoundtrips()
+    {
+        ARIAEngine ce = new ARIAEngine();
+        ARIAEngine cd = new ARIAEngine();
+
+        byte[] txt = new byte[ce.getBlockSize()];
+        byte[] enc = new byte[ce.getBlockSize()];
+        byte[] dec = new byte[ce.getBlockSize()];
+
+        for (int keyLen = 16; keyLen <= 32; keyLen += 8)
+        {
+            byte[] K = new byte[keyLen];
+
+            R.nextBytes(K);
+
+            KeyParameter key = new KeyParameter(K);
+            ce.init(true, key);
+            cd.init(false, key);
+
+            R.nextBytes(txt);
+
+            for (int i = 0; i < 100; ++i)
+            {
+                ce.processBlock(txt, 0, enc, 0);
+                cd.processBlock(enc, 0, dec, 0);
+
+                isTrue(Arrays.areEqual(txt, dec));
+
+                System.arraycopy(enc, 0, txt, 0, enc.length);
+            }
+        }
+    }
+
+    private void checkTestVector_RFC5794(String[] tv)
+    {
+        String name = "'" + tv[0] + "'";
+
+        BlockCipher c = new ARIAEngine();
+        int blockSize = c.getBlockSize();
+        isTrue("Wrong block size returned from getBlockSize() for " + name, 16 == blockSize);
+
+        KeyParameter key = new KeyParameter(Hex.decode(tv[1]));
+        byte[] plaintext = Hex.decode(tv[2]);
+        byte[] ciphertext = Hex.decode(tv[3]);
+
+        isTrue("Unexpected plaintext length for " + name, blockSize == plaintext.length);
+        isTrue("Unexpected ciphertext length for " + name, blockSize == ciphertext.length);
+
+        c.init(true, key);
+
+        byte[] actual = new byte[blockSize];
+        int num = c.processBlock(plaintext, 0, actual, 0);
+
+        isTrue("Wrong length returned from processBlock() (encryption) for " + name, blockSize == num);
+        isTrue("Incorrect ciphertext computed for " + name, Arrays.areEqual(ciphertext, actual));
+
+        c.init(false, key);
+        num = c.processBlock(ciphertext, 0, actual, 0);
+
+        isTrue("Wrong length returned from processBlock() (decryption) for " + name, blockSize == num);
+        isTrue("Incorrect plaintext computed for " + name, Arrays.areEqual(plaintext, actual));
+    }
+
+    private void checkTestVectors_RFC5794()
+    {
+        for (int i = 0; i < TEST_VECTORS_RFC5794.length; ++i)
+        {
+            checkTestVector_RFC5794(TEST_VECTORS_RFC5794[i]);
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new ARIATest());
+    }
+
+    private class MyARIAEngine extends ARIAEngine
+    {
+        public void checkImplementation()
+        {
+            checkInvolution();
+            checkSBoxes();
+        }
+
+        private void checkInvolution()
+        {
+            byte[] x = new byte[16], y = new byte[16];
+
+            for (int i = 0; i < 100; ++i)
+            {
+                R.nextBytes(x);
+                System.arraycopy(x, 0, y, 0, 16);
+                A(y);
+                A(y);
+                ARIATest.this.isTrue(Arrays.areEqual(x, y));
+            }
+        }
+
+        private void checkSBoxes()
+        {
+            for (int i = 0; i < 256; ++i)
+            {
+                byte x = (byte)i;
+
+                ARIATest.this.isTrue(x == SB1(SB3(x)));
+                ARIATest.this.isTrue(x == SB3(SB1(x)));
+
+                ARIATest.this.isTrue(x == SB2(SB4(x)));
+                ARIATest.this.isTrue(x == SB4(SB2(x)));
+            }
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/GCMTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/GCMTest.java
index 16d8362..3f09fc0 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/test/GCMTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/GCMTest.java
@@ -13,6 +13,7 @@
 import org.bouncycastle.crypto.modes.gcm.Tables8kGCMMultiplier;
 import org.bouncycastle.crypto.params.AEADParameters;
 import org.bouncycastle.crypto.params.KeyParameter;
+import org.bouncycastle.util.Strings;
 import org.bouncycastle.util.Times;
 import org.bouncycastle.util.encoders.Hex;
 import org.bouncycastle.util.test.SimpleTest;
@@ -338,23 +339,38 @@
             // expected
         }
 
+        AEADTestUtil.testTampering(this, gcm, new AEADParameters(new KeyParameter(new byte[16]), 128, new byte[16]));
+
+        byte[] P = Strings.toByteArray("Hello world!");
+        byte[] buf = new byte[100];
+
+        GCMBlockCipher c = new GCMBlockCipher(createAESEngine());
+        AEADParameters aeadParameters = new AEADParameters(new KeyParameter(new byte[16]), 128, new byte[16]);
+        c.init(true, aeadParameters);
+
+        c.processBytes(P, 0, P.length, buf, 0);
+
+        c.doFinal(buf, 0);
+        
         try
         {
-            AEADTestUtil.testReset(this, new GCMBlockCipher(createAESEngine()), new GCMBlockCipher(createAESEngine()), new AEADParameters(new KeyParameter(new byte[16]), 128, new byte[16]));
+            c.doFinal(buf, 0);
+            fail("no exception on reuse");
+        }
+        catch (IllegalStateException e)
+        {
+            isTrue("wrong message", e.getMessage().equals("GCM cipher cannot be reused for encryption"));
+        }
 
-            fail("no exception");
+        try
+        {
+            c.init(true, aeadParameters);
+            fail("no exception on reuse");
         }
         catch (IllegalArgumentException e)
         {
-
+            isTrue("wrong message", e.getMessage().equals("cannot reuse nonce for GCM encryption"));
         }
-
-        AEADTestUtil.testTampering(this, gcm, new AEADParameters(new KeyParameter(new byte[16]), 128, new byte[16]));
-        // TODO: should probably come up with varients of these that don't trigger reuse exception
-//        AEADTestUtil.testOutputSizes(this, new GCMBlockCipher(createAESEngine()), new AEADParameters(new KeyParameter(
-//                new byte[16]), 128, new byte[16]));
-//        AEADTestUtil.testBufferSizeChecks(this, new GCMBlockCipher(createAESEngine()), new AEADParameters(
-//                new KeyParameter(new byte[16]), 128, new byte[16]));
     }
 
     private void runTestCase(String[] testVector)
@@ -429,6 +445,7 @@
         GCMBlockCipher encCipher = initCipher(encM, true, parameters);
         GCMBlockCipher decCipher = initCipher(decM, false, parameters);
         checkTestCase(encCipher, decCipher, testName, SA, P, C, T);
+        encCipher = initCipher(encM, true, parameters);
         checkTestCase(encCipher, decCipher, testName + " (reused)", SA, P, C, T);
 
         // Key reuse
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/GMacTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/GMacTest.java
index 6897ba6..5c5b515 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/test/GMacTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/GMacTest.java
@@ -109,6 +109,9 @@
             mac.init(new ParametersWithIV(key, testCase.getIv()));
 
             testSingleByte(mac, testCase);
+
+            mac = new GMac(new GCMBlockCipher(new AESEngine()), testCase.getTag().length * 8);
+            mac.init(new ParametersWithIV(key, testCase.getIv()));
             testMultibyte(mac, testCase);
         }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/GOST28147Test.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/GOST28147Test.java
index 8de8440..74e7861 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/test/GOST28147Test.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/GOST28147Test.java
@@ -37,6 +37,18 @@
             0xF,0xE,0xD,0xC,0xB,0xA,0x9,0x8,0x7,0x6,0x5,0x4,0x3,0x2,0x1,0x0
     };
 
+    static byte[] TestSBox_1 =
+    {
+         0xE, 0x3, 0xC, 0xD, 0x1, 0xF, 0xA, 0x9, 0xB, 0x6, 0x2, 0x7, 0x5, 0x0, 0x8, 0x4,
+         0xD, 0x9, 0x0, 0x4, 0x7, 0x1, 0x3, 0xB, 0x6, 0xC, 0x2, 0xA, 0xF, 0xE, 0x5, 0x8,
+         0x8, 0xB, 0xA, 0x7, 0x1, 0xD, 0x5, 0xC, 0x6, 0x3, 0x9, 0x0, 0xF, 0xE, 0x2, 0x4,
+         0xD, 0x7, 0xC, 0x9, 0xF, 0x0, 0x5, 0x8, 0xA, 0x2, 0xB, 0x6, 0x4, 0x3, 0x1, 0xE,
+         0xB, 0x4, 0x6, 0x5, 0x0, 0xF, 0x1, 0xC, 0x9, 0xE, 0xD, 0x8, 0x3, 0x7, 0xA, 0x2,
+         0xD, 0xF, 0x9, 0x4, 0x2, 0xC, 0x5, 0xA, 0x6, 0x0, 0x3, 0x8, 0x7, 0xE, 0x1, 0xB,
+         0xF, 0xE, 0x9, 0x5, 0xB, 0x2, 0x1, 0x8, 0x6, 0x0, 0xD, 0x3, 0x4, 0x7, 0xC, 0xA,
+         0xA, 0x3, 0xE, 0x2, 0x0, 0x1, 0x4, 0x6, 0xB, 0x8, 0xC, 0x7, 0xD, 0x5, 0xF, 0x9
+    };
+
     static SimpleTest[]   tests =
     {   new BlockCipherVectorTest(1, new GOST28147Engine(),
             new KeyParameter(Hex.decode("546d203368656c326973652073736e62206167796967747473656865202c3d73")),
@@ -128,7 +140,38 @@
                 Hex.decode("1234567890abcdef")), //IV
                 "bc350e71aa11345709acde",  //input message
                 "1bcc2282707c676fb656dc"), //encrypt message
-
+        new BlockCipherVectorTest(15, new GOFBBlockCipher(new GOST28147Engine()),
+            new ParametersWithIV(
+                new ParametersWithSBox(
+                    new KeyParameter(Hex.decode("0A43145BA8B9E9FF0AEA67D3F26AD87854CED8D9017B3D33ED81301F90FDF993")), //key
+                    TestSBox_1), //type, IV, S-box
+                Hex.decode("8001069080010690")),
+            "094C912C5EFDD703D42118971694580B", //input message
+            "2707B58DF039D1A64460735FFE76D55F"), //encrypt message
+        new BlockCipherVectorTest(16, new GOFBBlockCipher(new GOST28147Engine()),
+            new ParametersWithIV(
+                new ParametersWithSBox(
+                    new KeyParameter(Hex.decode("0A43145BA8B9E9FF0AEA67D3F26AD87854CED8D9017B3D33ED81301F90FDF993")), //key
+                    TestSBox_1), //type, S-box
+                    Hex.decode("800107A0800107A0")),
+            "FE780800E0690083F20C010CF00C0329", //input message
+            "9AF623DFF948B413B53171E8D546188D"), //encrypt message
+        new BlockCipherVectorTest(17, new GOFBBlockCipher(new GOST28147Engine()),
+            new ParametersWithIV(
+                new ParametersWithSBox(
+                    new KeyParameter(Hex.decode("0A43145BA8B9E9FF0AEA67D3F26AD87854CED8D9017B3D33ED81301F90FDF993")), //key
+                    TestSBox_1), //type, S-box
+                    Hex.decode("8001114080011140")),
+            "D1088FD8C0A86EE8F1DCD1088FE8C058", //input message
+            "62A6B64D12253BCD8241A4BB0CFD3E7C"), //encrypt message
+        new BlockCipherVectorTest(18, new GOFBBlockCipher(new GOST28147Engine()),
+            new ParametersWithIV(
+                new ParametersWithSBox(
+                    new KeyParameter(Hex.decode("0A43145BA8B9E9FF0AEA67D3F26AD87854CED8D9017B3D33ED81301F90FDF993")), //key
+                    TestSBox_1), //type, IV, S-box
+                    Hex.decode("80011A3080011A30")),
+            "D431FACD011C502C501B500A12921090", //input message
+            "07313C89D302FF73234B4A0506AB00F3"), //encrypt message
     };
 
     static private final int GOST28147_KEY_LENGTH = 32;
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/RegressionTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/RegressionTest.java
index 9dbfe0e..427bb5f 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/test/RegressionTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/RegressionTest.java
@@ -12,6 +12,7 @@
         new AESFastTest(),
         new AESWrapTest(),
         new AESWrapPadTest(),
+        new ARIATest(),
         new DESTest(),
         new DESedeTest(),
         new ModeTest(),
@@ -147,6 +148,9 @@
         new Blake2bDigestTest(),
         new KeccakDigestTest(),
         new SHAKEDigestTest(),
+        new SM2EngineTest(),
+        new SM2KeyExchangeTest(),
+        new SM2SignerTest(),
         new SM4Test()
     };
 
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2EngineTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2EngineTest.java
new file mode 100644
index 0000000..82fbefe
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2EngineTest.java
@@ -0,0 +1,166 @@
+package org.bouncycastle.crypto.test;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.InvalidCipherTextException;
+import org.bouncycastle.crypto.engines.SM2Engine;
+import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
+import org.bouncycastle.crypto.params.ECPublicKeyParameters;
+import org.bouncycastle.crypto.params.ParametersWithRandom;
+import org.bouncycastle.math.ec.ECCurve;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.TestRandomBigInteger;
+
+public class SM2EngineTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "SM2Engine";
+    }
+
+    private void doEngineTestFp()
+        throws Exception
+    {
+        BigInteger SM2_ECC_P = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3", 16);
+        BigInteger SM2_ECC_A = new BigInteger("787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498", 16);
+        BigInteger SM2_ECC_B = new BigInteger("63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A", 16);
+        BigInteger SM2_ECC_N = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7", 16);
+        BigInteger SM2_ECC_GX = new BigInteger("421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D", 16);
+        BigInteger SM2_ECC_GY = new BigInteger("0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2", 16);
+
+        ECCurve curve = new ECCurve.Fp(SM2_ECC_P, SM2_ECC_A, SM2_ECC_B);
+
+        ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
+        ECDomainParameters domainParams = new ECDomainParameters(curve, g, SM2_ECC_N);
+
+        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
+
+        ECKeyGenerationParameters aKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("1649AB77A00637BD5E2EFE283FBF353534AA7F7CB89463F208DDBC2920BB0DA0", 16));
+
+        keyPairGenerator.init(aKeyGenParams);
+
+        AsymmetricCipherKeyPair aKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters aPub = (ECPublicKeyParameters)aKp.getPublic();
+        ECPrivateKeyParameters aPriv = (ECPrivateKeyParameters)aKp.getPrivate();
+
+        SM2Engine sm2Engine = new SM2Engine();
+
+        byte[] m = Strings.toByteArray("encryption standard");
+
+        sm2Engine.init(true, new ParametersWithRandom(aPub, new TestRandomBigInteger("4C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F", 16)));
+
+        byte[] enc = sm2Engine.processBlock(m, 0, m.length);
+
+        isTrue("enc wrong", Arrays.areEqual(Hex.decode(
+            "04245C26 FB68B1DD DDB12C4B 6BF9F2B6 D5FE60A3 83B0D18D 1C4144AB F17F6252" +
+            "E776CB92 64C2A7E8 8E52B199 03FDC473 78F605E3 6811F5C0 7423A24B 84400F01" +
+            "B8650053 A89B41C4 18B0C3AA D00D886C 00286467 9C3D7360 C30156FA B7C80A02" +
+            "76712DA9 D8094A63 4B766D3A 285E0748 0653426D"), enc));
+
+        sm2Engine.init(false, aPriv);
+
+        byte[] dec = sm2Engine.processBlock(enc, 0, enc.length);
+
+        isTrue("dec wrong", Arrays.areEqual(m, dec));
+
+        enc[80] = (byte)(enc[80] + 1);
+
+        try
+        {
+            sm2Engine.processBlock(enc, 0, enc.length);
+            fail("no exception");
+        }
+        catch (InvalidCipherTextException e)
+        {
+            isTrue("wrong exception", "invalid cipher text".equals(e.getMessage()));
+        }
+
+        // long message
+        sm2Engine = new SM2Engine();
+
+        m = new byte[4097];
+        for (int i = 0; i != m.length; i++)
+        {
+            m[i] = (byte)i;
+        }
+
+        sm2Engine.init(true, new ParametersWithRandom(aPub, new TestRandomBigInteger("4C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F", 16)));
+
+        enc = sm2Engine.processBlock(m, 0, m.length);
+
+        sm2Engine.init(false, aPriv);
+
+        dec = sm2Engine.processBlock(enc, 0, enc.length);
+
+        isTrue("dec wrong", Arrays.areEqual(m, dec));
+    }
+
+    private void doEngineTestF2m()
+        throws Exception
+    {
+        BigInteger SM2_ECC_A = new BigInteger("00", 16);
+        BigInteger SM2_ECC_B = new BigInteger("E78BCD09746C202378A7E72B12BCE00266B9627ECB0B5A25367AD1AD4CC6242B", 16);
+        BigInteger SM2_ECC_N = new BigInteger("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBC972CF7E6B6F900945B3C6A0CF6161D", 16);
+        BigInteger SM2_ECC_GX = new BigInteger("00CDB9CA7F1E6B0441F658343F4B10297C0EF9B6491082400A62E7A7485735FADD", 16);
+        BigInteger SM2_ECC_GY = new BigInteger("013DE74DA65951C4D76DC89220D5F7777A611B1C38BAE260B175951DC8060C2B3E", 16);
+        BigInteger SM2_ECC_H = BigInteger.valueOf(4);
+
+        ECCurve curve = new ECCurve.F2m(257, 12, SM2_ECC_A, SM2_ECC_B);
+
+        ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
+        ECDomainParameters domainParams = new ECDomainParameters(curve, g, SM2_ECC_N, SM2_ECC_H);
+
+        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
+
+        ECKeyGenerationParameters aKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("56A270D17377AA9A367CFA82E46FA5267713A9B91101D0777B07FCE018C757EB", 16));
+
+        keyPairGenerator.init(aKeyGenParams);
+
+        AsymmetricCipherKeyPair aKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters aPub = (ECPublicKeyParameters)aKp.getPublic();
+        ECPrivateKeyParameters aPriv = (ECPrivateKeyParameters)aKp.getPrivate();
+
+        SM2Engine sm2Engine = new SM2Engine();
+
+        byte[] m = Strings.toByteArray("encryption standard");
+
+        sm2Engine.init(true, new ParametersWithRandom(aPub, new TestRandomBigInteger("6D3B497153E3E92524E5C122682DBDC8705062E20B917A5F8FCDB8EE4C66663D", 16)));
+
+        byte[] enc = sm2Engine.processBlock(m, 0, m.length);
+
+        isTrue("f2m enc wrong", Arrays.areEqual(Hex.decode(
+            "04019D23 6DDB3050 09AD52C5 1BB93270 9BD534D4 76FBB7B0 DF9542A8 A4D890A3" +
+                "F2E100B2 3B938DC0 A94D1DF8 F42CF45D 2D6601BF 638C3D7D E75A29F0 2AFB7E45" +
+                "E91771FD 55AC6213 C2A8A040 E4CAB5B2 6A9CFCDA 737373A4 8625D375 8FA37B3E" +
+                "AB80E9CF CABA665E 3199EA15 A1FA8189 D96F5791 25E4"), enc));
+
+        sm2Engine.init(false, aPriv);
+
+        byte[] dec = sm2Engine.processBlock(enc, 0, enc.length);
+
+        isTrue("f2m dec wrong", Arrays.areEqual(m, dec));
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        doEngineTestFp();
+        doEngineTestF2m();
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new SM2EngineTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2KeyExchangeTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2KeyExchangeTest.java
new file mode 100644
index 0000000..f6f694d
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2KeyExchangeTest.java
@@ -0,0 +1,227 @@
+package org.bouncycastle.crypto.test;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.agreement.SM2KeyExchange;
+import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
+import org.bouncycastle.crypto.params.ECPublicKeyParameters;
+import org.bouncycastle.crypto.params.ParametersWithID;
+import org.bouncycastle.crypto.params.SM2KeyExchangePrivateParameters;
+import org.bouncycastle.crypto.params.SM2KeyExchangePublicParameters;
+import org.bouncycastle.math.ec.ECCurve;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.util.Arrays;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.TestRandomBigInteger;
+
+public class SM2KeyExchangeTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "SM2KeyExchange";
+    }
+
+    private void doKeyExchangeTestFp()
+        throws Exception
+    {
+        BigInteger SM2_ECC_P = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3", 16);
+        BigInteger SM2_ECC_A = new BigInteger("787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498", 16);
+        BigInteger SM2_ECC_B = new BigInteger("63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A", 16);
+        BigInteger SM2_ECC_N = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7", 16);
+        BigInteger SM2_ECC_GX = new BigInteger("421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D", 16);
+        BigInteger SM2_ECC_GY = new BigInteger("0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2", 16);
+
+        ECCurve curve = new ECCurve.Fp(SM2_ECC_P, SM2_ECC_A, SM2_ECC_B);
+
+        ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
+        ECDomainParameters domainParams = new ECDomainParameters(curve, g, SM2_ECC_N);
+
+        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
+
+        ECKeyGenerationParameters aKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("6FCBA2EF9AE0AB902BC3BDE3FF915D44BA4CC78F88E2F8E7F8996D3B8CCEEDEE", 16));
+
+        keyPairGenerator.init(aKeyGenParams);
+
+        AsymmetricCipherKeyPair aKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters aPub = (ECPublicKeyParameters)aKp.getPublic();
+        ECPrivateKeyParameters aPriv = (ECPrivateKeyParameters)aKp.getPrivate();
+
+        ECKeyGenerationParameters aeKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("83A2C9C8B96E5AF70BD480B472409A9A327257F1EBB73F5B073354B248668563", 16));
+
+        keyPairGenerator.init(aeKeyGenParams);
+
+        AsymmetricCipherKeyPair aeKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters aePub = (ECPublicKeyParameters)aeKp.getPublic();
+        ECPrivateKeyParameters aePriv = (ECPrivateKeyParameters)aeKp.getPrivate();
+
+        ECKeyGenerationParameters bKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("5E35D7D3F3C54DBAC72E61819E730B019A84208CA3A35E4C2E353DFCCB2A3B53", 16));
+
+        keyPairGenerator.init(bKeyGenParams);
+
+        AsymmetricCipherKeyPair bKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters bPub = (ECPublicKeyParameters)bKp.getPublic();
+        ECPrivateKeyParameters bPriv = (ECPrivateKeyParameters)bKp.getPrivate();
+
+        ECKeyGenerationParameters beKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("33FE21940342161C55619C4A0C060293D543C80AF19748CE176D83477DE71C80", 16));
+
+        keyPairGenerator.init(beKeyGenParams);
+
+        AsymmetricCipherKeyPair beKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters bePub = (ECPublicKeyParameters)beKp.getPublic();
+        ECPrivateKeyParameters bePriv = (ECPrivateKeyParameters)beKp.getPrivate();
+
+        SM2KeyExchange exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(true, aPriv, aePriv), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        byte[] k1 = exch.calculateKey(128, new ParametersWithID(new SM2KeyExchangePublicParameters(bPub, bePub), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        isTrue("key 1 wrong", Arrays.areEqual(Hex.decode("55b0ac62a6b927ba23703832c853ded4"), k1));
+
+        exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(false, bPriv, bePriv), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        byte[] k2 = exch.calculateKey(128, new ParametersWithID(new SM2KeyExchangePublicParameters(aPub, aePub), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        isTrue("key 2 wrong", Arrays.areEqual(Hex.decode("55b0ac62a6b927ba23703832c853ded4"), k2));
+
+        // with key confirmation
+        exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(false, bPriv, bePriv), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        byte[][] vals2 = exch.calculateKeyWithConfirmation(128, null, new ParametersWithID(new SM2KeyExchangePublicParameters(aPub, aePub), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        isTrue("key 2 wrong", Arrays.areEqual(Hex.decode("55b0ac62a6b927ba23703832c853ded4"), k2));
+      
+        isTrue("conf a tag 2 wrong", Arrays.areEqual(Hex.decode("284C8F198F141B502E81250F1581C7E9EEB4CA6990F9E02DF388B45471F5BC5C"), vals2[1]));
+        isTrue("conf b tag 2 wrong", Arrays.areEqual(Hex.decode("23444DAF8ED7534366CB901C84B3BDBB63504F4065C1116C91A4C00697E6CF7A"), vals2[2]));
+
+        exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(true, aPriv, aePriv), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        byte[][] vals1 = exch.calculateKeyWithConfirmation(128, vals2[1], new ParametersWithID(new SM2KeyExchangePublicParameters(bPub, bePub), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        isTrue("conf key 1 wrong", Arrays.areEqual(Hex.decode("55b0ac62a6b927ba23703832c853ded4"), vals1[0]));
+        isTrue("conf tag 1 wrong", Arrays.areEqual(Hex.decode("23444DAF8ED7534366CB901C84B3BDBB63504F4065C1116C91A4C00697E6CF7A"), vals1[1]));
+    }
+
+    private void doKeyExchangeTestF2m()
+        throws Exception
+    {
+        BigInteger SM2_ECC_A = new BigInteger("00", 16);
+        BigInteger SM2_ECC_B = new BigInteger("E78BCD09746C202378A7E72B12BCE00266B9627ECB0B5A25367AD1AD4CC6242B", 16);
+        BigInteger SM2_ECC_N = new BigInteger("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBC972CF7E6B6F900945B3C6A0CF6161D", 16);
+        BigInteger SM2_ECC_GX = new BigInteger("00CDB9CA7F1E6B0441F658343F4B10297C0EF9B6491082400A62E7A7485735FADD", 16);
+        BigInteger SM2_ECC_GY = new BigInteger("013DE74DA65951C4D76DC89220D5F7777A611B1C38BAE260B175951DC8060C2B3E", 16);
+        BigInteger SM2_ECC_H = BigInteger.valueOf(4);
+
+        ECCurve curve = new ECCurve.F2m(257, 12, SM2_ECC_A, SM2_ECC_B);
+
+        ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
+        ECDomainParameters domainParams = new ECDomainParameters(curve, g, SM2_ECC_N, SM2_ECC_H);
+        
+        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
+
+        ECKeyGenerationParameters aKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("4813903D254F2C20A94BC5704238496954BB5279F861952EF2C5298E84D2CEAA", 16));
+
+        keyPairGenerator.init(aKeyGenParams);
+
+        AsymmetricCipherKeyPair aKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters aPub = (ECPublicKeyParameters)aKp.getPublic();
+        ECPrivateKeyParameters aPriv = (ECPrivateKeyParameters)aKp.getPrivate();
+
+        ECKeyGenerationParameters aeKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("54A3D6673FF3A6BD6B02EBB164C2A3AF6D4A4906229D9BFCE68CC366A2E64BA4", 16));
+
+        keyPairGenerator.init(aeKeyGenParams);
+
+        AsymmetricCipherKeyPair aeKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters aePub = (ECPublicKeyParameters)aeKp.getPublic();
+        ECPrivateKeyParameters aePriv = (ECPrivateKeyParameters)aeKp.getPrivate();
+
+        ECKeyGenerationParameters bKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("08F41BAE0922F47C212803FE681AD52B9BF28A35E1CD0EC273A2CF813E8FD1DC", 16));
+
+        keyPairGenerator.init(bKeyGenParams);
+
+        AsymmetricCipherKeyPair bKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters bPub = (ECPublicKeyParameters)bKp.getPublic();
+        ECPrivateKeyParameters bPriv = (ECPrivateKeyParameters)bKp.getPrivate();
+
+        ECKeyGenerationParameters beKeyGenParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("1F21933387BEF781D0A8F7FD708C5AE0A56EE3F423DBC2FE5BDF6F068C53F7AD", 16));
+
+        keyPairGenerator.init(beKeyGenParams);
+
+        AsymmetricCipherKeyPair beKp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters bePub = (ECPublicKeyParameters)beKp.getPublic();
+        ECPrivateKeyParameters bePriv = (ECPrivateKeyParameters)beKp.getPrivate();
+
+        SM2KeyExchange exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(true, aPriv, aePriv), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        byte[] k1 = exch.calculateKey(128, new ParametersWithID(new SM2KeyExchangePublicParameters(bPub, bePub), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        // there appears to be typo for ZA in the draft
+        //isTrue("F2m key 1 wrong", Arrays.areEqual(Hex.decode("4E587E5C66634F22D973A7D98BF8BE23"), k1));
+        isTrue("F2m key 1 wrong", Arrays.areEqual(Hex.decode("8c2b03289aa7126555dc660cfc29fd74"), k1));
+
+        exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(false, bPriv, bePriv), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        byte[] k2 = exch.calculateKey(128, new ParametersWithID(new SM2KeyExchangePublicParameters(aPub, aePub), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        //isTrue("F2m key 2 wrong", Arrays.areEqual(Hex.decode("4E587E5C66634F22D973A7D98BF8BE23"), k2));
+        isTrue("F2m key 2 wrong", Arrays.areEqual(Hex.decode("8c2b03289aa7126555dc660cfc29fd74"), k2));
+
+        // with key confirmation
+        exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(false, bPriv, bePriv), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        byte[][] vals2 = exch.calculateKeyWithConfirmation(128, null, new ParametersWithID(new SM2KeyExchangePublicParameters(aPub, aePub), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        isTrue("key 2 wrong", Arrays.areEqual(Hex.decode("8c2b03289aa7126555dc660cfc29fd74"), k2));
+
+        isTrue("conf a tag 2 wrong", Arrays.areEqual(Hex.decode("d8294c4c0f0ac180feac95e8a0d786638c9e915b9a684b2348809af03a0de2a5"), vals2[1]));
+        isTrue("conf b tag 2 wrong", Arrays.areEqual(Hex.decode("52089e706911b58fd5e7c7b2ab5cf32bb61e481ef1e114a1e33d99eec84b5a4f"), vals2[2]));
+
+        exch = new SM2KeyExchange();
+
+        exch.init(new ParametersWithID(new SM2KeyExchangePrivateParameters(true, aPriv, aePriv), Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        byte[][] vals1 = exch.calculateKeyWithConfirmation(128, vals2[1], new ParametersWithID(new SM2KeyExchangePublicParameters(bPub, bePub), Strings.toByteArray("BILL456@YAHOO.COM")));
+
+        isTrue("conf key 1 wrong", Arrays.areEqual(Hex.decode("8c2b03289aa7126555dc660cfc29fd74"), vals1[0]));
+        isTrue("conf tag 1 wrong", Arrays.areEqual(Hex.decode("52089e706911b58fd5e7c7b2ab5cf32bb61e481ef1e114a1e33d99eec84b5a4f"), vals1[1]));
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        doKeyExchangeTestFp();
+        doKeyExchangeTestF2m();
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new SM2KeyExchangeTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2SignerTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2SignerTest.java
new file mode 100644
index 0000000..1df48b6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM2SignerTest.java
@@ -0,0 +1,120 @@
+package org.bouncycastle.crypto.test;
+
+import java.math.BigInteger;
+
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
+import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
+import org.bouncycastle.crypto.params.ECPublicKeyParameters;
+import org.bouncycastle.crypto.params.ParametersWithID;
+import org.bouncycastle.crypto.params.ParametersWithRandom;
+import org.bouncycastle.crypto.signers.SM2Signer;
+import org.bouncycastle.math.ec.ECCurve;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.util.Strings;
+import org.bouncycastle.util.test.SimpleTest;
+import org.bouncycastle.util.test.TestRandomBigInteger;
+
+public class SM2SignerTest
+    extends SimpleTest
+{
+    public String getName()
+    {
+        return "SM2Signer";
+    }
+
+    private void doSignerTestFp()
+        throws Exception
+    {
+        BigInteger SM2_ECC_P = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3", 16);
+        BigInteger SM2_ECC_A = new BigInteger("787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498", 16);
+        BigInteger SM2_ECC_B = new BigInteger("63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A", 16);
+        BigInteger SM2_ECC_N = new BigInteger("8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7", 16);
+        BigInteger SM2_ECC_GX = new BigInteger("421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D", 16);
+        BigInteger SM2_ECC_GY = new BigInteger("0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2", 16);
+        
+        ECCurve curve = new ECCurve.Fp(SM2_ECC_P, SM2_ECC_A, SM2_ECC_B);
+
+        ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
+        ECDomainParameters domainParams = new ECDomainParameters(curve, g, SM2_ECC_N);
+
+        ECKeyGenerationParameters keyGenerationParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("128B2FA8BD433C6C068C8D803DFF79792A519A55171B1B650C23661D15897263", 16));
+        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
+
+        keyPairGenerator.init(keyGenerationParams);
+        AsymmetricCipherKeyPair kp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters ecPub = (ECPublicKeyParameters)kp.getPublic();
+        ECPrivateKeyParameters ecPriv = (ECPrivateKeyParameters)kp.getPrivate();
+
+        SM2Signer signer = new SM2Signer();
+
+        signer.init(true,
+            new ParametersWithID(new ParametersWithRandom(ecPriv,
+                    new TestRandomBigInteger("6CB28D99385C175C94F94E934817663FC176D925DD72B727260DBAAE1FB2F96F", 16)),
+                Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        BigInteger[] rs = signer.generateSignature(Strings.toByteArray("message digest"));
+
+        isTrue("r wrong", rs[0].equals(new BigInteger("40F1EC59F793D9F49E09DCEF49130D4194F79FB1EED2CAA55BACDB49C4E755D1", 16)));
+        isTrue("s wrong", rs[1].equals(new BigInteger("6FC6DAC32C5D5CF10C77DFB20F7C2EB667A457872FB09EC56327A67EC7DEEBE7", 16)));
+
+        signer.init(false, new ParametersWithID(ecPub, Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        isTrue("verification failed", signer.verifySignature(Strings.toByteArray("message digest"), rs[0], rs[1]));
+    }
+
+    private void doSignerTestF2m()
+        throws Exception
+    {
+        BigInteger SM2_ECC_A = new BigInteger("00", 16);
+        BigInteger SM2_ECC_B = new BigInteger("E78BCD09746C202378A7E72B12BCE00266B9627ECB0B5A25367AD1AD4CC6242B", 16);
+        BigInteger SM2_ECC_N = new BigInteger("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBC972CF7E6B6F900945B3C6A0CF6161D", 16);
+        BigInteger SM2_ECC_GX = new BigInteger("00CDB9CA7F1E6B0441F658343F4B10297C0EF9B6491082400A62E7A7485735FADD", 16);
+        BigInteger SM2_ECC_GY = new BigInteger("013DE74DA65951C4D76DC89220D5F7777A611B1C38BAE260B175951DC8060C2B3E", 16);
+
+        ECCurve curve = new ECCurve.F2m(257, 12, SM2_ECC_A, SM2_ECC_B);
+
+        ECPoint g = curve.createPoint(SM2_ECC_GX, SM2_ECC_GY);
+        ECDomainParameters domainParams = new ECDomainParameters(curve, g, SM2_ECC_N);
+
+        ECKeyGenerationParameters keyGenerationParams = new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger("771EF3DBFF5F1CDC32B9C572930476191998B2BF7CB981D7F5B39202645F0931", 16));
+        ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
+
+        keyPairGenerator.init(keyGenerationParams);
+        AsymmetricCipherKeyPair kp = keyPairGenerator.generateKeyPair();
+
+        ECPublicKeyParameters ecPub = (ECPublicKeyParameters)kp.getPublic();
+        ECPrivateKeyParameters ecPriv = (ECPrivateKeyParameters)kp.getPrivate();
+
+        SM2Signer signer = new SM2Signer();
+
+        signer.init(true,
+            new ParametersWithID(new ParametersWithRandom(ecPriv,
+                    new TestRandomBigInteger("36CD79FC8E24B7357A8A7B4A46D454C397703D6498158C605399B341ADA186D6", 16)),
+                Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        BigInteger[] rs = signer.generateSignature(Strings.toByteArray("message digest"));
+
+        isTrue("F2m r wrong", rs[0].equals(new BigInteger("6D3FBA26EAB2A1054F5D198332E335817C8AC453ED26D3391CD4439D825BF25B", 16)));
+        isTrue("F2m s wrong", rs[1].equals(new BigInteger("3124C5688D95F0A10252A9BED033BEC84439DA384621B6D6FAD77F94B74A9556", 16)));
+
+        signer.init(false, new ParametersWithID(ecPub, Strings.toByteArray("ALICE123@YAHOO.COM")));
+
+        isTrue("F2m verification failed", signer.verifySignature(Strings.toByteArray("message digest"), rs[0], rs[1]));
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        doSignerTestFp();
+        doSignerTestF2m();
+    }
+
+    public static void main(String[] args)
+    {
+        runTest(new SM2SignerTest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/test/SM3DigestTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM3DigestTest.java
index 2d418cb..83d0a9f 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/test/SM3DigestTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/test/SM3DigestTest.java
@@ -2,6 +2,7 @@
 
 import org.bouncycastle.crypto.Digest;
 import org.bouncycastle.crypto.digests.SM3Digest;
+import org.bouncycastle.util.encoders.Hex;
 
 /**
  * standard vector test for SM3 digest from chinese specification
@@ -19,6 +20,108 @@
         "abcdefghijklmnopqrstuvwxyz",
     };
 
+    private static String[] hexMessages = {
+        /* 2 p.57 ZA */
+        "0090" +
+        "414C494345313233405941484F4F2E434F4D" +
+        "787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498" +
+        "63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A" +
+        "421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D" +
+        "0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2" +
+        "0AE4C7798AA0F119471BEE11825BE46202BB79E2A5844495E97C04FF4DF2548A" +
+        "7C0240F88F1CD4E16352A73C17B7F16F07353E53A176D684A9FE0C6BB798E857",
+        /* 3 p.59 ZA */
+        "0090" +
+        "414C494345313233405941484F4F2E434F4D" +
+        "000000000000000000000000000000000000000000000000000000000000000000" +
+        "00E78BCD09746C202378A7E72B12BCE00266B9627ECB0B5A25367AD1AD4CC6242B" +
+        "00CDB9CA7F1E6B0441F658343F4B10297C0EF9B6491082400A62E7A7485735FADD" +
+        "013DE74DA65951C4D76DC89220D5F7777A611B1C38BAE260B175951DC8060C2B3E" +
+        "0165961645281A8626607B917F657D7E9382F1EA5CD931F40F6627F357542653B2" +
+        "01686522130D590FB8DE635D8FCA715CC6BF3D05BEF3F75DA5D543454448166612",
+        /* 4 p.72 ZA */
+        "0090" +
+        "414C494345313233405941484F4F2E434F4D" +
+        "787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498" +
+        "63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A" +
+        "421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D" +
+        "0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2" +
+        "3099093BF3C137D8FCBBCDF4A2AE50F3B0F216C3122D79425FE03A45DBFE1655" +
+        "3DF79E8DAC1CF0ECBAA2F2B49D51A4B387F2EFAF482339086A27A8E05BAED98B",
+        /* 5 p.72 ZB */
+        "0088" +
+        "42494C4C343536405941484F4F2E434F4D" +
+        "787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498" +
+        "63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A" +
+        "421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D" +
+        "0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2" +
+        "245493D446C38D8CC0F118374690E7DF633A8A4BFB3329B5ECE604B2B4F37F43" +
+        "53C0869F4B9E17773DE68FEC45E14904E0DEA45BF6CECF9918C85EA047C60A4C",
+        /* 6 p.75 ZA */
+        "0090" +
+        "414C494345313233405941484F4F2E434F4D" +
+        "000000000000000000000000000000000000000000000000000000000000000000" +
+        "00E78BCD09746C202378A7E72B12BCE00266B9627ECB0B5A25367AD1AD4CC6242B" +
+        "00CDB9CA7F1E6B0441F658343F4B10297C0EF9B6491082400A62E7A7485735FADD" +
+        "013DE74DA65951C4D76DC89220D5F7777A611B1C38BAE260B175951DC8060C2B3E" +
+        "008E3BDB2E11F9193388F1F901CCC857BF49CFC065FB38B9069CAAE6D5AFC3592F" +
+        "004555122AAC0075F42E0A8BBD2C0665C789120DF19D77B4E3EE4712F598040415",
+        /* 7 p.76 ZB */
+        "0088" +
+        "42494C4C343536405941484F4F2E434F4D" +
+        "000000000000000000000000000000000000000000000000000000000000000000" +
+        "00E78BCD09746C202378A7E72B12BCE00266B9627ECB0B5A25367AD1AD4CC6242B" +
+        "00CDB9CA7F1E6B0441F658343F4B10297C0EF9B6491082400A62E7A7485735FADD" +
+        "013DE74DA65951C4D76DC89220D5F7777A611B1C38BAE260B175951DC8060C2B3E" +
+        "0034297DD83AB14D5B393B6712F32B2F2E938D4690B095424B89DA880C52D4A7D9" +
+        "0199BBF11AC95A0EA34BBD00CA50B93EC24ACB68335D20BA5DCFE3B33BDBD2B62D",
+        /* 8 TopsecCA cert ZA */
+        "0080" +
+        "31323334353637383132333435363738" +
+        "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC" +
+        "28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93" +
+        "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7" +
+        "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0" +
+        "D69C2F1EEC3BFB6B95B30C28085C77B125D77A9C39525D8190768F37D6B205B5" +
+        "89DCD316BBE7D89A9DC21917F17799E698531F5E6E3E10BD31370B259C3F81C3",
+        /* 9 */
+        "4D38D2958CA7FD2CFAE3AF04486959CF92C8EF48E8B83A05C112E739D5F181D0" +
+        "3082020CA003020102020900" +
+        "AF28725D98D33143300C06082A811CCF" +
+        "550183750500307D310B300906035504" +
+        "060C02636E310B300906035504080C02" +
+        "626A310B300906035504070C02626A31" +
+        "0F300D060355040A0C06746F70736563" +
+        "310F300D060355040B0C06746F707365" +
+        "633111300F06035504030C08546F7073" +
+        "65634341311F301D06092A864886F70D" +
+        "0109010C10626A40746F707365632E63" +
+        "6F6D2E636E301E170D31323036323430" +
+        "37353433395A170D3332303632303037" +
+        "353433395A307D310B30090603550406" +
+        "0C02636E310B300906035504080C0262" +
+        "6A310B300906035504070C02626A310F" +
+        "300D060355040A0C06746F7073656331" +
+        "0F300D060355040B0C06746F70736563" +
+        "3111300F06035504030C08546F707365" +
+        "634341311F301D06092A864886F70D01" +
+        "09010C10626A40746F707365632E636F" +
+        "6D2E636E3059301306072A8648CE3D02" +
+        "0106082A811CCF5501822D03420004D6" +
+        "9C2F1EEC3BFB6B95B30C28085C77B125" +
+        "D77A9C39525D8190768F37D6B205B589" +
+        "DCD316BBE7D89A9DC21917F17799E698" +
+        "531F5E6E3E10BD31370B259C3F81C3A3" +
+        "733071300F0603551D130101FF040530" +
+        "030101FF301D0603551D0E041604148E" +
+        "5D90347858BAAAD870D8BDFBA6A85E7B" +
+        "563B64301F0603551D23041830168014" +
+        "8E5D90347858BAAAD870D8BDFBA6A85E" +
+        "7B563B64300B0603551D0F0404030201" +
+        "06301106096086480186F84201010404" +
+        "03020057",
+    };
+    
     private static String[] digests = {
         // Standard test vectors
         "66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0",
@@ -27,6 +130,15 @@
         "1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b",
         "623476ac18f65a2909e43c7fec61b49c7e764a91a18ccb82f1917a29c86c5e88",
         "b80fe97a4da24afc277564f66a359ef440462ad28dcc6d63adb24d5c20a61595",
+        // Additional vectors for GMSSL
+        "F4A38489E32B45B6F876E3AC2168CA392362DC8F23459C1D1146FC3DBFB7BC9A",
+        "26352AF82EC19F207BBC6F9474E11E90CE0F7DDACE03B27F801817E897A81FD5",
+        "E4D1D0C3CA4C7F11BC8FF8CB3F4C02A78F108FA098E51A668487240F75E20F31",
+        "6B4B6D0E276691BD4A11BF72F4FB501AE309FDACB72FA6CC336E6656119ABD67",
+        "329c2f6030cc7e0ca3af6c97b76243ca250338ad3d3dc3a8b322d1cfdf98c2b7", // original appears wrong -> "ECF0080215977B2E5D6D61B98A99442F03E8803DC39E349F8DCA5621A9ACDF2B",
+        "557BAD30E183559AEEC3B2256E1C7C11F870D22B165D015ACF9465B09B87B527",
+        "4D38D2958CA7FD2CFAE3AF04486959CF92C8EF48E8B83A05C112E739D5F181D0",
+        "C3B02E500A8B60B77DEDCF6F4C11BEF8D56E5CDE708C72065654FD7B2167915A",
     };
 
     final static String sixtyFourKdigest = "97049bdc8f0736bc7300eafa9980aeb9cf00f24f7ec3a8f1f8884954d7655c1d";
@@ -41,10 +153,38 @@
     {
         super.performTest();
 
+        SM3Digest dig = new SM3Digest();
+        byte[] resBuf = new byte[dig.getDigestSize()];
+        
+        vectorTest(dig, 10, resBuf, Hex.decode(hexMessages[0]), Hex.decode(digests[messages.length]));
+        vectorTest(dig, 11, resBuf, Hex.decode(hexMessages[1]), Hex.decode(digests[messages.length + 1]));
+        vectorTest(dig, 12, resBuf, Hex.decode(hexMessages[2]), Hex.decode(digests[messages.length + 2]));
+        vectorTest(dig, 13, resBuf, Hex.decode(hexMessages[3]), Hex.decode(digests[messages.length + 3]));
+        vectorTest(dig, 14, resBuf, Hex.decode(hexMessages[4]), Hex.decode(digests[messages.length + 4]));
+        vectorTest(dig, 15, resBuf, Hex.decode(hexMessages[5]), Hex.decode(digests[messages.length + 5]));
+        vectorTest(dig, 16, resBuf, Hex.decode(hexMessages[6]), Hex.decode(digests[messages.length + 6]));
+        vectorTest(dig, 17, resBuf, Hex.decode(hexMessages[7]), Hex.decode(digests[messages.length + 7]));
+
         sixtyFourKTest(sixtyFourKdigest);
         millionATest(million_a_digest);
     }
 
+    private void vectorTest(
+        Digest digest,
+        int count,
+        byte[] resBuf,
+        byte[] input,
+        byte[] expected)
+    {
+        digest.update(input, 0, input.length);
+        digest.doFinal(resBuf, 0);
+
+        if (!areEqual(resBuf, expected))
+        {
+            fail("Vector " + count + " failed got " + new String(Hex.encode(resBuf)));
+        }
+    }
+
     protected Digest cloneDigest(Digest digest)
     {
         return new SM3Digest((SM3Digest)digest);
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsKeyExchange.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsKeyExchange.java
index d684aba..37f982c 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsKeyExchange.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsKeyExchange.java
@@ -38,7 +38,7 @@
         if (TlsUtils.isSignatureAlgorithmsExtensionAllowed(clientVersion))
         {
             /*
-             * RFC 5264 7.4.1.4.1. If the client does not send the signature_algorithms extension,
+             * RFC 5246 7.4.1.4.1. If the client does not send the signature_algorithms extension,
              * the server MUST do the following:
              * 
              * - If the negotiated key exchange algorithm is one of (RSA, DHE_RSA, DH_RSA, RSA_PSK,
@@ -104,14 +104,14 @@
         if (supportedSignatureAlgorithms == null)
         {
             /*
-             * TODO RFC 2264 7.4.2. Unless otherwise specified, the signing algorithm for the
+             * TODO RFC 2246 7.4.2. Unless otherwise specified, the signing algorithm for the
              * certificate must be the same as the algorithm for the certificate key.
              */
         }
         else
         {
             /*
-             * TODO RFC 5264 7.4.2. If the client provided a "signature_algorithms" extension, then
+             * TODO RFC 5246 7.4.2. If the client provided a "signature_algorithms" extension, then
              * all certificates provided by the server MUST be signed by a hash/signature algorithm
              * pair that appears in that extension.
              */
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsServer.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsServer.java
index 8131c9f..0e22993 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsServer.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/AbstractTlsServer.java
@@ -209,11 +209,12 @@
         throws IOException
     {
         /*
-         * TODO RFC 5246 7.4.3. In order to negotiate correctly, the server MUST check any candidate
+         * RFC 5246 7.4.3. In order to negotiate correctly, the server MUST check any candidate
          * cipher suites against the "signature_algorithms" extension before selecting them. This is
          * somewhat inelegant but is a compromise designed to minimize changes to the original
          * cipher suite design.
          */
+        Vector sigAlgs = TlsUtils.getUsableSignatureAlgorithms(supportedSignatureAlgorithms);
 
         /*
          * RFC 4429 5.1. A server that receives a ClientHello containing one or both of these
@@ -231,7 +232,8 @@
 
             if (Arrays.contains(this.offeredCipherSuites, cipherSuite)
                 && (eccCipherSuitesEnabled || !TlsECCUtils.isECCCipherSuite(cipherSuite))
-                && TlsUtils.isValidCipherSuiteForVersion(cipherSuite, serverVersion))
+                && TlsUtils.isValidCipherSuiteForVersion(cipherSuite, serverVersion)
+                && TlsUtils.isValidCipherSuiteForSignatureAlgorithms(cipherSuite, sigAlgs))
             {
                 return this.selectedCipherSuite = cipherSuite;
             }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/ByteQueue.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/ByteQueue.java
index cfa72df..2b18e60 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/ByteQueue.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/ByteQueue.java
@@ -1,5 +1,9 @@
 package org.bouncycastle.crypto.tls;
 
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
 /**
  * A queue for bytes. This file could be more optimized.
  */
@@ -42,6 +46,8 @@
      */
     private int available = 0;
 
+    private boolean readOnlyBuf = false;
+
     public ByteQueue()
     {
         this(DEFAULT_CAPACITY);
@@ -49,7 +55,73 @@
 
     public ByteQueue(int capacity)
     {
-        databuf = new byte[capacity];
+        databuf = capacity == 0 ? TlsUtils.EMPTY_BYTES : new byte[capacity];
+    }
+
+    public ByteQueue(byte[] buf, int off, int len)
+    {
+        this.databuf = buf;
+        this.skipped = off;
+        this.available = len;
+        this.readOnlyBuf = true;
+    }
+
+    /**
+     * Add some data to our buffer.
+     *
+     * @param buf A byte-array to read data from.
+     * @param off How many bytes to skip at the beginning of the array.
+     * @param len How many bytes to read from the array.
+     */
+    public void addData(byte[] buf, int off, int len)
+    {
+        if (readOnlyBuf)
+        {
+            throw new IllegalStateException("Cannot add data to read-only buffer");
+        }
+
+        if ((skipped + available + len) > databuf.length)
+        {
+            int desiredSize = ByteQueue.nextTwoPow(available + len);
+            if (desiredSize > databuf.length)
+            {
+                byte[] tmp = new byte[desiredSize];
+                System.arraycopy(databuf, skipped, tmp, 0, available);
+                databuf = tmp;
+            }
+            else
+            {
+                System.arraycopy(databuf, skipped, databuf, 0, available);
+            }
+            skipped = 0;
+        }
+
+        System.arraycopy(buf, off, databuf, skipped + available, len);
+        available += len;
+    }
+
+    /**
+     * @return The number of bytes which are available in this buffer.
+     */
+    public int available()
+    {
+        return available;
+    }
+
+    /**
+     * Copy some bytes from the beginning of the data to the provided {@link OutputStream}.
+     *
+     * @param output The {@link OutputStream} to copy the bytes to.
+     * @param length How many bytes to copy.
+     */
+    public void copyTo(OutputStream output, int length) throws IOException
+    {
+        if (length > available)
+        {
+            throw new IllegalStateException("Cannot copy " + length + " bytes, only got " + available);
+        }
+
+        output.write(databuf, skipped, length);
     }
 
     /**
@@ -75,32 +147,23 @@
     }
 
     /**
-     * Add some data to our buffer.
-     *
-     * @param buf A byte-array to read data from.
-     * @param off How many bytes to skip at the beginning of the array.
-     * @param len How many bytes to read from the array.
+     * Return a {@link ByteArrayInputStream} over some bytes at the beginning of the data.
+     * @param length How many bytes will be readable.
+     * @return A {@link ByteArrayInputStream} over the data.
      */
-    public void addData(byte[] buf, int off, int len)
+    public ByteArrayInputStream readFrom(int length)
     {
-        if ((skipped + available + len) > databuf.length)
+        if (length > available)
         {
-            int desiredSize = ByteQueue.nextTwoPow(available + len);
-            if (desiredSize > databuf.length)
-            {
-                byte[] tmp = new byte[desiredSize];
-                System.arraycopy(databuf, skipped, tmp, 0, available);
-                databuf = tmp;
-            }
-            else
-            {
-                System.arraycopy(databuf, skipped, databuf, 0, available);
-            }
-            skipped = 0;
+            throw new IllegalStateException("Cannot read " + length + " bytes, only got " + available);
         }
 
-        System.arraycopy(buf, off, databuf, skipped + available, len);
-        available += len;
+        int position = skipped;
+
+        available -= length;
+        skipped += length;
+
+        return new ByteArrayInputStream(databuf, position, length);
     }
 
     /**
@@ -142,20 +205,24 @@
         removeData(buf, 0, len, skip);
         return buf;
     }
-    
-    /**
-     * @deprecated Use 'available' instead
-     */
-    public int size()
-    {
-        return available;
-    }
 
-    /**
-     * @return The number of bytes which are available in this buffer.
-     */
-    public int available()
+    public void shrink()
     {
-        return available;
+        if (available == 0)
+        {
+            databuf = TlsUtils.EMPTY_BYTES;
+            skipped = 0;
+        }
+        else
+        {
+            int desiredSize = ByteQueue.nextTwoPow(available);
+            if (desiredSize < databuf.length)
+            {
+                byte[] tmp = new byte[desiredSize];
+                System.arraycopy(databuf, skipped, tmp, 0, available);
+                databuf = tmp;
+                skipped = 0;
+            }
+        }
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSClientProtocol.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSClientProtocol.java
index ef5a250..4f7f1ed 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSClientProtocol.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSClientProtocol.java
@@ -818,7 +818,7 @@
             securityParameters.getCipherSuite());
 
         /*
-         * RFC 5264 7.4.9. Any cipher suite which does not explicitly specify verify_data_length has
+         * RFC 5246 7.4.9. Any cipher suite which does not explicitly specify verify_data_length has
          * a verify_data_length equal to 12. This includes all existing cipher suites.
          */
         securityParameters.verifyDataLength = 12;
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSRecordLayer.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSRecordLayer.java
index 2ce6b58..bfec777 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSRecordLayer.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSRecordLayer.java
@@ -505,7 +505,7 @@
         }
 
         /*
-         * RFC 5264 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert,
+         * RFC 5246 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert,
          * or ChangeCipherSpec content types.
          */
         if (len < 1 && contentType != ContentType.application_data)
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSServerProtocol.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSServerProtocol.java
index 7da59ef..a61bf1f 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSServerProtocol.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DTLSServerProtocol.java
@@ -434,7 +434,7 @@
             securityParameters.getCipherSuite());
 
         /*
-         * RFC 5264 7.4.9. Any cipher suite which does not explicitly specify verify_data_length
+         * RFC 5246 7.4.9. Any cipher suite which does not explicitly specify verify_data_length
          * has a verify_data_length equal to 12. This includes all existing cipher suites.
          */
         securityParameters.verifyDataLength = 12;
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsClient.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsClient.java
index e07a73f..a5b44a6 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsClient.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsClient.java
@@ -44,6 +44,7 @@
 
         switch (keyExchangeAlgorithm)
         {
+        case KeyExchangeAlgorithm.DH_anon:
         case KeyExchangeAlgorithm.DH_DSS:
         case KeyExchangeAlgorithm.DH_RSA:
             return createDHKeyExchange(keyExchangeAlgorithm);
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsServer.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsServer.java
index 0287bab..2adfab4 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsServer.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/DefaultTlsServer.java
@@ -82,6 +82,7 @@
         case KeyExchangeAlgorithm.DHE_DSS:
             return getDSASignerCredentials();
 
+        case KeyExchangeAlgorithm.DH_anon:
         case KeyExchangeAlgorithm.ECDH_anon:
             return null;
 
@@ -108,6 +109,7 @@
 
         switch (keyExchangeAlgorithm)
         {
+        case KeyExchangeAlgorithm.DH_anon:
         case KeyExchangeAlgorithm.DH_DSS:
         case KeyExchangeAlgorithm.DH_RSA:
             return createDHKeyExchange(keyExchangeAlgorithm);
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/RecordStream.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/RecordStream.java
index 99ff9e8..8a942bb 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/RecordStream.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/RecordStream.java
@@ -5,6 +5,8 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
+import org.bouncycastle.util.io.SimpleOutputStream;
+
 /**
  * An implementation of the TLS 1.0/1.1/1.2 record layer, allowing downgrade to SSLv3.
  */
@@ -25,6 +27,13 @@
     private ByteArrayOutputStream buffer = new ByteArrayOutputStream();
 
     private TlsHandshakeHash handshakeHash = null;
+    private SimpleOutputStream handshakeHashUpdater = new SimpleOutputStream()
+    {
+        public void write(byte[] buf, int off, int len) throws IOException
+        {
+            handshakeHash.update(buf, off, len);
+        }
+    };
 
     private ProtocolVersion readVersion = null, writeVersion = null;
     private boolean restrictReadVersion = true;
@@ -131,6 +140,42 @@
         this.pendingCipher = null;
     }
 
+    void checkRecordHeader(byte[] recordHeader) throws IOException
+    {
+        short type = TlsUtils.readUint8(recordHeader, TLS_HEADER_TYPE_OFFSET);
+
+        /*
+         * RFC 5246 6. If a TLS implementation receives an unexpected record type, it MUST send an
+         * unexpected_message alert.
+         */
+        checkType(type, AlertDescription.unexpected_message);
+
+        if (!restrictReadVersion)
+        {
+            int version = TlsUtils.readVersionRaw(recordHeader, TLS_HEADER_VERSION_OFFSET);
+            if ((version & 0xffffff00) != 0x0300)
+            {
+                throw new TlsFatalAlert(AlertDescription.illegal_parameter);
+            }
+        }
+        else
+        {
+            ProtocolVersion version = TlsUtils.readVersion(recordHeader, TLS_HEADER_VERSION_OFFSET);
+            if (readVersion == null)
+            {
+                // Will be set later in 'readRecord'
+            }
+            else if (!version.equals(readVersion))
+            {
+                throw new TlsFatalAlert(AlertDescription.illegal_parameter);
+            }
+        }
+
+        int length = TlsUtils.readUint16(recordHeader, TLS_HEADER_LENGTH_OFFSET);
+
+        checkLength(length, ciphertextLimit, AlertDescription.record_overflow);
+    }
+
     boolean readRecord()
         throws IOException
     {
@@ -170,6 +215,9 @@
         }
 
         int length = TlsUtils.readUint16(recordHeader, TLS_HEADER_LENGTH_OFFSET);
+
+        checkLength(length, ciphertextLimit, AlertDescription.record_overflow);
+
         byte[] plaintext = decodeAndVerify(type, input, length);
         handler.processRecord(type, plaintext, 0, plaintext.length);
         return true;
@@ -178,15 +226,13 @@
     byte[] decodeAndVerify(short type, InputStream input, int len)
         throws IOException
     {
-        checkLength(len, ciphertextLimit, AlertDescription.record_overflow);
-
         byte[] buf = TlsUtils.readFully(len, input);
         byte[] decoded = readCipher.decodeCiphertext(readSeqNo++, type, buf, 0, buf.length);
 
         checkLength(decoded.length, compressedLimit, AlertDescription.record_overflow);
 
         /*
-         * TODO RFC5264 6.2.2. Implementation note: Decompression functions are responsible for
+         * TODO RFC 5246 6.2.2. Implementation note: Decompression functions are responsible for
          * ensuring that messages cannot cause internal buffer overflows.
          */
         OutputStream cOut = readCompression.decompress(buffer);
@@ -198,14 +244,14 @@
         }
 
         /*
-         * RFC 5264 6.2.2. If the decompression function encounters a TLSCompressed.fragment that
+         * RFC 5246 6.2.2. If the decompression function encounters a TLSCompressed.fragment that
          * would decompress to a length in excess of 2^14 bytes, it should report a fatal
          * decompression failure error.
          */
         checkLength(decoded.length, plaintextLimit, AlertDescription.decompression_failure);
 
         /*
-         * RFC 5264 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert,
+         * RFC 5246 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert,
          * or ChangeCipherSpec content types.
          */
         if (decoded.length < 1 && type != ContentType.application_data)
@@ -226,18 +272,18 @@
         }
 
         /*
-         * RFC 5264 6. Implementations MUST NOT send record types not defined in this document
+         * RFC 5246 6. Implementations MUST NOT send record types not defined in this document
          * unless negotiated by some extension.
          */
         checkType(type, AlertDescription.internal_error);
 
         /*
-         * RFC 5264 6.2.1 The length should not exceed 2^14.
+         * RFC 5246 6.2.1 The length should not exceed 2^14.
          */
         checkLength(plaintextLength, plaintextLimit, AlertDescription.internal_error);
 
         /*
-         * RFC 5264 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert,
+         * RFC 5246 6.2.1 Implementations MUST NOT send zero-length fragments of Handshake, Alert,
          * or ChangeCipherSpec content types.
          */
         if (plaintextLength < 1 && type != ContentType.application_data)
@@ -245,11 +291,6 @@
             throw new TlsFatalAlert(AlertDescription.internal_error);
         }
 
-        if (type == ContentType.handshake)
-        {
-            updateHandshakeData(plaintext, plaintextOffset, plaintextLength);
-        }
-
         OutputStream cOut = writeCompression.compress(buffer);
 
         byte[] ciphertext;
@@ -264,7 +305,7 @@
             byte[] compressed = getBufferContents();
 
             /*
-             * RFC5264 6.2.2. Compression must be lossless and may not increase the content length
+             * RFC 5246 6.2.2. Compression must be lossless and may not increase the content length
              * by more than 1024 bytes.
              */
             checkLength(compressed.length, plaintextLength + 1024, AlertDescription.internal_error);
@@ -273,7 +314,7 @@
         }
 
         /*
-         * RFC 5264 6.2.3. The length may not exceed 2^14 + 2048.
+         * RFC 5246 6.2.3. The length may not exceed 2^14 + 2048.
          */
         checkLength(ciphertext.length, ciphertextLimit, AlertDescription.internal_error);
 
@@ -296,6 +337,11 @@
         return handshakeHash;
     }
 
+    OutputStream getHandshakeHashUpdater()
+    {
+        return handshakeHashUpdater;
+    }
+
     TlsHandshakeHash prepareToFinish()
     {
         TlsHandshakeHash result = handshakeHash;
@@ -303,11 +349,6 @@
         return result;
     }
 
-    void updateHandshakeData(byte[] message, int offset, int len)
-    {
-        handshakeHash.update(message, offset, len);
-    }
-
     void safeClose()
     {
         try
@@ -349,7 +390,7 @@
         case ContentType.alert:
         case ContentType.change_cipher_spec:
         case ContentType.handshake:
-        case ContentType.heartbeat:
+//        case ContentType.heartbeat:
             break;
         default:
             throw new TlsFatalAlert(alertDescription);
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsClientProtocol.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsClientProtocol.java
index 2e5efdb..45a62b8 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsClientProtocol.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsClientProtocol.java
@@ -133,11 +133,9 @@
         return tlsClient;
     }
 
-    protected void handleHandshakeMessage(short type, byte[] data)
+    protected void handleHandshakeMessage(short type, ByteArrayInputStream buf)
         throws IOException
     {
-        ByteArrayInputStream buf = new ByteArrayInputStream(data);
-
         if (this.resumedSession)
         {
             if (type != HandshakeType.finished || this.connection_state != CS_SERVER_HELLO)
@@ -150,7 +148,6 @@
 
             sendFinishedMessage();
             this.connection_state = CS_CLIENT_FINISHED;
-            this.connection_state = CS_END;
 
             completeHandshake();
             return;
@@ -246,7 +243,6 @@
             {
                 processFinishedMessage(buf);
                 this.connection_state = CS_SERVER_FINISHED;
-                this.connection_state = CS_END;
 
                 completeHandshake();
                 break;
@@ -386,10 +382,19 @@
                 sendClientKeyExchangeMessage();
                 this.connection_state = CS_CLIENT_KEY_EXCHANGE;
 
+                if (TlsUtils.isSSL(getContext()))
+                {
+                    establishMasterSecret(getContext(), keyExchange);
+                }
+
                 TlsHandshakeHash prepareFinishHash = recordStream.prepareToFinish();
                 this.securityParameters.sessionHash = getCurrentPRFHash(getContext(), prepareFinishHash, null);
 
-                establishMasterSecret(getContext(), keyExchange);
+                if (!TlsUtils.isSSL(getContext()))
+                {
+                    establishMasterSecret(getContext(), keyExchange);
+                }
+
                 recordStream.setPendingConnectionState(getPeer().getCompression(), getPeer().getCipher());
 
                 if (clientCreds != null && clientCreds instanceof TlsSignerCredentials)
@@ -424,7 +429,7 @@
                 break;
             }
             default:
-                throw new TlsFatalAlert(AlertDescription.handshake_failure);
+                throw new TlsFatalAlert(AlertDescription.unexpected_message);
             }
 
             this.connection_state = CS_CLIENT_FINISHED;
@@ -810,7 +815,7 @@
             this.securityParameters.getCipherSuite());
 
         /*
-         * RFC 5264 7.4.9. Any cipher suite which does not explicitly specify
+         * RFC 5246 7.4.9. Any cipher suite which does not explicitly specify
          * verify_data_length has a verify_data_length equal to 12. This includes all
          * existing cipher suites.
          */
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsDHKeyExchange.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsDHKeyExchange.java
index e25a7ad..3a2ac7b 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsDHKeyExchange.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsDHKeyExchange.java
@@ -1,5 +1,6 @@
 package org.bouncycastle.crypto.tls;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -35,6 +36,7 @@
 
         switch (keyExchange)
         {
+        case KeyExchangeAlgorithm.DH_anon:
         case KeyExchangeAlgorithm.DH_RSA:
         case KeyExchangeAlgorithm.DH_DSS:
             this.tlsSigner = null;
@@ -65,12 +67,19 @@
     public void skipServerCredentials()
         throws IOException
     {
-        throw new TlsFatalAlert(AlertDescription.unexpected_message);
+        if (keyExchange != KeyExchangeAlgorithm.DH_anon)
+        {
+            throw new TlsFatalAlert(AlertDescription.unexpected_message);
+        }
     }
 
     public void processServerCertificate(Certificate serverCertificate)
         throws IOException
     {
+        if (keyExchange == KeyExchangeAlgorithm.DH_anon)
+        {
+            throw new TlsFatalAlert(AlertDescription.unexpected_message);
+        }
         if (serverCertificate.isEmpty())
         {
             throw new TlsFatalAlert(AlertDescription.bad_certificate);
@@ -119,15 +128,45 @@
     {
         switch (keyExchange)
         {
+        case KeyExchangeAlgorithm.DH_anon:
         case KeyExchangeAlgorithm.DHE_DSS:
         case KeyExchangeAlgorithm.DHE_RSA:
-        case KeyExchangeAlgorithm.DH_anon:
             return true;
         default:
             return false;
         }
     }
 
+    public byte[] generateServerKeyExchange() throws IOException
+    {
+        if (!requiresServerKeyExchange())
+        {
+            return null;
+        }
+
+        // DH_anon is handled here, DHE_* in a subclass
+
+        ByteArrayOutputStream buf = new ByteArrayOutputStream();
+        this.dhAgreePrivateKey = TlsDHUtils.generateEphemeralServerKeyExchange(context.getSecureRandom(),
+            this.dhParameters, buf);
+        return buf.toByteArray();
+    }
+
+    public void processServerKeyExchange(InputStream input) throws IOException
+    {
+        if (!requiresServerKeyExchange())
+        {
+            throw new TlsFatalAlert(AlertDescription.unexpected_message);
+        }
+
+        // DH_anon is handled here, DHE_* in a subclass
+
+        ServerDHParams dhParams = ServerDHParams.parse(input);
+
+        this.dhAgreePublicKey = TlsDHUtils.validateDHPublicKey(dhParams.getPublicKey());
+        this.dhParameters = validateDHParameters(dhAgreePublicKey.getParameters());
+    }
+
     public void validateCertificateRequest(CertificateRequest certificateRequest)
         throws IOException
     {
@@ -151,6 +190,11 @@
     public void processClientCredentials(TlsCredentials clientCredentials)
         throws IOException
     {
+        if (keyExchange == KeyExchangeAlgorithm.DH_anon)
+        {
+            throw new TlsFatalAlert(AlertDescription.internal_error);
+        }
+
         if (clientCredentials instanceof TlsAgreementCredentials)
         {
             // TODO Validate client cert has matching parameters (see 'areCompatibleParameters')?
@@ -184,12 +228,13 @@
 
     public void processClientCertificate(Certificate clientCertificate) throws IOException
     {
-        // TODO Extract the public key and validate
+        if (keyExchange == KeyExchangeAlgorithm.DH_anon)
+        {
+            throw new TlsFatalAlert(AlertDescription.unexpected_message);
+        }
 
-        /*
-         * TODO If the certificate is 'fixed', take the public key as dhAgreePublicKey and check
-         * that the parameters match the server's (see 'areCompatibleParameters').
-         */
+        // TODO Extract the public key
+        // TODO If the certificate is 'fixed', take the public key as dhAgreePublicKey
     }
 
     public void processClientKeyExchange(InputStream input) throws IOException
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsNoCloseNotifyException.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsNoCloseNotifyException.java
new file mode 100644
index 0000000..a5c583b
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsNoCloseNotifyException.java
@@ -0,0 +1,15 @@
+package org.bouncycastle.crypto.tls;
+
+import java.io.EOFException;
+
+/**
+ * This exception will be thrown (only) when the connection is closed by the peer without sending a
+ * {@link AlertDescription#close_notify close_notify} warning alert. If this happens, the TLS
+ * protocol cannot rule out truncation of the connection data (potentially malicious). It may be
+ * possible to check for truncation via some property of a higher level protocol built upon TLS,
+ * e.g. the Content-Length header for HTTPS.
+ */
+public class TlsNoCloseNotifyException
+    extends EOFException
+{
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsProtocol.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsProtocol.java
index 7b06a2e..9c274ea 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsProtocol.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsProtocol.java
@@ -54,9 +54,9 @@
     /*
      * Queues for data from some protocols.
      */
-    private ByteQueue applicationDataQueue = new ByteQueue();
+    private ByteQueue applicationDataQueue = new ByteQueue(0);
     private ByteQueue alertQueue = new ByteQueue(2);
-    private ByteQueue handshakeQueue = new ByteQueue();
+    private ByteQueue handshakeQueue = new ByteQueue(0);
 //    private ByteQueue heartbeatQueue = new ByteQueue();
 
     /*
@@ -122,7 +122,7 @@
     {
     }
 
-    protected abstract void handleHandshakeMessage(short type, byte[] buf)
+    protected abstract void handleHandshakeMessage(short type, ByteArrayInputStream buf)
         throws IOException;
 
     protected void handleWarningMessage(short description)
@@ -185,7 +185,8 @@
             {
                 if (this.closed)
                 {
-                    // TODO What kind of exception/alert?
+                    // NOTE: Any close during the handshake should have raised an exception.
+                    throw new TlsFatalAlert(AlertDescription.internal_error);
                 }
 
                 safeReadRecord();
@@ -198,6 +199,11 @@
     {
         try
         {
+            this.connection_state = CS_END;
+
+            this.alertQueue.shrink();
+            this.handshakeQueue.shrink();
+
             this.recordStream.finaliseHandshake();
 
             this.appDataSplitEnabled = !TlsUtils.isTLSv11(getContext());
@@ -245,7 +251,7 @@
         }
     }
 
-    protected void processRecord(short protocol, byte[] buf, int offset, int len)
+    protected void processRecord(short protocol, byte[] buf, int off, int len)
         throws IOException
     {
         /*
@@ -255,8 +261,8 @@
         {
         case ContentType.alert:
         {
-            alertQueue.addData(buf, offset, len);
-            processAlert();
+            alertQueue.addData(buf, off, len);
+            processAlertQueue();
             break;
         }
         case ContentType.application_data:
@@ -265,109 +271,112 @@
             {
                 throw new TlsFatalAlert(AlertDescription.unexpected_message);
             }
-            applicationDataQueue.addData(buf, offset, len);
-            processApplicationData();
+            applicationDataQueue.addData(buf, off, len);
+            processApplicationDataQueue();
             break;
         }
         case ContentType.change_cipher_spec:
         {
-            processChangeCipherSpec(buf, offset, len);
+            processChangeCipherSpec(buf, off, len);
             break;
         }
         case ContentType.handshake:
         {
-            handshakeQueue.addData(buf, offset, len);
-            processHandshake();
-            break;
-        }
-        case ContentType.heartbeat:
-        {
-            if (!appDataReady)
+            if (handshakeQueue.available() > 0)
             {
-                throw new TlsFatalAlert(AlertDescription.unexpected_message);
+                handshakeQueue.addData(buf, off, len);
+                processHandshakeQueue(handshakeQueue);
             }
-            // TODO[RFC 6520]
-//            heartbeatQueue.addData(buf, offset, len);
-//            processHeartbeat();
+            else
+            {
+                ByteQueue tmpQueue = new ByteQueue(buf, off, len);
+                processHandshakeQueue(tmpQueue);
+                int remaining = tmpQueue.available();
+                if (remaining > 0)
+                {
+                    handshakeQueue.addData(buf, off + len - remaining, remaining);
+                }
+            }
             break;
         }
+//        case ContentType.heartbeat:
+//        {
+//            if (!appDataReady)
+//            {
+//                throw new TlsFatalAlert(AlertDescription.unexpected_message);
+//            }
+//            // TODO[RFC 6520]
+////            heartbeatQueue.addData(buf, offset, len);
+////            processHeartbeat();
+//            break;
+//        }
         default:
-            /*
-             * Uh, we don't know this protocol.
-             * 
-             * RFC2246 defines on page 13, that we should ignore this.
-             */
-            break;
+            // Record type should already have been checked
+            throw new TlsFatalAlert(AlertDescription.internal_error);
         }
     }
 
-    private void processHandshake()
+    private void processHandshakeQueue(ByteQueue queue)
         throws IOException
     {
-        boolean read;
-        do
+        while (queue.available() >= 4)
         {
-            read = false;
             /*
              * We need the first 4 bytes, they contain type and length of the message.
              */
-            if (handshakeQueue.available() >= 4)
+            byte[] beginning = new byte[4];
+            queue.read(beginning, 0, 4, 0);
+            short type = TlsUtils.readUint8(beginning, 0);
+            int length = TlsUtils.readUint24(beginning, 1);
+            int totalLength = 4 + length;
+    
+            /*
+             * Check if we have enough bytes in the buffer to read the full message.
+             */
+            if (queue.available() < totalLength)
             {
-                byte[] beginning = new byte[4];
-                handshakeQueue.read(beginning, 0, 4, 0);
-                short type = TlsUtils.readUint8(beginning, 0);
-                int len = TlsUtils.readUint24(beginning, 1);
-
-                /*
-                 * Check if we have enough bytes in the buffer to read the full message.
-                 */
-                if (handshakeQueue.available() >= (len + 4))
-                {
-                    /*
-                     * Read the message.
-                     */
-                    byte[] buf = handshakeQueue.removeData(len, 4);
-
-                    checkReceivedChangeCipherSpec(connection_state == CS_END || type == HandshakeType.finished);
-
-                    /*
-                     * RFC 2246 7.4.9. The value handshake_messages includes all handshake messages
-                     * starting at client hello up to, but not including, this finished message.
-                     * [..] Note: [Also,] Hello Request messages are omitted from handshake hashes.
-                     */
-                    switch (type)
-                    {
-                    case HandshakeType.hello_request:
-                        break;
-                    case HandshakeType.finished:
-                    {
-                        TlsContext ctx = getContext();
-                        if (this.expected_verify_data == null
-                            && ctx.getSecurityParameters().getMasterSecret() != null)
-                        {
-                            this.expected_verify_data = createVerifyData(!ctx.isServer());
-                        }
-
-                        // NB: Fall through to next case label
-                    }
-                    default:
-                        recordStream.updateHandshakeData(beginning, 0, 4);
-                        recordStream.updateHandshakeData(buf, 0, len);
-                        break;
-                    }
-
-                    /*
-                     * Now, parse the message.
-                     */
-                    handleHandshakeMessage(type, buf);
-                    read = true;
-                }
+                break;
             }
+
+            checkReceivedChangeCipherSpec(connection_state == CS_END || type == HandshakeType.finished);
+
+            /*
+             * RFC 2246 7.4.9. The value handshake_messages includes all handshake messages
+             * starting at client hello up to, but not including, this finished message.
+             * [..] Note: [Also,] Hello Request messages are omitted from handshake hashes.
+             */
+            switch (type)
+            {
+            case HandshakeType.hello_request:
+                break;
+            case HandshakeType.finished:
+            {
+                TlsContext ctx = getContext();
+                if (this.expected_verify_data == null
+                    && ctx.getSecurityParameters().getMasterSecret() != null)
+                {
+                    this.expected_verify_data = createVerifyData(!ctx.isServer());
+                }
+
+                // NB: Fall through to next case label
+            }
+            default:
+                queue.copyTo(recordStream.getHandshakeHashUpdater(), totalLength);
+                break;
+            }
+
+            queue.removeData(4);
+
+            ByteArrayInputStream buf = queue.readFrom(length);
+
+            /*
+             * Now, parse the message.
+             */
+            handleHandshakeMessage(type, buf);
         }
-        while (read);
     }
 
-    private void processApplicationData()
+    private void processApplicationDataQueue()
     {
         /*
          * There is nothing we need to do here.
@@ -376,7 +385,7 @@
          */
     }
 
-    private void processAlert()
+    private void processAlertQueue()
         throws IOException
     {
         while (alertQueue.available() >= 2)
@@ -407,14 +416,16 @@
             }
             else
             {
-
                 /*
                  * RFC 5246 7.2.1. The other party MUST respond with a close_notify alert of its own
                  * and close down the connection immediately, discarding any pending writes.
                  */
-                // TODO Can close_notify be a fatal alert?
                 if (description == AlertDescription.close_notify)
                 {
+                    if (!appDataReady)
+                    {
+                        throw new TlsFatalAlert(AlertDescription.handshake_failure);
+                    }
                     handleClose(false);
                 }
 
@@ -511,6 +522,30 @@
         return len;
     }
 
+    protected void safeCheckRecordHeader(byte[] recordHeader)
+        throws IOException
+    {
+        try
+        {
+            recordStream.checkRecordHeader(recordHeader);
+        }
+        catch (TlsFatalAlert e)
+        {
+            this.failWithError(AlertLevel.fatal, e.getAlertDescription(), "Failed to read record", e);
+            throw e;
+        }
+        catch (IOException e)
+        {
+            this.failWithError(AlertLevel.fatal, AlertDescription.internal_error, "Failed to read record", e);
+            throw e;
+        }
+        catch (RuntimeException e)
+        {
+            this.failWithError(AlertLevel.fatal, AlertDescription.internal_error, "Failed to read record", e);
+            throw e;
+        }
+    }
+
     protected void safeReadRecord()
         throws IOException
     {
@@ -518,9 +553,11 @@
         {
             if (!recordStream.readRecord())
             {
-                // TODO It would be nicer to allow graceful connection close if between records
-//                this.failWithError(AlertLevel.warning, AlertDescription.close_notify);
-                throw new EOFException();
+                if (!appDataReady)
+                {
+                    throw new TlsFatalAlert(AlertDescription.handshake_failure);
+                }
+                throw new TlsNoCloseNotifyException();
             }
         }
         catch (TlsFatalAlert e)
@@ -659,14 +696,26 @@
 
     protected void writeHandshakeMessage(byte[] buf, int off, int len) throws IOException
     {
-        while (len > 0)
+        if (len < 4)
+        {
+            throw new TlsFatalAlert(AlertDescription.internal_error);
+        }
+
+        short type = TlsUtils.readUint8(buf, off);
+        if (type != HandshakeType.hello_request)
+        {
+            recordStream.getHandshakeHashUpdater().write(buf, off, len);
+        }
+
+        int total = 0;
+        do
         {
             // Fragment data according to the current fragment limit.
-            int toWrite = Math.min(len, recordStream.getPlaintextLimit());
-            safeWriteRecord(ContentType.handshake, buf, off, toWrite);
-            off += toWrite;
-            len -= toWrite;
+            int toWrite = Math.min(len - total, recordStream.getPlaintextLimit());
+            safeWriteRecord(ContentType.handshake, buf, off + total, toWrite);
+            total += toWrite;
         }
+        while (total < len);
     }
 
     /**
@@ -694,6 +743,34 @@
     }
 
     /**
+     * Should be called in non-blocking mode when the input data reaches EOF.
+     */
+    public void closeInput() throws IOException
+    {
+        if (blocking)
+        {
+            throw new IllegalStateException("Cannot use closeInput() in blocking mode!");
+        }
+
+        if (closed)
+        {
+            return;
+        }
+
+        if (inputBuffers.available() > 0)
+        {
+            throw new EOFException();
+        }
+
+        if (!appDataReady)
+        {
+            throw new TlsFatalAlert(AlertDescription.handshake_failure);
+        }
+
+        throw new TlsNoCloseNotifyException();
+    }
+
+    /**
      * Offer input from an arbitrary source. Only allowed in non-blocking mode.<br>
      * <br>
      * After this method returns, the input buffer is "owned" by this object. Other code
@@ -728,17 +805,28 @@
         // loop while there are enough bytes to read the length of the next record
         while (inputBuffers.available() >= RecordStream.TLS_HEADER_SIZE)
         {
-            byte[] header = new byte[RecordStream.TLS_HEADER_SIZE];
-            inputBuffers.peek(header);
+            byte[] recordHeader = new byte[RecordStream.TLS_HEADER_SIZE];
+            inputBuffers.peek(recordHeader);
 
-            int totalLength = TlsUtils.readUint16(header, RecordStream.TLS_HEADER_LENGTH_OFFSET) + RecordStream.TLS_HEADER_SIZE;
+            int totalLength = TlsUtils.readUint16(recordHeader, RecordStream.TLS_HEADER_LENGTH_OFFSET) + RecordStream.TLS_HEADER_SIZE;
             if (inputBuffers.available() < totalLength)
             {
                 // not enough bytes to read a whole record
+                safeCheckRecordHeader(recordHeader);
                 break;
             }
 
             safeReadRecord();
+
+            if (closed)
+            {
+                if (connection_state != CS_END)
+                {
+                    // NOTE: Any close during the handshake should have raised an exception.
+                    throw new TlsFatalAlert(AlertDescription.internal_error);
+                }
+                break;
+            }
         }
     }
 
@@ -1291,6 +1379,9 @@
 
         switch (ciphersuite)
         {
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_GCM_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA256:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256:
@@ -1394,6 +1485,7 @@
             throw new TlsFatalAlert(AlertDescription.illegal_parameter);
         }
 
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384:
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsRSASigner.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsRSASigner.java
index 35538a7..2bd955c 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsRSASigner.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsRSASigner.java
@@ -102,7 +102,7 @@
     protected AsymmetricBlockCipher createRSAImpl()
     {
         /*
-         * RFC 5264 7.4.7.1. Implementation note: It is now known that remote timing-based attacks
+         * RFC 5246 7.4.7.1. Implementation note: It is now known that remote timing-based attacks
          * on TLS are possible, at least when the client and server are on the same LAN.
          * Accordingly, implementations that use static RSA keys MUST use RSA blinding or some other
          * anti-timing technique, as described in [TIMING].
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsServerProtocol.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsServerProtocol.java
index 2923dee..d9aecfe 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsServerProtocol.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsServerProtocol.java
@@ -121,11 +121,9 @@
         return tlsServer;
     }
 
-    protected void handleHandshakeMessage(short type, byte[] data)
+    protected void handleHandshakeMessage(short type, ByteArrayInputStream buf)
         throws IOException
     {
-        ByteArrayInputStream buf = new ByteArrayInputStream(data);
-
         switch (type)
         {
         case HandshakeType.client_hello:
@@ -373,7 +371,6 @@
 
                 sendFinishedMessage();
                 this.connection_state = CS_SERVER_FINISHED;
-                this.connection_state = CS_END;
 
                 completeHandshake();
                 break;
@@ -654,10 +651,19 @@
 
         assertEmpty(buf);
 
+        if (TlsUtils.isSSL(getContext()))
+        {
+            establishMasterSecret(getContext(), keyExchange);
+        }
+
         this.prepareFinishHash = recordStream.prepareToFinish();
         this.securityParameters.sessionHash = getCurrentPRFHash(getContext(), prepareFinishHash, null);
 
-        establishMasterSecret(getContext(), keyExchange);
+        if (!TlsUtils.isSSL(getContext()))
+        {
+            establishMasterSecret(getContext(), keyExchange);
+        }
+
         recordStream.setPendingConnectionState(getPeer().getCompression(), getPeer().getCipher());
 
         if (!expectSessionTicket)
@@ -817,7 +823,7 @@
         securityParameters.prfAlgorithm = getPRFAlgorithm(getContext(), securityParameters.getCipherSuite());
 
         /*
-         * RFC 5264 7.4.9. Any cipher suite which does not explicitly specify verify_data_length has
+         * RFC 5246 7.4.9. Any cipher suite which does not explicitly specify verify_data_length has
          * a verify_data_length equal to 12. This includes all existing cipher suites.
          */
         securityParameters.verifyDataLength = 12;
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsUtils.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsUtils.java
index a402109..446060d 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsUtils.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/TlsUtils.java
@@ -35,6 +35,7 @@
 import org.bouncycastle.crypto.util.PublicKeyFactory;
 import org.bouncycastle.util.Arrays;
 import org.bouncycastle.util.Integers;
+import org.bouncycastle.util.Shorts;
 import org.bouncycastle.util.Strings;
 import org.bouncycastle.util.io.Streams;
 
@@ -706,6 +707,16 @@
         buf[offset + 1] = (byte)version.getMinorVersion();
     }
 
+    public static Vector getAllSignatureAlgorithms()
+    {
+        Vector v = new Vector(4);
+        v.addElement(Shorts.valueOf(SignatureAlgorithm.anonymous));
+        v.addElement(Shorts.valueOf(SignatureAlgorithm.rsa));
+        v.addElement(Shorts.valueOf(SignatureAlgorithm.dsa));
+        v.addElement(Shorts.valueOf(SignatureAlgorithm.ecdsa));
+        return v;
+    }
+
     public static Vector getDefaultDSSSignatureAlgorithms()
     {
         return vectorOfOne(new SignatureAndHashAlgorithm(HashAlgorithm.sha1, SignatureAlgorithm.dsa));
@@ -1447,6 +1458,7 @@
     {
         switch (ciphersuite)
         {
+        case CipherSuite.TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA:
         case CipherSuite.TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA:
         case CipherSuite.TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA:
@@ -1466,6 +1478,8 @@
         case CipherSuite.TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA:
             return EncryptionAlgorithm._3DES_EDE_CBC;
 
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA256:
         case CipherSuite.TLS_DH_RSA_WITH_AES_128_CBC_SHA:
@@ -1512,6 +1526,7 @@
         case CipherSuite.TLS_RSA_WITH_AES_128_CCM_8:
             return EncryptionAlgorithm.AES_128_CCM_8;
 
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_GCM_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_GCM_SHA256:
         case CipherSuite.TLS_DH_RSA_WITH_AES_128_GCM_SHA256:
         case CipherSuite.TLS_DHE_DSS_WITH_AES_128_GCM_SHA256:
@@ -1534,6 +1549,8 @@
         case CipherSuite.DRAFT_TLS_PSK_WITH_AES_128_OCB:
             return EncryptionAlgorithm.AES_128_OCB_TAGLEN96;
 
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_CBC_SHA256:
         case CipherSuite.TLS_DH_RSA_WITH_AES_256_CBC_SHA:
@@ -1580,6 +1597,7 @@
         case CipherSuite.TLS_RSA_WITH_AES_256_CCM_8:
             return EncryptionAlgorithm.AES_256_CCM_8;
 
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DH_RSA_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DHE_DSS_WITH_AES_256_GCM_SHA384:
@@ -1602,17 +1620,16 @@
         case CipherSuite.DRAFT_TLS_PSK_WITH_AES_256_OCB:
             return EncryptionAlgorithm.AES_256_OCB_TAGLEN96;
 
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA:
-        case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA:
-        case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA:
-        case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA:
-        case CipherSuite.TLS_RSA_WITH_CAMELLIA_128_CBC_SHA:
-            return EncryptionAlgorithm.CAMELLIA_128_CBC;
-
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA:
         case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA:
         case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA:
         case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256:
@@ -1620,10 +1637,12 @@
         case CipherSuite.TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256:
-        case CipherSuite.TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_RSA_WITH_CAMELLIA_128_CBC_SHA:
         case CipherSuite.TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256:
             return EncryptionAlgorithm.CAMELLIA_128_CBC;
 
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256:
         case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256:
         case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256:
@@ -1638,30 +1657,29 @@
         case CipherSuite.TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256:
             return EncryptionAlgorithm.CAMELLIA_128_GCM;
 
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA:
-        case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA:
-        case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA:
-        case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA:
-        case CipherSuite.TLS_RSA_WITH_CAMELLIA_256_CBC_SHA:
-            return EncryptionAlgorithm.CAMELLIA_256_CBC;
-
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256:
+        case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA:
         case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256:
+        case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA:
         case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256:
-        case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256:
-        case CipherSuite.TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256:
-            return EncryptionAlgorithm.CAMELLIA_256_CBC;
-
         case CipherSuite.TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384:
+        case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA:
+        case CipherSuite.TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256:
         case CipherSuite.TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384:
         case CipherSuite.TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384:
         case CipherSuite.TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384:
         case CipherSuite.TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384:
         case CipherSuite.TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384:
         case CipherSuite.TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384:
+        case CipherSuite.TLS_RSA_WITH_CAMELLIA_256_CBC_SHA:
+        case CipherSuite.TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256:
         case CipherSuite.TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384:
             return EncryptionAlgorithm.CAMELLIA_256_CBC;
 
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384:
         case CipherSuite.TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384:
         case CipherSuite.TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384:
@@ -1729,6 +1747,7 @@
         case CipherSuite.TLS_RSA_PSK_WITH_RC4_128_SHA:
             return EncryptionAlgorithm.RC4_128;
 
+        case CipherSuite.TLS_DH_anon_WITH_SEED_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_SEED_CBC_SHA:
         case CipherSuite.TLS_DH_RSA_WITH_SEED_CBC_SHA:
         case CipherSuite.TLS_DHE_DSS_WITH_SEED_CBC_SHA:
@@ -1745,6 +1764,23 @@
     {
         switch (ciphersuite)
         {
+        case CipherSuite.TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_GCM_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_GCM_SHA384:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384:
+        case CipherSuite.TLS_DH_anon_WITH_RC4_128_MD5:
+        case CipherSuite.TLS_DH_anon_WITH_SEED_CBC_SHA:
+            return KeyExchangeAlgorithm.DH_anon;
+
         case CipherSuite.TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA256:
@@ -2024,6 +2060,10 @@
     {
         switch (ciphersuite)
         {
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_GCM_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_GCM_SHA384:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_GCM_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256:
@@ -2113,10 +2153,17 @@
         case CipherSuite.TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384:
             return MACAlgorithm._null;
 
+        case CipherSuite.TLS_DH_anon_WITH_RC4_128_MD5:
         case CipherSuite.TLS_RSA_WITH_NULL_MD5:
         case CipherSuite.TLS_RSA_WITH_RC4_128_MD5:
             return MACAlgorithm.hmac_md5;
 
+        case CipherSuite.TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA:
+        case CipherSuite.TLS_DH_anon_WITH_SEED_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_CBC_SHA:
@@ -2205,6 +2252,10 @@
         case CipherSuite.TLS_SRP_SHA_WITH_AES_256_CBC_SHA:
             return MACAlgorithm.hmac_sha1;
 
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_AES_256_CBC_SHA256:
         case CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256:
@@ -2279,6 +2330,10 @@
     {
         switch (ciphersuite)
         {
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_128_GCM_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_CBC_SHA256:
+        case CipherSuite.TLS_DH_anon_WITH_AES_256_GCM_SHA384:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256:
         case CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256:
@@ -2429,8 +2484,70 @@
         return CipherType.stream == getCipherType(ciphersuite);
     }
 
+    public static boolean isValidCipherSuiteForSignatureAlgorithms(int cipherSuite, Vector sigAlgs)
+    {
+        int keyExchangeAlgorithm;
+        try
+        {
+            keyExchangeAlgorithm = getKeyExchangeAlgorithm(cipherSuite);
+        }
+        catch (IOException e)
+        {
+            return true;
+        }
+
+        switch (keyExchangeAlgorithm)
+        {
+        case KeyExchangeAlgorithm.DH_anon:
+        case KeyExchangeAlgorithm.DH_anon_EXPORT:
+        case KeyExchangeAlgorithm.ECDH_anon:
+            return sigAlgs.contains(Shorts.valueOf(SignatureAlgorithm.anonymous));
+
+        case KeyExchangeAlgorithm.DHE_RSA:
+        case KeyExchangeAlgorithm.DHE_RSA_EXPORT:
+        case KeyExchangeAlgorithm.ECDHE_RSA:
+        case KeyExchangeAlgorithm.SRP_RSA:
+            return sigAlgs.contains(Shorts.valueOf(SignatureAlgorithm.rsa));
+
+        case KeyExchangeAlgorithm.DHE_DSS:
+        case KeyExchangeAlgorithm.DHE_DSS_EXPORT:
+        case KeyExchangeAlgorithm.SRP_DSS:
+            return sigAlgs.contains(Shorts.valueOf(SignatureAlgorithm.dsa));
+
+        case KeyExchangeAlgorithm.ECDHE_ECDSA:
+            return sigAlgs.contains(Shorts.valueOf(SignatureAlgorithm.ecdsa));
+
+        default:
+            return true;
+        }
+    }
+
     public static boolean isValidCipherSuiteForVersion(int cipherSuite, ProtocolVersion serverVersion)
     {
         return getMinimumVersion(cipherSuite).isEqualOrEarlierVersionOf(serverVersion.getEquivalentTLSVersion());
     }
+
+    public static Vector getUsableSignatureAlgorithms(Vector sigHashAlgs)
+    {
+        if (sigHashAlgs == null)
+        {
+            return getAllSignatureAlgorithms();
+        }
+
+        Vector v = new Vector(4);
+        v.addElement(Shorts.valueOf(SignatureAlgorithm.anonymous));
+        for (int i = 0; i < sigHashAlgs.size(); ++i)
+        {
+            SignatureAndHashAlgorithm sigHashAlg = (SignatureAndHashAlgorithm)sigHashAlgs.elementAt(i);
+//            if (sigHashAlg.getHash() >= MINIMUM_HASH_STRICT)
+            {
+                Short sigAlg = Shorts.valueOf(sigHashAlg.getSignature());
+                if (!v.contains(sigAlg))
+                {
+                    v.addElement(sigAlg);
+                }
+            }
+        }
+        return v;
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/AllTests.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/AllTests.java
index 97de4b8..9eb94b9 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/AllTests.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/AllTests.java
@@ -23,9 +23,11 @@
         suite.addTestSuite(DTLSProtocolTest.class);
         suite.addTestSuite(DTLSTestCase.class);
         suite.addTestSuite(TlsProtocolTest.class);
+        suite.addTestSuite(TlsProtocolNonBlockingTest.class);
         suite.addTestSuite(TlsPSKProtocolTest.class);
         suite.addTestSuite(TlsSRPProtocolTest.class);
         suite.addTestSuite(TlsTestCase.class);
+        suite.addTest(TlsTestSuite.suite());
 
         return new BCTestSetup(suite);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/HTTPSServerThread.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/HTTPSServerThread.java
index d55bc73..528da42 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/HTTPSServerThread.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/HTTPSServerThread.java
@@ -104,6 +104,7 @@
             sendResponse(sslSock.getOutputStream());
 
             sslSock.close();
+            sSock.close();
         }
         catch (Exception e)
         {
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsProtocolNonBlockingTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsProtocolNonBlockingTest.java
index 564bb74..5fc095c 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsProtocolNonBlockingTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsProtocolNonBlockingTest.java
@@ -52,6 +52,7 @@
         // close the connection
         clientProtocol.close();
         pumpData(clientProtocol, serverProtocol, fragment);
+        serverProtocol.closeInput();
         checkClosed(serverProtocol);
         checkClosed(clientProtocol);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsServerTest.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsServerTest.java
index e2faea7..27cf877 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsServerTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsServerTest.java
@@ -29,13 +29,20 @@
         int port = 5556;
 
         ServerSocket ss = new ServerSocket(port, 16, address);
-        while (true)
+        try
         {
-            Socket s = ss.accept();
-            System.out.println("--------------------------------------------------------------------------------");
-            System.out.println("Accepted " + s);
-            ServerThread t = new ServerThread(s);
-            t.start();
+            while (true)
+            {
+                Socket s = ss.accept();
+                System.out.println("--------------------------------------------------------------------------------");
+                System.out.println("Accepted " + s);
+                ServerThread t = new ServerThread(s);
+                t.start();
+            }
+        }
+        finally
+        {
+            ss.close();
         }
     }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsTestSuite.java b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsTestSuite.java
index 9a555df..c661db0 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsTestSuite.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/tls/test/TlsTestSuite.java
@@ -25,6 +25,7 @@
         TlsTestSuite testSuite = new TlsTestSuite();
 
         addFallbackTests(testSuite);
+        addVersionTests(testSuite, ProtocolVersion.SSLv3);
         addVersionTests(testSuite, ProtocolVersion.TLSv10);
         addVersionTests(testSuite, ProtocolVersion.TLSv11);
         addVersionTests(testSuite, ProtocolVersion.TLSv12);
@@ -196,10 +197,10 @@
     private static TlsTestConfig createTlsTestConfig(ProtocolVersion version)
     {
         TlsTestConfig c = new TlsTestConfig();
-        c.clientMinimumVersion = ProtocolVersion.TLSv10;
+        c.clientMinimumVersion = ProtocolVersion.SSLv3;
         c.clientOfferVersion = ProtocolVersion.TLSv12;
         c.serverMaximumVersion = version;
-        c.serverMinimumVersion = ProtocolVersion.TLSv10;
+        c.serverMinimumVersion = ProtocolVersion.SSLv3;
         return c;
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DH.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DH.java
index badbfd1..8512395 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DH.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DH.java
@@ -1,5 +1,8 @@
 package org.bouncycastle.jcajce.provider.asymmetric;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
 import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;
 import org.bouncycastle.jcajce.provider.asymmetric.dh.KeyFactorySpi;
@@ -10,6 +13,14 @@
 {
     private static final String PREFIX = "org.bouncycastle.jcajce.provider.asymmetric" + ".dh.";
 
+    private static final Map<String, String> generalDhAttributes = new HashMap<String, String>();
+
+    static
+    {
+        generalDhAttributes.put("SupportedKeyClasses", "javax.crypto.interfaces.DHPublicKey|javax.crypto.interfaces.DHPrivateKey");
+        generalDhAttributes.put("SupportedKeyFormats", "PKCS#8|X.509");
+    }
+
     public static class Mappings
         extends AsymmetricAlgorithmProvider
     {
@@ -22,6 +33,7 @@
             provider.addAlgorithm("KeyPairGenerator.DH", PREFIX + "KeyPairGeneratorSpi");
             provider.addAlgorithm("Alg.Alias.KeyPairGenerator.DIFFIEHELLMAN", "DH");
 
+            provider.addAttributes("KeyAgreement.DH", generalDhAttributes);
             provider.addAlgorithm("KeyAgreement.DH", PREFIX + "KeyAgreementSpi");
             provider.addAlgorithm("Alg.Alias.KeyAgreement.DIFFIEHELLMAN", "DH");
             provider.addAlgorithm("KeyAgreement", PKCSObjectIdentifiers.id_alg_ESDH, PREFIX + "KeyAgreementSpi$DHwithRFC2631KDF");
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DSA.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DSA.java
index 1bdc994..2164cb6 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DSA.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/DSA.java
@@ -79,7 +79,7 @@
                 provider.addAlgorithm("Alg.Alias.Signature." + DSAUtil.dsaOids[i], "DSA");
 
                 registerOid(provider, DSAUtil.dsaOids[i], "DSA", keyFact);
-                registerOidAlgorithmParameters(provider, DSAUtil.dsaOids[i], "DSA");
+                registerOidAlgorithmParameterGenerator(provider, DSAUtil.dsaOids[i], "DSA");
             }
         }
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/EC.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/EC.java
index 05bf010..174d9c8 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/EC.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/EC.java
@@ -1,5 +1,8 @@
 package org.bouncycastle.jcajce.provider.asymmetric;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import org.bouncycastle.asn1.bsi.BSIObjectIdentifiers;
 import org.bouncycastle.asn1.eac.EACObjectIdentifiers;
 import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
@@ -15,6 +18,14 @@
 {
     private static final String PREFIX = "org.bouncycastle.jcajce.provider.asymmetric" + ".ec.";
 
+    private static final Map<String, String> generalEcAttributes = new HashMap<String, String>();
+
+    static
+    {
+        generalEcAttributes.put("SupportedKeyClasses", "java.security.interfaces.ECPublicKey|java.security.interfaces.ECPrivateKey");
+        generalEcAttributes.put("SupportedKeyFormats", "PKCS#8|X.509");
+    }
+
     public static class Mappings
         extends AsymmetricAlgorithmProvider
     {
@@ -26,8 +37,11 @@
         {
             provider.addAlgorithm("AlgorithmParameters.EC", PREFIX + "AlgorithmParametersSpi");
 
+            provider.addAttributes("KeyAgreement.ECDH", generalEcAttributes);
             provider.addAlgorithm("KeyAgreement.ECDH", PREFIX + "KeyAgreementSpi$DH");
+            provider.addAttributes("KeyAgreement.ECDHC", generalEcAttributes);
             provider.addAlgorithm("KeyAgreement.ECDHC", PREFIX + "KeyAgreementSpi$DHC");
+            provider.addAttributes("KeyAgreement.ECCDH", generalEcAttributes);
             provider.addAlgorithm("KeyAgreement.ECCDH", PREFIX + "KeyAgreementSpi$DHC");
 
             provider.addAlgorithm("KeyAgreement." + X9ObjectIdentifiers.dhSinglePass_stdDH_sha1kdf_scheme, PREFIX + "KeyAgreementSpi$DHwithSHA1KDFAndSharedInfo");
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ElGamal.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ElGamal.java
index 8dfeed0..279e951 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ElGamal.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ElGamal.java
@@ -40,7 +40,7 @@
             AsymmetricKeyInfoConverter keyFact = new KeyFactorySpi();
 
             registerOid(provider, OIWObjectIdentifiers.elGamalAlgorithm, "ELGAMAL", keyFact);
-            registerOidAlgorithmParameters(provider, OIWObjectIdentifiers.elGamalAlgorithm, "ELGAMAL");
+            registerOidAlgorithmParameterGenerator(provider, OIWObjectIdentifiers.elGamalAlgorithm, "ELGAMAL");
         }
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GM.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GM.java
new file mode 100644
index 0000000..3192904
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GM.java
@@ -0,0 +1,35 @@
+package org.bouncycastle.jcajce.provider.asymmetric;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bouncycastle.asn1.gm.GMObjectIdentifiers;
+import org.bouncycastle.jcajce.provider.config.ConfigurableProvider;
+import org.bouncycastle.jcajce.provider.util.AsymmetricAlgorithmProvider;
+
+public class GM
+{
+    private static final String PREFIX = "org.bouncycastle.jcajce.provider.asymmetric" + ".ec.";
+
+    private static final Map<String, String> generalSm2Attributes = new HashMap<String, String>();
+
+    static
+    {
+        generalSm2Attributes.put("SupportedKeyClasses", "java.security.interfaces.ECPublicKey|java.security.interfaces.ECPrivateKey");
+        generalSm2Attributes.put("SupportedKeyFormats", "PKCS#8|X.509");
+    }
+
+    public static class Mappings
+        extends AsymmetricAlgorithmProvider
+    {
+        public Mappings()
+        {
+        }
+
+        public void configure(ConfigurableProvider provider)
+        {
+            provider.addAlgorithm("Signature.SM3WITHSM2", PREFIX + "GMSignatureSpi$sm3WithSM2");
+            provider.addAlgorithm("Alg.Alias.Signature." + GMObjectIdentifiers.sm2sign_with_sm3, "SM3WITHSM2");
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GOST.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GOST.java
index 39ab20d..30b6f2f 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GOST.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/GOST.java
@@ -31,7 +31,7 @@
             provider.addAlgorithm("AlgorithmParameterGenerator.GOST3410", PREFIX + "AlgorithmParameterGeneratorSpi");
 
             registerOid(provider, CryptoProObjectIdentifiers.gostR3410_94, "GOST3410", new KeyFactorySpi());
-            registerOidAlgorithmParameters(provider, CryptoProObjectIdentifiers.gostR3410_94, "GOST3410");
+            registerOidAlgorithmParameterGenerator(provider, CryptoProObjectIdentifiers.gostR3410_94, "GOST3410");
 
             provider.addAlgorithm("Signature.GOST3410", PREFIX + "SignatureSpi");
             provider.addAlgorithm("Alg.Alias.Signature.GOST-3410", "GOST3410");
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/RSA.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/RSA.java
index ebb483e..c32690a 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/RSA.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/RSA.java
@@ -1,5 +1,8 @@
 package org.bouncycastle.jcajce.provider.asymmetric;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
 import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
 import org.bouncycastle.asn1.oiw.OIWObjectIdentifiers;
@@ -15,6 +18,14 @@
 {
     private static final String PREFIX = "org.bouncycastle.jcajce.provider.asymmetric" + ".rsa.";
 
+    private static final Map<String, String> generalRsaAttributes = new HashMap<String, String>();
+
+    static
+    {
+        generalRsaAttributes.put("SupportedKeyClasses", "javax.crypto.interfaces.RSAPublicKey|javax.crypto.interfaces.RSAPrivateKey");
+        generalRsaAttributes.put("SupportedKeyFormats", "PKCS#8|X.509");
+    }
+
     public static class Mappings
         extends AsymmetricAlgorithmProvider
     {
@@ -49,6 +60,7 @@
             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.NONEWITHRSASSA-PSS", "PSS");
             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.NONEWITHRSAANDMGF1", "PSS");
 
+            provider.addAttributes("Cipher.RSA", generalRsaAttributes);
             provider.addAlgorithm("Cipher.RSA", PREFIX + "CipherSpi$NoPadding");
             provider.addAlgorithm("Cipher.RSA/RAW", PREFIX + "CipherSpi$NoPadding");
             provider.addAlgorithm("Cipher.RSA/PKCS1", PREFIX + "CipherSpi$PKCS1v1_5Padding");
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/AlgorithmParameterGeneratorSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/AlgorithmParameterGeneratorSpi.java
index e4c8172..bf6bfe7 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/AlgorithmParameterGeneratorSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/AlgorithmParameterGeneratorSpi.java
@@ -11,12 +11,13 @@
 import org.bouncycastle.crypto.generators.DHParametersGenerator;
 import org.bouncycastle.crypto.params.DHParameters;
 import org.bouncycastle.jcajce.provider.asymmetric.util.BaseAlgorithmParameterGeneratorSpi;
+import org.bouncycastle.jcajce.provider.asymmetric.util.PrimeCertaintyCalculator;
 
 public class AlgorithmParameterGeneratorSpi
     extends BaseAlgorithmParameterGeneratorSpi
 {
     protected SecureRandom random;
-    protected int strength = 1024;
+    protected int strength = 2048;
 
     private int l = 0;
 
@@ -48,13 +49,15 @@
     {
         DHParametersGenerator pGen = new DHParametersGenerator();
 
+        int certainty = PrimeCertaintyCalculator.getDefaultCertainty(strength);
+
         if (random != null)
         {
-            pGen.init(strength, 20, random);
+            pGen.init(strength, certainty, random);
         }
         else
         {
-            pGen.init(strength, 20, new SecureRandom());
+            pGen.init(strength, certainty, new SecureRandom());
         }
 
         DHParameters p = pGen.generateParameters();
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/IESCipher.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/IESCipher.java
index 6af56f5..02f7fe4 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/IESCipher.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/IESCipher.java
@@ -25,7 +25,6 @@
 import org.bouncycastle.crypto.InvalidCipherTextException;
 import org.bouncycastle.crypto.KeyEncoder;
 import org.bouncycastle.crypto.agreement.DHBasicAgreement;
-import org.bouncycastle.crypto.digests.SHA1Digest;
 import org.bouncycastle.crypto.engines.AESEngine;
 import org.bouncycastle.crypto.engines.DESedeEngine;
 import org.bouncycastle.crypto.engines.IESEngine;
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyAgreementSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyAgreementSpi.java
index b75b5e1..801a04a 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyAgreementSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyAgreementSpi.java
@@ -17,7 +17,6 @@
 
 import org.bouncycastle.crypto.DerivationFunction;
 import org.bouncycastle.crypto.agreement.kdf.DHKEKGenerator;
-import org.bouncycastle.crypto.digests.SHA1Digest;
 import org.bouncycastle.crypto.util.DigestFactory;
 import org.bouncycastle.jcajce.provider.asymmetric.util.BaseAgreementSpi;
 import org.bouncycastle.jcajce.spec.UserKeyingMaterialSpec;
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi.java
index 793f729..864bf56 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi.java
@@ -15,6 +15,7 @@
 import org.bouncycastle.crypto.params.DHParameters;
 import org.bouncycastle.crypto.params.DHPrivateKeyParameters;
 import org.bouncycastle.crypto.params.DHPublicKeyParameters;
+import org.bouncycastle.jcajce.provider.asymmetric.util.PrimeCertaintyCalculator;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
 import org.bouncycastle.util.Integers;
 
@@ -26,8 +27,7 @@
 
     DHKeyGenerationParameters param;
     DHBasicKeyPairGenerator engine = new DHBasicKeyPairGenerator();
-    int strength = 1024;
-    int certainty = 20;
+    int strength = 2048;
     SecureRandom random = new SecureRandom();
     boolean initialised = false;
 
@@ -95,7 +95,7 @@
 
                             DHParametersGenerator pGen = new DHParametersGenerator();
 
-                            pGen.init(strength, certainty, random);
+                            pGen.init(strength, PrimeCertaintyCalculator.getDefaultCertainty(strength), random);
 
                             param = new DHKeyGenerationParameters(random, pGen.generateParameters());
 
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/AlgorithmParameterGeneratorSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/AlgorithmParameterGeneratorSpi.java
index 2d7c4c5..9a79659 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/AlgorithmParameterGeneratorSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/AlgorithmParameterGeneratorSpi.java
@@ -12,12 +12,13 @@
 import org.bouncycastle.crypto.params.DSAParameterGenerationParameters;
 import org.bouncycastle.crypto.params.DSAParameters;
 import org.bouncycastle.jcajce.provider.asymmetric.util.BaseAlgorithmParameterGeneratorSpi;
+import org.bouncycastle.jcajce.provider.asymmetric.util.PrimeCertaintyCalculator;
 
 public class AlgorithmParameterGeneratorSpi
     extends BaseAlgorithmParameterGeneratorSpi
 {
     protected SecureRandom random;
-    protected int strength = 1024;
+    protected int strength = 2048;
     protected DSAParameterGenerationParameters params;
 
     protected void engineInit(
@@ -69,19 +70,21 @@
             random = new SecureRandom();
         }
 
+        int certainty = PrimeCertaintyCalculator.getDefaultCertainty(strength);
+
         if (strength == 1024)
         {
-            params = new DSAParameterGenerationParameters(1024, 160, 80, random);
+            params = new DSAParameterGenerationParameters(1024, 160, certainty, random);
             pGen.init(params);
         }
         else if (strength > 1024)
         {
-            params = new DSAParameterGenerationParameters(strength, 256, 80, random);
+            params = new DSAParameterGenerationParameters(strength, 256, certainty, random);
             pGen.init(params);
         }
         else
         {
-            pGen.init(strength, 20, random);
+            pGen.init(strength, certainty, random);
         }
 
         DSAParameters p = pGen.generateParameters();
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/DSASigner.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/DSASigner.java
index a9aeff5..0237978 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/DSASigner.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/DSASigner.java
@@ -21,7 +21,6 @@
 import org.bouncycastle.crypto.DSA;
 import org.bouncycastle.crypto.Digest;
 import org.bouncycastle.crypto.digests.NullDigest;
-import org.bouncycastle.crypto.digests.SHA1Digest;
 import org.bouncycastle.crypto.params.ParametersWithRandom;
 import org.bouncycastle.crypto.signers.HMacDSAKCalculator;
 import org.bouncycastle.crypto.util.DigestFactory;
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi.java
index bacbb6c..0c019e7 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi.java
@@ -17,6 +17,7 @@
 import org.bouncycastle.crypto.params.DSAParameters;
 import org.bouncycastle.crypto.params.DSAPrivateKeyParameters;
 import org.bouncycastle.crypto.params.DSAPublicKeyParameters;
+import org.bouncycastle.jcajce.provider.asymmetric.util.PrimeCertaintyCalculator;
 import org.bouncycastle.util.Integers;
 import org.bouncycastle.util.Properties;
 
@@ -28,8 +29,7 @@
 
     DSAKeyGenerationParameters param;
     DSAKeyPairGenerator engine = new DSAKeyPairGenerator();
-    int strength = 1024;
-    int certainty = 20;
+    int strength = 2048;
     SecureRandom random = new SecureRandom();
     boolean initialised = false;
 
@@ -94,6 +94,8 @@
                         DSAParametersGenerator pGen;
                         DSAParameterGenerationParameters dsaParams;
 
+                        int certainty = PrimeCertaintyCalculator.getDefaultCertainty(strength);
+
                         // Typical combination of keysize and size of q.
                         //     keysize = 1024, q's size = 160
                         //     keysize = 2048, q's size = 224
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/GMSignatureSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/GMSignatureSpi.java
new file mode 100644
index 0000000..3500de3
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/GMSignatureSpi.java
@@ -0,0 +1,172 @@
+package org.bouncycastle.jcajce.provider.asymmetric.ec;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.InvalidKeyException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Encoding;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.crypto.DSA;
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.crypto.digests.SM3Digest;
+import org.bouncycastle.crypto.params.ParametersWithRandom;
+import org.bouncycastle.crypto.signers.SM2Signer;
+import org.bouncycastle.jcajce.provider.asymmetric.util.DSABase;
+import org.bouncycastle.jcajce.provider.asymmetric.util.DSAEncoder;
+import org.bouncycastle.jcajce.provider.asymmetric.util.ECUtil;
+import org.bouncycastle.util.Arrays;
+
+public class GMSignatureSpi
+    extends DSABase
+{
+    GMSignatureSpi(Digest digest, DSA signer, DSAEncoder encoder)
+    {
+        super(digest, signer, encoder);
+    }
+
+    protected void engineInitVerify(PublicKey publicKey)
+        throws InvalidKeyException
+    {
+        CipherParameters param = ECUtils.generatePublicKeyParameter(publicKey);
+
+        digest.reset();
+        signer.init(false, param);
+    }
+
+    protected void engineInitSign(
+        PrivateKey privateKey)
+        throws InvalidKeyException
+    {
+        CipherParameters param = ECUtil.generatePrivateKeyParameter(privateKey);
+
+        digest.reset();
+
+        if (appRandom != null)
+        {
+            signer.init(true, new ParametersWithRandom(param, appRandom));
+        }
+        else
+        {
+            signer.init(true, param);
+        }
+    }
+
+    static public class sm3WithSM2
+        extends GMSignatureSpi
+    {
+        public sm3WithSM2()
+        {
+            super(new SM3Digest(), new SM2Signer(), new StdDSAEncoder());
+        }
+    }
+    
+    private static class StdDSAEncoder
+        implements DSAEncoder
+    {
+        public byte[] encode(
+            BigInteger r,
+            BigInteger s)
+            throws IOException
+        {
+            ASN1EncodableVector v = new ASN1EncodableVector();
+
+            v.add(new ASN1Integer(r));
+            v.add(new ASN1Integer(s));
+
+            return new DERSequence(v).getEncoded(ASN1Encoding.DER);
+        }
+
+        public BigInteger[] decode(
+            byte[] encoding)
+            throws IOException
+        {
+            ASN1Sequence s = (ASN1Sequence)ASN1Primitive.fromByteArray(encoding);
+            if (s.size() != 2)
+            {
+                throw new IOException("malformed signature");
+            }
+            if (!Arrays.areEqual(encoding, s.getEncoded(ASN1Encoding.DER)))
+            {
+                throw new IOException("malformed signature");
+            }
+
+            BigInteger[] sig = new BigInteger[2];
+
+
+            sig[0] = ASN1Integer.getInstance(s.getObjectAt(0)).getValue();
+            sig[1] = ASN1Integer.getInstance(s.getObjectAt(1)).getValue();
+
+            return sig;
+        }
+    }
+
+    private static class PlainDSAEncoder
+        implements DSAEncoder
+    {
+        public byte[] encode(
+            BigInteger r,
+            BigInteger s)
+            throws IOException
+        {
+            byte[] first = makeUnsigned(r);
+            byte[] second = makeUnsigned(s);
+            byte[] res;
+
+            if (first.length > second.length)
+            {
+                res = new byte[first.length * 2];
+            }
+            else
+            {
+                res = new byte[second.length * 2];
+            }
+
+            System.arraycopy(first, 0, res, res.length / 2 - first.length, first.length);
+            System.arraycopy(second, 0, res, res.length - second.length, second.length);
+
+            return res;
+        }
+
+
+        private byte[] makeUnsigned(BigInteger val)
+        {
+            byte[] res = val.toByteArray();
+
+            if (res[0] == 0)
+            {
+                byte[] tmp = new byte[res.length - 1];
+
+                System.arraycopy(res, 1, tmp, 0, tmp.length);
+
+                return tmp;
+            }
+
+            return res;
+        }
+
+        public BigInteger[] decode(
+            byte[] encoding)
+            throws IOException
+        {
+            BigInteger[] sig = new BigInteger[2];
+
+            byte[] first = new byte[encoding.length / 2];
+            byte[] second = new byte[encoding.length / 2];
+
+            System.arraycopy(encoding, 0, first, 0, first.length);
+            System.arraycopy(encoding, first.length, second, 0, second.length);
+
+            sig[0] = new BigInteger(1, first);
+            sig[1] = new BigInteger(1, second);
+
+            return sig;
+        }
+    }
+}
\ No newline at end of file
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/IESCipher.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/IESCipher.java
index f500350..6fdebc7 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/IESCipher.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/ec/IESCipher.java
@@ -23,7 +23,6 @@
 import org.bouncycastle.crypto.InvalidCipherTextException;
 import org.bouncycastle.crypto.KeyEncoder;
 import org.bouncycastle.crypto.agreement.ECDHBasicAgreement;
-import org.bouncycastle.crypto.digests.SHA1Digest;
 import org.bouncycastle.crypto.engines.AESEngine;
 import org.bouncycastle.crypto.engines.DESedeEngine;
 import org.bouncycastle.crypto.engines.IESEngine;
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/ISOSignatureSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/ISOSignatureSpi.java
index 550c5f6..8bad9f4 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/ISOSignatureSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/ISOSignatureSpi.java
@@ -12,14 +12,7 @@
 import org.bouncycastle.crypto.AsymmetricBlockCipher;
 import org.bouncycastle.crypto.CipherParameters;
 import org.bouncycastle.crypto.Digest;
-import org.bouncycastle.crypto.digests.MD5Digest;
 import org.bouncycastle.crypto.digests.RIPEMD160Digest;
-import org.bouncycastle.crypto.digests.SHA1Digest;
-import org.bouncycastle.crypto.digests.SHA224Digest;
-import org.bouncycastle.crypto.digests.SHA256Digest;
-import org.bouncycastle.crypto.digests.SHA384Digest;
-import org.bouncycastle.crypto.digests.SHA512Digest;
-import org.bouncycastle.crypto.digests.SHA512tDigest;
 import org.bouncycastle.crypto.digests.WhirlpoolDigest;
 import org.bouncycastle.crypto.engines.RSABlindedEngine;
 import org.bouncycastle.crypto.signers.ISO9796d2Signer;
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi.java
index f779a66..4159241 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi.java
@@ -12,6 +12,7 @@
 import org.bouncycastle.crypto.params.RSAKeyGenerationParameters;
 import org.bouncycastle.crypto.params.RSAKeyParameters;
 import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters;
+import org.bouncycastle.jcajce.provider.asymmetric.util.PrimeCertaintyCalculator;
 
 public class KeyPairGeneratorSpi
     extends java.security.KeyPairGenerator
@@ -23,7 +24,6 @@
     }
 
     final static BigInteger defaultPublicExponent = BigInteger.valueOf(0x10001);
-    final static int defaultTests = 112;
 
     RSAKeyGenerationParameters param;
     RSAKeyPairGenerator engine;
@@ -34,7 +34,7 @@
 
         engine = new RSAKeyPairGenerator();
         param = new RSAKeyGenerationParameters(defaultPublicExponent,
-            new SecureRandom(), 2048, defaultTests);
+            new SecureRandom(), 2048, PrimeCertaintyCalculator.getDefaultCertainty(2048));
         engine.init(param);
     }
 
@@ -43,7 +43,7 @@
         SecureRandom random)
     {
         param = new RSAKeyGenerationParameters(defaultPublicExponent,
-            random, strength, defaultTests);
+            random, strength, PrimeCertaintyCalculator.getDefaultCertainty(strength));
 
         engine.init(param);
     }
@@ -61,7 +61,7 @@
 
         param = new RSAKeyGenerationParameters(
             rsaParams.getPublicExponent(),
-            random, rsaParams.getKeysize(), defaultTests);
+            random, rsaParams.getKeysize(), PrimeCertaintyCalculator.getDefaultCertainty(2048));
 
         engine.init(param);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/ECUtil.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/ECUtil.java
index 7542dba..d4d9138 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/ECUtil.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/ECUtil.java
@@ -10,6 +10,7 @@
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
 import org.bouncycastle.asn1.anssi.ANSSINamedCurves;
 import org.bouncycastle.asn1.cryptopro.ECGOST3410NamedCurves;
+import org.bouncycastle.asn1.gm.GMNamedCurves;
 import org.bouncycastle.asn1.nist.NISTNamedCurves;
 import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
 import org.bouncycastle.asn1.sec.SECNamedCurves;
@@ -345,6 +346,10 @@
             {
                 oid = ANSSINamedCurves.getOID(name);
             }
+            if (oid == null)
+            {
+                oid = GMNamedCurves.getOID(name);
+            }
         }
 
         return oid;
@@ -391,6 +396,10 @@
             {
                 params = TeleTrusTNamedCurves.getByOID(oid);
             }
+            if (params == null)
+            {
+                params = GMNamedCurves.getByOID(oid);
+            }
         }
 
         return params;
@@ -416,6 +425,10 @@
             {
                 params = TeleTrusTNamedCurves.getByName(curveName);
             }
+            if (params == null)
+            {
+                params = GMNamedCurves.getByName(curveName);
+            }
         }
 
         return params;
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/PrimeCertaintyCalculator.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/PrimeCertaintyCalculator.java
new file mode 100644
index 0000000..92431ef
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/util/PrimeCertaintyCalculator.java
@@ -0,0 +1,21 @@
+package org.bouncycastle.jcajce.provider.asymmetric.util;
+
+public class PrimeCertaintyCalculator
+{
+    private PrimeCertaintyCalculator()
+    {
+
+    }
+
+    /**
+     * Return the current wisdom on prime certainty requirements.
+     *
+     * @param keySizeInBits size of the key being generated.
+     * @return a certainty value.
+     */
+    public static int getDefaultCertainty(int keySizeInBits)
+    {
+        // Based on FIPS 186-4 Table C.1
+        return keySizeInBits <= 1024 ? 80 : (96 + 16 * ((keySizeInBits - 1) / 1024));
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/CertificateFactory.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/CertificateFactory.java
index 9bd1bf0..7765c27 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/CertificateFactory.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/CertificateFactory.java
@@ -4,7 +4,6 @@
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.PushbackInputStream;
 import java.security.cert.CRL;
 import java.security.cert.CRLException;
 import java.security.cert.CertPath;
@@ -44,6 +43,7 @@
 
     private static final PEMUtil PEM_CERT_PARSER = new PEMUtil("CERTIFICATE");
     private static final PEMUtil PEM_CRL_PARSER = new PEMUtil("CRL");
+    private static final PEMUtil PEM_PKCS7_PARSER = new PEMUtil("PKCS7");
 
     private ASN1Set sData = null;
     private int                sDataObjectCount = 0;
@@ -57,8 +57,24 @@
         ASN1InputStream dIn)
         throws IOException, CertificateParsingException
     {
-        ASN1Sequence seq = (ASN1Sequence)dIn.readObject();
+        return getCertificate(ASN1Sequence.getInstance(dIn.readObject()));
+    }
 
+    private java.security.cert.Certificate readPEMCertificate(
+        InputStream in)
+        throws IOException, CertificateParsingException
+    {
+        return getCertificate(PEM_CERT_PARSER.readPEMObject(in));
+    }
+
+    private java.security.cert.Certificate getCertificate(ASN1Sequence seq)
+        throws CertificateParsingException
+    {
+        if (seq == null)
+        {
+            return null;
+        }
+        
         if (seq.size() > 1
                 && seq.getObjectAt(0) instanceof ASN1ObjectIdentifier)
         {
@@ -95,23 +111,9 @@
         return null;
     }
 
-    private java.security.cert.Certificate readPEMCertificate(
-        InputStream in)
-        throws IOException, CertificateParsingException
-    {
-        ASN1Sequence seq = PEM_CERT_PARSER.readPEMObject(in);
-
-        if (seq != null)
-        {
-            return new X509CertificateObject(bcHelper,
-                            Certificate.getInstance(seq));
-        }
-
-        return null;
-    }
 
     protected CRL createCRL(CertificateList c)
-    throws CRLException
+        throws CRLException
     {
         return new X509CRLObject(bcHelper, c);
     }
@@ -120,23 +122,24 @@
         InputStream in)
         throws IOException, CRLException
     {
-        ASN1Sequence seq = PEM_CRL_PARSER.readPEMObject(in);
-
-        if (seq != null)
-        {
-            return createCRL(
-                            CertificateList.getInstance(seq));
-        }
-
-        return null;
+        return getCRL(PEM_CRL_PARSER.readPEMObject(in));
     }
 
     private CRL readDERCRL(
         ASN1InputStream aIn)
         throws IOException, CRLException
     {
-        ASN1Sequence seq = (ASN1Sequence)aIn.readObject();
+        return getCRL(ASN1Sequence.getInstance(aIn.readObject()));
+    }
 
+    private CRL getCRL(ASN1Sequence seq)
+        throws CRLException
+    {
+        if (seq == null)
+        {
+            return null;
+        }
+        
         if (seq.size() > 1
                 && seq.getObjectAt(0) instanceof ASN1ObjectIdentifier)
         {
@@ -144,7 +147,7 @@
             {
                 sCrlData = SignedData.getInstance(ASN1Sequence.getInstance(
                     (ASN1TaggedObject)seq.getObjectAt(1), true)).getCRLs();
-    
+
                 return getCRL();
             }
         }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/PEMUtil.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/PEMUtil.java
index 3efd2d6..7badbdc 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/PEMUtil.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/x509/PEMUtil.java
@@ -10,16 +10,20 @@
 {
     private final String _header1;
     private final String _header2;
+    private final String _header3;
     private final String _footer1;
     private final String _footer2;
+    private final String _footer3;
 
     PEMUtil(
         String type)
     {
         _header1 = "-----BEGIN " + type + "-----";
         _header2 = "-----BEGIN X509 " + type + "-----";
+        _header3 = "-----BEGIN PKCS7-----";
         _footer1 = "-----END " + type + "-----";
         _footer2 = "-----END X509 " + type + "-----";
+        _footer3 = "-----END PKCS7-----";
     }
 
     private String readLine(
@@ -71,7 +75,7 @@
 
         while ((line = readLine(in)) != null)
         {
-            if (line.startsWith(_header1) || line.startsWith(_header2))
+            if (line.startsWith(_header1) || line.startsWith(_header2) || line.startsWith(_header3))
             {
                 break;
             }
@@ -79,7 +83,7 @@
 
         while ((line = readLine(in)) != null)
         {
-            if (line.startsWith(_footer1) || line.startsWith(_footer2))
+            if (line.startsWith(_footer1) || line.startsWith(_footer2) || line.startsWith(_footer3))
             {
                 break;
             }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/config/ConfigurableProvider.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/config/ConfigurableProvider.java
index 0865b57..768df66 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/config/ConfigurableProvider.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/config/ConfigurableProvider.java
@@ -1,5 +1,7 @@
 package org.bouncycastle.jcajce.provider.config;
 
+import java.util.Map;
+
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
 import org.bouncycastle.jcajce.provider.util.AsymmetricKeyInfoConverter;
 
@@ -48,4 +50,6 @@
     boolean hasAlgorithm(String type, String name);
 
     void addKeyInfoConverter(ASN1ObjectIdentifier oid, AsymmetricKeyInfoConverter keyInfoConverter);
+
+    void addAttributes(String key, Map<String, String> attributeMap);
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/drbg/DRBG.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/drbg/DRBG.java
index b33c305..d48c401 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/drbg/DRBG.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/drbg/DRBG.java
@@ -5,10 +5,15 @@
 import java.security.Provider;
 import java.security.SecureRandom;
 import java.security.SecureRandomSpi;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 
 import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.crypto.macs.HMac;
 import org.bouncycastle.crypto.prng.EntropySource;
 import org.bouncycastle.crypto.prng.EntropySourceProvider;
+import org.bouncycastle.crypto.prng.SP800SecureRandom;
 import org.bouncycastle.crypto.prng.SP800SecureRandomBuilder;
 import org.bouncycastle.jcajce.provider.config.ConfigurableProvider;
 import org.bouncycastle.jcajce.provider.util.AsymmetricAlgorithmProvider;
@@ -108,15 +113,22 @@
 
             EntropySource initSource = entropyProvider.get(16 * 8);
 
+            byte[] personalisationString = isPredictionResistant ? generateDefaultPersonalizationString(initSource.getEntropy())
+                                                                 : generateNonceIVPersonalizationString(initSource.getEntropy());
+
             return new SP800SecureRandomBuilder(entropyProvider)
-                                .setPersonalizationString(generateDefaultPersonalizationString(initSource.getEntropy()))
+                                .setPersonalizationString(personalisationString)
                                 .buildHash(new SHA512Digest(), Arrays.concatenate(initSource.getEntropy(), initSource.getEntropy()), isPredictionResistant);
         }
         else
         {
-            SecureRandom randomSource = createInitialEntropySource();   // needs to be done late, can't use static
+            SecureRandom randomSource = new HybridSecureRandom();   // needs to be done late, can't use static
+
+            byte[] personalisationString = isPredictionResistant ? generateDefaultPersonalizationString(randomSource.generateSeed(16))
+                                                                 : generateNonceIVPersonalizationString(randomSource.generateSeed(16));
+
             return new SP800SecureRandomBuilder(randomSource, true)
-                .setPersonalizationString(generateDefaultPersonalizationString(randomSource.generateSeed(16)))
+                .setPersonalizationString(personalisationString)
                 .buildHash(new SHA512Digest(), randomSource.generateSeed(32), isPredictionResistant);
         }
     }
@@ -196,4 +208,106 @@
         return Arrays.concatenate(Strings.toByteArray("Nonce"), seed,
             Pack.longToLittleEndian(Thread.currentThread().getId()), Pack.longToLittleEndian(System.currentTimeMillis()));
     }
+
+    private static class HybridSecureRandom
+        extends SecureRandom
+    {
+        private final AtomicBoolean seedAvailable = new AtomicBoolean(false);
+        private final AtomicInteger samples = new AtomicInteger(0);
+        private final SecureRandom baseRandom = createInitialEntropySource();
+        private final SP800SecureRandom drbg;
+
+        HybridSecureRandom()
+        {
+            drbg = new SP800SecureRandomBuilder(new EntropySourceProvider()
+                {
+                    public EntropySource get(final int bitsRequired)
+                    {
+                        return new SignallingEntropySource(bitsRequired);
+                    }
+                })
+                .setPersonalizationString(Strings.toByteArray("Bouncy Castle Hybrid Entropy Source"))
+                .buildHMAC(new HMac(new SHA512Digest()), baseRandom.generateSeed(32), false);     // 32 byte nonce
+        }
+
+        public byte[] generateSeed(int numBytes)
+        {
+            byte[] data = new byte[numBytes];
+
+            // after 20 samples we'll start to check if there is new seed material.
+            if (samples.getAndIncrement() > 20)
+            {
+                if (seedAvailable.getAndSet(false))
+                {
+                    samples.set(0);
+                    drbg.reseed(null);
+                }
+            }
+
+            drbg.nextBytes(data);
+
+            return data;
+        }
+
+        private class SignallingEntropySource
+            implements EntropySource
+        {
+            private final int byteLength;
+            private final AtomicReference entropy = new AtomicReference();
+            private final AtomicBoolean scheduled = new AtomicBoolean(false);
+
+            SignallingEntropySource(int bitsRequired)
+            {
+                this.byteLength = (bitsRequired + 7) / 8;
+            }
+
+            public boolean isPredictionResistant()
+            {
+                return true;
+            }
+
+            public byte[] getEntropy()
+            {
+                byte[] seed = (byte[])entropy.getAndSet(null);
+
+                if (seed == null || seed.length != byteLength)
+                {
+                    seed = baseRandom.generateSeed(byteLength);
+                }
+                else
+                {
+                    scheduled.set(false);
+                }
+
+                if (!scheduled.getAndSet(true))
+                {
+                    new Thread(new EntropyGatherer(byteLength)).start();
+                }
+
+                return seed;
+            }
+
+            public int entropySize()
+            {
+                return byteLength * 8;
+            }
+
+            private class EntropyGatherer
+                implements Runnable
+            {
+                private final int numBytes;
+
+                EntropyGatherer(int numBytes)
+                {
+                    this.numBytes = numBytes;
+                }
+
+                public void run()
+                {
+                    entropy.set(baseRandom.generateSeed(numBytes));
+                    seedAvailable.set(true);
+                }
+            }
+        }
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/AES.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/AES.java
index 1c13146..09da054 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/AES.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/AES.java
@@ -6,6 +6,8 @@
 import java.security.SecureRandom;
 import java.security.spec.AlgorithmParameterSpec;
 import java.security.spec.InvalidParameterSpecException;
+import java.util.HashMap;
+import java.util.Map;
 
 import javax.crypto.spec.IvParameterSpec;
 
@@ -22,6 +24,7 @@
 import org.bouncycastle.crypto.Mac;
 import org.bouncycastle.crypto.engines.AESEngine;
 import org.bouncycastle.crypto.engines.AESWrapEngine;
+import org.bouncycastle.crypto.engines.AESWrapPadEngine;
 import org.bouncycastle.crypto.engines.RFC3211WrapEngine;
 import org.bouncycastle.crypto.engines.RFC5649WrapEngine;
 import org.bouncycastle.crypto.generators.Poly1305KeyGenerator;
@@ -49,6 +52,14 @@
 {
     private static final Class gcmSpecClass = lookup("javax.crypto.spec.GCMParameterSpec");
 
+    private static final Map<String, String> generalAesAttributes = new HashMap<String, String>();
+
+    static
+    {
+        generalAesAttributes.put("SupportedKeyClasses", "javax.crypto.SecretKey");
+        generalAesAttributes.put("SupportedKeyFormats", "RAW");
+    }
+
     private AES()
     {
     }
@@ -232,6 +243,15 @@
         }
     }
 
+    public static class WrapPad
+        extends BaseWrapCipher
+    {
+        public WrapPad()
+        {
+            super(new AESWrapPadEngine());
+        }
+    }
+
     public static class RFC3211Wrap
         extends BaseWrapCipher
     {
@@ -812,6 +832,7 @@
             provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NISTObjectIdentifiers.id_aes192_CBC, "AES");
             provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NISTObjectIdentifiers.id_aes256_CBC, "AES");
 
+            provider.addAttributes("Cipher.AES", generalAesAttributes);
             provider.addAlgorithm("Cipher.AES", PREFIX + "$ECB");
             provider.addAlgorithm("Alg.Alias.Cipher." + wrongAES128, "AES");
             provider.addAlgorithm("Alg.Alias.Cipher." + wrongAES192, "AES");
@@ -828,12 +849,21 @@
             provider.addAlgorithm("Cipher", NISTObjectIdentifiers.id_aes128_CFB, PREFIX + "$CFB");
             provider.addAlgorithm("Cipher", NISTObjectIdentifiers.id_aes192_CFB, PREFIX + "$CFB");
             provider.addAlgorithm("Cipher", NISTObjectIdentifiers.id_aes256_CFB, PREFIX + "$CFB");
+
+            provider.addAttributes("Cipher.AESWRAP", generalAesAttributes);
             provider.addAlgorithm("Cipher.AESWRAP", PREFIX + "$Wrap");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes128_wrap, "AESWRAP");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes192_wrap, "AESWRAP");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes256_wrap, "AESWRAP");
             provider.addAlgorithm("Alg.Alias.Cipher.AESKW", "AESWRAP");
 
+            provider.addAttributes("Cipher.AESWRAPPAD", generalAesAttributes);
+            provider.addAlgorithm("Cipher.AESWRAPPAD", PREFIX + "$WrapPad");
+            provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes128_wrap_pad, "AESWRAPPAD");
+            provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes192_wrap_pad, "AESWRAPPAD");
+            provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes256_wrap_pad, "AESWRAPPAD");
+            provider.addAlgorithm("Alg.Alias.Cipher.AESKWP", "AESWRAPPAD");
+
             provider.addAlgorithm("Cipher.AESRFC3211WRAP", PREFIX + "$RFC3211Wrap");
             provider.addAlgorithm("Cipher.AESRFC5649WRAP", PREFIX + "$RFC5649Wrap");
 
@@ -842,6 +872,7 @@
             provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NISTObjectIdentifiers.id_aes192_CCM, "CCM");
             provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NISTObjectIdentifiers.id_aes256_CCM, "CCM");
 
+            provider.addAttributes("Cipher.CCM", generalAesAttributes);
             provider.addAlgorithm("Cipher.CCM", PREFIX + "$CCM");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes128_CCM, "CCM");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes192_CCM, "CCM");
@@ -852,6 +883,7 @@
             provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NISTObjectIdentifiers.id_aes192_GCM, "GCM");
             provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NISTObjectIdentifiers.id_aes256_GCM, "GCM");
 
+            provider.addAttributes("Cipher.GCM", generalAesAttributes);
             provider.addAlgorithm("Cipher.GCM", PREFIX + "$GCM");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes128_GCM, "GCM");
             provider.addAlgorithm("Alg.Alias.Cipher", NISTObjectIdentifiers.id_aes192_GCM, "GCM");
@@ -883,6 +915,10 @@
             provider.addAlgorithm("KeyGenerator", NISTObjectIdentifiers.id_aes128_CCM, PREFIX + "$KeyGen128");
             provider.addAlgorithm("KeyGenerator", NISTObjectIdentifiers.id_aes192_CCM, PREFIX + "$KeyGen192");
             provider.addAlgorithm("KeyGenerator", NISTObjectIdentifiers.id_aes256_CCM, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator.AESWRAPPAD", PREFIX + "$KeyGen");
+            provider.addAlgorithm("KeyGenerator", NISTObjectIdentifiers.id_aes128_wrap_pad, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NISTObjectIdentifiers.id_aes192_wrap_pad, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NISTObjectIdentifiers.id_aes256_wrap_pad, PREFIX + "$KeyGen256");
 
             provider.addAlgorithm("Mac.AESCMAC", PREFIX + "$AESCMAC");
 
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/ARIA.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/ARIA.java
new file mode 100644
index 0000000..819a832
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/ARIA.java
@@ -0,0 +1,508 @@
+package org.bouncycastle.jcajce.provider.symmetric;
+
+import java.io.IOException;
+import java.security.AlgorithmParameters;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.SecureRandom;
+import java.security.spec.AlgorithmParameterSpec;
+import java.security.spec.InvalidParameterSpecException;
+
+import javax.crypto.spec.IvParameterSpec;
+
+import org.bouncycastle.asn1.cms.CCMParameters;
+import org.bouncycastle.asn1.cms.GCMParameters;
+import org.bouncycastle.asn1.nsri.NSRIObjectIdentifiers;
+import org.bouncycastle.crypto.BlockCipher;
+import org.bouncycastle.crypto.BufferedBlockCipher;
+import org.bouncycastle.crypto.CipherKeyGenerator;
+import org.bouncycastle.crypto.engines.ARIAEngine;
+import org.bouncycastle.crypto.engines.ARIAWrapEngine;
+import org.bouncycastle.crypto.engines.ARIAWrapPadEngine;
+import org.bouncycastle.crypto.engines.RFC3211WrapEngine;
+import org.bouncycastle.crypto.generators.Poly1305KeyGenerator;
+import org.bouncycastle.crypto.macs.GMac;
+import org.bouncycastle.crypto.modes.CBCBlockCipher;
+import org.bouncycastle.crypto.modes.CFBBlockCipher;
+import org.bouncycastle.crypto.modes.GCMBlockCipher;
+import org.bouncycastle.crypto.modes.OFBBlockCipher;
+import org.bouncycastle.jcajce.provider.config.ConfigurableProvider;
+import org.bouncycastle.jcajce.provider.symmetric.util.BaseAlgorithmParameterGenerator;
+import org.bouncycastle.jcajce.provider.symmetric.util.BaseAlgorithmParameters;
+import org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher;
+import org.bouncycastle.jcajce.provider.symmetric.util.BaseKeyGenerator;
+import org.bouncycastle.jcajce.provider.symmetric.util.BaseMac;
+import org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher;
+import org.bouncycastle.jcajce.provider.symmetric.util.BlockCipherProvider;
+import org.bouncycastle.jcajce.provider.symmetric.util.IvAlgorithmParameters;
+import org.bouncycastle.jcajce.spec.AEADParameterSpec;
+
+public final class ARIA
+{
+    private ARIA()
+    {
+    }
+    
+    public static class ECB
+        extends BaseBlockCipher
+    {
+        public ECB()
+        {
+            super(new BlockCipherProvider()
+            {
+                public BlockCipher get()
+                {
+                    return new ARIAEngine();
+                }
+            });
+        }
+    }
+
+    public static class CBC
+       extends BaseBlockCipher
+    {
+        public CBC()
+        {
+            super(new CBCBlockCipher(new ARIAEngine()), 128);
+        }
+    }
+
+    static public class CFB
+        extends BaseBlockCipher
+    {
+        public CFB()
+        {
+            super(new BufferedBlockCipher(new CFBBlockCipher(new ARIAEngine(), 128)), 128);
+        }
+    }
+
+    static public class OFB
+        extends BaseBlockCipher
+    {
+        public OFB()
+        {
+            super(new BufferedBlockCipher(new OFBBlockCipher(new ARIAEngine(), 128)), 128);
+        }
+    }
+
+    public static class Wrap
+        extends BaseWrapCipher
+    {
+        public Wrap()
+        {
+            super(new ARIAWrapEngine());
+        }
+    }
+
+    public static class WrapPad
+        extends BaseWrapCipher
+    {
+        public WrapPad()
+        {
+            super(new ARIAWrapPadEngine());
+        }
+    }
+    
+    public static class RFC3211Wrap
+        extends BaseWrapCipher
+    {
+        public RFC3211Wrap()
+        {
+            super(new RFC3211WrapEngine(new ARIAEngine()), 16);
+        }
+    }
+
+    public static class GMAC
+        extends BaseMac
+    {
+        public GMAC()
+        {
+            super(new GMac(new GCMBlockCipher(new ARIAEngine())));
+        }
+    }
+
+    public static class Poly1305
+        extends BaseMac
+    {
+        public Poly1305()
+        {
+            super(new org.bouncycastle.crypto.macs.Poly1305(new ARIAEngine()));
+        }
+    }
+
+    public static class Poly1305KeyGen
+        extends BaseKeyGenerator
+    {
+        public Poly1305KeyGen()
+        {
+            super("Poly1305-ARIA", 256, new Poly1305KeyGenerator());
+        }
+    }
+
+    public static class KeyGen
+        extends BaseKeyGenerator
+    {
+        public KeyGen()
+        {
+            this(256);
+        }
+
+        public KeyGen(int keySize)
+        {
+            super("ARIA", keySize, new CipherKeyGenerator());
+        }
+    }
+
+    public static class KeyGen128
+        extends KeyGen
+    {
+        public KeyGen128()
+        {
+            super(128);
+        }
+    }
+
+    public static class KeyGen192
+        extends KeyGen
+    {
+        public KeyGen192()
+        {
+            super(192);
+        }
+    }
+
+    public static class KeyGen256
+        extends KeyGen
+    {
+        public KeyGen256()
+        {
+            super(256);
+        }
+    }
+
+    public static class AlgParamGen
+        extends BaseAlgorithmParameterGenerator
+    {
+        protected void engineInit(
+            AlgorithmParameterSpec genParamSpec,
+            SecureRandom random)
+            throws InvalidAlgorithmParameterException
+        {
+            throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for ARIA parameter generation.");
+        }
+
+        protected AlgorithmParameters engineGenerateParameters()
+        {
+            byte[] iv = new byte[16];
+
+            if (random == null)
+            {
+                random = new SecureRandom();
+            }
+
+            random.nextBytes(iv);
+
+            AlgorithmParameters params;
+
+            try
+            {
+                params = createParametersInstance("ARIA");
+                params.init(new IvParameterSpec(iv));
+            }
+            catch (Exception e)
+            {
+                throw new RuntimeException(e.getMessage());
+            }
+
+            return params;
+        }
+    }
+
+    public static class AlgParams
+        extends IvAlgorithmParameters
+    {
+        protected String engineToString()
+        {
+            return "ARIA IV";
+        }
+    }
+
+    public static class AlgParamsGCM
+        extends BaseAlgorithmParameters
+    {
+        private GCMParameters gcmParams;
+
+        protected void engineInit(AlgorithmParameterSpec paramSpec)
+            throws InvalidParameterSpecException
+        {
+            if (GcmSpecUtil.isGcmSpec(paramSpec))
+            {
+                gcmParams = GcmSpecUtil.extractGcmParameters(paramSpec);
+            }
+            else if (paramSpec instanceof AEADParameterSpec)
+            {
+                gcmParams = new GCMParameters(((AEADParameterSpec)paramSpec).getNonce(), ((AEADParameterSpec)paramSpec).getMacSizeInBits() / 8);
+            }
+            else
+            {
+                throw new InvalidParameterSpecException("AlgorithmParameterSpec class not recognized: " + paramSpec.getClass().getName());
+            }
+        }
+
+        protected void engineInit(byte[] params)
+            throws IOException
+        {
+            gcmParams = GCMParameters.getInstance(params);
+        }
+
+        protected void engineInit(byte[] params, String format)
+            throws IOException
+        {
+            if (!isASN1FormatString(format))
+            {
+                throw new IOException("unknown format specified");
+            }
+
+            gcmParams = GCMParameters.getInstance(params);
+        }
+
+        protected byte[] engineGetEncoded()
+            throws IOException
+        {
+            return gcmParams.getEncoded();
+        }
+
+        protected byte[] engineGetEncoded(String format)
+            throws IOException
+        {
+            if (!isASN1FormatString(format))
+            {
+                throw new IOException("unknown format specified");
+            }
+
+            return gcmParams.getEncoded();
+        }
+
+        protected String engineToString()
+        {
+            return "GCM";
+        }
+
+        protected AlgorithmParameterSpec localEngineGetParameterSpec(Class paramSpec)
+            throws InvalidParameterSpecException
+        {
+            if (paramSpec == AlgorithmParameterSpec.class || GcmSpecUtil.isGcmSpec(paramSpec))
+            {
+                if (GcmSpecUtil.gcmSpecExists())
+                {
+                    return GcmSpecUtil.extractGcmSpec(gcmParams.toASN1Primitive());
+                }
+                return new AEADParameterSpec(gcmParams.getNonce(), gcmParams.getIcvLen() * 8);
+            }
+            if (paramSpec == AEADParameterSpec.class)
+            {
+                return new AEADParameterSpec(gcmParams.getNonce(), gcmParams.getIcvLen() * 8);
+            }
+            if (paramSpec == IvParameterSpec.class)
+            {
+                return new IvParameterSpec(gcmParams.getNonce());
+            }
+
+            throw new InvalidParameterSpecException("AlgorithmParameterSpec not recognized: " + paramSpec.getName());
+        }
+    }
+
+    public static class AlgParamsCCM
+        extends BaseAlgorithmParameters
+    {
+        private CCMParameters ccmParams;
+
+        protected void engineInit(AlgorithmParameterSpec paramSpec)
+            throws InvalidParameterSpecException
+        {
+            if (GcmSpecUtil.isGcmSpec(paramSpec))
+            {
+                ccmParams = CCMParameters.getInstance(GcmSpecUtil.extractGcmParameters(paramSpec));
+            }
+            else if (paramSpec instanceof AEADParameterSpec)
+            {
+                ccmParams = new CCMParameters(((AEADParameterSpec)paramSpec).getNonce(), ((AEADParameterSpec)paramSpec).getMacSizeInBits() / 8);
+            }
+            else
+            {
+                throw new InvalidParameterSpecException("AlgorithmParameterSpec class not recognized: " + paramSpec.getClass().getName());
+            }
+        }
+
+        protected void engineInit(byte[] params)
+            throws IOException
+        {
+            ccmParams = CCMParameters.getInstance(params);
+        }
+
+        protected void engineInit(byte[] params, String format)
+            throws IOException
+        {
+            if (!isASN1FormatString(format))
+            {
+                throw new IOException("unknown format specified");
+            }
+
+            ccmParams = CCMParameters.getInstance(params);
+        }
+
+        protected byte[] engineGetEncoded()
+            throws IOException
+        {
+            return ccmParams.getEncoded();
+        }
+
+        protected byte[] engineGetEncoded(String format)
+            throws IOException
+        {
+            if (!isASN1FormatString(format))
+            {
+                throw new IOException("unknown format specified");
+            }
+
+            return ccmParams.getEncoded();
+        }
+
+        protected String engineToString()
+        {
+            return "CCM";
+        }
+
+        protected AlgorithmParameterSpec localEngineGetParameterSpec(Class paramSpec)
+            throws InvalidParameterSpecException
+        {
+            if (paramSpec == AlgorithmParameterSpec.class || GcmSpecUtil.isGcmSpec(paramSpec))
+            {
+                if (GcmSpecUtil.gcmSpecExists())
+                {
+                    return GcmSpecUtil.extractGcmSpec(ccmParams.toASN1Primitive());
+                }
+                return new AEADParameterSpec(ccmParams.getNonce(), ccmParams.getIcvLen() * 8);
+            }
+            if (paramSpec == AEADParameterSpec.class)
+            {
+                return new AEADParameterSpec(ccmParams.getNonce(), ccmParams.getIcvLen() * 8);
+            }
+            if (paramSpec == IvParameterSpec.class)
+            {
+                return new IvParameterSpec(ccmParams.getNonce());
+            }
+
+            throw new InvalidParameterSpecException("AlgorithmParameterSpec not recognized: " + paramSpec.getName());
+        }
+    }
+    
+    public static class Mappings
+        extends SymmetricAlgorithmProvider
+    {
+        private static final String PREFIX = ARIA.class.getName();
+
+        public Mappings()
+        {
+        }
+
+        public void configure(ConfigurableProvider provider)
+        {
+            provider.addAlgorithm("AlgorithmParameters.ARIA", PREFIX + "$AlgParams");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameters", NSRIObjectIdentifiers.id_aria128_cbc, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameters", NSRIObjectIdentifiers.id_aria192_cbc, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameters", NSRIObjectIdentifiers.id_aria256_cbc, "ARIA");
+
+            provider.addAlgorithm("AlgorithmParameterGenerator.ARIA", PREFIX + "$AlgParamGen");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria128_cbc, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria192_cbc, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria256_cbc, "ARIA");
+
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria128_ofb, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria192_ofb, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria256_ofb, "ARIA");
+
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria128_cfb, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria192_cfb, "ARIA");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator", NSRIObjectIdentifiers.id_aria256_cfb, "ARIA");
+
+
+            provider.addAlgorithm("Cipher.ARIA", PREFIX + "$ECB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria128_ecb, PREFIX + "$ECB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria192_ecb, PREFIX + "$ECB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria256_ecb, PREFIX + "$ECB");
+            
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria128_cbc, PREFIX + "$CBC");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria192_cbc, PREFIX + "$CBC");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria256_cbc, PREFIX + "$CBC");
+
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria128_cfb, PREFIX + "$CFB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria192_cfb, PREFIX + "$CFB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria256_cfb, PREFIX + "$CFB");
+
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria128_ofb, PREFIX + "$OFB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria192_ofb, PREFIX + "$OFB");
+            provider.addAlgorithm("Cipher", NSRIObjectIdentifiers.id_aria256_ofb, PREFIX + "$OFB");
+
+            provider.addAlgorithm("Cipher.ARIARFC3211WRAP", PREFIX + "$RFC3211Wrap");
+
+            provider.addAlgorithm("Cipher.ARIAWRAP", PREFIX + "$Wrap");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria128_kw, "ARIAWRAP");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria192_kw, "ARIAWRAP");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria256_kw, "ARIAWRAP");
+            provider.addAlgorithm("Alg.Alias.Cipher.ARIAKW", "ARIAWRAP");
+
+            provider.addAlgorithm("Cipher.ARIAWRAPPAD", PREFIX + "$WrapPad");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria128_kwp, "ARIAWRAPPAD");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria192_kwp, "ARIAWRAPPAD");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria256_kwp, "ARIAWRAPPAD");
+            provider.addAlgorithm("Alg.Alias.Cipher.ARIAKWP", "ARIAWRAPPAD");
+            
+            provider.addAlgorithm("KeyGenerator.ARIA", PREFIX + "$KeyGen");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_kw, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_kw, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_kw, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_kwp, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_kwp, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_kwp, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_ecb, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_ecb, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_ecb, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_cbc, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_cbc, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_cbc, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_cfb, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_cfb, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_cfb, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_ofb, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_ofb, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_ofb, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_ccm, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_ccm, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_ccm, PREFIX + "$KeyGen256");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria128_gcm, PREFIX + "$KeyGen128");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria192_gcm, PREFIX + "$KeyGen192");
+            provider.addAlgorithm("KeyGenerator", NSRIObjectIdentifiers.id_aria256_gcm, PREFIX + "$KeyGen256");
+
+            provider.addAlgorithm("AlgorithmParameterGenerator.ARIACCM", PREFIX + "$AlgParamGenCCM");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NSRIObjectIdentifiers.id_aria128_ccm, "CCM");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NSRIObjectIdentifiers.id_aria192_ccm, "CCM");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NSRIObjectIdentifiers.id_aria256_ccm, "CCM");
+
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria128_ccm, "CCM");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria192_ccm, "CCM");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria256_ccm, "CCM");
+
+            provider.addAlgorithm("AlgorithmParameterGenerator.ARIAGCM", PREFIX + "$AlgParamGenGCM");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NSRIObjectIdentifiers.id_aria128_gcm, "GCM");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NSRIObjectIdentifiers.id_aria192_gcm, "GCM");
+            provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + NSRIObjectIdentifiers.id_aria256_gcm, "GCM");
+
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria128_gcm, "GCM");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria192_gcm, "GCM");
+            provider.addAlgorithm("Alg.Alias.Cipher", NSRIObjectIdentifiers.id_aria256_gcm, "GCM");
+            
+            addGMacAlgorithm(provider, "ARIA", PREFIX + "$GMAC", PREFIX + "$KeyGen");
+            addPoly1305Algorithm(provider, "ARIA", PREFIX + "$Poly1305", PREFIX + "$Poly1305KeyGen");
+        }
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseMac.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseMac.java
index daa53d7..7c41af0 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseMac.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseMac.java
@@ -18,6 +18,7 @@
 
 import org.bouncycastle.crypto.CipherParameters;
 import org.bouncycastle.crypto.Mac;
+import org.bouncycastle.crypto.macs.HMac;
 import org.bouncycastle.crypto.params.AEADParameters;
 import org.bouncycastle.crypto.params.KeyParameter;
 import org.bouncycastle.crypto.params.ParametersWithIV;
@@ -35,8 +36,8 @@
     private Mac macEngine;
 
     private int scheme = PKCS12;
-    private int                     pbeHash = SHA1;
-    private int                     keySize = 160;
+    private int pbeHash = SHA1;
+    private int keySize = 160;
 
     protected BaseMac(
         Mac macEngine)
@@ -103,10 +104,40 @@
                 digest = GOST3411;
                 keySize = 256;
             }
-            else if (macEngine.getAlgorithmName().startsWith("SHA256"))
+            else if (macEngine instanceof HMac)
             {
-                digest = SHA256;
-                keySize = 256;
+                if (!macEngine.getAlgorithmName().startsWith("SHA-1"))
+                {
+                    if (macEngine.getAlgorithmName().startsWith("SHA-224"))
+                    {
+                        digest = SHA224;
+                        keySize = 224;
+                    }
+                    else if (macEngine.getAlgorithmName().startsWith("SHA-256"))
+                    {
+                        digest = SHA256;
+                        keySize = 256;
+                    }
+                    else if (macEngine.getAlgorithmName().startsWith("SHA-384"))
+                    {
+                        digest = SHA384;
+                        keySize = 384;
+                    }
+                    else if (macEngine.getAlgorithmName().startsWith("SHA-512"))
+                    {
+                        digest = SHA512;
+                        keySize = 512;
+                    }
+                    else if (macEngine.getAlgorithmName().startsWith("RIPEMD160"))
+                    {
+                        digest = RIPEMD160;
+                        keySize = 160;
+                    }
+                    else
+                    {
+                        throw new InvalidAlgorithmParameterException("no PKCS12 mapping for HMAC: " + macEngine.getAlgorithmName());
+                    }
+                }
             }
             // TODO: add correct handling for other digests
             param = PBE.Util.makePBEMacParameters(k, PKCS12, digest, keySize, pbeSpec);
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseStreamCipher.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseStreamCipher.java
index e4a10e1..598d1fc 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseStreamCipher.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/symmetric/util/BaseStreamCipher.java
@@ -5,6 +5,7 @@
 import java.security.InvalidKeyException;
 import java.security.InvalidParameterException;
 import java.security.Key;
+import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.spec.AlgorithmParameterSpec;
 
@@ -119,10 +120,11 @@
      */
     protected void engineSetMode(
         String  mode)
+        throws NoSuchAlgorithmException
     {
         if (!mode.equalsIgnoreCase("ECB"))
         {
-            throw new IllegalArgumentException("can't support mode " + mode);
+            throw new NoSuchAlgorithmException("can't support mode " + mode);
         }
     }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/util/AsymmetricAlgorithmProvider.java b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/util/AsymmetricAlgorithmProvider.java
index c401084..448c352 100644
--- a/bcprov/src/main/java/org/bouncycastle/jcajce/provider/util/AsymmetricAlgorithmProvider.java
+++ b/bcprov/src/main/java/org/bouncycastle/jcajce/provider/util/AsymmetricAlgorithmProvider.java
@@ -36,6 +36,11 @@
 
     protected void registerOidAlgorithmParameters(ConfigurableProvider provider, ASN1ObjectIdentifier oid, String name)
     {
+        provider.addAlgorithm("Alg.Alias.AlgorithmParameters." + oid, name);
+    }
+
+    protected void registerOidAlgorithmParameterGenerator(ConfigurableProvider provider, ASN1ObjectIdentifier oid, String name)
+    {
         provider.addAlgorithm("Alg.Alias.AlgorithmParameterGenerator." + oid, name);
         provider.addAlgorithm("Alg.Alias.AlgorithmParameters." + oid, name);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/BouncyCastleProvider.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/BouncyCastleProvider.java
index a490c61..7a8d7c6 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/BouncyCastleProvider.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/BouncyCastleProvider.java
@@ -7,6 +7,7 @@
 import java.security.Provider;
 import java.security.PublicKey;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.Map;
 
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
@@ -44,7 +45,7 @@
 public final class BouncyCastleProvider extends Provider
     implements ConfigurableProvider
 {
-    private static String info = "BouncyCastle Security Provider v1.56";
+    private static String info = "BouncyCastle Security Provider v1.57";
 
     public static final String PROVIDER_NAME = "BC";
 
@@ -69,7 +70,7 @@
 
     private static final String[] SYMMETRIC_CIPHERS =
     {
-        "AES", "ARC4", "Blowfish", "Camellia", "CAST5", "CAST6", "ChaCha", "DES", "DESede",
+        "AES", "ARC4", "ARIA", "Blowfish", "Camellia", "CAST5", "CAST6", "ChaCha", "DES", "DESede",
         "GOST28147", "Grainv1", "Grain128", "HC128", "HC256", "IDEA", "Noekeon", "RC2", "RC5",
         "RC6", "Rijndael", "Salsa20", "SEED", "Serpent", "Shacal2", "Skipjack", "SM4", "TEA", "Twofish", "Threefish",
         "VMPC", "VMPCKSA3", "XTEA", "XSalsa20", "OpenSSLPBKDF"
@@ -89,7 +90,7 @@
 
     private static final String[] ASYMMETRIC_CIPHERS =
     {
-        "DSA", "DH", "EC", "RSA", "GOST", "ECGOST", "ElGamal", "DSTU4145"
+        "DSA", "DH", "EC", "RSA", "GOST", "ECGOST", "ElGamal", "DSTU4145", "GM"
     };
 
     /*
@@ -127,7 +128,7 @@
      */
     public BouncyCastleProvider()
     {
-        super(PROVIDER_NAME, 1.56, info);
+        super(PROVIDER_NAME, 1.57, info);
 
         AccessController.doPrivileged(new PrivilegedAction()
         {
@@ -276,6 +277,21 @@
         }
     }
 
+    public void addAttributes(String key, Map<String, String> attributeMap)
+    {
+        for (Iterator it = attributeMap.keySet().iterator(); it.hasNext();)
+        {
+            String attributeName = (String)it.next();
+            String attributeKey = key + " " + attributeName;
+            if (containsKey(attributeKey))
+            {
+                throw new IllegalStateException("duplicate provider attribute key (" + attributeKey + ") found");
+            }
+
+            put(attributeKey, attributeMap.get(attributeName));
+        }
+    }
+
     private static AsymmetricKeyInfoConverter getAsymmetricKeyInfoConverter(ASN1ObjectIdentifier algorithm)
     {
         synchronized (keyInfoConverters)
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/BrokenKDF2BytesGenerator.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/BrokenKDF2BytesGenerator.java
index c907085..a5ef1a1 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/BrokenKDF2BytesGenerator.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/BrokenKDF2BytesGenerator.java
@@ -77,15 +77,15 @@
             throw new DataLengthException("output buffer too small");
         }
 
-        long    oBits = len * 8;
+        long    oBits = len * 8L;
 
         //
         // this is at odds with the standard implementation, the
-        // maximum value should be hBits * (2^23 - 1) where hBits
+        // maximum value should be hBits * (2^32 - 1) where hBits
         // is the digest output size in bits. We can't have an
         // array with a long index at the moment...
         //
-        if (oBits > (digest.getDigestSize() * 8 * (2L^32 - 1)))
+        if (oBits > (digest.getDigestSize() * 8L * (1L<<32 - 1)))
         {
             new IllegalArgumentException("Output length to large");
         }
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/AESTest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/AESTest.java
index ce0ac4c..454232a 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/AESTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/AESTest.java
@@ -4,6 +4,7 @@
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.IOException;
+import java.security.InvalidKeyException;
 import java.security.Key;
 import java.security.Security;
 
@@ -286,6 +287,34 @@
         {
             // expected
         }
+
+
+        // reuse test
+        in = Cipher.getInstance("AES/GCM/NoPadding", "BC");
+        
+        in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(N));
+
+        enc = in.doFinal(P);
+
+        try
+        {
+            in.doFinal(P);
+            fail("no exception on reuse");
+        }
+        catch (IllegalStateException e)
+        {
+            isTrue("wrong message", e.getMessage().equals("GCM cipher cannot be reused for encryption"));
+        }
+
+        try
+        {
+            in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(N));
+            fail("no exception on reuse");
+        }
+        catch (InvalidKeyException e)
+        {
+            isTrue("wrong message", e.getMessage().equals("cannot reuse nonce for GCM encryption"));
+        }
     }
 
     private void ocbTest()
@@ -399,13 +428,21 @@
 
 
         String[] wrapOids = {
-                NISTObjectIdentifiers.id_aes128_wrap.getId(),
-                NISTObjectIdentifiers.id_aes192_wrap.getId(),
-                NISTObjectIdentifiers.id_aes256_wrap.getId()
+            NISTObjectIdentifiers.id_aes128_wrap.getId(),
+            NISTObjectIdentifiers.id_aes192_wrap.getId(),
+            NISTObjectIdentifiers.id_aes256_wrap.getId(),
         };
 
         wrapOidTest(wrapOids, "AESWrap");
 
+        wrapOids = new String[] {
+                NISTObjectIdentifiers.id_aes128_wrap_pad.getId(),
+                NISTObjectIdentifiers.id_aes192_wrap_pad.getId(),
+                NISTObjectIdentifiers.id_aes256_wrap_pad.getId()
+        };
+
+        wrapOidTest(wrapOids, "AESWrapPad");
+
         eaxTest();
         ccmTest();
         gcmTest();
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/ARIATest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/ARIATest.java
new file mode 100644
index 0000000..c49691e
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/ARIATest.java
@@ -0,0 +1,427 @@
+package org.bouncycastle.jce.provider.test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.security.Key;
+import java.security.Security;
+
+import javax.crypto.Cipher;
+import javax.crypto.CipherInputStream;
+import javax.crypto.CipherOutputStream;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import org.bouncycastle.asn1.nsri.NSRIObjectIdentifiers;
+import org.bouncycastle.crypto.prng.FixedSecureRandom;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.util.encoders.Hex;
+
+/**
+ * basic test class for the ARIA cipher vectors from FIPS-197
+ */
+public class ARIATest
+    extends BaseBlockCipherTest
+{
+    static String[] cipherTests =
+    {
+            "128",
+            "000102030405060708090a0b0c0d0e0f",
+            "00112233445566778899aabbccddeeff",
+            "d718fbd6ab644c739da95f3be6451778",
+            "192",
+            "000102030405060708090a0b0c0d0e0f1011121314151617",
+            "00112233445566778899aabbccddeeff",
+            "26449c1805dbe7aa25a468ce263a9e79",
+            "256",
+            "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+            "00112233445566778899aabbccddeeff",
+            "f92bd7c79fb72e2f2b8f80c1972d24fc"
+    };
+
+    public ARIATest()
+    {
+        super("ARIA");
+    }
+
+    private void test(
+        int         strength,
+        byte[]      keyBytes,
+        byte[]      input,
+        byte[]      output)
+        throws Exception
+    {
+        Key                     key;
+        Cipher                  in, out;
+        CipherInputStream       cIn;
+        CipherOutputStream      cOut;
+        ByteArrayInputStream    bIn;
+        ByteArrayOutputStream   bOut;
+
+        key = new SecretKeySpec(keyBytes, "ARIA");
+
+        in = Cipher.getInstance("ARIA/ECB/NoPadding", "BC");
+        out = Cipher.getInstance("ARIA/ECB/NoPadding", "BC");
+        
+        try
+        {
+            out.init(Cipher.ENCRYPT_MODE, key);
+        }
+        catch (Exception e)
+        {
+            fail("ARIA failed initialisation - " + e.toString(), e);
+        }
+
+        try
+        {
+            in.init(Cipher.DECRYPT_MODE, key);
+        }
+        catch (Exception e)
+        {
+            fail("ARIA failed initialisation - " + e.toString(), e);
+        }
+
+        //
+        // encryption pass
+        //
+        bOut = new ByteArrayOutputStream();
+
+        cOut = new CipherOutputStream(bOut, out);
+
+        try
+        {
+            for (int i = 0; i != input.length / 2; i++)
+            {
+                cOut.write(input[i]);
+            }
+            cOut.write(input, input.length / 2, input.length - input.length / 2);
+            cOut.close();
+        }
+        catch (IOException e)
+        {
+            fail("ARIA failed encryption - " + e.toString(), e);
+        }
+
+        byte[]    bytes;
+
+        bytes = bOut.toByteArray();
+
+        if (!areEqual(bytes, output))
+        {
+            fail("ARIA failed encryption - expected " + new String(Hex.encode(output)) + " got " + new String(Hex.encode(bytes)));
+        }
+
+        //
+        // decryption pass
+        //
+        bIn = new ByteArrayInputStream(bytes);
+
+        cIn = new CipherInputStream(bIn, in);
+
+        try
+        {
+            DataInputStream dIn = new DataInputStream(cIn);
+
+            bytes = new byte[input.length];
+
+            for (int i = 0; i != input.length / 2; i++)
+            {
+                bytes[i] = (byte)dIn.read();
+            }
+            dIn.readFully(bytes, input.length / 2, bytes.length - input.length / 2);
+        }
+        catch (Exception e)
+        {
+            fail("ARIA failed encryption - " + e.toString(), e);
+        }
+
+        if (!areEqual(bytes, input))
+        {
+            fail("ARIA failed decryption - expected " + new String(Hex.encode(input)) + " got " + new String(Hex.encode(bytes)));
+        }
+    }
+
+    private void eaxTest()
+        throws Exception
+    {
+        byte[] K = Hex.decode("233952DEE4D5ED5F9B9C6D6FF80FF478");
+        byte[] N = Hex.decode("62EC67F9C3A4A407FCB2A8C49031A8B3");
+        byte[] P = Hex.decode("68656c6c6f20776f726c642121");
+        byte[] C = Hex.decode("85fe63d6cfb872d2420e65425c074dfad6fe752e03");
+
+        Key                     key;
+        Cipher                  in, out;
+
+        key = new SecretKeySpec(K, "ARIA");
+
+        in = Cipher.getInstance("ARIA/EAX/NoPadding", "BC");
+        out = Cipher.getInstance("ARIA/EAX/NoPadding", "BC");
+
+        in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] enc = in.doFinal(P);
+        if (!areEqual(enc, C))
+        {
+            fail("ciphertext doesn't match in EAX: " + Hex.toHexString(enc));
+        }
+
+        out.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] dec = out.doFinal(C);
+        if (!areEqual(dec, P))
+        {
+            fail("plaintext doesn't match in EAX");
+        }
+
+        try
+        {
+            in = Cipher.getInstance("ARIA/EAX/PKCS5Padding", "BC");
+
+            fail("bad padding missed in EAX");
+        }
+        catch (NoSuchPaddingException e)
+        {
+            // expected
+        }
+    }
+
+    private void ccmTest()
+        throws Exception
+    {
+        byte[] K = Hex.decode("404142434445464748494a4b4c4d4e4f");
+        byte[] N = Hex.decode("10111213141516");
+        byte[] P = Hex.decode("68656c6c6f20776f726c642121");
+        byte[] C = Hex.decode("0af625ff69cd9dbe65fae181d654717eb7a0263bcd");
+
+        Key                     key;
+        Cipher                  in, out;
+
+        key = new SecretKeySpec(K, "ARIA");
+
+        in = Cipher.getInstance("ARIA/CCM/NoPadding", "BC");
+        out = Cipher.getInstance("ARIA/CCM/NoPadding", "BC");
+
+        in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] enc = in.doFinal(P);
+        if (!areEqual(enc, C))
+        {
+            fail("ciphertext doesn't match in CCM: " + Hex.toHexString(enc));
+        }
+
+        out.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] dec = out.doFinal(C);
+        if (!areEqual(dec, P))
+        {
+            fail("plaintext doesn't match in CCM");
+        }
+
+        try
+        {
+            in = Cipher.getInstance("ARIA/CCM/PKCS5Padding", "BC");
+
+            fail("bad padding missed in CCM");
+        }
+        catch (NoSuchPaddingException e)
+        {
+            // expected
+        }
+    }
+
+    private void gcmTest()
+        throws Exception
+    {
+        // Test Case 15 from McGrew/Viega
+        byte[] K = Hex.decode(
+              "feffe9928665731c6d6a8f9467308308"
+            + "feffe9928665731c6d6a8f9467308308");
+        byte[] P = Hex.decode(
+              "d9313225f88406e5a55909c5aff5269a"
+            + "86a7a9531534f7da2e4c303d8a318a72"
+            + "1c3c0c95956809532fcf0e2449a6b525"
+            + "b16aedf5aa0de657ba637b391aafd255");
+        byte[] N = Hex.decode("cafebabefacedbaddecaf888");
+        String T = "c8f245c8619ca9ba7d6d9545e7f48214";
+        byte[] C = Hex.decode(             
+              "c3aa0e01a4f8b5dfdb25d0f1c78c275e516114080e2be7a7f7bffd4504b19a8552f80ad5b55f3d911725489629996d398d5ed6f077e22924c5b8ebe20a219693"
+            + T);
+
+        Key                     key;
+        Cipher                  in, out;
+
+        key = new SecretKeySpec(K, "ARIA");
+
+        in = Cipher.getInstance("ARIA/GCM/NoPadding", "BC");
+        out = Cipher.getInstance("ARIA/GCM/NoPadding", "BC");
+
+        in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] enc = in.doFinal(P);
+        if (!areEqual(enc, C))
+        {
+            fail("ciphertext doesn't match in GCM: " + Hex.toHexString(enc));
+        }
+
+        out.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] dec = out.doFinal(C);
+        if (!areEqual(dec, P))
+        {
+            fail("plaintext doesn't match in GCM");
+        }
+
+        try
+        {
+            in = Cipher.getInstance("ARIA/GCM/PKCS5Padding", "BC");
+    
+            fail("bad padding missed in GCM");
+        }
+        catch (NoSuchPaddingException e)
+        {
+            // expected
+        }
+    }
+
+    private void ocbTest()
+        throws Exception
+    {
+        byte[] K = Hex.decode(
+              "000102030405060708090A0B0C0D0E0F");
+        byte[] P = Hex.decode(
+              "000102030405060708090A0B0C0D0E0F");
+        byte[] N = Hex.decode("000102030405060708090A0B");
+        String T = "0027ce4f3aaeec75";
+        byte[] C = Hex.decode(
+            "7bcae9eac9f1f54704a630e309099a87f53a1c1559de1b3b" + T);
+
+        Key                     key;
+        Cipher                  in, out;
+
+        key = new SecretKeySpec(K, "ARIA");
+
+        in = Cipher.getInstance("ARIA/OCB/NoPadding", "BC");
+        out = Cipher.getInstance("ARIA/OCB/NoPadding", "BC");
+
+        in.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] enc = in.doFinal(P);
+        if (!areEqual(enc, C))
+        {
+            fail("ciphertext doesn't match in OCB: " + Hex.toHexString(enc));
+        }
+
+        out.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(N));
+
+        byte[] dec = out.doFinal(C);
+        if (!areEqual(dec, P))
+        {
+            fail("plaintext doesn't match in OCB");
+        }
+
+        try
+        {
+            in = Cipher.getInstance("ARIA/OCB/PKCS5Padding", "BC");
+
+            fail("bad padding missed in OCB");
+        }
+        catch (NoSuchPaddingException e)
+        {
+            // expected
+        }
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        for (int i = 0; i != cipherTests.length; i += 4)
+        {
+            test(Integer.parseInt(cipherTests[i]), 
+                            Hex.decode(cipherTests[i + 1]),
+                            Hex.decode(cipherTests[i + 2]),
+                            Hex.decode(cipherTests[i + 3]));
+        }
+
+        byte[]  kek1 = Hex.decode("000102030405060708090a0b0c0d0e0f");
+        byte[]  in1 = Hex.decode("00112233445566778899aabbccddeeff");
+        byte[]  out1 = Hex.decode("a93f148d4909d85f1aae656909879275ae597b3acf9d60db");
+        
+        wrapTest(1, "ARIAWrap", kek1, in1, out1);
+
+        byte[]  kek2 = Hex.decode("000102030405060708090a0b0c0d0e0f");
+        byte[]  in2 = Hex.decode("00112233445566778899aabbccddeeff");
+        byte[]  out2 = Hex.decode("9b2d3cac0acf9d4bde7c1bdb0313fbef931f025acc77bf57d3d1cabc88b514d0");
+
+        wrapTest(2, "ARIARFC3211WRAP", kek2,  kek2, new FixedSecureRandom(Hex.decode("9688df2af1b7b1ac9688df2a")), in2, out2);
+
+        byte[]  kek3 = Hex.decode("000102030405060708090a0b0c0d0e0f");
+        byte[]  in3 = Hex.decode("00112233445566778899aabbccddeeff");
+        byte[]  out3 = Hex.decode("ac0e22699a036ced63adeb75f4946f82dc98ad8af43b24d5");
+
+        wrapTest(3, "ARIAWrapPad", kek3, in3, out3);
+
+        String[] oids = {
+                NSRIObjectIdentifiers.id_aria128_ecb.getId(),
+                NSRIObjectIdentifiers.id_aria128_cbc.getId(),
+                NSRIObjectIdentifiers.id_aria128_ofb.getId(),
+                NSRIObjectIdentifiers.id_aria128_cfb.getId(),
+                NSRIObjectIdentifiers.id_aria192_ecb.getId(),
+                NSRIObjectIdentifiers.id_aria192_cbc.getId(),
+                NSRIObjectIdentifiers.id_aria192_ofb.getId(),
+                NSRIObjectIdentifiers.id_aria192_cfb.getId(),
+                NSRIObjectIdentifiers.id_aria256_ecb.getId(),
+                NSRIObjectIdentifiers.id_aria256_cbc.getId(),
+                NSRIObjectIdentifiers.id_aria256_ofb.getId(),
+                NSRIObjectIdentifiers.id_aria256_cfb.getId()
+        };
+
+        String[] names = {
+                "ARIA/ECB/PKCS7Padding",
+                "ARIA/CBC/PKCS7Padding",
+                "ARIA/OFB/NoPadding",
+                "ARIA/CFB/NoPadding",
+                "ARIA/ECB/PKCS7Padding",
+                "ARIA/CBC/PKCS7Padding",
+                "ARIA/OFB/NoPadding",
+                "ARIA/CFB/NoPadding",
+                "ARIA/ECB/PKCS7Padding",
+                "ARIA/CBC/PKCS7Padding",
+                "ARIA/OFB/NoPadding",
+                "ARIA/CFB/NoPadding"
+        };
+
+        oidTest(oids, names, 4);
+
+
+        String[] wrapOids = {
+                NSRIObjectIdentifiers.id_aria128_kw.getId(),
+                NSRIObjectIdentifiers.id_aria192_kw.getId(),
+                NSRIObjectIdentifiers.id_aria256_kw.getId()
+        };
+
+        wrapOidTest(wrapOids, "ARIAWrap");
+
+        wrapOids = new String[] {
+                NSRIObjectIdentifiers.id_aria128_kwp.getId(),
+                NSRIObjectIdentifiers.id_aria192_kwp.getId(),
+                NSRIObjectIdentifiers.id_aria256_kwp.getId()
+        };
+
+        wrapOidTest(wrapOids, "ARIAWrapPad");
+
+        eaxTest();
+        ccmTest();
+        gcmTest();
+        ocbTest();
+    }
+
+    public static void main(
+        String[]    args)
+    {
+        Security.addProvider(new BouncyCastleProvider());
+
+        runTest(new ARIATest());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/BlockCipherTest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/BlockCipherTest.java
index eccf385..83cfdeb 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/BlockCipherTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/BlockCipherTest.java
@@ -901,8 +901,20 @@
                 System.arraycopy(input, 0, input2, input.length * 2, input.length);
                 System.arraycopy(input, 0, input2, input.length * 3, input.length);
 
+                if (algorithm.indexOf("GCM") > 0)
+                {
+                    out = Cipher.getInstance(algorithm, "BC");
+                    out.init(Cipher.ENCRYPT_MODE, key, rand);
+                }
+
                 byte[] output2 = out.doFinal(input2);
 
+                if (algorithm.indexOf("GCM") > 0)
+                {
+                    out = Cipher.getInstance(algorithm, "BC");
+                    out.init(Cipher.ENCRYPT_MODE, key, rand);
+                }
+                
                 byte[] out1 = new byte[input2.length / 2 - out.getBlockSize() * 2 - 1];
 
                 try
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/CertTest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/CertTest.java
index 5e41d28..bd70012 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/CertTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/CertTest.java
@@ -1144,6 +1144,119 @@
             "flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==\n" +
             "-----END CERTIFICATE-----";
 
+    private final String pemPKCS7 =
+        "-----BEGIN PKCS7-----\n"+
+        "MIIJDAYJKoZIhvcNAQcCoIII/TCCCPkCAQExADALBgkqhkiG9w0BBwGgggjfMIIF\n"+
+        "wTCCBKmgAwIBAgIJ+pQ4odKc8AABMA0GCSqGSIb3DQEBBQUAMGAxCzAJBgNVBAYT\n"+
+        "AlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRIwEAYDVQQHEwlTYW4gTWF0ZW8xFzAV\n"+
+        "BgNVBAoTDkdlbml1cy5jb20gSW5jMQ8wDQYDVQQLEwZOZXRPcHMwHhcNMTQwMTI4\n"+
+        "MjE0MjE0WhcNMjQwMTI2MjE0MjE0WjBgMQswCQYDVQQGEwJVUzETMBEGA1UECBMK\n"+
+        "Q2FsaWZvcm5pYTESMBAGA1UEBxMJU2FuIE1hdGVvMRcwFQYDVQQKEw5HZW5pdXMu\n"+
+        "Y29tIEluYzEPMA0GA1UECxMGTmV0T3BzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A\n"+
+        "MIIBCgKCAQEArfmkkDffJP6ODl13KnTaB8cwvB4anWw8+bGa8y9N7wPx7RWZWFMr\n"+
+        "fOac01p2fhq+oUIw3/uxRcDAQBQx0ZFLx3OFMuQkTpFbzHeSctsXi1Kk28pn4K3B\n"+
+        "K2CModRh8ir/qdhu0PG4SsXdyN8uT8H6bitmH4vpLaAMMi6aa1M6Ygio8a37UCQQ\n"+
+        "7fw2P7YVR61BsyqwsM/eYtgd2LqrObLwkkOvxTwpZPWDftHI4ucz1rgNnD9q0H3g\n"+
+        "kyGyGq9NBkBHJ25+CkMe+1q/eh4Xt2kt2ML4q5YZmQEwHm1eIR3/uGlb1+bueRMd\n"+
+        "hrueth/FsUiKPJ0gzmsxzQefgcLnctIx3wIDAQABo4ICfDCCAngwCQYDVR0TBAIw\n"+
+        "ADALBgNVHQ8EBAMCBeAwHQYDVR0OBBYEFJ/uU/wudzNDSI/SWkNNTXNLq2EIMIGS\n"+
+        "BgNVHSMEgYowgYeAFJ/uU/wudzNDSI/SWkNNTXNLq2EIoWSkYjBgMQswCQYDVQQG\n"+
+        "EwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTESMBAGA1UEBxMJU2FuIE1hdGVvMRcw\n"+
+        "FQYDVQQKEw5HZW5pdXMuY29tIEluYzEPMA0GA1UECxMGTmV0T3Bzggn6lDih0pzw\n"+
+        "AAEwHgYJYIZIAYb4QgENBBEWD1guNTA5IFVuaXQgVGVzdDCBwwYDVR0RBIG7MIG4\n"+
+        "oA4GAyoDBKAHDAV0ZXN0MYEQeDUwOUBleGFtcGxlLmNvbYIQeDUwOS5leGFtcGxl\n"+
+        "LmNvbaRQME4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1Bd2Vzb21lIER1ZGVzMRcw\n"+
+        "FQYDVQQLFA7DnGJlciBGcsOuZW5kczEOMAwGA1UEAxQF4oiGxpKGJWh0dHA6Ly93\n"+
+        "d3cuZXhhbXBsZS5jb20vP3E9YXdlc29tZW5lc3OHBMCoAAGIAyoDBDCBwwYDVR0S\n"+
+        "BIG7MIG4oA4GAyoDBKAHDAV0ZXN0MYEQeDUwOUBleGFtcGxlLmNvbYIQeDUwOS5l\n"+
+        "eGFtcGxlLmNvbaRQME4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1Bd2Vzb21lIER1\n"+
+        "ZGVzMRcwFQYDVQQLFA7DnGJlciBGcsOuZW5kczEOMAwGA1UEAxQF4oiGxpKGJWh0\n"+
+        "dHA6Ly93d3cuZXhhbXBsZS5jb20vP3E9YXdlc29tZW5lc3OHBMCoAAGIAyoDBDAN\n"+
+        "BgkqhkiG9w0BAQUFAAOCAQEAQK5jBzTq2lX1GpVD9RHxtTHJn/WkYOpMJYJruw8j\n"+
+        "HGfQwAkhlL9AqWgodTruoTnXgZbA7F3S8hx9gmUbHVjVeBvxZnGEJ8g7So1erFKv\n"+
+        "yQD1Ajtn7+uGXw6s0Dvde2ZVzV05pRk9ybg7kxKNXvVbKS3kyd6XoA27H5CSmzDu\n"+
+        "8cwHQkN4mJlwAiNCwMarpN4m4X0rQ+g1Ncfq+4sRjFLd8VVCbCpzD8UMBOVTpxxj\n"+
+        "kSyRPJZ7Db8SY0H2vcTUj2Yyog1RQ+RA/xp7Fgw+leEiveIE23Dq62hCHq6rU5Vj\n"+
+        "6L/LlLiKZ17lZT4z0fJ0lukPUpmVTynALKsKNm57+fOfnzCCAxYwggLWoAMCAQIC\n"+
+        "CQDcaK5WyhbztjAJBgcqhkjOOAQDMGAxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpD\n"+
+        "YWxpZm9ybmlhMRIwEAYDVQQHEwlTYW4gTWF0ZW8xFzAVBgNVBAoTDkdlbml1cy5j\n"+
+        "b20gSW5jMQ8wDQYDVQQLEwZOZXRPcHMwHhcNMTQwMTI4MjE0MjE1WhcNMTQwMjI3\n"+
+        "MjE0MjE1WjBgMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTESMBAG\n"+
+        "A1UEBxMJU2FuIE1hdGVvMRcwFQYDVQQKEw5HZW5pdXMuY29tIEluYzEPMA0GA1UE\n"+
+        "CxMGTmV0T3BzMIIBtzCCASsGByqGSM44BAEwggEeAoGBAIiv42coWuyVXpYoyEwf\n"+
+        "7uevd4ILhylFuvKH5tRWRcZENuxPOmXfr3L43PCdbnJhXMg3RkkWgjaE7lBk5evx\n"+
+        "LKH6rU2a1GnGmoY34OIvVvGL3xi96uYTTvLIX3+6NXaAlNppIBSHXcYx8cMdtYIn\n"+
+        "3J6JGSHEPo36ay4rDZbfS1frAhUAxF6k+/9T00QMolE41R+6ytzrawkCgYA4soyt\n"+
+        "rrIrQq6gwm2HanT8coIChr3/Et8rMamj7gS1yT9kH8HNGf217XtE3f/LUZZWUkBq\n"+
+        "3PNOuxhprNmvSAdQ7ZzhWfRvOFHKaH/DtKvLeEC5I00DfYSI64/V869Jy7lnyY7M\n"+
+        "h7ShLIwOlwnBDIL5oluircfXTr20a/Jv9pS1AAOBhQACgYEAhg6lELBZAIHVkjm7\n"+
+        "bwVJ5G/ka+KCjXxWXo+BCbqo0LqfrKQoQwUcwDzuKdqWxYbyUd0cl5/9fX59/RT/\n"+
+        "9ULklGy+dTyUSc/hj85PCXLYly3G6WECiN29TK0QLhEMZfi+iSm3YxNX3rxvmrHb\n"+
+        "bfO2SMef4r6ujv9KscDg0zQ4AgajGjAYMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgA3\n"+
+        "MAkGByqGSM44BAMDLwAwLAIUVcYZ1LNv22fDBiajZ99FpTn05SMCFCgMXzUGLdPy\n"+
+        "gY460q7tGpuydry+oQAxAA==\n"+
+        "-----END PKCS7-----\n";
+
+    private static byte[] sm_root = Base64.decode(
+        "MIICwzCCAmmgAwIBAgIIIBQGIgAAAAMwCgYIKoEcz1UBg3UwgdgxCzAJBgNVBAYT" +
+            "AkNOMRIwEAYDVQQIDAnmsZ/oi4/nnIExEjAQBgNVBAcMCeWNl+S6rOW4gjE8MDoG" +
+            "A1UECgwz5rGf6IuP55yB55S15a2Q5ZWG5Yqh5pyN5Yqh5Lit5b+D5pyJ6ZmQ6LSj" +
+            "5Lu75YWs5Y+4MUswSQYDVQQLDELmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHk" +
+            "uK3lv4PmnInpmZDotKPku7vlhazlj7jlronlhajkuovkuJrpg6gxFjAUBgNVBAMM" +
+            "DUpTQ0FfUk9PVF9TTTIwHhcNMTQwNjIyMDQ1MzAyWhcNMzQwNjIyMDQ1MzAyWjCB" +
+            "1jELMAkGA1UEBhMCQ04xEjAQBgNVBAgMCeaxn+iLj+ecgTESMBAGA1UEBwwJ5Y2X" +
+            "5Lqs5biCMTwwOgYDVQQKDDPmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHkuK3l" +
+            "v4PmnInpmZDotKPku7vlhazlj7gxSzBJBgNVBAsMQuaxn+iLj+ecgeeUteWtkOWV" +
+            "huWKoeacjeWKoeS4reW/g+aciemZkOi0o+S7u+WFrOWPuOWuieWFqOS6i+S4mumD" +
+            "qDEUMBIGA1UEAwwLSlNDQV9DQV9TTTIwWTATBgcqhkjOPQIBBggqgRzPVQGCLQNC" +
+            "AAS/gvW90+LvyXPgpR7L0pwlVoZQdan7V5YQMEpxt47tzer31/8WJIfldx9NL/1A" +
+            "swkk6ItveCVW5k0u+IIk6crLox0wGzAMBgNVHRMEBTADAQH/MAsGA1UdDwQEAwIB" +
+            "BjAKBggqgRzPVQGDdQNIADBFAiEAy9NkogihHCj9Jx0ZiHdkMyCHF0wHWX58KZco" +
+            "CW5mjbgCIC9cAyuVV91ygLWk14PDuIAPFWKm6rJPXbiZL6KzwHQA");
+
+    private static byte[] sm_ca = Base64.decode(
+         "MIIC/TCCAqKgAwIBAgIIIBYDKQETeGQwCgYIKoEcz1UBg3UwgccxCzAJBgNVBAYT" +
+             "AkNOMRIwEAYDVQQIDAnmsZ/oi4/nnIExEjAQBgNVBAcMCeWNl+S6rOW4gjE8MDoG" +
+             "A1UECgwz5rGf6IuP55yB55S15a2Q5ZWG5Yqh5pyN5Yqh5Lit5b+D5pyJ6ZmQ6LSj" +
+             "5Lu75YWs5Y+4MTwwOgYDVQQLDDPmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHk" +
+             "uK3lv4PmnInpmZDotKPku7vlhazlj7gxFDASBgNVBAMMC0pTQ0FfQ0FfU00yMB4X" +
+             "DTE2MDMyOTA3MzQxOVoXDTIxMDMyOTA3MzQxOVowejENMAsGA1UEAxMEaG9zdDEL" +
+             "MAkGA1UECxMCMTExETAPBgNVBAoTCEFCQyBsdGQuMQswCQYDVQQHEwJOSjELMAkG" +
+             "A1UECBMCSlMxIjAgBgRVBC0RExhEOURGQThBN0NFMDg5QTg0Q0Q4Q0RCQjYxCzAJ" +
+             "BgNVBAYTAkNOMFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEaTG1mpejjdsNRr2q" +
+             "p3ZC0pPXuBO19sNhIJEG6cMSi/kE1hNDosCBRhpr2gOqKP9bXHrIhVGe41Z9Ci8L" +
+             "jf/hpaOBwzCBwDAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHSUEFjAUBggr" +
+             "BgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAU/9NocgiO5XrE+eYsU0VOkaSx" +
+             "egMwRwYIKwYBBQUHAQEEOzA5MDcGCCsGAQUFBzAChitodHRwOi8vMTAuMTA4LjUu" +
+             "Mjo4ODgwL2Rvd25sb2FkL0pTQ0FfQ0EuY2VyMB0GA1UdDgQWBBQQ80pId+SJS9uP" +
+             "aZaItbNdEE2C0zAKBggqgRzPVQGDdQNJADBGAiEAogpBxL3Cc4P4v+FvQsnCgCZs" +
+             "oSdFZLZDB4uDlOIqU9wCIQDXmE1iiCsWi1RmdoY+/ics2ZlY8vyHWBJnZ+XFy1Jb" +
+             "fA==");
+
+    private static byte[] sm_sign = Base64.decode(
+        "MIID9zCCA5ygAwIBAgIIIBcEJwKSCCMwCgYIKoEcz1UBg3UwgccxCzAJBgNVBAYT" +
+        "AkNOMRIwEAYDVQQIDAnmsZ/oi4/nnIExEjAQBgNVBAcMCeWNl+S6rOW4gjE8MDoG" +
+        "A1UECgwz5rGf6IuP55yB55S15a2Q5ZWG5Yqh5pyN5Yqh5Lit5b+D5pyJ6ZmQ6LSj" +
+        "5Lu75YWs5Y+4MTwwOgYDVQQLDDPmsZ/oi4/nnIHnlLXlrZDllYbliqHmnI3liqHk" +
+        "uK3lv4PmnInpmZDotKPku7vlhazlj7gxFDASBgNVBAMMC0pTQ0FfQ0FfU00yMB4X" +
+        "DTE3MDQyNzAwMzkwNVoXDTE4MDQyNzAwMzkwNVowggEdMQ4wDAYDVQRYDAUwMDAw" +
+        "MTESMBAGA1UEGgwJ5biC6L6W5Yy6MRswGQYDVQQBDBIzMjAxMTIxOTgxMDUxMTAw" +
+        "MTQxDTALBgRVBIhYDAM0NTYxDTALBgRVBIhXDAMxMjMxEjAQBgNVBC0MCXVzZXJD" +
+        "ZXJ0MjELMAkGA1UEBhMCQ04xEjAQBgNVBAgMCeaxn+iLj+ecgTESMBAGA1UEBwwJ" +
+        "5Y2X5Lqs5biCMQwwCgYDVQQLDAMwMDgxHzAdBgkqhkiG9w0BCQEWEDMyNzMyMTU2" +
+        "OEBxcS5jb20xITAfBgNVBCoMGOa1i+ivlee9keWFs1NNMueul+azlTEyMzEhMB8G" +
+        "A1UEAwwY5rWL6K+V572R5YWzU00y566X5rOVMTIzMFkwEwYHKoZIzj0CAQYIKoEc" +
+        "z1UBgi0DQgAEdbrBzy2y8Gz4grOF23iaDipPhRPQRApAMIAP0cAuL1tATFjFuWJs" +
+        "pBc1cnCZmsOJnVpV4W7VF8hNOaqv3Tq4NqOCARcwggETMAkGA1UdEwQCMAAwCwYD" +
+        "VR0PBAQDAgbAMB0GA1UdDgQWBBRsWSOQDniy75t7UEvTXugwfq0HpzAfBgNVHSME" +
+        "GDAWgBT/02hyCI7lesT55ixTRU6RpLF6AzAxBgNVHSUEKjAoBggrBgEFBQcDAgYI" +
+        "KwYBBQUHAwgGCCsGAQUFBwMEBggrBgEFBQcDCDA9BgNVHR8ENjA0MDKgMKAuhixo" +
+        "dHRwOi8vY3JsLmpzY2EuY29tLmNuL2NybC9TTTJDUkxfRU5USVRZLmNybDBHBggr" +
+        "BgEFBQcBAQQ7MDkwNwYIKwYBBQUHMAKBK2h0dHA6Ly8xMC4xMDguNS4yOjg4ODAv" +
+        "ZG93bmxvYWQvSlNDQV9DQS5jZXIwCgYIKoEcz1UBg3UDSQAwRgIhALFoMoA1+uO4" +
+        "tXfmoyePz1pmv0CWPBgEP1EfDeS6FPitAiEAjHJYq7ryHKULqpRg6ph9r+xUDoWd" +
+        "0TPMOQ9jj4XJPO4=");
+
     private PublicKey dudPublicKey = new PublicKey() 
     {
         public String getAlgorithm()
@@ -1184,6 +1297,7 @@
             Certificate cert = fact.generateCertificate(bIn);
 
             PublicKey    k = cert.getPublicKey();
+
             // System.out.println(cert);
         }
         catch (Exception e)
@@ -1480,6 +1594,8 @@
         //
         InputStream in = new ByteArrayInputStream(pkcs7CrlProblem);
         Collection certCol = cf.generateCertificates(in);
+
+        in.reset();
         Collection crlCol = cf.generateCRLs(in);
 
         if (crlCol.size() != 0)
@@ -1491,6 +1607,22 @@
         {
             fail("wrong number of Certs: " + certCol.size());
         }
+
+        in = new ByteArrayInputStream(pemPKCS7.getBytes("US-ASCII"));
+        certCol = cf.generateCertificates(in);
+
+        in.reset();
+        crlCol = cf.generateCRLs(in);
+
+        if (crlCol.size() != 0)
+        {
+            fail("wrong number of CRLs: " + crlCol.size());
+        }
+
+        if (certCol.size() != 2)
+        {
+            fail("wrong number of Certs: " + certCol.size());
+        }
     }
 
     private KeyPair generateLongFixedKeys()
@@ -1649,6 +1781,17 @@
         isTrue("collection not empty", certs2.isEmpty());
     }
 
+    private void invalidCRLs()
+        throws Exception
+    {
+        CertificateFactory certFact = CertificateFactory.getInstance("X.509", "BC");
+
+        Collection crls = certFact.generateCRLs(this.getClass().getResourceAsStream("cert_chain.txt"));
+        isTrue("multi crl", crls.isEmpty());
+        CRL crl = certFact.generateCRL(this.getClass().getResourceAsStream("cert_chain.txt"));
+        isTrue("single crl", crl == null);
+    }
+
     private void pemFileTestWithNl()
         throws Exception
     {
@@ -1695,6 +1838,7 @@
         checkCertificate(5, cert5);
         checkCertificate(6, oldEcdsa);
         checkCertificate(7, cert7);
+        checkCertificate(8, sm_sign);
 
         checkComparison(cert1);
 
@@ -1735,7 +1879,9 @@
         pemFileTestWithNl();
         pkcs7Test();
         rfc4491Test();
-        
+
+        invalidCRLs();
+
         testForgedSignature();
 
         checkCertificate(18, emptyDNCert);
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DHIESTest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DHIESTest.java
index a21bbc2..0d0155d 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DHIESTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DHIESTest.java
@@ -44,7 +44,31 @@
 
     BigInteger g1024 = new BigInteger("2",16);
 
-    DHParameterSpec param = new DHParameterSpec(p1024, g1024);
+    BigInteger p2048 = new BigInteger("95475cf5d93e596c3fcd1d902add02f427f5f3c7210313bb45fb4d5b" +
+                                "b2e5fe1cbd678cd4bbdd84c9836be1f31c0777725aeb6c2fc38b85f4" +
+                                "8076fa76bcd8146cc89a6fb2f706dd719898c2083dc8d896f84062e2" +
+                                "c9c94d137b054a8d8096adb8d51952398eeca852a0af12df83e475aa" +
+                                "65d4ec0c38a9560d5661186ff98b9fc9eb60eee8b030376b236bc73b" +
+                                "e3acdbd74fd61c1d2475fa3077b8f080467881ff7e1ca56fee066d79" +
+                                "506ade51edbb5443a563927dbc4ba520086746175c8885925ebc64c6" +
+                                "147906773496990cb714ec667304e261faee33b3cbdf008e0c3fa906" +
+                                "50d97d3909c9275bf4ac86ffcb3d03e6dfc8ada5934242dd6d3bcca2" +
+                                "a406cb0b", 16);
+
+    BigInteger g2048 = new BigInteger("42debb9da5b3d88cc956e08787ec3f3a09bba5f48b889a74aaf53174" +
+                                "aa0fbe7e3c5b8fcd7a53bef563b0e98560328960a9517f4014d3325f" +
+                                "c7962bf1e049370d76d1314a76137e792f3f0db859d095e4a5b93202" +
+                                "4f079ecf2ef09c797452b0770e1350782ed57ddf794979dcef23cb96" +
+                                "f183061965c4ebc93c9c71c56b925955a75f94cccf1449ac43d586d0" +
+                                "beee43251b0b2287349d68de0d144403f13e802f4146d882e057af19" +
+                                "b6f6275c6676c8fa0e3ca2713a3257fd1b27d0639f695e347d8d1cf9" +
+                                "ac819a26ca9b04cb0eb9b7b035988d15bbac65212a55239cfc7e58fa" +
+                                "e38d7250ab9991ffbc97134025fe8ce04c4399ad96569be91a546f49" +
+                                "78693c7a", 16);
+
+    DHParameterSpec param1024 = new DHParameterSpec(p1024, g1024);
+
+    DHParameterSpec param2048 = new DHParameterSpec(p2048, g2048);
 
     DHIESTest()
     {
@@ -70,7 +94,7 @@
         KeyPairGenerator    g = KeyPairGenerator.getInstance("DH", "BC");
         KeyPairGenerator    g512 = KeyPairGenerator.getInstance("DH", "BC");
 
-        g.initialize(param);
+        g.initialize(param1024);
 
         doTest("DHIES with default", g, "DHIES", params);
         
@@ -79,7 +103,7 @@
         doTest("DHIES with 512-bit", g512, "DHIES", params);
 
         // Testing ECIES with 1024-bit prime in streaming mode 
-        g.initialize(param, new SecureRandom());
+        g.initialize(param1024, new SecureRandom());
         doTest("DHIES with 1024-bit", g, "DHIES", params);
 
         c1 = new IESCipher(new IESEngine(new DHBasicAgreement(), 
@@ -94,19 +118,21 @@
     
         params = new IESParameterSpec(derivation, encoding, 128, 192, Hex.decode("0001020304050607"));
       
-        // Testing DHIES with default prime using DESEDE
+        // Testing DHIES with default prime (2048) using DESEDE
         g = KeyPairGenerator.getInstance("DH", "BC");
+        g.initialize(param2048, new SecureRandom());
+
         doTest("DHIESwithDES default", g, "DHIESwithDESEDE-CBC", params);
         
         // Testing DHIES with 512-bit prime using DESEDE
         doTest("DHIESwithDES 512-bit", g512, "DHIESwithDESEDE-CBC", params);
         
         // Testing DHIES with 1024-bit prime using DESEDE
-        g.initialize(param, new SecureRandom());
+        g.initialize(param1024, new SecureRandom());
         doTest("DHIESwithDES 1024-bit", g, "DHIESwithDESEDE-CBC", params);
 
         g = KeyPairGenerator.getInstance("DH", "BC");
-        g.initialize(param);
+        g.initialize(param1024);
 
         c1 = new IESCipher.IESwithAESCBC();
         c2 = new IESCipher.IESwithAESCBC();
@@ -119,7 +145,7 @@
         doTest("DHIESwithAES 512-bit", g512, "DHIESwithAES-CBC", params);
         
         // Testing DHIES with 1024-bit prime using AES
-        g.initialize(param, new SecureRandom());
+        g.initialize(param1024, new SecureRandom());
         doTest("DHIESwithAES 1024-bit", g, "DHIESwithAES-CBC", params);
 
         KeyPair       keyPair = g.generateKeyPair();
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DigestTest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DigestTest.java
index 96a81ac..151b01d 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DigestTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/DigestTest.java
@@ -130,6 +130,18 @@
         {
             fail("Result object 5 not equal");
         }
+
+        // test six, check reset() method with longer message
+        digest.update(message);
+        digest.update(message);
+        digest.reset();
+
+        result2 = digest.digest(message);
+
+        if (!MessageDigest.isEqual(result, result2))
+        {
+            fail("Result object 6 not equal");
+        }
     }
 
     /**
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/PBETest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/PBETest.java
index 2cc5530..0dfbbad 100644
--- a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/PBETest.java
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/PBETest.java
@@ -29,6 +29,7 @@
 import org.bouncycastle.crypto.generators.PKCS12ParametersGenerator;
 import org.bouncycastle.crypto.params.KeyParameter;
 import org.bouncycastle.crypto.params.ParametersWithIV;
+import org.bouncycastle.jcajce.PKCS12Key;
 import org.bouncycastle.jcajce.PKCS12KeyWithParameters;
 import org.bouncycastle.jcajce.provider.symmetric.util.BCPBEKey;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
@@ -383,6 +384,46 @@
         }
     }
 
+    public void testPKCS12HMac(
+        String  hmacName,
+        byte[]  output)
+    {
+        SecretKey           key;
+        byte[]              out;
+        Mac                 mac;
+
+        try
+        {
+            mac = Mac.getInstance(hmacName, "BC");
+        }
+        catch (Exception e)
+        {
+            fail("Failed - exception " + e.toString(), e);
+            return;
+        }
+
+        try
+        {
+            mac.init(new PKCS12Key("hello".toCharArray()), new PBEParameterSpec(new byte[20], 100));
+        }
+        catch (Exception e)
+        {
+            fail("Failed - exception " + e.toString(), e);
+            return;
+        }
+
+        mac.reset();
+
+        mac.update(message, 0, message.length);
+
+        out = mac.doFinal();
+
+        if (!Arrays.areEqual(out, output))
+        {
+            fail("Failed - expected " + new String(Hex.encode(output)) + " got " + new String(Hex.encode(out)));
+        }
+    }
+
     public void testPBEonSecretKeyHmac(
         String  hmacName,
         byte[]  output)
@@ -639,6 +680,24 @@
 
         checkPBE("PBKDF2WithHmacSHA1", true, "f14687fc31a66e2f7cc01d0a65f687961bd27e20", "6f6579193d6433a3e4600b243bb390674f04a615");
 
+        testPKCS12HMac("HMacSHA1", Hex.decode("bcc42174ccb04f425d9a5c8c4a95d6fd7c372911"));
+        testPKCS12HMac("HMacSHA256", Hex.decode("e1ae77e2d1dcc56a8befa3867ea3ff8c2163b01885504379412e525b120bf9ce"));
+        testPKCS12HMac("HMacSHA384", Hex.decode("1256a861351db2082f2ba827ca72cede54ee851f533962bba1fd97b500b6d6eb42aa4a51920aca0c817955feaf52d7f8"));
+        testPKCS12HMac("HMacSHA512", Hex.decode("9090898971914cb2e65eb1b083f1cad1ce9a9d386f963a2e2ede965fbce0a7121526b5f8aed83f81db60b97ced0bc4b0c27cf23407028cc2f289957f607cec98"));
+        testPKCS12HMac("HMacRIPEMD160", Hex.decode("cb1d8bdb6aca9e3fa8980d6eb41ab28a7eb2cfd6"));
+
+        try
+        {
+            Mac mac = Mac.getInstance("HMacRIPEMD256", "BC");
+
+            mac.init(new PKCS12Key("hello".toCharArray()), new PBEParameterSpec(new byte[20], 100));
+            fail("no exception");
+        }
+        catch (InvalidAlgorithmParameterException e)
+        {
+            isTrue("wrong exception", "no PKCS12 mapping for HMAC: RIPEMD256/HMAC".equals(e.getMessage()));
+        }
+
         testMixedKeyTypes();
         testNullSalt();
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/jce/provider/test/SignatureTest.java b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/SignatureTest.java
new file mode 100644
index 0000000..07da260
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/jce/provider/test/SignatureTest.java
@@ -0,0 +1,177 @@
+package org.bouncycastle.jce.provider.test;
+
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.SecureRandom;
+import java.security.Security;
+import java.security.Signature;
+
+import org.bouncycastle.asn1.cryptopro.CryptoProObjectIdentifiers;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jce.spec.ECNamedCurveGenParameterSpec;
+import org.bouncycastle.jce.spec.GOST3410ParameterSpec;
+import org.bouncycastle.util.encoders.Hex;
+import org.bouncycastle.util.test.SimpleTest;
+
+public class SignatureTest
+    extends SimpleTest
+{
+    private static final byte[] DATA = Hex.decode("00000000deadbeefbeefdeadffffffff00000000");
+
+    private void checkSig(KeyPair kp, String name)
+        throws Exception
+    {
+        Signature sig = Signature.getInstance(name, "BC");
+
+        sig.initSign(kp.getPrivate());
+        sig.update(DATA);
+
+        byte[] signature1 = sig.sign();
+
+        sig.update(DATA);
+
+        byte[] signature2 = sig.sign();
+
+        sig.initVerify(kp.getPublic());
+
+        sig.update(DATA);
+        if (!sig.verify(signature1))
+        {
+            fail("did not verify: " + name);
+        }
+
+        // After verify, should be reusable as if we are after initVerify
+        sig.update(DATA);
+        if (!sig.verify(signature1))
+        {
+            fail("second verify failed: " + name);
+        }
+
+        sig.update(DATA);
+        if (!sig.verify(signature2))
+        {
+            fail("second verify failed (2): " + name);
+        }
+    }
+
+    public void performTest()
+        throws Exception
+    {
+        KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA", "BC");
+
+        kpGen.initialize(2048);
+
+        KeyPair kp = kpGen.generateKeyPair();
+
+        checkSig(kp, "SHA1withRSA");
+        checkSig(kp, "SHA224withRSA");
+        checkSig(kp, "SHA256withRSA");
+        checkSig(kp, "SHA384withRSA");
+        checkSig(kp, "SHA512withRSA");
+
+        checkSig(kp, "SHA3-224withRSA");
+        checkSig(kp, "SHA3-256withRSA");
+        checkSig(kp, "SHA3-384withRSA");
+        checkSig(kp, "SHA3-512withRSA");
+
+        checkSig(kp, "MD2withRSA");
+        checkSig(kp, "MD4withRSA");
+        checkSig(kp, "MD5withRSA");
+        checkSig(kp, "RIPEMD160withRSA");
+        checkSig(kp, "RIPEMD128withRSA");
+        checkSig(kp, "RIPEMD256withRSA");
+
+        checkSig(kp, "SHA1withRSAandMGF1");
+        checkSig(kp, "SHA1withRSAandMGF1");
+        checkSig(kp, "SHA224withRSAandMGF1");
+        checkSig(kp, "SHA256withRSAandMGF1");
+        checkSig(kp, "SHA384withRSAandMGF1");
+        checkSig(kp, "SHA512withRSAandMGF1");
+
+        checkSig(kp, "SHA1withRSA/ISO9796-2");
+        checkSig(kp, "MD5withRSA/ISO9796-2");
+        checkSig(kp, "RIPEMD160withRSA/ISO9796-2");
+
+//        checkSig(kp, "SHA1withRSA/ISO9796-2PSS");
+//        checkSig(kp, "MD5withRSA/ISO9796-2PSS");
+//        checkSig(kp, "RIPEMD160withRSA/ISO9796-2PSS");
+
+        checkSig(kp, "RIPEMD128withRSA/X9.31");
+        checkSig(kp, "RIPEMD160withRSA/X9.31");
+        checkSig(kp, "SHA1withRSA/X9.31");
+        checkSig(kp, "SHA224withRSA/X9.31");
+        checkSig(kp, "SHA256withRSA/X9.31");
+        checkSig(kp, "SHA384withRSA/X9.31");
+        checkSig(kp, "SHA512withRSA/X9.31");
+        checkSig(kp, "WhirlpoolwithRSA/X9.31");
+
+        kpGen = KeyPairGenerator.getInstance("DSA", "BC");
+
+        kpGen.initialize(2048);
+
+        kp = kpGen.generateKeyPair();
+
+        checkSig(kp, "SHA1withDSA");
+        checkSig(kp, "SHA224withDSA");
+        checkSig(kp, "SHA256withDSA");
+        checkSig(kp, "SHA384withDSA");
+        checkSig(kp, "SHA512withDSA");
+        checkSig(kp, "NONEwithDSA");
+
+        kpGen = KeyPairGenerator.getInstance("EC", "BC");
+
+        kpGen.initialize(256);
+
+        kp = kpGen.generateKeyPair();
+
+        checkSig(kp, "SHA1withECDSA");
+        checkSig(kp, "SHA224withECDSA");
+        checkSig(kp, "SHA256withECDSA");
+        checkSig(kp, "SHA384withECDSA");
+        checkSig(kp, "SHA512withECDSA");
+        checkSig(kp, "RIPEMD160withECDSA");
+
+        kpGen = KeyPairGenerator.getInstance("EC", "BC");
+
+        kpGen.initialize(521);
+
+        kp = kpGen.generateKeyPair();
+
+        checkSig(kp, "SHA1withECNR");
+        checkSig(kp, "SHA224withECNR");
+        checkSig(kp, "SHA256withECNR");
+        checkSig(kp, "SHA384withECNR");
+        checkSig(kp, "SHA512withECNR");
+
+        kpGen = KeyPairGenerator.getInstance("ECGOST3410", "BC");
+
+        kpGen.initialize(new ECNamedCurveGenParameterSpec("GostR3410-2001-CryptoPro-A"), new SecureRandom());
+
+        kp = kpGen.generateKeyPair();
+
+        checkSig(kp, "GOST3411withECGOST3410");
+
+        kpGen = KeyPairGenerator.getInstance("GOST3410", "BC");
+
+        GOST3410ParameterSpec gost3410P = new GOST3410ParameterSpec(CryptoProObjectIdentifiers.gostR3410_94_CryptoPro_A.getId());
+
+        kpGen.initialize(gost3410P);
+        
+        kp = kpGen.generateKeyPair();
+
+        checkSig(kp, "GOST3411withGOST3410");
+    }
+
+    public String getName()
+    {
+        return "SigNameTest";
+    }
+
+    public static void main(
+        String[] args)
+    {
+        Security.addProvider(new BouncyCastleProvider());
+
+        runTest(new SignatureTest());
+    }
+}
\ No newline at end of file
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointCombMultiplier.java b/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointCombMultiplier.java
index 9fe00b9..c91de7b 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointCombMultiplier.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointCombMultiplier.java
@@ -47,7 +47,7 @@
             R = R.twicePlus(lookupTable[index]);
         }
 
-        return R;
+        return R.add(info.getOffset());
     }
 
     protected int getWidthForCombSize(int combSize)
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointPreCompInfo.java b/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointPreCompInfo.java
index b7569aa..31f5d10 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointPreCompInfo.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointPreCompInfo.java
@@ -5,6 +5,8 @@
  */
 public class FixedPointPreCompInfo implements PreCompInfo
 {
+    protected ECPoint offset = null;
+
     /**
      * Array holding the precomputed <code>ECPoint</code>s used for a fixed
      * point multiplication.
@@ -18,6 +20,16 @@
      */
     protected int width = -1;
 
+    public ECPoint getOffset()
+    {
+        return offset;
+    }
+
+    public void setOffset(ECPoint offset)
+    {
+        this.offset = offset;
+    }
+
     public ECPoint[] getPreComp()
     {
         return preComp;
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointUtil.java b/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointUtil.java
index e4fbb8d..93b435c 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointUtil.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/FixedPointUtil.java
@@ -35,18 +35,21 @@
             int bits = getCombSize(c);
             int d = (bits + minWidth - 1) / minWidth;
 
-            ECPoint[] pow2Table = new ECPoint[minWidth];
+            ECPoint[] pow2Table = new ECPoint[minWidth + 1];
             pow2Table[0] = p;
             for (int i = 1; i < minWidth; ++i)
             {
                 pow2Table[i] = pow2Table[i - 1].timesPow2(d);
             }
-    
+
+            // This will be the 'offset' value 
+            pow2Table[minWidth] = pow2Table[0].subtract(pow2Table[1]);
+
             c.normalizeAll(pow2Table);
-    
+
             lookupTable = new ECPoint[n];
-            lookupTable[0] = c.getInfinity();
-    
+            lookupTable[0] = pow2Table[0];
+
             for (int bit = minWidth - 1; bit >= 0; --bit)
             {
                 ECPoint pow2 = pow2Table[bit];
@@ -60,6 +63,7 @@
 
             c.normalizeAll(lookupTable);
 
+            info.setOffset(pow2Table[minWidth]);
             info.setPreComp(lookupTable);
             info.setWidth(minWidth);
 
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163K1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163K1Point.java
index 9c48319..43dfd0a 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163K1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163K1Point.java
@@ -147,11 +147,9 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1).addOne();
             if (X3.isZero())
             {
-//                return new SecT163K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT163K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -169,7 +167,6 @@
             X3 = AU1.multiply(AU2);
             if (X3.isZero())
             {
-//                return new SecT163K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT163K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -215,7 +212,6 @@
         ECFieldElement T = L1.square().add(L1Z1).add(Z1Sq);
         if (T.isZero())
         {
-//            return new SecT163K1Point(curve, T, curve.getB().sqrt(), withCompression);
             return new SecT163K1Point(curve, T, curve.getB(), withCompression);
         }
 
@@ -263,10 +259,7 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = Z1Sq.add(L1Sq).add(L1Z1);
-        ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -283,13 +276,12 @@
 
         if (A.isZero())
         {
-//            return new SecT163K1Point(curve, A, curve.getB().sqrt(), withCompression);
             return new SecT163K1Point(curve, A, curve.getB(), withCompression);
         }
 
         ECFieldElement X3 = A.square().multiply(X2Z1Sq);
         ECFieldElement Z3 = A.multiply(B).multiply(Z1Sq);
-        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2plus1, Z3);
+        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2.addOne(), Z3);
 
         return new SecT163K1Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163R2Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163R2Point.java
index dcadede..00b6a2c 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163R2Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT163R2Point.java
@@ -147,7 +147,6 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1).addOne();
             if (X3.isZero())
             {
@@ -259,10 +258,7 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = Z1Sq.add(L1Sq).add(L1Z1);
-        ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -284,7 +280,7 @@
 
         ECFieldElement X3 = A.square().multiply(X2Z1Sq);
         ECFieldElement Z3 = A.multiply(B).multiply(Z1Sq);
-        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2plus1, Z3);
+        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2.addOne(), Z3);
 
         return new SecT163R2Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233K1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233K1Point.java
index 90a9701..ac29aa3 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233K1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233K1Point.java
@@ -147,11 +147,9 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1);
             if (X3.isZero())
             {
-//                return new SecT233K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT233K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -169,7 +167,6 @@
             X3 = AU1.multiply(AU2);
             if (X3.isZero())
             {
-//                return new SecT233K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT233K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -223,7 +220,6 @@
 
         if (T.isZero())
         {
-//            return new SecT233K1Point(curve, T, curve.getB().sqrt(), withCompression);
             return new SecT233K1Point(curve, T, curve.getB(), withCompression);
         }
 
@@ -272,10 +268,8 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = L1Sq.add(L1Z1);
         ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2plus1.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -292,7 +286,6 @@
 
         if (A.isZero())
         {
-//            return new SecT233K1Point(curve, A, curve.getB().sqrt(), withCompression);
             return new SecT233K1Point(curve, A, curve.getB(), withCompression);
         }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233R1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233R1Point.java
index 2c01a58..8493094 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233R1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT233R1Point.java
@@ -147,7 +147,6 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1).addOne();
             if (X3.isZero())
             {
@@ -259,10 +258,7 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = Z1Sq.add(L1Sq).add(L1Z1);
-        ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -284,7 +280,7 @@
 
         ECFieldElement X3 = A.square().multiply(X2Z1Sq);
         ECFieldElement Z3 = A.multiply(B).multiply(Z1Sq);
-        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2plus1, Z3);
+        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2.addOne(), Z3);
 
         return new SecT233R1Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT239K1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT239K1Point.java
index 39384dc..1de2a29 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT239K1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT239K1Point.java
@@ -147,11 +147,9 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1);
             if (X3.isZero())
             {
-//                return new SecT239K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT239K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -169,7 +167,6 @@
             X3 = AU1.multiply(AU2);
             if (X3.isZero())
             {
-//                return new SecT239K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT239K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -224,7 +221,6 @@
 
         if (T.isZero())
         {
-//            return new SecT239K1Point(curve, T, curve.getB().sqrt(), withCompression);
             return new SecT239K1Point(curve, T, curve.getB(), withCompression);
         }
 
@@ -273,10 +269,8 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = L1Sq.add(L1Z1);
         ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2plus1.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -293,7 +287,6 @@
 
         if (A.isZero())
         {
-//            return new SecT239K1Point(curve, A, curve.getB().sqrt(), withCompression);
             return new SecT239K1Point(curve, A, curve.getB(), withCompression);
         }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283K1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283K1Point.java
index f3b704e..a99936e 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283K1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283K1Point.java
@@ -147,11 +147,9 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1);
             if (X3.isZero())
             {
-//                return new SecT283K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT283K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -169,7 +167,6 @@
             X3 = AU1.multiply(AU2);
             if (X3.isZero())
             {
-//                return new SecT283K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT283K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -224,7 +221,6 @@
 
         if (T.isZero())
         {
-//            return new SecT283K1Point(curve, T, curve.getB().sqrt(), withCompression);
             return new SecT283K1Point(curve, T, curve.getB(), withCompression);
         }
 
@@ -273,10 +269,8 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = L1Sq.add(L1Z1);
         ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2plus1.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -293,7 +287,6 @@
 
         if (A.isZero())
         {
-//            return new SecT283K1Point(curve, A, curve.getB().sqrt(), withCompression);
             return new SecT283K1Point(curve, A, curve.getB(), withCompression);
         }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283R1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283R1Point.java
index 7a95a73..0718239 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283R1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT283R1Point.java
@@ -147,7 +147,6 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1).addOne();
             if (X3.isZero())
             {
@@ -259,10 +258,7 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = Z1Sq.add(L1Sq).add(L1Z1);
-        ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -284,7 +280,7 @@
 
         ECFieldElement X3 = A.square().multiply(X2Z1Sq);
         ECFieldElement Z3 = A.multiply(B).multiply(Z1Sq);
-        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2plus1, Z3);
+        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2.addOne(), Z3);
 
         return new SecT283R1Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409K1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409K1Point.java
index 4204923..41155f3 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409K1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409K1Point.java
@@ -147,11 +147,9 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1);
             if (X3.isZero())
             {
-//                return new SecT409K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT409K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -169,7 +167,6 @@
             X3 = AU1.multiply(AU2);
             if (X3.isZero())
             {
-//                return new SecT409K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT409K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
@@ -224,7 +221,6 @@
 
         if (T.isZero())
         {
-//            return new SecT409K1Point(curve, T, curve.getB().sqrt(), withCompression);
             return new SecT409K1Point(curve, T, curve.getB(), withCompression);
         }
 
@@ -273,10 +269,8 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = L1Sq.add(L1Z1);
         ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2plus1.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -293,7 +287,6 @@
 
         if (A.isZero())
         {
-//            return new SecT409K1Point(curve, A, curve.getB().sqrt(), withCompression);
             return new SecT409K1Point(curve, A, curve.getB(), withCompression);
         }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409R1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409R1Point.java
index 078935d..3d3566e 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409R1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT409R1Point.java
@@ -147,7 +147,6 @@
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
             X3 = L.square().add(L).add(X1).addOne();
             if (X3.isZero())
             {
@@ -259,10 +258,7 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = Z1Sq.add(L1Sq).add(L1Z1);
-        ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -284,7 +280,7 @@
 
         ECFieldElement X3 = A.square().multiply(X2Z1Sq);
         ECFieldElement Z3 = A.multiply(B).multiply(Z1Sq);
-        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2plus1, Z3);
+        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2.addOne(), Z3);
 
         return new SecT409R1Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571Field.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571Field.java
index 6836808..554304b 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571Field.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571Field.java
@@ -31,6 +31,14 @@
         }
     }
 
+    public static void addBothTo(long[] x, long[] y, long[] z)
+    {
+        for (int i = 0; i < 9; ++i)
+        {
+            z[i] ^= x[i] ^ y[i];
+        }
+    }
+
     private static void addBothTo(long[] x, int xOff, long[] y, int yOff, long[] z, int zOff)
     {
         for (int i = 0; i < 9; ++i)
@@ -130,6 +138,46 @@
         addExt(zz, tt, zz);
     }
 
+    public static void multiplyPrecomp(long[] x, long[] precomp, long[] z)
+    {
+        long[] tt = Nat576.createExt64();
+        implMultiplyPrecomp(x, precomp, tt);
+        reduce(tt, z);
+    }
+
+    public static void multiplyPrecompAddToExt(long[] x, long[] precomp, long[] zz)
+    {
+        long[] tt = Nat576.createExt64();
+        implMultiplyPrecomp(x, precomp, tt);
+        addExt(zz, tt, zz);
+    }
+
+    public static long[] precompMultiplicand(long[] x)
+    {
+        /*
+         * Precompute table of all 4-bit products of x (first section)
+         */
+        int len = 9 << 4;
+        long[] t = new long[len << 1];
+        System.arraycopy(x, 0, t, 9, 9);
+//        reduce5(T0, 9);
+        int tOff = 0;
+        for (int i = 7; i > 0; --i)
+        {
+            tOff += 18;
+            Nat.shiftUpBit64(9, t, tOff >>> 1, 0L, t, tOff);
+            reduce5(t, tOff);
+            add(t, 9, t, tOff, t, tOff + 9);
+        }
+
+        /*
+         * Second section with all 4-bit products of B shifted 4 bits
+         */
+        Nat.shiftUpBits64(len, t, 0, 4, 0L, t, len);
+
+        return t;
+    }
+
     public static void reduce(long[] xx, long[] z)
     {
         long xx09 = xx[9];
@@ -226,27 +274,13 @@
 //            implMulwAcc(x, y[i], zz, i);
 //        }
 
-        /*
-         * Precompute table of all 4-bit products of y
-         */
-        long[] T0 = new long[9 << 4];
-        System.arraycopy(y, 0, T0, 9, 9);
-//        reduce5(T0, 9);
-        int tOff = 0;
-        for (int i = 7; i > 0; --i)
-        {
-            tOff += 18;
-            Nat.shiftUpBit64(9, T0, tOff >>> 1, 0L, T0, tOff);
-            reduce5(T0, tOff);
-            add(T0, 9, T0, tOff, T0, tOff + 9);
-        }
+        long[] precomp = precompMultiplicand(y);
+        
+        implMultiplyPrecomp(x, precomp, zz);
+    }
 
-        /*
-         * Second table with all 4-bit products of B shifted 4 bits
-         */
-        long[] T1 = new long[T0.length];
-        Nat.shiftUpBits64(T0.length, T0, 0, 4, 0L, T1, 0);
-
+    protected static void implMultiplyPrecomp(long[] x, long[] precomp, long[] zz)
+    {
         int MASK = 0xF;
 
         /*
@@ -260,7 +294,7 @@
                 int aVal = (int)(x[j] >>> k);
                 int u = aVal & MASK;
                 int v = (aVal >>> 4) & MASK;
-                addBothTo(T0, 9 * u, T1, 9 * v, zz, j - 1);
+                addBothTo(precomp, 9 * u, precomp, 9 * (v + 16), zz, j - 1);
             }
             Nat.shiftUpBits64(16, zz, 0, 8, 0L);
         }
@@ -272,7 +306,7 @@
                 int aVal = (int)(x[j] >>> k);
                 int u = aVal & MASK;
                 int v = (aVal >>> 4) & MASK;
-                addBothTo(T0, 9 * u, T1, 9 * v, zz, j);
+                addBothTo(precomp, 9 * u, precomp, 9 * (v + 16), zz, j);
             }
             if (k > 0)
             {
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571K1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571K1Point.java
index c9238cd..8f1c4ca 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571K1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571K1Point.java
@@ -5,6 +5,7 @@
 import org.bouncycastle.math.ec.ECFieldElement;
 import org.bouncycastle.math.ec.ECPoint;
 import org.bouncycastle.math.ec.ECPoint.AbstractF2m;
+import org.bouncycastle.math.raw.Nat576;
 
 public class SecT571K1Point extends AbstractF2m
 {
@@ -91,8 +92,8 @@
 
         ECCurve curve = this.getCurve();
 
-        ECFieldElement X1 = this.x;
-        ECFieldElement X2 = b.getRawXCoord();
+        SecT571FieldElement X1 = (SecT571FieldElement)this.x;
+        SecT571FieldElement X2 = (SecT571FieldElement)b.getRawXCoord();
 
         if (X1.isZero())
         {
@@ -104,31 +105,49 @@
             return b.add(this);
         }
 
-        ECFieldElement L1 = this.y, Z1 = this.zs[0];
-        ECFieldElement L2 = b.getRawYCoord(), Z2 = b.getZCoord(0);
+        SecT571FieldElement L1 = (SecT571FieldElement)this.y, Z1 = (SecT571FieldElement)this.zs[0];
+        SecT571FieldElement L2 = (SecT571FieldElement)b.getRawYCoord(), Z2 = (SecT571FieldElement)b.getZCoord(0);
 
-        boolean Z1IsOne = Z1.isOne();
-        ECFieldElement U2 = X2, S2 = L2;
-        if (!Z1IsOne)
+        long[] t1 = Nat576.create64();
+        long[] t2 = Nat576.create64();
+        long[] t3 = Nat576.create64();
+        long[] t4 = Nat576.create64();
+
+        long[] Z1Precomp = Z1.isOne() ? null : SecT571Field.precompMultiplicand(Z1.x);
+        long[] U2, S2;
+        if (Z1Precomp == null)
         {
-            U2 = U2.multiply(Z1);
-            S2 = S2.multiply(Z1);
+            U2 = X2.x;
+            S2 = L2.x;
+        }
+        else
+        {
+            SecT571Field.multiplyPrecomp(X2.x, Z1Precomp, U2 = t2);
+            SecT571Field.multiplyPrecomp(L2.x, Z1Precomp, S2 = t4);
         }
 
-        boolean Z2IsOne = Z2.isOne();
-        ECFieldElement U1 = X1, S1 = L1;
-        if (!Z2IsOne)
+        long[] Z2Precomp = Z2.isOne() ? null : SecT571Field.precompMultiplicand(Z2.x);
+        long[] U1, S1;
+        if (Z2Precomp == null)
         {
-            U1 = U1.multiply(Z2);
-            S1 = S1.multiply(Z2);
+            U1 = X1.x;
+            S1 = L1.x;
+        }
+        else
+        {
+            SecT571Field.multiplyPrecomp(X1.x, Z2Precomp, U1 = t1);
+            SecT571Field.multiplyPrecomp(L1.x, Z2Precomp, S1 = t3);
         }
 
-        ECFieldElement A = S1.add(S2);
-        ECFieldElement B = U1.add(U2);
+        long[] A = t3;
+        SecT571Field.add(S1, S2, A);
 
-        if (B.isZero())
+        long[] B = t4;
+        SecT571Field.add(U1, U2, B);
+
+        if (Nat576.isZero64(B))
         {
-            if (A.isZero())
+            if (Nat576.isZero64(A))
             {
                 return twice();
             }
@@ -136,55 +155,69 @@
             return curve.getInfinity();
         }
 
-        ECFieldElement X3, L3, Z3;
+        SecT571FieldElement X3, L3, Z3;
         if (X2.isZero())
         {
             // TODO This can probably be optimized quite a bit
             ECPoint p = this.normalize();
-            X1 = p.getXCoord();
+            X1 = (SecT571FieldElement)p.getXCoord();
             ECFieldElement Y1 = p.getYCoord();
 
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
-            X3 = L.square().add(L).add(X1).addOne();
+            X3 = (SecT571FieldElement)L.square().add(L).add(X1);
             if (X3.isZero())
             {
-//                return new SecT571K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT571K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
             ECFieldElement Y3 = L.multiply(X1.add(X3)).add(X3).add(Y1);
-            L3 = Y3.divide(X3).add(X3);
-            Z3 = curve.fromBigInteger(ECConstants.ONE);
+            L3 = (SecT571FieldElement)Y3.divide(X3).add(X3);
+            Z3 = (SecT571FieldElement)curve.fromBigInteger(ECConstants.ONE);
         }
         else
         {
-            B = B.square();
+            SecT571Field.square(B, B);
 
-            ECFieldElement AU1 = A.multiply(U1);
-            ECFieldElement AU2 = A.multiply(U2);
+            long[] APrecomp = SecT571Field.precompMultiplicand(A);
 
-            X3 = AU1.multiply(AU2);
+            long[] AU1 = t1;
+            long[] AU2 = t2;
+
+            SecT571Field.multiplyPrecomp(U1, APrecomp, AU1);
+            SecT571Field.multiplyPrecomp(U2, APrecomp, AU2);
+
+            X3 = new SecT571FieldElement(t1);
+            SecT571Field.multiply(AU1, AU2, X3.x);
+
             if (X3.isZero())
             {
-//                return new SecT571K1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT571K1Point(curve, X3, curve.getB(), this.withCompression);
             }
 
-            ECFieldElement ABZ2 = A.multiply(B);
-            if (!Z2IsOne)
+            Z3 = new SecT571FieldElement(t3);
+            SecT571Field.multiplyPrecomp(B, APrecomp, Z3.x);
+
+            if (Z2Precomp != null)
             {
-                ABZ2 = ABZ2.multiply(Z2);
+                SecT571Field.multiplyPrecomp(Z3.x, Z2Precomp, Z3.x);
             }
 
-            L3 = AU2.add(B).squarePlusProduct(ABZ2, L1.add(Z1));
+            long[] tt = Nat576.createExt64();
 
-            Z3 = ABZ2;
-            if (!Z1IsOne)
+            SecT571Field.add(AU2, B, t4);
+            SecT571Field.squareAddToExt(t4, tt);
+
+            SecT571Field.add(L1.x, Z1.x, t4);
+            SecT571Field.multiplyAddToExt(t4, Z3.x, tt);
+
+            L3 = new SecT571FieldElement(t4);
+            SecT571Field.reduce(tt, L3.x);
+
+            if (Z1Precomp != null)
             {
-                Z3 = Z3.multiply(Z1);
+                SecT571Field.multiplyPrecomp(Z3.x, Z1Precomp, Z3.x);
             }
         }
 
@@ -224,7 +257,6 @@
 
         if (T.isZero())
         {
-//            return new SecT571K1Point(curve, T, curve.getB().sqrt(), withCompression);
             return new SecT571K1Point(curve, T, curve.getB(), withCompression);
         }
 
@@ -273,10 +305,8 @@
         ECFieldElement Z1Sq = Z1.square();
         ECFieldElement L1Z1 = L1.multiply(Z1);
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
         ECFieldElement T = L1Sq.add(L1Z1);
         ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement A = L2plus1.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
         ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
         ECFieldElement B = X2Z1Sq.add(T).square();
@@ -293,7 +323,6 @@
 
         if (A.isZero())
         {
-//            return new SecT571K1Point(curve, A, curve.getB().sqrt(), withCompression);
             return new SecT571K1Point(curve, A, curve.getB(), withCompression);
         }
 
diff --git a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571R1Point.java b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571R1Point.java
index 921828f..71766d6 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571R1Point.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/ec/custom/sec/SecT571R1Point.java
@@ -5,6 +5,8 @@
 import org.bouncycastle.math.ec.ECFieldElement;
 import org.bouncycastle.math.ec.ECPoint;
 import org.bouncycastle.math.ec.ECPoint.AbstractF2m;
+import org.bouncycastle.math.raw.Nat;
+import org.bouncycastle.math.raw.Nat576;
 
 public class SecT571R1Point extends AbstractF2m
 {
@@ -91,8 +93,8 @@
 
         ECCurve curve = this.getCurve();
 
-        ECFieldElement X1 = this.x;
-        ECFieldElement X2 = b.getRawXCoord();
+        SecT571FieldElement X1 = (SecT571FieldElement)this.x;
+        SecT571FieldElement X2 = (SecT571FieldElement)b.getRawXCoord();
 
         if (X1.isZero())
         {
@@ -104,31 +106,49 @@
             return b.add(this);
         }
 
-        ECFieldElement L1 = this.y, Z1 = this.zs[0];
-        ECFieldElement L2 = b.getRawYCoord(), Z2 = b.getZCoord(0);
+        SecT571FieldElement L1 = (SecT571FieldElement)this.y, Z1 = (SecT571FieldElement)this.zs[0];
+        SecT571FieldElement L2 = (SecT571FieldElement)b.getRawYCoord(), Z2 = (SecT571FieldElement)b.getZCoord(0);
 
-        boolean Z1IsOne = Z1.isOne();
-        ECFieldElement U2 = X2, S2 = L2;
-        if (!Z1IsOne)
+        long[] t1 = Nat576.create64();
+        long[] t2 = Nat576.create64();
+        long[] t3 = Nat576.create64();
+        long[] t4 = Nat576.create64();
+
+        long[] Z1Precomp = Z1.isOne() ? null : SecT571Field.precompMultiplicand(Z1.x);
+        long[] U2, S2;
+        if (Z1Precomp == null)
         {
-            U2 = U2.multiply(Z1);
-            S2 = S2.multiply(Z1);
+            U2 = X2.x;
+            S2 = L2.x;
+        }
+        else
+        {
+            SecT571Field.multiplyPrecomp(X2.x, Z1Precomp, U2 = t2);
+            SecT571Field.multiplyPrecomp(L2.x, Z1Precomp, S2 = t4);
         }
 
-        boolean Z2IsOne = Z2.isOne();
-        ECFieldElement U1 = X1, S1 = L1;
-        if (!Z2IsOne)
+        long[] Z2Precomp = Z2.isOne() ? null : SecT571Field.precompMultiplicand(Z2.x);
+        long[] U1, S1;
+        if (Z2Precomp == null)
         {
-            U1 = U1.multiply(Z2);
-            S1 = S1.multiply(Z2);
+            U1 = X1.x;
+            S1 = L1.x;
+        }
+        else
+        {
+            SecT571Field.multiplyPrecomp(X1.x, Z2Precomp, U1 = t1);
+            SecT571Field.multiplyPrecomp(L1.x, Z2Precomp, S1 = t3);
         }
 
-        ECFieldElement A = S1.add(S2);
-        ECFieldElement B = U1.add(U2);
+        long[] A = t3;
+        SecT571Field.add(S1, S2, A);
 
-        if (B.isZero())
+        long[] B = t4;
+        SecT571Field.add(U1, U2, B);
+
+        if (Nat576.isZero64(B))
         {
-            if (A.isZero())
+            if (Nat576.isZero64(A))
             {
                 return twice();
             }
@@ -136,55 +156,69 @@
             return curve.getInfinity();
         }
 
-        ECFieldElement X3, L3, Z3;
+        SecT571FieldElement X3, L3, Z3;
         if (X2.isZero())
         {
             // TODO This can probably be optimized quite a bit
             ECPoint p = this.normalize();
-            X1 = p.getXCoord();
+            X1 = (SecT571FieldElement)p.getXCoord();
             ECFieldElement Y1 = p.getYCoord();
 
             ECFieldElement Y2 = L2;
             ECFieldElement L = Y1.add(Y2).divide(X1);
 
-//            X3 = L.square().add(L).add(X1).add(curve.getA());
-            X3 = L.square().add(L).add(X1).addOne();
+            X3 = (SecT571FieldElement)L.square().add(L).add(X1).addOne();
             if (X3.isZero())
             {
-//                return new SecT571R1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT571R1Point(curve, X3, SecT571R1Curve.SecT571R1_B_SQRT, this.withCompression);
             }
 
             ECFieldElement Y3 = L.multiply(X1.add(X3)).add(X3).add(Y1);
-            L3 = Y3.divide(X3).add(X3);
-            Z3 = curve.fromBigInteger(ECConstants.ONE);
+            L3 = (SecT571FieldElement)Y3.divide(X3).add(X3);
+            Z3 = (SecT571FieldElement)curve.fromBigInteger(ECConstants.ONE);
         }
         else
         {
-            B = B.square();
+            SecT571Field.square(B, B);
 
-            ECFieldElement AU1 = A.multiply(U1);
-            ECFieldElement AU2 = A.multiply(U2);
+            long[] APrecomp = SecT571Field.precompMultiplicand(A);
 
-            X3 = AU1.multiply(AU2);
+            long[] AU1 = t1;
+            long[] AU2 = t2;
+
+            SecT571Field.multiplyPrecomp(U1, APrecomp, AU1);
+            SecT571Field.multiplyPrecomp(U2, APrecomp, AU2);
+
+            X3 = new SecT571FieldElement(t1);
+            SecT571Field.multiply(AU1, AU2, X3.x);
+
             if (X3.isZero())
             {
-//                return new SecT571R1Point(curve, X3, curve.getB().sqrt(), this.withCompression);
                 return new SecT571R1Point(curve, X3, SecT571R1Curve.SecT571R1_B_SQRT, this.withCompression);
             }
 
-            ECFieldElement ABZ2 = A.multiply(B);
-            if (!Z2IsOne)
+            Z3 = new SecT571FieldElement(t3);
+            SecT571Field.multiplyPrecomp(B, APrecomp, Z3.x);
+
+            if (Z2Precomp != null)
             {
-                ABZ2 = ABZ2.multiply(Z2);
+                SecT571Field.multiplyPrecomp(Z3.x, Z2Precomp, Z3.x);
             }
 
-            L3 = AU2.add(B).squarePlusProduct(ABZ2, L1.add(Z1));
+            long[] tt = Nat576.createExt64();
 
-            Z3 = ABZ2;
-            if (!Z1IsOne)
+            SecT571Field.add(AU2, B, t4);
+            SecT571Field.squareAddToExt(t4, tt);
+
+            SecT571Field.add(L1.x, Z1.x, t4);
+            SecT571Field.multiplyAddToExt(t4, Z3.x, tt);
+
+            L3 = new SecT571FieldElement(t4);
+            SecT571Field.reduce(tt, L3.x);
+
+            if (Z1Precomp != null)
             {
-                Z3 = Z3.multiply(Z1);
+                SecT571Field.multiplyPrecomp(Z3.x, Z1Precomp, Z3.x);
             }
         }
 
@@ -200,30 +234,66 @@
 
         ECCurve curve = this.getCurve();
 
-        ECFieldElement X1 = this.x;
+        SecT571FieldElement X1 = (SecT571FieldElement)this.x;
         if (X1.isZero())
         {
             // A point with X == 0 is it's own additive inverse
             return curve.getInfinity();
         }
 
-        ECFieldElement L1 = this.y, Z1 = this.zs[0];
+        SecT571FieldElement L1 = (SecT571FieldElement)this.y, Z1 = (SecT571FieldElement)this.zs[0];
 
-        boolean Z1IsOne = Z1.isOne();
-        ECFieldElement L1Z1 = Z1IsOne ? L1 : L1.multiply(Z1);
-        ECFieldElement Z1Sq = Z1IsOne ? Z1 : Z1.square();
-        ECFieldElement T = L1.square().add(L1Z1).add(Z1Sq);
-        if (T.isZero())
+        long[] t1 = Nat576.create64();
+        long[] t2 = Nat576.create64();
+
+        long[] Z1Precomp = Z1.isOne() ? null : SecT571Field.precompMultiplicand(Z1.x);
+        long[] L1Z1, Z1Sq;
+        if (Z1Precomp == null)
         {
-//            return new SecT571R1Point(curve, T, curve.getB().sqrt(), withCompression);
-            return new SecT571R1Point(curve, T, SecT571R1Curve.SecT571R1_B_SQRT, withCompression);
+            L1Z1 = L1.x;
+            Z1Sq = Z1.x;
+        }
+        else
+        {
+            SecT571Field.multiplyPrecomp(L1.x, Z1Precomp, L1Z1 = t1);
+            SecT571Field.square(Z1.x, Z1Sq = t2);
         }
 
-        ECFieldElement X3 = T.square();
-        ECFieldElement Z3 = Z1IsOne ? T : T.multiply(Z1Sq);
+        long[] T = Nat576.create64();
+        SecT571Field.square(L1.x, T);
+        SecT571Field.addBothTo(L1Z1, Z1Sq, T);
 
-        ECFieldElement X1Z1 = Z1IsOne ? X1 : X1.multiply(Z1);
-        ECFieldElement L3 = X1Z1.squarePlusProduct(T, L1Z1).add(X3).add(Z3);
+        if (Nat576.isZero64(T))
+        {
+            return new SecT571R1Point(curve, new SecT571FieldElement(T), SecT571R1Curve.SecT571R1_B_SQRT, withCompression);
+        }
+
+        long[] tt = Nat576.createExt64();
+        SecT571Field.multiplyAddToExt(T, L1Z1, tt);
+
+        SecT571FieldElement X3 = new SecT571FieldElement(t1);
+        SecT571Field.square(T, X3.x);
+
+        SecT571FieldElement Z3 = new SecT571FieldElement(T);
+        if (Z1Precomp != null)
+        {
+            SecT571Field.multiply(Z3.x, Z1Sq, Z3.x);
+        }
+
+        long[] X1Z1;
+        if (Z1Precomp == null)
+        {
+            X1Z1 = X1.x;
+        }
+        else
+        {
+            SecT571Field.multiplyPrecomp(X1.x, Z1Precomp, X1Z1 = t2);
+        }
+
+        SecT571Field.squareAddToExt(X1Z1, tt);
+        SecT571Field.reduce(tt, t2);
+        SecT571Field.addBothTo(X3.x, Z3.x, t2);
+        SecT571FieldElement L3 = new SecT571FieldElement(t2);
 
         return new SecT571R1Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
@@ -241,38 +311,63 @@
 
         ECCurve curve = this.getCurve();
 
-        ECFieldElement X1 = this.x;
+        SecT571FieldElement X1 = (SecT571FieldElement)this.x;
         if (X1.isZero())
         {
             // A point with X == 0 is it's own additive inverse
             return b;
         }
 
-        ECFieldElement X2 = b.getRawXCoord(), Z2 = b.getZCoord(0);
+        SecT571FieldElement X2 = (SecT571FieldElement)b.getRawXCoord(), Z2 = (SecT571FieldElement)b.getZCoord(0);
         if (X2.isZero() || !Z2.isOne())
         {
             return twice().add(b);
         }
 
-        ECFieldElement L1 = this.y, Z1 = this.zs[0];
-        ECFieldElement L2 = b.getRawYCoord();
+        SecT571FieldElement L1 = (SecT571FieldElement)this.y, Z1 = (SecT571FieldElement)this.zs[0];
+        SecT571FieldElement L2 = (SecT571FieldElement)b.getRawYCoord();
 
-        ECFieldElement X1Sq = X1.square();
-        ECFieldElement L1Sq = L1.square();
-        ECFieldElement Z1Sq = Z1.square();
-        ECFieldElement L1Z1 = L1.multiply(Z1);
+        long[] t1 = Nat576.create64();
+        long[] t2 = Nat576.create64();
+        long[] t3 = Nat576.create64();
+        long[] t4 = Nat576.create64();
 
-//        ECFieldElement T = curve.getA().multiply(Z1Sq).add(L1Sq).add(L1Z1);
-        ECFieldElement T = Z1Sq.add(L1Sq).add(L1Z1);
-        ECFieldElement L2plus1 = L2.addOne();
-//        ECFieldElement A = curve.getA().add(L2plus1).multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
-        ECFieldElement A = L2.multiply(Z1Sq).add(L1Sq).multiplyPlusProduct(T, X1Sq, Z1Sq);
-        ECFieldElement X2Z1Sq = X2.multiply(Z1Sq);
-        ECFieldElement B = X2Z1Sq.add(T).square();
+        long[] X1Sq = t1;
+        SecT571Field.square(X1.x, X1Sq);
 
-        if (B.isZero())
+        long[] L1Sq = t2;
+        SecT571Field.square(L1.x, L1Sq);
+
+        long[] Z1Sq = t3;
+        SecT571Field.square(Z1.x, Z1Sq);
+
+        long[] L1Z1 = t4;
+        SecT571Field.multiply(L1.x, Z1.x, L1Z1);
+
+        long[] T = L1Z1;
+        SecT571Field.addBothTo(Z1Sq, L1Sq, T);
+
+        long[] Z1SqPrecomp = SecT571Field.precompMultiplicand(Z1Sq);
+
+        long[] A = t3;
+        SecT571Field.multiplyPrecomp(L2.x, Z1SqPrecomp, A);
+        SecT571Field.add(A, L1Sq, A);
+
+        long[] tt = Nat576.createExt64();
+        SecT571Field.multiplyAddToExt(A, T, tt);
+        SecT571Field.multiplyPrecompAddToExt(X1Sq, Z1SqPrecomp, tt);
+        SecT571Field.reduce(tt, A);
+
+        long[] X2Z1Sq = t1;
+        SecT571Field.multiplyPrecomp(X2.x, Z1SqPrecomp, X2Z1Sq);
+
+        long[] B = t2;
+        SecT571Field.add(X2Z1Sq, T, B);
+        SecT571Field.square(B, B);
+
+        if (Nat576.isZero64(B))
         {
-            if (A.isZero())
+            if (Nat576.isZero64(A))
             {
                 return b.twice();
             }
@@ -280,15 +375,28 @@
             return curve.getInfinity();
         }
 
-        if (A.isZero())
+        if (Nat576.isZero64(A))
         {
-//            return new SecT571R1Point(curve, A, curve.getB().sqrt(), withCompression);
-            return new SecT571R1Point(curve, A, SecT571R1Curve.SecT571R1_B_SQRT, withCompression);
+            return new SecT571R1Point(curve, new SecT571FieldElement(A), SecT571R1Curve.SecT571R1_B_SQRT, withCompression);
         }
 
-        ECFieldElement X3 = A.square().multiply(X2Z1Sq);
-        ECFieldElement Z3 = A.multiply(B).multiply(Z1Sq);
-        ECFieldElement L3 = A.add(B).square().multiplyPlusProduct(T, L2plus1, Z3);
+        SecT571FieldElement X3 = new SecT571FieldElement();
+        SecT571Field.square(A, X3.x);
+        SecT571Field.multiply(X3.x, X2Z1Sq, X3.x);
+
+        SecT571FieldElement Z3 = new SecT571FieldElement(t1);
+        SecT571Field.multiply(A, B, Z3.x);
+        SecT571Field.multiplyPrecomp(Z3.x, Z1SqPrecomp, Z3.x);
+
+        SecT571FieldElement L3 = new SecT571FieldElement(t2);
+        SecT571Field.add(A, B, L3.x);
+        SecT571Field.square(L3.x, L3.x);
+
+        Nat.zero64(18, tt);
+        SecT571Field.multiplyAddToExt(L3.x, T, tt);
+        SecT571Field.addOne(L2.x, t4);
+        SecT571Field.multiplyAddToExt(t4, Z3.x, tt);
+        SecT571Field.reduce(tt, L3.x);
 
         return new SecT571R1Point(curve, X3, L3, new ECFieldElement[]{ Z3 }, this.withCompression);
     }
diff --git a/bcprov/src/main/java/org/bouncycastle/math/raw/Nat.java b/bcprov/src/main/java/org/bouncycastle/math/raw/Nat.java
index 2057c8b..6b77f8f 100644
--- a/bcprov/src/main/java/org/bouncycastle/math/raw/Nat.java
+++ b/bcprov/src/main/java/org/bouncycastle/math/raw/Nat.java
@@ -1075,4 +1075,12 @@
             z[i] = 0;
         }
     }
+
+    public static void zero64(int len, long[] z)
+    {
+        for (int i = 0; i < len; ++i)
+        {
+            z[i] = 0L;
+        }
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/ExchangePairGenerator.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/ExchangePairGenerator.java
index 6993899..5909dab 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/ExchangePairGenerator.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/ExchangePairGenerator.java
@@ -12,6 +12,15 @@
      *
      * @param senderPublicKey the public key of the exchange initiator.
      * @return An ExchangePair derived from the sender public key.
+     * @deprecated use generateExchange
      */
     ExchangePair GenerateExchange(AsymmetricKeyParameter senderPublicKey);
+
+    /**
+     * Generate an exchange pair based on the sender public key.
+     *
+     * @param senderPublicKey the public key of the exchange initiator.
+     * @return An ExchangePair derived from the sender public key.
+     */
+    ExchangePair generateExchange(AsymmetricKeyParameter senderPublicKey);
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/mceliece/McElieceCCA2PrivateKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/mceliece/McElieceCCA2PrivateKeyParameters.java
index ed5bea8..c83a8e2 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/mceliece/McElieceCCA2PrivateKeyParameters.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/mceliece/McElieceCCA2PrivateKeyParameters.java
@@ -45,20 +45,37 @@
      * @param field  the finite field <tt>GF(2<sup>m</sup>)</tt>
      * @param gp     the irreducible Goppa polynomial
      * @param p      the permutation
-     * @param digest McElieceCCA2Parameters
+     * @param digest name of digest algorithm
      */
     public McElieceCCA2PrivateKeyParameters(int n, int k, GF2mField field,
                                             PolynomialGF2mSmallM gp, Permutation p, String digest)
     {
+        this(n, k, field, gp, GoppaCode.createCanonicalCheckMatrix(field, gp), p, digest);
+    }
+    
+    /**
+     * Constructor.
+     *
+     * @param n                         the length of the code
+     * @param k                         the dimension of the code
+     * @param field                     the finite field <tt>GF(2<sup>m</sup>)</tt>
+     * @param gp                        the irreducible Goppa polynomial
+     * @param canonicalCheckMatrix      the canonical check matrix
+     * @param p                         the permutation
+     * @param digest                    name of digest algorithm
+     */
+    public McElieceCCA2PrivateKeyParameters(int n, int k, GF2mField field, PolynomialGF2mSmallM gp, 
+                                            GF2Matrix canonicalCheckMatrix, Permutation p, String digest)
+    {
         super(true, digest);
+        
         this.n = n;
         this.k = k;
         this.field = field;
         this.goppaPoly = gp;
+        this.h = canonicalCheckMatrix;
         this.p = p;
-
-        this.h = GoppaCode.createCanonicalCheckMatrix(field, gp);
-
+        
         PolynomialRingGF2m ring = new PolynomialRingGF2m(field, gp);
 
         // matrix for computing square roots in (GF(2^m))^t
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/newhope/NHExchangePairGenerator.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/newhope/NHExchangePairGenerator.java
index 7c9f38d..678e93a 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/newhope/NHExchangePairGenerator.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/newhope/NHExchangePairGenerator.java
@@ -18,6 +18,11 @@
 
     public ExchangePair GenerateExchange(AsymmetricKeyParameter senderPublicKey)
     {
+        return generateExchange(senderPublicKey);
+    }
+
+    public ExchangePair generateExchange(AsymmetricKeyParameter senderPublicKey)
+    {
         NHPublicKeyParameters pubKey = (NHPublicKeyParameters)senderPublicKey;
 
         byte[] sharedValue = new byte[NewHope.AGREEMENT_SIZE];
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/AllTests.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/AllTests.java
index e99242d..3c2df4b 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/AllTests.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/AllTests.java
@@ -26,6 +26,17 @@
         suite.addTestSuite(NTRUSignatureKeyTest.class);
         suite.addTestSuite(NTRUSignerTest.class);
         suite.addTestSuite(NTRUSigningParametersTest.class);
+        suite.addTestSuite(XMSSMTPrivateKeyTest.class);
+        suite.addTestSuite(XMSSMTPublicKeyTest.class);
+        suite.addTestSuite(XMSSMTSignatureTest.class);
+        suite.addTestSuite(XMSSMTTest.class);
+        suite.addTestSuite(XMSSOidTest.class);
+        suite.addTestSuite(XMSSPrivateKeyTest.class);
+        suite.addTestSuite(XMSSPublicKeyTest.class);
+        suite.addTestSuite(XMSSReducedSignatureTest.class);
+        suite.addTestSuite(XMSSSignatureTest.class);
+        suite.addTestSuite(XMSSTest.class);
+        suite.addTestSuite(XMSSUtilTest.class);
         suite.addTestSuite(AllTests.SimpleTestTest.class);
 
         return new BCTestSetup(suite);
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/BitStringTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/BitStringTest.java
index 85e1ffa..d5132db 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/BitStringTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/BitStringTest.java
@@ -85,4 +85,4 @@
         System.arraycopy(src, 0, tmp, 0, tmp.length > src.length ? src.length : tmp.length);
         return tmp;
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/EncryptionKeyTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/EncryptionKeyTest.java
index f023406..976f8af 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/EncryptionKeyTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/EncryptionKeyTest.java
@@ -6,8 +6,8 @@
 
 import junit.framework.TestCase;
 import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
-import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionKeyPairGenerator;
 import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionKeyGenerationParameters;
+import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionKeyPairGenerator;
 import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionPrivateKeyParameters;
 import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionPublicKeyParameters;
 
@@ -48,4 +48,4 @@
         assertEquals(kp.getPublic(), kp3.getPublic());
         assertEquals(kp.getPrivate(), kp3.getPrivate());
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptTest.java
index df63a10..e079b7d 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptTest.java
@@ -7,11 +7,11 @@
 import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
 import org.bouncycastle.crypto.DataLengthException;
 import org.bouncycastle.crypto.InvalidCipherTextException;
-import org.bouncycastle.pqc.crypto.ntru.NTRUEngine;
-import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionKeyPairGenerator;
 import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionKeyGenerationParameters;
+import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionKeyPairGenerator;
 import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionPrivateKeyParameters;
 import org.bouncycastle.pqc.crypto.ntru.NTRUEncryptionPublicKeyParameters;
+import org.bouncycastle.pqc.crypto.ntru.NTRUEngine;
 import org.bouncycastle.pqc.crypto.ntru.NTRUParameters;
 import org.bouncycastle.pqc.math.ntru.polynomial.DenseTernaryPolynomial;
 import org.bouncycastle.pqc.math.ntru.polynomial.IntegerPolynomial;
@@ -295,4 +295,4 @@
             return super.decrypt(e, priv_t, priv_fp);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptionParametersTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptionParametersTest.java
index 54f53ad..4b2c8be 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptionParametersTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUEncryptionParametersTest.java
@@ -45,4 +45,4 @@
         params = NTRUEncryptionKeyGenerationParameters.APR2011_439_FAST;
         assertEquals(params, params.clone());
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureKeyTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureKeyTest.java
index 509839a..c9150ac 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureKeyTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureKeyTest.java
@@ -55,4 +55,4 @@
         assertEquals(kPub, kp3.getPublic());
         assertEquals(kPriv, kp3.getPrivate());
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureParametersTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureParametersTest.java
index 4c5751e..a5f7604 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureParametersTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignatureParametersTest.java
@@ -61,4 +61,4 @@
             assertEquals(params, params.clone());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignerTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignerTest.java
index 3a765af..06edc60 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignerTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSignerTest.java
@@ -314,4 +314,4 @@
         }
     }
     */
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSigningParametersTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSigningParametersTest.java
index 7cf7de8..5279312 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSigningParametersTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NTRUSigningParametersTest.java
@@ -62,4 +62,4 @@
             assertEquals(params, params.clone());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NewHopeTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NewHopeTest.java
index e0d63ad..d039f50 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NewHopeTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/NewHopeTest.java
@@ -101,7 +101,7 @@
 
             NHExchangePairGenerator exchGen = new NHExchangePairGenerator(bobRand);
 
-            ExchangePair bobExchPair = exchGen.GenerateExchange(aliceKp.getPublic());
+            ExchangePair bobExchPair = exchGen.generateExchange(aliceKp.getPublic());
 
             NHAgreement agreement = new NHAgreement();
 
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTPrivateKeyTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTPrivateKeyTest.java
new file mode 100644
index 0000000..ec5cbe7
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTPrivateKeyTest.java
@@ -0,0 +1,33 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.text.ParseException;
+
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMT;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+import junit.framework.TestCase;
+
+/**
+ * Test cases for XMSSMTPrivateKey class.
+ * 
+ */
+public class XMSSMTPrivateKeyTest extends TestCase {
+
+	public void testPrivateKeyParsingSHA256() throws IOException, ClassNotFoundException {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new SecureRandom());
+		XMSSMT mt = new XMSSMT(params);
+		mt.generateKeys();
+		byte[] privateKey = mt.exportPrivateKey();
+		byte[] publicKey = mt.exportPublicKey();
+		try {
+			mt.importState(privateKey, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		assertTrue(XMSSUtil.compareByteArray(privateKey, mt.exportPrivateKey()));
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTPublicKeyTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTPublicKeyTest.java
new file mode 100644
index 0000000..41b5160
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTPublicKeyTest.java
@@ -0,0 +1,51 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.text.ParseException;
+
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMT;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTPublicKeyParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+import junit.framework.TestCase;
+
+/**
+ * Test cases for XMSSMTPublicKey class.
+ * 
+ */
+public class XMSSMTPublicKeyTest extends TestCase {
+
+	public void testPublicKeyParsingSHA256() throws IOException, ClassNotFoundException {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new SecureRandom());
+		XMSSMT mt = new XMSSMT(params);
+		mt.generateKeys();
+		byte[] privateKey = mt.exportPrivateKey();
+		byte[] publicKey = mt.exportPublicKey();
+
+		try {
+			mt.importState(privateKey, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		assertTrue(XMSSUtil.compareByteArray(publicKey, mt.exportPublicKey()));
+	}
+
+	public void testConstructor() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMTPublicKeyParameters pk = null;
+		try {
+			pk = new XMSSMTPublicKeyParameters.Builder(params).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+		}
+		byte[] pkByte = pk.toByteArray();
+		/* check everything is 0 */
+		for (int i = 0; i < pkByte.length; i++) {
+			assertEquals(0x00, pkByte[i]);
+		}
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTSignatureTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTSignatureTest.java
new file mode 100644
index 0000000..a38530f
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTSignatureTest.java
@@ -0,0 +1,51 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.text.ParseException;
+
+import junit.framework.TestCase;
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMT;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTSignature;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * Test cases for XMSS^MT signature class.
+ */
+public class XMSSMTSignatureTest extends TestCase {
+
+	public void testSignatureParsingSHA256() {
+		int totalHeight = 6;
+		int layers = 3;
+		byte[] message = new byte[1024];
+		XMSSMTParameters params = new XMSSMTParameters(totalHeight, layers, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] signature1 = xmssMT.sign(message);
+		XMSSMTSignature mtSignature = null;
+		try {
+			mtSignature = new XMSSMTSignature.Builder(params).withSignature(signature1).build();
+			byte[] signature2 = mtSignature.toByteArray();
+			assertTrue(XMSSUtil.compareByteArray(signature1, signature2));
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+	}
+
+	public void testConstructor() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMTSignature sig = null;
+		try {
+			sig = new XMSSMTSignature.Builder(params).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+		}
+		byte[] sigByte = sig.toByteArray();
+		/* check everything is 0 */
+		for (int i = 0; i < sigByte.length; i++) {
+			assertEquals(0x00, sigByte[i]);
+		}
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTTest.java
new file mode 100644
index 0000000..b4041aa
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSMTTest.java
@@ -0,0 +1,518 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.text.ParseException;
+import java.util.Arrays;
+
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMT;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+import org.bouncycastle.util.encoders.Hex;
+
+import junit.framework.TestCase;
+
+/**
+ * Test cases for XMSS^MT class.
+ * 
+ */
+public class XMSSMTTest extends TestCase {
+
+	public void testGenKeyPairSHA256() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] privateKey = xmssMT.exportPrivateKey();
+		byte[] publicKey = xmssMT.exportPublicKey();
+		String expectedPrivateKey = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f5bb70f454d7c7bda84d207c5a0d47211af7b489e839d2294cc8c9d5522a8ae";
+		String expectedPublicKey = "1f5bb70f454d7c7bda84d207c5a0d47211af7b489e839d2294cc8c9d5522a8ae0000000000000000000000000000000000000000000000000000000000000000";
+		byte[] strippedPrivateKey = XMSSUtil.extractBytesAtOffset(privateKey, 0, (Hex.decode(expectedPrivateKey).length));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPrivateKey), strippedPrivateKey));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPublicKey), publicKey));
+	}
+	
+	public void testGenKeyPairSHA512() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA512Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] privateKey = xmssMT.exportPrivateKey();
+		byte[] publicKey = xmssMT.exportPublicKey();
+		String expectedPrivateKey = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e5a47fa691568971bdef45d4c9a7db69fe8a691df7f70a9341e33dba98a215fe9651933da16a3524124dc4c3f1baf35d6f03369ff3800346bbd8c2e179ae4abd";
+		String expectedPublicKey = "e5a47fa691568971bdef45d4c9a7db69fe8a691df7f70a9341e33dba98a215fe9651933da16a3524124dc4c3f1baf35d6f03369ff3800346bbd8c2e179ae4abd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+		byte[] strippedPrivateKey = XMSSUtil.extractBytesAtOffset(privateKey, 0, (Hex.decode(expectedPrivateKey).length));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPrivateKey), strippedPrivateKey));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPublicKey), publicKey));
+	}
+	
+	public void testSignSHA256() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = xmssMT.sign(message);
+		byte[] sig2 = xmssMT.sign(message);
+		byte[] sig3 = xmssMT.sign(message);
+		String expectedSig1 = "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";
+		String expectedSig2 = "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";
+		String expectedSig3 = "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";
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig1), sig1));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig2), sig2));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig3), sig3));
+	}
+	
+	public void testSignSHA256Complete1() {
+		final String[] signatures = {
+				"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",
+				"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",
+				"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",
+				"0386edf8472409c6a0fe2f3da07457868477f3f745d6717aec4a4ba8c7ab1647489bbf7a4c5b7b7904296d3be50258e80a4ca6b59a6a22a1c63576ee508e2407cfb66454d3e4fb310c896480822cc3800f0769622463743c17601947db673131d542d7800af123d2ac2d705844b093404f2072dd430f48bdb09438a21119e1b3730ad685a39c4e8c67750bf56795a43d93be6d5d6181d05922a13aa08d95fba85bca65919b91eff118c81038214df51fd883fb56e353334d0e3cdca46afefd63780c4a7919a28e3e827f67951feac797e39e96e7c3ba19196f0f0175b91d5c7c5976a1a1d928fad412c4e2a9cd8c841970fe3055797a5dbdaaf32f4de79602dbe35d0fe38b3f5ee7dbe1f6942ec427d8b15cdeac92278b2a105e647c3ad4916948d22a6df03aad05a9c5f476bc4e70169ab50710c2177cd78598fea88681d34a7e4f9c4cb8ff3fb1dcea06f624c0fc879cc5e307ed78eecc6f9aa44d382016ee472ebe19b30716e55e380065ba32927ca73bfbdad670f191876e671787e859cca6e4c895dda8730a40d0c73b0487ce327eaa9c85815d308ee08ed25cc5f1b48d302eea1568fee7d44f8a40b4496cbcc25b6dd7b199323db3873709c2e6bb8dfc7edc95724b541840a32d6ca4465e335c4bc8fdf5aa5ebdc3b3ad9874954771a734c9bd9ec525c081b95802534cc71cab2d9a3d3bca09403c9d6dfd7d7d35c0e4ba866c9ff837c3d538b270aae8d8152db295b20b7a19e2a3aa383163d9162fdbb7ef5341887a5eb94828253f6977a251607fa2e6853159f0b64d5c8fcde6d18cc6dd02e72f7ed723b74da9f3129230a75980bb9697bbed6475f974c20b12a02ed7313ef4ca5f473774e0e4b5f520cdeb4fed526ea10375656c18b349f984119fe43133794c2c7e2672503f150b5a740c04e3a763af2ee0c3b14de8e0516222ae91bf50b7e5cf92f5cc6df8ffec7584f88a9deea3b5ab4a8d8ba79c42b9bcb028ec911c4c93526315ad80b1efb97e11a692c4160d6f9f6821c0625889b524fe437112df5845df7fe8d9ebf47dd29ec45448dbce81dc4efab911477ed9408cb7a15978f2cdd7b779aacf3a4d4f44d0d87b60e4bd6dc145b0c40fcc6ddfad114281d87b68d4f51e9bcb317ae7436f2cce963a327bda95e9e460ab660696a528c393ed21f92e38402dd50f3d643563214546d0e4037501b3456b4dc5a02d1e4b9b59c18d0c341170d73841ff7ace5c7f1dae32da6bd6f97adf3a52dbdb30a46424abc17a4a89340d3345ebb08fc03a7ad4578a64d1488b879823a35afbda39dd9ee9d0ab8ce94bf864f3cb1105ce74bd99e85b6fdd97fc3c54393ce901e43344d05f31a8376265777b18d853553b95a11f2bb099be5d433fefa7c97b8d3b229e423bcd1832ce5bd731854fd5e31d0ccb4421e4f73f121f4b79404d06786e3318fb337dfed40359c63aa685457ad21b69d365da9ba2cf1e665d02995180df2f35312c4e45c8f3ce7215be2ef053807341c00acab30a0c7dffe8e75fdc71704f35f13de8ac21b6e39482271d036fe5b8fd6020eb0ef06f80490915de57255a3f9a31d2d6750f86ba57ee7320cde75c4a49bd4d5efe393775dafe2f209abfbdf7762c560106006f4905dc938f91bb88a5f3f6c0176e38b4bae238f34b2f1319c2d48a8be83e53959b26e6109f8ac292b9a88cbb51dd3369dca35e58774a9a02d7fa47d47557bdcec261a7fd6dd60437fa9af3324a36ba88c0ac652c3760f5a35a585245a0c5978591b1ff73ac058ed438e359b09feebc290d3d3a5ba3670d62887ee338099e94d14fc40257e36bfec7d5f3b192062a003965acd650f8285c2d9b5a1ba46ac46042b985d5f631188b2fe1a5624a92752d3317d177089b68a35966fa021dd0f8e4acbce56d1643650c64ecba2243431c06d4065cf738e5cb0980da72a35425f568e3e48e9c7b73ec5394e45842607a4fea3be2853ba6bb6b3d27f7af28f0e41cd6b42ae977f09bf4f2a1d594afcb83a2f0ca20c7e442bd7052a9ac85fe67cb537250ce91a255d3b7fe4b2d052312b839aa59d306afadcfd503b303bd2dba7da45ce8dc8eaa303a1f9495038a3e2fb77e4bc35c5399556b58004d9cad13db1c1fe7ad4c66c88882396aa36c267227441cdfdb5a5c89dd23616a7563b5249483ec60e25e36024b5251ed6e0557a7414180b084266c1d731d2e42544513fd2d53d4eb964ba1c67a4e13b192c5e41f5c5b4160e8336a2956c1396e55b2c417fb5855d4aa56dcfc54f8e19c6eebf9eef09ac5c38735090d692b837cd08e50738e106cdb3a5b95314744b8d67bcf40645ab09f1233559173aea688279d0c31cc885227e88bb3e02064762052fa3b0e69f70e44dcb1410ac1fc604f27e86796c6d3819c82d0971df6b5cd89f2403623c4bb252e60af6717d4c2cedcf5dc96015c5b700e7e915e60aab7a1f85bc19e2b6a5307a51988aa1abab57a201a488b7d8f18716f0bf8aafd9c7660dc46a29665836e0aeab04806bd0fc5989c4f63f7ba4a58834d8d5447f70ebf67d33c57ddbee6574d5b741af87217f3c0ffe4f87c48e2d49a274968b87a254eb41e3461dfb92f63bf91f42f43f33f7ce9af91ab8f28d2fba20dd005a1c04633f3c5478b93bf6583f3f7da072dce7ba305b717af5930ff609084e1f4c1e7b2725517188a734e7dfc69db20e4f33408611ebe4dcd039074bed4698035c36336daee42097c826a0352278dfd649d7ce54e5b18060fd25679d745d701d24aa7efffd56419df616dabad7380353034f639a981931fc2e6c2e54414fc3bdfb77c15f5b5181120e745215d126be23f8cc9bf2ecebe045fccd5d3d1e67dbfdccaf54004460e013c27cc86975f3edb844be4d037b07cff57cd14ef994df7541b1650f50d02c77b79d34204fd67c3f2b1649bafabe7bed873702c06d5d0e49d1b372fd3c38453e9bd59d04ff5409825280d38e100f29eccc045ecbb69cc2c9f37f898b2612c524f3809415d3a07297d5264bfd1c8c914b49f8e6088c80bf1700adbdce7bba60518c29485c0a9998d34d2065628eea51d4005b39785ca870e09710e1c93982cf716daa1c350b4dbbaa17a95a2251cf702fdc87c03e410d9ac0062bbc479ad59262cc6bce4048859718988b62e2c4511ed65f659cf8c579a53a6a544a1331bf650758d64bb8fab1104170824894fdd8a284d281aec9d627055bba150d47c43ac58f099040e06ba3fcf42a08dae32984bf4099c6ae94670013f2d14375d9b56e64c069c67ab3e15658c8336d1b7327f83f8e5daee3ddc76b369f3cc354c7a4685852cfd47e4d8724090d5d629ed3c2b672c61f2a0d14c178a4d9eaed7fe9d1de7bac3ea2d8d94148694fe1993770fd56de255b75ae30069d3d93744fe7f82d106a54784329a4c73c548232dbf6bae651655eb3b3f62c85f698f0d86655d01f65d3566c9d2d3fb5942b2e3d846e173417f7a8c57ba38a7fd443eecd76fee81a1520c8e9e660e75b23eb7ece588a577fdfcf06e09ef5c9a99499d52a1310358893639b5b346ee21d1fc2ce91619be31e61c5f7821dde339476055039cc1a8f045434bc512ff74fc75e451aa20c174ee7a5fb6f68604830e72b903c957fa86dead167fe8df5cc67a3411f6e44a2e96ecdcc314cd6f7c6590218da02182c16ea1c87fc258f30e4c3368fb924a6e73738c2e534832855d8ea0cd1c002b8901cb40b66c7e3646b1dc14ed70da0e3d8a120bbc1eb4e4d81003c7ee2464cfa9169b18b5290cb0a443281ef3ec3bd9e6926c778f15320876cef162a07ba8cc6e61216e2a54d45d7a33d361bae1839ca8e62b4b4e4905b216bdccdb167807f137eca3a98a68d2b5e21fb8f0b8bb275f5b551ca77373066a7fbc0b8fff4969ee54e5e4cb946e8d5163e1b65fdca260915b834794419117c2614f0c835522a77a19dc3127378eeff43ba94689b2177801b00f2fac6861bc1b461dee1c53e5861de9a21f5eb45f87dcbfdb8189f972ddc970f98d903e5d08f9f5663cfaf400ccbeaa9777c9ae178583ee09b5a88a6f970d527658322ed87f1c8d2cb1df6007241440221447b6d9307c978cd964d90d076d516f02c258bcf2eaf6e7720ee365fbbd3996342d2edeb87b8ce38abe9b3a51b56f92384c3d8e3ad9770be26a60af23095474a368aecbad10e93b8607500d2553d07b52a3cfb6b9d13d98fb5b5a4916d89849f0f37ae22903676f26a1b2088b4912dd62f17f05f02e45eebe33a0b514412c18a6e39819b3e92f7c2901bb1dfc375e927afe468993400da91c590a19ebe5b8047d2780176b1341928691cd8ef916e2f8bbcee52d02aabe5a1155e186bff3af82245f9c5f24a647662dffb193f3f0a11006a05b7e9fb035e55b4cea67db00a65daa87ad8a64fd37e17150e73cbc0619a09453201789a655884002fd6e93aa49513a914fe5460bc4804158ed90231c811b928b5064c36ca9bd29e8f2db2ab992fe32abad052bdff6a16f2a6a0e8babfa68e59c862ec7a1c2554439c735aa1aeeb9dc98b58c6a0269785f54253bee831361c3140255b755a8c42b978edbd21c99fdaaf73690cfc684e7885fb19dbbbe90b108fcae3748d4421d9ff44bc9ea2b4f28d5ae451a89f7a2fe184ede5e448acf22de728ab6e3310802835869ccf772bfa5c9794978481480d0522aa97ea4a3b7636c53da9fd390453158482fbc3f9692b4e6a8c7530d6b2c3546da72b639e4be34991d32035a846d074a040ffa6d39610593fdb023188f9fe238e392c9e6687b2226f46778b1d378a306332ecabed3546867108d132cf51737d0513c91d0bd4db23e2157abe891f125518416f1bb70230a1e629e948ab31cc03c53cbc2eb5f485b8868490243b9e37533b5226c759c298ee10aaf083ed7ffea7573fc4e7ae46563229979e8bcae0ea5ca6bee5f7d7c7c1515056df6db5252d043730434d4900408dca27fe2628847002db7671dcf1f959fc4b7da3253c62dc0b680a3854070d321aeed508be02cbb51e4f23734d337c152ec688ba863fdec58493e03925913fe0214cc1fcffb23f0fdd6ff13cf98e9caff86eb89a3ed8412b0e8212f04e83c56181e80df54f3d22753de597ab1800784cae7b55eab78cfaf6c9f9e6d587fdaca3ce632ef17d03411f34c6bf05707e957c7d2a3a801961d9dd44c1affee6c6274f8c4ea783492dfdb6cc0e3a41e40d66e3e173ce4f1feb0ab3b12668b9670e3ed64872ac5c26fa422ee686aceb1a99e89dbbb07cc61b945389e76454d7feb4690d5a5785958a67b8f018f4df317ebc3b9343aad88cc9072abc1d0a0bf9b39a0513a85ded70261b4dc5a30c8b776989e13e6232a978ca50954d9f7caa964a46d62eefc8c448cefd16f2bada187d674cc4aeeae5af5b2063963a180c41bc0fe3a82be90bd08aa74abf08a588cd2dca2e2d256ef5165081a1068dd608d722c42ea612f394df8915af997ef54e95be44e401948131c23637153174b62743fe5b6b104bb01b3365a82ba4e4ded915bbf9b47675936feeb9198164787ea2c97164286a4da425a705cc553d575641b7970333f334f44462f8cb9bb0969d7a35d3a2091d63735f651ced99a2f5edf917841b3d2000ad65227f7f226a1220d61a062fe981b699153f57522726f91924aae820689497df4fca303a7a2f02ed762a75f083f261d144c7d937cc8ec9825875a6e9e1fc763373ebd097edaf9644a7b3d2355fa5b69172a26a4af6587626e3c0d9ae0a4eb982ec6bc3353c504baad39f51d5657e32d760dc5ad35582c44b5aa78130e0ac01ae32be641371a93813755cece24eab2339142748c055a31e13f1529e5ddd0924e92343a5280bfd05f3a44d116fe436422b470075c05b5eba896848ab73579515e1c2a2b5163d3eebb35accfe3cc0242c6b90ee2a4dc99ea534147d317112dd2ca051f1df61aecedcea981979341a6b105952988fba768bfddf4d8a880091ac114a4fe137a8f0856f5521d27cbb628cb6c8c5fe5a307966d8531f3316e2770d883bf0186d1debc6861141633e3c2d1f4fb62b2d3b16a9eff6c71e1ed34de8660731439527c7ff66f8994bff0919298818b7717197f0fdd5470f4c1233c3eaf66ce632cbbf501148734e7c58022be9f515d9dbb3fa0e1657082799c268724db4e2d534a9bd6e243efc22a749c97a53e72d8f4429423245f625164a060bdcfe1a4cb682a2f5f08d9fccf05b5e38c9882b49a6ae467b8232f1652fbfa90c66190fbe8f7debd0653fbff088a039d833f9e98d853648543bb60eb4ed5c4e3ec2c0480a7b2fe85c324c4869aa01b67a73204b8f0cbaadb040ed9dc55385c60d342f125c9f36beef4ef8e7e9264eef88f07ab26118fb08a7fcc497a31c96d1ecb",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"112d9f54baa2e5a127ae6876be1157072d10fcb5d0aa1a2c20bdfeae57588880bcbb9a4bbafb6dfc6d5fde84efd20165941b397a9b4252bd5300d01dd49ce04f1276812d6ba47f452046b2d14a259b69f8f59d5f18f7eb94e79802a2e274ef2a5fd22654dc431ced07d39e8f1ceb4ff753cca6a09d14e4690ceb7ac720686e76b24d781cf20aaa868597728695742fdf07cf03f6f0020c1d0d3880644871f23e24a88e7525085950cc70d45e86823ae135bd3cc94692b43545ce08cccf22b40c25819bfb439cf28ad38fdf202b9eb25c918ef8d8c6a239594ee58e72de20701bdd3c46987ef28cef61d77d7aa38670b7aa7145bf83540afde0e4f51c9c8ca639c48133c9d79f656d1bc429b74e28c6ab8fc4b28a650c2dc22a801d89041e2e742692dbcefff895d84ccbd6617853a15b7465cc2c9d31bf4490ffa3bc3b2264b1be3525b7956c95d8aaaa245ad1057c2f10eb8fc5695ea87b37536d2aba97b35246bc76f71493bc5938cc159cdbf6299b25b6fd451fdf2476e031ae490838f111e62b609d970a6848ab72326d6940628cc31cbdea1d165001fefd08a2cb6e8df476b3402ecc1def57080629ba454af2c14b73aafaf26f7191966170a98f65f6c3566c381d4e236fdd4eec5d426a19f3dfced9657396c4dfff45ad72019764a5ca8bb3806acfe9f6261f3c6a94a8015b231541bfc19a86ddb7494994c22f175736cce9d2e25921aafef6f7359a10fcd2f8581a99e4ba34c803c9308d5d0d6a8c8b9a5c327f2a4cdeecaf64a99fb5ea9345ee02c999c3b02c4fe8954255ed1bfc58ead7d40af492c40318bdfef6ba6708abcd0f152b4d042280b9d7c1198540b9cbdef6e7be71d9022256d184c99bd6127f679553b73380b56e341917d0e14ff96d95cad886ce4b23eb466bcd1922c51e0b6e3c7e550755563f582e0b607a3bc7f9e2791f3bcad679139a9881aa43a04dc5fb7f4e18da33081f08edc320cd22f1a38c5f4d3edafc7c8458c7e04669f876ba41388c923506daafa8c77398d292fdf6ea020d778d92bd723ab13743f54c457456712bcde27d2b2ee5e755d753224d2e8f0525d4d3d30efbbe9a3a7967be98e9f3d67564eca294c8a1f856045531d3362abbc2c47f50708b1170921fd1cae4778fb19ef922792ab823196c4df775cc2524b91c3079b03ae97339d323f29e7f0698fe1cef3f782f9052c91d3d59db381d5b31d007a464fa41f18c079c8b6eb113fc1b87154e8bb3007aa2c6cf8d2843a035ca50db4b91b2d2c66fd458deb486e3173a0ffb787663c2f923134cf171bf91c39b0d16f17fa225a7a0f2c42c6c63dda7b4ef56b5fe9a2725fece75061c50143a01c8f659b55a1a229ebe881a00451680f590096fc49a89a8e922863e879f87d60b8d3cf13cc43bfb571c59dd53c396fcdaeb71048a739d09eb5554079e0099cdd864d55bcf77ba1f471c1f5bc0b01e1f64cc092691d6364bfc52806f01c7baf47c605ee7c02df24104cdf996e7bc3f56eb8ebfbedff1af8b0ecb9ab9b155e6a273019e568210fb55f14bebcd0c0701d66188e1da9fd1be4db5720e41aae0579c320c259db4c17f526f67441044f0ceb346cec70b77c522853310f9051aa3f3f1e5f80caa522926b1cafd9b0198433782605ceb03e106e8437b162f750904c94151d76258fc3a1c53bd11a9e3ac96d1509f3fa1556bc8c7470f44e24c94546692ba00adbcf2803843969dc5eed6e1df63cee15d4262c42107e60d5909783cffb3fdce3c1a577d24d63831b887588ec6c94d62195dc8294b739ae9513d9c4d7fc80dcfe3590d1bda2d17cacab8c4d3ff28df24379d63b41501c93e293e2b44ce75e2afc0c5d8006dd2324b7bc39230696215d7b5ddf3de2d0fcad99ae0e0609575dd59c1819a606b155a86fbdabd892fa060714ec49711de59d75b7a5c667eab7f3a81214cfafbda33e2fe2eca7b469d37d1185c9072bfe35533b473dd701ed357926244f824d9fa01887de1b5cd131f7c577ab7519763fcc17a324fa8eb9490ea983008210e6f351f6273cfe755ba4e3ca62acee62d0e4a90844aae7a9e19c1fe67f7c508b597af14be61399218fd9a743c8269ec4d33dba3316f19d54cdcc92f7f804321c93ca8c21595fca4a847e5aa53aeab519b28fad58b3832ca77a39295cfa4857e2cf4ed6f619b73aab40fe2bbd64b90e24df5e5972f5b2d5d70cb404e55b33cbb39a1586c12a6231e9e6b5795156362224796b622536b65efc941567f81c791b188f686d0b8105e56cc075e015939962ec4a28039088474906126fb85dbb21e63ae0d8832ab8366858d9eff26b05d93d14be61c7ff3c58ac7765cea3104bf69af09f5e15579b2a324a6051a5c8cd82b3aa514dad139dccb23e189d547d15a83801a7ba5762cfba46523c80026a5d7030543e2c0db98def7d34ffc9dfe42f471214d46f761b9f433cd25629e423bf92cb01d5202ffa61e7a0ebd8deae02f27a3db30d8ae2ff4116198fe24ca12e1e8243ccbc0172e7949c2a6f40cf0f3f0bcaa71fb9f397a70c44ea2289853bd60ff8ae5227369fac701c8629cdf5e97e8c0acce98738740a360938d3b0ed0e583bd1c6b61669b155bbd3c4ad375c05a7b7d55d5c98be66797128f294242acfaada9fc8e9d8e07bd203dc89f7eb3e1e3e13c58716c09347c09fc8765de3b066aead6540bcc818010b19d37d13da4377f5fe2757d76215637b0e9bdb735d42b97ac586c41c3868b5d1226cb5f27e9c7f37e8d49df4f9a6303dd1ab3f8e24c28703430c77beb3d7041612d79844382c36f7c24aa183e40b3a646f6636be77f1241a4790d73898773a4e34363ee9e6d986ed86c4a67695e14a68f31875208dbdf909c551e75150ec8bb46016e17a576cbeedf95fb8f20bed662c87e011990c66dab9bdaf412ffdc0d9bfa4a376fc75ef800ffff35da20e4bc97a1c43eea60ff3bdf3677f890da0284b666968e769bb94dc63a79d902db591035d449d9599db8bd1c82a8417a52db7cc576db8b32dcbf6537f78dd1d406ecd0baec8d2c31cc73b2e5dfe34b3ead72853d387e4964622578ea79d90d77875e1ee92ed681543f2edff426ca83d072b3d74853c6bb354f3fb304f4bb37a67b19624250e2ac1f372397dfeb8e63349e3243134dfbdde74521a6e0d8b32f2f839f10ebdafd50de18e34242e5ba64a9c36363976292a7d1129c0dc4de408c2053d71fa4a02f68e2b7ce49c66f25f1b06c5f700df036615b34b7a89280b388531f3d942dfc0cc6cd13db48f07195b5336fd4fbbfc09167e5e911990c763ed248b2a6e029fb55fe62911ce2b25c775858cb1d77c953d306569c36a8218eef73f6245180172ca23e05958b038cf4ca7e58ababef4f5804ac7d4f71bba810b5a9224781c142777281df1330159a77f685ce17bfcace901b7a18a45413ce7250097a5b09b54b7013dd0f5d65270ada384eaabcf10117b15fa2534d2068d48bf793d6e312493bb54642262b396532466e2fd80597efe641cdf3fcd5426e2b79e3b744d7c9b03a9296bee0492d7c7cb80ed7d45f5e7abf9a05e9f68e552ae98a41a5bc726d3793d0f36238eea0c807d0009dee53d30e37830b669657ee848532ed18d5df9f90e3ed668dae422b79bd60b88a3e2ea05dfab475b16218983c7f4a97262e6ff753f1a27c7cb36accf10d2099223624ac199fd42d2b838853b2601cd8a93380982e233fd34dbdd6f169592fd29bdbc388beb736bd3e0ab85600aaf7c16775df634da22fcd9cf94e175c4dcd0486119a6b98cd364eed478609a575084bce3db89cc39878f24170d1684f388f5fdfc4f57aa7a2d6a00a41d27ef8feb5c03a5b8e0b24e690ab6794715cec771cf31c07a4f27c5bb2a57ec294fbf30928424b4dc5126011ee41a5b978c89f7577d717cad1e7651a87e775c0439c90a5edb75914baa818efcd1d718e3af6d502fdfb7ca3786582480105f9acb14cfb6467f84344cf7598c0809d0e6f84565f8fe2f2ea1992adfac576f61486cd3408c9b855e5d6782baa895ae4c358e03af41bdca3e566894fbede74972bef286673913d19c79978d8d3aa7d5727cf06100b87e8d0e7f3bf921f45868bb3bb65e2a213dd8ff1cc731758ed8768969ce2ead4535af777e01457923ab3c503de662e8f46cf01f26396ec02285ca196f2d2e173e62173c418c5c6bab4ac991f56eba8aa112bd08a97b926db2bb039641113cc1db9a8dcc43d3fafec37f03cfd60d0315f556d240366c5f6a5da092e7dd51b1b69f14a94de058d05d2b6245cc3b6455895598459a50a17cac5507a91ba3173aaf65ae8ab343b2cd0cae32f775015937cf90bc8ea768d35fedd4703216e12c2088c6427b5b2e7d1fd612df88a8d5b55f51c054c083c701848d4364d02ff0c906c566c995f1b244265f3e2e55a6cb3e6ddc35e928f11556b14cf2bce9da84d2b9913ed15a6b05775270d23f52d4ce480091f63d42a169fee253087e60621fc2f1af3a89834bab301ef40cc8a4d62233dab31660341f58410e21463605ca59116c57cdabfc15c2ef37687b3edc6d17b1e6fb4ff9ac07234bcd5c0199bb9a189c5f2e52703206a4d3b4d1e3ee9a4fc30768179e64280e37b616bd0544dd67b98b349d859b20ac230206c03c042e16fd34a29667c3fe174bfe2c9c2e7f0fcf7b323ccadaa563d50f98972bf07c2f5d65841afa898c38048287f21fd27154ee4ffbc4b1068321af26af8dafdfde73a18ac4f69a114b521d541b41d25a9c0fe60b32e84519582e90fb4250cd7fd01b9798484e91759eecbeb409844b5cf3483297af2b7e175ebdfb7989d13619df831351b8169777011e83989fc319b4adcd1fc9c7cb9843934ea166d318df5aba90234c8e0e1bf60f9df24b9aa0387fd0cdc40c0874d72702bba1dcf74fff4f95e321ad43255afc0e43638cc286baf822b9beb0a379148c2960704914d75b4ee30d6a715d28fda1a1499d5c99d779003792496e78fec2028de27ba83a7610f9da89fcd13fff235e3cbdad71067b0bf4bae3b456971ec92e4f288ee2f42d11c23c61075f8c34a51246030867f94dea95170db78f96079f857c176e5ea1386cb97368f13d6dd6caabe907e47ac1d6f128a9b8448c4fca4719fba6c1a3b1700cdd79c697bf8ab7ebf427087ca98a5aaf66995d994be6012a54deaead8c50a0c813dab15fed0d505d484961d2d5ee66aea45edf6a1d4d43f768d1eca94ee6a84a089cf54480184afe6d7030a057fe6d6d5baa64debc0da934fc6f3b76d60b7887b484b652c7364fedbd09a9856ee28f26d0b1d6c8120db5e28c0ea5c3018a89528ba3e9253e01c6413559fd95dfdfca4f5e38e764662a8ef882f620f8936c848e7070b02b871c3e0aa89def96ecddc4021e2432097460f5ad3dfbb6d63b6919356401a4d61972449d88c19e9de15dad6b4e5ca8064709b36377fee9a366f3e401ff4085c8980e345a6c0b90f3f349429e67e7aaa649470b409b1fba7bc85f1703e5cc875547de495cd11b99768dcf15fce0d5093d2a6809b08960c41bcc7e4d3ed02662edec79d6166fe957bd54f71fdf8db6fd3bbbef0b5ba37ba98d5aeebad2d184e95bddbdf842b84140b10c8e9acf2ecdd89766fe0387681cefbfa576edc7622e1639ebe8f762569ba3704edc26dc704a5c01d03f128e8785470ed6516b5dcef55b82da77ee0b0c08dcf9edca28fa04702041960d874c994b62c8eadbb3cbd6267b9fc568ec06d4f79cdcd496c4df22fe3a9bc0df149f39d83c8690e7d8d0af6362778393cacf32710e43657df466a6a37e0032b7aec14a96ec109b68b85763f402b1d69a8f54b700515983bf3a964eb002a5a88050c4965cce9574ef402a05b529fa1aec5a92bfe688036df8316515f5ed7bcacd14d38a2484940b34996b6c0a103ca0bb041a80e19d38741c2b39db1c188a9bf47916231d43f5246de6340ebc8bee8d7d9e73f1f80aee0a7a7137b191fa91ba00d876470fdf38bb93125ad7fb033dbab4e5aba83cc55202c63639e5d2efde3a63db4789082d9cafdb283ef1c2245512af3a48742ad6b20a01ad330c2615aa9b4c52adc28c0edbd3f16dbb235aad854e0ba4dac350d6ca1797218d37a24dd4b91fa46f28eb69b943be42e08363055ab7cb36b04d5a27192e3da65441f820dc54a8f35b7fb38842b1af99b74347df3170cf463a77ca430790a66ea7262c462e85d8c3079d951b75dadf5f24c471078bdf4d50461ff8e1ebebea1539bec4f97e04d579558868d95029221d5ea68546d99a41b371372090b2877a8b62d171d25bf8e38b0a9a089fac89496294a8542198d67836112a242f125c9f36beef4ef8e7e9264eef88f07ab26118fb08a7fcc497a31c96d1ecb",
+				"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",
+				"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",
+				"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",
+				"150b194ad8be8ef61afcbab20228f63cf3daac7181e52ff00def82994cac8cadbc0afd2003db8617889a0023296ec9d028cf0dab03f5a6ac2c5626c62d536decacf9ad52f5b4363b3ae3a3a3451658248edbe61993cc7fd9b6e620f40573c307fdd45100b4454e53f2c3ec133a04aa9fd652313b434351d996ae76f85016461773ad3b75c23af84670708e414e6e726972352bff2246f6c0f57b2cedc376a8a8cb1df74d83e7aafc10545a521f31f6e5945ae14ef4f0e973e9fbdaafc57d41eb0ae8b277c10f9029c90be5c50c6b400fc0decae22b5d3eeb3fda02765058b4dafd6d861a54526e51efd1b5cea8d7994fe7293b86dc601d6140b9d3f7f083984c7bddea56acd6b0a381a59db4fb97cb3074a7dce6cc8087c832b5b1c71909bfed4efd41bcef99defd1e6e7b86efdf813c23322cb7083eabb538ee0c105fbb42a33484b2232b4728af68665322e62a515a0c16e12b9bab4443f7aab5d5555814e1cb3791dc3ec2eb1439fe4a7db79d119db0557e3900afedf808bb636e1ddf5fa15e5cd406410771b5de00768437bc29f3242437d94141b28cd5eff641b21be2254074651e4e0e0888d0cf81e6f5b9c3f56b1a932eb852aad78120866511318298437fbd3c58e7af626dbd32e2033e5eaa5fc1686097e515bd69715d05d9eeff926515a754d3d0684696ea28f8eb88bc8271b839778588d16b56603d1db5534f20cfe0616f2db4e35e0624bb03c99329758a28ff722d3c676025e1780ed3a3c1124a49090b0930dd621e43eda3cdd731a46b3a9724ad32fa32c2901ed0b3925acacc9cdd9d3d3a196a60a83d83acfe1a9cbf4ca1bb29ec264b94b4bc510736d9916d8dd8412188710e0ea928c566b95b23eb556bfdce5befd3edde10244e98f07e6e3914f366aa6c5c326504baf1c38c97d20b7f447359a213b8e34c0f34556b19380a5477b768200ddaa2ef6ac4b47b9aedb389309aecd9386e9ff169eee2a6fb5436bf4d11742752e4179bfe90b58b075212e82b073ae89b142069e348af3db79510eb975aa478e4a0b948957b34642e3c521d6f5281d7c8b969f265edc3febff1eae7eb1a6ae68cc2c0e012343eb5b13c466f6df5152dbec1f3ff7348c6f35c9b9dcd22cfe9f6d7ed39653b16c816b57a99057467eab40ca1fbc48e27d2abb23306068b1a468322ec54a7bf26d4d0f716104bd890a7e40bda60ea55ec2c803561379fb4d531e510b9d2caf0455e86d1dc1015c87da07288466607ce1981641c9dc8ef56545e394095e1ae7b94fa672017c5360c7d0ea62f09e96b301f7846d9c949ace8bb9d64bc670531f081d90c8b06b1024c41d98b7bf2d45c5f9eab78f473dca5152182391bae24fec6154e0b52512101065e9e5d627676c1b63f3426a2881b184125b4ed06e85bc69cf7203985f083e7f7c30ccfbabf4655ebc350c94325ec9e4bb84f8c8b3b7b5b8696afa1f520fbc200839da20cbccdc72273c3994bd34721684d09743cfe4c751d9f141679c1f504b188b38b4659018d4d2d3feed1ceaf8725faee719528c697156c59d806ff2a05b74f95c654f301c5ade813f72c9b6a951e2b3d694619aa0825005395282e9bd7d8fcce2c57846d8ce337b7f8d77de1130682cb93372d18120f27a062e3636e759487edb2ac8a5c9e851f58545c218e97e1e5b623373054a70d6a9ee4b98980380130b572e82b0b7041c71782ac50a9f7287c9da9f04ed05317b10170f1572f9d6614df8659704af759b899ea2a5918b885bce49cd218f311631079315566fdb4d6e425910dc6ecfc604312bce7b96121f4324dfc629b08bfe5c109696e7dfb47ff14b764eb0556ad4ce454bb3472322efa28c5867951bcb559120ede8e139a1accc52eda02c78b32e40608b095b7a629cdd2e8f5a94c06e8cbded10981600812f857d8906861a728ed5d7574823be6fd270d28cb11a1b1729387ebf9e933130a7bf73d4322a11a43e01c47bf06d76f2422d8c9079d3e93ebae2f5857d27d2fe33bd351cee66d3ff5906a10165f79f4b383f67b9815589a9707eadc16f09585e488dc1f54c93e87158c5841d32bfc0b411880d3cfc09157b69a3af10bae29040d4db2c5925aa6f4a3cb36c89f026287ca05fcd645c3267d365cb5ebd613311e817d4417248dfe49fd3fafcba7fdeeca699c3c4396c7fd7a1ba73433ec745c9ee1c7f6479be808716eb9ba1e2724a247967fea7dcecf0e14356c2aa863fd5d42d5234679c07893f4c7c7f10721378b2a6acb034dbe4d7082b700bbab28466fb960fdbdeeff90cdd3ca53b171380b16dfd8c7cc560aa8d6b6db5659a73f34f0cfec292f100a3bca4783a168e5cd287033bc6b19b361e0c5f6c90e7f0a21cdc1a0baedc4cfc5abd00eb85c6123f1de1cbe334e1455090ab719545d744c90d0aacc37b15c03fecfce830bf47b058ac3e191b7ffb2306461060daf7ee368775acc6ec5281bc79a21492e15885b238dedd0ce33f73a00f08400330b6df02f9de2519e52c32b08dcefeba3f738be726c7932be0de263fbd0cf26503400b6de7e7842875df7dadd48af7a709797a8268fe64cb0d8ba10ab1d0f7ca396ac707dcb512f753173c2098a5f0338dcdcd72a11e6576fecb4d7921461af44500bc2f64a232ccf3888a17171c6b8b53c28a0c606bf208a9cf2b7126ba4b65410e96dd7e3dedd4bc3bdc8b334b0e2656047eef365d23d538ae179d2657d1da099eddf792a528d7666278c12b512ed604b0f4c928d2ecdd3aa30296919e0583a64dfec68ab2ec22b2ef5e25b0cc1318e9e5c8c75c3c442f642a6bc9b3292e0ae1368d0b4d38e9a065ce2a2774eda18f702fc7e756383e45f595b50d57e44d9dbff60861e261e9ee42c1543a1a2a5a0d3cacb0731a2f56b321faa8ea7811f90878acf15eca61751c2ea90957902f4c7838542466e59918d3591dac0a8547347a3e3a3c5e0ceaece465a8fcf404af49e736d12b01b47573761d7bcb509aadf1e966025f7bd397c153bc54dbc6d798281d2d37ec52f63cb04cbc9941de9fdb2c10c2376ae1b885b395d73ea478891e281d832372d81e8ac44b87a6aa87e6a2a2b3e44431ec1daa25832067d1c38b9a9379e2cc9e2452faae56f24bfa8a4478311b58152b2cc8099be1c1b6ed72861a5cdda7d7474144c88eec207bed1b94f8aa2f5c5039a8066ef158e4b6bd66065fcae02997f9b44175f8cde408c2053d71fa4a02f68e2b7ce49c66f25f1b06c5f700df036615b34b7a89280b388531f3d942dfc0cc6cd13db48f07195b5336fd4fbbfc09167e5e911990c763ed248b2a6e029fb55fe62911ce2b25c775858cb1d77c953d306569c36a8218eef73f6245180172ca23e05958b038cf4ca7e58ababef4f5804ac7d4f71bba810b5a9224781c142777281df1330159a77f685ce17bfcace901b7a18a45413ce7250097a5b09b54b7013dd0f5d65270ada384eaabcf10117b15fa2534d2068d48bf793d6e312493bb54642262b396532466e2fd80597efe641cdf3fcd5426e2b79e3b744d7c9b03a9296bee0492d7c7cb80ed7d45f5e7abf9a05e9f68e552ae98a41a5bc726d3793d0f36238eea0c807d0009dee53d30e37830b669657ee848532ed18d5df9f90e3ed668dae422b79bd60b88a3e2ea05dfab475b16218983c7f4a97262e6ff753f1a27c7cb36accf10d2099223624ac199fd42d2b838853b2601cd8a93380982e233fd34dbdd6f169592fd29bdbc388beb736bd3e0ab85600aaf7c16775df634da22fcd9cf94e175c4dcd0486119a6b98cd364eed478609a575084bce3db89cc39878f24170d1684f388f5fdfc4f57aa7a2d6a00a41d27ef8feb5c03a5b8e0b24e690ab6794715cec771cf31c07a4f27c5bb2a57ec294fbf30928424b4dc5126011ee41a5b978c89f7577d717cad1e7651a87e775c0439c90a5edb75914baa818efcd1d718e3af6d502fdfb7ca3786582480105f9acb14cfb6467f84344cf7598c0809d0e6f84565f8fe2f2ea1992adfac576f61486cd3408c9b855e5d6782baa895ae4c358e03af41bdca3e566894fbede74972bef286673913d19c79978d8d3aa7d5727cf06100b87e8d0e7f3bf921f45868bb3bb65e2a213dd8ff1cc731758ed8768969ce2ead4535af777e01457923ab3c503de662e8f46cf01f26396ec02285ca196f2d2e173e62173c418c5c6bab4ac991f56eba8aa112bd08a97b926db2bb039641113cc1db9a8dcc43d3fafec37f03cfd60d0315f556d240366c5f6a5da092e7dd51b1b69f14a94de058d05d2b6245cc3b6455895598459a50a17cac5507a91ba3173aaf65ae8ab343b2cd0cae32f775015937cf90bc8ea768d35fedd4703216e12c2088c6427b5b2e7d1fd612df88a8d5b55f51c054c083c701848d4364d02ff0c906c566c995f1b244265f3e2e55a6cb3e6ddc35e928f11556b14cf2bce9da84d2b9913ed15a6b05775270d23f52d4ce480091f63d42a169fee253087e60621fc2f1af3a89834bab301ef40cc8a4d62233dab31660341f58410e21463605ca59116c57cdabfc15c2ef37687b3edc6d17b1e6fb4ff9ac07234bcd5c0199bb9a189c5f2e52703206a4d3b4d1e3ee9a4fc30768179e64280e37b616bd0544dd67b98b349d859b20ac230206c03c042e16fd34a29667c3fe174bfe2c9c2e7f0fcf7b323ccadaa563d50f98972bf07c2f5d65841afa898c38048287f21fd27154ee4ffbc4b1068321af26af8dafdfde73a18ac4f69a114b521d541b41d25a9c0fe60b32e84519582e90fb4250cd7fd01b9798484e91759eecbeb409844b5cf3483297af2b7e175ebdfb7989d13619df831351b8169777011e83989fc319b4adcd1fc9c7cb9843934ea166d318df5aba90234c8e0e1bf60f9df24b9aa0387fd0cdc40c0874d72702bba1dcf74fff4f95e321ad43255afc0e43638cc286baf822b9beb0a379148c2960704914d75b4ee30d6a715d28fda1a1499d5c99d779003792496e78fec2028de27ba83a7610f9da89fcd13fff235e3cbdad71067b0bf4bae3b456971ec92e4f288ee2f42d11c23c61075f8c34a51246030867f94dea95170db78f96079f857c176e5ea1386cb97368f13d6dd6caabe907e47ac1d6f128a9b8448c4fca4719fba6c1a3b1700cdd79c697bf8ab7ebf427087ca98a5aaf66995d994be6012a54deaead8c50a0c813dab15fed0d505d484961d2d5ee66aea45edf6a1d4d43f768d1eca94ee6a84a089cf54480184afe6d7030a057fe6d6d5baa64debc0da934fc6f3b76d60b7887b484b652c7364fedbd09a9856ee28f26d0b1d6c8120db5e28c0ea5c3018a89528ba3e9253e01c6413559fd95dfdfca4f5e38e764662a8ef882f620f8936c848e7070b02b871c3e0aa89def96ecddc4021e2432097460f5ad3dfbb6d63b6919356401a4d61972449d88c19e9de15dad6b4e5ca8064709b36377fee9a366f3e401ff4085c8980e345a6c0b90f3f349429e67e7aaa649470b409b1fba7bc85f1703e5cc875547de495cd11b99768dcf15fce0d5093d2a6809b08960c41bcc7e4d3ed02662edec79d6166fe957bd54f71fdf8db6fd3bbbef0b5ba37ba98d5aeebad2d184e95bddbdf842b84140b10c8e9acf2ecdd89766fe0387681cefbfa576edc7622e1639ebe8f762569ba3704edc26dc704a5c01d03f128e8785470ed6516b5dcef55b82da77ee0b0c08dcf9edca28fa04702041960d874c994b62c8eadbb3cbd6267b9fc568ec06d4f79cdcd496c4df22fe3a9bc0df149f39d83c8690e7d8d0af6362778393cacf32710e43657df466a6a37e0032b7aec14a96ec109b68b85763f402b1d69a8f54b700515983bf3a964eb002a5a88050c4965cce9574ef402a05b529fa1aec5a92bfe688036df8316515f5ed7bcacd14d38a2484940b34996b6c0a103ca0bb041a80e19d38741c2b39db1c188a9bf47916231d43f5246de6340ebc8bee8d7d9e73f1f80aee0a7a7137b191fa91ba00d876470fdf38bb93125ad7fb033dbab4e5aba83cc55202c63639e5d2efde3a63db4789082d9cafdb283ef1c2245512af3a48742ad6b20a01ad330c2615aa9b4c52adc28c0edbd3f16dbb235aad854e0ba4dac350d6ca1797218d37a24dd4b91fa46f28eb69b943be42e08363055ab7cb36b04d5a27192e3da65441f820dc54a8f35b7fb38842b1af99b74347df3170cf463a77ca430790a66ea7262c462e85d8c3079d951b75dadf5f24c471078bdf4d50461ff8e1ebebea1539bec4f97e04d579558868d95029221d5ea68546d99a41b371372090b2877a8b62d171d25bf8e38b0a9a089fac89496294a8542198d67836112a242f125c9f36beef4ef8e7e9264eef88f07ab26118fb08a7fcc497a31c96d1ecb",
+				"1685e55780241c3bfeae16e9aa47ca1781a8a32313637cf47a90a8020128c40c18235c7824578da3ed4ec6eff8a0ee0405e65555151d5e247b7d9b8fc2905e20b4aa91eb87381884a972e21020d2ae661b52f31c54a2fc5d1d09aa8d6f3220907c18d08f3b14042e8d745cb7033b1c6a44d75c91dbf823109d831685d77dcff6aec9fab81f8b7d8a07fabfd26f1fea447194d6ea01ab1a6640be5cf00eded97b52c7635aff9a71275f429ec63a292b5a849a3db4e991bc44601b45de6e2faeb6f8d436d0943f99e79827193e66855d5dd6e34a9984a210fdd3a2c7e7fe61eb7404e4159c496d720c50f2906a427b4a9edf4598c294d274e3020950935a05d17c6cdd9dee2d00f969d071b269117304f2edee613f7b1826647a427c53ea7b9f1956153214add3d243adc6dee5dacdcd87632265ecba21488af414f026c52cd480d7bc094d8e01b82c814539db6e7cd7be6e74d0b53e156195ce2b7fbcbca345ff7eff58131d931ee11ac6a46c7d2070a4ed72d3a4d25323b34b793bbe13a6f841639e3829f682a82be037cfef7541a1e211ed637be1e2728f8bb3aae333aff2edb22fa1a832f8075aa3a93e6f282d7e60c987bf0fae9cf5620c3480a5f8f9cf181f455ca40866dd5632dfca464e9a42040de9ac7baff04a9b530ba11d4378b5c79226bc4fec29002a9fd62f2e5d1b8ca6a635296e2b4dfe1daee421157d764f9a9cb0b9e0d0ae66479eb3ebe17b82b78f104e308db92df5332d60f74cac97dbdfe6b6d0b1da4a79e77bde280cabfd11bbfc2297a81bb964b207e82252108738a6013c593d58e231f9830c75f4acd2c44e89af2afe2c2cae2f8d98ac05caacf6c815a7ee7bee050d87d7acee8a38d8c04d5bf42b7c69f72a2c0097087e03e62767acb8898d14f04455f5eb4d90eb0f49981d7e386e956288de2c2a2acd67b4ce765c491e730750dd81c075e74af5f03f3a9a25f4c1258ec830075dfb5fbfa9db24da5ad5028b01b485fc717997eb21692b04bef44305708d95f8394db55e82f631fc0e049915a10bbff2b0725adc407ddf5efde0c9a30d3b101dfdc31306862c45829625383bc60fcef4f2f6415a354d34ac9b3914c1a571f9edb034f87e38de2046210950633239c9700b8c8a3bc260ac013d24a42743302a612434f76b22fbb9f2a6ab9ff0d66f8ce88a176688941f966d79601720e66beab479698aa9caa415cd27b7ab48c5407e20d460c0912630de3d2ca4e9ba2d331a67e3001d8acf56e7f7d4de83df9537a86d3fd41737408934b36898b860543265e21e6aef6992ac39c20def0d2c58339c79ffc8a021604098876327635b53db331cf6e4615251a5bea6df9fec81bf9380e2706f17368de1d931be2f60c002b259455f10065e701bbf4b39303b5c361df424a95b5941ae2b648ea58457d61ab4b7ae7bce45d02988900bcdb4d362a9652154cf29b90e4525c8e84f9c2ace19928b94554a5400405c405b51d1f4b081fed1f0457cc3ac0b30cbd20128ed31d10a2fa873a5304f6cc51bc724b3e27c177d7638b236a10cc918caeec08480ebcb120d911b02d4597383f5433bb6ff487c64d22fd4f110acd4f786afbdbd1ca174ed70b74aa6a60ef1ebd372e78364286f358bb7e8bb711ef30bf6d5d15c54e8ad357e63572bf5c731f7b04c028656676af572578926e51d450146cf9f3ded5cf658ae5fe54012953c5a107f49be08b18595c8f50524e422cb506d9cf9ef89dca3a074f1e5bf693695c70ae32996a50823ec1e54a117025e514cd6e13c4fb89e994b9572b64e4424506a442bc95f1424da7f0288b2ddce32a7b9cd2cf5358b04dba85baab9139f5d3461ed62b335ce202396450ac163dce5d4dc5285d3a458bd615109ba569ebd03f9c3b77aa5ea33113d8802c994db68cc201aade5e713cef415eeb44409d534e90a7f7ae6602d7d5411640d6bb86b6002d3c5aef6911e5f1bc9a268be4790f19fcb44c36a5eb3df8a2660416381e6c422579d3b17bd7e6b0dde78b9e50c8dd97c760a646e21decd60b84cef479d5eaef1a95dd2c82051a77b7758b63e0549d0f9f05b21acfa684e76d94f2132d7f3d14a0feb639b6756f3f44e33dee5c08413f1cf7a655ad28cf77113578d846eb3071bda1a46d5a5da44503e972d4c4a30107d586bc42f197080bc98dc286a6baf0b90169bea1c27fca5cba27f48ea2c88c0c5010bd37575f1927e7e41423c849f6beb420b408421b231961afbe816d4cf184613c8607a343762ba7cb8918b81a437b9ba5607da28ca415cb0946416832cf2773c60397c629780ec97d12dd387e33225996479ba51eb0420b37a91dbc01cc02ac39443a2f324bee1e242e40e5dbe21e630f5acee6f637631f07add8f5e080879067e862f23a07eef9fc995295657e31557e8f83b1542ee598ac37c7db0b4c4ff9072f8cca1a250f1a5bb59445e2d7539b598fe73517c0ed0814a19db909f4cbb31f14420c7b830784aa5411af0c0e44d577f40f1db3ca0b107385d7da7f1f59d5adb6afc6c284e7e2a64dde3ccb4332f89417e91fe2c8d734147310e697d3432047c9028194a3cbc00c4e9f2fa230ee11e74bbbfb26854bb26bb8a82e362ad4f6184ff77657eae62401eec537d0f4c01a66b23f0a4d7d96d46ca904cf4a4d4df15e5160f7905fc367f72ced01f1bb918b392376b0682b9d6c4feedeeb675cb3328abff32659632d2258b7a984ab8bc870a39b6da66af28bed791e285bcf7f964857487d20781e7e5663b71972a5e79faea12f557bcbde684f10bbe49265cbb38a7ca60c2f62a2f0311cb9625f873e43e06f1019d0eabbc3821296b7f322457b1c05e2283b76b0d4cd21f9c9c5ef963c3b16a37a3149310d5186bfbd951343a47b0bcc6163ae38751f7ff5a4c97a3d372c2d953753821c2a048e203bac4a108db3efcd6bd176654b0e3b124871be273d03acb80f076f80868becfbebfa3fe1dca553f11995500ae6b6ca68ee57bc1d9b8490a5f1bbf602b1a2b6ef0e6cc2d7eef7da6039ca9ae8c5d102f840630ba4309335c3a5194bbfe4592a2d03d4cff422cd59cc98f59e839c0e119fe7776ec0341ba89817f708105d398de01b41bfa2c185c2001de672d8f9c83410df28d79dd6a4244e5e902acd5d7818a01986c3689be07c82d33c207bed1b94f8aa2f5c5039a8066ef158e4b6bd66065fcae02997f9b44175f8cde408c2053d71fa4a02f68e2b7ce49c66f25f1b06c5f700df036615b34b7a89280b388531f3d942dfc0cc6cd13db48f07195b5336fd4fbbfc09167e5e911990c763ed248b2a6e029fb55fe62911ce2b25c775858cb1d77c953d306569c36a8218eef73f6245180172ca23e05958b038cf4ca7e58ababef4f5804ac7d4f71bba810b5a9224781c142777281df1330159a77f685ce17bfcace901b7a18a45413ce7250097a5b09b54b7013dd0f5d65270ada384eaabcf10117b15fa2534d2068d48bf793d6e312493bb54642262b396532466e2fd80597efe641cdf3fcd5426e2b79e3b744d7c9b03a9296bee0492d7c7cb80ed7d45f5e7abf9a05e9f68e552ae98a41a5bc726d3793d0f36238eea0c807d0009dee53d30e37830b669657ee848532ed18d5df9f90e3ed668dae422b79bd60b88a3e2ea05dfab475b16218983c7f4a97262e6ff753f1a27c7cb36accf10d2099223624ac199fd42d2b838853b2601cd8a93380982e233fd34dbdd6f169592fd29bdbc388beb736bd3e0ab85600aaf7c16775df634da22fcd9cf94e175c4dcd0486119a6b98cd364eed478609a575084bce3db89cc39878f24170d1684f388f5fdfc4f57aa7a2d6a00a41d27ef8feb5c03a5b8e0b24e690ab6794715cec771cf31c07a4f27c5bb2a57ec294fbf30928424b4dc5126011ee41a5b978c89f7577d717cad1e7651a87e775c0439c90a5edb75914baa818efcd1d718e3af6d502fdfb7ca3786582480105f9acb14cfb6467f84344cf7598c0809d0e6f84565f8fe2f2ea1992adfac576f61486cd3408c9b855e5d6782baa895ae4c358e03af41bdca3e566894fbede74972bef286673913d19c79978d8d3aa7d5727cf06100b87e8d0e7f3bf921f45868bb3bb65e2a213dd8ff1cc731758ed8768969ce2ead4535af777e01457923ab3c503de662e8f46cf01f26396ec02285ca196f2d2e173e62173c418c5c6bab4ac991f56eba8aa112bd08a97b926db2bb039641113cc1db9a8dcc43d3fafec37f03cfd60d0315f556d240366c5f6a5da092e7dd51b1b69f14a94de058d05d2b6245cc3b6455895598459a50a17cac5507a91ba3173aaf65ae8ab343b2cd0cae32f775015937cf90bc8ea768d35fedd4703216e12c2088c6427b5b2e7d1fd612df88a8d5b55f51c054c083c701848d4364d02ff0c906c566c995f1b244265f3e2e55a6cb3e6ddc35e928f11556b14cf2bce9da84d2b9913ed15a6b05775270d23f52d4ce480091f63d42a169fee253087e60621fc2f1af3a89834bab301ef40cc8a4d62233dab31660341f58410e21463605ca59116c57cdabfc15c2ef37687b3edc6d17b1e6fb4ff9ac07234bcd5c0199bb9a189c5f2e52703206a4d3b4d1e3ee9a4fc30768179e64280e37b616bd0544dd67b98b349d859b20ac230206c03c042e16fd34a29667c3fe174bfe2c9c2e7f0fcf7b323ccadaa563d50f98972bf07c2f5d65841afa898c38048287f21fd27154ee4ffbc4b1068321af26af8dafdfde73a18ac4f69a114b521d541b41d25a9c0fe60b32e84519582e90fb4250cd7fd01b9798484e91759eecbeb409844b5cf3483297af2b7e175ebdfb7989d13619df831351b8169777011e83989fc319b4adcd1fc9c7cb9843934ea166d318df5aba90234c8e0e1bf60f9df24b9aa0387fd0cdc40c0874d72702bba1dcf74fff4f95e321ad43255afc0e43638cc286baf822b9beb0a379148c2960704914d75b4ee30d6a715d28fda1a1499d5c99d779003792496e78fec2028de27ba83a7610f9da89fcd13fff235e3cbdad71067b0bf4bae3b456971ec92e4f288ee2f42d11c23c61075f8c34a51246030867f94dea95170db78f96079f857c176e5ea1386cb97368f13d6dd6caabe907e47ac1d6f128a9b8448c4fca4719fba6c1a3b1700cdd79c697bf8ab7ebf427087ca98a5aaf66995d994be6012a54deaead8c50a0c813dab15fed0d505d484961d2d5ee66aea45edf6a1d4d43f768d1eca94ee6a84a089cf54480184afe6d7030a057fe6d6d5baa64debc0da934fc6f3b76d60b7887b484b652c7364fedbd09a9856ee28f26d0b1d6c8120db5e28c0ea5c3018a89528ba3e9253e01c6413559fd95dfdfca4f5e38e764662a8ef882f620f8936c848e7070b02b871c3e0aa89def96ecddc4021e2432097460f5ad3dfbb6d63b6919356401a4d61972449d88c19e9de15dad6b4e5ca8064709b36377fee9a366f3e401ff4085c8980e345a6c0b90f3f349429e67e7aaa649470b409b1fba7bc85f1703e5cc875547de495cd11b99768dcf15fce0d5093d2a6809b08960c41bcc7e4d3ed02662edec79d6166fe957bd54f71fdf8db6fd3bbbef0b5ba37ba98d5aeebad2d184e95bddbdf842b84140b10c8e9acf2ecdd89766fe0387681cefbfa576edc7622e1639ebe8f762569ba3704edc26dc704a5c01d03f128e8785470ed6516b5dcef55b82da77ee0b0c08dcf9edca28fa04702041960d874c994b62c8eadbb3cbd6267b9fc568ec06d4f79cdcd496c4df22fe3a9bc0df149f39d83c8690e7d8d0af6362778393cacf32710e43657df466a6a37e0032b7aec14a96ec109b68b85763f402b1d69a8f54b700515983bf3a964eb002a5a88050c4965cce9574ef402a05b529fa1aec5a92bfe688036df8316515f5ed7bcacd14d38a2484940b34996b6c0a103ca0bb041a80e19d38741c2b39db1c188a9bf47916231d43f5246de6340ebc8bee8d7d9e73f1f80aee0a7a7137b191fa91ba00d876470fdf38bb93125ad7fb033dbab4e5aba83cc55202c63639e5d2efde3a63db4789082d9cafdb283ef1c2245512af3a48742ad6b20a01ad330c2615aa9b4c52adc28c0edbd3f16dbb235aad854e0ba4dac350d6ca1797218d37a24dd4b91fa46f28eb69b943be42e08363055ab7cb36b04d5a27192e3da65441f820dc54a8f35b7fb38842b1af99b74347df3170cf463a77ca430790a66ea7262c462e85d8c3079d951b75dadf5f24c471078bdf4d50461ff8e1ebebea1539bec4f97e04d579558868d95029221d5ea68546d99a41b371372090b2877a8b62d171d25bf8e38b0a9a089fac89496294a8542198d67836112a242f125c9f36beef4ef8e7e9264eef88f07ab26118fb08a7fcc497a31c96d1ecb",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"24a6c9d337c58d1908420f010a3df1fa396bcf04e3778ebb42a27a4084c17ace078f5d1d36f24ec0a32aa45ef4aaa51d44fa71689cd6dcae06e6f5a8f5b0145a241b9993d1c4719c07ed2f571abf0852f6cc3841c1b7aec3f8bbba9a53bf378b288880d0df18517cc8dc13b25376fdd4dfeb88ed0254a8f902e5dc5a31af4e42547dec66873ef0803bd6e377168fb6cb55985525f0b71198cc8352e6aafce7fa80f3383973e22b4f66ed5a9239d108baab9bee4fd73bafacc376a6fc2746210a00facca815e05c36a6468cd0aa7a22ba61a8a38ba0bea83ce589749b028123aac322f964efd0c26da3244423a7db19f3db2142bc1d64c3b8730bca7b5accf58d07a720625ea494513299dca973fce6ddf262be932edfeb04001a5cfd2012f03d7310383fb6ec85f76dee656148b0a1a844000aadc8ce76f8127bf74bc1238f15a03698cb013a42a8a1f9308d41aa106e3417e8630e62c452b4e8e17be0f3d23fa07e6442518c4ea3f11ed25c1ded6e905b5696e1ddb9e54b9b38e1b45f5fd8df5351680d71abd851788c82e15ffb4cdaf9d17f32957be30581c39cedae1bde0c48c31e79ff5bcc5c8418a59efd867f5eb3a2d0559d3dbff1712b9228d45980f4f8ed3e0bd714daa79e23bdae2d08f008188646f76747ede5014792d59cf21fea6dabbd3586ecef23446ac7ccffc01bea2cc393300d6125a7e7d21a60503ee653513db94eca370ea3c55bdcd5b726ee3b3162a6561ec2ba7102caa325f660587b298ba33bf832d150a3be950b55e0240259440daa2252a9408f72496b60bb23f6a574fab99a8cc7e069f22bb055689130bfda18787d80a20b01dd1ee46505987ed1d545741909539fcd42793084b6cc4b5c49b4f685c41834c97223b8d0fd81023670c1ebf3987fc589506fd7f97fcd5d7f83762d73fa97dc321c3d632669770815ecb501acdf7cad03dc91aa9859ac710683a4389fd84f3a78d5784b8d4c497d8dd69c7747fa98825c01f48d81cb799860b478faae2bc065849e948dda865e0c71678eacc87f9391dc6ac2ecb82c0f47baa472ab8d6f6f040708e7c998f879bf3658ffb9a975cb14d3074c44ad709b43796b5b5e8710cfb912c5c2c56169c6376309d518184b1851ac8c2a8f49c08651e4ecdb59f078e93c647288dde9aab5bd42da6fc24a301294ea8d9121c0cce01b17da3754fc424882a696b85d7f7a8fcd85c5bd49c735b3b707e21d8c58732d56291b751f484ee1dd77d35ece16138aa89ec68b3ba08856f61772d6b86d1d4b86568de014638c1da03111bf1b5337c47b1c44f88215487b66f6ce39aebb7d84164d97ddb095d15942dec9793a79f3967c78cbf696d6b572a6143a00d57fb5c7185af26c2084423720c47e7a9352615008bf2808d1251363f45a26507460a54795394832d82ab898b9aee8fa262c21edfb2e3478c78f61d5da683406557037b3b796d4fa57e4a817a21810b01422dc0b8f1bdb68113f5f50108a27905b646fd62a97072513c2ec632f2185bade6fefc0b2c0836380d5231b8e43739e4f937cac153330d263ba42447b633549ab00d6c898cb7cbabb86c0a28323cc47f2b0093652de36ecefa60f87f3de13a41cf7eebfe685515c07a5f893da49a3918ae3ea4f51df0d9e4cdb3d311fbcb717d4e48e39620e25302ee43d505fdf8ec97607e198e8ffe7d09c864f9328b57f5b0596981812b07c4d74b62594e836125696565a262d88e47f7b7cefbec6a94f67fc7429402b7fa4f49fa8d0e3b88a937cd3720196615b1a48d0788a7fb527fda3ea5bed71962ed519447676b2701c357e8f3abfcf7cdd39d7d5c758cfa4a034e51f57fdc8388a86faa94dc4c9f0c8fbe1fde47e9231cebdf83a512dd95abbee28eda1736ff6173f589f8b99620fa705f127e44fd217607498d89c3efbf08107804958093c1687bc91fd1c7c27b85943b01b7c3cd93bed1f317c552f4e149e91a962d16a0c3b3b4c5e9fbc026a8a1b527f99f445f312e7e585803790291c9dce225772490c35280a1928336d4eebaf558b76490a286d36a6e123fe9026f7ad1276cd829f81b8ed8415f95cc8fcb5533137348d609b8cefad35a9dcbb1947f8346bdc7f5d7bdb3699340a734c279851e085730cce150fd336597c570a53567e03efb985dc3032ac95e711d87ad3a0357c60a67779a02c141605e24cc2d68d065a95672c069690184563c889e103fc00c5d96093b3675adcc439fb1464efd60905891217b299debdf1df34c93000214f0a2629d2cfd9d770c0a4ef2205699d2219c1c00675089156da99d9625c485e4fc36a970ae2deddae5a2963f5ec76bdd02508d858b54e8a65842fd3953f3dbb9816a6f7403e6798dce1b455efb3fcf2fa169f5546adb82abd6301b06ae084cee5db07415e2fc9e0a29abdc316ca95a310544fff3210117d805644e46cc5604e8ae9415c34375c251a5169c2cd0f1e474a1a73da0a307e9026d22e5ec40d2a8ad52e7ad1409bfc97c1310e3e69c96673a9b63c22ac2ac1ad682aab9738273c4a11504d5e106084c2afb7321dfb200022ac7ea0c7e018761cd627455e4de0ebdc86f75c7c54b1641200f8daf65274b332bbb0f949b6ddb619aa434b350f980f7683564e6f7c9c611abf325af905fbfba3f611c6f1365dd55fd328ec13fd1f5d0f6931a8e6c607e22a4706ca4df0ce18cc21c0bf4afc24e0391573323dc3ab7a090710ba77a7e9e49c0c012c91aa4d8bba1a3016ce6bca023da54ca722f060d984ee2187105caa7a38108a644ff24b2414000a1baf66bbdf59d81a55761f4992af45104d06ac0205bd1868801a76b9e1f0cfc3798f7121f6dd0efd765232e71275d2af100f8c56b449e3d3fb1d50796f6b5c9c420844581c536508d0a0134b1cd4800b4fa2ef99fc22e9b03ab345a4fe68f8075cc4405bd6489a7e887439c04270e4afa11f29b73fd59c4afe884e70729d5d2ee673d3930c503501acabe2891c08697a7013fb3d07d091946c61314729fed05122a4812eb9298d8ea9ff31b5b6bbfdc5dd230889454ec5aa1a8d2831269c7824d5ae5c828085fcc90592ccd17e602ef38da81e87b7716669909c7b8788687bf86d69dea7fd514426f5aca5713d2d3fc976247402cb805da7e28f525cf9ef0646a64d9f9200ac85c01e6210828c2bba7416664772c146ecf90e55f25f6717b6f48e0f8d623d07dee7ee7ded3ff07f9ad0d538acfe847551dec86ae87a65344698c7be512a9bf7f67419bced642902ff3fe520aba6602d4b81e7cc008a8509848d43f11aeaac5aaaa1d40aa64895b8206096fc36daf38bd7b90834b8e687b2cb62ae9e3b4fef298d5a1bcf41275c99fe72e3857721ae68d5374d9234e73a44c3498e444a8508398ef0412697b538f6bfce54718a7424b9859edb92eeaf98b32b5f93354387950ccd4a2a1f27fad59608e3d4bf880a11af701252bbb28a4a4714d99f98445698ae8ef8eaf2f36bcd2f0a6eabc49f6d3d6ea89812fe3a3aa05b9c197f64d2a0120d60bf86ce938742d9bd6952fbb9355037214505a67ac89626bd4e2fc778268b3c9db4ee28cce5c13081fbe5397b46fe6539076cce644a8f423ccb9469dec1d841685865bc32b454ed5e25a5b379e64eea38307cf151d83c4da8319f0c5a85d3e10e9b4c1d3e416284c4a5d665741df5abdafaa9e0e2949c396033ff7c0711d4ab9086bdbf7748556ec43f467216f688d7ad62d0451ea6347e257bf35ac9ea4fae491354f8d90871ac0d15fd145ffdf6bb4495f491149f1ff3de661094066d4ddf8f20cd13d192b92e5efa2fd75df80283a36ff02f45c25c45d40a65ca1a1181dc8f81aee7248854e814f8b894c5b4eb08213743724193bc0afedaab9dbb71298cfb490adb347a8ff001d504e9204f968ca51cfaa09965651b6001141af59c81d48fc6e544b42746e835750e1315229a88e7e6d754bee5cf31e89f1e8451884b85a5148bf85f9ebdef5a876929a51b54f0f9c352091ca8b98015f6d74b1ec1aaba96d247391b90fce011e1698a2215e7b4cd7da7e90fc8537af306b7b9f8e48b998cc8557da6d695c0fd7354fc056294108840c6fc6a6752cc7a3386d1f97b66df6c36a5efa8f06673980d506cbcc73ba11c3848d2a83cd34f6b944d5ab5bab103c6793d994da5bb39ce20fe26dbfe3c515bf02cb8ec297ea06c35bcacb6525046d9d22d81849bfc31793bf67515049e3a82778dc7e8147241efde4e269579e5ff9b7ee219b2b993882fa3abace415b600bc1bc0457834c150d2748b537950b9c4c2213fcf245d7d8d17cf2c32db06a761a1c02afc0bd491feacb49f79dfc91ae35f5319ba3da01a264525c72b367a225fd041ccade751e75bcf456d3934e7c69bfd246db51f43baf476bb2566e30c95eac1f846f4f52750b3812944b18973f29293d7db961756cff813eff9591e328b240b2a53140a4e6e46e8b627b085d2a9a054d233c419c619ad3d546595e5b675ecc8d9218536f88174c7df4de3a32ca84760e9d37b0aecbf6216ebf0d778ddad11671da9d8369ef318ca79f9112d2895707bcab71e57891c276ab603d5f4d8ea08fae2a5cec939dca56eaab8a1293962fbc4bf9a23aae328e1939329d7f7d29dfdd2b0b424fd67f212eed1b6d2e7570c5377404633580dfa67f28a0102372b7724bfad3e5b99a6e04aa9da9c17da278a19199e8f9a95737c6d8eaf17374bd30a207cf18a676b5cdc81887d26c0f4f406d3ba0d4a5df4cd17ed494b8e4e75a488db6d3d5743c06c888b1d178827e18227fd1e05a78b7fb0f4c17d3e061222d988b8cb27b148cfa9d7ff18c04902341627cd63ce9f877b548a3b643bee9e1a3dbcca7f1b8562fef75c941e089e2ae24b2866f5126b57c0b31d7424adcc94cf1b15004263f537cb935b4b7a5a4b8fc7834034b395519f4642fa0083c0e372f05447450c5dbf3cd97597865715da0040d37422a6e47c1645a165e846cff368013c593edc2fd448a057732431e9cb0957234b02cbba211f41b6deb09799a146d9a207956058cbea9707e5f821f5a6ca6a4816aee8cc5424266ea118c7f3a0191a46705a0f78aae59a4084dd2873edb8ec644caf70d29228c1e7481e9dbbf78321394f4ada79aa61653122e27dd616083f073b04eb0942989c74e2aa975713775b294d6311a928dde41d15168cdd0d0cd8b7b87cba2b263b9698a7251af0f3d37a76fdfd97f7871db5bbc82a293a520c29e9c7fa3c8f9ac38013a40d701a72cd118ba5dc756d25c9c6e7823a8c1a2b146d3dfa74da3d5bde5c4846b355a99f574060306f22f841109e610fc8ee59853266111542593af6d7369e5238c0721b92dbe258873714151787de5e1ec7de836d248bee8b30212bdb3cf648dacf0743d6c9912e5224bded3d222edd61023529b7ff1b00fb8ef427ff2f5f3ff189bcff9f75507d90421af29315f239cd4e7ba1f0540836d7a538035d12a34a7958a5fcaaa1d48910bd5501b3afb86a1b355b1f2d9df7ad7cd332021ff15ccd8ef6e6420b2b1874e90969ecbd00071c81387f50b5f2a086dcd5f5310bb9d6e4a1b74d9fcd8ce1113c115df5fec08f73a3574709c5a97d15658e22e14a4e54e754b14f7521df95ba7007c7f3e97e0f6ce1de7f145c6249b57e1d7c0a539d906816f1abf1a5d53795b421af91915e47bd33efc6510636957ce224d85f21f5926dcc50895d1224868fe8d78ef7e1bf67d1b5b8ff412e66e5bf3d9d311041dfac409274f886100dd1812cdfaaf2736f9f9f6809e18dfec6fd93e8a0dac2b104e46ca70dac73280098d107cffbd8350e434eca915d089480c38f2cd340f7d092319a9892887fbe706b1a238034704a4b4c6dac71ea32e1cfcd4bd0d99526e72ee53a734cb8b1e4e976f99170e7c6dbcf84188928ee457fb132ac9462f1ac83a700bda7883052d7599f77c2bd3b38a9e43dc4f5850222c0eda600f8eed330dfedfe095ab0a4ceedaecdecd9f535c583a50b4566b8fcfbc68338b2bad8eb97267c3a8211b6c88233c249e260149ecaa6de3f71cbc49e3d8aae4a439a9c31c961b8bcee2c30979d28cad77edfe2d9ed6703c19b942ec237aa9afb7040a15696463bcf8ad68357b1137c25fe5e3ad497d80d2b095fef588d3228bc697e3b1b275f377da513ec87d028ed548bbc2b8aafc51b528ba94c0107ed1f1956567afbbda4692632e5901d0603082819cec51cc757d2e05e9331fca9ba66e691d5f127912559229644f98a634d07bbc63ff081074afe428e2042672b0cfd239e42187e52ce0d006146130b3e8b420eff8004345d8e4c6aa225f93eab381eb96b6d98329939971b534ef9c82ccbdaccede15e6a945fa603cdbac2ebf385846864fd30",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"2e9f1b2d971eddcded8bc3076ab9c3f0031ee792a50ec50af9d35e295521d775eb3476822cd1421c3490a34c4b0d6fdfcdaedd0e3a991743a3bb783993f5548e593d11a5ae5ffdb1197dd6ffe6bbceb726f7abdd1a44eb544535dbba01f5ed986d03782a404780b43e5914b7de443d989f31a87986ae5a30daba9fe9e8b3888930467b9d29583345bd1be8f40081231195acf2941ce2bd867ea15ee4689532a226965a1e4bbc70ce44d506194dea555e86409a462f2f88a449266d7d07d3bbf0e0e39ebe9c3cc34e9f94a494ff00ecd96d1b4d8b1885eaa95fcb9b4bd93871b7e26011a863168c94b98d883d278aae9a8512ed55c009bb8173494123ef610ae533550df03a089a0559174df73556477a53177030e5c436b03637fd759b82cd7c8e7928b72a0224684312469284f82c1f5bf38c83c0d3574c4d44fea4153958c514cdfdd00382b4a3d210abc66c7a1f3d6ebaca64842964fd85b8681970fc1e369b3b6a319efbb09ad888d92d12ae4789ba8015f278cd815975d0f2eb57c621766547b8a532d3fd8b7851df30b491f1a408b69c0c6e56077e55dbc3003183b9e991428323a7ed00c2aa31adec9238e7f6332663d6d31106fd9d253e6351f25681cb81934485373e525d4bbdd0fda723b556f3f7fbc097ad8aef777b9bb230e5a354c872aee55a9696baf88604133b7c876cd54e1327b9a924294e4c6b37c26d6da633ece6fccc6aa3116ada930b16931b87f3125be81f277d3ab0bf7e7c9f38e5ba0a1934e36841ef3ce31e5aef293ea2eff2bd520225633740b167ca5992b2250f914d0190865190c36b54acdf4969b60e0027f740fa27b1deebf832f5fdf9b41ca410c9f1ed521a7dbd8a94b000945bf515bc137785bd44fd54156e2c97a7599b3a9581412f36599b771abeecd73bc94d63f74e38dd524be43cfa3491e9b8e5fb8b88ae117a10bb0b14b21c326a99b6ac6656a8cdca2364be8605bf580376215685215757b7ff8e3c23a59d33ef22f06f42cda43bdb13a8de132b46d36ed91acb3f8e6275746519b2729a3f22660713471defac3b6a55d3cad759ce250aef3f19c07c69e445d880283b4ee7a14ac7f2521bf059e13f7d10b889f98054216fa283a9f0ac22a32ab33f389282b3081eec97e3d3111d2c82712a28eb37d49ed36799980c5c7ffb610fe79ae13acdff81a9f82ebb8b8328e01367c9fd889a1a31e702afcd5676368b8222a5b8601767b698f2ba702c6a43965db7c22ab7407c475d4f72d79161b7d2ddc44ec73ff6c7e9e09be8f7c2bf9d84e9e689f572f3073ccf6e52c92a0bf83e09cff8e434e5807d9728a5e8e8be785d95c2d9a2d73084cbb226007e70c46a4728d58e939b77fa65dfab5f757646b6721cace23795072d35813661890e743a806107a40bb23c907e70918efd8562b56e8e83088505fafba9a18c5615c93f98cb0380b19a3795c7c02928c648220e84c114a1f70d7869f9d3f91bb72a860f2e124a10b47a4f01274fe26e0d2d5629a1d8693d79352e9cb2ff7b1dc63219ea3ef709e0e63a2e1f0f465e6af54e138635da7185c7595bbd148a419129d91b1cb3a6651de9924786103f5f6d57968a2df5bb075e1a03bc9b536e42baf093d02eff946cd81174160ebe1b7d223d2cae0e32018551b31ef77b05ae19041fec6006915239e7f793d033692f02b85eae37cfa56e1d808462103e2eb1ec002eac45c9134c27b0969b9eaa3d4842a28d44935c2c76f811860898fbfc2e2e9865bf764829c8790c0438ba4757a585f84cde8d336956ce99a44a65d5b328c847a1713b0bfbf43cc65c8da9520bdf625c31f026b802e571a879cd0709ce71d28ec4df44d6c1edac5c35c03dfe7411e60ae1aca73741d7507d4db28fe59df2975af6f5c10e0e10997fe683ea7d30616c416282f4cc40dddca0537c4fb20b11fbaa0dcb479b18d79007fa1ad2bc2b16f11dea199c0542f026e34f136da017874f58ad3e1ba48ad5c173b97a70b0a5242f4643416d0b4afba13d0c0ec334e761387a787718c35db2c635d30c7b475e28e33e3afee773c599636d76b08c13707ffe390c2ad1ccff152f6dfa9176cb1d4dfb7effc7b98488e664e52c0217ad34ac9f18dce1a19a61f6e531b378155f7b036882bc0bb338050bb8d57e124ef3d70b88ba4d82d1b70b7597462588d7edb5a94d19a39ee73bc4adea9f269008526b1b2945137dc660303cca7d38f40c4aef3e48c509a7e4149324832e09e9b943ec43f9b18facf6b91f9bc292496b0a88baae59e94eca7b560111d80be1eb0e279402db9847965db6a790522d605e0dcbc0bdc5908e6b8f68015582713d9e5ba75fcd2c926e1c76bd9e929d72615be75d044f55de47c604ca8a2929c635b23ae361264ad9e92e701b4133e4a4e3de9892066c699df6df836e1daea7fe1618261764d28dd96037347c4b1573354b78f8a5e315f7ea4b0c388dc3c25e286d5613a83616548e847cc9d356178f432b348eced18dfa43f7a29d03997e4d5a03bdc454a66d901bba01bbf99faef5a0d10f55fc24d4608e92150a5cc6f1fc94239c3781cac1fedfd490609b9017d1712ca97a0c31afdf00722333fd8dbfd197b4fb2fc521f4ca8f27e3d27d138bd880a0d52c62b24204aca927e5a5b03d523889ab9af5ea87d633d641715104d8e925a61250e07d2e102c52ba80c0d0642ae21ac66d00c6591dddf2335704b10f331aa3c3c488900285cb2abf93f4553ce4e88d9ffde0afec35663f03e2779a8ff5ab23807f8da6354b6edf5134a605398068a071c63b4ee493a23105c3f6d9fceb477198ddaecfc4ea69b07b32ddc7ebddf910de9bdf8b6c9ec249d8c1ac193b2bc5f11787bfb7b2bdddc32086ffc61d5b30c9df5c0afcdceac1171a9c1104141f57ed63483a9c37f69d97b562cfe20c377671bb5399e63946578b059898d93f12ac02e6457d215aee32de1e299eef16980b908ac956e909291c26b96f0fc30b7cad1659b45eb9a96e61c1228f3830451c46495b49557a6c2c84defaf3aff36d5f83f45d903893b0596739776e2f619644f65ecade5eba2d47c0f4d6ff83cb37516285a6367f93ff7f51199db09f814e363edd1a0c499b61b07a1ac9cdf31321bfb6444a82b0ca889596a233822d16467860aaef0287eb6cb30cf8d8ade0750edca071ef611ef59cfa5ed322c6401bebe646e92525e04c677a2ac6e4bcca8649d98f4cdc4049cba4189fdb4f6d3b302bae2509c24fb1dfd02366a4f3b0ae9ed3929d5ff53cd2a52f79fa5f760def0c3fabb7ad29015630a1db7c94902a355f9253b04b27b37d4032641359b8a2af4873a00935af24b3581eb876dd5b5b77d333624965d9f111a418c6d52d27ec077bbb6e4af47c30c1af88de18e78bd12ddec4ac95441d6d250beda3d00c5749297a9d9eacfceeba57c702b40dd689c97f814d875d7801467a116c18fca3f87d29aaf7d93df441326e915dc4fbfb998a09210194b83c0f5c026abde5ddd84fe6fc0dab52f913aa95e18a17b57076a45c43d462618801a2a491188b8669456b13b5cca4a8af9743edded05454a6f2daeb25f427b0e869f93b930598cca12cbbc0c76934a7ca189086447bc98efe77fdc451ceda5daa59f46163978f066cd201264cb07e5a4b060932e908a3f3f50dad32997802ba09d260e5d34ad736b0fa071b56e903171e0b6ef7a315d3f707e75813de262e9fece391ecc13c75b8633fe450535d8f376f047f3cfb95d8236110acf7f634570badf7fca12fc67597993efb142f8cc1b4155a12e589b8ef4751ebc79ac76dc3081ba98b39ea862d0acc43377608b85234ca37518f77b5f95f4f0c9df443f29241bd37e0c5b2de872c4820e080cefa55222c4bde0b97064f25f1a1bb22ca5e6fe46ef570e5967717acb5022ef3a16dc33eba4e9fc073307af3d5121721b04958c15015ba717ba0ab7cc9f8d09478cc1ffd8a95ef7588cf0913d4962e19c20bb3eef063df0f8742316ef2e716fc1a07cdccde9f65c7f96ba4905c10f1be509feed93ca9c87fa25e69fdc9bd9a65645ca88959fb9f192d9a051d257762670019ebf83a822061770261e5d853366480f9e78d916bcfad408296040036d8ca110f1aec995b3a51e1cee2c091c42d822bb58e5030ea544ba3e654635a3f6852f10ab8b20261abd29728386b7afa1c90b22f501c2a56791290c7b4cfa45f00e6e5cf9290615f5662fa14721f4bc39b5f1d8cd26e48eb315bdddc0ded1761ac2c35fd19e6c6b5b099342030010c359c602d884d5bcd1fef0b767f48007466fc5de7e75edfbb0d0bf5283580806a1206ae56ceb33462d73f7963d59ea39a1573b68077b374c78c7f9c2e30702a702de89eac5dcd307e4c15b5fcda71999717c4a62ce39d5c8f0d64b04432db805e6fb1eea5bd80f24cc16ada944460f6dc7b87388cd35d95b31c556ae2fb3e38adc976bc0b0cc57195bcc5716da471843765cf56463c5dc60545980c3e875bf34b0161d151289eb40ce4ffeb622289f875e6c772e36bbbf4adb0219ae5a57d3e538c99aed9dfe25996933982b16edcdda63b2224ee328ddd7c553973dd179fb103214f8b7a2ef64be5cb4902af5d1ac34143789c1b22334a94cd62f0c564540b622a4fe64f351e9f0bdc38cf67cba390a89b4f31122c2af687621b8e73564fdc55b1f47d726456a5d680da5d190a6964b75d22cfd2a1811e122da4b13d418a23d8516c00ab43258ad1a167c4c646086a393453a68a7d4ed728390c3668fbd5a3249f3abfea61fcce739dba13d7f54452710ba93abc3fe59521e6b51f75c6c86eee2b802eb91906a2012ea2c610cb6ccce1426ca387cfeaf5adc58f8efca2be5c879c4ad7dd5743cddf055d2ba7d5b21c1bdf99b0764db277c009f4a74551c2439c3077a622cdf71cca3c50c7566672dada194a80b87b61fc9a9703516d05416bfbbf8efe8b851274b4aac21ddebe08b59cfc27ddd09e62dd2c204ccd41e7e70439f14c04c301ee12510829915cca471281aada72bce316db43b300e0db02f2de5c5b983a0865ef040e07bda1abeef8aec9dd35dd1f0d682c74143e4975a8ad2d47388bb11ac712b0d497333a2f7d8a1f8c592fed73cfeb44608395c961534b7553071d5f5a8c5ff577fb9a256e3730d523eac6802c2b3ac51dbb3d99e9ef82e9a665574284f20e03eeae9bca77304aa9bbdbd0e5a8918079110cab6f360b2cac2bfec486f0f4fe243103d76e4edcdb6a45bc26d1fb1ef7b27f8fd186a51ec05afc9293e7dceb7115e3f5d704c2e2a97a41a4d0e020dabf71c5eb383e48afa92d92ea6ce6a0a49bc03b51bf16054d0edd8949a989774021e2a33c6ff3bfe2d27c30af475af7824feffea8504c344fc53ca7be12486a14bf29a1ee7411e5fa9c30d1e7087b3de8d66cef6961f0a8aec5d9b2028fa7b616a67cecdad5e87c336692707a977667c466dafd5ca9fbd4d82a95b8fbb290427012cade518643d4bf23a3bd3bd03fb6764aea2d67712e6d9037865a73b30c39d73ad646c20bc7ed12d3665d579dea7fe535ac2a793ad000b5f24bc620262757120cb5a5327b9528bffce4a1e4424cd6d7f4763d32f39994fc1354a951403c4c9661652204c54339b86b9e0a3502061f46c49ed270640c0592bfeb3be8e7ce46a88794ba25e60472824ac99b1811cd45cbd5d318fe142909d8a650697d17fd9d9562ab9490a0505be9bcfe7ff076512e9a59e82d0158a5651718d3cbfc6aa1350ee9f5a3dc92fdb3c47f455b837ede08ff887a13932b99caae20cf3454a93c9552d2b576090a3732fa060b79114a25b7a76dca543a2dc6196c036c3fab400ecae7f60db74454951470a9115458bbf66249435ffb072c1337590f216c66fac68a4ca8447b74f0369ed495f08cb47f7e2a35c9f3488e986df8515f6862ed088cd1664aee5e795243b5fbd97a0e9b02b4a717b6a465dece97bf94eb051f005c4c6bcac464cc2eff1ef76d0354445e3e6c73e265a0d8678b9d03c7d7297ecbe05df1b6c1976f0149d3fefd281be6e7b2ff4417807f98a915fa2f547ac1e0754e4aed029f537ceb73ced97dfb64d72310c1aad1c6813309cb7a5ba9d9e0a680d03b485deef17e6bd6b37d68b735729a4c2b6cd9171247b9e83f34ae2bdb9b8281d44b19a3a16bd435de67d279cd409b49be9c9cabef9c33369e276a1fa877aeb617c158b5a81efb72a2560d0d5d52f242429aba494341ff666d029a81b73851a3a67bd472ac45e246505501f6ef3d96fb4d79bb7db21c736f931bf8d587d67e52ce0d006146130b3e8b420eff8004345d8e4c6aa225f93eab381eb96b6d98329939971b534ef9c82ccbdaccede15e6a945fa603cdbac2ebf385846864fd30",
+				"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",
+				"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",
+				"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",
+				"320874fcb8dc9994f4df4a2aa37998a47a205b077d37bf1883db5884e8f90d7341cd254e777b0ee7241ce0ae3eee042c6c7fc7d9a28fd15d05844470767b3972ec05e9987bcabab8b31dcf2b6b9901e458aec7470c7804642bdd474a577736f8880e8a1bc1cb69fc40505247afd2ff5e2f593212521a9853900225abe6d962ecafdb8c3fdc97545de2ea474c290ff766b31d5883d51158cd7dd49a6e00e1a3aadaacde913a70cea960a4ed2658874f08793f08a8a476d3fa5c19af8395ffd525c0635418bb6f4a6294676e4efa561de44bc684484d03a3dd1204442b8b90df192e2cacd8a41fe5fe4835eafc607965b61de75bf9f9a4ef7708ff2cfaa6f30af90340adf57eea5ff9094f21c9dfc6d5f06c42039e8dc61d9d35915286effe7ab3db9c375bc024772798e13836e744159514c83acbbc56de22ccb2bcaf733f6f0691d2d07a290de613ebc5fa0db39078584a6f506e9fcc5f45a3132fdcbf3906e32abf064a113bf9b75109d34418aeb70d8c2ec1e08eaa559f3afac55f49faea78e37b4bbc6163b7f9392b2488de06d493c495e9baa5cdbe662b78e50996f946278748864c9f36784d8c726323226cb0c0a38db3d8f8d036775ac026b8bf04688fbf1e0b520ce96df7450bb3e6b17b196ef079ba8e24e9bf6231b9d9b8e84d1b62252fc76bb3611e750dfc96d5007624efebcde1ab4b0326efa4835067d62c133d141bb002ad7d270f160081b80191fa17da3ef8d0af809776849989e5d64a5679be20c6027cfd0159451f0d3abea77046e5407cb7019b682b6b5be39f624e7e98a8513701994e8d4a31552d8569d78ac35f35305a7ae327a78acbccdb784a2bde1ed81ab13c6f6aa8762d0da7cb4f142768abf4eebb0b4be340220175cf2724fecbda8b5b31033773733c73089e46787a0610b1554681066779ba0897bbba48cadab026d1e06c636de3b864a8f6aab94e08ac5dd6dbaf500fa33783254f7704bd83272cf361fdf5f55ddecbb2ff085196d15a833dedca487de51ec3508dec5d34e2bc633af681a9be23fbf7f6e29e4e693fbbea80b3ff5ad7d8cabc4f025ad1b0f3630ad866be06e716c059af034b4e1723f6d9e4860ec711ee749299c5d83da242928c99fd66adfafbf3fc71eefeb313d3a0cedee00e44ea79ee4896bf0c4ed046ef86cbf543f62b995ce14c3ffada875efd1f5d3f00b341a44cb73a4e83d9a7e21074616ee9adf9f194ffeb7c826c4e0770733d5cda58ab58322180d767ed9798c0ca9f0f78cb0d6b872d0966c5befc874080e46cc3717bffb7d24551889d75fcfe0e7489b422806abfc4322a26ffa58921b796ac583c09dca4a9d647dda7edb9f6725b0317989c7d76ba47dcb471dd796bad6d1e18e7b50c774298ee343de23cb4e186d26d8f3c2d5755674e814dc23d81a892d55af912e8d29e9463f5a7ff0d526715c69fe2ace6ea24c3e77a01eb253f54bc87480afd3cf3b2ebaf55e52b5675f0799caba63a3934804a5b86b1cd8b8962e0d70d09328f64a7b49eb63863695c098ee411843747e703820485cd65a814939452ff29b6aa080750e3a9765b4930c1123883d4f8655be28732dd1e3e65ea7878706b1e397e79f0a345e5c3df2df0630df76d913aeb05b335e9296c5cd0c2d9433e599050466b12af93ab07b5fec067a4a124ebe8664a7227a151c1a7257a24b2d34399a881328e1ca13ddacaf5c9aa3cf2e6a565d4a98e8b730c8163d2d0ff4e9d918754022456eb41a8d3613659c1d0e39facbef92ded92d973f031922f8fa8f70d172796ed153f9bb0d653484c9672c01264b2d92f6bdde727d518ab66bc331fdd7dbf9c34b2442283d60123e2931a4868c961aebb001784f58716b37db82a158609751bf6d39404fbc457acad24ec84b85a26e490eaef47e2825128e36bc8e031660d74118be8c0718f5b78a35f530e941d46a83eada2c8a5b4e0fa4ef4336f866744248246e4b2c535ad8f0ebf36f71bb5d458189bbb1066d532ce9a9e84dbe33ea8e814df2fd53b3ddd460b594d54a80cd1cecc1dcf2a48ab00cdb8b371923e667d625c8ab0eabed2d83ca51b9b19909dea6eb15efb51ef1db32089b07d2395834ed5bca43f8bfe21941f57362376ee081aa6a5a043db0a308b5b4b905c65c837ce508e9fe314ecd532970e0056d00fa76ee13ec50fd20731cb66a286a674fb7ddbe61ec14fd45a88437aa033a9b2123ec8d7ea00447c86bbc053f553d9750c518a0310e5013256ec640ae8353597c54a054f079b24c73428546bd23ed297bffaeb55d09ae2e9e02cce16d4dc5a386dc6072b701233d7a565dc9d2118db3b718ffda5fcd236ffcb5f58a0d864e484ee7d72c02c9ce3ddc6d5aa8c61d5026d659cadfb5a978184e7c47d9c4607a6ab0d8ffe48f91805ba3a9ccb4e7ca8971864f01eca98e7b5f43a09426d60c5cc87800afb9968f1094b496d15e92e3e559db5a3f90593eb9bf9c19332bfc5e328ab950d080c96358aabc623f683c491eef281ff790d84c080c75f5939a0084228666e9f1d2ad7613523b2530302c72d4916c2d183e44a3314be025a0cb1d9b857ceb988b58bd39055e03dfb3ef07502a2dff9c1d3f40f2a3cc9c7c9a6d7bac943c2c990e45d58f87e1c2f9c32af6356134f5d610670488c9b43e334b11c2a7f987503a71cf8c3bad740a470d3751d11c8f1b60f0aba7f994b7a6e75c0027c3b5f2b0d733f17d08db11ac4a690a7237241ce4d8f3b71d743b6a71baf7921dcbd1e41d4387dbab201d77c0e256b178f104c5ab0568a66eee0001da790953acef406544ba8c22b3783059bc780f35b25c21304e41f63a4c7661696059eca432aa5142fceed8bd2c368093b14110deefb8e051d5b02448de35b29180a7b14558423add3dfbbca1d619220eaf90f06bda0e9a0b47d63e6bf6e3d3a4fdd059a4435103b43186bd569622be3791f6a5b3f6b85577fb80333f563ac75ca5f61f4e695a47b0deed8c6ef6ac0b480c0b339d57ba46cfbe85dfd29733462db7908327a5d7ce129ab5afc4590cb3ce0edfc5342564b1de184dd54a0a4375545ac54a3639362ce704d0d5724ec8cac0888608f6309c7b85658e6cb4e454fe265a0d29ce320446b5d8d9347689d8aa1458e3c9ee89cf73cb635e84357b371064fe2c4532effc6dc3c298007dccd60e431b9670c10124290c714e7dd079da82801b8db983df3f15497dbf3bf7279d360d2fff58170aaabc0e099206cc02c8ec699807d624917501961868a52c98378648cebdf92f51d21dd8a1ec89925ef0e571f9e464e4994f1d0284562e005e2a53f2a64c78538e3d82a7a1c9f228c5b08b2e0fb2ad9707d0f1ac41cf90daa704c96906eafce30002407d5f37a5c34f96e7dd9f92b1477d29e8df7030a62224de68a9320db6653722d6fdbdcc0fbfbda053f9c8f3b2c41765f2916c598035e4c1fd26d1c5063b7d80701e15f1b460987c55e4da30cb04f96ba6b5abb934e884cd489c4994b94de237ac9601c415159e5b4bf1c75b11c47de604f7af7b467c1849459f1ca2f22db77e2975ea995833d2e395267727d0f8f77ddeefaf3df3ef12f0fdffc46f3d53017b8b0d6dc676d95a5d9327d35e6a7cad33cef87a620b27d72c92bffa26a0d7e8babad5d84a305455f97339f756494ac27670f37a703280d3761b7ea0ae37567bc8894cb1e5d3f3849652a3fc4a5c413f5d0d42be847c87dd8b7bfbac6d77de51f00bfc81ddcfd418192bdee13843e03a699c52760191e0916523b13682807127e5142198686cb2dd8d0a03559383305acb12b899851d32d5a6af4d87368e8f7da281221cecf66ec2937e34df4f8ebacadc0717fe69b015ce4fa6ba053f912f1491daae582333c0c2c4d18d7f19d926d487380bc19db28d7d0899511858ebd00cc637bf56ded344517c9fe8e14723adcaab57d90d2958901edd47e8b4645b232c9a2c9dac8d28691b7be0179090354d13cff2a01dc9690656f85d0618558487b7c8fa738dbd17fd99bab9d8b21748e6b9b216f7d056788336bedf64449209445d5d103488b847d5ffc06ecf9548824e3c0cf5a84d5646dd55ca3e190cfbd7940e9b3201ce8d7911e14c1de47acdbfd10f02f2b1efd860e08e8cdb658b8e6c1c5a40349b720a6b267aa719df4cc6c7596e6897208881988f189c7806095275e8735bb2f62d19ebca995783d0eb936483b0e68930c31071a43f6790067f119336739ed17a2bfe8fa41607833d6194b5cc1900bf8d19601ba12be8473f836dc5883ff06e885f4eaeaaf05d59970713d3ffb8a972b29391d3bc31808bbced4c5af495f8286156a0c03aea18db2a60069bfc4d14df1238390e4dd816a6edf28ea1ca71cc2ae5d0a26fbb86a3271faf6cc8000765ea310ae979fbe377a1ff044f724cd6a389aa7c24e2f0aabc4b8d408ebfd92b2a40f16125fc4b7a5ff17615c0a50a3c83aa54de3ce8526e215a6de45a16e9d3d358b039325ad378c0abc2448a3bb8089e842fa848defa7ce4f2fab5e966b38830b9ebea02ab0a8225621e9c8ee8908e620ad020c058d7ab25003899c225d77aafd3c492622b9e8ae9f98d512667340b7972b4c840a7afcf7a75a4e176d8867f9fcc26491d74a7827762b3faa51599bcdb2c1bd2a0ca8b407f4b5525f144ac9ae9f7f5349d2832a6ff0bc3749b3288054837e16a910ba8d21ddfb547014b0820a971937087907e7b96f661caac4384fd44355ffecdfebb42c44c244bbd6a5729a194c241dafa0803d67dfbf34b81c6f55ce5fc07da966a688f304eec8f6d47d39c0eb0350c728a0b481999b9984f53d0b542c0654aec61b49b3f9d942d3644c596892c7f0e20c569b63fc2bb9fd2cc737d70892f3a73ccb7f306cb67fa027d162b87d23ecd73b5d0d53926ac0ba21e1bb25f63dfd22c32f71c1a7dc0ad6f3d354a260c139a88d386407b478ae8476e846aef4df07809680ec3d0ebe5382f905501fcbe5af86ad584e737cc018920c19acc39fd5e067279d72c19ecf80b1a6049715be779f730efe9d2cf21692abf138b4482263b6db65fa00efe7fc1f92877cbf89a7d77315c06ff3fdf149e7f4580131fc88ed7a401e32f87e52c354fa100f343e5520f74d52c86e6e364499aa5b609608b3a4b2936a817f12bed11540f5561d1ee105543ee8ec48adcf4a78504478017f2cf110ca127d689c5cbc0f80801b98e9db87c18c3dbeff208fa676706e989ec8472f184874cd72e8f1ab7e461f20bf8a9420b9892b4aa70f80450e5b0aa4df5335e4905e6e60608bf180cb2e3c06edcbc705f6707a4f9658e7d22c259202bcbed6947d4631a2064bb44d958e9d3e4235805e148f38f495102c17a50ed44193777d221e4201098882408cf2d5c39c558c8ad2e1af20349784f6c48064d485f951b5f3b2455ea10e4b4c49ae98eed3e0754420922643659f72093d18647d2919b2e933202c9083c81872d4b12af41013d07cb6fe084581ff90d2c21fba51f20b5225b3c67521e85ef5b56cb4d1255cf117e78d154d9dc8a5a7ce1e076a03d6ed91b5ad76dddf5f98b760b505abbeb77a73d183b1baf431e95e7afe7e8a72e54dc42941f7734ff8569a59246245ad643ba8141aa293275e6b323d5d43f7edb6426fbc0c15a6186c5bb6fc7db088fdcaa79b81c076d95ffdbd011fcdc2d95c928a30781f253783e3bc116db85e3edfe69a227f799384e9f505226a4c02e941d26dd8d941bd4d2a215a9519ade4da4f770d374c368dcc6cbc7b4d11287bd2c7ec92ff844076c40e1c9c770e681bf1e09d1752d8625d33336500a98ee375f774828445e7f88ed8b13bc7508e7c6cdf19b70381ae582dfcd2376ea637b89f1db62aab7154c79e59f104bbac1329ebb7f97d65185e388abd2e9239ae5b30358a081c9ebdb9b35766fdeed7457079c4a86e7a4e3d809b0193ef03b5b637ea46b881d2abad23cb1b97a5460da4293ae41b46868a5aeb728ab8152882b75d5339d44278c75ef35e6514eb3670b237c6389c1f6b8f8e8eaf7a6988a299d4fc26a89bdd930a7f785844c9e8545e6dad410eeff9f09a68dce5fc13dc331f7450ee38dd9b30941e2c40358991ed394ea3c674042f0f048cb8c200e9b123adba886353e8e52220a4ec753e4e4b4d5648630c16d538c64ef3087f034f7fef5fcb18e183468429ce5e479c7d106149a07560a5a620ec4f5d378110ae30c6b010c42ce3c93edb0f2263c20de6bfa92bdea7206cfd1d981ba87e8221028ec449d5a2187509a1710d4f5023868c5ae4c0defda5183b7f4a289b00159139a3161253ffe47e77ccfb3ef8ee1119ba56b51e5c626de41f5ba197329939971b534ef9c82ccbdaccede15e6a945fa603cdbac2ebf385846864fd30",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"39d50598bf0157950c6f626fb8cd21ccfa55e82a86e8fa45ae8eddc18767b1b0a4a5d5080511c32a0cee5631804458861a86fa4b4c73f2db345b05b2dd67861046d4415e87d0b0c0a639f74c9fa3d4fd8bdd56e55034ea341787b565b07c76f2bd49e5cb57d10660f79dd06cd4f604f051d01b3fba10f9285d436ee7a8d8d61791e006eccc98a2222495ea3016365bbfe73b94ff1202fea5cea6aa20b5f82b2497e066e6a803533fa6ce70317bed8e652f470202c9b8c0cc72e2573251a0f5f70e89c121993eae1cb6740088010e0753b174ca4f6fcf236b1eb55915de61b079c9c2d05a34b274fc1915fb44ba6681bae28a7644f49fc8493a4df168e690eb994642ce1fd175951338e54cddd103223b8824c68804dc62ec754137132e3779b82ed74b123fc52943cad0d0bb06119ac8fb9b82fe302f7641af849775bb1db27d01e0c5311b9d03a6bba9719be72e337cea2209b3b9a0e400f6dae6dde69e618c865aa3af16ef1ba4d9b48ef5594f7670e7c472e2be49a6ef06efd2ade1665e8182bce220eb9f0bcee0ab1dc67a1f3657764fb8b2ca62e212f20ecdea55d7384a38907d7b757d2a03130c08abf65b56d9c6ae54e1d9acd994e62453fae9c43630079502b0cf33d22dcfd516b8d2bccde2fe70d74fd4ae24ab5444e6ea299e13c5448eed5249da2600012fb95b4addc28b3a4c15689cb416c119d73a65f0fc35c7c7a2b0fc365f8fe1915956d4d70e418ff62612364a9650bc0d485ee49373fef0226c97d2a6232984fa03d4be23251c677a8022cf8a9212d0de901e9d06187753f3e22995aef87284f0ccb40eb92b1af7f64294ff3b2bca09456933785c06f5edb0648c2d86fa5c2bba934cd2c4c4d0149e7f3b9f0632406d1724bf1674d4053a42d88de9ebaef134adfef817b1d6b026816830dd87e2ddf31717801b93d59f2148c28c678f17a1534928312194942b6e9f89eb274bbe78347f5dba939206081df701fa0c05ffca40c298e8e4d3edf4e65a25a0a813b8baee8d82923fb544755f144b49dfb812a58c0bacdfd62bb9aef1a09bcee725f34fa2b8378bb45c428915fa52d2c165c9edabe3881dd97dc63dd7e3a907c1ad3cd2bf3ad41f3b52a3ca21d3ae072d981b84162a02e6556afaa22b593cc56dd8569a18cfed408c0f843e97276f98bd492e7c7f6277fe1ccbbe779b1dad3ab9ea2eb23868933fedd64ae9ab90ffac1e5b4e7ec86eebc685d56abc25a61ea63ff2bf5b5abeeb8fcdb861cffaf00cc9bbcd55ef8b23cafa0669f61f30851a0fd08bffaf7b1cdce86a403c5979fc5a979b25727089109b566aadf5829119af553b5df31c298c2860e6ebf236483f4b7875b314b909324ae34f03a4c308730131a8a6aafa85ef05da56897dda189568062be7e791b66f62c38bf7363069ba583d7caad16787ea288e04bad498cc581381155b98c477f1008f484c72bf1843c3e86cf9daf9a1d45d8d9d6cd55d95d541fd855209417ce91875ca5ccc92903ef906a34470ea818f4561cede77117da52245cab83844f696730ef096f3d46a3abf5cd2888700e2d38ac8b6614d8da0fd2a05c934625af8522fff875d907dc69545173732a2f8030071577b13508f6aea3174628a22621d32da0e45e1bb9612637654a9f4809528514877d5742a6d4cd8ed6f6441908789b4ec320c6045f7f88488be698b4e4225c794ceee3dc1027e37010182c62e5a8f5b5461a50ccf2cdca8b5e6aa72cc29fe848de1437377685712783eb0cc215881a1792207bc2081b9247fcbad21dc6edae817f4df57e77e3dc67eaa015e661e264f939d7dae79662b373aa526c229df7ff15db854db59e91feda24fd3070364e1e9f34d5dded17ffc68a4c226e4586c8e85d1f20f7cd36a99a521c0156afe65c65f95cfb0aa1c6e6f8ced73a726c79a25be125dbfbad7683704f54778d14aa5beafb745bb9c4815a273581a2c627b1a6758f1c09e46336d10dfcc31a832eca9b8fe61e2c6f97923a7734d8620416cafc788cb7c53cf79131bb048b97f3fa372a5e0ec01e677c41496e67e6a585eda533ddd76ac06b05a36dc541b2019ac62d32ef03967516e86c09eaf8a042e61213e4169690d8d2caad79389c31c97ba9efa2cb8e4a396b197d41e394392f9e2cea24293ddd12f62c75ef9f172a08e359bbdb969cf07b07eada3daa5226070522435dfc897f0ca6c25baadc22444228f54056a87d111b16778212f32ad49686bc6d7f315519dba787d7913b46a85187765b177be0eaeb422570089ca9a3ce2adbf4d4dfa35fd990f00886729bbb70a025feb80b9bc5aa2570523b84ae8e20bb009ad9c61c42c409ad74f6ec88395e49c1859ac7ba6868ea786ab9a2f435b9a9b800d012c87db61ac9ed69c3c743e2ef542744f1104258d470ac16b20fbd255ba3988344d33f24ff3d1679e5c4957596d03c6dbc50f68253c2af3d7291a0048a19148669192fdfdc668035aafce52bdf1ee47a7f957e5153c5093d1d77fb54b1f19398c28e20ebfd8095c072bf1f23c9b637936836bfcd0786714502aebaacca8fe85c49f9ea3c53e0781648d7839820f7d1b0ee07f0546228a688941d3b438ca4597e80c481107b6d74ef11aedeefbb3a3008dc50edc88ee44abdc645aaeb2ec9f645dcf63b4d15bffa3898a07dbe708f9d0e3e5cf2744bc1159f663a7048ae8d23e8c9a1b9eaa0e7c7a8bda197ec90fb6e3614507880770710f01634bbe64687a6cbab73279b15ca5e1011ba29152e4bdb1eb8996b6d66b5799c4d46f2552dfece1e0bed9a140776dbbcec0b03aff2243cb13b81a16881414160c920ffcf5938ef2390b44eb8b84f277b5256ed0ab7324ee6ef20b0789b8dd7cf42ecedd24f099a978fe22dcb604fa3430078e7f0cef3045cb8c2e0a647af6967086e2f505fbe1fd796b00495901a39c5c3ac36e390917723fc9296beb0a1d13b0c768f1a08ce67ce6013bacf95a4c8fa36cb2f46f022b758fc5409163e412022e82260778e62bd256ec7f29a3694a548cb0822e0b387df2ede2bce510ad2185fc289af1e0dd71fc5308ded413cc1e51fc39197cf57ca965cc6ddacdaa83cc2b25e3bad5630fdf6ef3974b27690703d8809c1d15f449bbc588283454d94eecc36b06287d874fb9747277065aa8f7c0c3630d7a7a380e89959a95f3c25eca41f846e7a398c51906f7375fccd47636b1609009eedc517b616c5fea4b9946b83cb72104b5e160d84300f8cee9cae72a6598340569fc1b97aa3083dec862bf5d781b5f15b9d0e10cf9264f9eb2ae99448dff2c9a89c9e96e176b212b7637a1511733e309447ab932d87f8069f694b42bbd456a503b5c2b5c7876e460f26138aa68850deae1de2ade824f27721ca0a089d2edb7607a58b0a6a40b10788fc3ea170427fe5b8c0de92797890bd44c9e9c4512a299ce47ce3bdffda2b54cca10bb0656d0361fe1fa31590f01c8902ae4d99e416d0805b416da8c2fce263be00823bfc5b703364eb8d29af02353840927a369ce6060ad09e517ebb90dd1b9572133e8ce12b2cc1464ef645ad2ba04fd179d27b052fc5042d1ffbd9ebe2ed6c671095e677d54b2b6d304d7e4a929ac011183d7cb0c2ebcb94eaadeade0912e17b0bac06e092358d911ada7b1f6cc25d333976e8740e9266e1af2045fe5ef361d4b624d8b58ffd71ee6113c79e221405a8e9d244b84f4ee0aded60ef160a937ef34a4f12d91f92f84997432fa484c1eee881ca5f7384c9cf1a93fcd48b4ba669335d68a2745bdf315fc70e3870b7f2ed8d72a5ecec9858dab33e4b8a0f81600300a207af29c6a4ed63dc40f00fb08bed452dccaab699cd8e31b805118482fbd3db5b10662a194da222e5f0cbb485baded120a3d64a42b17852b1ed150858de3e42050886afbaf608b08a5ab6be149853ae37c0307aa06a0a47ce2f06695ef55c9d051a1faec488e604d0687be84d79dc639ccae00c438882fea4b737505f75de56ee099c110ccc05e6153da121cae4ee913da84f0e31c9f394f7798f01dc211e2a2d0228ae69e701f8d03fc081917ff83a20c42957615def47fb46cb33a4f2bf94febed7970e10425e9d389b2b080a060c89d0b78f4e0bd6595eae225acd01d0c89b3e4bafc85d43e19d28c579c31bea7197a394eb68204483855b47298c2a6bfeca80c290cbfe4d4fb9d097639e83c7af928f872804af5cdf2c70f0cd80b6cbef7d21bcb34ca8f85eb0e779ea8d0a3edd90708bda16f55738e2e4f671adb7fc8820fc72ecef56df3632406cb884a6f575bbbc93724d9fd01dc5a89bbfd62c2cc838039b37a977a27dcce08b379007f3f2b8f06fd0960a4994b93c5c85b08f14cd66ca5d90e53cccea433fe7e9836734b3f833b00913eb80c1bbd9e90f88d714bfd0ab0b7928be35881d6f58e7a72fd13d18aa587134f8b5a7985fad32bdbe347b7700d8ea5fcb317e054c24ec132a27018d273230921fcaafac0c7deab9a77e7bec0308af72b3ad1192edbeda237b788228a515b17585346a1bffdebfafd62ff24d6877bfc6b15aedc6b638aa87bdd7ee2e23aa607a16e4f66065b808f0aa4dcc355d57db0e76a66fc42a39575624bb4acb9da91e67e101e0ef341128dfbdde7f4a0f20d79d739c4a3e11bb1b90b7b8e3e7ba7f3c10841ed2e99777af8e0a64d20a540df65550dd6a089426f82fa1bf597bc03e46f41f9be6147b867643795b7e93e7b34568e210ff4d82d46e834f011e93972099978889fe98793736ae88dc35d5aa99034fda93a22490b685cbf97264bd719df5d54c3fc23322ab5cfd8d3e7063e1fba9542c662e269e93289d71e1966ac94706e74f9702aed3053f40bff842e4c02ed4753ca69768bfff599edd089011d9752a476888fff2d8734f4ff882b73281e5fcd7e30f0f2633f53b58f13392e11903a93cfa23ccb8c49c00ef344fcf249dafa38d321714633c129498df70e0e8370db620c2490bcd99be38e67dc3d18911d87845313be28e17e2ee3bbe0ed7ab8e5a98d68c1c5e07f169db41e111f98ee858fc7346a5d4e7ed184b2b60ab441b1e3b186c58b2ac33ffa547473767276efd912303b440a58fe95091efde1360e6513a9e5390906e18e302173005028325d34f70a8a85f48bdabae0f15c33ec997d3d4acb6d3bcbd2434b0a83a1fbecbd33fcdf31e4a4044e201257836ecfe7b4c84a181827536eb95fb340da741d3827095350caf3964cbfb2eefe4e8ebb257ffb0904187df2eac9afc6e5e35caaf6e6a855d43b6e445fd91419bbceff8d30832b5e75b2ca5561ad64c306b09ad0d2ca3d17ea230bab0e3b6c1566eeab4693431e683057f07fa77099227a5c3f05308c8c3fb63e94a847003e0f0a78bd936d59b589c3e70ff70b9c688d43eb7835366a6574b0701e8804be965d7a2d2ec408faf31e6a68522b0b8da3cdba52c76cef757fa5fa466b542d5d57ab1504500a07037e1353b244a4424082f66d35aa99bd5fbb9a702362d81812771aac607695050c62cb589f00d614695b163af1e86bb3e6c1505609032576dbb14d42b421e72561482737faadb6fd823dec0e1310a99c9936a22017b9149ce23cbbdf77f34a57050b5f3b414028ca939c31e95655e909c630ad9dfe3f3f09a250e578030f4c3e9099dbb0088d58e1b4046b97b2f61d9a2be4cca9bc0240f06075850045ee17e19ec504e4ae273934909cc4840fea6766af2592fd6c12f3a82ab05856a646786184c68ac2020d2a8fc7828717cb2f89cc2d42046d8b618dfe4fa9e90b15d5c08ac3bac5c197eac5cee915e3fa0c6c4730110f2da5e66c0a124c26a62ede1e2de4357b275ee84d020410668a3efa1e828cba53c62150bf2691afa904762f2aa0309bcf67d023cd62d1b7c37aea8b1d69e36e07f5b8182885d3b526b02b6ba5b3647364ceeb601dd90c33d466779fd06fcad909db0fe5f376108786a82d336cc1f79fd23264e5455938ba924fce91d6f94e0ad00275b5e5c063ace5ffcf48f84e370c90b51c1327ff6e5105699795201784d8479d695cb70567f8f06698386e751a552fe72bfbd773226a10eacd32fa2cebea1403e796c2e1c21accc9f76ed21f05549fa17f10e97bb8736cf345d70b2fcee0a2c0044d02b5615c2e3f5075667942e2e39a40a3630fceec3653450b84307bf027a3bc78033ddcc5841ef3462e34da3778c496bc3f29d55ca47b64db23ce488170a5a0498a3a0cd0065b6ac1a8676ef1dd5bd8b14f298390a29c1df1403db94993b9537b3e018d82875623b1ac6ef0b549cd2b9676cb9b00159139a3161253ffe47e77ccfb3ef8ee1119ba56b51e5c626de41f5ba197329939971b534ef9c82ccbdaccede15e6a945fa603cdbac2ebf385846864fd30",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"3fef199d1e8f4b5ec30f289f0e11643811de32d694bdbab50ffb020e02ff6adb4a68e5ee7ec242301d1862c6c9de81673797fc08a73f006d46407454fa8f88c05b8aabfe5397541cab33d93e9ad585d4fc580f0ea5cbb8d9517b075149c68278f1aa76f25ad625b54fe724665df891bbed9cb52af8d1768315fa3a44956c3531d8fe4631b6e575bf332f6b50ac27744d4d4036375f1fa6c6d341193e823cd8d41ee035d08f77d317dbaab2480f3d780840311a94a733bb7235cb021167ce047d7f9271f7c3a1ee7e83879ef7fd08e313b88fdcb68aa2afa43f051ba6a86ec6fbbb5d4645f487cdf01bdea7150a6e5c78758f249b482ce71c4f4223010e6b70a6261452dc9037e4826902b768e326e979bd1f01bb1c90160975f3ec123c03788124ee4246ec64293ce913b7288e760c556dd693bc89a2a93ce8e920bb2678c8fd8f7e7fea68f3c8544ed3873dd39bc7152f9b4ef7c472d77bb60722ff65638ab4584e9c728486c008f998627da2ee446866d5db13e32fb7b5a30bf907bcea2eefcabaa7f53e9a7c94df11ece802c62d376ab8dbc396d7109ce9ce232207b7cb8cd3a6b127698b4fa8c1291a09b0f11e0a9cdfc1b19aa4f6c7a002028445edfcef35f1a68a51bcd3d9012c486abb8da48eb3498fabf8ae2d21afd0cc52a654869e67cb078ea887f68ad5263a57475a1ed1f7b5e551fdb2d967dd082da4d30028d946277e5c406d07a29e011bafbf14e5e51da7867ff76b4705ae059de46f3b9ac922c53db63189c154320652d6066963f10342f4f20992271c24625e8286e918b05e37c287cc0502375786fa930cb526bd6f3413da7e01aff07adf15232a8513fdaf7ac4e5a73f4e4a540ae008e4e52d44adbb1984c08b85540440d56fd63415ae56d978cd145001f8ed780665f273ade06f72364b5f4d180637a06156b60e75247c81d0a37e9a5fde226cdb595c3161e3fa78ef49afeb1edb2f2bb250fc5af575fada6c11c137b8595fbf57c4c8df38320c29787bde8f4608c3964beefc2b9f04585bdc6072720f014e5c7cbafba340a5e35ecf2dfb0eea4f1cc49f532eb8ff4e2be928de92336ddb0b3234b5ff46c48f49b2dd0a4f58ee3391353e295843d8d7461deba00102e2964009099804f0660ea37026abcdd7d4389460d69d51a85895f7dfbf4a0605a4d3fc6dc5c83d6e15c4f04ecce15856a1912599d331632bf1a04f39310db0405555fc62c59518fa8810ded2ddef7c3163ad13b9b788a163fc6cc2d26f25358562f95263acac6b56c81b8c39376162a73591b1f6a2626451cb2f425bef9455fae7e22c250f14299ee90d9aa9d548a0d1196949d8e72376f1cdc4f56b2db1786d77e8c23ba5fa8a32fe9209c7b621758ec11b4c0b784bd9b106aed25dddfaae73e501f92d6100ec158dd3a981e5311b8340d5445d24df4765d9e6496700124bb21721c63022b3546d31130c88ad2ae927700f3c2912dba4d84ad136c9c70342bd42a458cf09aa3fcc333de09db3ccd5f43b3317630e598b45717e7491582cad253942e5fa36464cad205bcbe71504d2567fb9e1afdf31c423833fe63d05cdcfd368f4ec6d69d599825fc48d901d69d1d9f192062aa6aae0cbde1f1b94a3b88869e92cf52bdb0f0734f2e2298747823dc4059873c0784be9285786b4cce5fa81854c2e19f6804ea3638b69efd10d7f1918d9c18e50360be16f4e968771d537c989812948475b4218a0ba4e889618cbef4c0c3f50bf63d9402b451c2cd3202b41720965094ad5cc6938c9a9e9716fa599416410d434fcdda0340f2f021b45553856a4126b03f932d242629e585993c58d71bc6fd95e11848a6092bcdc7fbcb706ece63c89548413238e3d7be9c3e345886af0b081254274622e10913937492368d29c790e8e338d7053b33cd6c1654ddad73476b901dfcdced535fc174b06bc16f183a2f67545de2f325aad3c07d4856eeb5876896c88677683ae72f8851cce00b8472703d88305950925c70deae29d726c5e2258edc84b71f436f7bdb339d1e9f132ded0de3c0aac035f2b93e8d19027b758e7f337311e2a8556fc50a0608df5d93d45e7bdbea1b8d42d5654d515361804d79e88e1b607ef3309f610f605b9d18bcdae8a7597a6e334e5eb66d7fddec12f07df0bee57a873945320a5e88bf751a4299eb324e07106e6ef26224dc3388ea127930d649276db54f5dd705e3cc94d0d56447aa9798dd62804d493dd1674e15ecb95fb8a169b6d74c2e21c3b84928591585f26773451edf872063c06aeb3defbe7a6f57d36a195cf16dec3068ab8447808a7c49306f7d8a6b7dae9fafff813ad8267756cbb87d4cd5b8c398e2f3aee3933fdd651a0d52d5ecfb9dc7758d5d4813a67ae61545e9d7498c1f6b1713cbf5fd72c8d81ce1acaeefb67ffa0104b8728f50ccf5bdabec070d653a3eb9a97f5bafa581aa47924fae03fe59d7fd76d6c370ac35c5471ff830ad655b3a619fe9890a62577d73ae56cbf1ba3a17a2094304eb9560bd68033cb18d8824ede87878b04d98ea715241999aa9c78a12682e4e4d2ecc11457af4534d0e21c07781bd3381b2dcc3c7875e788eb960251dc7cfc6d7380ce3b419a39ac545c5752ff83c298b264539b1550055d9bf70b56e94cf8fd2bc69a70a0da71d0c6b1d9c77a9bb858db24c1597f9ea000465f1d6c4329b9e1b72f3d97c8e86630d84d1bb76f211c6254d97713207b984a3cb98bddb7cf53a834fc34d2c7e6fc7eb41544859899e4ca5f326f3383c44f509ba8139cd3af00d47e6049dfdf820b076af9af90340f6c0675a6136f7d00c4c060167758050915eb64023c04f733695f8e4fa42f7f965dcf6b8ff1bd1c15c5450410a556b23b6e78337624634b691397b02c66b83cf3d358e2750de25b7e289b4e9d9774993977c3dc0c39161dc684718ea7c68900457b06f8c4c0d0da7ffa4373478fd9c8b9862890d025565e06be5802c383f82a161b3efa482975d4677333bbaa5c05edca512b059a8ca718bf244dfc2f573a1d448a9329ebb3eb9e278abd23842c320a944b8a86a1fa5b39ba08fec3de7b70b10c9be17406c09772b270f82348ec9b0ab262c7a314d37a15d68338806b48ecc3f0772c331a214b9cb61afe06072ffac2b86109369ddecb321f78c9a814b7bc8df852bada0eaae459efe34872e3a21bb28ea963437c9260cadb23ac6ad5176eeedc517b616c5fea4b9946b83cb72104b5e160d84300f8cee9cae72a6598340569fc1b97aa3083dec862bf5d781b5f15b9d0e10cf9264f9eb2ae99448dff2c9a89c9e96e176b212b7637a1511733e309447ab932d87f8069f694b42bbd456a503b5c2b5c7876e460f26138aa68850deae1de2ade824f27721ca0a089d2edb7607a58b0a6a40b10788fc3ea170427fe5b8c0de92797890bd44c9e9c4512a299ce47ce3bdffda2b54cca10bb0656d0361fe1fa31590f01c8902ae4d99e416d0805b416da8c2fce263be00823bfc5b703364eb8d29af02353840927a369ce6060ad09e517ebb90dd1b9572133e8ce12b2cc1464ef645ad2ba04fd179d27b052fc5042d1ffbd9ebe2ed6c671095e677d54b2b6d304d7e4a929ac011183d7cb0c2ebcb94eaadeade0912e17b0bac06e092358d911ada7b1f6cc25d333976e8740e9266e1af2045fe5ef361d4b624d8b58ffd71ee6113c79e221405a8e9d244b84f4ee0aded60ef160a937ef34a4f12d91f92f84997432fa484c1eee881ca5f7384c9cf1a93fcd48b4ba669335d68a2745bdf315fc70e3870b7f2ed8d72a5ecec9858dab33e4b8a0f81600300a207af29c6a4ed63dc40f00fb08bed452dccaab699cd8e31b805118482fbd3db5b10662a194da222e5f0cbb485baded120a3d64a42b17852b1ed150858de3e42050886afbaf608b08a5ab6be149853ae37c0307aa06a0a47ce2f06695ef55c9d051a1faec488e604d0687be84d79dc639ccae00c438882fea4b737505f75de56ee099c110ccc05e6153da121cae4ee913da84f0e31c9f394f7798f01dc211e2a2d0228ae69e701f8d03fc081917ff83a20c42957615def47fb46cb33a4f2bf94febed7970e10425e9d389b2b080a060c89d0b78f4e0bd6595eae225acd01d0c89b3e4bafc85d43e19d28c579c31bea7197a394eb68204483855b47298c2a6bfeca80c290cbfe4d4fb9d097639e83c7af928f872804af5cdf2c70f0cd80b6cbef7d21bcb34ca8f85eb0e779ea8d0a3edd90708bda16f55738e2e4f671adb7fc8820fc72ecef56df3632406cb884a6f575bbbc93724d9fd01dc5a89bbfd62c2cc838039b37a977a27dcce08b379007f3f2b8f06fd0960a4994b93c5c85b08f14cd66ca5d90e53cccea433fe7e9836734b3f833b00913eb80c1bbd9e90f88d714bfd0ab0b7928be35881d6f58e7a72fd13d18aa587134f8b5a7985fad32bdbe347b7700d8ea5fcb317e054c24ec132a27018d273230921fcaafac0c7deab9a77e7bec0308af72b3ad1192edbeda237b788228a515b17585346a1bffdebfafd62ff24d6877bfc6b15aedc6b638aa87bdd7ee2e23aa607a16e4f66065b808f0aa4dcc355d57db0e76a66fc42a39575624bb4acb9da91e67e101e0ef341128dfbdde7f4a0f20d79d739c4a3e11bb1b90b7b8e3e7ba7f3c10841ed2e99777af8e0a64d20a540df65550dd6a089426f82fa1bf597bc03e46f41f9be6147b867643795b7e93e7b34568e210ff4d82d46e834f011e93972099978889fe98793736ae88dc35d5aa99034fda93a22490b685cbf97264bd719df5d54c3fc23322ab5cfd8d3e7063e1fba9542c662e269e93289d71e1966ac94706e74f9702aed3053f40bff842e4c02ed4753ca69768bfff599edd089011d9752a476888fff2d8734f4ff882b73281e5fcd7e30f0f2633f53b58f13392e11903a93cfa23ccb8c49c00ef344fcf249dafa38d321714633c129498df70e0e8370db620c2490bcd99be38e67dc3d18911d87845313be28e17e2ee3bbe0ed7ab8e5a98d68c1c5e07f169db41e111f98ee858fc7346a5d4e7ed184b2b60ab441b1e3b186c58b2ac33ffa547473767276efd912303b440a58fe95091efde1360e6513a9e5390906e18e302173005028325d34f70a8a85f48bdabae0f15c33ec997d3d4acb6d3bcbd2434b0a83a1fbecbd33fcdf31e4a4044e201257836ecfe7b4c84a181827536eb95fb340da741d3827095350caf3964cbfb2eefe4e8ebb257ffb0904187df2eac9afc6e5e35caaf6e6a855d43b6e445fd91419bbceff8d30832b5e75b2ca5561ad64c306b09ad0d2ca3d17ea230bab0e3b6c1566eeab4693431e683057f07fa77099227a5c3f05308c8c3fb63e94a847003e0f0a78bd936d59b589c3e70ff70b9c688d43eb7835366a6574b0701e8804be965d7a2d2ec408faf31e6a68522b0b8da3cdba52c76cef757fa5fa466b542d5d57ab1504500a07037e1353b244a4424082f66d35aa99bd5fbb9a702362d81812771aac607695050c62cb589f00d614695b163af1e86bb3e6c1505609032576dbb14d42b421e72561482737faadb6fd823dec0e1310a99c9936a22017b9149ce23cbbdf77f34a57050b5f3b414028ca939c31e95655e909c630ad9dfe3f3f09a250e578030f4c3e9099dbb0088d58e1b4046b97b2f61d9a2be4cca9bc0240f06075850045ee17e19ec504e4ae273934909cc4840fea6766af2592fd6c12f3a82ab05856a646786184c68ac2020d2a8fc7828717cb2f89cc2d42046d8b618dfe4fa9e90b15d5c08ac3bac5c197eac5cee915e3fa0c6c4730110f2da5e66c0a124c26a62ede1e2de4357b275ee84d020410668a3efa1e828cba53c62150bf2691afa904762f2aa0309bcf67d023cd62d1b7c37aea8b1d69e36e07f5b8182885d3b526b02b6ba5b3647364ceeb601dd90c33d466779fd06fcad909db0fe5f376108786a82d336cc1f79fd23264e5455938ba924fce91d6f94e0ad00275b5e5c063ace5ffcf48f84e370c90b51c1327ff6e5105699795201784d8479d695cb70567f8f06698386e751a552fe72bfbd773226a10eacd32fa2cebea1403e796c2e1c21accc9f76ed21f05549fa17f10e97bb8736cf345d70b2fcee0a2c0044d02b5615c2e3f5075667942e2e39a40a3630fceec3653450b84307bf027a3bc78033ddcc5841ef3462e34da3778c496bc3f29d55ca47b64db23ce488170a5a0498a3a0cd0065b6ac1a8676ef1dd5bd8b14f298390a29c1df1403db94993b9537b3e018d82875623b1ac6ef0b549cd2b9676cb9b00159139a3161253ffe47e77ccfb3ef8ee1119ba56b51e5c626de41f5ba197329939971b534ef9c82ccbdaccede15e6a945fa603cdbac2ebf385846864fd30",
+		};
+		int height = 6;
+		int layers = 2;
+		XMSSMTParameters params = new XMSSMTParameters(height, layers, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		for (int i = 0; i < (1 << height); i++) {
+			byte[] signature = xmssMT.sign(new byte[1024]);
+			assertEquals(signatures[i], Hex.toHexString(signature));
+		}
+		try {
+			xmssMT.sign(new byte[1024]);
+			fail();
+		} catch (Exception ex) { }
+	}
+	
+	public void testSignSHA256Complete2() {
+		final String[] signatures = {
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"05b8763e46e573e82d661c123228225d57b4b1645954acc7e0455e04594a529b5269d0f84c1e6411237d0b09c194e90e115a39561ddb20161f482842c8837ea1ad22a58320aaa0dc07f09b550096d5049c2f1673644528e3a27ecf7c78c552087c482d2b7215e988f404d2407ff8a3c537563a284e0a5de22a1c86e2b4fc7f63d256a51b46a7d586518df981426501af9d801152a2fac5aa26d75557c95b291ec2d3b7e5ac8583bef9a65f40d19a29068700b375f7f97dde44f7d58af559a13b783fdcb4429a200c9c44840a65a0a27bfcb63919cd2a0c58fb954c1bd1ce9a5da46d1fbe7a1999caf5aba92194e2671939aa8bca3615a609278ce28b133518ce84f644ee85c0e93083b2006eb08aee175a1cc19bca4832e789560377da4ce1600b16b5e262f6d17af05406de19d5161d5f48974740fe63a571223337a9cc1c2c842f6526db460826c7f1d4b0f593f942663255332e81aabd902eec4eb2ed204f78c11ce01ee62a818723fe215b6f26b494e3afe334e98527c66095bed2804fc1051e08ecf3a85eeed248dac2cd5986425d0ea1df64bf1a25df0bf37502c9c5fa13ba1f97ee6708941a79eccf228b10d39b3b3ac94453393ba455502c51a9608098fed9a4af70f938e45185d959135172268a13512edf97889ca6d0b3ed84aeab8780e187c9aa789de19ef4ed2b380553dbc56be377eaabceb70753652083d40ea84687feedeccb1daaf3ba49a1ec4a82d668dd64d51170e10c7e26ff17caf0f62e40e705b90445b0293e9f68945f7a4a167d8f1b33f3a382ba9d97e699c98b8f79f526e096bef68138e6b57772ffeb50ea7cc80cb7ab93ad24358dff0afc4d994244dab7404eb0a3dfefa2290987a292ee7c5acd4133f211dac3ef11c848d3f784776c97331ddfa141a36204a7add3dd2ed09876531a03cfe36c358c4beac03214ac152e061ba50c17bc58f8b403b427c2515ee6ef9b64af4ec86ca501edfa03ecbdcefb52eb2658cb9f25cbb3a7f07939969f8119356980c76e341e24d6f0c5684267f924ad88305f1edd68ce6bf9cc610dbb19235309faeadbbfc3853e1e2bb06ef0320d919fe83898bc03ef0a51bb82126c9d5ccbafc2b5825796cb716609e30b0c9082ca67beef530393b76f66862c69441b202831199373c302e94d2917d86a95bc27f29042661df832877b8bde2c91463c5c62d47675c089b091fc680d61aec35fe59547401b002648b960a1d7961782217f74bd9d82416eca47d301a3487c3557b08042a279addb23b3854cf7c404c84e3ca1afc8e15938a2f144955fb56d22c2ee0d4286ec82b9457453f7320250d197a52fa24f9ac6b4895ab497456a5bc105c9b658316cb0930fcb324070095c52862656ec4b9512b7f869ff4282921fc7c928ad6456c20e777bfb3e86e91c1c34791272a54c9626c1aa28a4fad591fee7d79325885123cc7085fdc5a0d66ad51bb57c24db9627d48ba5052b86983a6611e93b901abdcbe4e127dd9daefe38e3ecb25d2c9892359af26a7d13c4bc39bdd3a4c7dc14b5272de6aa92cca0b252f5727f7b43d6f1a5f12b4bb051435f670c0b0701ae9a98a23308f2ab1a33f7479aefbd7354c1e3f3e606d814fcc05847f0485546d07b6871c2781186f90d5040e970c3a45b92ce7082f97e4db4cd4efdd0e0d5e6f972827dd1bc47147d3df63d73f73c2bb9d058d407cfe53971e3e2b2ef9b122a959641b823b6b95def0ceb2735993265701ba1d1473889d287b3895f747ec0c1bec95b2408c6bf0db0dc8ac6ba1bd32157d2d6469decb33966f2051e0312bff4b176ce0442e1f2f920bfc79c22546ffaf429a80b8824ff87de7536d6c9c67a5db1822518bf5783f9c8463301c9fd07a0b56d1235eadfca962787c4436671bd48c8f45fc9e99090bd82879ea4265c250e839e52b3117b029f4f68b3c39e0ba5ec4282cf64589df2374ba7e417764adbd2ea7cf094397c2ca403d63bb9c2f28a4dd767d22ae89adfdc49a6f7fbf7be8b08a1cbf6f7c7715d7634e5f7bdaef05855bdf04c848f15046a854d6a908f44cb0ad1cbe303210fa34b0b832cf704dd5c699975b5616e5e6eba0fe579fd2ea1361ebe36fd3d3245a437dc68748c658aca35f85a726a955df1b2e3f047de21b150f0058ea9d3db4f32259dd2babbe8195b7b7a2a8d336326ce70812fea41949fd9ff9f8abf442f211311fe9dd1d134d16af258647ee32dc077fb1e1030c03060df079c6daf7f5aae8591f2ec06661af54276da41191fc2589e9850768e65adbdd095aed21407c632535ef0b09a3858533a4048ddc086ac88b4bf60d88671da2d54b1881fc58efccdb4601498781de66f0d5f1b6749163a1fe9afaa5c8390a43fbd28f930656fc97feb741ba9a7f12a2b612971bee5ad9186f1cbaaed73627dad5663d1ad2793eb146c009c0a83bf897c7cc2e3058d60bf67b2a432c7f551033b695eaf0301537f86c1e8d3e66335afbe0bcc8baf4fcdb70f1d502b8221abceacd30a2e17fc81f0f770ad5631f7ca50117de27c1b502008e8aebaf9ee7de7a3d72967f3cccf59f1cd790829a251bdf89be3b24e65c2b707350b7c1e9f34ad6f315233d8c7abafcc9ec6797aa1c70a63518d9c56f020a87721f8a5c0d3d48a83c09c0f369c80ed9beb6292726a06eee0d72dd753d15532793bb49a806c538d60d77c6490389d2746c80b0c730af73dfd40358274bf1fc1605a0c405134818794350de60acee25e70b00f871c2560335e3bfdd62f51b8489dd78eda9b647805e0ac6d5db0700ad07fb5f8ddb3ad03c8eabd85d9168b3c25e12916f0575b25f0131e47957b406fdba12e0d370dbf9abcac869a3a19a395ee00481630eae079303f7041db4a431c7e865fa7415772b91baa9932ed7daea77ac5f0d4d364d9678401c5aaa9b53fec7b2d56e77cbd2ed6a6f25a92759b1255933706c6c66bcb89e468c01f005225c62c22afd7573a069d293369be6881a6002dbad737d7a9139ed844e2c994d5f2b6494d77e79d008445920ca1e138868c018b118dc0ba69d72e02049978f50ec35cee1cc84f4f0a687b1617d512aeb134a08e0a84b79b62c2c1de14c982b71ffcc9965b7321dacfbb60368585e8b6fb71782fdb9fcab34528e286e26d5b77c8e52a8ff881ef6fb928c0d42eb2ad43b87a08a4146cab897d8dd6bf9d549d2a326e19043822cc59f29ef116c58500f098981f7d239b2f0ef9de9b30a77a01d56149f23dbac51f294807eb7f7bbe0cf7812f9918037fc8e460cf3489a39f5b5d62d2b3003ad7d3320b10c15b3d662bfb4ebdbe464ba1b2a5d852ddb43a793eeb1ca0757648ec0c81e0d155e980d1e2f9bc407c70b3580ffc9aca344b3075fbefa9c13e1148d4f9ef1c8d5bc08760d6bcb79035212adf2c89ad715b22bf80799f52a415125fb2e9b5fab1474ec7483b631612b4cb299ab96e17202985fc908d3b09ac34a729092f6659b2fd0404a49cbf25a01fa872dcf5b17ec6c2d5396fc5637eb8531e40501c38f40b755fd7392ef18bed62ee240e6283d5285df28e4cc270cfe19d3e257bdf04f730a6fc8615102400b8bc712322856a7891db403d759dd54c5dd8bed4bb9b7c34cb10c4ea08d0e6c1d946af90e755e33c9df0b81eb282f6896e2ae4c21d4d4e359f6382bc294975ca1de0666ae28ea24531f1414229c31e98aae2b46a43f52aee23551c268cf8655043e6ff8451b9c9a18a4d393bfe89b765e4d30e683ac1d3f76eb474fbd878a73b4f69178e20e88ada7c18c5e6e2e7e5439322ae704cfc9a5466d071e6faceff991b91414908299b6b7cb89706bb1aeb2e51fe53662489b8f2237c78ec6e894252309d1868bcec1e53cc06b9eb808fb04ca9b36b441c8479b92e9f3d6d1239fc194550f4ea12f88f13682c92a6c946d5de07621c96d34bd928e4ab654ecc5f9a05ee20b94b7eb52633a91117715da1f73e407b36492c0cd18608c4ca4cf222b934f324a6ad60db3a5dfea14d60cbbe5185e27f871ac90168446aeb971caabe6e2392e721a919a0d6bb5e210f2ef40c36d5d67c23281587a80fc7c58f1c45b892d7c199de4d9b867be97933d273afed6a9bc7819595f4da24db116a09b67663f677778cfba1396332f863d4c20c3ae0e11df868dcaf088f4ba500317761ddae6509dc0e38111e2a2cc89f33a642bbb7f21987587b2644d9970c31b6abae949bcfeee26e30ddc675311ebdbb2cacc3b1d7f36522b499c7aa345597be247dbdb2c9cb5d35b00f0b8068b9f406b7df27720e1114f964a2d4068a4e2c3ac89e722735d909b2d21c8504525dd313e3e2eae43ada4096f2074dd643f32ca1fe2632e079befdaa3bda951837532af047453fbd6a39deed1899c226478c47cb28a4ebeab0f20281f9771300c0a00b08476343d714026e96d7cb3848be5d436072218bde7a58bd929d6be1db502662314063ae9c8568a46e147222aee8a369e66ecfa46a8e98811007943331f2ed3475853451dba43ddfe8cb76860e00508cc9cd765c8b05f95003f3636c3059ac8891ba40c298ed0f86c801a33a989981edc2770b3f6662f2c32109e9b79a81aa8c1113d82c54f2e4a0fc5d93f1c65707aaaf8450974aa357ba48e75dd980888f5a4be5f6f573bcb027667168a9ae0282d62886faebbea770cba91e523a8f67aca3a51494bcb10ab40e68c960c4d9136f9e486b0da9877cc522cb3d8d353464c3222dc0482bc2b4a5589abd4c7790e89b42bf875fc8068974e5022f73512a033a81d2653da9487c70ad998222314d8d7c5b42aee0a58390a0ca277403ed68c89d240bd40fd6672e0341bf12ca0c66bf149007b8957a5ecb5db3cdac641a951ceb4ad29e08ae6a9ecfe2b6476e0eda521421dbde9d89562ad9ac49e46e0389392821b4fbff0532a4503eebe0dfa1fae4c2bf3d02d9d5e25908484395a1d63cdbf534bd93d7cf2e0ed93105640bfdd1a8f2e7d7e19475c65c478bc29079e00d1df36b75e99dd4f45bf8d4bb5e5d2f07894d005c001d86ded5af7e6eb1d501f1bb03b765eae56717f1fc3a3b0a4680eef595cba1e7583c5132be5a09cc604903ad8b4727abe6881b927d3390db8be607e8865999e65347542f7716ee1a7d20043f8227683db3aeeb80cecb170fdd56edda4892e74169c96572c24b6107c1492b7361eb65edf7489521b4520a77215133902418caf4bf1226826d9413834a0d612e325d1ac0f4a460b34520d34daf57649d2864cc5ef375cf6f5793305902dfd9ae97252b8e127925e33861ebf70802d30e7251c06eab16972f59336444a758552fd60eb02b47e60bb2bb04d540f3e957444187e95b45e2ae60daf48f47ea8c33e263282356d8f79198dd14d69871d5606a8b4f86a6f2444fef29fb0be1d46a7807185a668c4981282e57ca0bfd40ebf678bd373e5a0a6f0295affd4b1274dd3cce34651e4de67c3615f69a9c215bf253e9bd53a6b43fad72b648c18b1c3c35b511ad125ead54e82b44b9a1df815593fd9778c1177c3ecff27cd24d9cff9c94ba07a27ebea9d975bd58e51ff88c7c2bf89b4a1421a5c87bbfb85b8feff57e1c6e2d074fc6123cb3835cef32a629cec9daa1c12482e8e16da2e3a9fd63466be85e85d4507fe6840580ce1a6128a0295035bfe3e9c73f8908413480c8d5d040e11c94555e47bbcf369a2589297b993fc66b0394d67e5362c348989a7c38d55c01d2a5375cc0dc3351371b931158a4695ca05aeb255d6d6907b8b60cc646ad8bfdbe5c538d3c088ece388f4ced4ce4604df03fe3b5299158a1d338a25b63598b17375969279685a7b45e576b1fa35d752eb801b97d8d5968d9079ca3a05c0f58478debb8d39339e6b68710efdd7c1882424b2823a496478fd1c4fb1bb89bb186a70198282ad271c774f4385943e55ef87dd94b448a1efb92a2c5f6b8008fd6b270b2ed5888f78924fc5d4da86788d2123870210168a8a929151b255221edfb86d2c9abf28c269d897b025d702fa3d795d022cc519cf3b0cbca56a22b165f7ccbaf35a16e2ad9a15396c3eafbf970ac87c06fb996a29b550ff58bcb0573ae39f79050c6a90ae21ff1561a557604aa328166eaa11987936da2276c7845800944605359793949af3479d5f3fa57c48a98e3925e324d8da33454781e698c78070c1cb2306d04538591b308d3802f064fe9c5ab39d3df891c5b3397ef63c08a112ae23cd66779b7d12eafeb1236818d3cf92c01c8e4e2ea1e8e2c0480a7b2fe85c324c4869aa01b67a73204b8f0cbaadb040ed9dc55385c60d3",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"0da714e82f54dfd7f6c178572d168289c560985042e67c45781d7e940aa1a33f47902d63013c6536ae47023e86bcde904f9aaa901c57dba3621a06357d5e6a3c65f88a1d681aa8bc75416a9be5d1e478f6c8268172110c1dae6c6821f4bc3b36e907aab3fbc16e01ef6671dff82e84e76985a0ea7e25ec890edbb1813ca87bfa61a002548741d792691957e43e774b8141ef9602caf775cc5be87c9abe6aa6fd8a7b83d7a13b3635076b13099b822c4b4b7caef53a800ad740ea93f1f8d06842d8c0b7158714d4369ebdba995ce1c7d45fca8bdf8b6e7a6cb0efd228a5689c99c01f90a9edecad9409975594b65c0404da45c18d18be04a61a87cfb1ae1c0b6d4be10024a0f6d5c75ca06f0b9b15a582abb52ab8b347dc8d7b2222f93bef0f07608905cf8c25080f613a8e20c5fe9daace2d06b7db380d5cf6b94663960743d5c88cb039b71278fd08795da93cb474e8a9a20406ff1792ae569395e409647cbc5629fc88f2b1ba15cf4fe0e1864b2bc095868b92960b3496d903c5add506278d85138d6b11a27c19c7506c74b1c8fa6796867413c37c90386fa91e50fbc73e7f6bf4b22248d679d6187607fd4ab227c95c783091f4165e35a425e8e076cdcc8986f5c6756f9d96bd9a17b3f89256069d6dcd9943ca28ffa6bc60f96190437b7e2b39977ab8ce858cb138bb4ea763edf76281d0614ceba6faccd4f5a5301d2edfb9074b28d73d929aef9bd6cbed546cb06e9ed31e4f998329378a80a771f6c0aad2fe68ca974c2f09e89d837f1062454b957f02ca15ffaec5eb0b45194ec03dcb92a9b75f26a9ff0dc99d98c3d5107c2b07fb858c4c9ef3207c63bfc73da979182fef927ed234d04de03716ff60743d00b16cc1255b35e46224ec0ae6e2a78ac72165247d26c1afe2959a741d9023e8dfe738be95c0f9d1bf0cf80f9a2d1e4b2756ca44d5d751b522450b22bca9b5a6b1d14a58e69b16d5a2e074bb0e5787bd7a9d21532b3c8c8256c9cba44d4ab159d7756d1e49b184f2ac032df5350013cc37e931dec91ecafad2a202a8aa7850b306b1177e94f30b65c8f0cac8fbf05d9389b07ffa222328922ad9e9318fd1dfe03ec37d57da7ade4bf43007534e9d3616eef5e1393a6c7a42108eb019c0e706a2839b86f013b72ccc833ed93777d0f1bf70fa2a02d2b52e11391226836e15c62302b7582b3702111375ccb7b775407f1e53df3c877ea97668c07f415d024092cf3ad7d59dbcab565165d3e2027cdf180b8ee006449f4bae1397b2e7565e6de14bd79a75ee69d1d4b814d92e8eb3e17bca30ce2e7a04f1b1d15d7b3d8beb79fdd2bc97637910c3f8052a68339bc01a1507cf6a29585d86605ba57ddf1d56fb0764a68c6f8b6a88198aa6a9064a826bcfd0fa61e3c9721b19c68ae1ef17bc2f0d7c4e39d176de97bcdaeead1ef5f1fd74e70df110c7d845ce225ec148e60a1f2e54a7e5b2aaa2e0d9048f993ebbc8b1d8720e9e24826b58fd073b11d28f8bde2f883fed8ce609738fa68d68cee4c8ba94c2460dce24aeb32b373ff875f6a34745d65d8fbe9e843af826c0b7015bed00ed6bc45f97f2f511f96d664f7d852f26bd7a4cf9436bd723a5db23191c8c70ece261cb26b73d4087b8b51dd3b6e97370a009f89924b0c369ce69a57456c7aadac0d4a4053f97b1829a902be22a9ae7dbfd8347220b34b1d1b4625a3eb5af1d6cbd69068293c236fb28c65939afbd755b937ce0b732e49c02872710c037508b097cdf6ea90ce9c1d8626232ad444374519534db2b333fc8aa107f0b269bee8f7a7f78a60ee95c97398e7e3abd13eed9a9c3b6c2eeb2a5a29c53f911fb1c67b7c57b33da087ca760aea1325bef7fa2f20f7bcfea67b8ffcef60f7de082497a0a52b3e56814d666162eb2df2771e47d8adb1b6d376d7b6dfd47f84fc3803808a9eb048aba65f461275ce23ca5aa3550e366d4d12826ceeaf72edc549c2959f611029b95eda6b5af1c3d8f6158170f238082423f72513ed672d78831470aa681626615d0ae6da78251ea96e03206889f5d8f74bb71491d357117704e71b2111fb51992c3832176736d8c5b31dce9fc452d7c6d78b407b7c6b2b145b273c805365099447cceca2be4cda3b67e9ae3926f636a9b356e945b653e02c86d64c40246e635e033926724d0d709558a2e1cff8887b5a3382493658aadf7ccb2a09143bc320670836e08125b44780d5c90220201f5bf7042d68c4affa00ea8a6db3314b0db60d25ca5cf69e23fa890c0bc770a9320fc2288c775cc6ff259b8ce45fdea8aa1e4e1d57cc1396035fad1f3159209133dfbebf47207ab25a8f33655b09178596e30235947dcccbff2f6a56a1fe7179d7ae76aebebfc9c7880e602ed92e166ea5a1fe623cfb5351cc8a911cefe676a638457ee40380941e82a44c0fc93b124e366425ab315c7fdcd056c335cedc1003571d8dab54ccd2d5a83c4c3afd9c4a0e04ffd021f236fbc42fbb1b229b2ceed70db9c47f1e9c01973bb37e068a46a58538eddfad948dc189cc203e1afd671b1c024841f24c9c78a78c3a2635b8289cfb7f46500bec7927e59db76751ab53a845a5e9e0309ac376158cec3a9cd5c9856d30006b17bd58924eb287eea2e74d5e4a6465412f906bf70e0b0e37aa6351ce9d9894070417b554d188ad7072efde03ff7102d31f6cd3ba7215f006f87c346144e3ef2283a1377eb60d648c1fdeaf5726a6f0d93ab7129b1f56c7c4fae65a281aa4452907b08fdf2fae131a34d215dbdaf60e1ee5be13af4c194a1eff4f17ce1aab6f6f9494a050302c30734efa6744c3c92e53da53e414befccd66997eb20e34c6e561beeac9788adf6d3565d69df1ec7294067ce85962ea4f5a21d7c298354fc723b90fe4737635ceef13a2cf985c7ce2bbc2a737ca426bdd24533b9fca54274928c312ac79982267e02f3a11e53487934fcca2d6d1222037087d11082e5e2f86da3929235bee95fc6a19364784164bc1487bea1dec2b34a2a9fffa842983690c53eb11ec2ee330111af072625f92532f50a8c3bcab9f05173e059b01658030d76f285299b9acb7bf48452d347dfbb6c60a28d0f34a475c24780ed4ee656ba8ac4c3947667c12f0030d0436282667f9f2b4fb849088b139e035728c3bbba3e613731974cb831aa3dba10773ba2743b2ac300cb53794bcee7f7576b976a580c70d8438a1eaa413986d58a66c5d218cfe63baacf9cbcb7c8ee96479719a57833e0451fef26c39466333d6e0903e92c2c0ff2edf3ff9327532efd768f13962a42ed1394af185518d4da0d11c5ec362579da97c2c977608e327b72c312c3f5c44b28432ac26b97a3b897e2de036b6348ae702a8fbdc73aa4a5c85d7ded66aa866c0bf4fa524b92d2d55242b9c0fc7fa768df35f5bbf845c8b27ce68235569fabe4a48e5c6d52b05cd4fda34346fa3780ddfba41ca865725db2f38ecbcc9e43a219018b7a0cafed83b547b29f158f35a8bedbbb5a8ed10d7d4216c80313fd21a15ec411c65cc9d3d0220448f0b933e427156ba1a28913b49ac83bfd9d67d43fa773ac64da6edf60d8906eb64a05f67d0a40b3b3f48b699f14cad3835df5db59688ab1f7985d125947a36786dbd41c760331b9d2c2cf77a905a926cff0b541d98da7e1062821d7d23b5df14c1f9b548dd3bfe70c0dd975cb6c67d5adefc9ff1bdf41d469116d9efd7a43e513d46a49fb6d0353274cc8529205a11e8add837359b0e5bacc9ad3aa1bb56d352fb114bb22dd121ef7b20dcc6ff7124771c116d6fbe109415bec3b935df48a516ff8b4c96dd69b6b1c566731939f47a67db17735d746ae7f5ff6b82f9355452c79e3de14fd17cfd8b8974156964b0667b236a2f6f6f6a518f8ffe8752276f85e8de2aaa644cd5f0b8dffb459bc2d4294ee24229467740290affd67f199c4300e70482967d40886b83c2dc29496c789b5e1da8d9e2d3fdd24af5d4b98f2e6525129816229d55126f1d3a495f67ed8acb447ebbc9aa07765e35bac3b87fa8ba9cddab6fe6e25d01798c62d3f92047a82fde74fed4ddc8f871bdcfc28d8b95375c09d1e57713a543209b3fabe509f31edd5a9677807c38aedfa5912610cee503baf941e6866182a64700f165211648e358c5db2fe7a3803e08990c00aa048ec1cd36eb1b23cfd7b118e2b07cee67404f24ca5bcbc84aa11fe404a79525aad49751cca531f1254ce18dc5ad677e046e976d695ac10fe3097489f47a375ab6054e3bb0c5f3f47d84664dd0840f6ea8e41dbff2efb1c8b4cb61ce5d5e7e43906714dc3cb1fb420359f2c52cc7d91d13d612f44f6e7f16362722f8314bbd60ea984c0088e5dbb74144097a7e4ed05b0b58efd733f26e55799d401191016e57a486d19ba2076f4a53c6d21c953e1d1b130e2112066fe7fd38972f3f2adc440bbdcd2252b9da46cacae4ce750775d6cdfc070a398cf3664dc11f28d149ee76d1dc895e509cc292bcc4820667cc5bf650b5b34476cf765f3eac2a2809199dc2e0aa9b25f8c35880a169ca9ed155eb5cf162fafe24cb5f7f8bdb4c882f061ce7e75e491612d50c178017bbf5d86b23d07d5f21457530fe1fdb8498d96ab1b45528139fa3af5b7711bf69bc1caecf5a9f99a73d6eabcbb3088c0918720b809dc706fa26985a1496afd35b46216bddb9febb556d9c342e54a742d3f2db7a46813561e3c1b0672ba54f616617cade548442dffe1cb5834069f652e047303ddd7285a30238b521df26129ba696638781c1100e2d1ff73f32b3de3c7d2efa4968e7d1cddc6dec9b1a79f80c77832ffe4e015bcb905b8a196ba8bc7e97b2f6f6711c25ec582cb43f7ea8363e7788e173bc8ea9ad7daa5e9d6bb823862534f081195ef9b2d6af95f8d6823fc7c00536b789573b2859d613a1bcf4c1ed4fb40d9e645ad561d92d37432a86c0978036dc74052ad4e70b71d3ee520d30fcadb021641336795e61389ba2505e43aa9233ee78877c9de5a620f0edd5f5d6841763b062eb56ad6d0ffef4e704f625c91d0320c58a41da815525c9b9a8b47046cb909677f87bdb67fd2dda2aa0539a1a333919a58ebb91daa89e2c6605d16a04bec8cec4868e4c6ed466388fd13cd8dc09728ff957e6a84bdcda7e1acb9017a1c0e6fc02fd497d4aa64dae91a4cbba3f471e534a6e33a58401055c46bf5f17898c3f34b65d6a208e5e872e8cfe4c1dd2e399efca08b846b41fa802c35f1c0ef975859129b2165ee7bb38dd9f823fbd4aa40e807d144a9e0a9d3adeddb18d0f8a0da7a14c113715f165e88f69cf7902de907146c4c9e5049fef6bed6c00234e0c2066807b64a76c893463e90aa04b32a41a1191af74825e24adeecae3f4ec2ed1193b502390b66ecfbdce9f3c00364674a8723a8ed673e702da16cbecb80c017c43a7f71378f9171c5f251ca4247d0aae131a2f51d06ae51b743b72752b1505215614c6534a7e241e0963e9b88a3cbab6ad05e2295668355fc6aaa8caec4d880841651e440fd2b8c18e1acafc82204f194790ebe5d5da9b4f63e330912c0c1794d04b37338373787f3a144288181be492279122f1efcd157f91e74615bbfeaa74bb569a9dae0dc8dbd11ac012678b90cdc9f345e8a9d048d4758a4a4b8bc5389d6cee437d240219d0bc7a0d95c229704584d32fa8f3829f9fa4bfc06fa4e1fdffc8848ef9ca999468ff7044ef20859c38edc70f343b97264789f3ef0ca36bb614a6496d6b943a1a818288994677cb58712618204d72ec5eeb810bf4e4574b17c49823d91d7cc4586493adee7e424082bf3b081b6583a58adc9d04359d54904e6b443e82ec13c8705c2e557af7ae6daf9201c0201725dc2ca00548fcf4dd3985eabb7175f982b2eddc997550c6f2ec7d98f8776778bb094cc5271cd3960cd39163bf31c5aec1949491aa0c2cdfb98145802640db5ba5b7a825d8905203bd2e8cf8f4bf9cdb90d6b1ef4dba071aa39907431e00ea382bf5c89e5086dcfdc78f70b7c86fe7fca175f589e9be2f92bdc48caac63ebbda83f09120f09e0c23391e7e7d5776a93d9a7e3395c97840c00999bae61133683832494792296b2aa00be848317c69a7fc4bd7b2bd06e1b95f174ed62fba6e89482a62776b82d5174351b2a70f862fc7b44ff18bba52e76bf50f49a33433333828154209c05671a8589006adb258a4578a8205662c225fb75124912f7b4355ec14bff14174f644d20d9715f82bdb36928e837191ef586f3090b2877a8b62d171d25bf8e38b0a9a089fac89496294a8542198d67836112a2",
+				"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",
+				"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"
+		};
+		int height = 4;
+		int layers = 2;
+		XMSSMTParameters params = new XMSSMTParameters(height, layers, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		for (int i = 0; i < (1 << height); i++) {
+			byte[] signature = xmssMT.sign(new byte[1024]);
+			assertEquals(signatures[i], Hex.toHexString(signature));
+		}
+		try {
+			xmssMT.sign(new byte[1024]);
+			fail();
+		} catch (Exception ex) { }
+	}
+	
+	public void testSignSHA256Complete3() {
+		final String[] signatures = {
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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"
+		};
+		int height = 10;
+		int layers = 5;
+		XMSSMTParameters params = new XMSSMTParameters(height, layers, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		for (int i = 0; i < (1 << height); i++) {
+			byte[] signature = xmssMT.sign(new byte[1024]);
+			switch (i) {
+			case 0x0006:
+				assertEquals(signatures[0], Hex.toHexString(signature));
+				break;
+			case 0x0023:
+				assertEquals(signatures[1], Hex.toHexString(signature));
+				break;
+			case 0x014c:
+				assertEquals(signatures[2], Hex.toHexString(signature));
+				break;
+			case 0x01dd:
+				assertEquals(signatures[3], Hex.toHexString(signature));
+				break;
+			case 0x028d:
+				assertEquals(signatures[4], Hex.toHexString(signature));
+				break;
+			case 0x0320:
+				assertEquals(signatures[5], Hex.toHexString(signature));
+				break;
+			case 0x0338:
+				assertEquals(signatures[6], Hex.toHexString(signature));
+				break;
+			case 0x03e9:
+				assertEquals(signatures[7], Hex.toHexString(signature));
+				break;
+			case 0x03fe:
+				assertEquals(signatures[8], Hex.toHexString(signature));
+				break;
+			case 0x03ff:
+				assertEquals(signatures[9], Hex.toHexString(signature));
+				break;
+			}
+		}
+		try {
+			xmssMT.sign(new byte[1024]);
+			fail();
+		} catch (Exception ex) { }
+	}
+	
+	public void testSignSHA512() {
+		XMSSMTParameters params = new XMSSMTParameters(6, 3, new SHA512Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = xmssMT.sign(message);
+		byte[] sig2 = xmssMT.sign(message);
+		byte[] sig3 = xmssMT.sign(message);
+		String expectedSig1 = "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";
+		String expectedSig2 = "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";
+		String expectedSig3 = "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";
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig1), sig1));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig2), sig2));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig3), sig3));
+	}
+	
+	public void testVerifySignatureSHA256() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] msg1 = new byte[1024];
+		
+		for (int i = 0; i < 3; i++) {
+			byte[] publicKey = xmssMT.exportPublicKey();
+			xmssMT.sign(msg1);
+			byte[] signature = xmssMT.sign(msg1);
+			try {
+				assertEquals(true, xmssMT.verifySignature(msg1, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+			byte[] msg2 = new byte[1024];
+			msg2[0] = 0x01;
+			try {
+				assertEquals(false, xmssMT.verifySignature(msg2, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+		}
+	}
+	
+	public void testVerifySignatureSHA512() {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA512Digest(), new NullPRNG());
+		XMSSMT xmssMT = new XMSSMT(params);
+		xmssMT.generateKeys();
+		byte[] msg1 = new byte[1024];
+		
+		for (int i = 0; i < 3; i++) {
+			byte[] publicKey = xmssMT.exportPublicKey();
+			xmssMT.sign(msg1);
+			byte[] signature = xmssMT.sign(msg1);
+			try {
+				assertEquals(true, xmssMT.verifySignature(msg1, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+			byte[] msg2 = new byte[1024];
+			msg2[0] = 0x01;
+			try {
+				assertEquals(false, xmssMT.verifySignature(msg2, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+		}
+	}
+	
+	public void testImportKeysSHA256() throws IOException, ClassNotFoundException {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMT xmssMT1 = new XMSSMT(params);
+		xmssMT1.generateKeys();
+		byte[] msg1 = new byte[1024];
+		byte[] msg2 = new byte[2048];
+		byte[] msg3 = new byte[3096];
+		Arrays.fill(msg1, (byte) 0xaa);
+		Arrays.fill(msg2, (byte) 0xbb);
+		Arrays.fill(msg3, (byte) 0xcc);
+		byte[] signature1 = xmssMT1.sign(msg1);
+		byte[] signature2 = xmssMT1.sign(msg2);
+		byte[] exportedPrivateKey = xmssMT1.exportPrivateKey();
+		byte[] exportedPublicKey = xmssMT1.exportPublicKey();
+		byte[] publicKey = xmssMT1.exportPublicKey();
+		byte[] signature3 = xmssMT1.sign(msg3);
+		
+		XMSSMT xmssMT2 = new XMSSMT(params);
+		try {
+			xmssMT2.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		byte[] signature4 = xmssMT2.sign(msg3);
+		assertEquals(true, XMSSUtil.compareByteArray(signature3, signature4));
+		xmssMT2.generateKeys();
+		try {
+			assertEquals(true, xmssMT2.verifySignature(msg1, signature1, publicKey));
+			assertEquals(true, xmssMT2.verifySignature(msg2, signature2, publicKey));
+			assertEquals(true, xmssMT2.verifySignature(msg3, signature3, publicKey));
+			assertEquals(false, xmssMT2.verifySignature(msg1, signature3, publicKey));
+			assertEquals(false, xmssMT2.verifySignature(msg2, signature3, publicKey));
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+	}
+	
+	public void testImportKeysSHA512() throws IOException, ClassNotFoundException {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA512Digest(), new NullPRNG());
+		XMSSMT xmssMT1 = new XMSSMT(params);
+		xmssMT1.generateKeys();
+		byte[] msg1 = new byte[1024];
+		byte[] msg2 = new byte[2048];
+		byte[] msg3 = new byte[3096];
+		Arrays.fill(msg1, (byte) 0xaa);
+		Arrays.fill(msg2, (byte) 0xbb);
+		Arrays.fill(msg3, (byte) 0xcc);
+		byte[] signature1 = xmssMT1.sign(msg1);
+		byte[] signature2 = xmssMT1.sign(msg2);
+		byte[] exportedPrivateKey = xmssMT1.exportPrivateKey();
+		byte[] exportedPublicKey = xmssMT1.exportPublicKey();
+		byte[] publicKey = xmssMT1.exportPublicKey();
+		byte[] signature3 = xmssMT1.sign(msg3);
+		
+		XMSSMT xmssMT2 = new XMSSMT(params);
+		try {
+			xmssMT2.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		byte[] signature4 = xmssMT2.sign(msg3);
+		assertEquals(true, XMSSUtil.compareByteArray(signature3, signature4));
+		xmssMT2.generateKeys();
+		try {
+			assertEquals(true, xmssMT2.verifySignature(msg1, signature1, publicKey));
+			assertEquals(true, xmssMT2.verifySignature(msg2, signature2, publicKey));
+			assertEquals(true, xmssMT2.verifySignature(msg3, signature3, publicKey));
+			assertEquals(false, xmssMT2.verifySignature(msg1, signature3, publicKey));
+			assertEquals(false, xmssMT2.verifySignature(msg2, signature3, publicKey));
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+	}
+	
+	public void testRandom() throws ClassNotFoundException, IOException {
+		XMSSMTParameters params = new XMSSMTParameters(20, 10, new SHA512Digest(), new NullPRNG());
+		XMSSMT xmss1 = new XMSSMT(params);
+		xmss1.generateKeys();
+		byte[] publicKey = xmss1.exportPublicKey();
+		byte[] message = new byte[1024];
+		
+		for (int i = 0; i < 5; i++) {
+			xmss1.sign(message);
+		}
+		byte[] signature = xmss1.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(publicKey, xmss1.exportPublicKey()));
+		try {
+			xmss1.verifySignature(message, signature, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		assertTrue(XMSSUtil.compareByteArray(publicKey, xmss1.exportPublicKey()));
+		xmss1.sign(message);
+		byte[] privateKey7 = xmss1.exportPrivateKey();
+		try {
+			xmss1.verifySignature(message, signature, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		assertTrue(XMSSUtil.compareByteArray(privateKey7, xmss1.exportPrivateKey()));
+		byte[] signature7 = xmss1.sign(message);
+
+		try {
+			xmss1.importState(privateKey7, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		byte[] signature7AfterImport = xmss1.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(signature7AfterImport, signature7));
+		
+		XMSSMTParameters params2 = new XMSSMTParameters(20, 10, new SHA512Digest(), new NullPRNG());
+		XMSSMT xmss2 = new XMSSMT(params2);
+		try {
+			boolean valid = xmss2.verifySignature(message, signature7, publicKey);
+			assertTrue(valid);
+			valid = xmss2.verifySignature(message, signature, publicKey);
+			assertTrue(valid);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		
+		XMSSMT xmss3 = new XMSSMT(params);
+		try {
+			xmss3.importState(privateKey7, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		byte[] signatureAgain = xmss3.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(signatureAgain, signature7));
+	}
+	
+	public void testPublicSeed() throws IOException, ClassNotFoundException {
+		byte[] message = new byte[1024];
+		XMSSMTParameters params1 = new XMSSMTParameters(20, 10, new SHA256Digest(), new SecureRandom());
+		XMSSMT mt1 = new XMSSMT(params1);
+		mt1.generateKeys();
+		byte[] publicKey1 = mt1.exportPublicKey();
+		byte[] signature1 = mt1.sign(message);
+		
+		XMSSMTParameters params2 = new XMSSMTParameters(20, 10, new SHA256Digest(), new NullPRNG());
+		XMSSMT mt2 = new XMSSMT(params2);
+		mt2.generateKeys();
+		byte[] publicKey2 = mt2.exportPublicKey();
+		byte[] privateKey2 = mt2.exportPrivateKey();
+		byte[] signature2 = mt2.sign(message);
+		
+		try {
+			mt2.importState(privateKey2, publicKey2);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		try {
+			boolean isValid = mt2.verifySignature(message, signature1, publicKey1);
+			assertTrue(isValid);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		byte[] signature3 = mt2.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(signature2, signature3));
+	}
+	
+	public void testBDSImport() throws IOException, ClassNotFoundException {
+		XMSSMTParameters params = new XMSSMTParameters(10, 5, new SHA256Digest(), new SecureRandom());
+		XMSSMT xmss = new XMSSMT(params);
+		xmss.generateKeys();
+		xmss.sign(new byte[1024]);
+		byte[] exportedPrivateKey = xmss.exportPrivateKey();
+		byte[] exportedPublicKey = xmss.exportPublicKey();
+		try {
+			xmss.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		byte[] sig1 = xmss.sign(new byte[1024]);
+		try {
+			xmss.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		byte[] sig2 = xmss.sign(new byte[1024]);
+		assertEquals(true, XMSSUtil.compareByteArray(sig1, sig2));
+		try {
+			xmss.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (Exception ex) { }
+		xmss.sign(new byte[1024]);
+		byte[] sig3 = xmss.sign(new byte[1024]);
+		assertEquals(false, XMSSUtil.compareByteArray(sig1, sig3));
+		try {
+			xmss.importState(null, exportedPublicKey);
+			fail();
+		} catch (Exception ex) { }
+		try {
+			xmss.importState(exportedPrivateKey, null);
+			fail();
+		} catch (Exception ex) { }
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSOidTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSOidTest.java
new file mode 100644
index 0000000..2353bf3
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSOidTest.java
@@ -0,0 +1,70 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import junit.framework.TestCase;
+import org.bouncycastle.pqc.crypto.xmss.DefaultXMSSOid;
+
+/**
+ * Test cases for {@link DefaultXMSSOid} class.
+ */
+public class XMSSOidTest
+    extends TestCase
+{
+
+    public void testXMSSOidException1()
+    {
+        DefaultXMSSOid xmssOid = DefaultXMSSOid.lookup("SHA-256", 32, 16, 67, -1);
+        assertEquals(xmssOid, null);
+    }
+
+    public void testXMSSOidException2()
+    {
+        DefaultXMSSOid xmssOid = DefaultXMSSOid.lookup("SHA-256", 32, 16, 67, 8);
+        assertEquals(xmssOid, null);
+    }
+
+    public void testXMSSOidException3()
+    {
+        DefaultXMSSOid xmssOid = DefaultXMSSOid.lookup("SHA-256", 32, 4, 67, 10);
+        assertEquals(xmssOid, null);
+    }
+
+    public void testXMSSOid()
+    {
+        DefaultXMSSOid xmssOid = DefaultXMSSOid.lookup("SHA-256", 32, 16, 67, 10);
+        assertEquals(0x01000001, xmssOid.getOid());
+        assertEquals("XMSS_SHA2-256_W16_H10", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHA-256", 32, 16, 67, 16);
+        assertEquals(0x02000002, xmssOid.getOid());
+        assertEquals("XMSS_SHA2-256_W16_H16", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHA-256", 32, 16, 67, 20);
+        assertEquals(0x03000003, xmssOid.getOid());
+        assertEquals("XMSS_SHA2-256_W16_H20", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHA-512", 64, 16, 131, 10);
+        assertEquals(0x04000004, xmssOid.getOid());
+        assertEquals("XMSS_SHA2-512_W16_H10", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHA-512", 64, 16, 131, 16);
+        assertEquals(0x05000005, xmssOid.getOid());
+        assertEquals("XMSS_SHA2-512_W16_H16", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHA-512", 64, 16, 131, 20);
+        assertEquals(0x06000006, xmssOid.getOid());
+        assertEquals("XMSS_SHA2-512_W16_H20", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHAKE128", 32, 16, 67, 10);
+        assertEquals(0x07000007, xmssOid.getOid());
+        assertEquals("XMSS_SHAKE128_W16_H10", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHAKE128", 32, 16, 67, 16);
+        assertEquals(0x08000008, xmssOid.getOid());
+        assertEquals("XMSS_SHAKE128_W16_H16", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHAKE128", 32, 16, 67, 20);
+        assertEquals(0x09000009, xmssOid.getOid());
+        assertEquals("XMSS_SHAKE128_W16_H20", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHAKE256", 64, 16, 131, 10);
+        assertEquals(0x0a00000a, xmssOid.getOid());
+        assertEquals("XMSS_SHAKE256_W16_H10", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHAKE256", 64, 16, 131, 16);
+        assertEquals(0x0b00000b, xmssOid.getOid());
+        assertEquals("XMSS_SHAKE256_W16_H16", xmssOid.toString());
+        xmssOid = DefaultXMSSOid.lookup("SHAKE256", 64, 16, 131, 20);
+        assertEquals(0x0c00000c, xmssOid.getOid());
+        assertEquals("XMSS_SHAKE256_W16_H20", xmssOid.toString());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSPrivateKeyTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSPrivateKeyTest.java
new file mode 100644
index 0000000..991ebea
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSPrivateKeyTest.java
@@ -0,0 +1,50 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.io.IOException;
+import java.text.ParseException;
+
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSS;
+import org.bouncycastle.pqc.crypto.xmss.XMSSParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSPrivateKeyParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+import junit.framework.TestCase;
+
+/**
+ * Test cases for XMSSPrivateKey class.
+ * 
+ */
+public class XMSSPrivateKeyTest extends TestCase {
+
+	public void testPrivateKeyParsing() throws ClassNotFoundException, IOException {
+		XMSSParameters params = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		byte[] root = { (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06,
+				(byte) 0x07, (byte) 0x08, (byte) 0x09, (byte) 0x0a, (byte) 0x0b, (byte) 0x0c, (byte) 0x0d, (byte) 0x0e,
+				(byte) 0x0f, (byte) 0x10, (byte) 0x20, (byte) 0x30, (byte) 0x03, (byte) 0x40, (byte) 0x50, (byte) 0x60,
+				(byte) 0x70, (byte) 0x80, (byte) 0x90, (byte) 0xa0, (byte) 0xb0, (byte) 0xc0, (byte) 0xd0, (byte) 0xe0,
+				(byte) 0xf0 };
+		XMSSPrivateKeyParameters privateKey = null;
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withIndex(0xaa).withRoot(root).build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		}
+		byte[] export = privateKey.toByteArray();
+
+		XMSSPrivateKeyParameters privateKey2 = null;
+		try {
+			privateKey2 = new XMSSPrivateKeyParameters.Builder(params).withPrivateKey(export, new XMSS(params)).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		assertEquals(privateKey.getIndex(), privateKey2.getIndex());
+		assertEquals(true, XMSSUtil.compareByteArray(privateKey.getSecretKeySeed(), privateKey2.getSecretKeySeed()));
+		assertEquals(true, XMSSUtil.compareByteArray(privateKey.getSecretKeyPRF(), privateKey2.getSecretKeyPRF()));
+		assertEquals(true, XMSSUtil.compareByteArray(privateKey.getPublicSeed(), privateKey2.getPublicSeed()));
+		assertEquals(true, XMSSUtil.compareByteArray(privateKey.getRoot(), privateKey2.getRoot()));
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSPublicKeyTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSPublicKeyTest.java
new file mode 100644
index 0000000..f56ad21
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSPublicKeyTest.java
@@ -0,0 +1,93 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.text.ParseException;
+
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSSParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSPublicKeyParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+import junit.framework.TestCase;
+
+/**
+ * Test cases for XMSSPublicKey class.
+ * 
+ */
+public class XMSSPublicKeyTest extends TestCase {
+
+	public void testPublicKeyParsingSHA256() {
+		XMSSParameters params = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		byte[] root = { (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06,
+				(byte) 0x07, (byte) 0x08, (byte) 0x09, (byte) 0x0a, (byte) 0x0b, (byte) 0x0c, (byte) 0x0d, (byte) 0x0e,
+				(byte) 0x0f, (byte) 0x10, (byte) 0x20, (byte) 0x30, (byte) 0x03, (byte) 0x40, (byte) 0x50, (byte) 0x60,
+				(byte) 0x70, (byte) 0x80, (byte) 0x90, (byte) 0xa0, (byte) 0xb0, (byte) 0xc0, (byte) 0xd0, (byte) 0xe0,
+				(byte) 0xf0 };
+		XMSSPublicKeyParameters publicKey = null;
+		try {
+			publicKey = new XMSSPublicKeyParameters.Builder(params).withRoot(root).build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		}
+		byte[] export = publicKey.toByteArray();
+
+		XMSSPublicKeyParameters publicKey2 = null;
+		try {
+			publicKey2 = new XMSSPublicKeyParameters.Builder(params).withPublicKey(export).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		assertEquals(true, XMSSUtil.compareByteArray(publicKey.getRoot(), publicKey2.getRoot()));
+		assertEquals(true, XMSSUtil.compareByteArray(publicKey.getPublicSeed(), publicKey2.getPublicSeed()));
+	}
+
+	public void testPublicKeyParsingSHA512() {
+		XMSSParameters params = new XMSSParameters(10, new SHA512Digest(), new NullPRNG());
+		byte[] root = { (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06,
+				(byte) 0x07, (byte) 0x08, (byte) 0x09, (byte) 0x0a, (byte) 0x0b, (byte) 0x0c, (byte) 0x0d, (byte) 0x0e,
+				(byte) 0x0f, (byte) 0x10, (byte) 0x20, (byte) 0x30, (byte) 0x03, (byte) 0x40, (byte) 0x50, (byte) 0x60,
+				(byte) 0x70, (byte) 0x80, (byte) 0x90, (byte) 0xa0, (byte) 0xb0, (byte) 0xc0, (byte) 0xd0, (byte) 0xe0,
+				(byte) 0xf0, (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06,
+				(byte) 0x07, (byte) 0x08, (byte) 0x09, (byte) 0x0a, (byte) 0x0b, (byte) 0x0c, (byte) 0x0d, (byte) 0x0e,
+				(byte) 0x0f, (byte) 0x10, (byte) 0x20, (byte) 0x30, (byte) 0x03, (byte) 0x40, (byte) 0x50, (byte) 0x60,
+				(byte) 0x70, (byte) 0x80, (byte) 0x90, (byte) 0xa0, (byte) 0xb0, (byte) 0xc0, (byte) 0xd0, (byte) 0xe0,
+				(byte) 0xf0 };
+		XMSSPublicKeyParameters publicKey = null;
+		try {
+			publicKey = new XMSSPublicKeyParameters.Builder(params).withRoot(root).build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		}
+		byte[] export = publicKey.toByteArray();
+
+		XMSSPublicKeyParameters publicKey2 = null;
+		try {
+			publicKey2 = new XMSSPublicKeyParameters.Builder(params).withPublicKey(export).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		assertEquals(true, XMSSUtil.compareByteArray(publicKey.getRoot(), publicKey2.getRoot()));
+		assertEquals(true, XMSSUtil.compareByteArray(publicKey.getPublicSeed(), publicKey2.getPublicSeed()));
+	}
+
+	public void testConstructor() {
+		XMSSParameters params = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		XMSSPublicKeyParameters pk = null;
+		try {
+			pk = new XMSSPublicKeyParameters.Builder(params).build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		}
+		byte[] pkByte = pk.toByteArray();
+		/* check everything is 0 */
+		for (int i = 0; i < pkByte.length; i++) {
+			assertEquals(0x00, pkByte[i]);
+		}
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSReducedSignatureTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSReducedSignatureTest.java
new file mode 100644
index 0000000..c5a73ab
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSReducedSignatureTest.java
@@ -0,0 +1,81 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.text.ParseException;
+
+import junit.framework.TestCase;
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMT;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSMTSignature;
+import org.bouncycastle.pqc.crypto.xmss.XMSSParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSReducedSignature;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * Test cases for XMSSReducedSignature class.
+ * 
+ */
+public class XMSSReducedSignatureTest extends TestCase {
+
+	public void testSignatureParsingSHA256() {
+		XMSSMTParameters params = new XMSSMTParameters(8, 2, new SHA256Digest(), new NullPRNG());
+		XMSSMT mt = new XMSSMT(params);
+		mt.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = mt.sign(message);
+		XMSSMTSignature sig2 = null;
+		try {
+			sig2 = new XMSSMTSignature.Builder(params).withSignature(sig1).build();
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		XMSSReducedSignature reducedSignature1 = sig2.getReducedSignatures().get(0);
+		byte[] reducedSignatureBinary = reducedSignature1.toByteArray();
+		XMSSReducedSignature reducedSignature2 = null;
+		try {
+			reducedSignature2 = new XMSSReducedSignature.Builder(new XMSSParameters(4, new SHA256Digest(), new NullPRNG())).withReducedSignature(reducedSignatureBinary).build();
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		assertTrue(XMSSUtil.compareByteArray(reducedSignatureBinary, reducedSignature2.toByteArray()));
+	}
+
+	public void testSignatureParsingSHA512() {
+		XMSSMTParameters params = new XMSSMTParameters(4, 2, new SHA512Digest(), new NullPRNG());
+		XMSSMT mt = new XMSSMT(params);
+		mt.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = mt.sign(message);
+		XMSSMTSignature sig2 = null;
+		try {
+			sig2 = new XMSSMTSignature.Builder(params).withSignature(sig1).build();
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		XMSSReducedSignature reducedSignature1 = sig2.getReducedSignatures().get(0);
+		byte[] reducedSignatureBinary = reducedSignature1.toByteArray();
+		XMSSReducedSignature reducedSignature2 = null;
+		try {
+			reducedSignature2 = new XMSSReducedSignature.Builder(new XMSSParameters(2, new SHA512Digest(), new NullPRNG())).withReducedSignature(reducedSignatureBinary).build();
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		assertTrue(XMSSUtil.compareByteArray(reducedSignatureBinary, reducedSignature2.toByteArray()));
+	}
+
+	public void testConstructor() {
+		XMSSReducedSignature sig = null;
+		try {
+			sig = new XMSSReducedSignature.Builder(new XMSSParameters(4, new SHA512Digest(), new NullPRNG())).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+		}
+		byte[] sigByte = sig.toByteArray();
+		/* check everything is 0 */
+		for (int i = 0; i < sigByte.length; i++) {
+			assertEquals(0x00, sigByte[i]);
+		}
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSSignatureTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSSignatureTest.java
new file mode 100644
index 0000000..8c8153f
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSSignatureTest.java
@@ -0,0 +1,68 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.text.ParseException;
+
+import junit.framework.TestCase;
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSS;
+import org.bouncycastle.pqc.crypto.xmss.XMSSParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSSignature;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * Test cases for XMSSSignature class.
+ * 
+ */
+public class XMSSSignatureTest extends TestCase {
+
+	public void testSignatureParsingSHA256() {
+		XMSSParameters params = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = xmss.sign(message);
+		XMSSSignature sig2 = null;
+		try {
+			sig2 = new XMSSSignature.Builder(params).withSignature(sig1).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		byte[] sig3 = sig2.toByteArray();
+		assertEquals(true, XMSSUtil.compareByteArray(sig1, sig3));
+	}
+
+	public void testSignatureParsingSHA512() {
+		XMSSParameters params = new XMSSParameters(10, new SHA512Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = xmss.sign(message);
+		XMSSSignature sig2 = null;
+		try {
+			sig2 = new XMSSSignature.Builder(params).withSignature(sig1).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		byte[] sig3 = sig2.toByteArray();
+		assertEquals(true, XMSSUtil.compareByteArray(sig1, sig3));
+	}
+
+	public void testConstructor() {
+		XMSSParameters params = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		XMSSSignature sig = null;
+		try {
+			sig = new XMSSSignature.Builder(params).build();
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+		}
+		byte[] sigByte = sig.toByteArray();
+		/* check everything is 0 */
+		for (int i = 0; i < sigByte.length; i++) {
+			assertEquals(0x00, sigByte[i]);
+		}
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSTest.java
new file mode 100644
index 0000000..b152331
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSTest.java
@@ -0,0 +1,431 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.text.ParseException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.bouncycastle.crypto.digests.SHA256Digest;
+import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.pqc.crypto.xmss.NullPRNG;
+import org.bouncycastle.pqc.crypto.xmss.XMSS;
+import org.bouncycastle.pqc.crypto.xmss.XMSSNode;
+import org.bouncycastle.pqc.crypto.xmss.XMSSParameters;
+import org.bouncycastle.pqc.crypto.xmss.XMSSSignature;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+import org.bouncycastle.util.encoders.Hex;
+
+import junit.framework.TestCase;
+
+/**
+ * Test cases for XMSS class.
+ * 
+ */
+public class XMSSTest extends TestCase {
+
+	public void testAuthPath() {
+		XMSSParameters xmssParams = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(xmssParams);
+		xmss.generateKeys();
+		String[] expectedAuthPath = {
+				"e0e81477f50e2b8719d1d9a3c1a55d5460711b88eb4f2c8df8d17d38832de9d4",
+				"251142aa2cdb5a9d81a0c7a98e2c3c95bf96e73c68c78d467186eeac1dffce38",
+				"53a6a544a1331bf650758d64bb8fab1104170824894fdd8a284d281aec9d6270",
+				"5683d8f8de11a5845b9d1b5cedb7fd0bd76da3341e75ddd05f261520228664d0",
+				"16b265f881e4b7bd303b7c38b8adcf31a7c211bcddb5260080105c1b70c41ee9",
+				"9d421eefaf1e51d762f245853cc36250bfbb3f547770303dc8a38d03dec2d0a7",
+				"233b634f83a2456f279126c7fcb47f9301cb2d5e8db69f4721f68000d78cffb3",
+				"9317371748b85e824bd82284875b7bb65604c94ff0b8816cef677ade31963bd5",
+				"14ba59e3d998735a963d018b840a80be11a52ccdadaceb7ed45f0763e6cd49ca",
+				"6af97f6bde85e4569178192bab4fd59d8c2b1fec181f27a8fa2c17552c16e3b5"
+		};
+		byte[] signature = xmss.sign(new byte[1024]);
+		XMSSSignature sig = null;
+		try {
+			sig = new XMSSSignature.Builder(xmssParams).withSignature(signature).build();
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		List<XMSSNode> authPath = sig.getAuthPath();
+		for (int i = 0; i < authPath.size(); i++) {
+			assertEquals(expectedAuthPath[i], Hex.toHexString(authPath.get(i).getValue()));
+		}
+	}
+	
+	public void testGenKeyPairSHA256() {
+		XMSSParameters xmssParams = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(xmssParams);
+		xmss.generateKeys();
+		byte[] privateKey = xmss.exportPrivateKey();
+		byte[] publicKey = xmss.exportPublicKey();
+		String expectedPrivateKey = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000073c3fc6de1195aa5d69f9dafc9db8504aa8059115e8319ca15cf58a1c83c0de3";
+		String expectedPublicKey = "73c3fc6de1195aa5d69f9dafc9db8504aa8059115e8319ca15cf58a1c83c0de30000000000000000000000000000000000000000000000000000000000000000";
+		byte[] strippedPrivateKey = XMSSUtil.extractBytesAtOffset(privateKey, 0, (Hex.decode(expectedPrivateKey).length));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPrivateKey), strippedPrivateKey));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPublicKey), publicKey));
+	}
+	
+	public void testGenKeyPairSHA512() {
+		XMSSParameters xmssParams = new XMSSParameters(10, new SHA512Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(xmssParams);
+		xmss.generateKeys();
+		byte[] privateKey = xmss.exportPrivateKey();
+		byte[] publicKey = xmss.exportPublicKey();
+		String expectedPrivateKey = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f48df90f8e217076d8af6327691321bdcf63668c4bd28d021d49f2334eca845fa3073991049286c0eef5dc7f23ec0b31f5c1bd1e5b8edb2403ae02f292f6f30e";
+		String expectedPublicKey = "f48df90f8e217076d8af6327691321bdcf63668c4bd28d021d49f2334eca845fa3073991049286c0eef5dc7f23ec0b31f5c1bd1e5b8edb2403ae02f292f6f30e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+		byte[] strippedPrivateKey = XMSSUtil.extractBytesAtOffset(privateKey, 0, (Hex.decode(expectedPrivateKey).length));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPrivateKey), strippedPrivateKey));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedPublicKey), publicKey));
+	}
+	
+	public void testSignSHA256() {
+		XMSSParameters params = new XMSSParameters(10, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = xmss.sign(message);
+		byte[] sig2 = xmss.sign(message);
+		byte[] sig3 = xmss.sign(message);
+		String expectedSig1 = "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";
+		String expectedSig2 = "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";
+		String expectedSig3 = "000000029200f6d2d656430e2c49eda24923d91c484885f9e626e8e76cad5fd2f7d875ccaa913998ed0c0085cae2d9c2e563315d4df92d857520f22935aca637e8755fe9f62d6389cbc9738ce8cff101e0707d6850ce003b9b884fd3c669647d697bfd3a24b675a6955113297e9ba806b790a776362c47d3081dc09e430172d5d6212893a751c05c70ab1481395e204d1fb675e0dc47e226ca450d132163dcd9dbec52d4df457482e99dcc06c7746eb4ed000eeefd95ee8fdb6d154db279a7f7eeb2aec2f43d566cbbf92bd7c45cd3a56f52223439bfe06a8b136aa35c76381ed5576e8ecc0a25657200ac81e914ce227bc2dc859545d315fce5cae6f88816fde127a76d9cc67953590a63ff7ec230b27658e97a2d5f9a9edcd87b9323381f72d121dc2c56f89312eb58294290415619247ceff45fdf49284ce795592f519288a5c7a86436c190883edab0e58b31eb277ed32cc572e53241394e526496b94f338abdbe84251ae0183edc154fba47af8c0a9e9ad9a2d7ff45aba5987cdb127b344a22b4583cd1926c5791139f4c9852013b0ae8acfd8ce7114ae6d45b321d245a3db19a082d3a3205a6ad3b7838c824bb81952250b09858c543254a42ecfaf23affd642fff84929a4bcb40d65fcea84e461c4b3fc2f8d4a1ba3e561be9805fdfd74741ab4c407252d40188ad932d4b53ac3b806d674a01140f2e97bfb25a3baf30c29b534db198680822a0da9c1a103278e059a8d0dcf5e444178f1a55e3d75ea9bd3147739364960c959667a61645ede0d5fbc8cbb853ab42002a2205fe271b17e9fe095cadad0d168bafa8a392eb8e3e8d2afeacdccbc5a6f4addad61c0b4368f6a92b182c39c2eea41520419bfea541ba2815ba1f539275ce944fb66f94f72c47383350966125927196399bcb39c287889daad0f1dfc41af86bd70429ee6ffda828d4ded50080c47b7315150768eedd9bfe586fdf37d7a0c74807838fafc5a1e5e64feaeba16a1b87cb1f6241af614997ebdfb83681b74ec33b23e4ab6732417ca3b6fb5336b3e31ebe82c90d60aa218d26dd09e65e6542aac5c3f295e3e050e43d68792d10b4c2c5e6c7d0129d85e3ea79e6b13c2af471a2192e8ab8a6f4c96185468e8931b4dac3036e87467d2cf75aec5d908a526a507740e333575ff3902d4142f88bdcb5b06583523197ca8b9ab390fa61e9929ad6a4c73d1ade927f945d45f77175a813623caaf0ff586330ddbc6dba9ee39e62da280ecc13ffc22f83a8cbfe7f3495231a7612b9628e17fc7758f020fa42df2dcedb74b4844481aed37c108bbdd8576f189b662633fa1e91fc481b381f042dd4dbf5e2f6d545b88f1b8c2f04126f62d6f2147aa9001781f930984298edb117598e711702e0788e0e9304c760d9fa1321254290463c5ce096daedae47109657353704ea9809a7e10f2a0cfbee0604098b7f8431a7ec26ad04698b74097b9ec544fe510a29dda677dc2e12e73e57f639e880b0aad0deb5fa29771abfdbb582a76061f3b42c3939c12dd426a03fe9d5287f1bb9f8fcf4f5b2598210ac126c52bcdbe27695432625fbce06960d3460012e52971b5d19fd1b1ee55e52971ce27377dcc4a907bbc7bc2ace94265f22c2089a4c3dda2fd42b3e388e7db905eb043a48ba49104dbbd47c5baae0f1af80a7f414e22799c4e5312a98a72a464ce11850772c4b6bff995be2567dba1364c98b1fa6326b4bfcd4bdf30c48a25f36158875dbd77597987f2bbed2bf0d0ea457726cf108af5628c32fd0f36cf214275aa8961b22fb1e042959d81bff3c1bf2128d4355d0f964dfa6469b5579d63485bf3ba3eb2cea80e095b32ab8665b48c0b1c04895eaea3c67edb71f30bd308971b130eb85a0970b570f47f4e613dfa5e3ee6ea68c6f71cdf369c79146bddb693a1a92b8c80acd061815b34737b5e4adfd68d28e293a3dd85620d6aecf5714e3ea7cd148b9976738b367291ab32de5144a3de66306a248109a43b32d239e80b34ef2994dcb2af1c28f7739f6f7e502a2cba8629cdb74dbab64162782da7b72c0f3d5dc4fbb351eaaa423026842a7fa340fcabb7188487d805abd8f0bbc8dac9d277d3976aef2d300eef62fad9ce676dd243beb43344577510f974a39fe48d922c2a22c6fafebfa549473d9432df34836163cf71dd0a3f337027d2aceafbe27d8bf99657c137567de22bfc060c60c15539b058a6c9eb703be266cde32ffae7eb881a35e4cb453fb5f1a5615ff99107de5b9577bf85d2f00937731a0d96fa7c994a2a69c8ce789bfcd448d2bdcda4191b6ea3ed3b020f78e779f70a1b526026c5d9c0bc15861800e0e71a1b481f0e74069354e08abc6d7d1944bd46596456a4768ac26b555785ebc68f48cff8af0e52b847b7e4d40089a48c741c9adca24754abb1e201020a5d39e7d7b9060a762957060f12d26667bf59cd39b7327e873a7ac774018a0fefef3d22d920ec00cc0d8dc53192306d5306aac11092c750985a226fd6cbe125f68133c12882ee31e48f5c2781e27abefe44cd4a1b4384c42be03218b26722fdf83d6c4490e9bed4a430151206eee84694e5787c94670ef60d5ae8158e78af8797962082fec9b492769231a39f2dfd2dd5e08babc3ecd90d648e8b3acce525680684c37be1ccc9f2abf75b9dc198f33c9dc13bd328ba4cfe1a375a6ddd2fb8b2e44a16ccf87f5eed8247aa49efa0368718ed7de0e3b925ef0d2e362f466763d61baaf81abd468a04c0a164938b77c9293b70ad9ea6fd500d406eafd4e64a716d4480b3861a3f4c1d56df1494877eeff2934690c2e6b03b3d4c618cbca4cfed4e3a5bc0204aa307b023e24f17cf41cb26a52797cf55a94a015a79d1fa5a49df99501f4590522645f54bfd8738b8395b3b7da5f5bdd2b1a2cdbaa21d692e6c8894c9896d42ee55088f4829f07e226a2d06196b15d909a709df1ad319de092e30f3d373595c704192d1b9f6330dc1631bdef5fb01d9ba7c0790cd840f3de0d0cc48b5c6640b3b7729ff9c1dc23e3b44edd9da3615e4e46080fec3123382f7ec23eb2b9c2e37befc6d246af039b5765d039be4aa2007955dfe8862983d252d8b79a33e9b1c531003f1cd3a8bcc6d29ff8aac0062bbc479ad59262cc6bce4048859718988b62e2c4511ed65f659cf8c579a53a6a544a1331bf650758d64bb8fab1104170824894fdd8a284d281aec9d62705683d8f8de11a5845b9d1b5cedb7fd0bd76da3341e75ddd05f261520228664d016b265f881e4b7bd303b7c38b8adcf31a7c211bcddb5260080105c1b70c41ee99d421eefaf1e51d762f245853cc36250bfbb3f547770303dc8a38d03dec2d0a7233b634f83a2456f279126c7fcb47f9301cb2d5e8db69f4721f68000d78cffb39317371748b85e824bd82284875b7bb65604c94ff0b8816cef677ade31963bd514ba59e3d998735a963d018b840a80be11a52ccdadaceb7ed45f0763e6cd49ca6af97f6bde85e4569178192bab4fd59d8c2b1fec181f27a8fa2c17552c16e3b5";
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig1), sig1));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig2), sig2));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig3), sig3));
+	}
+
+	public void testSignSHA256CompleteEvenHeight1() {
+		final String[] signatures = {
+				"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",
+				"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",
+				"000000029200f6d2d656430e2c49eda24923d91c484885f9e626e8e76cad5fd2f7d875cc1a024d58a92556c86b25cd3eb57e4c90806efe4324e6240d3794284d4c682f3af62d6389cbc9738ce8cff101e0707d6850ce003b9b884fd3c669647d697bfd3a992e0c3ff8b2dc7d51f3b3b8ebb1d42e933c89c44655a602fee6909fe9e972f503cc9a155d185e6638188f2bb8385a519563384778cc15284d03647265b64de909da1ca2871d66495f944abaaec13730a7cc63ae95e0edd4c8887950fae41e02d930b84c3a0f6cfbc49d8c9900dda13b6a7e9273cba461e52af92372709d8d35d29057792ec2ea5e7ce48c03e42cd71595f6bc21878b2d0755af9f0c6e203761059df223016065153d1ea2458fb1c7e4bd881ab3b3c777765adbcff7327270c203f0d3abd11fcd7eb17dbad445d7d13c94d3d75d3cd0dea624e231e867a2f1c26ccc79944785df6ee955296fd29a555df7d83feca277dba523187c83c480c83833346cc9e9b75ac25afe60dd3a8f07a74fee7db3519c0d176d66c47ba8945f843cd1926c5791139f4c9852013b0ae8acfd8ce7114ae6d45b321d245a3db19a087128109b19fd393ca52327af307ba656132e5837cd861783668a8eb0a1039a30e8ca5c22f9b77a008758cf9e92d49ba7d5ac0afb6dcc71572c3b9e6c58fd5b91f34129133d4a4fe1a84debb1072dad543ce99a66ab0a8518d68650ff20ce95cd0d99725065625fcb8a8731de017b1ddcb6df613177280cebb62d004d73b56ed3b2550983f215f5ad25149e3c65aa92d531b9435aba210a1909575d5aa580cd9bf6b2f648620b17ec5b90da73e4d8978fa5cb361a46e4390c8713a3fd2c92026155cbeaa3e9ffa03249f9819b9c114d900ae376b48040cab1ee669d61751f82c1ff9fd61578d4ecb15963d5c62d6c9b64e649b33843c87f4b0bf92c192cb3c3d1c9a867f30afbba4feb549710a1060a6784262baf647fe22e2d16c8f58ddd8bf80aa6c2e7e08a9aabd6171a6a9b49697fdd8c896a7cf857789670d79306c3550d44f535f1e83b7e669ec1a7c7bb49f655bfe7d152e7a05a3c0a9659e2fa5ef951ab3d7d2d30712c561764c765c592e047722c756ff186c3094b041376c484489a0d4049b6f1532e52f97a852f5b810fe43160616be53f3d781d8a4b2d4c039bf5028c2f7057b0523a6617f98e25fc99229c8961488867c11899998cea957c2d135c46ec6de295d9017a5c1436abef766777da7876a1d0adf411863ba4e576d1d613eeca592882601723a1d9dfe5c6b04646c7945a2624cfdfd8417cfdae769ebdd5cb9d2a4016fa8d186910bfc806aed6bb0fb1debb259fc1e9c7362eb36f0913c8a35d1b8800f9b39d5a0844dbd281696b54900d4226939ffe49b07a48952ea9fddf5f0b8ebb0e79a19f83bec3c51b6e4ee8853ddd80becc8ac7a0e214b3f6f6e2a75c09e8f144428df8e2a9aaa930a7fe38ac1a5847933cc5b4c2804eb3833566da3568eccb46cf6a439ddb3304487370dfdd20d237c09613eb22bdf2bb36651ed4b564890c478b720d60c59e07aeff8101ff1b0ffbb9c894cac3c1f78ff49602f3b7c55e664011dc235d2c6b833bb790e2cb06f419a98f43e419c925d30e4984d868fd55b955bc7a73c3d3b8ba7b1befe54d67236e4e42f99e54409cd5cda875df13c0c787285c03d89d6241cc7a992732292e2ce4a6698a64527aba1d7011a09a2f21dfd24b86e16a30ec471bfef6675e72ed2d450309144da61655c6c3706bfd3ab7025d37daf17d0e852ad884a98394ff7a08bcb63f6c3a2b1c9a06c494167207a672aecd7748b34e68fb3719635308f90e01bf61a51df786544f2dbfadfbd6e8509bf6744c906b6a96e535865165ddb175b46c3b7258c32802c10166f2bbed48a8080933030a581ed12ae57483c3e08b48b48d817ea84f71a980b4028de31e01b543be905e9a998991fb44e82b8e6bcd88d09ba15ee58b380a44ebc1821c0dc6eba1d5aa00b9dee768ebdca34b5e757e43047688bd6a3aa03b047b171bad8ef66a6f739c1a11777381c66beef7be94260948a3b774656c75bce0b08515391488b850b3430530613f277c1ee7bed2a7bc272f3b8c6ee177c727e69bea31eb3edad0afb76151d30fe31d6649fa90a36f5903d6bee31b2cf7410896977d7aa4ca5f9749402f7bda44a33aa1211e392493640e2f0df751e769ce000aff1a60f9ba91d17c7cf6bda9f3186dcb1b87e7157b8cd264319404a909222036a836dd3af06c03fb52cf3c9a8afbe25ff9dec5c5e7c542b6bf8f5c535ebc653bbf4597860d1fc57c25cce1531b7ee5e86a990067a5db54188addba92b4e82fdbc9c5c781ab83f33d267abc0ffa02a8e3a7bd91876e7cbbaea246f5a8d3c1372e802ec929353f8a1136447ac61e3f81b37532ee969be56df9d5be0048ba38ee17ae460d640eee02be69de6e4d18606b2bf8c604de3028b42812f9cc4385924240c8f3426d5306aac11092c750985a226fd6cbe125f68133c12882ee31e48f5c2781e27a7aeec7b419c655c8e85830d403fce77a59e5fcb7701d2f24716b63d313a6f2e2e8ad76bf14ca509717319387b69a937d39d2edde293bb663b72b93aa58285c3669cc0d6835e8ea7e1a66f24236b2cb1879a0b391d7cf7b2e65d6c4849d9c365a21bec8d77091ca5c510f8dfd50f46cbe18ff05728f27d4a1977be024ce364f708b81a07f4d60853f01cefd48faf34e4b7ef2cfb5a098e5ddc8e758aa2108890bfb0f6392c1bd0b2a78164a490e2cdb88abac7c1d4829ecab6e639d6a44935d29593c1558cf5d36e9a59d275f88fef060f3aa60ac06e0c15f4ca46901553d27ebc5820896fd6aad46294e40ab0d2c6c6458267cd017ef82fd5fb8cfef2be9535952d6bcdb029abaf13be1e868e90265baa6f044eb9c95ea709f375272ffa245668c944f61f837d00baa017230a5630ba293c3f1f2c0594c6e8a9f55e995f38d8295eb37955f4d3c29f81426636afbb4a1551cfb6c8bfb521941c4f167a30fa2aa5bfeceab0fed80c9cf813e3b75aee9162054ed94243cc2998739b63bb3ba08e79be4aa2007955dfe8862983d252d8b79a33e9b1c531003f1cd3a8bcc6d29ff8aac0062bbc479ad59262cc6bce4048859718988b62e2c4511ed65f659cf8c579a53a6a544a1331bf650758d64bb8fab1104170824894fdd8a284d281aec9d62705683d8f8de11a5845b9d1b5cedb7fd0bd76da3341e75ddd05f261520228664d0",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"0000000da714e82f54dfd7f6c178572d168289c560985042e67c45781d7e940aa1a33f475daa7030d66e06aa3af46ca036f84b6e3b64ed6fd3192a9ce620f5646dc3e27cd949e534744afe3763f3766ad1f3040c8765b58938cef23bb6959863450b322a4d6abaacf215216be0ffff2d0032ea3d2c5080b75bd836bd89286193dce3c869c62dcce82a28a7383c7aa44c05bd97e018c56686042d78076739f8a335f3db927f9f02d385370c05d72859ec69a2a361fbe07cb6e2dc6cef48cc253d76fe80c65c2afb2df7a16e2f380d96cc054408fad0e97ba8ef4ab07a40720ec846c43c00b5bfd6359b187ccd9a39c44da45d9858a2e98d65c432199b44b09ba66d4db8908cc8d642bbc41e2353efd83c7b32898791ce4ab95977f813bc8af3eb03598f2773667277aad09e296675de39f5256c2652da25810bfeb575b36dace7ce0da4a188c30ab6cf32dc02eda4518b4811dce8df899556d50382a0df047b9d60cc2fb746da68e2635044bb99aa9b55b0b91c709c273a6b2e4639ec33cb0d89aae6667d2a7548d89930021cf49f417702f0affff0a3643bcd0d01755db385f32c3da9e8a09e1ba753aa8b2604f5e54186877aac6e3bf110ff66219441b84d9c21835bb9c6fcd0d4eb2cf222167d3d0d6cbf5c701c0372c8cece7e54d719cc87d5fdf454fc01be4255d00880c2c43abb6290098207fb9afa3066ad64c6298eea1db4f4d0955d7f5badddaea10a7594fd2cd97c36433489e2cf4c68edfd2b2de08144bcb43a72786e244f235812aeec01da3bf2f0b8b8f5a0594bd206990858361de2e5cdd88d58bf4fbbe4a360fdbb992315ba586bed1aa31993264969f3054b9d182c027aca53b6e44b1866e0f76ce781e42f65f330048ecdb9a0fb41ce5b6303871fe893c4b824f639dfa3fc44761caeacddc61fd5495e9e62697ccca4a25cca3264dba4c2e84c3c9ba0600fbc9418499865654fbfa601114d2bdd2ed7ccb8a98cfe1b01a3b6432a9d5ac508f118be58be1b1511f7da077dadc35efabbad2e8edc1b715f80aded69412833985e0d043cf454d0d74c5f0cd439fcdb14ffb3dd42155c00c6ab40cb975e4fce7e24d27be4922227d42f66860fcf7b2fcab0970c78a5b8354886cd1e0be2473a230f52ec9e9b0d0eba098a498b1f15f53c02bd8eb8b9f977c76d930e886bc1e8d2f60df02de4fa101c9be366c4cf6f12c1826d9ea8a4a68312124db136e3bfb3fddf46fec16739dd5f791d7a3b215cfcf245edb8173ef65faf7674fd461d0b61d9f72ccfa28092b1f879297f7eca38e91624a525d013025190371798a93e7271ca2687d9d8b9d19b152aadbdb3b1086df9d27bbe9700726be574823625561b65d5a4cf7e865228766bbdde67291eba7a33bebd428d52767a8fb9a96f7f7dc977defed8076a4acbc0d1bf78ef933e4d58b1edde90584b0c7a440db4f8a9309170ed54b2c673137a565d6ee62deace26f1ee568939ff5f921cc1e4a8639178d1231d21954ddf2326cd397e456904655e4c00183cdadd8ac2ac33b1e1113de190bfd61df44383358f1ad95fae88b43031bc9be52ba88d65d60f7ed19a49ba8d39ce4e7bf863ffb45bdd4430b76face2669e7e0cd579286edbc414558c56fdc44d79bc0e1d9dcf3c8a8f849a4ea5e429adea28e3be1408dca1d380ba0e06828bc5f33cd9a5bd62675ea79827b00c11a8d4ce2b095fd158f8a1b58907b016065a78a70910f450634e08bd132f2f6c510eb1bd3dfd3304c59676a8d44f87ef19623f2d4ace042c8d12f63f2dc7ef60d89ac00fb5a193cb4e6c40a2d2fbb1a314e78148fecb96437af58dbe7973c63b375788cb8f7a8af9a77b4c4d2010359b36abdbbadce79ff7353d4662fb8c28231f0c0631cccece50f217170093e2fe7063f2d13ef13bcd2cdbaa4a575bda1ba8b73b990ee52cfe27d325a6927de33b3a42b4059d3bafe60936fcf26eb7cf409dc7bb70b95a82a2ca81ae8afa7120d9f9c4c66ed8ad7ed4b02633f11913f23bdbd75d55287010fd027c7c4ce5c5c1f561236dde2ab0ab9156d8c75174d2ca2f5870977ec2cd9b2aa1eb3bfa7f7c828237cbe6217b8c317f27504aed5dfc6045aad43c8d9d20adebf022643500f7bfce324fee49118787b544db1fb511bf1f47200e6f2df8b779c7d9eb629b77912c3665d2003b3951f4e3bc5425a8183c1094de2b4bf417b3d1db7dd35549db5194ba3c34889ce99a13bcc5860c0fdc5853217e10796bf5af771593c47dfa432d83a9544da80102d74f3f920d134244d74646aac0e8bfd3842719dc8a79f15ff8876eb556191d20f66947db08bd93e7f3ad130a10defbe215b5961d15e0b373d3e99f2cb23e9e9873f1df4484d779daf8cdc6f2e0da7855e1f6c67c19c60844abd2cea13a102287a950712768c2e321782ae8eb7434ff239b4210ac0941789464de35420b2518822792f9490a6955c66ce5b9e6b90438adc255851152350aaa57a1c96391bd08c5d98b679db4c04478fef77648b0c41105c86f31cf5e0554ea3f79fa24e8ba6a6e14ae6c029376f651abc1e6e74341338919f9607a119d493acd94168a4b6be73287a81dd1106f3ce877eb7e4f2426355f2a3cf72b97c54de2de4689f9bce7b90f72a7c27cd215661ee2ff2de308848161f7eca05ff28967e1c5676e33d13fb0c1d05cbee97b0f5a2e9a3146db6401ee85a25ddadcb2f3c98a43cfe47391754e0a75fce59f77b4022c07530d86ac217b3d5c864661d650ed9520bf8b5daa2dd5a37a8f0741229c43c866fd5af070c5f41d668a651182c7ba43fab5246eb1c47747aea958946952d61171f2f9758eaa4319f4a84cb5c020034e818835d06a41dbc9d019d6b9971bff8ccb159e5cdbd1fe43e81b0c06246d163c531f0bf3c5e2369e8c5b2bf21925c3c261a500de90b94fda0c85fa8d781486d3085ad7f3745b2f056a4fd641dfb3270c3f1f03b91deb6ce1125cae8aa4afb42db0cfec6228450839f18812edb4cb0edeff8456de65b604b4fa7f6e880139b1a09d4fd94c41ffd2d07496c7f0f30545677b6da3127699a73fbe84a0e0b1bb7e23cbfb473a07adc74cb81454d7cf337c97eaddedf4d2ffe8de3ad645e77fab66ce3a9383fba252835f1ddda1b9ead2594a80d91977c594c0ac4f1035a407439803b4976821f565bbd0f31126eb6bc370c6f7253908c1b092714e0c984b4afbdff758f38dc4949de1203bb359ff82c3b4b629ae973e1b97ea046596f49282043603",
+				"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",
+				"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" };
+		int height = 4;
+		XMSSParameters params = new XMSSParameters(height, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		for (int i = 0; i < (1 << height); i++) {
+			byte[] signature = xmss.sign(new byte[1024]);
+			assertEquals(signatures[i], Hex.toHexString(signature));
+		}
+		try {
+			xmss.sign(new byte[1024]);
+			fail();
+		} catch (Exception ex) {
+		}
+	}
+
+	public void testSignSHA256CompleteEvenHeight2() {
+		final String[] signatures = {
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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",
+				"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" };
+		int height = 10;
+		XMSSParameters params = new XMSSParameters(height, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		for (int i = 0; i < (1 << height); i++) {
+			byte[] signature = xmss.sign(new byte[1024]);
+			switch (i) {
+			case 0x005b:
+				assertEquals(signatures[0], Hex.toHexString(signature));
+				break;
+			case 0x0822:
+				assertEquals(signatures[1], Hex.toHexString(signature));
+				break;
+			case 0x00b0:
+				assertEquals(signatures[2], Hex.toHexString(signature));
+				break;
+			case 0x016d:
+				assertEquals(signatures[3], Hex.toHexString(signature));
+				break;
+			case 0x0189:
+				assertEquals(signatures[4], Hex.toHexString(signature));
+				break;
+			case 0x01f9:
+				assertEquals(signatures[5], Hex.toHexString(signature));
+				break;
+			case 0x02a1:
+				assertEquals(signatures[6], Hex.toHexString(signature));
+				break;
+			case 0x038b:
+				assertEquals(signatures[7], Hex.toHexString(signature));
+				break;
+			case 0x03fe:
+				assertEquals(signatures[8], Hex.toHexString(signature));
+				break;
+			case 0x03ff:
+				assertEquals(signatures[9], Hex.toHexString(signature));
+				break;
+			}
+		}
+		try {
+			xmss.sign(new byte[1024]);
+			fail();
+		} catch (Exception ex) {
+		}
+	}
+
+	public void testSignSHA512() {
+		XMSSParameters params = new XMSSParameters(10, new SHA512Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] message = new byte[1024];
+		byte[] sig1 = xmss.sign(message);
+		byte[] sig2 = xmss.sign(message);
+		byte[] sig3 = xmss.sign(message);
+		String expectedSig1 = "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";
+		String expectedSig2 = "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";
+		String expectedSig3 = "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";
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig1), sig1));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig2), sig2));
+		assertEquals(true, XMSSUtil.compareByteArray(Hex.decode(expectedSig3), sig3));
+	}
+	
+	public void testVerifySignatureSHA256() {
+		XMSSParameters params = new XMSSParameters(4, new SHA256Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] msg1 = new byte[1024];
+		
+		for (int i = 0; i < 3; i++) {
+			byte[] publicKey = xmss.exportPublicKey();
+			xmss.sign(msg1);
+			byte[] signature = xmss.sign(msg1);
+			try {
+				assertEquals(true, xmss.verifySignature(msg1, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+			byte[] msg2 = new byte[1024];
+			msg2[0] = 0x01;
+			try {
+				assertEquals(false, xmss.verifySignature(msg2, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+		}
+	}
+	
+	public void testVerifySignatureSHA512() {
+		XMSSParameters params = new XMSSParameters(4, new SHA512Digest(), new NullPRNG());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] msg1 = new byte[1024];
+		
+		for (int i = 0; i < 3; i++) {
+			byte[] publicKey = xmss.exportPublicKey();
+			xmss.sign(msg1);
+			byte[] signature = xmss.sign(msg1);
+			try {
+				assertEquals(true, xmss.verifySignature(msg1, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+			byte[] msg2 = new byte[1024];
+			msg2[0] = 0x01;
+			try {
+				assertEquals(false, xmss.verifySignature(msg2, signature, publicKey));
+			} catch (ParseException ex) {
+				ex.printStackTrace();
+				fail();
+			}
+		}
+	}
+	
+	public void testImportStateSHA256() throws IOException, ClassNotFoundException {
+		XMSSParameters params = new XMSSParameters(4, new SHA256Digest(), new NullPRNG());
+		XMSS xmss1 = new XMSS(params);
+		xmss1.generateKeys();
+		byte[] msg1 = new byte[1024];
+		byte[] msg2 = new byte[2048];
+		byte[] msg3 = new byte[3096];
+		Arrays.fill(msg1, (byte) 0xaa);
+		Arrays.fill(msg2, (byte) 0xbb);
+		Arrays.fill(msg3, (byte) 0xcc);
+		byte[] signature1 = xmss1.sign(msg1);
+		byte[] signature2 = xmss1.sign(msg2);
+		byte[] exportedPrivateKey = xmss1.exportPrivateKey();
+		byte[] exportedPublicKey = xmss1.exportPublicKey();
+		byte[] signature3 = xmss1.sign(msg3);
+		
+		XMSS xmss2 = new XMSS(params);
+		try {
+			xmss2.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		byte[] signature4 = xmss2.sign(msg3);
+		assertEquals(true, XMSSUtil.compareByteArray(signature3, signature4));
+		xmss2.generateKeys();
+		try {
+			assertEquals(true, xmss2.verifySignature(msg1, signature1, exportedPublicKey));
+			assertEquals(true, xmss2.verifySignature(msg2, signature2, exportedPublicKey));
+			assertEquals(true, xmss2.verifySignature(msg3, signature3, exportedPublicKey));
+			assertEquals(false, xmss2.verifySignature(msg1, signature3, exportedPublicKey));
+			assertEquals(false, xmss2.verifySignature(msg2, signature3, exportedPublicKey));
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+	}
+	
+	public void testImportKeysSHA512() throws IOException, ClassNotFoundException {
+		XMSSParameters params = new XMSSParameters(4, new SHA512Digest(), new NullPRNG());
+		XMSS xmss1 = new XMSS(params);
+		xmss1.generateKeys();
+		byte[] msg1 = new byte[1024];
+		byte[] msg2 = new byte[2048];
+		byte[] msg3 = new byte[3096];
+		Arrays.fill(msg1, (byte) 0xaa);
+		Arrays.fill(msg2, (byte) 0xbb);
+		Arrays.fill(msg3, (byte) 0xcc);
+		byte[] signature1 = xmss1.sign(msg1);
+		byte[] signature2 = xmss1.sign(msg2);
+		byte[] exportedPrivateKey = xmss1.exportPrivateKey();
+		byte[] exportedPublicKey = xmss1.exportPublicKey();
+		byte[] signature3 = xmss1.sign(msg3);
+		
+		XMSS xmss2 = new XMSS(params);
+		try {
+			xmss2.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+		byte[] signature4 = xmss2.sign(msg3);
+		assertEquals(true, XMSSUtil.compareByteArray(signature3, signature4));
+		xmss2.generateKeys();
+		try {
+			assertEquals(true, xmss2.verifySignature(msg1, signature1, exportedPublicKey));
+			assertEquals(true, xmss2.verifySignature(msg2, signature2, exportedPublicKey));
+			assertEquals(true, xmss2.verifySignature(msg3, signature3, exportedPublicKey));
+			assertEquals(false, xmss2.verifySignature(msg1, signature3, exportedPublicKey));
+			assertEquals(false, xmss2.verifySignature(msg2, signature3, exportedPublicKey));
+		} catch (ParseException ex) {
+			ex.printStackTrace();
+			fail();
+		}
+	}
+	
+	public void testRandom() throws IOException, ClassNotFoundException {
+		XMSSParameters params = new XMSSParameters(4, new SHA512Digest(), new SecureRandom());
+		XMSS xmss1 = new XMSS(params);
+		xmss1.generateKeys();
+		byte[] publicKey = xmss1.exportPublicKey();
+		byte[] message = new byte[1024];
+		
+		for (int i = 0; i < 5; i++) {
+			xmss1.sign(message);
+		}
+		byte[] signature = xmss1.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(publicKey, xmss1.exportPublicKey()));
+		try {
+			xmss1.verifySignature(message, signature, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		assertTrue(XMSSUtil.compareByteArray(publicKey, xmss1.exportPublicKey()));
+		xmss1.sign(message);
+		byte[] privateKey7 = xmss1.exportPrivateKey();
+		try {
+			xmss1.verifySignature(message, signature, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		assertTrue(XMSSUtil.compareByteArray(privateKey7, xmss1.exportPrivateKey()));
+		byte[] signature7 = xmss1.sign(message);
+
+		try {
+			xmss1.importState(privateKey7, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		byte[] signature7AfterImport = xmss1.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(signature7AfterImport, signature7));
+		
+		XMSSParameters params2 = new XMSSParameters(4, new SHA512Digest(), new SecureRandom());
+		XMSS xmss2 = new XMSS(params2);
+		try {
+			boolean valid = xmss2.verifySignature(message, signature7, publicKey);
+			assertTrue(valid);
+			valid = xmss2.verifySignature(message, signature, publicKey);
+			assertTrue(valid);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		
+		XMSS xmss3 = new XMSS(params);
+		try {
+			xmss3.importState(privateKey7, publicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+			fail();
+		}
+		byte[] signatureAgain = xmss3.sign(message);
+		assertTrue(XMSSUtil.compareByteArray(signatureAgain, signature7));
+	}
+	
+	public void testBDSImport() throws IOException, ClassNotFoundException {
+		XMSSParameters params = new XMSSParameters(4, new SHA256Digest(), new SecureRandom());
+		XMSS xmss = new XMSS(params);
+		xmss.generateKeys();
+		byte[] exportedPrivateKey = xmss.exportPrivateKey();
+		byte[] exportedPublicKey = xmss.exportPublicKey();
+		try {
+			xmss.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		byte[] sig1 = xmss.sign(new byte[1024]);
+		try {
+			xmss.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		byte[] sig2 = xmss.sign(new byte[1024]);
+		assertEquals(true, XMSSUtil.compareByteArray(sig1, sig2));
+		try {
+			xmss.importState(exportedPrivateKey, exportedPublicKey);
+		} catch (Exception ex) { }
+		xmss.sign(new byte[1024]);
+		byte[] sig3 = xmss.sign(new byte[1024]);
+		assertEquals(false, XMSSUtil.compareByteArray(sig1, sig3));
+		try {
+			xmss.importState(null, exportedPublicKey);
+			fail();
+		} catch (Exception ex) { }
+		try {
+			xmss.importState(exportedPrivateKey, null);
+			fail();
+		} catch (Exception ex) { }
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSUtilTest.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSUtilTest.java
new file mode 100644
index 0000000..9e02432
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/test/XMSSUtilTest.java
@@ -0,0 +1,250 @@
+package org.bouncycastle.pqc.crypto.test;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+import org.bouncycastle.util.Pack;
+
+/**
+ * Test cases for XMSSUtil class.
+ * 
+ */
+public class XMSSUtilTest
+    extends TestCase
+{
+
+    public void testLog2()
+    {
+        assertEquals(3, XMSSUtil.log2(8));
+        assertEquals(3, XMSSUtil.log2(10));
+        assertEquals(26, XMSSUtil.log2(100010124));
+    }
+
+    public void testIntToBytesBigEndian()
+    {
+        byte[] b = XMSSUtil.toBytesBigEndian(1, 4);
+        assertEquals(4, b.length);
+        assertEquals((byte)0x00, b[0]);
+        assertEquals((byte)0x00, b[1]);
+        assertEquals((byte)0x00, b[2]);
+        assertEquals((byte)0x01, b[3]);
+        b = XMSSUtil.toBytesBigEndian(1, 6);
+        assertEquals(6, b.length);
+        assertEquals((byte)0x00, b[0]);
+        assertEquals((byte)0x00, b[1]);
+        assertEquals((byte)0x00, b[2]);
+        assertEquals((byte)0x00, b[3]);
+        assertEquals((byte)0x00, b[4]);
+        assertEquals((byte)0x01, b[5]);
+        b = XMSSUtil.toBytesBigEndian(1, 32);
+        assertEquals(32, b.length);
+        for (int i = 0; i < 31; i++)
+        {
+            assertEquals((byte)0x00, b[i]);
+        }
+        b = XMSSUtil.toBytesBigEndian(12345, 5);
+        assertEquals(5, b.length);
+        assertEquals((byte)0x00, b[0]);
+        assertEquals((byte)0x00, b[1]);
+        assertEquals((byte)0x00, b[2]);
+        assertEquals((byte)0x30, b[3]);
+        assertEquals((byte)0x39, b[4]);
+    }
+
+    public void testLongToBytesBigEndian()
+    {
+        byte[] b = XMSSUtil.toBytesBigEndian(1, 8);
+        assertEquals(8, b.length);
+        assertEquals((byte)0x00, b[0]);
+        assertEquals((byte)0x00, b[1]);
+        assertEquals((byte)0x00, b[2]);
+        assertEquals((byte)0x00, b[3]);
+        assertEquals((byte)0x00, b[4]);
+        assertEquals((byte)0x00, b[5]);
+        assertEquals((byte)0x00, b[6]);
+        assertEquals((byte)0x01, b[7]);
+        b = XMSSUtil.toBytesBigEndian(1, 10);
+        assertEquals(10, b.length);
+        assertEquals((byte)0x00, b[0]);
+        assertEquals((byte)0x00, b[1]);
+        assertEquals((byte)0x00, b[2]);
+        assertEquals((byte)0x00, b[3]);
+        assertEquals((byte)0x00, b[4]);
+        assertEquals((byte)0x00, b[5]);
+        assertEquals((byte)0x00, b[6]);
+        assertEquals((byte)0x00, b[7]);
+        assertEquals((byte)0x00, b[8]);
+        assertEquals((byte)0x01, b[9]);
+        b = XMSSUtil.toBytesBigEndian(1, 32);
+        for (int i = 0; i < 31; i++)
+        {
+            assertEquals((byte)0x00, b[i]);
+        }
+        assertEquals((byte)0x01, b[31]);
+        b = XMSSUtil.toBytesBigEndian(12345, 9);
+        assertEquals(9, b.length);
+        assertEquals((byte)0x00, b[0]);
+        assertEquals((byte)0x00, b[1]);
+        assertEquals((byte)0x00, b[2]);
+        assertEquals((byte)0x00, b[3]);
+        assertEquals((byte)0x00, b[4]);
+        assertEquals((byte)0x00, b[5]);
+        assertEquals((byte)0x00, b[6]);
+        assertEquals((byte)0x30, b[7]);
+        assertEquals((byte)0x39, b[8]);
+    }
+
+    public void testIntToBytesBigEndianOffsetException()
+    {
+        byte[] in = new byte[4];
+        try
+        {
+            XMSSUtil.intToBytesBigEndianOffset(in, 1, 1);
+            fail();
+        }
+        catch (Exception ex)
+        {
+        }
+    }
+
+    public void testIntToBytesBigEndianOffset()
+    {
+        byte[] in = new byte[32];
+        XMSSUtil.intToBytesBigEndianOffset(in, 12345, 5);
+        assertEquals((byte)0x00, in[0]);
+        assertEquals((byte)0x00, in[1]);
+        assertEquals((byte)0x00, in[2]);
+        assertEquals((byte)0x00, in[3]);
+        assertEquals((byte)0x00, in[4]);
+        assertEquals((byte)0x00, in[5]);
+        assertEquals((byte)0x00, in[6]);
+        assertEquals((byte)0x30, in[7]);
+        assertEquals((byte)0x39, in[8]);
+        for (int i = 9; i < in.length; i++)
+        {
+            assertEquals((byte)0x00, in[i]);
+        }
+        in = new byte[32];
+        XMSSUtil.intToBytesBigEndianOffset(in, 12345, 28);
+        for (int i = 0; i < 28; i++)
+        {
+            assertEquals((byte)0x00, in[i]);
+        }
+        assertEquals((byte)0x00, in[28]);
+        assertEquals((byte)0x00, in[29]);
+        assertEquals((byte)0x30, in[30]);
+        assertEquals((byte)0x39, in[31]);
+    }
+
+    public void testLongToBytesBigEndianOffsetException()
+    {
+        try
+        {
+            byte[] in = new byte[8];
+            XMSSUtil.longToBytesBigEndianOffset(in, 1, 1);
+            fail();
+        }
+        catch (Exception ex)
+        {
+        }
+    }
+
+    public void testLongToBytesBigEndianOffset()
+    {
+        byte[] in = new byte[32];
+        XMSSUtil.longToBytesBigEndianOffset(in, 12345, 5);
+        assertEquals((byte)0x00, in[0]);
+        assertEquals((byte)0x00, in[1]);
+        assertEquals((byte)0x00, in[2]);
+        assertEquals((byte)0x00, in[3]);
+        assertEquals((byte)0x00, in[4]);
+        assertEquals((byte)0x00, in[5]);
+        assertEquals((byte)0x00, in[6]);
+        assertEquals((byte)0x00, in[7]);
+        assertEquals((byte)0x00, in[8]);
+        assertEquals((byte)0x00, in[9]);
+        assertEquals((byte)0x00, in[10]);
+        assertEquals((byte)0x30, in[11]);
+        assertEquals((byte)0x39, in[12]);
+        for (int i = 14; i < in.length; i++)
+        {
+            assertEquals((byte)0x00, in[i]);
+        }
+        in = new byte[32];
+        XMSSUtil.longToBytesBigEndianOffset(in, 12345, 24);
+        for (int i = 0; i < 24; i++)
+        {
+            assertEquals((byte)0x00, in[i]);
+        }
+        assertEquals((byte)0x00, in[28]);
+        assertEquals((byte)0x00, in[29]);
+        assertEquals((byte)0x30, in[30]);
+        assertEquals((byte)0x39, in[31]);
+    }
+
+    public void testBytesToIntBigEndianException()
+    {
+        byte[] in = new byte[4];
+        try
+        {
+            Pack.bigEndianToInt(in, 1);
+            fail();
+        }
+        catch (Exception ex)
+        {
+        }
+    }
+
+    public void testBytesToIntBigEndian()
+    {
+        byte[] in1 = {0x00, (byte)0xff, 0x00, (byte)0xff};
+        int out = Pack.bigEndianToInt(in1, 0);
+        assertEquals(16711935, out);
+        byte[] in2 = {(byte)0xab, (byte)0xcd, (byte)0xef, (byte)0xaa};
+        out = Pack.bigEndianToInt(in2, 0);
+        assertEquals("2882400170", new BigInteger(1, in2).toString());
+        byte[] in3 = new byte[100];
+        Arrays.fill(in3, (byte)0xaa);
+        for (int i = 35; i < 39; i++)
+        {
+            in3[i] = (byte)0xff;
+        }
+        out = Pack.bigEndianToInt(in3, 35);
+        assertEquals(new BigInteger("4294967295"), BigInteger.valueOf(out & 0xffffffffL));
+    }
+
+    public void testBytesToLongBigEndianException()
+    {
+        byte[] in = new byte[10];
+        try
+        {
+            Pack.bigEndianToLong(in, 3);
+            fail();
+        }
+        catch (Exception ex)
+        {
+        }
+    }
+
+    public void testBytesToLongBigEndian()
+    {
+        byte[] in1 = {0x00, (byte)0xff, 0x00, (byte)0xff, 0x00, (byte)0xff, 0x00, (byte)0xff};
+        long out = Pack.bigEndianToLong(in1, 0);
+        assertEquals(71777214294589695L, out);
+        byte[] in2 = {(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff};
+        out = Pack.bigEndianToLong(in2, 0);
+        assertEquals("18446744073709551615", new BigInteger(1, in2).toString());
+    }
+
+    public void testCalculateTau()
+    {
+        int height = 10;
+        for (int index = 0; index < (1 << 10); index += 2)
+        {
+            assertEquals(0, XMSSUtil.calculateTau(index, height));
+        }
+        assertEquals(9, XMSSUtil.calculateTau(511, height));
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/BDS.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/BDS.java
new file mode 100644
index 0000000..7ca02d5
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/BDS.java
@@ -0,0 +1,417 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+import java.util.TreeMap;
+
+/**
+ * BDS.
+ *
+ */
+public final class BDS implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	private final class TreeHash implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		private XMSSNode tailNode;
+		private final int initialHeight;
+		private int height;
+		private int nextIndex;
+		private boolean initialized;
+		private boolean finished;
+
+		private TreeHash(int initialHeight) {
+			super();
+			this.initialHeight = initialHeight;
+			initialized = false;
+			finished = false;
+		}
+
+		private void initialize(int nextIndex) {
+			tailNode = null;
+			height = initialHeight;
+			this.nextIndex = nextIndex;
+			initialized = true;
+			finished = false;
+		}
+
+		private void update(OTSHashAddress otsHashAddress) {
+			if (otsHashAddress == null) {
+				throw new NullPointerException("otsHashAddress == null");
+			}
+			if (finished || !initialized) {
+				throw new IllegalStateException("finished or not initialized");
+			}
+			/* prepare addresses */
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withOTSAddress(nextIndex).withChainAddress(otsHashAddress.getChainAddress())
+					.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(otsHashAddress.getKeyAndMask())
+					.build();
+			LTreeAddress lTreeAddress = (LTreeAddress) new LTreeAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withLTreeAddress(nextIndex).build();
+			HashTreeAddress hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withTreeIndex(nextIndex).build();
+
+			/* calculate leaf node */
+			wotsPlus.importKeys(xmss.getWOTSPlusSecretKey(otsHashAddress), xmss.getPublicSeed());
+			WOTSPlusPublicKeyParameters wotsPlusPublicKey = wotsPlus.getPublicKey(otsHashAddress);
+			XMSSNode node = xmss.lTree(wotsPlusPublicKey, lTreeAddress);
+
+			while (!stack.isEmpty() && stack.peek().getHeight() == node.getHeight()
+					&& stack.peek().getHeight() != initialHeight) {
+				hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+						.withLayerAddress(hashTreeAddress.getLayerAddress())
+						.withTreeAddress(hashTreeAddress.getTreeAddress())
+						.withTreeHeight(hashTreeAddress.getTreeHeight())
+						.withTreeIndex((hashTreeAddress.getTreeIndex() - 1) / 2)
+						.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+				node = xmss.randomizeHash(stack.pop(), node, hashTreeAddress);
+				node = new XMSSNode(node.getHeight() + 1, node.getValue());
+				hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+						.withLayerAddress(hashTreeAddress.getLayerAddress())
+						.withTreeAddress(hashTreeAddress.getTreeAddress())
+						.withTreeHeight(hashTreeAddress.getTreeHeight() + 1)
+						.withTreeIndex(hashTreeAddress.getTreeIndex()).withKeyAndMask(hashTreeAddress.getKeyAndMask())
+						.build();
+			}
+
+			if (tailNode == null) {
+				tailNode = node;
+			} else {
+				if (tailNode.getHeight() == node.getHeight()) {
+					hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+							.withLayerAddress(hashTreeAddress.getLayerAddress())
+							.withTreeAddress(hashTreeAddress.getTreeAddress())
+							.withTreeHeight(hashTreeAddress.getTreeHeight())
+							.withTreeIndex((hashTreeAddress.getTreeIndex() - 1) / 2)
+							.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+					node = xmss.randomizeHash(tailNode, node, hashTreeAddress);
+					node = new XMSSNode(tailNode.getHeight() + 1, node.getValue());
+					tailNode = node;
+					hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+							.withLayerAddress(hashTreeAddress.getLayerAddress())
+							.withTreeAddress(hashTreeAddress.getTreeAddress())
+							.withTreeHeight(hashTreeAddress.getTreeHeight() + 1)
+							.withTreeIndex(hashTreeAddress.getTreeIndex())
+							.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+				} else {
+					stack.push(node);
+				}
+			}
+
+			if (tailNode.getHeight() == initialHeight) {
+				finished = true;
+			} else {
+				height = node.getHeight();
+				nextIndex++;
+			}
+		}
+
+		private int getHeight() {
+			if (!initialized || finished) {
+				return Integer.MAX_VALUE;
+			}
+			return height;
+		}
+
+		private int getIndexLeaf() {
+			return nextIndex;
+		}
+
+		private void setNode(XMSSNode node) {
+			tailNode = node;
+			height = node.getHeight();
+			if (height == initialHeight) {
+				finished = true;
+			}
+		}
+
+		private boolean isFinished() {
+			return finished;
+		}
+
+		private boolean isInitialized() {
+			return initialized;
+		}
+	}
+
+	private transient XMSS xmss;
+	private transient WOTSPlus wotsPlus;
+	private final int treeHeight;
+	private int k;
+	private XMSSNode root;
+	private List<XMSSNode> authenticationPath;
+	private Map<Integer, LinkedList<XMSSNode>> retain;
+	private Stack<XMSSNode> stack;
+	private List<TreeHash> treeHashInstances;
+	private Map<Integer, XMSSNode> keep;
+	private int index;
+
+	protected BDS(XMSS xmss) {
+		super();
+		if (xmss == null) {
+			throw new NullPointerException("xmss == null");
+		}
+		this.xmss = xmss;
+		wotsPlus = xmss.getWOTSPlus();
+		treeHeight = xmss.getParams().getHeight();
+		k = xmss.getParams().getK();
+		if (k > treeHeight || k < 2 || ((treeHeight - k) % 2) != 0) {
+			throw new IllegalArgumentException("illegal value for BDS parameter k");
+		}
+		authenticationPath = new ArrayList<XMSSNode>();
+		retain = new TreeMap<Integer, LinkedList<XMSSNode>>();
+		stack = new Stack<XMSSNode>();
+		initializeTreeHashInstances();
+		keep = new TreeMap<Integer, XMSSNode>();
+		index = 0;
+	}
+
+	private void initializeTreeHashInstances() {
+		treeHashInstances = new ArrayList<TreeHash>();
+		for (int height = 0; height < (treeHeight - k); height++) {
+			treeHashInstances.add(new TreeHash(height));
+		}
+	}
+
+	protected XMSSNode initialize(OTSHashAddress otsHashAddress) {
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		/* prepare addresses */
+		LTreeAddress lTreeAddress = (LTreeAddress) new LTreeAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.build();
+		HashTreeAddress hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.build();
+
+		/* iterate indexes */
+		for (int indexLeaf = 0; indexLeaf < (1 << treeHeight); indexLeaf++) {
+			/* generate leaf */
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withOTSAddress(indexLeaf).withChainAddress(otsHashAddress.getChainAddress())
+					.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(otsHashAddress.getKeyAndMask())
+					.build();
+			/*
+			 * import WOTSPlusSecretKey as its needed to calculate the public
+			 * key on the fly
+			 */
+			wotsPlus.importKeys(xmss.getWOTSPlusSecretKey(otsHashAddress), xmss.getPublicSeed());
+			WOTSPlusPublicKeyParameters wotsPlusPublicKey = wotsPlus.getPublicKey(otsHashAddress);
+			lTreeAddress = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(lTreeAddress.getLayerAddress())
+					.withTreeAddress(lTreeAddress.getTreeAddress()).withLTreeAddress(indexLeaf)
+					.withTreeHeight(lTreeAddress.getTreeHeight()).withTreeIndex(lTreeAddress.getTreeIndex())
+					.withKeyAndMask(lTreeAddress.getKeyAndMask()).build();
+			XMSSNode node = xmss.lTree(wotsPlusPublicKey, lTreeAddress);
+
+			hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+					.withLayerAddress(hashTreeAddress.getLayerAddress())
+					.withTreeAddress(hashTreeAddress.getTreeAddress()).withTreeIndex(indexLeaf)
+					.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+			while (!stack.isEmpty() && stack.peek().getHeight() == node.getHeight()) {
+				/* add to authenticationPath if leafIndex == 1 */
+				int indexOnHeight = ((int) Math.floor(indexLeaf / (1 << node.getHeight())));
+				if (indexOnHeight == 1) {
+					authenticationPath.add(node.clone());
+				}
+				/* store next right authentication node */
+				if (indexOnHeight == 3 && node.getHeight() < (treeHeight - k)) {
+					treeHashInstances.get(node.getHeight()).setNode(node.clone());
+				}
+				if (indexOnHeight >= 3 && (indexOnHeight & 1) == 1 && node.getHeight() >= (treeHeight - k)
+						&& node.getHeight() <= (treeHeight - 2)) {
+					if (retain.get(node.getHeight()) == null) {
+						LinkedList<XMSSNode> queue = new LinkedList<XMSSNode>();
+						queue.add(node.clone());
+						retain.put(node.getHeight(), queue);
+					} else {
+						retain.get(node.getHeight()).add(node.clone());
+					}
+				}
+				hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+						.withLayerAddress(hashTreeAddress.getLayerAddress())
+						.withTreeAddress(hashTreeAddress.getTreeAddress())
+						.withTreeHeight(hashTreeAddress.getTreeHeight())
+						.withTreeIndex((hashTreeAddress.getTreeIndex() - 1) / 2)
+						.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+				node = xmss.randomizeHash(stack.pop(), node, hashTreeAddress);
+				node = new XMSSNode(node.getHeight() + 1, node.getValue());
+				hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+						.withLayerAddress(hashTreeAddress.getLayerAddress())
+						.withTreeAddress(hashTreeAddress.getTreeAddress())
+						.withTreeHeight(hashTreeAddress.getTreeHeight() + 1)
+						.withTreeIndex(hashTreeAddress.getTreeIndex()).withKeyAndMask(hashTreeAddress.getKeyAndMask())
+						.build();
+			}
+			/* push to stack */
+			stack.push(node);
+		}
+		root = stack.pop();
+		return root.clone();
+	}
+
+	protected void nextAuthenticationPath(OTSHashAddress otsHashAddress) {
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		if (index > ((1 << treeHeight) - 2)) {
+			throw new IllegalStateException("index out of bounds");
+		}
+		/* prepare addresses */
+		LTreeAddress lTreeAddress = (LTreeAddress) new LTreeAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.build();
+		HashTreeAddress hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.build();
+
+		/* determine tau */
+		int tau = XMSSUtil.calculateTau(index, treeHeight);
+
+		/* parent of leaf on height tau+1 is a left node */
+		if (((index >> (tau + 1)) & 1) == 0 && (tau < (treeHeight - 1))) {
+			keep.put(tau, authenticationPath.get(tau).clone());
+		}
+		/* leaf is a left node */
+		if (tau == 0) {
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withOTSAddress(index).withChainAddress(otsHashAddress.getChainAddress())
+					.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(otsHashAddress.getKeyAndMask())
+					.build();
+			/*
+			 * import WOTSPlusSecretKey as its needed to calculate the public
+			 * key on the fly
+			 */
+			wotsPlus.importKeys(xmss.getWOTSPlusSecretKey(otsHashAddress), xmss.getPublicSeed());
+			WOTSPlusPublicKeyParameters wotsPlusPublicKey = wotsPlus.getPublicKey(otsHashAddress);
+			lTreeAddress = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(lTreeAddress.getLayerAddress())
+					.withTreeAddress(lTreeAddress.getTreeAddress()).withLTreeAddress(index)
+					.withTreeHeight(lTreeAddress.getTreeHeight()).withTreeIndex(lTreeAddress.getTreeIndex())
+					.withKeyAndMask(lTreeAddress.getKeyAndMask()).build();
+			XMSSNode node = xmss.lTree(wotsPlusPublicKey, lTreeAddress);
+			authenticationPath.set(0, node);
+		} else {
+			/* add new left node on height tau to authentication path */
+			hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+					.withLayerAddress(hashTreeAddress.getLayerAddress())
+					.withTreeAddress(hashTreeAddress.getTreeAddress()).withTreeHeight(tau - 1)
+					.withTreeIndex(index >> tau).withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+			XMSSNode node = xmss.randomizeHash(authenticationPath.get(tau - 1), keep.get(tau - 1), hashTreeAddress);
+			node = new XMSSNode(node.getHeight() + 1, node.getValue());
+			authenticationPath.set(tau, node);
+			keep.remove(tau - 1);
+
+			/* add new right nodes to authentication path */
+			for (int height = 0; height < tau; height++) {
+				if (height < (treeHeight - k)) {
+					authenticationPath.set(height, treeHashInstances.get(height).tailNode.clone());
+				} else {
+					authenticationPath.set(height, retain.get(height).removeFirst());
+				}
+			}
+
+			/* reinitialize treehash instances */
+			int minHeight = Math.min(tau, treeHeight - k);
+			for (int height = 0; height < minHeight; height++) {
+				int startIndex = index + 1 + (3 * (1 << height));
+				if (startIndex < (1 << treeHeight)) {
+					treeHashInstances.get(height).initialize(startIndex);
+				}
+			}
+		}
+
+		/* update treehash instances */
+		for (int i = 0; i < (treeHeight - k) >> 1; i++) {
+			TreeHash treeHash = getTreeHashInstanceForUpdate();
+			if (treeHash != null) {
+				treeHash.update(otsHashAddress);
+			}
+		}
+		index++;
+	}
+
+	private TreeHash getTreeHashInstanceForUpdate() {
+		TreeHash ret = null;
+		for (TreeHash treeHash : treeHashInstances) {
+			if (treeHash.isFinished() || !treeHash.isInitialized()) {
+				continue;
+			}
+			if (ret == null) {
+				ret = treeHash;
+				continue;
+			}
+			if (treeHash.getHeight() < ret.getHeight()) {
+				ret = treeHash;
+				continue;
+			}
+			if (treeHash.getHeight() == ret.getHeight()) {
+				if (treeHash.getIndexLeaf() < ret.getIndexLeaf()) {
+					ret = treeHash;
+				}
+			}
+		}
+		return ret;
+	}
+
+	protected void validate() {
+		if (treeHeight != xmss.getParams().getHeight()) {
+			throw new IllegalStateException("wrong height");
+		}
+		if (authenticationPath == null) {
+			throw new IllegalStateException("authenticationPath == null");
+		}
+		if (retain == null) {
+			throw new IllegalStateException("retain == null");
+		}
+		if (stack == null) {
+			throw new IllegalStateException("stack == null");
+		}
+		if (treeHashInstances == null) {
+			throw new IllegalStateException("treeHashInstances == null");
+		}
+		if (keep == null) {
+			throw new IllegalStateException("keep == null");
+		}
+		if (!XMSSUtil.isIndexValid(treeHeight, index)) {
+			throw new IllegalStateException("index in BDS state out of bounds");
+		}
+	}
+
+	protected int getTreeHeight() {
+		return treeHeight;
+	}
+
+	protected XMSSNode getRoot() {
+		return root.clone();
+	}
+
+	protected List<XMSSNode> getAuthenticationPath() {
+		List<XMSSNode> authenticationPath = new ArrayList<XMSSNode>();
+		for (XMSSNode node : this.authenticationPath) {
+			authenticationPath.add(node.clone());
+		}
+		return authenticationPath;
+	}
+
+	protected void setXMSS(XMSS xmss) {
+		this.xmss = xmss;
+		this.wotsPlus = xmss.getWOTSPlus();
+	}
+
+	protected int getIndex() {
+		return index;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/DefaultXMSSMTOid.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/DefaultXMSSMTOid.java
new file mode 100644
index 0000000..900b423
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/DefaultXMSSMTOid.java
@@ -0,0 +1,160 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * XMSSOid^MT class.
+ *
+ */
+public final class DefaultXMSSMTOid implements XMSSOid {
+
+	/**
+	 * XMSS^MT OID lookup table.
+	 */
+	private static final Map<String, DefaultXMSSMTOid> oidLookupTable;
+
+	static {
+		Map<String, DefaultXMSSMTOid> map = new HashMap<String, DefaultXMSSMTOid>();
+		map.put(createKey("SHA-256", 32, 16, 67, 20, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H20_D2"));
+		map.put(createKey("SHA-256", 32, 16, 67, 20, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H20_D4"));
+		map.put(createKey("SHA-256", 32, 16, 67, 40, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H40_D2"));
+		map.put(createKey("SHA-256", 32, 16, 67, 40, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H40_D4"));
+		map.put(createKey("SHA-256", 32, 16, 67, 40, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H40_D8"));
+		map.put(createKey("SHA-256", 32, 16, 67, 60, 8),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H60_D3"));
+		map.put(createKey("SHA-256", 32, 16, 67, 60, 6),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H60_D6"));
+		map.put(createKey("SHA-256", 32, 16, 67, 60, 12),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-256_W16_H60_D12"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 20, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H20_D2"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 20, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H20_D4"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 40, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H40_D2"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 40, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H40_D4"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 40, 8),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H40_D8"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 60, 3),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H60_D3"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 60, 6),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H60_D6"));
+		map.put(createKey("SHA2-512", 64, 16, 131, 60, 12),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHA2-512_W16_H60_D12"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 20, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H20_D2"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 20, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H20_D4"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 40, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H40_D2"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 40, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H40_D4"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 40, 8),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H40_D8"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 60, 3),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H60_D3"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 60, 6),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H60_D6"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 60, 12),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE128_W16_H60_D12"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 20, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H20_D2"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 20, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H20_D4"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 40, 2),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H40_D2"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 40, 4),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H40_D4"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 40, 8),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H40_D8"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 60, 3),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H60_D3"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 60, 6),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H60_D6"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 60, 12),
+				new DefaultXMSSMTOid(0x01000001, "XMSSMT_SHAKE256_W16_H60_D12"));
+		oidLookupTable = Collections.unmodifiableMap(map);
+	}
+
+	/**
+	 * OID.
+	 */
+	private final int oid;
+	/**
+	 * String representation of OID.
+	 */
+	private final String stringRepresentation;
+
+	/**
+	 * Constructor...
+	 *
+	 * @param oid
+	 *            OID.
+	 * @param stringRepresentation
+	 *            String representation of OID.
+	 */
+	private DefaultXMSSMTOid(int oid, String stringRepresentation) {
+		super();
+		this.oid = oid;
+		this.stringRepresentation = stringRepresentation;
+	}
+
+	/**
+	 * Lookup OID.
+	 *
+	 * @param algorithmName
+	 *            Algorithm name.
+	 * @param winternitzParameter
+	 *            Winternitz parameter.
+	 * @param height
+	 *            Binary tree height.
+	 * @return XMSS OID if parameters were found, null else.
+	 */
+	public static DefaultXMSSMTOid lookup(String algorithmName, int digestSize, int winternitzParameter, int len,
+			int height, int layers) {
+		if (algorithmName == null) {
+			throw new NullPointerException("algorithmName == null");
+		}
+		return oidLookupTable.get(createKey(algorithmName, digestSize, winternitzParameter, len, height, layers));
+	}
+
+	/**
+	 * Create a key based on parameters.
+	 *
+	 * @param algorithmName
+	 *            Algorithm name.
+	 * @param winternitzParameter
+	 *            Winternitz Parameter.
+	 * @param height
+	 *            Binary tree height.
+	 * @return String representation of parameters for lookup table.
+	 */
+	private static String createKey(String algorithmName, int digestSize, int winternitzParameter, int len, int height,
+			int layers) {
+		if (algorithmName == null) {
+			throw new NullPointerException("algorithmName == null");
+		}
+		return algorithmName + "-" + digestSize + "-" + winternitzParameter + "-" + len + "-" + height + "-" + layers;
+	}
+
+	/**
+	 * Getter OID.
+	 *
+	 * @return OID.
+	 */
+	public int getOid() {
+		return oid;
+	}
+
+	public String toString() {
+		return stringRepresentation;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/DefaultXMSSOid.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/DefaultXMSSOid.java
new file mode 100644
index 0000000..908083a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/DefaultXMSSOid.java
@@ -0,0 +1,109 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * XMSSOid class.
+ *
+ */
+public final class DefaultXMSSOid implements XMSSOid {
+
+	/**
+	 * XMSS OID lookup table.
+	 */
+	private static final Map<String, DefaultXMSSOid> oidLookupTable;
+
+	static {
+		Map<String, DefaultXMSSOid> map = new HashMap<String, DefaultXMSSOid>();
+		map.put(createKey("SHA-256", 32, 16, 67, 10), new DefaultXMSSOid(0x01000001, "XMSS_SHA2-256_W16_H10"));
+		map.put(createKey("SHA-256", 32, 16, 67, 16), new DefaultXMSSOid(0x02000002, "XMSS_SHA2-256_W16_H16"));
+		map.put(createKey("SHA-256", 32, 16, 67, 20), new DefaultXMSSOid(0x03000003, "XMSS_SHA2-256_W16_H20"));
+		map.put(createKey("SHA-512", 64, 16, 131, 10), new DefaultXMSSOid(0x04000004, "XMSS_SHA2-512_W16_H10"));
+		map.put(createKey("SHA-512", 64, 16, 131, 16), new DefaultXMSSOid(0x05000005, "XMSS_SHA2-512_W16_H16"));
+		map.put(createKey("SHA-512", 64, 16, 131, 20), new DefaultXMSSOid(0x06000006, "XMSS_SHA2-512_W16_H20"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 10), new DefaultXMSSOid(0x07000007, "XMSS_SHAKE128_W16_H10"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 16), new DefaultXMSSOid(0x08000008, "XMSS_SHAKE128_W16_H16"));
+		map.put(createKey("SHAKE128", 32, 16, 67, 20), new DefaultXMSSOid(0x09000009, "XMSS_SHAKE128_W16_H20"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 10), new DefaultXMSSOid(0x0a00000a, "XMSS_SHAKE256_W16_H10"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 16), new DefaultXMSSOid(0x0b00000b, "XMSS_SHAKE256_W16_H16"));
+		map.put(createKey("SHAKE256", 64, 16, 131, 20), new DefaultXMSSOid(0x0c00000c, "XMSS_SHAKE256_W16_H20"));
+		oidLookupTable = Collections.unmodifiableMap(map);
+	}
+
+	/**
+	 * OID.
+	 */
+	private final int oid;
+	/**
+	 * String representation of OID.
+	 */
+	private final String stringRepresentation;
+
+	/**
+	 * Constructor...
+	 *
+	 * @param oid
+	 *            OID.
+	 * @param stringRepresentation
+	 *            String representation of OID.
+	 */
+	private DefaultXMSSOid(int oid, String stringRepresentation) {
+		super();
+		this.oid = oid;
+		this.stringRepresentation = stringRepresentation;
+	}
+
+	/**
+	 * Lookup OID.
+	 *
+	 * @param algorithmName
+	 *            Algorithm name.
+	 * @param winternitzParameter
+	 *            Winternitz parameter.
+	 * @param height
+	 *            Binary tree height.
+	 * @return XMSS OID if parameters were found, null else.
+	 */
+	public static DefaultXMSSOid lookup(String algorithmName, int digestSize, int winternitzParameter, int len,
+			int height) {
+		if (algorithmName == null) {
+			throw new NullPointerException("algorithmName == null");
+		}
+		return oidLookupTable.get(createKey(algorithmName, digestSize, winternitzParameter, len, height));
+	}
+
+	/**
+	 * Create a key based on parameters.
+	 *
+	 * @param algorithmName
+	 *            Algorithm name.
+	 * @param winternitzParameter
+	 *            Winternitz Parameter.
+	 * @param height
+	 *            Binary tree height.
+	 * @return String representation of parameters for lookup table.
+	 */
+	private static String createKey(String algorithmName, int digestSize, int winternitzParameter, int len,
+			int height) {
+		if (algorithmName == null) {
+			throw new NullPointerException("algorithmName == null");
+		}
+		return algorithmName + "-" + digestSize + "-" + winternitzParameter + "-" + len + "-" + height;
+	}
+
+	/**
+	 * Getter OID.
+	 *
+	 * @return OID.
+	 */
+	public int getOid() {
+		return oid;
+	}
+
+	@Override
+	public String toString() {
+		return stringRepresentation;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/HashTreeAddress.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/HashTreeAddress.java
new file mode 100644
index 0000000..d456cbc
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/HashTreeAddress.java
@@ -0,0 +1,76 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * Hash tree address.
+ *
+ */
+public final class HashTreeAddress extends XMSSAddress {
+
+	private static final int TYPE = 0x02;
+	private static final int PADDING = 0x00;
+
+	private final int padding;
+	private final int treeHeight;
+	private final int treeIndex;
+
+	private HashTreeAddress(Builder builder) {
+		super(builder);
+		padding = PADDING;
+		treeHeight = builder.treeHeight;
+		treeIndex = builder.treeIndex;
+	}
+	
+	protected static class Builder extends XMSSAddress.Builder<Builder> {
+
+		/* optional */
+		private int treeHeight = 0;
+		private int treeIndex = 0;
+
+		protected Builder() {
+			super(TYPE);
+		}
+		
+		protected Builder withTreeHeight(int val) {
+			treeHeight = val;
+			return this;
+		}
+		
+		protected Builder withTreeIndex(int val) {
+			treeIndex = val;
+			return this;
+		}
+		
+		@Override
+		protected XMSSAddress build() {
+			return new HashTreeAddress(this);
+		}
+
+		@Override
+		protected Builder getThis() {
+			return this;
+		}
+	}
+
+	@Override
+	protected byte[] toByteArray() {
+		byte[] byteRepresentation = super.toByteArray();
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, padding, 16);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, treeHeight, 20);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, treeIndex, 24);
+		return byteRepresentation;
+	}
+
+	protected int getPadding() {
+		return padding;
+	}
+
+	protected int getTreeHeight() {
+		return treeHeight;
+	}
+
+	protected int getTreeIndex() {
+		return treeIndex;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/KeyedHashFunctions.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/KeyedHashFunctions.java
new file mode 100644
index 0000000..10382c8
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/KeyedHashFunctions.java
@@ -0,0 +1,85 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.crypto.Xof;
+
+/**
+ * Crypto functions for XMSS.
+ *
+ */
+public final class KeyedHashFunctions {
+
+	private final Digest digest;
+	private final int digestSize;
+
+	protected KeyedHashFunctions(Digest digest, int digestSize) {
+		super();
+		if (digest == null) {
+			throw new NullPointerException("digest == null");
+		}
+		this.digest = digest;
+		this.digestSize = digestSize;
+	}
+
+	private byte[] coreDigest(int fixedValue, byte[] key, byte[] index) {
+		byte[] buffer = new byte[digestSize + key.length + index.length];
+		byte[] in = XMSSUtil.toBytesBigEndian(fixedValue, digestSize);
+		/* fill first n byte of out buffer */
+		for (int i = 0; i < in.length; i++) {
+			buffer[i] = in[i];
+		}
+		/* add key */
+		for (int i = 0; i < key.length; i++) {
+			buffer[in.length + i] = key[i];
+		}
+		/* add index */
+		for (int i = 0; i < index.length; i++) {
+			buffer[in.length + key.length + i] = index[i];
+		}
+		digest.update(buffer, 0, buffer.length);
+		byte[] out = new byte[digestSize];
+		if (digest instanceof Xof) {
+			((Xof) digest).doFinal(out, 0, digestSize);
+		} else {
+			digest.doFinal(out, 0);
+		}
+		return out;
+	}
+
+	protected byte[] F(byte[] key, byte[] in) {
+		if (key.length != digestSize) {
+			throw new IllegalArgumentException("wrong key length");
+		}
+		if (in.length != digestSize) {
+			throw new IllegalArgumentException("wrong in length");
+		}
+		return coreDigest(0, key, in);
+	}
+
+	protected byte[] H(byte[] key, byte[] in) {
+		if (key.length != digestSize) {
+			throw new IllegalArgumentException("wrong key length");
+		}
+		if (in.length != (2 * digestSize)) {
+			throw new IllegalArgumentException("wrong in length");
+		}
+		return coreDigest(1, key, in);
+	}
+
+	protected byte[] HMsg(byte[] key, byte[] in) {
+		if (key.length != (3 * digestSize)) {
+			throw new IllegalArgumentException("wrong key length");
+		}
+		return coreDigest(2, key, in);
+	}
+
+	protected byte[] PRF(byte[] key, byte[] address) {
+		if (key.length != digestSize) {
+			throw new IllegalArgumentException("wrong key length");
+		}
+		if (address.length != 32) {
+			throw new IllegalArgumentException("wrong address length");
+		}
+		return coreDigest(3, key, address);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/LTreeAddress.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/LTreeAddress.java
new file mode 100644
index 0000000..3278dca
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/LTreeAddress.java
@@ -0,0 +1,81 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * L-tree address.
+ *
+ */
+public final class LTreeAddress extends XMSSAddress {
+
+	private static final int TYPE = 0x01;
+	
+	private final int lTreeAddress;
+	private final int treeHeight;
+	private final int treeIndex;
+
+	private LTreeAddress(Builder builder) {
+		super(builder);
+		lTreeAddress = builder.lTreeAddress;
+		treeHeight = builder.treeHeight;
+		treeIndex = builder.treeIndex;
+	}
+	
+	protected static class Builder extends XMSSAddress.Builder<Builder> {
+
+		/* optional */
+		private int lTreeAddress = 0;
+		private int treeHeight = 0;
+		private int treeIndex = 0;
+
+		protected Builder() {
+			super(TYPE);
+		}
+		
+		protected Builder withLTreeAddress(int val) {
+			lTreeAddress = val;
+			return this;
+		}
+		
+		protected Builder withTreeHeight(int val) {
+			treeHeight = val;
+			return this;
+		}
+		
+		protected Builder withTreeIndex(int val) {
+			treeIndex = val;
+			return this;
+		}
+		
+		@Override
+		protected XMSSAddress build() {
+			return new LTreeAddress(this);
+		}
+
+		@Override
+		protected Builder getThis() {
+			return this;
+		}
+	}
+
+	@Override
+	protected byte[] toByteArray() {
+		byte[] byteRepresentation = super.toByteArray();
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, lTreeAddress, 16);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, treeHeight, 20);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, treeIndex, 24);
+		return byteRepresentation;
+	}
+
+	protected int getLTreeAddress() {
+		return lTreeAddress;
+	}
+	
+	protected int getTreeHeight() {
+		return treeHeight;
+	}
+	
+	protected int getTreeIndex() {
+		return treeIndex;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/NullPRNG.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/NullPRNG.java
new file mode 100644
index 0000000..aa46f90
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/NullPRNG.java
@@ -0,0 +1,24 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.security.SecureRandom;
+
+/**
+ * Implementation of null PRNG returning zeroes only. For testing purposes
+ * only(!).
+ *
+ */
+public final class NullPRNG extends SecureRandom {
+
+	private static final long serialVersionUID = 1L;
+
+	public NullPRNG() {
+		super();
+	}
+
+	@Override
+	public void nextBytes(byte[] bytes) {
+		for (int i = 0; i < bytes.length; i++) {
+			bytes[i] = 0x00;
+		}
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/OTSHashAddress.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/OTSHashAddress.java
new file mode 100644
index 0000000..c5890d8
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/OTSHashAddress.java
@@ -0,0 +1,81 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * OTS hash address.
+ *
+ */
+public final class OTSHashAddress extends XMSSAddress {
+
+	private static final int TYPE = 0x00;
+
+	private final int otsAddress;
+	private final int chainAddress;
+	private final int hashAddress;
+
+	private OTSHashAddress(Builder builder) {
+		super(builder);
+		otsAddress = builder.otsAddress;
+		chainAddress = builder.chainAddress;
+		hashAddress = builder.hashAddress;
+	}
+	
+	protected static class Builder extends XMSSAddress.Builder<Builder> {
+
+		/* optional */
+		private int otsAddress = 0;
+		private int chainAddress = 0;
+		private int hashAddress = 0;
+
+		protected Builder() {
+			super(TYPE);
+		}
+		
+		protected Builder withOTSAddress(int val) {
+			otsAddress = val;
+			return this;
+		}
+		
+		protected Builder withChainAddress(int val) {
+			chainAddress = val;
+			return this;
+		}
+		
+		protected Builder withHashAddress(int val) {
+			hashAddress = val;
+			return this;
+		}
+		
+		@Override
+		protected XMSSAddress build() {
+			return new OTSHashAddress(this);
+		}
+
+		@Override
+		protected Builder getThis() {
+			return this;
+		}
+	}
+
+	@Override
+	protected byte[] toByteArray() {
+		byte[] byteRepresentation = super.toByteArray();
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, otsAddress, 16);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, chainAddress, 20);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, hashAddress, 24);
+		return byteRepresentation;
+	}
+
+	protected int getOTSAddress() {
+		return otsAddress;
+	}
+	
+	protected int getChainAddress() {
+		return chainAddress;
+	}
+	
+	protected int getHashAddress() {
+		return hashAddress;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlus.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlus.java
new file mode 100644
index 0000000..6ef91b1
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlus.java
@@ -0,0 +1,380 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * WOTS+.
+ *
+ */
+public final class WOTSPlus {
+
+	/**
+	 * WOTS+ parameters.
+	 */
+	private final WOTSPlusParameters params;
+	/**
+	 * Randomization functions.
+	 */
+	private final KeyedHashFunctions khf;
+	/**
+	 * WOTS+ secret key seed.
+	 */
+	private byte[] secretKeySeed;
+	/**
+	 * WOTS+ public seed.
+	 */
+	private byte[] publicSeed;
+
+	/**
+	 * Constructs a new WOTS+ one-time signature system based on the given WOTS+
+	 * parameters.
+	 *
+	 * @param params
+	 *            Parameters for WOTSPlus object.
+	 */
+	protected WOTSPlus(WOTSPlusParameters params) {
+		super();
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		this.params = params;
+		int n = params.getDigestSize();
+		khf = new KeyedHashFunctions(params.getDigest(), n);
+		secretKeySeed = new byte[n];
+		publicSeed = new byte[n];
+	}
+
+	/**
+	 * Import keys to WOTS+ instance.
+	 *
+	 * @param secretKeySeed
+	 *            Secret key seed.
+	 * @param publicSeed
+	 *            Public seed.
+	 */
+	protected void importKeys(byte[] secretKeySeed, byte[] publicSeed) {
+		if (secretKeySeed == null) {
+			throw new NullPointerException("secretKeySeed == null");
+		}
+		if (secretKeySeed.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of secretKeySeed needs to be equal to size of digest");
+		}
+		if (publicSeed == null) {
+			throw new NullPointerException("publicSeed == null");
+		}
+		if (publicSeed.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of publicSeed needs to be equal to size of digest");
+		}
+		this.secretKeySeed = secretKeySeed;
+		this.publicSeed = publicSeed;
+	}
+
+	/**
+	 * Creates a signature for the n-byte messageDigest.
+	 *
+	 * @param messageDigest
+	 *            Digest to sign.
+	 * @param otsHashAddress
+	 *            OTS hash address for randomization.
+	 * @return WOTS+ signature.
+	 */
+	protected WOTSPlusSignature sign(byte[] messageDigest, OTSHashAddress otsHashAddress) {
+		if (messageDigest == null) {
+			throw new NullPointerException("messageDigest == null");
+		}
+		if (messageDigest.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of messageDigest needs to be equal to size of digest");
+		}
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		List<Integer> baseWMessage = convertToBaseW(messageDigest, params.getWinternitzParameter(), params.getLen1());
+		/* create checksum */
+		int checksum = 0;
+		for (int i = 0; i < params.getLen1(); i++) {
+			checksum += params.getWinternitzParameter() - 1 - baseWMessage.get(i);
+		}
+		checksum <<= (8 - ((params.getLen2() * XMSSUtil.log2(params.getWinternitzParameter())) % 8));
+		int len2Bytes = (int) Math
+				.ceil((double) (params.getLen2() * XMSSUtil.log2(params.getWinternitzParameter())) / 8);
+		List<Integer> baseWChecksum = convertToBaseW(XMSSUtil.toBytesBigEndian(checksum, len2Bytes),
+				params.getWinternitzParameter(), params.getLen2());
+
+		/* msg || checksum */
+		baseWMessage.addAll(baseWChecksum);
+
+		/* create signature */
+		byte[][] signature = new byte[params.getLen()][];
+		for (int i = 0; i < params.getLen(); i++) {
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withOTSAddress(otsHashAddress.getOTSAddress()).withChainAddress(i)
+					.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(otsHashAddress.getKeyAndMask())
+					.build();
+			signature[i] = chain(expandSecretKeySeed(i), 0, baseWMessage.get(i), otsHashAddress);
+		}
+		return new WOTSPlusSignature(params, signature);
+	}
+
+	/**
+	 * Verifies signature on message.
+	 *
+	 * @param messageDigest
+	 *            The digest that was signed.
+	 * @param signature
+	 *            Signature on digest.
+	 * @param otsHashAddress
+	 *            OTS hash address for randomization.
+	 * @return true if signature was correct false else.
+	 */
+	protected boolean verifySignature(byte[] messageDigest, WOTSPlusSignature signature,
+			OTSHashAddress otsHashAddress) {
+		if (messageDigest == null) {
+			throw new NullPointerException("messageDigest == null");
+		}
+		if (messageDigest.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of messageDigest needs to be equal to size of digest");
+		}
+		if (signature == null) {
+			throw new NullPointerException("signature == null");
+		}
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		byte[][] tmpPublicKey = getPublicKeyFromSignature(messageDigest, signature, otsHashAddress).toByteArray();
+		/* compare values */
+		return XMSSUtil.compareByteArray(tmpPublicKey, getPublicKey(otsHashAddress).toByteArray()) ? true : false;
+	}
+
+	/**
+	 * Calculates a public key based on digest and signature.
+	 *
+	 * @param messageDigest
+	 *            The digest that was signed.
+	 * @param signature
+	 *            Signarure on digest.
+	 * @param otsHashAddress
+	 *            OTS hash address for randomization.
+	 * @return WOTS+ public key derived from digest and signature.
+	 */
+	protected WOTSPlusPublicKeyParameters getPublicKeyFromSignature(byte[] messageDigest, WOTSPlusSignature signature,
+			OTSHashAddress otsHashAddress) {
+		if (messageDigest == null) {
+			throw new NullPointerException("messageDigest == null");
+		}
+		if (messageDigest.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of messageDigest needs to be equal to size of digest");
+		}
+		if (signature == null) {
+			throw new NullPointerException("signature == null");
+		}
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		List<Integer> baseWMessage = convertToBaseW(messageDigest, params.getWinternitzParameter(), params.getLen1());
+		/* create checksum */
+		int checksum = 0;
+		for (int i = 0; i < params.getLen1(); i++) {
+			checksum += params.getWinternitzParameter() - 1 - baseWMessage.get(i);
+		}
+		checksum <<= (8 - ((params.getLen2() * XMSSUtil.log2(params.getWinternitzParameter())) % 8));
+		int len2Bytes = (int) Math
+				.ceil((double) (params.getLen2() * XMSSUtil.log2(params.getWinternitzParameter())) / 8);
+		List<Integer> baseWChecksum = convertToBaseW(XMSSUtil.toBytesBigEndian(checksum, len2Bytes),
+				params.getWinternitzParameter(), params.getLen2());
+
+		/* msg || checksum */
+		baseWMessage.addAll(baseWChecksum);
+
+		byte[][] publicKey = new byte[params.getLen()][];
+		for (int i = 0; i < params.getLen(); i++) {
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withOTSAddress(otsHashAddress.getOTSAddress()).withChainAddress(i)
+					.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(otsHashAddress.getKeyAndMask())
+					.build();
+			publicKey[i] = chain(signature.toByteArray()[i], baseWMessage.get(i),
+					params.getWinternitzParameter() - 1 - baseWMessage.get(i), otsHashAddress);
+		}
+		return new WOTSPlusPublicKeyParameters(params, publicKey);
+	}
+
+	/**
+	 * Computes an iteration of F on an n-byte input using outputs of PRF.
+	 *
+	 * @param startHash
+	 *            Starting point.
+	 * @param startIndex
+	 *            Start index.
+	 * @param steps
+	 *            Steps to take.
+	 * @param otsHashAddress
+	 *            OTS hash address for randomization.
+	 * @return Value obtained by iterating F for steps times on input startHash,
+	 *         using the outputs of PRF.
+	 */
+	private byte[] chain(byte[] startHash, int startIndex, int steps, OTSHashAddress otsHashAddress) {
+		int n = params.getDigestSize();
+		if (startHash == null) {
+			throw new NullPointerException("startHash == null");
+		}
+		if (startHash.length != n) {
+			throw new IllegalArgumentException("startHash needs to be " + n + "bytes");
+		}
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		if (otsHashAddress.toByteArray() == null) {
+			throw new NullPointerException("otsHashAddress byte array == null");
+		}
+		if ((startIndex + steps) > params.getWinternitzParameter() - 1) {
+			throw new IllegalArgumentException("max chain length must not be greater than w");
+		}
+
+		if (steps == 0) {
+			return startHash;
+		}
+
+		byte[] tmp = chain(startHash, startIndex, steps - 1, otsHashAddress);
+		otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.withOTSAddress(otsHashAddress.getOTSAddress()).withChainAddress(otsHashAddress.getChainAddress())
+				.withHashAddress(startIndex + steps - 1).withKeyAndMask(0).build();
+		byte[] key = khf.PRF(publicSeed, otsHashAddress.toByteArray());
+		otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.withOTSAddress(otsHashAddress.getOTSAddress()).withChainAddress(otsHashAddress.getChainAddress())
+				.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(1).build();
+		byte[] bitmask = khf.PRF(publicSeed, otsHashAddress.toByteArray());
+		byte[] tmpMasked = new byte[n];
+		for (int i = 0; i < n; i++) {
+			tmpMasked[i] = (byte) (tmp[i] ^ bitmask[i]);
+		}
+		tmp = khf.F(key, tmpMasked);
+		return tmp;
+	}
+
+	/**
+	 * Obtain base w values from Input.
+	 *
+	 * @param messageDigest
+	 *            Input data.
+	 * @param w
+	 *            Base.
+	 * @param outLength
+	 *            Length of output.
+	 * @return outLength-length list of base w integers.
+	 */
+	private List<Integer> convertToBaseW(byte[] messageDigest, int w, int outLength) {
+		if (messageDigest == null) {
+			throw new NullPointerException("msg == null");
+		}
+		if (w != 4 && w != 16) {
+			throw new IllegalArgumentException("w needs to be 4 or 16");
+		}
+		int logW = XMSSUtil.log2(w);
+		if (outLength > ((8 * messageDigest.length) / logW)) {
+			throw new IllegalArgumentException("outLength too big");
+		}
+
+		ArrayList<Integer> res = new ArrayList<Integer>();
+		for (int i = 0; i < messageDigest.length; i++) {
+			for (int j = 8 - logW; j >= 0; j -= logW) {
+				res.add((messageDigest[i] >> j) & (w - 1));
+				if (res.size() == outLength) {
+					return res;
+				}
+			}
+		}
+		return res;
+	}
+
+	/**
+	 * Derive private key at index from secret key seed.
+	 *
+	 * @param index
+	 *            Index.
+	 * @return Private key at index.
+	 */
+	private byte[] expandSecretKeySeed(int index) {
+		if (index < 0 || index >= params.getLen()) {
+			throw new IllegalArgumentException("index out of bounds");
+		}
+		return khf.PRF(secretKeySeed, XMSSUtil.toBytesBigEndian(index, 32));
+	}
+
+	/**
+	 * Getter parameters.
+	 *
+	 * @return params.
+	 */
+	protected WOTSPlusParameters getParams() {
+		return params;
+	}
+
+	/**
+	 * Getter keyed hash functions.
+	 *
+	 * @return keyed hash functions.
+	 */
+	protected KeyedHashFunctions getKhf() {
+		return khf;
+	}
+
+	/**
+	 * Getter secret key seed.
+	 *
+	 * @return secret key seed.
+	 */
+	protected byte[] getSecretKeySeed() {
+		return XMSSUtil.cloneArray(getSecretKeySeed());
+	}
+
+	/**
+	 * Getter public seed.
+	 *
+	 * @return public seed.
+	 */
+	protected byte[] getPublicSeed() {
+		return XMSSUtil.cloneArray(publicSeed);
+	}
+
+	/**
+	 * Getter private key.
+	 *
+	 * @return WOTS+ private key.
+	 */
+	protected WOTSPlusPrivateKeyParameters getPrivateKey() {
+		byte[][] privateKey = new byte[params.getLen()][];
+		for (int i = 0; i < privateKey.length; i++) {
+			privateKey[i] = expandSecretKeySeed(i);
+		}
+		return new WOTSPlusPrivateKeyParameters(params, privateKey);
+	}
+
+	/**
+	 * Calculates a new public key based on the state of secretKeySeed,
+	 * publicSeed and otsHashAddress.
+	 *
+	 * @param otsHashAddress
+	 *            OTS hash address for randomization.
+	 * @return WOTS+ public key.
+	 */
+	protected WOTSPlusPublicKeyParameters getPublicKey(OTSHashAddress otsHashAddress) {
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		byte[][] publicKey = new byte[params.getLen()][];
+		/* derive public key from secretKeySeed */
+		for (int i = 0; i < params.getLen(); i++) {
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+					.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+					.withOTSAddress(otsHashAddress.getOTSAddress()).withChainAddress(i)
+					.withHashAddress(otsHashAddress.getHashAddress()).withKeyAndMask(otsHashAddress.getKeyAndMask())
+					.build();
+			publicKey[i] = chain(expandSecretKeySeed(i), 0, params.getWinternitzParameter() - 1, otsHashAddress);
+		}
+		return new WOTSPlusPublicKeyParameters(params, publicKey);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusOid.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusOid.java
new file mode 100644
index 0000000..febb758
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusOid.java
@@ -0,0 +1,94 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * WOTS+ OID class.
+ * 
+ */
+public final class WOTSPlusOid implements XMSSOid {
+
+	/**
+	 * XMSS OID lookup table.
+	 */
+	private static final Map<String, WOTSPlusOid> oidLookupTable;
+
+	static {
+		Map<String, WOTSPlusOid> map = new HashMap<String, WOTSPlusOid>();
+		map.put(createKey("SHA-256", 32, 16, 67), new WOTSPlusOid(0x01000001, "WOTSP_SHA2-256_W16"));
+		map.put(createKey("SHA-512", 64, 16, 131), new WOTSPlusOid(0x02000002, "WOTSP_SHA2-512_W16"));
+		map.put(createKey("SHAKE128", 32, 16, 67), new WOTSPlusOid(0x03000003, "WOTSP_SHAKE128_W16"));
+		map.put(createKey("SHAKE256", 64, 16, 131), new WOTSPlusOid(0x04000004, "WOTSP_SHAKE256_W16"));
+		oidLookupTable = Collections.unmodifiableMap(map);
+	}
+
+	/**
+	 * OID.
+	 */
+	private final int oid;
+	/**
+	 * String representation of OID.
+	 */
+	private final String stringRepresentation;
+
+	/**
+	 * Constructor...
+	 *
+	 * @param oid
+	 *            OID.
+	 * @param stringRepresentation
+	 *            String representation of OID.
+	 */
+	private WOTSPlusOid(int oid, String stringRepresentation) {
+		super();
+		this.oid = oid;
+		this.stringRepresentation = stringRepresentation;
+	}
+
+	/**
+	 * Lookup OID.
+	 *
+	 * @param algorithmName
+	 *            Algorithm name.
+	 * @param winternitzParameter
+	 *            Winternitz parameter.
+	 * @return WOTS+ OID if parameters were found, null else.
+	 */
+	protected static WOTSPlusOid lookup(String algorithmName, int digestSize, int winternitzParameter, int len) {
+		if (algorithmName == null) {
+			throw new NullPointerException("algorithmName == null");
+		}
+		return oidLookupTable.get(createKey(algorithmName, digestSize, winternitzParameter, len));
+	}
+
+	/**
+	 * Create a key based on parameters.
+	 *
+	 * @param algorithmName
+	 *            Algorithm name.
+	 * @param winternitzParameter
+	 *            Winternitz Parameter.
+	 * @return String representation of parameters for lookup table.
+	 */
+	private static String createKey(String algorithmName, int digestSize, int winternitzParameter, int len) {
+		if (algorithmName == null) {
+			throw new NullPointerException("algorithmName == null");
+		}
+		return algorithmName + "-" + digestSize + "-" + winternitzParameter + "-" + len;
+	}
+
+	/**
+	 * Getter OID.
+	 *
+	 * @return OID.
+	 */
+	public int getOid() {
+		return oid;
+	}
+
+	public String toString() {
+		return stringRepresentation;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusParameters.java
new file mode 100644
index 0000000..b1b3cd3
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusParameters.java
@@ -0,0 +1,126 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import org.bouncycastle.crypto.Digest;
+
+/**
+ * WOTS+ Parameters.
+ */
+public final class WOTSPlusParameters {
+
+	/**
+	 * OID.
+	 */
+	private final XMSSOid oid;
+	/**
+	 * Digest used in WOTS+.
+	 */
+	private final Digest digest;
+	/**
+	 * The message digest size.
+	 */
+	private final int digestSize;
+	/**
+	 * The Winternitz parameter (currently fixed to 16).
+	 */
+	private final int winternitzParameter;
+	/**
+	 * The number of n-byte string elements in a WOTS+ secret key, public key,
+	 * and signature.
+	 */
+	private final int len;
+	/**
+	 * len1.
+	 */
+	private final int len1;
+	/**
+	 * len2.
+	 */
+	private final int len2;
+
+	/**
+	 * Constructor...
+	 *
+	 * @param digest
+	 *            The digest used for WOTS+.
+	 */
+	protected WOTSPlusParameters(Digest digest) {
+		super();
+		if (digest == null) {
+			throw new NullPointerException("digest == null");
+		}
+		this.digest = digest;
+		digestSize = XMSSUtil.getDigestSize(digest);
+		winternitzParameter = 16;
+		len1 = (int) Math.ceil((double) (8 * digestSize) / XMSSUtil.log2(winternitzParameter));
+		len2 = (int) Math.floor(XMSSUtil.log2(len1 * (winternitzParameter - 1)) / XMSSUtil.log2(winternitzParameter))
+				+ 1;
+		len = len1 + len2;
+		oid = WOTSPlusOid.lookup(digest.getAlgorithmName(), digestSize, winternitzParameter, len);
+		if (oid == null) {
+			throw new IllegalArgumentException("cannot find OID for digest algorithm: " + digest.getAlgorithmName());
+		}
+	}
+
+	/**
+	 * Getter OID.
+	 *
+	 * @return WOTS+ OID.
+	 */
+	protected XMSSOid getOid() {
+		return oid;
+	}
+
+	/**
+	 * Getter digest.
+	 *
+	 * @return digest.
+	 */
+	protected Digest getDigest() {
+		return digest;
+	}
+
+	/**
+	 * Getter digestSize.
+	 *
+	 * @return digestSize.
+	 */
+	protected int getDigestSize() {
+		return digestSize;
+	}
+
+	/**
+	 * Getter WinternitzParameter.
+	 *
+	 * @return winternitzParameter.
+	 */
+	protected int getWinternitzParameter() {
+		return winternitzParameter;
+	}
+
+	/**
+	 * Getter len.
+	 *
+	 * @return len.
+	 */
+	protected int getLen() {
+		return len;
+	}
+
+	/**
+	 * Getter len1.
+	 *
+	 * @return len1.
+	 */
+	protected int getLen1() {
+		return len1;
+	}
+
+	/**
+	 * Getter len2.
+	 *
+	 * @return len2.
+	 */
+	protected int getLen2() {
+		return len2;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusPrivateKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusPrivateKeyParameters.java
new file mode 100644
index 0000000..da5c494
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusPrivateKeyParameters.java
@@ -0,0 +1,36 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+/**
+ * WOTS+ private key.
+ *
+ */
+public final class WOTSPlusPrivateKeyParameters {
+
+	private final byte[][] privateKey;
+
+	protected WOTSPlusPrivateKeyParameters(WOTSPlusParameters params, byte[][] privateKey) {
+		super();
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		if (privateKey == null) {
+			throw new NullPointerException("privateKey == null");
+		}
+		if (XMSSUtil.hasNullPointer(privateKey)) {
+			throw new NullPointerException("privateKey byte array == null");
+		}
+		if (privateKey.length != params.getLen()) {
+			throw new IllegalArgumentException("wrong privateKey format");
+		}
+		for (int i = 0; i < privateKey.length; i++) {
+			if (privateKey[i].length != params.getDigestSize()) {
+				throw new IllegalArgumentException("wrong privateKey format");
+			}
+		}
+		this.privateKey = XMSSUtil.cloneArray(privateKey);
+	}
+
+	protected byte[][] toByteArray() {
+		return XMSSUtil.cloneArray(privateKey);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusPublicKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusPublicKeyParameters.java
new file mode 100644
index 0000000..c602d25
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusPublicKeyParameters.java
@@ -0,0 +1,36 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+/**
+ * WOTS+ public key.
+ *
+ */
+public final class WOTSPlusPublicKeyParameters {
+
+	private final byte[][] publicKey;
+
+	protected WOTSPlusPublicKeyParameters(WOTSPlusParameters params, byte[][] publicKey) {
+		super();
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		if (publicKey == null) {
+			throw new NullPointerException("publicKey == null");
+		}
+		if (XMSSUtil.hasNullPointer(publicKey)) {
+			throw new NullPointerException("publicKey byte array == null");
+		}
+		if (publicKey.length != params.getLen()) {
+			throw new IllegalArgumentException("wrong publicKey size");
+		}
+		for (int i = 0; i < publicKey.length; i++) {
+			if (publicKey[i].length != params.getDigestSize()) {
+				throw new IllegalArgumentException("wrong publicKey format");
+			}
+		}
+		this.publicKey = XMSSUtil.cloneArray(publicKey);
+	}
+
+	protected byte[][] toByteArray() {
+		return XMSSUtil.cloneArray(publicKey);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusSignature.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusSignature.java
new file mode 100644
index 0000000..b6592eb
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/WOTSPlusSignature.java
@@ -0,0 +1,36 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+/**
+ * WOTS+ signature.
+ *
+ */
+public final class WOTSPlusSignature {
+
+	private byte[][] signature;
+
+	protected WOTSPlusSignature(WOTSPlusParameters params, byte[][] signature) {
+		super();
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		if (signature == null) {
+			throw new NullPointerException("signature == null");
+		}
+		if (XMSSUtil.hasNullPointer(signature)) {
+			throw new NullPointerException("signature byte array == null");
+		}
+		if (signature.length != params.getLen()) {
+			throw new IllegalArgumentException("wrong signature size");
+		}
+		for (int i = 0; i < signature.length; i++) {
+			if (signature[i].length != params.getDigestSize()) {
+				throw new IllegalArgumentException("wrong signature format");
+			}
+		}
+		this.signature = XMSSUtil.cloneArray(signature);
+	}
+
+	public byte[][] toByteArray() {
+		return XMSSUtil.cloneArray(signature);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSS.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSS.java
new file mode 100644
index 0000000..d0ed3e9
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSS.java
@@ -0,0 +1,625 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.text.ParseException;
+
+/**
+ * XMSS.
+ *
+ */
+public class XMSS {
+
+	/**
+	 * XMSS parameters.
+	 */
+	private XMSSParameters params;
+	/**
+	 * WOTS+ instance.
+	 */
+	private WOTSPlus wotsPlus;
+	/**
+	 * PRNG.
+	 */
+	private SecureRandom prng;
+	/**
+	 * Randomization functions.
+	 */
+	private KeyedHashFunctions khf;
+	/**
+	 * XMSS private key.
+	 */
+	private XMSSPrivateKeyParameters privateKey;
+	/**
+	 * XMSS public key.
+	 */
+	private XMSSPublicKeyParameters publicKey;
+
+	/**
+	 * XMSS constructor...
+	 *
+	 * @param params
+	 *            XMSSParameters.
+	 */
+	public XMSS(XMSSParameters params) {
+		super();
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		this.params = params;
+		wotsPlus = params.getWOTSPlus();
+		prng = params.getPRNG();
+		khf = wotsPlus.getKhf();
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withBDSState(new BDS(this)).build();
+			publicKey = new XMSSPublicKeyParameters.Builder(params).build();
+		} catch (ParseException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Generate a new XMSS private key / public key pair.
+	 * 
+	 */
+	public void generateKeys() {
+		/* generate private key */
+		privateKey = generatePrivateKey();
+		XMSSNode root = getBDSState().initialize((OTSHashAddress) new OTSHashAddress.Builder().build());
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withIndex(privateKey.getIndex())
+					.withSecretKeySeed(privateKey.getSecretKeySeed()).withSecretKeyPRF(privateKey.getSecretKeyPRF())
+					.withPublicSeed(privateKey.getPublicSeed()).withRoot(root.getValue())
+					.withBDSState(privateKey.getBDSState()).build();
+			publicKey = new XMSSPublicKeyParameters.Builder(params).withRoot(root.getValue())
+					.withPublicSeed(getPublicSeed()).build();
+		} catch (ParseException ex) {
+			/* should not be possible */
+			ex.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Generate an XMSS private key.
+	 *
+	 * @return XMSS private key.
+	 */
+	private XMSSPrivateKeyParameters generatePrivateKey() {
+		int n = params.getDigestSize();
+		byte[] secretKeySeed = new byte[n];
+		prng.nextBytes(secretKeySeed);
+		byte[] secretKeyPRF = new byte[n];
+		prng.nextBytes(secretKeyPRF);
+		byte[] publicSeed = new byte[n];
+		prng.nextBytes(publicSeed);
+
+		XMSSPrivateKeyParameters privateKey = null;
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withSecretKeySeed(secretKeySeed)
+					.withSecretKeyPRF(secretKeyPRF).withPublicSeed(publicSeed)
+					.withBDSState(this.privateKey.getBDSState()).build();
+		} catch (ParseException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+		return privateKey;
+	}
+
+	/**
+	 * Import XMSS private key / public key pair.
+	 * 
+	 * @param privateKey
+	 *            XMSS private key.
+	 * @param publicKey
+	 *            XMSS public key.
+	 * @throws ParseException
+	 * @throws ClassNotFoundException
+	 * @throws IOException
+	 */
+	public void importState(byte[] privateKey, byte[] publicKey)
+			throws ParseException, ClassNotFoundException, IOException {
+		if (privateKey == null) {
+			throw new NullPointerException("privateKey == null");
+		}
+		if (publicKey == null) {
+			throw new NullPointerException("publicKey == null");
+		}
+		/* import keys */
+		XMSSPrivateKeyParameters tmpPrivateKey = new XMSSPrivateKeyParameters.Builder(params)
+				.withPrivateKey(privateKey, this).build();
+		XMSSPublicKeyParameters tmpPublicKey = new XMSSPublicKeyParameters.Builder(params).withPublicKey(publicKey)
+				.build();
+		if (!XMSSUtil.compareByteArray(tmpPrivateKey.getRoot(), tmpPublicKey.getRoot())) {
+			throw new IllegalStateException("root of private key and public key do not match");
+		}
+		if (!XMSSUtil.compareByteArray(tmpPrivateKey.getPublicSeed(), tmpPublicKey.getPublicSeed())) {
+			throw new IllegalStateException("public seed of private key and public key do not match");
+		}
+		/* import */
+		this.privateKey = tmpPrivateKey;
+		this.publicKey = tmpPublicKey;
+		wotsPlus.importKeys(new byte[params.getDigestSize()], this.privateKey.getPublicSeed());
+	}
+
+	/**
+	 * Sign message.
+	 *
+	 * @param message
+	 *            Message to sign.
+	 * @return XMSS signature on digest of message.
+	 */
+	public byte[] sign(byte[] message) {
+		if (message == null) {
+			throw new NullPointerException("message == null");
+		}
+		if (getBDSState().getAuthenticationPath().isEmpty()) {
+			throw new IllegalStateException("not initialized");
+		}
+		int index = privateKey.getIndex();
+		if (!XMSSUtil.isIndexValid(getParams().getHeight(), index)) {
+			throw new IllegalArgumentException("index out of bounds");
+		}
+
+		/* create (randomized keyed) messageDigest of message */
+		byte[] random = khf.PRF(privateKey.getSecretKeyPRF(), XMSSUtil.toBytesBigEndian(index, 32));
+		byte[] concatenated = XMSSUtil.concat(random, privateKey.getRoot(),
+				XMSSUtil.toBytesBigEndian(index, params.getDigestSize()));
+		byte[] messageDigest = khf.HMsg(concatenated, message);
+
+		/* create signature for messageDigest */
+		OTSHashAddress otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withOTSAddress(index).build();
+		WOTSPlusSignature wotsPlusSignature = wotsSign(messageDigest, otsHashAddress);
+		XMSSSignature signature = null;
+		try {
+			signature = (XMSSSignature) new XMSSSignature.Builder(params).withIndex(index).withRandom(random)
+					.withWOTSPlusSignature(wotsPlusSignature).withAuthPath(getBDSState().getAuthenticationPath())
+					.build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		}
+
+		/* prepare authentication path for next leaf */
+		int treeHeight = this.getParams().getHeight();
+		if (index < ((1 << treeHeight) - 1)) {
+			getBDSState().nextAuthenticationPath((OTSHashAddress) new OTSHashAddress.Builder().build());
+		}
+
+		/* update index */
+		setIndex(index + 1);
+
+		return signature.toByteArray();
+	}
+
+	/**
+	 * Verify an XMSS signature.
+	 * 
+	 * @param message
+	 *            Message.
+	 * @param signature
+	 *            XMSS signature.
+	 * @param publicKey
+	 *            XMSS public key.
+	 * @return true if signature is valid false else.
+	 * @throws ParseException
+	 */
+	public boolean verifySignature(byte[] message, byte[] signature, byte[] publicKey) throws ParseException {
+		if (message == null) {
+			throw new NullPointerException("message == null");
+		}
+		if (signature == null) {
+			throw new NullPointerException("signature == null");
+		}
+		if (publicKey == null) {
+			throw new NullPointerException("publicKey == null");
+		}
+		/* parse signature and public key */
+		XMSSSignature sig = new XMSSSignature.Builder(params).withSignature(signature).build();
+		/* generate public key */
+		XMSSPublicKeyParameters pubKey = new XMSSPublicKeyParameters.Builder(params).withPublicKey(publicKey).build();
+
+		/* save state */
+		int savedIndex = privateKey.getIndex();
+		byte[] savedPublicSeed = privateKey.getPublicSeed();
+
+		/* set index / public seed */
+		int index = sig.getIndex();
+		setIndex(index);
+		setPublicSeed(pubKey.getPublicSeed());
+
+		/* reinitialize WOTS+ object */
+		wotsPlus.importKeys(new byte[params.getDigestSize()], getPublicSeed());
+
+		/* create message digest */
+		byte[] concatenated = XMSSUtil.concat(sig.getRandom(), pubKey.getRoot(),
+				XMSSUtil.toBytesBigEndian(index, params.getDigestSize()));
+		byte[] messageDigest = khf.HMsg(concatenated, message);
+
+		/* get root from signature */
+		OTSHashAddress otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withOTSAddress(index).build();
+		XMSSNode rootNodeFromSignature = getRootNodeFromSignature(messageDigest, sig, otsHashAddress);
+
+		/* reset state */
+		setIndex(savedIndex);
+		setPublicSeed(savedPublicSeed);
+		return XMSSUtil.compareByteArray(rootNodeFromSignature.getValue(), pubKey.getRoot());
+	}
+
+	/**
+	 * Export XMSS private key.
+	 *
+	 * @return XMSS private key.
+	 */
+	public byte[] exportPrivateKey() {
+		return privateKey.toByteArray();
+	}
+
+	/**
+	 * Export XMSS public key.
+	 *
+	 * @return XMSS public key.
+	 */
+	public byte[] exportPublicKey() {
+		return publicKey.toByteArray();
+	}
+
+	/**
+	 * Randomization of nodes in binary tree.
+	 *
+	 * @param left
+	 *            Left node.
+	 * @param right
+	 *            Right node.
+	 * @param address
+	 *            Address.
+	 * @return Randomized hash of parent of left / right node.
+	 */
+	protected XMSSNode randomizeHash(XMSSNode left, XMSSNode right, XMSSAddress address) {
+		if (left == null) {
+			throw new NullPointerException("left == null");
+		}
+		if (right == null) {
+			throw new NullPointerException("right == null");
+		}
+		if (left.getHeight() != right.getHeight()) {
+			throw new IllegalStateException("height of both nodes must be equal");
+		}
+		if (address == null) {
+			throw new NullPointerException("address == null");
+		}
+		byte[] publicSeed = getPublicSeed();
+
+		if (address instanceof LTreeAddress) {
+			LTreeAddress tmpAddress = (LTreeAddress) address;
+			address = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(tmpAddress.getLayerAddress())
+					.withTreeAddress(tmpAddress.getTreeAddress()).withLTreeAddress(tmpAddress.getLTreeAddress())
+					.withTreeHeight(tmpAddress.getTreeHeight()).withTreeIndex(tmpAddress.getTreeIndex())
+					.withKeyAndMask(0).build();
+		} else if (address instanceof HashTreeAddress) {
+			HashTreeAddress tmpAddress = (HashTreeAddress) address;
+			address = (HashTreeAddress) new HashTreeAddress.Builder().withLayerAddress(tmpAddress.getLayerAddress())
+					.withTreeAddress(tmpAddress.getTreeAddress()).withTreeHeight(tmpAddress.getTreeHeight())
+					.withTreeIndex(tmpAddress.getTreeIndex()).withKeyAndMask(0).build();
+		}
+
+		byte[] key = khf.PRF(publicSeed, address.toByteArray());
+
+		if (address instanceof LTreeAddress) {
+			LTreeAddress tmpAddress = (LTreeAddress) address;
+			address = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(tmpAddress.getLayerAddress())
+					.withTreeAddress(tmpAddress.getTreeAddress()).withLTreeAddress(tmpAddress.getLTreeAddress())
+					.withTreeHeight(tmpAddress.getTreeHeight()).withTreeIndex(tmpAddress.getTreeIndex())
+					.withKeyAndMask(1).build();
+		} else if (address instanceof HashTreeAddress) {
+			HashTreeAddress tmpAddress = (HashTreeAddress) address;
+			address = (HashTreeAddress) new HashTreeAddress.Builder().withLayerAddress(tmpAddress.getLayerAddress())
+					.withTreeAddress(tmpAddress.getTreeAddress()).withTreeHeight(tmpAddress.getTreeHeight())
+					.withTreeIndex(tmpAddress.getTreeIndex()).withKeyAndMask(1).build();
+		}
+
+		byte[] bitmask0 = khf.PRF(publicSeed, address.toByteArray());
+
+		if (address instanceof LTreeAddress) {
+			LTreeAddress tmpAddress = (LTreeAddress) address;
+			address = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(tmpAddress.getLayerAddress())
+					.withTreeAddress(tmpAddress.getTreeAddress()).withLTreeAddress(tmpAddress.getLTreeAddress())
+					.withTreeHeight(tmpAddress.getTreeHeight()).withTreeIndex(tmpAddress.getTreeIndex())
+					.withKeyAndMask(2).build();
+		} else if (address instanceof HashTreeAddress) {
+			HashTreeAddress tmpAddress = (HashTreeAddress) address;
+			address = (HashTreeAddress) new HashTreeAddress.Builder().withLayerAddress(tmpAddress.getLayerAddress())
+					.withTreeAddress(tmpAddress.getTreeAddress()).withTreeHeight(tmpAddress.getTreeHeight())
+					.withTreeIndex(tmpAddress.getTreeIndex()).withKeyAndMask(2).build();
+		}
+
+		byte[] bitmask1 = khf.PRF(publicSeed, address.toByteArray());
+		int n = params.getDigestSize();
+		byte[] tmpMask = new byte[2 * n];
+		for (int i = 0; i < n; i++) {
+			tmpMask[i] = (byte) (left.getValue()[i] ^ bitmask0[i]);
+		}
+		for (int i = 0; i < n; i++) {
+			tmpMask[i + n] = (byte) (right.getValue()[i] ^ bitmask1[i]);
+		}
+		byte[] out = khf.H(key, tmpMask);
+		return new XMSSNode(left.getHeight(), out);
+	}
+
+	/**
+	 * Compresses a WOTS+ public key to a single n-byte string.
+	 *
+	 * @param publicKey
+	 *            WOTS+ public key to compress.
+	 * @param address
+	 *            Address.
+	 * @return Compressed n-byte string of public key.
+	 */
+	protected XMSSNode lTree(WOTSPlusPublicKeyParameters publicKey, LTreeAddress address) {
+		if (publicKey == null) {
+			throw new NullPointerException("publicKey == null");
+		}
+		if (address == null) {
+			throw new NullPointerException("address == null");
+		}
+		int len = wotsPlus.getParams().getLen();
+		/* duplicate public key to XMSSNode Array */
+		byte[][] publicKeyBytes = publicKey.toByteArray();
+		XMSSNode[] publicKeyNodes = new XMSSNode[publicKeyBytes.length];
+		for (int i = 0; i < publicKeyBytes.length; i++) {
+			publicKeyNodes[i] = new XMSSNode(0, publicKeyBytes[i]);
+		}
+		address = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(address.getLayerAddress())
+				.withTreeAddress(address.getTreeAddress()).withLTreeAddress(address.getLTreeAddress()).withTreeHeight(0)
+				.withTreeIndex(address.getTreeIndex()).withKeyAndMask(address.getKeyAndMask()).build();
+		while (len > 1) {
+			for (int i = 0; i < (int) Math.floor(len / 2); i++) {
+				address = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(address.getLayerAddress())
+						.withTreeAddress(address.getTreeAddress()).withLTreeAddress(address.getLTreeAddress())
+						.withTreeHeight(address.getTreeHeight()).withTreeIndex(i)
+						.withKeyAndMask(address.getKeyAndMask()).build();
+				publicKeyNodes[i] = randomizeHash(publicKeyNodes[2 * i], publicKeyNodes[(2 * i) + 1], address);
+			}
+			if (len % 2 == 1) {
+				publicKeyNodes[(int) Math.floor(len / 2)] = publicKeyNodes[len - 1];
+			}
+			len = (int) Math.ceil((double) len / 2);
+			address = (LTreeAddress) new LTreeAddress.Builder().withLayerAddress(address.getLayerAddress())
+					.withTreeAddress(address.getTreeAddress()).withLTreeAddress(address.getLTreeAddress())
+					.withTreeHeight(address.getTreeHeight() + 1).withTreeIndex(address.getTreeIndex())
+					.withKeyAndMask(address.getKeyAndMask()).build();
+		}
+		return publicKeyNodes[0];
+	}
+
+	/**
+	 * Generate a WOTS+ signature on a message without the corresponding
+	 * authentication path
+	 *
+	 * @param messageDigest
+	 *            Message digest of length n.
+	 * @param otsHashAddress
+	 *            OTS hash address.
+	 * @return XMSS signature.
+	 */
+	protected WOTSPlusSignature wotsSign(byte[] messageDigest, OTSHashAddress otsHashAddress) {
+		if (messageDigest.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of messageDigest needs to be equal to size of digest");
+		}
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+		/* (re)initialize WOTS+ instance */
+		wotsPlus.importKeys(getWOTSPlusSecretKey(otsHashAddress), getPublicSeed());
+		/* create WOTS+ signature */
+		return wotsPlus.sign(messageDigest, otsHashAddress);
+	}
+
+	/**
+	 * Compute a root node from a tree signature.
+	 *
+	 * @param messageDigest
+	 *            Message digest.
+	 * @param signature
+	 *            XMSS signature.
+	 * @return Root node calculated from signature.
+	 */
+	protected XMSSNode getRootNodeFromSignature(byte[] messageDigest, XMSSReducedSignature signature,
+			OTSHashAddress otsHashAddress) {
+		if (messageDigest.length != params.getDigestSize()) {
+			throw new IllegalArgumentException("size of messageDigest needs to be equal to size of digest");
+		}
+		if (signature == null) {
+			throw new NullPointerException("signature == null");
+		}
+		if (otsHashAddress == null) {
+			throw new NullPointerException("otsHashAddress == null");
+		}
+
+		/* prepare adresses */
+		LTreeAddress lTreeAddress = (LTreeAddress) new LTreeAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.withLTreeAddress(otsHashAddress.getOTSAddress()).build();
+		HashTreeAddress hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.withTreeIndex(otsHashAddress.getOTSAddress()).build();
+		/*
+		 * calculate WOTS+ public key and compress to obtain original leaf hash
+		 */
+		WOTSPlusPublicKeyParameters wotsPlusPK = wotsPlus.getPublicKeyFromSignature(messageDigest,
+				signature.getWOTSPlusSignature(), otsHashAddress);
+		XMSSNode[] node = new XMSSNode[2];
+		node[0] = lTree(wotsPlusPK, lTreeAddress);
+
+		for (int k = 0; k < params.getHeight(); k++) {
+			hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+					.withLayerAddress(hashTreeAddress.getLayerAddress())
+					.withTreeAddress(hashTreeAddress.getTreeAddress()).withTreeHeight(k)
+					.withTreeIndex(hashTreeAddress.getTreeIndex()).withKeyAndMask(hashTreeAddress.getKeyAndMask())
+					.build();
+			if (Math.floor(privateKey.getIndex() / (1 << k)) % 2 == 0) {
+				hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+						.withLayerAddress(hashTreeAddress.getLayerAddress())
+						.withTreeAddress(hashTreeAddress.getTreeAddress())
+						.withTreeHeight(hashTreeAddress.getTreeHeight())
+						.withTreeIndex(hashTreeAddress.getTreeIndex() / 2)
+						.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+				node[1] = randomizeHash(node[0], signature.getAuthPath().get(k), hashTreeAddress);
+				node[1] = new XMSSNode(node[1].getHeight() + 1, node[1].getValue());
+			} else {
+				hashTreeAddress = (HashTreeAddress) new HashTreeAddress.Builder()
+						.withLayerAddress(hashTreeAddress.getLayerAddress())
+						.withTreeAddress(hashTreeAddress.getTreeAddress())
+						.withTreeHeight(hashTreeAddress.getTreeHeight())
+						.withTreeIndex((hashTreeAddress.getTreeIndex() - 1) / 2)
+						.withKeyAndMask(hashTreeAddress.getKeyAndMask()).build();
+				node[1] = randomizeHash(signature.getAuthPath().get(k), node[0], hashTreeAddress);
+				node[1] = new XMSSNode(node[1].getHeight() + 1, node[1].getValue());
+			}
+			node[0] = node[1];
+		}
+		return node[0];
+	}
+
+	/**
+	 * Derive WOTS+ secret key for specific index as in XMSS ref impl Andreas
+	 * Huelsing.
+	 *
+	 * @param otsHashAddress
+	 * @return WOTS+ secret key at index.
+	 */
+	protected byte[] getWOTSPlusSecretKey(OTSHashAddress otsHashAddress) {
+		otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder()
+				.withLayerAddress(otsHashAddress.getLayerAddress()).withTreeAddress(otsHashAddress.getTreeAddress())
+				.withOTSAddress(otsHashAddress.getOTSAddress()).build();
+		return khf.PRF(privateKey.getSecretKeySeed(), otsHashAddress.toByteArray());
+	}
+
+	/**
+	 * Getter XMSS params.
+	 *
+	 * @return XMSS params.
+	 */
+	public XMSSParameters getParams() {
+		return params;
+	}
+
+	/**
+	 * Getter WOTS+.
+	 *
+	 * @return WOTS+ instance.
+	 */
+	protected WOTSPlus getWOTSPlus() {
+		return wotsPlus;
+	}
+
+	protected KeyedHashFunctions getKhf() {
+		return khf;
+	}
+
+	/**
+	 * Getter XMSS root.
+	 *
+	 * @return Root of binary tree.
+	 */
+	public byte[] getRoot() {
+		return privateKey.getRoot();
+	}
+
+	protected void setRoot(byte[] root) {
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withIndex(privateKey.getIndex())
+					.withSecretKeySeed(privateKey.getSecretKeySeed()).withSecretKeyPRF(privateKey.getSecretKeyPRF())
+					.withPublicSeed(getPublicSeed()).withRoot(root).withBDSState(privateKey.getBDSState()).build();
+			publicKey = new XMSSPublicKeyParameters.Builder(params).withRoot(root).withPublicSeed(getPublicSeed())
+					.build();
+		} catch (ParseException ex) {
+			/* should not be possible */
+			ex.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Getter XMSS index.
+	 *
+	 * @return Index.
+	 */
+	public int getIndex() {
+		return privateKey.getIndex();
+	}
+
+	protected void setIndex(int index) {
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withIndex(index)
+					.withSecretKeySeed(privateKey.getSecretKeySeed()).withSecretKeyPRF(privateKey.getSecretKeyPRF())
+					.withPublicSeed(privateKey.getPublicSeed()).withRoot(privateKey.getRoot())
+					.withBDSState(privateKey.getBDSState()).build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Getter XMSS public seed.
+	 *
+	 * @return Public seed.
+	 */
+	public byte[] getPublicSeed() {
+		return privateKey.getPublicSeed();
+	}
+
+	protected void setPublicSeed(byte[] publicSeed) {
+		try {
+			privateKey = new XMSSPrivateKeyParameters.Builder(params).withIndex(privateKey.getIndex())
+					.withSecretKeySeed(privateKey.getSecretKeySeed()).withSecretKeyPRF(privateKey.getSecretKeyPRF())
+					.withPublicSeed(publicSeed).withRoot(getRoot()).withBDSState(privateKey.getBDSState()).build();
+			publicKey = new XMSSPublicKeyParameters.Builder(params).withRoot(getRoot()).withPublicSeed(publicSeed)
+					.build();
+		} catch (ParseException ex) {
+			/* should not happen */
+			ex.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+		wotsPlus.importKeys(new byte[params.getDigestSize()], publicSeed);
+	}
+
+	protected BDS getBDSState() {
+		return privateKey.getBDSState();
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSAddress.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSAddress.java
new file mode 100644
index 0000000..697a15a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSAddress.java
@@ -0,0 +1,80 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import org.bouncycastle.pqc.crypto.xmss.XMSSUtil;
+
+/**
+ * XMSS address.
+ *
+ */
+public abstract class XMSSAddress {
+
+	private final int layerAddress;
+	private final long treeAddress;
+	private final int type;
+	private final int keyAndMask;
+
+	protected XMSSAddress(Builder builder) {
+		layerAddress = builder.layerAddress;
+		treeAddress = builder.treeAddress;
+		type = builder.type;
+		keyAndMask = builder.keyAndMask;
+	}
+
+	protected static abstract class Builder<T extends Builder> {
+
+		/* mandatory */
+		private final int type;
+		/* optional */
+		private int layerAddress = 0;
+		private long treeAddress = 0L;
+		private int keyAndMask = 0;
+
+		protected Builder(int type) {
+			super();
+			this.type = type;
+		}
+
+		protected T withLayerAddress(int val) {
+			layerAddress = val;
+			return getThis();
+		}
+		
+		protected T withTreeAddress(long val) {
+			treeAddress = val;
+			return getThis();
+		}
+		
+		protected T withKeyAndMask(int val) {
+			keyAndMask = val;
+			return getThis();
+		}
+		
+		protected abstract XMSSAddress build();
+		protected abstract T getThis();
+	}
+
+	protected byte[] toByteArray() {
+		byte[] byteRepresentation = new byte[32];
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, layerAddress, 0);
+		XMSSUtil.longToBytesBigEndianOffset(byteRepresentation, treeAddress, 4);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, type, 12);
+		XMSSUtil.intToBytesBigEndianOffset(byteRepresentation, keyAndMask, 28);
+		return byteRepresentation;
+	}
+
+	protected final int getLayerAddress() {
+		return layerAddress;
+	}
+
+	protected final long getTreeAddress() {
+		return treeAddress;
+	}
+
+	public final int getType() {
+		return type;
+	}
+
+	public final int getKeyAndMask() {
+		return keyAndMask;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMT.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMT.java
new file mode 100644
index 0000000..c3839be
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMT.java
@@ -0,0 +1,439 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.text.ParseException;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * XMSS^MT.
+ *
+ */
+public final class XMSSMT {
+
+	private XMSSMTParameters params;
+	private XMSS xmss;
+	private SecureRandom prng;
+	private KeyedHashFunctions khf;
+	private XMSSMTPrivateKeyParameters privateKey;
+	private XMSSMTPublicKeyParameters publicKey;
+
+	/**
+	 * XMSSMT constructor...
+	 *
+	 * @param params
+	 *            XMSSMTParameters.
+	 */
+	public XMSSMT(XMSSMTParameters params) {
+		super();
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		this.params = params;
+		xmss = params.getXMSS();
+		prng = params.getXMSS().getParams().getPRNG();
+		khf = xmss.getKhf();
+		try {
+			privateKey = new XMSSMTPrivateKeyParameters.Builder(params).build();
+			publicKey = new XMSSMTPublicKeyParameters.Builder(params).build();
+		} catch (ParseException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Generate a new XMSSMT private key / public key pair.
+	 * 
+	 */
+	public void generateKeys() {
+		/* generate XMSSMT private key */
+		privateKey = generatePrivateKey();
+
+		/* init global xmss */
+		XMSSPrivateKeyParameters xmssPrivateKey = null;
+		XMSSPublicKeyParameters xmssPublicKey = null;
+		try {
+			xmssPrivateKey = new XMSSPrivateKeyParameters.Builder(xmss.getParams())
+					.withSecretKeySeed(privateKey.getSecretKeySeed()).withSecretKeyPRF(privateKey.getSecretKeyPRF())
+					.withPublicSeed(privateKey.getPublicSeed()).withBDSState(new BDS(xmss)).build();
+			xmssPublicKey = new XMSSPublicKeyParameters.Builder(xmss.getParams()).withPublicSeed(getPublicSeed())
+					.build();
+		} catch (ParseException ex) {
+			/* should not be possible */
+			ex.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+
+		/* import to xmss */
+		try {
+			xmss.importState(xmssPrivateKey.toByteArray(), xmssPublicKey.toByteArray());
+		} catch (ParseException e) {
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		/* get root */
+		int rootLayerIndex = params.getLayers() - 1;
+		OTSHashAddress otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withLayerAddress(rootLayerIndex)
+				.build();
+
+		/* store BDS instance of root xmss instance */
+		BDS bdsRoot = new BDS(xmss);
+		XMSSNode root = bdsRoot.initialize(otsHashAddress);
+		getBDSState().put(rootLayerIndex, bdsRoot);
+		xmss.setRoot(root.getValue());
+
+		/* set XMSS^MT root / create public key */
+		try {
+			privateKey = new XMSSMTPrivateKeyParameters.Builder(params).withSecretKeySeed(privateKey.getSecretKeySeed())
+					.withSecretKeyPRF(privateKey.getSecretKeyPRF()).withPublicSeed(privateKey.getPublicSeed())
+					.withRoot(xmss.getRoot()).withBDSState(privateKey.getBDSState()).build();
+			publicKey = new XMSSMTPublicKeyParameters.Builder(params).withRoot(root.getValue())
+					.withPublicSeed(getPublicSeed()).build();
+		} catch (ParseException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+	}
+
+	private XMSSMTPrivateKeyParameters generatePrivateKey() {
+		int n = params.getDigestSize();
+		byte[] secretKeySeed = new byte[n];
+		prng.nextBytes(secretKeySeed);
+		byte[] secretKeyPRF = new byte[n];
+		prng.nextBytes(secretKeyPRF);
+		byte[] publicSeed = new byte[n];
+		prng.nextBytes(publicSeed);
+
+		XMSSMTPrivateKeyParameters privateKey = null;
+		try {
+			privateKey = new XMSSMTPrivateKeyParameters.Builder(params).withSecretKeySeed(secretKeySeed)
+					.withSecretKeyPRF(secretKeyPRF).withPublicSeed(publicSeed)
+					.withBDSState(this.privateKey.getBDSState()).build();
+		} catch (ParseException ex) {
+			/* should not be possible */
+			ex.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+		return privateKey;
+	}
+
+	/**
+	 * Import XMSSMT private key / public key pair.
+	 * 
+	 * @param privateKey
+	 *            XMSSMT private key.
+	 * @param publicKey
+	 *            XMSSMT public key.
+	 * @throws ParseException
+	 * @throws ClassNotFoundException
+	 * @throws IOException
+	 */
+	public void importState(byte[] privateKey, byte[] publicKey)
+			throws ParseException, ClassNotFoundException, IOException {
+		if (privateKey == null) {
+			throw new NullPointerException("privateKey == null");
+		}
+		if (publicKey == null) {
+			throw new NullPointerException("publicKey == null");
+		}
+		XMSSMTPrivateKeyParameters xmssMTPrivateKey = new XMSSMTPrivateKeyParameters.Builder(params)
+				.withPrivateKey(privateKey, xmss).build();
+		XMSSMTPublicKeyParameters xmssMTPublicKey = new XMSSMTPublicKeyParameters.Builder(params)
+				.withPublicKey(publicKey).build();
+		if (!XMSSUtil.compareByteArray(xmssMTPrivateKey.getRoot(), xmssMTPublicKey.getRoot())) {
+			throw new IllegalStateException("root of private key and public key do not match");
+		}
+		if (!XMSSUtil.compareByteArray(xmssMTPrivateKey.getPublicSeed(), xmssMTPublicKey.getPublicSeed())) {
+			throw new IllegalStateException("public seed of private key and public key do not match");
+		}
+
+		/* init global xmss */
+		XMSSPrivateKeyParameters xmssPrivateKey = new XMSSPrivateKeyParameters.Builder(xmss.getParams())
+				.withSecretKeySeed(xmssMTPrivateKey.getSecretKeySeed())
+				.withSecretKeyPRF(xmssMTPrivateKey.getSecretKeyPRF()).withPublicSeed(xmssMTPrivateKey.getPublicSeed())
+				.withRoot(xmssMTPrivateKey.getRoot()).withBDSState(new BDS(xmss)).build();
+		XMSSPublicKeyParameters xmssPublicKey = new XMSSPublicKeyParameters.Builder(xmss.getParams())
+				.withRoot(xmssMTPrivateKey.getRoot()).withPublicSeed(getPublicSeed()).build();
+
+		/* import to xmss */
+		xmss.importState(xmssPrivateKey.toByteArray(), xmssPublicKey.toByteArray());
+		this.privateKey = xmssMTPrivateKey;
+		this.publicKey = xmssMTPublicKey;
+	}
+
+	/**
+	 * Sign message.
+	 *
+	 * @param message
+	 *            Message to sign.
+	 * @return XMSSMT signature on digest of message.
+	 */
+	public byte[] sign(byte[] message) {
+		if (message == null) {
+			throw new NullPointerException("message == null");
+		}
+		if (getBDSState().isEmpty()) {
+			throw new IllegalStateException("not initialized");
+		}
+		// privateKey.increaseIndex(this);
+		long globalIndex = getIndex();
+		int totalHeight = params.getHeight();
+		int xmssHeight = xmss.getParams().getHeight();
+		if (!XMSSUtil.isIndexValid(totalHeight, globalIndex)) {
+			throw new IllegalArgumentException("index out of bounds");
+		}
+
+		/* compress message */
+		byte[] random = khf.PRF(privateKey.getSecretKeyPRF(), XMSSUtil.toBytesBigEndian(globalIndex, 32));
+		byte[] concatenated = XMSSUtil.concat(random, privateKey.getRoot(),
+				XMSSUtil.toBytesBigEndian(globalIndex, params.getDigestSize()));
+		byte[] messageDigest = khf.HMsg(concatenated, message);
+
+		XMSSMTSignature signature = null;
+		try {
+			signature = new XMSSMTSignature.Builder(params).withIndex(globalIndex).withRandom(random).build();
+		} catch (ParseException ex) {
+			/* should not be possible */
+			ex.printStackTrace();
+		}
+
+		/* layer 0 */
+		long indexTree = XMSSUtil.getTreeIndex(globalIndex, xmssHeight);
+		int indexLeaf = XMSSUtil.getLeafIndex(globalIndex, xmssHeight);
+
+		/* reset xmss */
+		xmss.setIndex(indexLeaf);
+		xmss.setPublicSeed(getPublicSeed());
+
+		/* create signature with XMSS tree on layer 0 */
+
+		/* adjust addresses */
+		OTSHashAddress otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withTreeAddress(indexTree)
+				.withOTSAddress(indexLeaf).build();
+
+		/* sign message digest */
+		WOTSPlusSignature wotsPlusSignature = xmss.wotsSign(messageDigest, otsHashAddress);
+		/* get authentication path from BDS */
+		if (getBDSState().get(0) == null || indexLeaf == 0) {
+			getBDSState().put(0, new BDS(xmss));
+			getBDSState().get(0).initialize(otsHashAddress);
+		}
+
+		XMSSReducedSignature reducedSignature = null;
+		try {
+			reducedSignature = new XMSSReducedSignature.Builder(xmss.getParams())
+					.withWOTSPlusSignature(wotsPlusSignature).withAuthPath(getBDSState().get(0).getAuthenticationPath())
+					.build();
+		} catch (ParseException ex) {
+			/* should never happen */
+			ex.printStackTrace();
+		}
+		signature.getReducedSignatures().add(reducedSignature);
+
+		/* prepare authentication path for next leaf */
+		if (indexLeaf < ((1 << xmssHeight) - 1)) {
+			getBDSState().get(0).nextAuthenticationPath(otsHashAddress);
+		}
+
+		/* loop over remaining layers */
+		for (int layer = 1; layer < params.getLayers(); layer++) {
+			/* get root of layer - 1 */
+			XMSSNode root = getBDSState().get(layer - 1).getRoot();
+
+			indexLeaf = XMSSUtil.getLeafIndex(indexTree, xmssHeight);
+			indexTree = XMSSUtil.getTreeIndex(indexTree, xmssHeight);
+			xmss.setIndex(indexLeaf);
+
+			/* adjust addresses */
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withLayerAddress(layer)
+					.withTreeAddress(indexTree).withOTSAddress(indexLeaf).build();
+
+			/* sign root digest of layer - 1 */
+			wotsPlusSignature = xmss.wotsSign(root.getValue(), otsHashAddress);
+			/* get authentication path from BDS */
+			if (getBDSState().get(layer) == null || XMSSUtil.isNewBDSInitNeeded(globalIndex, xmssHeight, layer)) {
+				getBDSState().put(layer, new BDS(xmss));
+				getBDSState().get(layer).initialize(otsHashAddress);
+			}
+			try {
+				reducedSignature = new XMSSReducedSignature.Builder(xmss.getParams())
+						.withWOTSPlusSignature(wotsPlusSignature)
+						.withAuthPath(getBDSState().get(layer).getAuthenticationPath()).build();
+			} catch (ParseException ex) {
+				/* should never happen */
+				ex.printStackTrace();
+			}
+			signature.getReducedSignatures().add(reducedSignature);
+
+			/* prepare authentication path for next leaf */
+			if (indexLeaf < ((1 << xmssHeight) - 1)
+					&& XMSSUtil.isNewAuthenticationPathNeeded(globalIndex, xmssHeight, layer)) {
+				getBDSState().get(layer).nextAuthenticationPath(otsHashAddress);
+			}
+		}
+
+		/* update private key */
+		try {
+			privateKey = new XMSSMTPrivateKeyParameters.Builder(params).withIndex(globalIndex + 1)
+					.withSecretKeySeed(privateKey.getSecretKeySeed()).withSecretKeyPRF(privateKey.getSecretKeyPRF())
+					.withPublicSeed(privateKey.getPublicSeed()).withRoot(privateKey.getRoot())
+					.withBDSState(privateKey.getBDSState()).build();
+		} catch (ParseException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		} catch (IOException e) {
+			/* should not be possible */
+			e.printStackTrace();
+		}
+		return signature.toByteArray();
+	}
+
+	/**
+	 * Verify an XMSSMT signature.
+	 * 
+	 * @param message
+	 *            Message.
+	 * @param signature
+	 *            XMSSMT signature.
+	 * @param publicKey
+	 *            XMSSMT public key.
+	 * @return true if signature is valid false else.
+	 * @throws ParseException
+	 */
+	public boolean verifySignature(byte[] message, byte[] signature, byte[] publicKey) throws ParseException {
+		if (message == null) {
+			throw new NullPointerException("message == null");
+		}
+		if (signature == null) {
+			throw new NullPointerException("signature == null");
+		}
+		if (publicKey == null) {
+			throw new NullPointerException("publicKey == null");
+		}
+		/* (re)create compressed message */
+		XMSSMTSignature sig = new XMSSMTSignature.Builder(params).withSignature(signature).build();
+		XMSSMTPublicKeyParameters pubKey = new XMSSMTPublicKeyParameters.Builder(params).withPublicKey(publicKey)
+				.build();
+
+		byte[] concatenated = XMSSUtil.concat(sig.getRandom(), pubKey.getRoot(),
+				XMSSUtil.toBytesBigEndian(sig.getIndex(), params.getDigestSize()));
+		byte[] messageDigest = khf.HMsg(concatenated, message);
+
+		long globalIndex = sig.getIndex();
+		int xmssHeight = xmss.getParams().getHeight();
+		long indexTree = XMSSUtil.getTreeIndex(globalIndex, xmssHeight);
+		int indexLeaf = XMSSUtil.getLeafIndex(globalIndex, xmssHeight);
+
+		/* adjust xmss */
+		xmss.setIndex(indexLeaf);
+		xmss.setPublicSeed(pubKey.getPublicSeed());
+
+		/* prepare addresses */
+		OTSHashAddress otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withTreeAddress(indexTree)
+				.withOTSAddress(indexLeaf).build();
+
+		/* get root node on layer 0 */
+		XMSSReducedSignature xmssMTSignature = sig.getReducedSignatures().get(0);
+		XMSSNode rootNode = xmss.getRootNodeFromSignature(messageDigest, xmssMTSignature, otsHashAddress);
+		for (int layer = 1; layer < params.getLayers(); layer++) {
+			xmssMTSignature = sig.getReducedSignatures().get(layer);
+			indexLeaf = XMSSUtil.getLeafIndex(indexTree, xmssHeight);
+			indexTree = XMSSUtil.getTreeIndex(indexTree, xmssHeight);
+			xmss.setIndex(indexLeaf);
+
+			/* adjust address */
+			otsHashAddress = (OTSHashAddress) new OTSHashAddress.Builder().withLayerAddress(layer)
+					.withTreeAddress(indexTree).withOTSAddress(indexLeaf).build();
+
+			/* get root node */
+			rootNode = xmss.getRootNodeFromSignature(rootNode.getValue(), xmssMTSignature, otsHashAddress);
+		}
+
+		/* compare roots */
+		return XMSSUtil.compareByteArray(rootNode.getValue(), pubKey.getRoot());
+	}
+
+	/**
+	 * Export XMSSMT private key.
+	 *
+	 * @return XMSSMT private key.
+	 */
+	public byte[] exportPrivateKey() {
+		return privateKey.toByteArray();
+	}
+
+	/**
+	 * Export XMSSMT public key.
+	 *
+	 * @return XMSSMT public key.
+	 */
+	public byte[] exportPublicKey() {
+		return publicKey.toByteArray();
+	}
+
+	/**
+	 * Getter XMSSMT params.
+	 *
+	 * @return XMSSMT params.
+	 */
+	public XMSSMTParameters getParams() {
+		return params;
+	}
+
+	/**
+	 * Getter XMSSMT index.
+	 *
+	 * @return XMSSMT index.
+	 */
+	public long getIndex() {
+		return privateKey.getIndex();
+	}
+
+	/**
+	 * Getter public seed.
+	 *
+	 * @return Public seed.
+	 */
+	public byte[] getPublicSeed() {
+		return privateKey.getPublicSeed();
+	}
+
+	protected Map<Integer, BDS> getBDSState() {
+		return privateKey.getBDSState();
+	}
+
+	protected XMSS getXMSS() {
+		return xmss;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTParameters.java
new file mode 100644
index 0000000..0ed47bd
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTParameters.java
@@ -0,0 +1,106 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.security.SecureRandom;
+
+import org.bouncycastle.crypto.Digest;
+
+/**
+ * XMSS^MT Parameters.
+ *
+ */
+public final class XMSSMTParameters {
+
+	private final XMSSOid oid;
+	private final XMSS xmss;
+	private final int height;
+	private final int layers;
+
+	/**
+	 * XMSSMT constructor...
+	 * 
+	 * @param height
+	 *            Height of tree.
+	 * @param layers
+	 *            Amount of layers.
+	 * @param digest
+	 *            Digest to use.
+	 * @param prng
+	 *            Secure random to use.
+	 */
+	public XMSSMTParameters(int height, int layers, Digest digest, SecureRandom prng) {
+		super();
+		this.height = height;
+		this.layers = layers;
+		this.xmss = new XMSS(new XMSSParameters(xmssTreeHeight(height, layers), digest, prng));
+		oid = DefaultXMSSMTOid.lookup(getDigest().getAlgorithmName(), getDigestSize(), getWinternitzParameter(),
+				getLen(), getHeight(), layers);
+		/*
+		 * if (oid == null) { throw new InvalidParameterException(); }
+		 */
+	}
+
+	private static int xmssTreeHeight(int height, int layers) throws IllegalArgumentException {
+		if (height < 2) {
+			throw new IllegalArgumentException("totalHeight must be > 1");
+		}
+		if (height % layers != 0) {
+			throw new IllegalArgumentException("layers must divide totalHeight without remainder");
+		}
+		if (height / layers == 1) {
+			throw new IllegalArgumentException("height / layers must be greater than 1");
+		}
+		return height / layers;
+	}
+
+	/**
+	 * Getter height.
+	 * 
+	 * @return XMSSMT height.
+	 */
+	public int getHeight() {
+		return height;
+	}
+
+	/**
+	 * Getter layers.
+	 * 
+	 * @return XMSSMT layers.
+	 */
+	public int getLayers() {
+		return layers;
+	}
+
+	protected XMSS getXMSS() {
+		return xmss;
+	}
+
+	protected WOTSPlus getWOTSPlus() {
+		return xmss.getWOTSPlus();
+	}
+
+	protected Digest getDigest() {
+		return xmss.getParams().getDigest();
+	}
+
+	/**
+	 * Getter digest size.
+	 * 
+	 * @return Digest size.
+	 */
+	public int getDigestSize() {
+		return xmss.getParams().getDigestSize();
+	}
+
+	/**
+	 * Getter Winternitz parameter.
+	 * 
+	 * @return Winternitz parameter.
+	 */
+	public int getWinternitzParameter() {
+		return xmss.getParams().getWinternitzParameter();
+	}
+
+	protected int getLen() {
+		return xmss.getWOTSPlus().getParams().getLen();
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTPrivateKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTPrivateKeyParameters.java
new file mode 100644
index 0000000..d1bb7c6
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTPrivateKeyParameters.java
@@ -0,0 +1,284 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.IOException;
+import java.text.ParseException;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * XMSSMT Private Key.
+ *
+ */
+public final class XMSSMTPrivateKeyParameters implements XMSSStoreableObjectInterface {
+
+	private final XMSSMTParameters params;
+	private final long index;
+	private final byte[] secretKeySeed;
+	private final byte[] secretKeyPRF;
+	private final byte[] publicSeed;
+	private final byte[] root;
+	private final Map<Integer, BDS> bdsState;
+
+	private XMSSMTPrivateKeyParameters(Builder builder) throws ParseException, ClassNotFoundException, IOException {
+		super();
+		params = builder.params;
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		int n = params.getDigestSize();
+		byte[] privateKey = builder.privateKey;
+		if (privateKey != null) {
+			if (builder.xmss == null) {
+				throw new NullPointerException("xmss == null");
+			}
+			/* import */
+			int totalHeight = params.getHeight();
+			int indexSize = (int) Math.ceil(totalHeight / (double) 8);
+			int secretKeySize = n;
+			int secretKeyPRFSize = n;
+			int publicSeedSize = n;
+			int rootSize = n;
+			/*
+			int totalSize = indexSize + secretKeySize + secretKeyPRFSize + publicSeedSize + rootSize;
+			if (privateKey.length != totalSize) {
+				throw new ParseException("private key has wrong size", 0);
+			}
+			*/
+			int position = 0;
+			index = XMSSUtil.bytesToXBigEndian(privateKey, position, indexSize);
+			if (!XMSSUtil.isIndexValid(totalHeight, index)) {
+				throw new ParseException("index out of bounds", 0);
+			}
+			position += indexSize;
+			secretKeySeed = XMSSUtil.extractBytesAtOffset(privateKey, position, secretKeySize);
+			position += secretKeySize;
+			secretKeyPRF = XMSSUtil.extractBytesAtOffset(privateKey, position, secretKeyPRFSize);
+			position += secretKeyPRFSize;
+			publicSeed = XMSSUtil.extractBytesAtOffset(privateKey, position, publicSeedSize);
+			position += publicSeedSize;
+			root = XMSSUtil.extractBytesAtOffset(privateKey, position, rootSize);
+			position += rootSize;
+			/* import BDS state */
+			byte[] bdsStateBinary = XMSSUtil.extractBytesAtOffset(privateKey, position, privateKey.length - position);
+			@SuppressWarnings("unchecked")
+			Map<Integer, BDS> bdsImport = (TreeMap<Integer, BDS>) XMSSUtil.deserialize(bdsStateBinary);
+			for (Integer key : bdsImport.keySet()) {
+				BDS bds = bdsImport.get(key);
+				bds.setXMSS(builder.xmss);
+				bds.validate();
+			}
+			bdsState = bdsImport;
+		} else {
+			/* set */
+			index = builder.index;
+			byte[] tmpSecretKeySeed = builder.secretKeySeed;
+			if (tmpSecretKeySeed != null) {
+				if (tmpSecretKeySeed.length != n) {
+					throw new IllegalArgumentException("size of secretKeySeed needs to be equal size of digest");
+				}
+				secretKeySeed = tmpSecretKeySeed;
+			} else {
+				secretKeySeed = new byte[n];
+			}
+			byte[] tmpSecretKeyPRF = builder.secretKeyPRF;
+			if (tmpSecretKeyPRF != null) {
+				if (tmpSecretKeyPRF.length != n) {
+					throw new IllegalArgumentException("size of secretKeyPRF needs to be equal size of digest");
+				}
+				secretKeyPRF = tmpSecretKeyPRF;
+			} else {
+				secretKeyPRF = new byte[n];
+			}
+			byte[] tmpPublicSeed = builder.publicSeed;
+			if (tmpPublicSeed != null) {
+				if (tmpPublicSeed.length != n) {
+					throw new IllegalArgumentException("size of publicSeed needs to be equal size of digest");
+				}
+				publicSeed = tmpPublicSeed;
+			} else {
+				publicSeed = new byte[n];
+			}
+			byte[] tmpRoot = builder.root;
+			if (tmpRoot != null) {
+				if (tmpRoot.length != n) {
+					throw new IllegalArgumentException("size of root needs to be equal size of digest");
+				}
+				root = tmpRoot;
+			} else {
+				root = new byte[n];
+			}
+			Map<Integer, BDS> tmpBDSState = builder.bdsState;
+			if (tmpBDSState != null) {
+				bdsState = tmpBDSState;
+			} else {
+				bdsState = new TreeMap<Integer, BDS>();
+			}
+		}
+	}
+
+	public static class Builder {
+
+		/* mandatory */
+		private final XMSSMTParameters params;
+		/* optional */
+		private long index = 0L;
+		private byte[] secretKeySeed = null;
+		private byte[] secretKeyPRF = null;
+		private byte[] publicSeed = null;
+		private byte[] root = null;
+		private Map<Integer, BDS> bdsState = null;
+		private byte[] privateKey = null;
+		private XMSS xmss = null;
+
+		public Builder(XMSSMTParameters params) {
+			super();
+			this.params = params;
+		}
+
+		public Builder withIndex(long val) {
+			index = val;
+			return this;
+		}
+
+		public Builder withSecretKeySeed(byte[] val) {
+			secretKeySeed = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withSecretKeyPRF(byte[] val) {
+			secretKeyPRF = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withPublicSeed(byte[] val) {
+			publicSeed = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withRoot(byte[] val) {
+			root = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withBDSState(Map<Integer, BDS> val) {
+			bdsState = val;
+			return this;
+		}
+
+		public Builder withPrivateKey(byte[] privateKeyVal, XMSS xmssVal) {
+			privateKey = XMSSUtil.cloneArray(privateKeyVal);
+			xmss = xmssVal;
+			return this;
+		}
+
+		public XMSSMTPrivateKeyParameters build() throws ParseException, ClassNotFoundException, IOException {
+			return new XMSSMTPrivateKeyParameters(this);
+		}
+	}
+
+	public byte[] toByteArray() {
+		/* index || secretKeySeed || secretKeyPRF || publicSeed || root */
+		int n = params.getDigestSize();
+		int indexSize = (int) Math.ceil(params.getHeight() / (double) 8);
+		int secretKeySize = n;
+		int secretKeyPRFSize = n;
+		int publicSeedSize = n;
+		int rootSize = n;
+		int totalSize = indexSize + secretKeySize + secretKeyPRFSize + publicSeedSize + rootSize;
+		byte[] out = new byte[totalSize];
+		int position = 0;
+		/* copy index */
+		byte[] indexBytes = XMSSUtil.toBytesBigEndian(index, indexSize);
+		XMSSUtil.copyBytesAtOffset(out, indexBytes, position);
+		position += indexSize;
+		/* copy secretKeySeed */
+		XMSSUtil.copyBytesAtOffset(out, secretKeySeed, position);
+		position += secretKeySize;
+		/* copy secretKeyPRF */
+		XMSSUtil.copyBytesAtOffset(out, secretKeyPRF, position);
+		position += secretKeyPRFSize;
+		/* copy publicSeed */
+		XMSSUtil.copyBytesAtOffset(out, publicSeed, position);
+		position += publicSeedSize;
+		/* copy root */
+		XMSSUtil.copyBytesAtOffset(out, root, position);
+		/* concatenate bdsState */
+		byte[] bdsStateOut = null;
+		try {
+			bdsStateOut = XMSSUtil.serialize(bdsState);
+		} catch (IOException e) {
+			e.printStackTrace();
+			throw new RuntimeException("error serializing bds state");
+		}
+		return XMSSUtil.concat(out, bdsStateOut);
+	}
+
+	/*
+	protected void increaseIndex(XMSSMT mt) {
+		if (mt == null) {
+			throw new NullPointerException("mt == null");
+		}
+		ZonedDateTime currentTime = ZonedDateTime.now(ZoneOffset.UTC);
+		long differenceHours = Duration.between(lastUsage, currentTime).toHours();
+		if (differenceHours >= 24) {
+			mt.getXMSS().setPublicSeed(getPublicSeed());
+
+			Map<Integer, BDS> bdsStates = mt.getBDS();
+			int xmssHeight = params.getXMSS().getParams().getHeight();
+			long keyIncreaseCount = differenceHours * indexIncreaseCountPerHour;
+			long oldGlobalIndex = getIndex();
+			long newGlobalIndex = oldGlobalIndex + keyIncreaseCount;
+			long oldIndexTree = XMSSUtil.getTreeIndex(oldGlobalIndex, xmssHeight);
+			long newIndexTree = XMSSUtil.getTreeIndex(newGlobalIndex, xmssHeight);
+			int newIndexLeaf = XMSSUtil.getLeafIndex(newGlobalIndex, xmssHeight);
+
+			// adjust bds instances
+			for (int layer = 0; layer < params.getLayers(); layer++) {
+				OTSHashAddress otsHashAddress = new OTSHashAddress();
+				otsHashAddress.setLayerAddress(layer);
+				otsHashAddress.setTreeAddress(newIndexTree);
+
+				if (newIndexLeaf != 0) {
+					if (oldIndexTree != newIndexTree || bdsStates.get(layer) == null) {
+						bdsStates.put(layer, new BDS(mt.getXMSS()));
+						bdsStates.get(layer).initialize(otsHashAddress);
+					}
+					for (int indexLeaf = bdsStates.get(layer).getIndex(); indexLeaf < newIndexLeaf; indexLeaf++) {
+						if (indexLeaf < ((1 << xmssHeight) - 1)) {
+							bdsStates.get(layer).nextAuthenticationPath(otsHashAddress);
+						}
+					}
+				}
+				oldIndexTree = XMSSUtil.getTreeIndex(oldIndexTree, xmssHeight);
+				newIndexLeaf = XMSSUtil.getLeafIndex(newIndexTree, xmssHeight);
+				newIndexTree = XMSSUtil.getTreeIndex(newIndexTree, xmssHeight);
+			}
+			setIndex(newGlobalIndex);
+		}
+	}
+	*/
+
+	public long getIndex() {
+		return index;
+	}
+
+	public byte[] getSecretKeySeed() {
+		return XMSSUtil.cloneArray(secretKeySeed);
+	}
+
+	public byte[] getSecretKeyPRF() {
+		return XMSSUtil.cloneArray(secretKeyPRF);
+	}
+
+	public byte[] getPublicSeed() {
+		return XMSSUtil.cloneArray(publicSeed);
+	}
+
+	public byte[] getRoot() {
+		return XMSSUtil.cloneArray(root);
+	}
+	
+	public Map<Integer, BDS> getBDSState() {
+		return bdsState;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTPublicKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTPublicKeyParameters.java
new file mode 100644
index 0000000..87b565e
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTPublicKeyParameters.java
@@ -0,0 +1,129 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.text.ParseException;
+
+/**
+ * XMSSMT Public Key.
+ *
+ */
+public final class XMSSMTPublicKeyParameters implements XMSSStoreableObjectInterface {
+
+	private final XMSSMTParameters params;
+	// private final int oid;
+	private final byte[] root;
+	private final byte[] publicSeed;
+
+	private XMSSMTPublicKeyParameters(Builder builder) throws ParseException {
+		super();
+		params = builder.params;
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		int n = params.getDigestSize();
+		byte[] publicKey = builder.publicKey;
+		if (publicKey != null) {
+			/* import */
+			// int oidSize = 4;
+			int rootSize = n;
+			int publicSeedSize = n;
+			int totalSize = rootSize + publicSeedSize;
+			if (publicKey.length != totalSize) {
+				throw new ParseException("public key has wrong size", 0);
+			}
+			int position = 0;
+			/*
+			 * oid = XMSSUtil.bytesToIntBigEndian(in, position); if (oid !=
+			 * params.getOid().getOid()) { throw new ParseException("wrong oid",
+			 * 0); } position += oidSize;
+			 */
+			root = XMSSUtil.extractBytesAtOffset(publicKey, position, rootSize);
+			position += rootSize;
+			publicSeed = XMSSUtil.extractBytesAtOffset(publicKey, position, publicSeedSize);
+		} else {
+			/* set */
+			byte[] tmpRoot = builder.root;
+			if (tmpRoot != null) {
+				if (tmpRoot.length != n) {
+					throw new IllegalArgumentException("length of root must be equal to length of digest");
+				}
+				root = tmpRoot;
+			} else {
+				root = new byte[n];
+			}
+			byte[] tmpPublicSeed = builder.publicSeed;
+			if (tmpPublicSeed != null) {
+				if (tmpPublicSeed.length != n) {
+					throw new IllegalArgumentException("length of publicSeed must be equal to length of digest");
+				}
+				publicSeed = tmpPublicSeed;
+			} else {
+				publicSeed = new byte[n];
+			}
+		}
+	}
+
+	public static class Builder {
+
+		/* mandatory */
+		private final XMSSMTParameters params;
+		/* optional */
+		private byte[] root = null;
+		private byte[] publicSeed = null;
+		private byte[] publicKey = null;
+
+		public Builder(XMSSMTParameters params) {
+			super();
+			this.params = params;
+		}
+
+		public Builder withRoot(byte[] val) {
+			root = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withPublicSeed(byte[] val) {
+			publicSeed = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withPublicKey(byte[] val) {
+			publicKey = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public XMSSMTPublicKeyParameters build() throws ParseException {
+			return new XMSSMTPublicKeyParameters(this);
+		}
+	}
+
+	public byte[] toByteArray() {
+		/* oid || root || seed */
+		int n = params.getDigestSize();
+		// int oidSize = 4;
+		int rootSize = n;
+		int publicSeedSize = n;
+		int totalSize = rootSize + publicSeedSize;
+		// int totalSize = oidSize + rootSize + publicSeedSize;
+		byte[] out = new byte[totalSize];
+		int position = 0;
+		/* copy oid */
+		/*
+		 * XMSSUtil.intToBytesBigEndianOffset(out, oid, position); position +=
+		 * oidSize;
+		 */
+		/* copy root */
+		XMSSUtil.copyBytesAtOffset(out, root, position);
+		position += rootSize;
+		/* copy public seed */
+		XMSSUtil.copyBytesAtOffset(out, publicSeed, position);
+		return out;
+	}
+
+	public byte[] getRoot() {
+		return XMSSUtil.cloneArray(root);
+	}
+
+	public byte[] getPublicSeed() {
+		return XMSSUtil.cloneArray(publicSeed);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTSignature.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTSignature.java
new file mode 100644
index 0000000..38fc208
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSMTSignature.java
@@ -0,0 +1,152 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * XMSSMT Signature.
+ *
+ */
+public final class XMSSMTSignature implements XMSSStoreableObjectInterface {
+
+	private final XMSSMTParameters params;
+	private final long index;
+	private final byte[] random;
+	private final List<XMSSReducedSignature> reducedSignatures;
+
+	private XMSSMTSignature(Builder builder) throws ParseException {
+		super();
+		params = builder.params;
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		int n = params.getDigestSize();
+		byte[] signature = builder.signature;
+		if (signature != null) {
+			/* import */
+			int len = params.getWOTSPlus().getParams().getLen();
+			int indexSize = (int) Math.ceil(params.getHeight() / (double) 8);
+			int randomSize = n;
+			int reducedSignatureSizeSingle = ((params.getHeight() / params.getLayers()) + len) * n;
+			int reducedSignaturesSizeTotal = reducedSignatureSizeSingle * params.getLayers();
+			int totalSize = indexSize + randomSize + reducedSignaturesSizeTotal;
+			if (signature.length != totalSize) {
+				throw new ParseException("signature has wrong size", 0);
+			}
+			int position = 0;
+			index = XMSSUtil.bytesToXBigEndian(signature, position, indexSize);
+			if (!XMSSUtil.isIndexValid(params.getHeight(), index)) {
+				throw new ParseException("index out of bounds", 0);
+			}
+			position += indexSize;
+			random = XMSSUtil.extractBytesAtOffset(signature, position, randomSize);
+			position += randomSize;
+			reducedSignatures = new ArrayList<XMSSReducedSignature>();
+			while (position < signature.length) {
+				XMSSReducedSignature xmssSig = new XMSSReducedSignature.Builder(params.getXMSS().getParams())
+						.withReducedSignature(XMSSUtil.extractBytesAtOffset(signature, position, reducedSignatureSizeSingle))
+						.build();
+				reducedSignatures.add(xmssSig);
+				position += reducedSignatureSizeSingle;
+			}
+		} else {
+			/* set */
+			index = builder.index;
+			byte[] tmpRandom = builder.random;
+			if (tmpRandom != null) {
+				if (tmpRandom.length != n) {
+					throw new IllegalArgumentException("size of random needs to be equal to size of digest");
+				}
+				random = tmpRandom;
+			} else {
+				random = new byte[n];
+			}
+			List<XMSSReducedSignature> tmpReducedSignatures = builder.reducedSignatures;
+			if (tmpReducedSignatures != null) {
+				reducedSignatures = tmpReducedSignatures;
+			} else {
+				reducedSignatures = new ArrayList<XMSSReducedSignature>();
+			}
+		}
+	}
+
+	public static class Builder {
+		
+		/* mandatory */
+		private final XMSSMTParameters params;
+		/* optional */
+		private long index = 0L;
+		private byte[] random = null;
+		private List<XMSSReducedSignature> reducedSignatures = null;
+		private byte[] signature = null;
+		
+		public Builder(XMSSMTParameters params) {
+			super();
+			this.params = params;
+		}
+		
+		public Builder withIndex(long val) {
+			index = val;
+			return this;
+		}
+		
+		public Builder withRandom(byte[] val) {
+			random = XMSSUtil.cloneArray(val);
+			return this;
+		}
+		
+		public Builder withReducedSignatures(List<XMSSReducedSignature> val) {
+			reducedSignatures = val;
+			return this;
+		}
+
+		public Builder withSignature(byte[] val) {
+			signature = val;
+			return this;
+		}
+
+		public XMSSMTSignature build() throws ParseException {
+			return new XMSSMTSignature(this);
+		}
+	}
+
+	public byte[] toByteArray() {
+		/* index || random || reduced signatures */
+		int n = params.getDigestSize();
+		int len = params.getWOTSPlus().getParams().getLen();
+		int indexSize = (int) Math.ceil(params.getHeight() / (double) 8);
+		int randomSize = n;
+		int reducedSignatureSizeSingle = ((params.getHeight() / params.getLayers()) + len) * n;
+		int reducedSignaturesSizeTotal = reducedSignatureSizeSingle * params.getLayers();
+		int totalSize = indexSize + randomSize + reducedSignaturesSizeTotal;
+		byte[] out = new byte[totalSize];
+		int position = 0;
+		/* copy index */
+		byte[] indexBytes = XMSSUtil.toBytesBigEndian(index, indexSize);
+		XMSSUtil.copyBytesAtOffset(out, indexBytes, position);
+		position += indexSize;
+		/* copy random */
+		XMSSUtil.copyBytesAtOffset(out, random, position);
+		position += randomSize;
+		/* copy reduced signatures */
+		for (XMSSReducedSignature reducedSignature : reducedSignatures) {
+			byte[] signature = reducedSignature.toByteArray();
+			XMSSUtil.copyBytesAtOffset(out, signature, position);
+			position += reducedSignatureSizeSingle;
+		}
+		return out;
+	}
+
+	public long getIndex() {
+		return index;
+	}
+
+	public byte[] getRandom() {
+		return XMSSUtil.cloneArray(random);
+	}
+
+	public List<XMSSReducedSignature> getReducedSignatures() {
+		return reducedSignatures;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSNode.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSNode.java
new file mode 100644
index 0000000..d2acd7a
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSNode.java
@@ -0,0 +1,38 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.Serializable;
+
+/**
+ * Binary tree node.
+ */
+public final class XMSSNode
+    implements Serializable
+{
+
+    private static final long serialVersionUID = 1L;
+
+    private final int height;
+    private final byte[] value;
+
+    protected XMSSNode(int height, byte[] value)
+    {
+        super();
+        this.height = height;
+        this.value = value;
+    }
+
+    public int getHeight()
+    {
+        return height;
+    }
+
+    public byte[] getValue()
+    {
+        return XMSSUtil.cloneArray(value);
+    }
+
+    protected XMSSNode clone()
+    {
+        return new XMSSNode(getHeight(), getValue());
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSOid.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSOid.java
new file mode 100644
index 0000000..64e8281
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSOid.java
@@ -0,0 +1,8 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+public interface XMSSOid {
+
+	int getOid();
+
+	String toString();
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSParameters.java
new file mode 100644
index 0000000..55061a8
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSParameters.java
@@ -0,0 +1,102 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.security.SecureRandom;
+
+import org.bouncycastle.crypto.Digest;
+
+/**
+ * XMSS Parameters.
+ *
+ */
+public final class XMSSParameters {
+
+	private final XMSSOid oid;
+	private final WOTSPlus wotsPlus;
+	private final SecureRandom prng;
+	private final int height;
+	private final int k;
+
+	/**
+	 * XMSS Constructor...
+	 *
+	 * @param height
+	 *            Height of tree.
+	 * @param digest
+	 *            Digest to use.
+	 * @param prng
+	 *            Secure random to use.
+	 */
+	public XMSSParameters(int height, Digest digest, SecureRandom prng) {
+		super();
+		if (height < 2) {
+			throw new IllegalArgumentException("height must be >= 2");
+		}
+		if (digest == null) {
+			throw new NullPointerException("digest == null");
+		}
+		if (prng == null) {
+			throw new NullPointerException("prng == null");
+		}
+		wotsPlus = new WOTSPlus(new WOTSPlusParameters(digest));
+		this.prng = prng;
+		this.height = height;
+		this.k = determineMinK();
+		oid = DefaultXMSSOid.lookup(getDigest().getAlgorithmName(), getDigestSize(), getWinternitzParameter(),
+				wotsPlus.getParams().getLen(), height);
+		/*
+		 * if (oid == null) { throw new InvalidParameterException(); }
+		 */
+	}
+
+	private int determineMinK() {
+		for (int k = 2; k <= height; k++) {
+			if ((height - k) % 2 == 0) {
+				return k;
+			}
+		}
+		throw new IllegalStateException("should never happen...");
+	}
+
+	protected Digest getDigest() {
+		return wotsPlus.getParams().getDigest();
+	}
+
+	protected SecureRandom getPRNG() {
+		return prng;
+	}
+
+	/**
+	 * Getter digest size.
+	 * 
+	 * @return Digest size.
+	 */
+	public int getDigestSize() {
+		return wotsPlus.getParams().getDigestSize();
+	}
+
+	/**
+	 * Getter Winternitz parameter.
+	 * 
+	 * @return Winternitz parameter.
+	 */
+	public int getWinternitzParameter() {
+		return wotsPlus.getParams().getWinternitzParameter();
+	}
+
+	/**
+	 * Getter height.
+	 * 
+	 * @return XMSS height.
+	 */
+	public int getHeight() {
+		return height;
+	}
+
+	protected WOTSPlus getWOTSPlus() {
+		return wotsPlus;
+	}
+
+	protected int getK() {
+		return k;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSPrivateKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSPrivateKeyParameters.java
new file mode 100644
index 0000000..b918b91
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSPrivateKeyParameters.java
@@ -0,0 +1,256 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.IOException;
+import java.text.ParseException;
+
+import org.bouncycastle.util.Pack;
+
+/**
+ * XMSS Private Key.
+ *
+ */
+public final class XMSSPrivateKeyParameters implements XMSSStoreableObjectInterface {
+
+	/**
+	 * XMSS parameters object.
+	 */
+	private final XMSSParameters params;
+	/**
+	 * Index for WOTS+ keys (randomization factor).
+	 */
+	private final int index;
+	/**
+	 * Secret for the derivation of WOTS+ secret keys.
+	 */
+	private final byte[] secretKeySeed;
+	/**
+	 * Secret for the randomization of message digests during signature
+	 * creation.
+	 */
+	private final byte[] secretKeyPRF;
+	/**
+	 * Public seed for the randomization of hashes.
+	 */
+	private final byte[] publicSeed;
+	/**
+	 * Public root of binary tree.
+	 */
+	private final byte[] root;
+	/**
+	 * BDS state.
+	 */
+	private final BDS bdsState;
+
+	private XMSSPrivateKeyParameters(Builder builder) throws ParseException, ClassNotFoundException, IOException {
+		super();
+		params = builder.params;
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		int n = params.getDigestSize();
+		byte[] privateKey = builder.privateKey;
+		if (privateKey != null) {
+			if (builder.xmss == null) {
+				throw new NullPointerException("xmss == null");
+			}
+			/* import */
+			int height = params.getHeight();
+			int indexSize = 4;
+			int secretKeySize = n;
+			int secretKeyPRFSize = n;
+			int publicSeedSize = n;
+			int rootSize = n;
+			/*
+			int totalSize = indexSize + secretKeySize + secretKeyPRFSize + publicSeedSize + rootSize;
+			if (privateKey.length != totalSize) {
+				throw new ParseException("private key has wrong size", 0);
+			}
+			*/
+			int position = 0;
+			index = Pack.bigEndianToInt(privateKey, position);
+			if (!XMSSUtil.isIndexValid(height, index)) {
+				throw new ParseException("index out of bounds", 0);
+			}
+			position += indexSize;
+			secretKeySeed = XMSSUtil.extractBytesAtOffset(privateKey, position, secretKeySize);
+			position += secretKeySize;
+			secretKeyPRF = XMSSUtil.extractBytesAtOffset(privateKey, position, secretKeyPRFSize);
+			position += secretKeyPRFSize;
+			publicSeed = XMSSUtil.extractBytesAtOffset(privateKey, position, publicSeedSize);
+			position += publicSeedSize;
+			root = XMSSUtil.extractBytesAtOffset(privateKey, position, rootSize);
+			position += rootSize;
+			/* import BDS state */
+			byte[] bdsStateBinary = XMSSUtil.extractBytesAtOffset(privateKey, position, privateKey.length - position);
+			BDS bdsImport = (BDS) XMSSUtil.deserialize(bdsStateBinary);
+			bdsImport.setXMSS(builder.xmss);
+			bdsImport.validate();
+			bdsState = bdsImport;
+		} else {
+			/* set */
+			index = builder.index;
+			byte[] tmpSecretKeySeed = builder.secretKeySeed;
+			if (tmpSecretKeySeed != null) {
+				if (tmpSecretKeySeed.length != n) {
+					throw new IllegalArgumentException("size of secretKeySeed needs to be equal size of digest");
+				}
+				secretKeySeed = tmpSecretKeySeed;
+			} else {
+				secretKeySeed = new byte[n];
+			}
+			byte[] tmpSecretKeyPRF = builder.secretKeyPRF;
+			if (tmpSecretKeyPRF != null) {
+				if (tmpSecretKeyPRF.length != n) {
+					throw new IllegalArgumentException("size of secretKeyPRF needs to be equal size of digest");
+				}
+				secretKeyPRF = tmpSecretKeyPRF;
+			} else {
+				secretKeyPRF = new byte[n];
+			}
+			byte[] tmpPublicSeed = builder.publicSeed;
+			if (tmpPublicSeed != null) {
+				if (tmpPublicSeed.length != n) {
+					throw new IllegalArgumentException("size of publicSeed needs to be equal size of digest");
+				}
+				publicSeed = tmpPublicSeed;
+			} else {
+				publicSeed = new byte[n];
+			}
+			byte[] tmpRoot = builder.root;
+			if (tmpRoot != null) {
+				if (tmpRoot.length != n) {
+					throw new IllegalArgumentException("size of root needs to be equal size of digest");
+				}
+				root = tmpRoot;
+			} else {
+				root = new byte[n];
+			}
+			BDS tmpBDSState = builder.bdsState;
+			if (tmpBDSState != null) {
+				bdsState = tmpBDSState;
+			} else {
+				bdsState = new BDS(new XMSS(params));
+			}
+		}
+	}
+
+	public static class Builder {
+
+		/* mandatory */
+		private final XMSSParameters params;
+		/* optional */
+		private int index = 0;
+		private byte[] secretKeySeed = null;
+		private byte[] secretKeyPRF = null;
+		private byte[] publicSeed = null;
+		private byte[] root = null;
+		private BDS bdsState = null;
+		private byte[] privateKey = null;
+		private XMSS xmss = null;
+
+		public Builder(XMSSParameters params) {
+			super();
+			this.params = params;
+		}
+
+		public Builder withIndex(int val) {
+			index = val;
+			return this;
+		}
+
+		public Builder withSecretKeySeed(byte[] val) {
+			secretKeySeed = XMSSUtil.cloneArray(val);
+			return this;
+		}
+		
+		public Builder withSecretKeyPRF(byte[] val) {
+			secretKeyPRF = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withPublicSeed(byte[] val) {
+			publicSeed = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withRoot(byte[] val) {
+			root = XMSSUtil.cloneArray(val);
+			return this;
+		}
+
+		public Builder withBDSState(BDS valBDS) {
+			bdsState = valBDS;
+			return this;
+		}
+
+		public Builder withPrivateKey(byte[] privateKeyVal, XMSS xmssVal) {
+			privateKey = XMSSUtil.cloneArray(privateKeyVal);
+			xmss = xmssVal;
+			return this;
+		}
+
+		public XMSSPrivateKeyParameters build() throws ParseException, ClassNotFoundException, IOException {
+			return new XMSSPrivateKeyParameters(this);
+		}
+	}
+
+	public byte[] toByteArray() {
+		/* index || secretKeySeed || secretKeyPRF || publicSeed || root */
+		int n = params.getDigestSize();
+		int indexSize = 4;
+		int secretKeySize = n;
+		int secretKeyPRFSize = n;
+		int publicSeedSize = n;
+		int rootSize = n;
+		int totalSize = indexSize + secretKeySize + secretKeyPRFSize + publicSeedSize + rootSize;
+		byte[] out = new byte[totalSize];
+		int position = 0;
+		/* copy index */
+		XMSSUtil.intToBytesBigEndianOffset(out, index, position);
+		position += indexSize;
+		/* copy secretKeySeed */
+		XMSSUtil.copyBytesAtOffset(out, secretKeySeed, position);
+		position += secretKeySize;
+		/* copy secretKeyPRF */
+		XMSSUtil.copyBytesAtOffset(out, secretKeyPRF, position);
+		position += secretKeyPRFSize;
+		/* copy publicSeed */
+		XMSSUtil.copyBytesAtOffset(out, publicSeed, position);
+		position += publicSeedSize;
+		/* copy root */
+		XMSSUtil.copyBytesAtOffset(out, root, position);
+		/* concatenate bdsState */
+		byte[] bdsStateOut = null;
+		try {
+			bdsStateOut = XMSSUtil.serialize(bdsState);
+		} catch (IOException e) {
+			e.printStackTrace();
+			throw new RuntimeException("error serializing bds state");
+		}
+		return XMSSUtil.concat(out, bdsStateOut);
+	}
+
+	public int getIndex() {
+		return index;
+	}
+
+	public byte[] getSecretKeySeed() {
+		return XMSSUtil.cloneArray(secretKeySeed);
+	}
+
+	public byte[] getSecretKeyPRF() {
+		return XMSSUtil.cloneArray(secretKeyPRF);
+	}
+
+	public byte[] getPublicSeed() {
+		return XMSSUtil.cloneArray(publicSeed);
+	}
+
+	public byte[] getRoot() {
+		return XMSSUtil.cloneArray(root);
+	}
+	
+	public BDS getBDSState() {
+		return bdsState;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSPublicKeyParameters.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSPublicKeyParameters.java
new file mode 100644
index 0000000..8b8f9f9
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSPublicKeyParameters.java
@@ -0,0 +1,134 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.text.ParseException;
+
+/**
+ * XMSS Public Key.
+ *
+ */
+public final class XMSSPublicKeyParameters implements XMSSStoreableObjectInterface {
+
+	/**
+	 * XMSS parameters object.
+	 */
+	private final XMSSParameters params;
+	//private final int oid;
+	private final byte[] root;
+	private final byte[] publicSeed;
+
+	private XMSSPublicKeyParameters(Builder builder) throws ParseException {
+		super();
+		params = builder.params;
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		int n = params.getDigestSize();
+		byte[] publicKey = builder.publicKey;
+		if (publicKey != null) {
+			/* import */
+			// int oidSize = 4;
+			int rootSize = n;
+			int publicSeedSize = n;
+			// int totalSize = oidSize + rootSize + publicSeedSize;
+			int totalSize = rootSize + publicSeedSize;
+			if (publicKey.length != totalSize) {
+				throw new ParseException("public key has wrong size", 0);
+			}
+			int position = 0;
+			/*
+			 * oid = XMSSUtil.bytesToIntBigEndian(publicKey, position); if (oid !=
+			 * xmss.getParams().getOid().getOid()) { throw new
+			 * ParseException("public key not compatible with current instance parameters"
+			 * , 0); } position += oidSize;
+			 */
+			root = XMSSUtil.extractBytesAtOffset(publicKey, position, rootSize);
+			position += rootSize;
+			publicSeed = XMSSUtil.extractBytesAtOffset(publicKey, position, publicSeedSize);
+		} else {
+			/* set */
+			byte[] tmpRoot = builder.root;
+			if (tmpRoot != null) {
+				if (tmpRoot.length != n) {
+					throw new IllegalArgumentException("length of root must be equal to length of digest");
+				}
+				root = tmpRoot;
+			} else {
+				root = new byte[n];
+			}
+			byte[] tmpPublicSeed = builder.publicSeed;
+			if (tmpPublicSeed != null) {
+				if (tmpPublicSeed.length != n) {
+					throw new IllegalArgumentException("length of publicSeed must be equal to length of digest");
+				}
+				publicSeed = tmpPublicSeed;
+			} else {
+				publicSeed = new byte[n];
+			}
+		}
+	}
+
+	public static class Builder {
+		
+		/* mandatory */
+		private final XMSSParameters params;
+		/* optional */
+		private byte[] root = null;
+		private byte[] publicSeed = null;
+		private byte[] publicKey = null;
+		
+		public Builder(XMSSParameters params) {
+			super();
+			this.params = params;
+		}
+		
+		public Builder withRoot(byte[] val) {
+			root = XMSSUtil.cloneArray(val);
+			return this;
+		}
+		
+		public Builder withPublicSeed(byte[] val) {
+			publicSeed = XMSSUtil.cloneArray(val);
+			return this;
+		}
+		
+		public Builder withPublicKey(byte[] val) {
+			publicKey = XMSSUtil.cloneArray(val);
+			return this;
+		}
+		
+		public XMSSPublicKeyParameters build() throws ParseException {
+			return new XMSSPublicKeyParameters(this);
+		}
+	}
+
+	public byte[] toByteArray() {
+		/* oid || root || seed */
+		int n = params.getDigestSize();
+		// int oidSize = 4;
+		int rootSize = n;
+		int publicSeedSize = n;
+		// int totalSize = oidSize + rootSize + publicSeedSize;
+		int totalSize = rootSize + publicSeedSize;
+		byte[] out = new byte[totalSize];
+		int position = 0;
+		/* copy oid */
+		/*
+		 * XMSSUtil.intToBytesBigEndianOffset(out, oid, position); position +=
+		 * oidSize;
+		 */
+		/* copy root */
+		XMSSUtil.copyBytesAtOffset(out, root, position);
+		position += rootSize;
+		/* copy public seed */
+		XMSSUtil.copyBytesAtOffset(out, publicSeed, position);
+		return out;
+	}
+
+	public byte[] getRoot() {
+		return XMSSUtil.cloneArray(root);
+	}
+
+	public byte[] getPublicSeed() {
+		return XMSSUtil.cloneArray(publicSeed);
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSReducedSignature.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSReducedSignature.java
new file mode 100644
index 0000000..f587cc7
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSReducedSignature.java
@@ -0,0 +1,137 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Reduced XMSS Signature.
+ *
+ */
+public class XMSSReducedSignature implements XMSSStoreableObjectInterface {
+
+	private final XMSSParameters params;
+	private final WOTSPlusSignature wotsPlusSignature;
+	private final List<XMSSNode> authPath;
+
+	protected XMSSReducedSignature(Builder builder) throws ParseException {
+		super();
+		params = builder.params;
+		if (params == null) {
+			throw new NullPointerException("params == null");
+		}
+		int n = params.getDigestSize();
+		int len = params.getWOTSPlus().getParams().getLen();
+		int height = params.getHeight();
+		byte[] reducedSignature = builder.reducedSignature;
+		if (reducedSignature != null) {
+			/* import */
+			int signatureSize = len * n;
+			int authPathSize = height * n;
+			int totalSize = signatureSize + authPathSize;
+			if (reducedSignature.length != totalSize) {
+				throw new ParseException("signature has wrong size", 0);
+			}
+			int position = 0;
+			byte[][] wotsPlusSignature = new byte[len][];
+			for (int i = 0; i < wotsPlusSignature.length; i++) {
+				wotsPlusSignature[i] = XMSSUtil.extractBytesAtOffset(reducedSignature, position, n);
+				position += n;
+			}
+			this.wotsPlusSignature = new WOTSPlusSignature(params.getWOTSPlus().getParams(), wotsPlusSignature);
+
+			List<XMSSNode> nodeList = new ArrayList<XMSSNode>();
+			for (int i = 0; i < height; i++) {
+				nodeList.add(new XMSSNode(i, XMSSUtil.extractBytesAtOffset(reducedSignature, position, n)));
+				position += n;
+			}
+			authPath = nodeList;
+		} else {
+			/* set */
+			WOTSPlusSignature tmpSignature = builder.wotsPlusSignature;
+			if (tmpSignature != null) {
+				wotsPlusSignature = tmpSignature;
+			} else {
+				wotsPlusSignature = new WOTSPlusSignature(params.getWOTSPlus().getParams(), new byte[len][n]);
+			}
+			List<XMSSNode> tmpAuthPath = builder.authPath;
+			if (tmpAuthPath != null) {
+				if (tmpAuthPath.size() != height) {
+					throw new IllegalArgumentException("size of authPath needs to be equal to height of tree");
+				}
+				authPath = tmpAuthPath;
+			} else {
+				authPath = new ArrayList<XMSSNode>();
+			}
+		}
+	}
+	
+	public static class Builder {
+		
+		/* mandatory */
+		private final XMSSParameters params;
+		/* optional */
+		private WOTSPlusSignature wotsPlusSignature = null;
+		private List<XMSSNode> authPath = null;
+		private byte[] reducedSignature = null;
+		
+		public Builder(XMSSParameters params) {
+			super();
+			this.params = params;
+		}
+		
+		public Builder withWOTSPlusSignature(WOTSPlusSignature val) {
+			wotsPlusSignature = val;
+			return this;
+		}
+		
+		public Builder withAuthPath(List<XMSSNode> val) {
+			authPath = val;
+			return this;
+		}
+		
+		public Builder withReducedSignature(byte[] val) {
+			reducedSignature = XMSSUtil.cloneArray(val);
+			return this;
+		}
+		
+		public XMSSReducedSignature build() throws ParseException {
+			return new XMSSReducedSignature(this);
+		}
+	}
+
+	public byte[] toByteArray() {
+		/* signature || authentication path */
+		int n = params.getDigestSize();
+		int signatureSize = params.getWOTSPlus().getParams().getLen() * n;
+		int authPathSize = params.getHeight() * n;
+		int totalSize = signatureSize + authPathSize;
+		byte[] out = new byte[totalSize];
+		int position = 0;
+		/* copy signature */
+		byte[][] signature = this.wotsPlusSignature.toByteArray();
+		for (int i = 0; i < signature.length; i++) {
+			XMSSUtil.copyBytesAtOffset(out, signature[i], position);
+			position += n;
+		}
+		/* copy authentication path */
+		for (int i = 0; i < authPath.size(); i++) {
+			byte[] value = authPath.get(i).getValue();
+			XMSSUtil.copyBytesAtOffset(out, value, position);
+			position += n;
+		}
+		return out;
+	}
+
+	public XMSSParameters getParams() {
+		return params;
+	}
+
+	public WOTSPlusSignature getWOTSPlusSignature() {
+		return wotsPlusSignature;
+	}
+
+	public List<XMSSNode> getAuthPath() {
+		return authPath;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSSignature.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSSignature.java
new file mode 100644
index 0000000..e50b206
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSSignature.java
@@ -0,0 +1,140 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.text.ParseException;
+
+import org.bouncycastle.util.Pack;
+
+/**
+ * XMSS Signature.
+ */
+public final class XMSSSignature
+    extends XMSSReducedSignature
+    implements XMSSStoreableObjectInterface
+{
+
+    private final int index;
+    private final byte[] random;
+
+    private XMSSSignature(Builder builder)
+        throws ParseException
+    {
+        super(builder);
+        index = builder.index;
+        int n = getParams().getDigestSize();
+        byte[] tmpRandom = builder.random;
+        if (tmpRandom != null)
+        {
+            if (tmpRandom.length != n)
+            {
+                throw new IllegalArgumentException("size of random needs to be equal to size of digest");
+            }
+            random = tmpRandom;
+        }
+        else
+        {
+            random = new byte[n];
+        }
+    }
+
+    public static class Builder
+        extends XMSSReducedSignature.Builder
+    {
+
+        private final XMSSParameters params;
+        /* optional */
+        private int index = 0;
+        private byte[] random = null;
+
+        public Builder(XMSSParameters params)
+        {
+            super(params);
+            this.params = params;
+        }
+
+        public Builder withIndex(int val)
+        {
+            index = val;
+            return this;
+        }
+
+        public Builder withRandom(byte[] val)
+        {
+            random = XMSSUtil.cloneArray(val);
+            return this;
+        }
+
+        public Builder withSignature(byte[] val)
+        {
+            if (val == null)
+            {
+                throw new NullPointerException("signature == null");
+            }
+            int n = params.getDigestSize();
+            int len = params.getWOTSPlus().getParams().getLen();
+            int height = params.getHeight();
+            int indexSize = 4;
+            int randomSize = n;
+            int signatureSize = len * n;
+            int authPathSize = height * n;
+            int position = 0;
+            /* extract index */
+            index = Pack.bigEndianToInt(val, position);
+            position += indexSize;
+			/* extract random */
+            random = XMSSUtil.extractBytesAtOffset(val, position, randomSize);
+            position += randomSize;
+            withReducedSignature(XMSSUtil.extractBytesAtOffset(val, position, signatureSize + authPathSize));
+            return this;
+        }
+
+        public XMSSSignature build()
+            throws ParseException
+        {
+            return new XMSSSignature(this);
+        }
+    }
+
+    public byte[] toByteArray()
+    {
+		/* index || random || signature || authentication path */
+        int n = getParams().getDigestSize();
+        int indexSize = 4;
+        int randomSize = n;
+        int signatureSize = getParams().getWOTSPlus().getParams().getLen() * n;
+        int authPathSize = getParams().getHeight() * n;
+        int totalSize = indexSize + randomSize + signatureSize + authPathSize;
+        byte[] out = new byte[totalSize];
+        int position = 0;
+		/* copy index */
+        XMSSUtil.intToBytesBigEndianOffset(out, index, position);
+        position += indexSize;
+		/* copy random */
+        XMSSUtil.copyBytesAtOffset(out, random, position);
+        position += randomSize;
+		/* copy signature */
+        byte[][] signature = getWOTSPlusSignature().toByteArray();
+        for (int i = 0; i < signature.length; i++)
+        {
+            XMSSUtil.copyBytesAtOffset(out, signature[i], position);
+            position += n;
+        }
+		/* copy authentication path */
+        for (int i = 0; i < getAuthPath().size(); i++)
+        {
+            byte[] value = getAuthPath().get(i).getValue();
+            XMSSUtil.copyBytesAtOffset(out, value, position);
+            position += n;
+        }
+        return out;
+    }
+
+    public int getIndex()
+    {
+        return index;
+    }
+
+    public byte[] getRandom()
+    {
+        return XMSSUtil.cloneArray(random);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSStoreableObjectInterface.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSStoreableObjectInterface.java
new file mode 100644
index 0000000..fba9569
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSStoreableObjectInterface.java
@@ -0,0 +1,15 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+/**
+ * Interface for XMSS objects that need to be storeable as a byte array.
+ *
+ */
+public interface XMSSStoreableObjectInterface {
+
+	/**
+	 * Create byte representation of object.
+	 *
+	 * @return Byte representation of object.
+	 */
+	public byte[] toByteArray();
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSUtil.java b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSUtil.java
new file mode 100644
index 0000000..af3b807
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/crypto/xmss/XMSSUtil.java
@@ -0,0 +1,402 @@
+package org.bouncycastle.pqc.crypto.xmss;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.util.encoders.Hex;
+
+/**
+ * Utils for XMSS implementation.
+ *
+ */
+public class XMSSUtil {
+
+	/**
+	 * Calculates the logarithm base 2 for a given Integer.
+	 *
+	 * @param n
+	 *            Number.
+	 * @return Logarithm to base 2 of {@code n}.
+	 */
+	public static int log2(int n) {
+		int log = 0;
+		while ((n >>= 1) != 0) {
+			log++;
+		}
+		return log;
+	}
+
+	/**
+	 * Convert int/long to n-byte array.
+	 *
+	 * @param value
+	 *            int/long value.
+	 * @param sizeInByte
+	 *            Size of byte array in byte.
+	 * @return int/long as big-endian byte array of size {@code sizeInByte}.
+	 */
+	public static byte[] toBytesBigEndian(long value, int sizeInByte) {
+		byte[] out = new byte[sizeInByte];
+		for (int i = (sizeInByte - 1); i >= 0; i--) {
+			out[i] = (byte) value;
+			value >>>= 8;
+		}
+		return out;
+	}
+
+	/**
+	 * Copy int to byte array in big-endian at specific offset.
+	 *
+	 * @param Byte
+	 *            array.
+	 * @param Integer
+	 *            to put.
+	 * @param Offset
+	 *            in {@code in}.
+	 */
+	public static void intToBytesBigEndianOffset(byte[] in, int value, int offset) {
+		if (in == null) {
+			throw new NullPointerException("in == null");
+		}
+		if ((in.length - offset) < 4) {
+			throw new IllegalArgumentException("not enough space in array");
+		}
+		in[offset] = (byte) ((value >> 24) & 0xff);
+		in[offset + 1] = (byte) ((value >> 16) & 0xff);
+		in[offset + 2] = (byte) ((value >> 8) & 0xff);
+		in[offset + 3] = (byte) ((value) & 0xff);
+	}
+
+	/**
+	 * Copy long to byte array in big-endian at specific offset.
+	 *
+	 * @param Byte
+	 *            array.
+	 * @param Long
+	 *            to put.
+	 * @param Offset
+	 *            in {@code in}.
+	 */
+	public static void longToBytesBigEndianOffset(byte[] in, long value, int offset) {
+		if (in == null) {
+			throw new NullPointerException("in == null");
+		}
+		if ((in.length - offset) < 8) {
+			throw new IllegalArgumentException("not enough space in array");
+		}
+		in[offset] = (byte) ((value >> 56) & 0xff);
+		in[offset + 1] = (byte) ((value >> 48) & 0xff);
+		in[offset + 2] = (byte) ((value >> 40) & 0xff);
+		in[offset + 3] = (byte) ((value >> 32) & 0xff);
+		in[offset + 4] = (byte) ((value >> 24) & 0xff);
+		in[offset + 5] = (byte) ((value >> 16) & 0xff);
+		in[offset + 6] = (byte) ((value >> 8) & 0xff);
+		in[offset + 7] = (byte) ((value) & 0xff);
+	}
+
+	/**
+	 * Generic convert from big endian byte array to long.
+	 *
+	 * @param x-byte
+	 *            array
+	 * @param offset.
+	 * @param size.
+	 * @return Long.
+	 */
+	public static long bytesToXBigEndian(byte[] in, int offset, int size) {
+		if (in == null) {
+			throw new NullPointerException("in == null");
+		}
+		long res = 0;
+		for (int i = offset; i < (offset + size); i++) {
+			res = (res << 8) | (in[i] & 0xff);
+		}
+		return res;
+	}
+
+	/**
+	 * Clone a byte array.
+	 *
+	 * @param in
+	 *            byte array.
+	 * @return Copy of byte array.
+	 */
+	public static byte[] cloneArray(byte[] in) {
+		if (in == null) {
+			throw new NullPointerException("in == null");
+		}
+		byte[] out = new byte[in.length];
+		for (int i = 0; i < in.length; i++) {
+			out[i] = in[i];
+		}
+		return out;
+	}
+
+	/**
+	 * Clone a 2d byte array.
+	 *
+	 * @param in
+	 *            2d byte array.
+	 * @return Copy of 2d byte array.
+	 */
+	public static byte[][] cloneArray(byte[][] in) {
+		if (hasNullPointer(in)) {
+			throw new NullPointerException("in has null pointers");
+		}
+		byte[][] out = new byte[in.length][];
+		for (int i = 0; i < in.length; i++) {
+			out[i] = new byte[in[i].length];
+			for (int j = 0; j < in[i].length; j++) {
+				out[i][j] = in[i][j];
+			}
+		}
+		return out;
+	}
+
+	/**
+	 * Concatenates an arbitrary number of byte arrays.
+	 *
+	 * @param arrays
+	 *            Arrays that shall be concatenated.
+	 * @return Concatenated array.
+	 */
+	public static byte[] concat(byte[]... arrays) {
+		int totalLength = 0;
+		for (int i = 0; i < arrays.length; i++) {
+			totalLength += arrays[i].length;
+		}
+		byte[] result = new byte[totalLength];
+		int currentIndex = 0;
+		for (int i = 0; i < arrays.length; i++) {
+			System.arraycopy(arrays[i], 0, result, currentIndex, arrays[i].length);
+			currentIndex += arrays[i].length;
+		}
+		return result;
+	}
+
+	/**
+	 * Compares two byte arrays.
+	 *
+	 * @param a
+	 *            byte array 1.
+	 * @param b
+	 *            byte array 2.
+	 * @return true if all values in byte array are equal false else.
+	 */
+	public static boolean compareByteArray(byte[] a, byte[] b) {
+		if (a == null || b == null) {
+			throw new NullPointerException("a or b == null");
+		}
+		if (a.length != b.length) {
+			throw new IllegalArgumentException("size of a and b must be equal");
+		}
+		for (int i = 0; i < a.length; i++) {
+			if (a[i] != b[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Compares two 2d-byte arrays.
+	 *
+	 * @param a
+	 *            2d-byte array 1.
+	 * @param b
+	 *            2d-byte array 2.
+	 * @return true if all values in 2d-byte array are equal false else.
+	 */
+	public static boolean compareByteArray(byte[][] a, byte[][] b) {
+		if (hasNullPointer(a) || hasNullPointer(b)) {
+			throw new NullPointerException("a or b == null");
+		}
+		for (int i = 0; i < a.length; i++) {
+			if (!compareByteArray(a[i], b[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Dump content of 2d byte array.
+	 *
+	 * @param x
+	 *            byte array.
+	 */
+	public static void dumpByteArray(byte[][] x) {
+		if (hasNullPointer(x)) {
+			throw new NullPointerException("x has null pointers");
+		}
+		for (int i = 0; i < x.length; i++) {
+			System.out.println(Hex.toHexString(x[i]));
+		}
+	}
+
+	/**
+	 * Checks whether 2d byte array has null pointers.
+	 *
+	 * @param in
+	 *            2d byte array.
+	 * @return true if at least one null pointer is found false else.
+	 */
+	public static boolean hasNullPointer(byte[][] in) {
+		if (in == null) {
+			return true;
+		}
+		for (int i = 0; i < in.length; i++) {
+			if (in[i] == null) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Copy src byte array to dst byte array at offset.
+	 *
+	 * @param dst
+	 *            Destination.
+	 * @param src
+	 *            Source.
+	 * @param offset
+	 *            Destination offset.
+	 */
+	public static void copyBytesAtOffset(byte[] dst, byte[] src, int offset) {
+		if (dst == null) {
+			throw new NullPointerException("dst == null");
+		}
+		if (src == null) {
+			throw new NullPointerException("src == null");
+		}
+		if (offset < 0) {
+			throw new IllegalArgumentException("offset hast to be >= 0");
+		}
+		if ((src.length + offset) > dst.length) {
+			throw new IllegalArgumentException("src length + offset must not be greater than size of destination");
+		}
+		for (int i = 0; i < src.length; i++) {
+			dst[offset + i] = src[i];
+		}
+	}
+
+	/**
+	 * Copy length bytes at position offset from src.
+	 *
+	 * @param src
+	 *            Source byte array.
+	 * @param offset
+	 *            Offset in source byte array.
+	 * @param length
+	 *            Length of bytes to copy.
+	 * @return New byte array.
+	 */
+	public static byte[] extractBytesAtOffset(byte[] src, int offset, int length) {
+		if (src == null) {
+			throw new NullPointerException("src == null");
+		}
+		if (offset < 0) {
+			throw new IllegalArgumentException("offset hast to be >= 0");
+		}
+		if (length < 0) {
+			throw new IllegalArgumentException("length hast to be >= 0");
+		}
+		if ((offset + length) > src.length) {
+			throw new IllegalArgumentException("offset + length must not be greater then size of source array");
+		}
+		byte[] out = new byte[length];
+		for (int i = 0; i < out.length; i++) {
+			out[i] = src[offset + i];
+		}
+		return out;
+	}
+
+	/**
+	 * Check whether an index is valid or not.
+	 *
+	 * @param height
+	 *            Height of binary tree.
+	 * @param index
+	 *            Index to validate.
+	 * @return true if index is valid false else.
+	 */
+	public static boolean isIndexValid(int height, long index) {
+		if (index < 0) {
+			throw new IllegalStateException("index must not be negative");
+		}
+		return index < (1L << height);
+	}
+
+	/**
+	 * Determine digest size of digest.
+	 *
+	 * @param digest
+	 *            Digest.
+	 * @return Digest size.
+	 */
+	public static int getDigestSize(Digest digest) {
+		if (digest == null) {
+			throw new NullPointerException("digest == null");
+		}
+		String algorithmName = digest.getAlgorithmName();
+		if (algorithmName.equals("SHAKE128")) {
+			return 32;
+		}
+		if (algorithmName.equals("SHAKE256")) {
+			return 64;
+		}
+		return digest.getDigestSize();
+	}
+
+	public static long getTreeIndex(long index, int xmssTreeHeight) {
+		return index >> xmssTreeHeight;
+	}
+
+	public static int getLeafIndex(long index, int xmssTreeHeight) {
+		return (int) (index & ((1L << xmssTreeHeight) - 1L));
+	}
+
+	public static byte[] serialize(Object obj) throws IOException {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		ObjectOutputStream oos = new ObjectOutputStream(out);
+		oos.writeObject(obj);
+		oos.flush();
+		return out.toByteArray();
+	}
+
+	public static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
+		ByteArrayInputStream in = new ByteArrayInputStream(data);
+		ObjectInputStream is = new ObjectInputStream(in);
+		return is.readObject();
+	}
+
+	public static int calculateTau(int index, int height) {
+		int tau = 0;
+		for (int i = 0; i < height; i++) {
+			if (((index >> i) & 1) == 0) {
+				tau = i;
+				break;
+			}
+		}
+		return tau;
+	}
+
+	public static boolean isNewBDSInitNeeded(long globalIndex, int xmssHeight, int layer) {
+		if (globalIndex == 0) {
+			return false;
+		}
+		return (globalIndex % (long) Math.pow((1 << xmssHeight), layer + 1) == 0) ? true : false;
+	}
+
+	public static boolean isNewAuthenticationPathNeeded(long globalIndex, int xmssHeight, int layer) {
+		if (globalIndex == 0) {
+			return false;
+		}
+		return ((globalIndex + 1) % (long) Math.pow((1 << xmssHeight), layer) == 0) ? true : false;
+	}
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/BouncyCastlePQCProvider.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/BouncyCastlePQCProvider.java
index 47d0a4c..f756be2 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/BouncyCastlePQCProvider.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/BouncyCastlePQCProvider.java
@@ -7,6 +7,7 @@
 import java.security.Provider;
 import java.security.PublicKey;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.Map;
 
 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
@@ -21,7 +22,7 @@
     extends Provider
     implements ConfigurableProvider
 {
-    private static String info = "BouncyCastle Post-Quantum Security Provider v1.56";
+    private static String info = "BouncyCastle Post-Quantum Security Provider v1.57";
 
     public static String PROVIDER_NAME = "BCPQC";
 
@@ -46,7 +47,7 @@
      */
     public BouncyCastlePQCProvider()
     {
-        super(PROVIDER_NAME, 1.56, info);
+        super(PROVIDER_NAME, 1.57, info);
 
         AccessController.doPrivileged(new PrivilegedAction()
         {
@@ -143,6 +144,21 @@
         }
     }
 
+    public void addAttributes(String key, Map<String, String> attributeMap)
+    {
+        for (Iterator it = attributeMap.keySet().iterator(); it.hasNext();)
+        {
+            String attributeName = (String)it.next();
+            String attributeKey = key + " " + attributeName;
+            if (containsKey(attributeKey))
+            {
+                throw new IllegalStateException("duplicate provider attribute key (" + attributeKey + ") found");
+            }
+
+            put(attributeKey, attributeMap.get(attributeName));
+        }
+    }
+
     private static AsymmetricKeyInfoConverter getAsymmetricKeyInfoConverter(ASN1ObjectIdentifier algorithm)
     {
         synchronized (keyInfoConverters)
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/NH.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/NH.java
index 388e4ea..baa9b84 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/NH.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/NH.java
@@ -27,7 +27,6 @@
             AsymmetricKeyInfoConverter keyFact = new NHKeyFactorySpi();
 
             registerOid(provider, PQCObjectIdentifiers.newHope, "NH", keyFact);
-            registerOidAlgorithmParameters(provider, PQCObjectIdentifiers.newHope, "NH");
         }
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/Rainbow.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/Rainbow.java
index 2a66028..6f547e5 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/Rainbow.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/Rainbow.java
@@ -30,7 +30,6 @@
             AsymmetricKeyInfoConverter keyFact = new RainbowKeyFactorySpi();
 
             registerOid(provider, PQCObjectIdentifiers.rainbow, "Rainbow", keyFact);
-            registerOidAlgorithmParameters(provider, PQCObjectIdentifiers.rainbow, "Rainbow");
         }
     }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceFujisakiCipherSpi.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceFujisakiCipherSpi.java
index e2f1810..19f7ed9 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceFujisakiCipherSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceFujisakiCipherSpi.java
@@ -17,7 +17,6 @@
 import org.bouncycastle.asn1.x509.X509ObjectIdentifiers;
 import org.bouncycastle.crypto.CipherParameters;
 import org.bouncycastle.crypto.Digest;
-import org.bouncycastle.crypto.digests.SHA1Digest;
 import org.bouncycastle.crypto.params.ParametersWithRandom;
 import org.bouncycastle.crypto.util.DigestFactory;
 import org.bouncycastle.pqc.crypto.mceliece.McElieceCCA2KeyParameters;
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceKobaraImaiCipherSpi.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceKobaraImaiCipherSpi.java
index 0a1df2a..8cb8f34 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceKobaraImaiCipherSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McElieceKobaraImaiCipherSpi.java
@@ -17,11 +17,6 @@
 import org.bouncycastle.asn1.x509.X509ObjectIdentifiers;
 import org.bouncycastle.crypto.CipherParameters;
 import org.bouncycastle.crypto.Digest;
-import org.bouncycastle.crypto.digests.SHA1Digest;
-import org.bouncycastle.crypto.digests.SHA224Digest;
-import org.bouncycastle.crypto.digests.SHA256Digest;
-import org.bouncycastle.crypto.digests.SHA384Digest;
-import org.bouncycastle.crypto.digests.SHA512Digest;
 import org.bouncycastle.crypto.params.ParametersWithRandom;
 import org.bouncycastle.crypto.util.DigestFactory;
 import org.bouncycastle.pqc.crypto.mceliece.McElieceCCA2KeyParameters;
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McEliecePointchevalCipherSpi.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McEliecePointchevalCipherSpi.java
index f4db11d..e375393 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McEliecePointchevalCipherSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/McEliecePointchevalCipherSpi.java
@@ -17,11 +17,6 @@
 import org.bouncycastle.asn1.x509.X509ObjectIdentifiers;
 import org.bouncycastle.crypto.CipherParameters;
 import org.bouncycastle.crypto.Digest;
-import org.bouncycastle.crypto.digests.SHA1Digest;
-import org.bouncycastle.crypto.digests.SHA224Digest;
-import org.bouncycastle.crypto.digests.SHA256Digest;
-import org.bouncycastle.crypto.digests.SHA384Digest;
-import org.bouncycastle.crypto.digests.SHA512Digest;
 import org.bouncycastle.crypto.params.ParametersWithRandom;
 import org.bouncycastle.crypto.util.DigestFactory;
 import org.bouncycastle.pqc.crypto.mceliece.McElieceCCA2KeyParameters;
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/Utils.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/Utils.java
index 7037d16..eeaad76 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/Utils.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/mceliece/Utils.java
@@ -5,11 +5,6 @@
 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.crypto.digests.SHA224Digest;
-import org.bouncycastle.crypto.digests.SHA256Digest;
-import org.bouncycastle.crypto.digests.SHA384Digest;
-import org.bouncycastle.crypto.digests.SHA512Digest;
 import org.bouncycastle.crypto.util.DigestFactory;
 
 class Utils
diff --git a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/newhope/KeyAgreementSpi.java b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/newhope/KeyAgreementSpi.java
index a51a297..c06424d 100644
--- a/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/newhope/KeyAgreementSpi.java
+++ b/bcprov/src/main/java/org/bouncycastle/pqc/jcajce/provider/newhope/KeyAgreementSpi.java
@@ -63,7 +63,7 @@
 
         if (exchangePairGenerator != null)
         {
-            ExchangePair exchPair = exchangePairGenerator.GenerateExchange((AsymmetricKeyParameter)otherPartyKey.getKeyParams());
+            ExchangePair exchPair = exchangePairGenerator.generateExchange((AsymmetricKeyParameter)otherPartyKey.getKeyParams());
 
             shared = exchPair.getSharedValue();
 
diff --git a/bcprov/src/main/java/org/bouncycastle/util/Arrays.java b/bcprov/src/main/java/org/bouncycastle/util/Arrays.java
index ae60928..6873117 100644
--- a/bcprov/src/main/java/org/bouncycastle/util/Arrays.java
+++ b/bcprov/src/main/java/org/bouncycastle/util/Arrays.java
@@ -944,6 +944,22 @@
         return result;
     }
 
+    public static String[] append(String[] a, String b)
+    {
+        if (a == null)
+        {
+            return new String[]{ b };
+        }
+
+        int length = a.length;
+        String[] result = new String[length + 1];
+        System.arraycopy(a, 0, result, 0, length);
+        result[length] = b;
+        return result;
+    }
+
+
+
     public static byte[] concatenate(byte[] a, byte[] b)
     {
         if (a != null && b != null)
diff --git a/bcprov/src/main/java/org/bouncycastle/util/Properties.java b/bcprov/src/main/java/org/bouncycastle/util/Properties.java
index 96cef35..e533b58 100644
--- a/bcprov/src/main/java/org/bouncycastle/util/Properties.java
+++ b/bcprov/src/main/java/org/bouncycastle/util/Properties.java
@@ -3,6 +3,10 @@
 import java.security.AccessControlException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.StringTokenizer;
 
 /**
  * Utility method for accessing system properties.
@@ -33,4 +37,19 @@
             return false;
         }
     }
+
+    public static Set<String> asKeySet(final String propertyName)
+    {
+        Set<String> set = new HashSet<String>();
+        String p = System.getProperty(propertyName);
+        if (p != null)
+        {
+            StringTokenizer sTok = new StringTokenizer(p, ",");
+            while (sTok.hasMoreElements())
+            {
+                set.add(Strings.toLowerCase(sTok.nextToken()).trim());
+            }
+        }
+        return Collections.unmodifiableSet(set);
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64.java b/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64.java
index c04a8cc..e3129f0 100644
--- a/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64.java
+++ b/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64.java
@@ -12,7 +12,7 @@
 public class Base64
 {
     private static final Encoder encoder = new Base64Encoder();
-    
+
     public static String toBase64String(
         byte[] data)
     {
@@ -21,8 +21,8 @@
 
     public static String toBase64String(
         byte[] data,
-        int    off,
-        int    length)
+        int off,
+        int length)
     {
         byte[] encoded = encode(data, off, length);
         return Strings.fromByteArray(encoded);
@@ -34,7 +34,7 @@
      * @return a byte array containing the base 64 encoded data.
      */
     public static byte[] encode(
-        byte[]    data)
+        byte[] data)
     {
         return encode(data, 0, data.length);
     }
@@ -46,8 +46,8 @@
      */
     public static byte[] encode(
         byte[] data,
-        int    off,
-        int    length)
+        int off,
+        int length)
     {
         int len = (length + 2) / 3 * 4;
         ByteArrayOutputStream bOut = new ByteArrayOutputStream(len);
@@ -60,7 +60,7 @@
         {
             throw new EncoderException("exception encoding base64 string: " + e.getMessage(), e);
         }
-        
+
         return bOut.toByteArray();
     }
 
@@ -70,39 +70,39 @@
      * @return the number of bytes produced.
      */
     public static int encode(
-        byte[]                data,
-        OutputStream    out)
+        byte[] data,
+        OutputStream out)
         throws IOException
     {
         return encoder.encode(data, 0, data.length, out);
     }
-    
+
     /**
      * Encode the byte data to base 64 writing it to the given output stream.
      *
      * @return the number of bytes produced.
      */
     public static int encode(
-        byte[]                data,
-        int                    off,
-        int                    length,
-        OutputStream    out)
+        byte[] data,
+        int off,
+        int length,
+        OutputStream out)
         throws IOException
     {
         return encoder.encode(data, off, length, out);
     }
-    
+
     /**
      * decode the base 64 encoded input data. It is assumed the input data is valid.
      *
      * @return a byte array representing the decoded data.
      */
     public static byte[] decode(
-        byte[]    data)
+        byte[] data)
     {
         int len = data.length / 4 * 3;
         ByteArrayOutputStream bOut = new ByteArrayOutputStream(len);
-        
+
         try
         {
             encoder.decode(data, 0, data.length, bOut);
@@ -111,21 +111,21 @@
         {
             throw new DecoderException("unable to decode base64 data: " + e.getMessage(), e);
         }
-        
+
         return bOut.toByteArray();
     }
-    
+
     /**
      * decode the base 64 encoded String data - whitespace will be ignored.
      *
      * @return a byte array representing the decoded data.
      */
     public static byte[] decode(
-        String    data)
+        String data)
     {
         int len = data.length() / 4 * 3;
         ByteArrayOutputStream bOut = new ByteArrayOutputStream(len);
-        
+
         try
         {
             encoder.decode(data, bOut);
@@ -134,10 +134,10 @@
         {
             throw new DecoderException("unable to decode base64 string: " + e.getMessage(), e);
         }
-        
+
         return bOut.toByteArray();
     }
-    
+
     /**
      * decode the base 64 encoded String data writing it to the given output stream,
      * whitespace characters will be ignored.
@@ -145,10 +145,31 @@
      * @return the number of bytes produced.
      */
     public static int decode(
-        String                data,
-        OutputStream    out)
+        String data,
+        OutputStream out)
         throws IOException
     {
         return encoder.decode(data, out);
     }
+
+    /**
+     * Decode to an output stream;
+     *
+     * @param base64Data       The source data.
+     * @param start            Start position.
+     * @param length           the length.
+     * @param out The output stream to write to.
+     */
+    public static int decode(byte[] base64Data, int start, int length, OutputStream out)
+    {
+        try
+        {
+           return encoder.decode(base64Data, start, length, out);
+        }
+        catch (Exception e)
+        {
+            throw new DecoderException("unable to decode base64 data: " + e.getMessage(), e);
+        }
+
+    }
 }
diff --git a/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64Encoder.java b/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64Encoder.java
index abad02c..4216674 100644
--- a/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64Encoder.java
+++ b/bcprov/src/main/java/org/bouncycastle/util/encoders/Base64Encoder.java
@@ -272,6 +272,11 @@
         
         if (c3 == padding)
         {
+            if (c4 != padding)
+            {
+                throw new IOException("invalid characters encountered at end of base64 data");
+            }
+            
             b1 = decodingTable[c1];
             b2 = decodingTable[c2];
 
diff --git a/bcprov/src/main/java/org/bouncycastle/util/io/SimpleOutputStream.java b/bcprov/src/main/java/org/bouncycastle/util/io/SimpleOutputStream.java
new file mode 100644
index 0000000..af2f45f
--- /dev/null
+++ b/bcprov/src/main/java/org/bouncycastle/util/io/SimpleOutputStream.java
@@ -0,0 +1,21 @@
+package org.bouncycastle.util.io;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+public abstract class SimpleOutputStream extends OutputStream
+{
+    public void close()
+    {
+    }
+
+    public void flush()
+    {
+    }
+
+    public void write(int b) throws IOException
+    {
+        byte[] buf = new byte[]{ (byte)b };
+        write(buf, 0, 1);
+    }
+}
diff --git a/bcprov/src/main/java/org/bouncycastle/util/test/SimpleTest.java b/bcprov/src/main/java/org/bouncycastle/util/test/SimpleTest.java
index dd18235..9e70a3f 100644
--- a/bcprov/src/main/java/org/bouncycastle/util/test/SimpleTest.java
+++ b/bcprov/src/main/java/org/bouncycastle/util/test/SimpleTest.java
@@ -13,7 +13,7 @@
     {
         return SimpleTestResult.successful(this, "Okay");
     }
-    
+
     protected void fail(
         String message)
     {
@@ -21,6 +21,15 @@
     }
 
     protected void isTrue(
+        boolean value)
+    {
+        if (!value)
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, "no message"));
+        }
+    }
+
+    protected void isTrue(
         String message,
         boolean value)
     {
@@ -29,14 +38,109 @@
             throw new TestFailedException(SimpleTestResult.failed(this, message));
         }
     }
-    
+
+    protected void isEquals(
+        Object a,
+        Object b)
+    {
+        if (!a.equals(b))
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, "no message"));
+        }
+    }
+
+    protected void isEquals(
+        int a,
+        int b)
+    {
+        if (a != b)
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, "no message"));
+        }
+    }
+
+    protected void isEquals(
+        String message,
+        boolean a,
+        boolean b)
+    {
+        if (a != b)
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, message));
+        }
+    }
+
+    protected void isEquals(
+        String message,
+        long a,
+        long b)
+    {
+        if (a != b)
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, message));
+        }
+    }
+
+    protected void isEquals(
+        String message,
+        Object a,
+        Object b)
+    {
+        if (a == null && b == null)
+        {
+            return;
+        }
+        else if (a == null)
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, message));
+        }
+        else if (b == null)
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, message));
+        }
+
+        if (!a.equals(b))
+        {
+            throw new TestFailedException(SimpleTestResult.failed(this, message));
+        }
+    }
+
+    protected boolean areEqual(byte[][] left, byte[][] right)
+    {
+        if (left == null && right == null)
+        {
+            return true;
+        }
+        else if (left == null || right == null)
+        {
+            return false;
+        }
+
+        if (left.length != right.length)
+        {
+            return false;
+        }
+
+        for (int t = 0; t < left.length; t++)
+        {
+            if (areEqual(left[t], right[t]))
+            {
+                continue;
+            }
+            return false;
+        }
+
+        return true;
+    }
+
+
     protected void fail(
-        String    message,
+        String message,
         Throwable throwable)
     {
         throw new TestFailedException(SimpleTestResult.failed(this, message, throwable));
     }
-    
+
     protected void fail(
         String message,
         Object expected,
@@ -44,20 +148,19 @@
     {
         throw new TestFailedException(SimpleTestResult.failed(this, message, expected, found));
     }
-        
+
     protected boolean areEqual(
         byte[] a,
         byte[] b)
     {
         return Arrays.areEqual(a, b);
     }
-    
+
     public TestResult perform()
     {
         try
         {
             performTest();
-            
             return success();
         }
         catch (TestFailedException e)
@@ -66,21 +169,21 @@
         }
         catch (Exception e)
         {
-            return SimpleTestResult.failed(this, "Exception: " +  e, e);
+            return SimpleTestResult.failed(this, "Exception: " + e, e);
         }
     }
-    
+
     protected static void runTest(
-        Test        test)
+        Test test)
     {
         runTest(test, System.out);
     }
-    
+
     protected static void runTest(
-        Test        test,
+        Test test,
         PrintStream out)
     {
-        TestResult      result = test.perform();
+        TestResult result = test.perform();
 
         out.println(result.toString());
         if (result.getException() != null)
diff --git a/bouncycastle.version b/bouncycastle.version
index c7e252d..e258c89 100644
--- a/bouncycastle.version
+++ b/bouncycastle.version
@@ -1,2 +1,2 @@
 BOUNCYCASTLE_JDK=15on
-BOUNCYCASTLE_VERSION=156
+BOUNCYCASTLE_VERSION=157