diff --git a/core/src/main/java/org/bouncycastle/asn1/misc/MiscObjectIdentifiers.java b/core/src/main/java/org/bouncycastle/asn1/misc/MiscObjectIdentifiers.java index e8d11f312e..6dda4a17f1 100644 --- a/core/src/main/java/org/bouncycastle/asn1/misc/MiscObjectIdentifiers.java +++ b/core/src/main/java/org/bouncycastle/asn1/misc/MiscObjectIdentifiers.java @@ -167,22 +167,22 @@ public interface MiscObjectIdentifiers // COMPOSITE SIGNATURES START // -- To be replaced by IANA - // Composite signature related OIDs. Based https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-10.html + // Composite signature related OIDs. Based https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-11.html // The current OIDs are EXPERIMENTAL and are going to change. - ASN1ObjectIdentifier id_composite_signatures = new ASN1ObjectIdentifier("2.16.840.1.114027.80.7.1"); + ASN1ObjectIdentifier id_composite_signatures = new ASN1ObjectIdentifier("2.16.840.1.114027.80.8.1"); ASN1ObjectIdentifier id_MLDSA44_RSA2048_PSS_SHA256 = id_composite_signatures.branch("1"); ASN1ObjectIdentifier id_MLDSA44_RSA2048_PKCS15_SHA256 = id_composite_signatures.branch("2"); ASN1ObjectIdentifier id_MLDSA44_Ed25519_SHA512 = id_composite_signatures.branch("3"); ASN1ObjectIdentifier id_MLDSA44_ECDSA_P256_SHA256 = id_composite_signatures.branch("4"); ASN1ObjectIdentifier id_MLDSA44_ECDSA_brainpoolP256r1_SHA256 = id_composite_signatures.branch("5"); - ASN1ObjectIdentifier id_MLDSA65_RSA3072_PSS_SHA256 = id_composite_signatures.branch("6"); - ASN1ObjectIdentifier id_MLDSA65_RSA3072_PKCS15_SHA256 = id_composite_signatures.branch("7"); - ASN1ObjectIdentifier id_MLDSA65_ECDSA_P256_SHA256 = id_composite_signatures.branch("8"); - ASN1ObjectIdentifier id_MLDSA65_ECDSA_brainpoolP256r1_SHA256 = id_composite_signatures.branch("9"); + ASN1ObjectIdentifier id_MLDSA65_RSA3072_PSS_SHA512 = id_composite_signatures.branch("6"); + ASN1ObjectIdentifier id_MLDSA65_RSA3072_PKCS15_SHA512 = id_composite_signatures.branch("7"); + ASN1ObjectIdentifier id_MLDSA65_ECDSA_P256_SHA512 = id_composite_signatures.branch("8"); + ASN1ObjectIdentifier id_MLDSA65_ECDSA_brainpoolP256r1_SHA512 = id_composite_signatures.branch("9"); ASN1ObjectIdentifier id_MLDSA65_Ed25519_SHA512 = id_composite_signatures.branch("10"); - ASN1ObjectIdentifier id_MLDSA87_ECDSA_P384_SHA384 = id_composite_signatures.branch("11"); - ASN1ObjectIdentifier id_MLDSA87_ECDSA_brainpoolP384r1_SHA384 = id_composite_signatures.branch("12"); - ASN1ObjectIdentifier id_MLDSA87_Ed448_SHAKE256 = id_composite_signatures.branch("13"); + ASN1ObjectIdentifier id_MLDSA87_ECDSA_P384_SHA512 = id_composite_signatures.branch("11"); + ASN1ObjectIdentifier id_MLDSA87_ECDSA_brainpoolP384r1_SHA512 = id_composite_signatures.branch("12"); + ASN1ObjectIdentifier id_MLDSA87_Ed448_SHA512 = id_composite_signatures.branch("13"); ASN1ObjectIdentifier id_Falcon512_ECDSA_P256_SHA256 = id_composite_signatures.branch("14"); ASN1ObjectIdentifier id_Falcon512_ECDSA_brainpoolP256r1_SHA256 = id_composite_signatures.branch("15"); ASN1ObjectIdentifier id_Falcon512_Ed25519_SHA512 = id_composite_signatures.branch("16"); diff --git a/pkix/src/test/java/org/bouncycastle/cert/test/CertTest.java b/pkix/src/test/java/org/bouncycastle/cert/test/CertTest.java index c8975dedfa..296b5efc40 100644 --- a/pkix/src/test/java/org/bouncycastle/cert/test/CertTest.java +++ b/pkix/src/test/java/org/bouncycastle/cert/test/CertTest.java @@ -5423,27 +5423,32 @@ private void checkSerialisation() doSerialize(attrHolder); } - public static String[] compositeSignaturesOIDs = {"2.16.840.1.114027.80.7.1.1", //id-MLDSA44-RSA2048-PSS-SHA256 - "2.16.840.1.114027.80.7.1.2", //id-MLDSA44-RSA2048-PKCS15-SHA256 - "2.16.840.1.114027.80.7.1.3", //id-MLDSA44-Ed25519-SHA512 - "2.16.840.1.114027.80.7.1.4", //id-MLDSA44-ECDSA-P256-SHA256 - "2.16.840.1.114027.80.7.1.5", //id-MLDSA44-ECDSA-brainpoolP256r1-SHA256 - "2.16.840.1.114027.80.7.1.6", //id-MLDSA65-RSA3072-PSS-SHA256 - "2.16.840.1.114027.80.7.1.7", //id-MLDSA65-RSA3072-PKCS15-SHA256 - "2.16.840.1.114027.80.7.1.8", //id-MLDSA65-ECDSA-P256-SHA256 - "2.16.840.1.114027.80.7.1.9", //id-MLDSA65-ECDSA-brainpoolP256r1-SHA256 - "2.16.840.1.114027.80.7.1.10", //id-MLDSA65-Ed25519-SHA512 - "2.16.840.1.114027.80.7.1.11", //id-MLDSA87-ECDSA-P384-SHA384 - "2.16.840.1.114027.80.7.1.12", //id-MLDSA87-ECDSA-brainpoolP384r1-SHA384 - "2.16.840.1.114027.80.7.1.13", //id-MLDSA87-Ed448-SHAKE256 - "2.16.840.1.114027.80.7.1.14", //id-Falon512-ECDSA-P256-SHA256 - "2.16.840.1.114027.80.7.1.15", //id-Falcon512-ECDSA-brainpoolP256r1-SHA256 - "2.16.840.1.114027.80.7.1.16", //id-Falcon512-Ed25519-SHA512 + // TESTS REGARDING COMPOSITES https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-11.html + private static String[] compositeSignaturesOIDs = { + "2.16.840.1.114027.80.8.1.1", //id-MLDSA44-RSA2048-PSS-SHA256 + "2.16.840.1.114027.80.8.1.2", //id-MLDSA44-RSA2048-PKCS15-SHA256 + "2.16.840.1.114027.80.8.1.3", //id-MLDSA44-Ed25519-SHA512 + "2.16.840.1.114027.80.8.1.4", //id-MLDSA44-ECDSA-P256-SHA256 + "2.16.840.1.114027.80.8.1.5", //id-MLDSA44-ECDSA-brainpoolP256r1-SHA256 + "2.16.840.1.114027.80.8.1.6", //id-MLDSA65-RSA3072-PSS-SHA512 + "2.16.840.1.114027.80.8.1.7", //id-MLDSA65-RSA3072-PKCS15-SHA512 + "2.16.840.1.114027.80.8.1.8", //id-MLDSA65-ECDSA-P256-SHA512 + "2.16.840.1.114027.80.8.1.9", //id-MLDSA65-ECDSA-brainpoolP256r1-SHA512 + "2.16.840.1.114027.80.8.1.10", //id-MLDSA65-Ed25519-SHA512 + "2.16.840.1.114027.80.8.1.11", //id-MLDSA87-ECDSA-P384-SHA512 + "2.16.840.1.114027.80.8.1.12", //id-MLDSA87-ECDSA-brainpoolP384r1-SHA512 + "2.16.840.1.114027.80.8.1.13", //id-MLDSA87-Ed448-SHA512 + "2.16.840.1.114027.80.8.1.14", //id-Falcon512-ECDSA-P256-SHA256 + "2.16.840.1.114027.80.8.1.15", //id-Falcon512-ECDSA-brainpoolP256r1-SHA256 + "2.16.840.1.114027.80.8.1.16", //id-Falcon512-Ed25519-SHA512 }; - private void checkCompositeSignatureCertificateCreation() { - try{ - for (String oid : compositeSignaturesOIDs) { + private void checkCompositeSignatureCertificateCreation() + { + try + { + for (String oid : compositeSignaturesOIDs) + { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(oid, "BC"); KeyPair keyPair = keyPairGenerator.generateKeyPair(); @@ -5451,7 +5456,7 @@ private void checkCompositeSignatureCertificateCreation() { X500Name issuer = new X500Name(subjectName); BigInteger serial = BigInteger.valueOf(5); Date notBefore = new Date(); - Date notAfter = new Date(System.currentTimeMillis() + 1000*60*60*24*365); + Date notAfter = new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 365); X500Name subject = new X500Name(subjectName); JcaX509v3CertificateBuilder certificateBuilder = new JcaX509v3CertificateBuilder(issuer, serial, notBefore, notAfter, subject, keyPair.getPublic()); @@ -5467,58 +5472,485 @@ private void checkCompositeSignatureCertificateCreation() { cert.verify(cert.getPublicKey()); } - } catch (NoSuchAlgorithmException | NoSuchProviderException | CertificateException | OperatorCreationException | SignatureException | InvalidKeyException | TestFailedException e) { + } + catch (NoSuchAlgorithmException | NoSuchProviderException | CertificateException | OperatorCreationException | + SignatureException | InvalidKeyException | TestFailedException e) + { fail("checkCompositeSignatureCertificateCreation failed: " + e.getMessage()); } } - private static String compositePublicKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIFfzANBgtghkgBhvprUAcBBAOCBWwAMIIFZwSCBSA+LrUqGdS5RSYzFWfGEmNS\n" + "ZhiNF7vW+lTyoUESmu1iWjPNA8ILNB8fyxMi3TApDYNHlniiz7ogh9VKvGuUWrgl\n" + "IUoX+f2FaErDnh3Fz24xpO7n0j7E7dqZYU0iSUTFekex+rRxr0hCNtuZQ++qYVSa\n" + "CQOxScsuWrLjSW6Q6KzVAeHGoJIAL28JckUZ8KCg6AaMyqZwIFIw6NJ678K4c+Zy\n" + "mFSusvyQ7LorxqAkHl03RGLy4BjMohDA2SzVW3W3Eez6rjvWoM8XMu8pWN1kJaqi\n" + "JQLQx/HPqgnu1qmgcFqmTWHil6Z0sRH7XSZyhYpU4rNZr9/1yxFCw0WjYymATrzt\n" + "CAGpfSzf8Igg/NL4mhOpSNkCzDnnC7ge/kskDHgHCDVWGPB9myTcXmVRsgCd53rh\n" + "CDhR8csztl29tzYwgSqkraNTnfrlMPY9iMCzi/V9ShMfh60DoOBRsLjxr4pDra88\n" + "vzHekDm084lEIghrkNZdswmCxELZSGpsPsiVyn32k4y1MdTorhiRTZn1Q+NlSk7t\n" + "YH5XzdnDY4DByL/azaAQ4IThHc9tn9fra8icox4Ov3pdDosvyu6pvUEPpQv8vfOM\n" + "vm156SFgS4JEj/ykqGF35E+9F96IS0aM9GBTjLQnM52DTm85BYSELx+EYb2AHxAr\n" + "jhD4fUXnjK/g5V1kxBLxFmAxBmU/PGNkYILrOdPxl8f79LH6+PCehgZS4QqzF943\n" + "FqO53B62Cp7F+zE2xpvUXeZ2ThuGGHce2cEE6lADa3Y3vX0rON7oWRHpBXRbSeP0\n" + "X85TS0M6svSpgR2bMou/a7V2+NFHcU/dHteOqszhL1w1wxDcEnoy+FKNnVS3U/pi\n" + "bFcGWzG63mxEgQc/wU0n7bBvOaFj29jnSmm6KsQrC/2J+AlX3uYqGCA4F3vzhPIP\n" + "bj34TfUWPCIvgdGey8M5PDbNpj9yVXELTN3EEViFTA4W3+yr7Pf8Z9GlwJ6Oxbic\n" + "E57oif1mKLRa3eIQ8R6T2/bTYCON1OtU///WJn8kE0A1Yayyr7AlBula/tM69aW0\n" + "WctoEda2TgcYbDmE4fdMtgwKCfCjw2zP88KLiQUs3m6ZcBvx/CqKmB6xZpx5pNYq\n" + "WqP4/YxhYLiTK6BNjW3gw5N1V+zIcTokeCClwwIzP/roO/sS2sMu1Y6znLfmawsY\n" + "7aK5bmb/icPQU+DPq/v6YIxwTq2FYNxrsXSjKs+JJG0PqYeRXJ8GJfLbYMHddSaR\n" + "CEXgYFIvAw4vn1Zqqqpm7OnRaIbV4EtzzxXDdy+vZUnMFs6hPEpGYCb+/DHYCfND\n" + "QMpb5Xxcn9ighN0dzyL3pPvliPQIFgmpniuPpXnv1eBAmjc4UQlfMgyhfCXngUNR\n" + "CjOJjEhWF+p4+26cDf25kLhO77gpog2JrV963GkQhHSyXoipvs0tK2/35Ec4/+bt\n" + "2mbT0kErQyRfQw73E0OHO3TmHVExqCvqLQFkonEyYL+tD9ne0m3TGFmokcIItgUk\n" + "09dAfeUOlcfvRfGYZlIxLTIFgep6UamMK+XNuOUNoq9S0UA7JZM+8YwCB61jI3oG\n" + "Vq9Y3ohtQAr5+3HYwatD9a2Poks6Fqr0UCc0F0CSPLaqdiEVbZW92b+z44c33KGo\n" + "E7QJgNfLsMazHsI+6bC5Ss8edJ07tGUKpiDzvQhMlvTMN8aqIyREuqSqNFc1CbF6\n" + "v2opDdRte5aeGJKrVp0H5EO9oIkAsDwJ/cfroye514dlJ/CQuBYzARnueVghPWti\n" + "BEEE5WF0F9l42el2mFaXWuOx5LvkUe5rxqlps10b0sgHUls5PPOeslgT9bVzhLu7\n" + "Uuwkv4949UUnIzx58SRKIJ3DJg==\n" + "-----END PUBLIC KEY-----"; - - private void checkParseCompositePublicKey() { - try { + //FROM RFC, SEEMS WRONG FORMAT +// private static String compositePublicKey = "-----BEGIN PUBLIC KEY-----\n" + +// "MIIFfzANBgtghkgBhvprUAgBBAOCBWwAMIIFZwSCBSAA9DTYoQys3PVrayi9zTam\n" + +// "kTzpqf6vuNI5+UaMENvnrq3Rps5LmiQ5gSXaQMu0HYjVpCEQVQWl/8nbJavELelk\n" + +// "gCVn528ndGBQUChAnffxhRdxgaFmOb2SEySTnHIh6QO1UFPO2kGiGx9zU6F9xZGK\n" + +// "FZFBm8B076UvRHCbaw+BTvu4o+Kg1irOFRPI3hLN4ku3si2nwWSZNhDoiLaPTfJe\n" + +// "7TRziBznEyrnSV3I2Xn7QdKxIWUFOwPXWBnnk/FGG/A2HdxGpiqIWxZ0gNLNcb+j\n" + +// "Cz6CWZSJhoOLoJWdOD5zyojPPrH5iFIGM96p0PZ4mv5PhmZDPA/RTIg/PcG1rywn\n" + +// "OJYqAsazntGyEhHEFLRe8QYOVEbiBuv20tNzkFaaulQRdW+boStcW8NefSkKG/9D\n" + +// "FgGnyR87W4Z/ieHEyIva4FBamvRm60xrblAyI0Z7II4l7LTStDzL/ghFq06RVria\n" + +// "au+mY5laq8rAGmRbWkUxNeKeGOVHxjGFYB3uaAkHef0o7tSMMkCSSjiDQlNk5ReQ\n" + +// "xgJMkuTRE7YRN1bDXv/0uPPjg7zfa3M0tMCD9wTXFhIk04HDLVV5WAsH0EK6Nytd\n" + +// "gqnsjGCwfZb2+Fw/QytBei50DUBHpIG3da4dBrxcaRTMiQPzPzL8FaDascE0ZIJM\n" + +// "9ilKvxgq02ryEHLGALFN8eZD1r6zq43KFlRzaynWBWqJ27MiUzK2dk8oC+dH5cz6\n" + +// "+xGXAhLJ+MipoO9k9dLg8re3dOAufsKaY5DLuuluo7dO6IF7rG9xblbiIzWpyfu3\n" + +// "7kJvUdwk36QzsQNGsxpELk65LaWYnaebV7wKyIaaniLysuNCG0dIcAicxRNLgpX9\n" + +// "jic5pi+BzlJI1IuPk+DqOG57pNnU7lTg3op08MUslNyeUH5yaag8DNsLG7uZHzvx\n" + +// "jcqffaqcqS+v6FVmbV2tDF07jn8a754Fnn/QNgsNcdfw9Ov4w7Ty+q5nT2wg2Lsg\n" + +// "bAuzN6b6FiWEuHHMw/I5aIL5cLj2GUpjHtlUHL4KEHpxZ2J5jbBgeqpTWEy1TuPQ\n" + +// "R34lryVASmue/kmk2liah6wNK5RXlGa8uidBm7RT8b5SkIMsrosLx9KpC5lKobzn\n" + +// "8ttK1NSy0ZuMDw9wtnePUbROGjEuw5Na/K1VgO68dATj/7rscvz7C+ZuQORrt88X\n" + +// "+OZmoyw+fEDWAocDnhzI6rJIHLPB0p+rSJ8iSKZpFZYeIy+CD0t6E98RJQHll8BJ\n" + +// "lLyJiMT0xAyelOMzrCJayHxD01aLw6LLOddFbiIRMq4lni5Ha4noWmdO2C80xy3A\n" + +// "jskUEK5sbD8KFl910JUHwaGvb/gDCqW+n10mRa9+cB0tRVjo5OZeSiB01Bkagu7a\n" + +// "f+bRv2i8cBa2ZoGVyW3xFFFhIkHzLgHaU+RLaGwJDe0qxKtwKYz5c/YpAsH+lodM\n" + +// "NV2E/PzHtNY+sg0PijblN6IVO+yiLkxJspKIjf0I1+s8hczhz3QkLRed7dU2nvID\n" + +// "puJQfgraKyS6rawlqLyWo66/PDtdd3tngw50wnDNZik0hz/usDc6o7IN5J9ha7XO\n" + +// "0vZQluMb9R5l+W6RLD2nRd4mlKVqm/Yfq0R8PKoIh8f7uLVk1kbN4prkfpsokvqR\n" + +// "rli5h4URG7WCNvp4bg/i1Ix/CEEjH56LRj83dhVB0O6WXorrZMAChQShMhwnEgeS\n" + +// "USaB5au7xRAM+9fWvF9cmju3hXSTT1zv0owyoSgp36OHcy2HzwZXxA7YWtRDbhMX\n" + +// "BEEEkSZvSVDhZlBXhAkaTBxlrRt624URpHlDVrd0njnPiR92XNs+NTjjvAImETMh\n" + +// "EPbQ/KPspugi6gkrLFhcmy/OiA==\n" + +// "-----END PUBLIC KEY-----"; + + private static String compositePublicKey = "-----BEGIN PUBLIC KEY-----\n" + + "MIIFgTANBgtghkgBhvprUAgBBAOCBW4AMIIFaQOCBSEAAfUZvANXzRUNjxYhBQ1c\n" + + "cfVgDKTDcnUedgGRNoIgXqay9wvF507qUqNVHCNW51FEBTAYRexzouhX0uX8VPce\n" + + "UMjxHbj8NPWSGTYLAfVFl0hVuItIjNySRJTStp/+61LVOOUbiDO7rirlwdRowzSd\n" + + "it0piamVt4M9bseekiTJEmQKjdAcf6czHeXs+agQawoyB8TNrAKpwFuv2Mzp/dXr\n" + + "OmPXeYwepkzpceTOGL0d7q9ktSyarCFjK8TfiESu8nNpRRsW1BvOwk8x2DRHU3Zr\n" + + "SVSB0zSreEeauO8BW/9mBks38yuBc0q51Mi6gOw9NRRJkvDyO/i8DMEFoaW83Off\n" + + "sYEJD6D0McjORqsx8ybpbTzGhhGThy4UMFq+Nkoz9UNPXFBK2KpatsM7s4uny6+Y\n" + + "PzKauJAgQAE4E/rdHDYzZjRrwfMEMNcRqP1iFwa7Dkeh/yEm1Cp18RmzgC73wsWa\n" + + "ArsbIiKnncomMFkhswtoUOZXKhdpVwFw2VbzTaThIXwGulx39NJ7WEF5bXTas47q\n" + + "xXhHOhEZYjqKmBAgATRyEUy5eScti4I/BLPq4uzg2jj71CHprsLMRnktbC4h0pds\n" + + "4RgGapViXgh7aUAeg6t+u+Y5N/pcS43tSsY8SEwdlEWvW0qIqOma7Z4yxROsdvxo\n" + + "Ne+qry1XP1KU3xV7HWftBIXt3Jq+X/OiMBDzmxme+tpkXRxl5mZiu8XfyXOc6BA/\n" + + "DWJPJh0D5zAYWTsXfdYrevCq+ZlyNDbxZFBRUUvuC9EWjCQCxCpaVTK8pPR/56rQ\n" + + "90lsY8zxSZlXr1rUUvObyOjH7iHg8kHl0CV1P43YiVMtHFy9ypesvidE/mjwoTOD\n" + + "viFS7ggJsDSWms38DToKKeqP8Yf8TIFApX06IKP9XC6tN7hlmFtI1WR5TgHz1jNt\n" + + "TjmeW0sUWl7R/OFt1elZZ4Ch964YLs4LUtJcQiM1yWq5oIlDQB7Fh4UdGtFywXVq\n" + + "FZJfrL5K1iSkxvPR3/eNVTlQg6GacodN5AcLIhw6yfolpub+7nJc7EQQhFM0fQP/\n" + + "T6SgAripEnHr9kq0p9jjlCwuIwbWVoQwlJHI6j3MV3HreNsIoVGyUMOyky1XzhyK\n" + + "Aycuc10xiLOfrD/uletXUeti+q9n/RMXTDtQyimrhdU6NjZRnsH5nRabiJqh07Kf\n" + + "LB7Xy3q9Tl9h2gPwB+6cTKevWdlzjeMdkgDeExrjedLqqUvmbAp9qkW48tjKvlzK\n" + + "IueQKZCgfB6nO3rBHGpmXpGx8+k30n0MuTS8dKBFMQPj2dAtIjWBYa54spKMp6DC\n" + + "aKvEJQt8pCW8PvndiBZP/VjAASx48AjnudSY65lCI4vuYEfxz3TL9pILHctN5rSp\n" + + "QsEpPGJkXLLT6LghD5mvC0wQ8dZUuHDLLB8gCj5kQmkhbewwlsnBtvv+PlA6rv04\n" + + "/p+19bNWXCPSQmVsAv8uabbU5LVCMMIpX7H1qFGYusSRwCN0IWBcnu7DqYioBK9b\n" + + "IajnQ9uCz3GIjVPGrtv7cNadz+fg4ftUAKNp00xUAyKgwv2z/ua88MOgubZpIKm0\n" + + "dZrR/tT15ooFtITzNJCkc5a0ZAGGQ0tM/3jpVHT1/MR72UVbTfaw748D6QKtHfwh\n" + + "u4mo6yEIwdWT7qVJ4wBif9JsobQPLj+lxKElImvKM1Tfju2tvXSrhaFLn1mdJN/0\n" + + "LHZYI9S6vX7DZSMt4ZftCF/wbw+WRI4AQyTzVvmHlzGZclp2GNB7otb6QyuFvL/P\n" + + "ZANCAATHm/6T32KQqwVlru4STRGF+wpZJhefwbywRmy+KKrElphc0NkVA95wBxWu\n" + + "dGgRaoHi+K93jgNwPC3Y2ZfSX5xj\n" + + "-----END PUBLIC KEY-----"; + + private void checkParseCompositePublicKey() + { + try + { PEMParser pemParser = new PEMParser(new StringReader(compositePublicKey)); SubjectPublicKeyInfo subjectPublicKeyInfo = (SubjectPublicKeyInfo) pemParser.readObject(); - isEquals(subjectPublicKeyInfo.getAlgorithm().getAlgorithm().toString(), "2.16.840.1.114027.80.7.1.4"); //id-MLDSA44-ECDSA-P256-SHA256 + isEquals(subjectPublicKeyInfo.getAlgorithm().getAlgorithm().toString(), "2.16.840.1.114027.80.8.1.4"); //id-MLDSA44-ECDSA-P256-SHA256 CompositePublicKey compositePublicKey = new CompositePublicKey(subjectPublicKeyInfo); isEquals(compositePublicKey.getPublicKeys().get(0).getAlgorithm(), "DILITHIUM2"); isEquals(compositePublicKey.getPublicKeys().get(1).getAlgorithm(), "ECDSA"); - } catch (Exception e) { + } + catch (Exception e) + { fail("checkParseCompositePublicKey failed: " + e.getMessage()); } } -//FROM RFC, SEEMS WRONG FORMAT -// private static String compositePrivateKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIPmQIBADANBgtghkgBhvprUAcBBASCD4Mwgg9/BIIPAD4utSoZ1LlFJjMVZ8YS\n" + "Y1JmGI0Xu9b6VPKhQRKa7WJa8O4O357Umw24m9Pd/Jg06IDz9AmosfLTjayQT5j9\n" + "tRaYa9SlMtuRa++YF0vtPF5KCc2GSbvH8nHNJaKc8to8JSCAYIKyJNtEchq1gIoG\n" + "ZYDCZKIQkSDFaSRDKSKQcRmIYVkUSlsAAdoiKcTEZJQoLQGyTIgQAViyaWAkERwR\n" + "DSNHYRhACcwWJhMRJROHLFoWScIGMpFIkQIBUEGEUIEyShPGCJPIjaPECZoYSACn\n" + "jYNIToxGSIKgEViAkEgIQRDDhFsGbQwxjuJIMUumDBNIgRqnkQIxJQpDiknIaeJG\n" + "ZcLGSQITclFEcJIojNMwQVsEDUA2ShsWiFlCAFA2Ssy4gNGiTQHISRMWglG4EEgi\n" + "ShFHCSDDYYQiTdgQcIgYLCMyERskMpIUMsM0aRJIgaAmhmCIBVlEQBSZSAEZcFoG\n" + "iQGnQREmYgA3aBi1aQQzMGLIjcDEiSEATiE1EBmEcQwzIMnGUUAySYEicuOUZQuU\n" + "CeNICaIETYKWjQOjkIuIcZQgRZyALQIiIsQEIJuSkBQjQAmDZSMXIKKCDYjGBWSA\n" + "ZZAgKgwpDKEkkVlGJtS2cAMZQAyjTFRGjRyFaIg0JoRCjEgEIeQiENEikBoFiNw2\n" + "TKKiBRA1UFwWheQiJhLDLeGITMwSCQPAIdioaaAGJNy2AGJILUwGgFImBsPEYcvG\n" + "QZQGLokSaViyYco4TMQ2MJEyRIQiEKM4LFEkckmGiUCkbQFDbhIWYgOEbBwAjNCw\n" + "AZlIEhEDYhmzMAoxStQ0LUQ2iJK2iCCDMFggTQklSJvGDMigMZnCSZM0LBMzLKIG\n" + "BhA4MAFAQgGEjQTCAQKyJFoETCMUAgvFIWSIgIEEbQA0TdIIYRoXbiM1JFkiQIMU\n" + "jWK2RQkBShEFiJCQDYhGCQHEDZkiBQmWQIwUTSAGDhMWhQuibaQSjcEIDFG4BQyH\n" + "cJMGLgkUaMsQgEASghCkjEiQcIkiRtCyMAgFYMCkLRqjgRJJTJMUYIM2TVAwTtQm\n" + "TQE2QiDCcQu4DKQQKQqQSYFAbZjGZASFRYgkZJQWhAoQRpnEgApATUA2IUoiDKQS\n" + "ZhAhBRqVjQu1gRRCjpsEKtTEYYMAkEOQDRo3hJMybAlJRKhhTP0aKQwPSKB9pfN8\n" + "dXgHTPuxm9SWLRPY/gp4oA0bg8Hi1uxCqZ9uuFIK8BmEpgsPO73JCbkyewPYmUmB\n" + "/9neuGdRvAmmoNOoFxt9FlroZWFB3wMUxYXuKUiuT91s0HZC8n1duwJ6gMbmNZ4A\n" + "sKiAZaJdKrKwF/pdx5qIgcXQ9wAngvTgGkiBH+EoNY2qLTnZ/4OdWFAho8DTOfxu\n" + "ViRPNgpuKIKZti4Cjh7idxNbx3lIXoZOZOeqs8Cw6nw7JLpGlW1dCjebe6mKFjyL\n" + "b0NaLc37kheNeyEUxL4hvsF9AdxDHaIJ6ARyH2Rg1by6XrvfXEIXz9KoYzGhuB+V\n" + "3roTAuM5026aHNZGNhMU53xUomAPj97DQK6o5q0D+0vxb3xTrVHvZc/m8IMgxlLa\n" + "mikqmxORaM/qr2EghWLkcMlgeO8VkrB/V7Oh9q8GVsiDN7BnyGd7LiUHdtFwEUZZ\n" + "ezohR9jea6gfwxVeqeVHA8STfFZIP+/fYUG6p7X0ixvOGYlBGRKMoLtZqGnzO4Ii\n" + "3subCMfNs9i+O1ZHPvd3O9jmalv5pMTWKbda2uQqDW9SkB2ZNSKJBzNfO0g71Tg3\n" + "L1ObdgOWPxEC97GlKmeaI6zlJ5zeZqRURrj+7vnNqyxniC9YzPE8vNKa6JxAKjPm\n" + "ubb6umaQeFOnKDuqM6g2/f+kAKZiZ8kmywFNQuizw7d2cXoWD4d4yRJgNd7clrUI\n" + "yV5ZmX9rGayTckfcq1rqp9IhL3vhiMXxq1DXhf7EUVCVn3kRT3pFOfcajV/GdJk/\n" + "wXmm25M5/zCFdls0AA1hjL8tvYxPwlAHNwVysdXsUPgy3WpeZumR52EM5twEcDbm\n" + "+G/1xAkTLR2sCzAZz+Z1ieQGpchsj8bKZIsJ0h2r2sZgdyzXHT8UpYVGvSbObZAV\n" + "+s3kiRzJfW0nZLd+zAtqXAl1fZhpGxBvFJz6bZ1YeYwfvR2gIkoJ8kYfmUC9OiIr\n" + "UYwQ4nshLbUrkfkcotqlD0Dl9f4SZZuaezIcUWmpw7PGm9eEbIg9Kw1UBDoJ3eK7\n" + "SBEEGyNDeYQJzuIkAlN++RL9kNV/86cSSvJraRSqAbDcABxvt5C1ltGz6546czCj\n" + "CT21LFtEyjkWaSsc1/1GzEyJ7/dLBvB98IHeDECupp+5Qi3NOmq8mZ3qsAvbhDLW\n" + "uYYJQQ7oKEv+R0Rr2TRRBghUVmVjSBb2B17kNBqDK6GiVzQQHR8tKymvx4x4O6qe\n" + "E0Jh8paay+Vfe8lfjJ+kw244BETG/Nocxn/XTOdBlsqAed6wbpABRAQU4ih+xX/r\n" + "KNNBs5HhtZKbVuyO8mItkjh2Waw6BVr2oKUiuwqtWfvgfF8/HwOUYNkjmyF0/cVB\n" + "nUOK1z2Ae1H5SYbnWNKgdcvRp3PxAAnNhHezLwi0fmQ73JZMty4RaifZLjqLcNSd\n" + "T5oKJFiNaow1etsRg2LkbJhQKwmI79KKhzTBs3fnkwgX5VFpX4EAfHeVNqHkCrok\n" + "wUE3qAw2UogT64AWIftOZ1PoS3IdJey1aEVuZRcGzGSWwCPvnwYuGZ9PqWQpq6sa\n" + "DIDbhJ/gR5LeqVjCtxPdq69NQ2FprkDgVCI1p6HVrzdT9e9GaGVotHnm6SmfURA9\n" + "gUkccwkmdKbE5JzKNkqsv/n40KIm4g+70kCM3CPNlnSKfqUXTMUEeXfD9uycS4qv\n" + "VcvI+wy71DtDgnvR/gatUvCwhxLxbNSavd2rqvVBVUPgL3yysptalzY4awvYHG5g\n" + "9MfjVoiJ/eJMIAGOdg3g93W1dt4mPzYOWffwvmDXa1Z1HPMSaQjky566xV51UlTZ\n" + "fA6iMlepUJvHE62gHl7AdqU2SFKQ476M2rDajfezVRbCaqTvDyjR7qiaNZ2aG9Ij\n" + "183yiv3CNzXpFDpU8mrhK2X4N48iKCBDleC7Qn2/PTzdN/77DZAM72qbOmrf1DeB\n" + "v9xPq1tGa8drPI7/KmzMR2lJr4f3IjNteGmcOtOe0i/wdIyN483JluYFc85oc6WC\n" + "zR/RGtBEaxWNaQdC3SeqV9t0z1HZRqf25Sis2Gv/MBmEvg2co7sv7b7o0NSZBKzr\n" + "dbnrm74uLtysUxCRoC6Ld5UES0tQr7Euv8qHHCsw2qOMzLpnYcrsL/KFTQFGOoAI\n" + "YSVTdZoz/gWvC3NbLGDDAzCHRIlkNBZrMi/MTYn8s3njHLnA2YWqUg+eE8GDmDl0\n" + "0//8ckvv5hNXpTT4i0NaNq8QPi61KhnUuUUmMxVnxhJjUmYYjRe71vpU8qFBEprt\n" + "YlozzQPCCzQfH8sTIt0wKQ2DR5Z4os+6IIfVSrxrlFq4JSFKF/n9hWhKw54dxc9u\n" + "MaTu59I+xO3amWFNIklExXpHsfq0ca9IQjbbmUPvqmFUmgkDsUnLLlqy40lukOis\n" + "1QHhxqCSAC9vCXJFGfCgoOgGjMqmcCBSMOjSeu/CuHPmcphUrrL8kOy6K8agJB5d\n" + "N0Ri8uAYzKIQwNks1Vt1txHs+q471qDPFzLvKVjdZCWqoiUC0Mfxz6oJ7tapoHBa\n" + "pk1h4pemdLER+10mcoWKVOKzWa/f9csRQsNFo2MpgE687QgBqX0s3/CIIPzS+JoT\n" + "qUjZAsw55wu4Hv5LJAx4Bwg1VhjwfZsk3F5lUbIAned64Qg4UfHLM7Zdvbc2MIEq\n" + "pK2jU5365TD2PYjAs4v1fUoTH4etA6DgUbC48a+KQ62vPL8x3pA5tPOJRCIIa5DW\n" + "XbMJgsRC2UhqbD7Ilcp99pOMtTHU6K4YkU2Z9UPjZUpO7WB+V83Zw2OAwci/2s2g\n" + "EOCE4R3PbZ/X62vInKMeDr96XQ6LL8ruqb1BD6UL/L3zjL5teekhYEuCRI/8pKhh\n" + "d+RPvRfeiEtGjPRgU4y0JzOdg05vOQWEhC8fhGG9gB8QK44Q+H1F54yv4OVdZMQS\n" + "8RZgMQZlPzxjZGCC6znT8ZfH+/Sx+vjwnoYGUuEKsxfeNxajudwetgqexfsxNsab\n" + "1F3mdk4bhhh3HtnBBOpQA2t2N719Kzje6FkR6QV0W0nj9F/OU0tDOrL0qYEdmzKL\n" + "v2u1dvjRR3FP3R7XjqrM4S9cNcMQ3BJ6MvhSjZ1Ut1P6YmxXBlsxut5sRIEHP8FN\n" + "J+2wbzmhY9vY50ppuirEKwv9ifgJV97mKhggOBd784TyD249+E31FjwiL4HRnsvD\n" + "OTw2zaY/clVxC0zdxBFYhUwOFt/sq+z3/GfRpcCejsW4nBOe6In9Zii0Wt3iEPEe\n" + "k9v202AjjdTrVP//1iZ/JBNANWGssq+wJQbpWv7TOvWltFnLaBHWtk4HGGw5hOH3\n" + "TLYMCgnwo8Nsz/PCi4kFLN5umXAb8fwqipgesWaceaTWKlqj+P2MYWC4kyugTY1t\n" + "4MOTdVfsyHE6JHggpcMCMz/66Dv7EtrDLtWOs5y35msLGO2iuW5m/4nD0FPgz6v7\n" + "+mCMcE6thWDca7F0oyrPiSRtD6mHkVyfBiXy22DB3XUmkQhF4GBSLwMOL59Waqqq\n" + "Zuzp0WiG1eBLc88Vw3cvr2VJzBbOoTxKRmAm/vwx2AnzQ0DKW+V8XJ/YoITdHc8i\n" + "96T75Yj0CBYJqZ4rj6V579XgQJo3OFEJXzIMoXwl54FDUQoziYxIVhfqePtunA39\n" + "uZC4Tu+4KaINia1fetxpEIR0sl6Iqb7NLStv9+RHOP/m7dpm09JBK0MkX0MO9xND\n" + "hzt05h1RMagr6i0BZKJxMmC/rQ/Z3tJt0xhZqJHCCLYFJNPXQH3lDpXH70XxmGZS\n" + "MS0yBYHqelGpjCvlzbjlDaKvUtFAOyWTPvGMAgetYyN6BlavWN6IbUAK+ftx2MGr\n" + "Q/Wtj6JLOhaq9FAnNBdAkjy2qnYhFW2Vvdm/s+OHN9yhqBO0CYDXy7DGsx7CPumw\n" + "uUrPHnSdO7RlCqYg870ITJb0zDfGqiMkRLqkqjRXNQmxer9qKQ3UbXuWnhiSq1ad\n" + "B+RDvaCJALA8Cf3H66MnudeHZSfwkLgWMwEZ7nlYIT1rYgR5MHcCAQEEICNcwpss\n" + "HyyHcp4sFiQfXGBHkt4Ful/+xUioOUgxpmhZoAoGCCqGSM49AwEHoUQDQgAE5WF0\n" + "F9l42el2mFaXWuOx5LvkUe5rxqlps10b0sgHUls5PPOeslgT9bVzhLu7Uuwkv494\n" + "9UUnIzx58SRKIJ3DJg==\n" + "-----END PRIVATE KEY-----"; - - private static final String compositePrivateKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIP8wIBADANBgtghkgBhvprUAcBBASCD90wgg/ZMIIPPwIBATANBgsrBgEEAQKC\n" + "CwwEBASCCgQEggoAg4wKtjXc4F9Eg8eA5mbgxvkITgbOOoY05QuGbFj+1Wl8ZKbu\n" + "jihkWHfUXe4j189SygnUsyRSK7YEiORIj0cFb0KdPMKpGsRoyAe5fFb/HOSWx7QW\n" + "3m6VbMAD7P8hejGr1RxMRaSshRD3nUxEWdxgFSJoeOQ0DZhARSnonjN7j5USgURi\n" + "AoTEOE0gATHBJlLCOJIhkjAghClUGAEbgwVDBlEJAI7cCClDxAgTJAYhk2QClyib\n" + "wgVbAiwEQCYEoUUAFUEYCY6RGIjUBGyREiGIpEjQNALAsmiKkilUFFGTNgZgIm2T\n" + "AArSBGmgRnAjs2gjtZEhKSYkJG1bgowMGUgjNiYgIIEbx4EUhhASEy1cMgDaEhIT\n" + "tWwSxwDRJgQBgXAiNBFclISIAlKhJAxbQA4iMiQAEQJSAAQiJBHjBELRAHKhpkTC\n" + "uImaFA5EsoxQyHAbSClbGASkqEVcIjIABw0EhEjMhlHixpCKSCxawIxYEoLSQjFS\n" + "oAAYw42LtHAcmIgjM2TkNCEDCBARk4XZsoWQhCkQhIEjqYkLB0rDAA0TKQhIgFAa\n" + "MEgcICKcyChDOBEUI2XUmGyAxiAUSVFSFAwYqEmQRkAjsxEESSDUBA2csEBBpk0C\n" + "IS0KJyoBEiIjOBFaCChYxnAhBSUYtHAMIkJApmxCJkWDFEKDFGDkQEBQklEQKAYA\n" + "x1GUEmmisoQkoBATwgzURnJJNBDcMA0LoY2bEm0byJBCRCCUtkGcJEEYw2AgkVGb\n" + "tGWSFklcxogbESIDsUUahiBjAIQcCJGMFo0TQhGcsClglgGLFCqjyCjkEIJjgnHh\n" + "CGJCAImKtk0bAykJuUGKiIEJOJBBuG2QFG3JGGRBKGIEtpFLQAaLCGXUJILMmIih\n" + "iFETOYwaGWTTwhEDIoiDBnKCFAwbgogIMWCKtHDRRkiRAkkClGAkNILjgC0hhiQB\n" + "t4iTOGHBoEUbJUBQNg2AEkQMSWwMAiYJJEBaQERRIHDEMFGhgBEkp4wjIYTjQEIR\n" + "kAXLpInhFAQgEECaKFADxgSDRAoZhSDZAGQZtmASA4KiIGUZqJAIgQ0bqUCBpIHk\n" + "RCaKQG7EpGDYQIHRMhAIMSZTMmITgQwQFAAaNiSBAgICGHIiJYYhwY0UwDCMtgQL\n" + "FigCAGRCJADbtA0iIVDJqCRASI3IJARBBgKkkDGIRiVhtpHgKGAUKWyLJkH2+wud\n" + "Qow57Gpo3IoEpGNe+LPtuFoUB5AGC+IIhYcDT7QT46BxzIgjQdwQnViO3tijGN8Z\n" + "WGXYe8qUzTqxxtI5zoHjbYp3p91BIm0/iAWVuzax/V494rLu6HJcEPHzir+M0e1x\n" + "ahZdcXlmFpZW8+Q67wHR1uUGU5T//ErZimpMkDlsyiJcTQ0sHTHno/6P/S3S5qRY\n" + "01dLaVT5CuFkE26BHTd6s5oE86lS+XeD1j+7gYRjwHN1BX7vyxrzvKDOLo4m+AUO\n" + "afcp/2Q4S1wQRKhR+0zVD92aaMc29HSSyqEdf3Nn4EXTjArZIBf13QHpah/W3N12\n" + "Anopeq2ff3MfQ03e2v5AHYCxQcNDdsKuEEyDAXw/suqzc7NPozoMlz4uXEhTXFBB\n" + "pg1VSfPT+6DqOHnD3rU+9RFDOw0om6nNo2a6tGhoyGp8LSEOlos2TzaqGSnwEndj\n" + "Zsk1XqbrSrduLYaNMub/Hbjf0ZvlHztEQQNq+5aU8mHEDBOFLtZh7stcB/7+ou/G\n" + "kl+1UelRzLUDjUJ171cIsyb3DRO8423HGrc7dqQV/XTW7i88vgtY2SZCxlFiuJUQ\n" + "FZGLeEnbT4gunTey3d9AnWTxdD4HQtGUQ4D0cH9Tc+B1nGIeH38hj/cmQnlryBzK\n" + "6b4OQ0x3x4rweTVKqZjy4QmL4L6Hr9XbuMQ909bFUcvbqG2Qd5BA7W8teZcKnpzs\n" + "Wy5BpHRSdstpyziemT7RN8p0cpjbNqEP1CusuBTbPkXhE9PNUJTMjAhoGOs09PPW\n" + "/k6BpCd/nF6npqKekVJbLHyQx8XBZ2bGJbxdfDS964EBSqSsyQRRAlMq8CBPGjs9\n" + "V6fXOhxqe5uk2BHl/9DEoNgjOszcmlKh4jRb2Gu6f4J1Y5FFekqANlZdUFY+KPod\n" + "dI+Rxf0P8mIiBVSTJTcnI5Pfpr9xaoyjoorszhu7XvYKgOZ2Cnspije3OIAMZrMQ\n" + "i19Kf3ewBBfukXVG9QT1bgQFQLj9D38lSEGv9tk2HY/nFj0viS7IUt/v7tnElZKm\n" + "seHi9qnjRqPJ3YHvK0hZSOwWyZIieMevIg3J+mUYdRuJGAN4l18IySba2P6HsvpI\n" + "1j1ko8y2JWruWQDT+nlmibkBTZWb7PB1jko7VHzKJ+NQ+5JsmN46Z6mNPEK7H4OP\n" + "OfCzuN9w7APw4edfCK+kloDylG9VrOr86MwewIxoZVPb3TMYS00slDbaM4Qucnts\n" + "iceVL+ztKJdSp7Rwd1yjmB+9c+4/PtGECPGz0V6h2m+vmbtq2mFEsJ/2LanR+jLm\n" + "RuNaSfYh0MzO3aUIJAD9U5PKm0P/CwpqYhuvzwUiggE71xktXnu8wzcjsW7UEX5o\n" + "oEpXKWpaF2IFEZFjSp2KFHXQKRtHsqk7Vdb1PEktny6dwDiiFYlvqiHR9dg4poL6\n" + "ZUuitVPz1nilq7pyW4adPyHESigZ3+UyPhTa9kxkSXpcIjm+pmyRONxggNAqeyi2\n" + "5TW6eliAbfZ56DdGAUOqubztnFUi38YQ5GxuvygH5x0uOIlfmX3FRs1G+JiE98Qu\n" + "N9Shounu798QeZvEdJNBZGW6PBKXKB3h2t52W/LKKkNTp3qFQGqKmVIA+3bksneg\n" + "Bh7AD8MH7U37OggxcpvDVCr/DMCR7N03fwodpEEuMlOrZcJ25kNQHdV7AI0TTlzB\n" + "wJ9AZmn56bZAFHPNwkmraCJqxCO8B/Pdf1swCUAmejYwVGYwd9xjGixJTGublaFA\n" + "dV9ItUgGUbcLG2IeEPU88JXeliXgzD2ulOPklvGctcY3nqKtM3dldgUUPu5YZ4LM\n" + "FQF6WzYKPXIgXCAkBGRlsSeDEG2evRQDraVIFOVoKPMZvnPVxqYEmdvouN4Nw9HU\n" + "LZ9T9Zy5FZ3EVS3QsKCR1wtGYKEt8ZClIIftKTxYbj8VDhMR1MdAbz24cjWxDSdU\n" + "zE4J4aAIkaWZd+Alnux3bNLRJZEXspfn+s6Ea2IQntrELgRHS17uuz8sOOcOgzSJ\n" + "oXH6dB0ZdvmrxfDKJuJy9cmUU5QsWP/uoBdLBgDYKmkfv8eidGyPEAyYpK9AHMt5\n" + "nl3RdyuEQM30TgwwKMpzWy3R5LHDkDfBwz+Z9qZqlUdnDPE9ZyEvpZC/zasivRh5\n" + "cFkqMRpQgKsA31h2VNZuC+2cV8IONtZd5FSHusq9+d2Ng24G04HvaD5kSUIHK33w\n" + "IFGprG6DFJzblstlqTNX1vz8ukS/D9W7kxjx6oGCBSEAg4wKtjXc4F9Eg8eA5mbg\n" + "xvkITgbOOoY05QuGbFj+1WnlcSc4iZijcfUTnr8XQRIICNt6k4Z9oDUE/vAU6h4E\n" + "qkJIdB4hQ6hOOEYNjN5q3vgCPaFLUcnL+dfZKqu3XK9MJ3kN62ejwyfK2U+od1CZ\n" + "liZmXALFbxdbMYtGVHi0/k0oYIaA8NKIwiIThMKFcs0j1wPyvmUHGPuNrSMMciSU\n" + "gWqvQgZ2XUKKt4IlyjCGWhOfVqBBLQdSZ48Bkyaa7DwFk45oP5Nif1k9YqGRLu9a\n" + "VTKPh+U4GfUKf5zBXssFOy0IWlK6DQ7QnyEI+gKQwCJcBoj2RFtEuBKy9NJYAHrK\n" + "xrlFf5fu8Lu09yLupSFT5DBWkiOHWHL7byASXu3swFzE/7YOmlmW6r8RkF5EZ2LS\n" + "ysBqkoYehYajBPEK+70M+VOS2uDau51QwE+HXpI4SQ7vjUWm2Y8thyN0PuuYsb4+\n" + "FaCcGNmF1xzLY4HVkRu0AGvwrPud/tmcgpAXK7TQMLNm7MxvOU3ZUUdoWoXHF6tQ\n" + "4HpCRZnP33uLGohhiCnY6RZcGnSnMO1pvF6VvnzkQpE6gPRj1WbWEqqAmEQ7ZM/P\n" + "FGbYC6AVUSO3CP5A8dUaKqW6svh2vDqhcgXEeCACAQ58OYb1HK51fLoZkVxMefrb\n" + "FlV/HJFTEaBl4rS8Maox60cjPRmMqszsHqaM5ugCTfcGITe0L3Y/+nO7XJNtM+C9\n" + "BZ5Aij+kTGEHjyN4kdm5HGOpgsxf90KL6wfuaZvTxq2GmY4+7f1BKm2ugJjNNAHl\n" + "mFOMnXcmp7rOZJj3qw7WeUWBN2jdw9XJ5lhefHstB7D/oH5Wrj1+gJheOmvGAsO3\n" + "w3LbyiI6FfO6S0iXrVzU3PboyIdklh2HbnILEw8g9Ga10m6qqA3eSmSiGLBKJu8U\n" + "v+BI0EzH9xbIELVMv69QWkZPBjRUjoBOPG/eDVpthyngq3r/HdggYrpDzxDC8Qrh\n" + "kEBPtFLYR/nqi05XiQ2FspeQMF/1Ou8MoDdeAs6V4RyZr+z74B3QsVcDdjQocLfD\n" + "2tQOWlu5bL5xP924aelqop5I2fn+KubJ5VcDqhjLZCRMkrPUHb9m86gcI+YtRAZP\n" + "tneMnzMMky+r6rH0Kq1pIgkzrAZKrfo1Mj+Y4llAKObololsdQqgzR1HmV6xdSGX\n" + "OII00C7lAOJrtlRiokGaHXqnoXY/8jCHrZF7/0cpnuWV2Yo9eZ9YgVHB+Oi7Se8w\n" + "vQIGhlpxfIEwT86i8P63ExOeNZ24iAgGBA3GNo38F5Q/3sU0KXogEtTW5zzT1mD5\n" + "pqn3fUhi7pwjrKb7beYKmrL8bvXseQiRz7A72A5xKGqrruaHYI1fzlUuafqOGPsE\n" + "6oYhFpU9ZSC71Ys0vTka7dXX7txEVtmLj+jNbKreJ2QtO0ilXJhQSInwLJCUNI3P\n" + "ju6r1m5JN8hDNaSWCcRVZnC+PU6w4fRwsTl47ZYlnFVElRQQPcIdWkOVsZO/Dn1s\n" + "cVA5BL1E9jo2cCjkEl5IlveIm/9BwgBspGf6L/uBw4JVDqSeIFO3N0//zjn/29wA\n" + "JY05o0KH9QBgpbTjhx8xPvogPp5A4LML6vJ0thE4M4NmTaHarhU8nOTy4HK9qjr1\n" + "omrFxXEZA9/wCm+Cph9CTZ6LN2K4k+5o5mzzwnSwJIcRwqMnwoAK/nz/fsQS9vSF\n" + "QlD9DWB4GE8vok5pdyi9r09FJFsgBjMGjGe6VEEwUSq5YwrVLbBpXHUwNgub+vdJ\n" + "BTCBkwIBADATBgcqhkjOPQIBBggqhkjOPQMBBwR5MHcCAQEEIFIstPgbrDKo+h3q\n" + "Q70LLrpldAFbEscVWo6/VCh8urMpoAoGCCqGSM49AwEHoUQDQgAEh031pehYFw/j\n" + "HLn6RFMA7UZjZTpUxl/SBhz21nI9BQsgpidnrYSRClWpKAGT8VcLlpmqcfAe6Uah\n" + "8M6Ll6MSoQ==\n" + "-----END PRIVATE KEY-----"; - private void checkParseCompositePrivateKey() { - try { + //FROM RFC, SEEMS WRONG FORMAT +// private static String compositePrivateKey = "-----BEGIN PRIVATE KEY-----\n" + +// "MIIPmQIBADANBgtghkgBhvprUAgBBASCD4Mwgg9/BIIPAAD0NNihDKzc9WtrKL3N\n" + +// "NqaRPOmp/q+40jn5RowQ2+euyt08tCb8n+fyXPTeYUqTRyok4CwyZDOBvRgzjQPo\n" + +// "ViTIHTQcWno6KkNnRaLLCmpapjHbTJvbRoBb09RllNQwzuM4KaISDYuwUNikESKz\n" + +// "ZUGAIGIyMiSHReImUtAkEkTGgcQEBIAGIsQ2ZoiERQpEJVsGKRzDiCEHaYnEjBJA\n" + +// "MeSmKFkIKiAXYUoYaZQkhkEWYSSFLQkkYgoEKiICZhMAIuDEAMu2YJu2aBmXjQCC\n" + +// "ASMEBVAoaFkiAJhEUcySIaAIEQgyISMTbBM4JqLESIMmRWDISQkHTplGahiQTMQY\n" + +// "JpQ2ZKQGgWMUaNCEkdAmZQHBKdJAShG0TYCikCNCcNLAcYkgQiOhcUHCZYCGROQo\n" + +// "YOEkZiRGkFnGiAsoYEsIYCOxaFQSAYy4EYIYRsQYRNuUSNooaUQGIMg0DdioAAsQ\n" + +// "RYMghgSlUNK4gVLACQgRSAkxDIs0QhEoRoKEQMMoMMSmTWNEDqOkMRw2AWSgUAQR\n" + +// "MaSiYAgmkeFGbtuIhFRAcSQyUWMYZIKEQNo0KkmkgVsiEcMGJJQgMko2JFKGMBmQ\n" + +// "RQzHhBsAASQZbNEQcVCGYZkIjkMYKpJChKEUhQSRgCTEIaEkkYSUQeMmkmSibGK0\n" + +// "TBopYAAmgVogBmIkauGADBKHKAoVQRhCYhoXUsCYgOCYJRDFgYsCLAuiEFE0ghEo\n" + +// "UQwSAUK2AUSAKMQobSMmcRQVbEQUDgA0MNwEhEjEaAQTaAKCjAMEcAyBSVgUZkAS\n" + +// "jUIQkWTCCRQVcAA2KllIAAIRQoLELRuzaCIRiZkGbNpIgYBIAQggIuOUTIzCMCI3\n" + +// "BoIIBcuEBYLIgMmEcZmkkEAwMEGSZRKXQKIEkcGERIFCCeEyIouYaQoEhsM2jdBI\n" + +// "JhS5YBAycSEEkOSAiGIYJgiQbVKkYZLIARmXTBvJjRIWYMI0RBGUkdQmZuO0QaOg\n" + +// "gcQGjNI4EFIyBVREAsMkIRoBClRIbgMUgVFIUgNCcVGmhBC3kdtEBBw0EVlEiRsC\n" + +// "YuKYCZumMFwyCMmCaYAoCgAWLBFAIqBELAGxcBoJQlKmYKCWgMKEUYQGZMqiDMqm\n" + +// "JRnHIJEoaAJHgByhBBIpCeQiBNAYSSEQQNKUUaMyMYs2DnQ5Y0NY1PJ+TCmdgiin\n" + +// "NmiycZW2gsYQVPr8uCyDiEcLELhhZoHkFkvKWQP2Y1iviJ+tgiKFSwbMipJmOq/I\n" + +// "hovLcLpcDIwxtiwJPsGtozGSuMwx/Se6MpI3omJT/z9a3fwV8gLxcbNiWw2UjB3N\n" + +// "3/BPb7Jr4F7Fu+9G4nwZI4kK4LRJ4/zgcqb0Jq/2vhLIoEQ5TpHdn2KSqrY4nHH7\n" + +// "Hmh74HaXrY7JHqUgj2xVwZQuW09AnjIpy7NQW8I3oNkRxf2YNqIM6pIgAHDDNbkS\n" + +// "FeJVp+5EhxmUTDgOwGM3kZg4enFT13auoY8iCbt8PhO3STSpo+A2he1wlmodsBvr\n" + +// "h42v9TpKJJW/2w0IB432RGbjCW0jiIJa5FO1jh3eH822vLnVs9VescBszHDjQRu3\n" + +// "+fyxFIAc/0jYYTgIFfrPqEwXZC2FA3UfpqQE7KtjTv2gN64E0/hSuBTrH2NG9Pvt\n" + +// "zlj04xtjMqiI3vULH9nTRcufSF/xO3POtty3zvEdBf/d+v9DKn7q6qaAB4rW6j4r\n" + +// "O9+WwiSowZ2lYv7vQnHT90bVKn0jHGGcHgfAlSNg7ecWBL8k+iL/U7zeAUAl9FNT\n" + +// "44X1eNYZZcy8MqjGiQSTIHFAQd3v93gflbAQVHC/6KDnn1OxbrhOgft2VgjjqggQ\n" + +// "W/jFfO/TDmaLvS3Igxsgud2H3byHOSLh2nd2bHm8yXXVUMJ3otg2/x8KnDS4Du/b\n" + +// "ORJSskflf0zUkfiDILHGm48bwYsvDxXc7rnIvqI7B4rrH2DzcG5Ve/kYUtOikvXu\n" + +// "hx01JbV2xQQfIvGWjpZWoG9GticpP3ZyRzMDSuPudiLBjVhQ0lutNvzuLclqGTVX\n" + +// "LshLtF1oF5nmFQTi/GExi4oUZ4ckD2V5om/fcG9Wdnn/IFVAqO0DM0SzCw1kdKbP\n" + +// "X97j9nOmgrrT9lnI4O5cQckjvfvGrbbM4oRNW7aInwA/SpYaXt+BnvkEt/BXTuQx\n" + +// "lg/g7asWzUSEqKoxM2wC5E8FqiupKMqKrdZP8wRpOrv2KikVMg9d9PM4GrCVcjKI\n" + +// "Xv1fyZW/H3eugnrr8/Po9J8RZkkqBUTVMXPAIju63yuqcMvU1AQRyiMo8BcdFRo4\n" + +// "hufRFe2K7APSGybKE5LgVALUGZ70GUl85bYVjnLslcHeZdySnXo82H+HNTM8UqKc\n" + +// "9BXGAJS+1Zb12fgTemZO/5PBfcgS+axLiRwUCSZDA/Hlev86OgHsjnRt3JjuNfX0\n" + +// "L3bHZ+9DTzRADJnm7Lyj7ylKlUuvoH+7WaPMmBiduXuuQ/k1iLOMq0TZa/T31UtP\n" + +// "izx6M9+1+SirJS0Dzgy5XDSCfc/I0u/lUtf1kynwSmAlLSG7YAbt1Ua/2k+5CW31\n" + +// "UZZdaw2HSVGFnT2PwSlXRnlq+FEdXVbzJA39oS/CNEOM/qdnRL8cU4rU40Xn0sm+\n" + +// "egIjYlKjKml1Dg+hVFuYvk7tY+ZUEk8mOuTFlsB1f125X80L5EnhYOeTHpn+muEt\n" + +// "GyoMCpdBwxV5AoQi/5DhzPqO8IPUwsjXHRKONcP2s6ibUC58HqkCmocTRJApAu9K\n" + +// "GZQnmcXwrSvV09AMhND3oNTIRup+pi1TSfETZGyYqouPJNgf5/3rzICwrxBfBz3c\n" + +// "+CDn0ELMhADS9lBQ2iLENSTYE9jCaoX+RFKQJIkJWd1GMHs6xoyNxSf9udsShyyS\n" + +// "aXPor4zprUON9lhzh4wcTZT9gsgkb1TesKRzkUe4/uzeDcAr2K3QgRq4H5a2F4Vt\n" + +// "ZJ13x+9sSrnAqPF8YMmwHEmky6Ny/m37lGKAbupMfW/vopEyQf4G9F7bqgiTJVPX\n" + +// "MmsvnYL0UF4LcQ5t22Vw4B1DVkrJ0itoQxFJHl4k1KFIv1k4XYVviKgmLHaNWhQo\n" + +// "N3rVN8sRQ+adm39D4ckB+btqNbD10hUxDiuJcouslXcYl8AoLJ82PdfItIbECKdA\n" + +// "zbF8HAKTMHHsexPls0BrDOrgH/Y/tvp2Gmgup56OwQNq2Hpnxnh2yNV64yk1A9Sm\n" + +// "4UhGenN0vIo2Ro3+RKo1pAEf6MJG7ZeLGb4xFiDfSweKQaIEtDuR86rw/AYGXlfu\n" + +// "OXJaNWeMDNmu/WltbjSWflpIpIKYFF8sdhkHfQpTX/XUaVZR93rS4ChtORKha+UL\n" + +// "/56l2DFTItDoOJ4R05PAgq6LEGz5Nr/dCRoAcpsXyj28BS3iD215llxthHMWdB6l\n" + +// "LUBX4IjSn+ZG8EeDCRy3E5ZBAPQ02KEMrNz1a2sovc02ppE86an+r7jSOflGjBDb\n" + +// "566t0abOS5okOYEl2kDLtB2I1aQhEFUFpf/J2yWrxC3pZIAlZ+dvJ3RgUFAoQJ33\n" + +// "8YUXcYGhZjm9khMkk5xyIekDtVBTztpBohsfc1OhfcWRihWRQZvAdO+lL0Rwm2sP\n" + +// "gU77uKPioNYqzhUTyN4SzeJLt7Itp8FkmTYQ6Ii2j03yXu00c4gc5xMq50ldyNl5\n" + +// "+0HSsSFlBTsD11gZ55PxRhvwNh3cRqYqiFsWdIDSzXG/ows+glmUiYaDi6CVnTg+\n" + +// "c8qIzz6x+YhSBjPeqdD2eJr+T4ZmQzwP0UyIPz3Bta8sJziWKgLGs57RshIRxBS0\n" + +// "XvEGDlRG4gbr9tLTc5BWmrpUEXVvm6ErXFvDXn0pChv/QxYBp8kfO1uGf4nhxMiL\n" + +// "2uBQWpr0ZutMa25QMiNGeyCOJey00rQ8y/4IRatOkVa4mmrvpmOZWqvKwBpkW1pF\n" + +// "MTXinhjlR8YxhWAd7mgJB3n9KO7UjDJAkko4g0JTZOUXkMYCTJLk0RO2ETdWw17/\n" + +// "9Ljz44O832tzNLTAg/cE1xYSJNOBwy1VeVgLB9BCujcrXYKp7IxgsH2W9vhcP0Mr\n" + +// "QXoudA1AR6SBt3WuHQa8XGkUzIkD8z8y/BWg2rHBNGSCTPYpSr8YKtNq8hByxgCx\n" + +// "TfHmQ9a+s6uNyhZUc2sp1gVqiduzIlMytnZPKAvnR+XM+vsRlwISyfjIqaDvZPXS\n" + +// "4PK3t3TgLn7CmmOQy7rpbqO3TuiBe6xvcW5W4iM1qcn7t+5Cb1HcJN+kM7EDRrMa\n" + +// "RC5OuS2lmJ2nm1e8CsiGmp4i8rLjQhtHSHAInMUTS4KV/Y4nOaYvgc5SSNSLj5Pg\n" + +// "6jhue6TZ1O5U4N6KdPDFLJTcnlB+cmmoPAzbCxu7mR878Y3Kn32qnKkvr+hVZm1d\n" + +// "rQxdO45/Gu+eBZ5/0DYLDXHX8PTr+MO08vquZ09sINi7IGwLszem+hYlhLhxzMPy\n" + +// "OWiC+XC49hlKYx7ZVBy+ChB6cWdieY2wYHqqU1hMtU7j0Ed+Ja8lQEprnv5JpNpY\n" + +// "moesDSuUV5RmvLonQZu0U/G+UpCDLK6LC8fSqQuZSqG85/LbStTUstGbjA8PcLZ3\n" + +// "j1G0ThoxLsOTWvytVYDuvHQE4/+67HL8+wvmbkDka7fPF/jmZqMsPnxA1gKHA54c\n" + +// "yOqySByzwdKfq0ifIkimaRWWHiMvgg9LehPfESUB5ZfASZS8iYjE9MQMnpTjM6wi\n" + +// "Wsh8Q9NWi8OiyznXRW4iETKuJZ4uR2uJ6FpnTtgvNMctwI7JFBCubGw/ChZfddCV\n" + +// "B8Ghr2/4Awqlvp9dJkWvfnAdLUVY6OTmXkogdNQZGoLu2n/m0b9ovHAWtmaBlclt\n" + +// "8RRRYSJB8y4B2lPkS2hsCQ3tKsSrcCmM+XP2KQLB/paHTDVdhPz8x7TWPrIND4o2\n" + +// "5TeiFTvsoi5MSbKSiI39CNfrPIXM4c90JC0Xne3VNp7yA6biUH4K2iskuq2sJai8\n" + +// "lqOuvzw7XXd7Z4MOdMJwzWYpNIc/7rA3OqOyDeSfYWu1ztL2UJbjG/UeZflukSw9\n" + +// "p0XeJpSlapv2H6tEfDyqCIfH+7i1ZNZGzeKa5H6bKJL6ka5YuYeFERu1gjb6eG4P\n" + +// "4tSMfwhBIx+ei0Y/N3YVQdDull6K62TAAoUEoTIcJxIHklEmgeWru8UQDPvX1rxf\n" + +// "XJo7t4V0k09c79KMMqEoKd+jh3Mth88GV8QO2FrUQ24TFwR5MHcCAQEEIOu1IEuD\n" + +// "uM16fyp4k0FSfEP+H1ka3o07lfZmk56nHuiloAoGCCqGSM49AwEHoUQDQgAEkSZv\n" + +// "SVDhZlBXhAkaTBxlrRt624URpHlDVrd0njnPiR92XNs+NTjjvAImETMhEPbQ/KPs\n" + +// "pugi6gkrLFhcmy/OiA==\n" + +// "-----END PRIVATE KEY-----"; + + private static final String compositePrivateKey = "-----BEGIN PRIVATE KEY-----\n" + + "MIIP8wIBADANBgtghkgBhvprUAgBBASCD90wgg/ZMIIPPwIBATANBgsrBgEEAQKC\n" + + "CwwEBASCCgQEggoAAfUZvANXzRUNjxYhBQ1ccfVgDKTDcnUedgGRNoIgXqZe/hnZ\n" + + "Ig2+/MQegF8RSZ60BmB6BjkYfmbWLY2aHZvntj/8E6SOTp4eM9Nroyirqj0joYWV\n" + + "OgHqMk7wEUJgIvOHXC6/lJevlms/3JuJ8vTeCq+nzh6IAwDcYtBs0Zy2OuJIIgWI\n" + + "AJIcBEJAtIyDGIGTlgiREmKYBgWMIihjiEgJEGSJEhEJtkhJxgEYGUrIJGADIW0T\n" + + "hgDIIibbsFCYSCAIwlDhsFESok0Kw5HMkGEJQY0IMiaipJFLJjDkMCIANixMQgUR\n" + + "MkFiMgpkkGxIEITBQiCLAHIQMm4cN00DJWKAJhAZliBJiAlEOAjguDALpWACsSjA\n" + + "oAQLsmmIMI6hhAlDAnCMBJASRmocwy3BokkIBChMhgBJhFHMoAAkKIECNyIUgwEZ\n" + + "toUUg2XBQkTBsgEIkFELglASSBJAoogBwmQJOA5ARDGLFiCkRoSJqIRhxCDJRFHT\n" + + "shAaMi6TpERkSGIahywSsk0LyCEZqWAUyYzIBmAblRFgwCxLlBFJyEVjMkgcMGyI\n" + + "KISTxBBgBDIUolHZSDKkOEYCgCiDIEWBIgQAkA3QBIISIiXhwFAUiWUDIgkaJ4gR\n" + + "wXEIOWETky2ciA0bFBEYNwEJRoKSFnITFkIKx0kgRy1TuIQjgChRgmBBRlKDooHQ\n" + + "lCgCOJCbpmXDgERBxkjZhggbx2UjyVABNo1UADBiJCmYIi1SEmzIJAQkMoJIQkIU\n" + + "RC3RRAYJQU4UsEgRJUnhSC5YRGihOIYANUkTsjAMh2SUNgwRA2STFCYYiQ0SMIrg\n" + + "AJADpIBcwozhBmnJgAgZwIwJM21JMjEYkpEEk5AQkYkhg2WQwHAASCWRxIiTxG0i\n" + + "QFGUEGoht0wjNhIjMoigFgVkoizKBEUMR0jcACrJSAwgJmwKFmSMAk6LwkATMZEg\n" + + "KQEjIABTIkHABoiTxkBAKHILBSVRlEFRSCUTxShEBkYgQnCkAlFJpITUNiKhpoEh\n" + + "lBEAkkHKsmFDBiIYuCgTSGASACTTlAVJgIkIlWVaMiWgQDFEKESitkUBl4AEtSUS\n" + + "Aw4YSUUJFU1YkIzRgoHLJIjJSARQBkwMBVELoingIlGAOGkQhWAcgjAJpCQKpWAC\n" + + "Qy0LhiQLpojhNCIIo0GJEGLLMGQht2WDJECMBiEklXAbxClTFhARNXIbMywrEOs4\n" + + "Z9qXryiC0c42h00rJpSe3mW+HCI7F3NFdB42UwjmZilcU96KCKX4Qmz1DJI/DNwT\n" + + "tzcHC6fPDaiQdVG15XPtQyxOKC3NYqoON4xMUNcm6SGx20xb6aeXQMF7cdpM+Gp/\n" + + "2BbA0cI9Oa/mReosw5rsd30XGvrilwz6+2gPuzfEeKzeD+igyvO52qAPheeY9khV\n" + + "aiafijNptrALzUYxI4qwTXLAG7l68yccBPLUx0Mcos4CkNC4/9Q84HpLcMGoBlvy\n" + + "yAT1G54Ouac/WQzQMIURRMR5sRXi3PrS7SAAadqRe9yljtUlqKlYdusMVL2oUy0R\n" + + "cd4NOljWjsk3LQPDH0tjbDTCWbhWLgmvsqQ9rlldlZvAMub5FfdbW2WdAiZGHMR0\n" + + "AWXabBQpLVyi3wt4GT8EyF7jhy0FBc/G3dVcCDhbtn7A8J6+/qlSqymzgrXcvS/C\n" + + "OFyiMmoJ+2HOdRFwtwcrXx1MN56BVA2u5KiFqZdY2yxdpjxJ9n2Xapu3YJCy2hPb\n" + + "bnP0T2ea/DnXlAuFYuL4Jt7j7eBwBlA0IWW5l9iwbCtGmewn8Qtuwg2/BGVVZ8gR\n" + + "6+LWYZhV87g4heBW2k4rdlFh5+WZUUtN0pT9Z0Uf0AsVM820Qj8yUl5uak9NgsCE\n" + + "ZPAVWuKX27TQDef3PH+6pBLUoSBHZ32qN+EZG0P6IJuSE8LA5ZrjgLMwPNo6Y7WU\n" + + "bsLBBznitwOYoVTXZuumfBZqE7ngVv432TlJy1lAzOWkLhdTXYY3tsBz1W1S/4vN\n" + + "H8/8+InuKQ/Ym/Gw+3SNHY01C0frSLb5IVDIAYzfod4W//u7hRWxd/E402nlGv4P\n" + + "0mjJBmESTonzRv90Rs+Kw7PHyjNbDLp9vTfOYEb8JURFWuEgDFBPwo4y8dF1uPKi\n" + + "C9AHk+1spapqSUnZUN8uGTcSJtB03BV68orlxdAG3u4vLTZhEkvl1njfE2lGNDVz\n" + + "IzQDAsgW13xIUOZJm6ciFWGhyiJiEPECc5D5if/IJ+dBQX53n/0qoccZJtF9elpU\n" + + "63UT5uDSjY6YkjaMV1FHgpQ702MBkr3TeO1eXv22FACdhQ+I/XABaB1H9jxwHVO5\n" + + "oD6eWLMZuttLPsS0Wc2wFHRcFSCuk4hnTWA1gV/Y+i7gjUk4/EMrTBBq1BRlkDBm\n" + + "CU44OcCxKpfbk/23Vv9tb2FR9U1iAmZrGjgcADFrPXPJpUTbbqL+wpYCzTwyZWUX\n" + + "1qv16ac7pzxk27HNTok/1mNXIzDEnugKVLrVdlWzNcdnflpoi5zvSzKakFKdWtEJ\n" + + "63SI7miaDpdS2z3xEd+98B7YFmv5lcEwH64sGSKK1FhvnVYuU3zC4SEIFz7Dk8go\n" + + "j4zejOiYyRpTMmfCujgxcN4Q6h4btf+HQ2NNMkUmn7rf3v3JlxcK2qwkdhlPkMJw\n" + + "9LjhNjf/9+p95sR+lvQJrMSVnXrDyy74hu+LLSg+kuJZ+vA6lAX2lQ5954aSFNKp\n" + + "OZlvxwvZdrPrzUEzHQbifdaBlLkb2m7MJoEXQMvLX3iaA5t/qSso2VwuNOHJdvcZ\n" + + "EbMnAIJiuOpvbnS1TJzPD7o58ldEc+UAscOaVgcOVc8hlGrz68ue9o+i4SwgbFMt\n" + + "n4u29odCNYmV8bTM/3CVHNtEACkVZKnOHx9AJ5kjA/JEigRK7Imj0rdE0iQR2OJw\n" + + "3VOJsqSV2XtVtL8cCKA1jUAAlYlDOlgz0c3z49hm6uZ89E5SyNJqS+1FLAtTTWqO\n" + + "sClprEGkvyOu+37yRiKwed7PnpCNebFyZ0uL0XibShcoPkdE5vjEDD5yMbTFn8hZ\n" + + "XddK82mbPE301Jrq04yG84mSzn0bEUJAhTVMhH1oVhBX8tcb6JfBSCxkEZwrm/wY\n" + + "gUGCDhNj4ixOGpBp08ut7RS0abqoLMBq8aATMvy7QMBYRcWXsG11tCqRGRoNW8sW\n" + + "2Rj+jpY1VpIg/S8CBTNfZx26EIPPgrvbncrNKCPzQN3d0diYw0LmW9a9RFI6D748\n" + + "2TRmyFiY+TGiYUVpxjmyOEkYe2xO/Zlvk6bgTKznFemrc9QoZSJVyWBQHUjU12jr\n" + + "EhnxB3bLtw46J3yef621XX96AYosCkEcKgoRaF5hy4A4ao9lVZs6hN9NTwjd1tKP\n" + + "HOQJzYyuf/8KJkoVXrwJPbIra87krD6dP7RnnZxPZMar/6zhV+vavHE+mcuz6S6F\n" + + "/qevHd5cLnlm+EySHLvDVXYdvkO1cys5QIkMU4GCBSEAAfUZvANXzRUNjxYhBQ1c\n" + + "cfVgDKTDcnUedgGRNoIgXqay9wvF507qUqNVHCNW51FEBTAYRexzouhX0uX8VPce\n" + + "UMjxHbj8NPWSGTYLAfVFl0hVuItIjNySRJTStp/+61LVOOUbiDO7rirlwdRowzSd\n" + + "it0piamVt4M9bseekiTJEmQKjdAcf6czHeXs+agQawoyB8TNrAKpwFuv2Mzp/dXr\n" + + "OmPXeYwepkzpceTOGL0d7q9ktSyarCFjK8TfiESu8nNpRRsW1BvOwk8x2DRHU3Zr\n" + + "SVSB0zSreEeauO8BW/9mBks38yuBc0q51Mi6gOw9NRRJkvDyO/i8DMEFoaW83Off\n" + + "sYEJD6D0McjORqsx8ybpbTzGhhGThy4UMFq+Nkoz9UNPXFBK2KpatsM7s4uny6+Y\n" + + "PzKauJAgQAE4E/rdHDYzZjRrwfMEMNcRqP1iFwa7Dkeh/yEm1Cp18RmzgC73wsWa\n" + + "ArsbIiKnncomMFkhswtoUOZXKhdpVwFw2VbzTaThIXwGulx39NJ7WEF5bXTas47q\n" + + "xXhHOhEZYjqKmBAgATRyEUy5eScti4I/BLPq4uzg2jj71CHprsLMRnktbC4h0pds\n" + + "4RgGapViXgh7aUAeg6t+u+Y5N/pcS43tSsY8SEwdlEWvW0qIqOma7Z4yxROsdvxo\n" + + "Ne+qry1XP1KU3xV7HWftBIXt3Jq+X/OiMBDzmxme+tpkXRxl5mZiu8XfyXOc6BA/\n" + + "DWJPJh0D5zAYWTsXfdYrevCq+ZlyNDbxZFBRUUvuC9EWjCQCxCpaVTK8pPR/56rQ\n" + + "90lsY8zxSZlXr1rUUvObyOjH7iHg8kHl0CV1P43YiVMtHFy9ypesvidE/mjwoTOD\n" + + "viFS7ggJsDSWms38DToKKeqP8Yf8TIFApX06IKP9XC6tN7hlmFtI1WR5TgHz1jNt\n" + + "TjmeW0sUWl7R/OFt1elZZ4Ch964YLs4LUtJcQiM1yWq5oIlDQB7Fh4UdGtFywXVq\n" + + "FZJfrL5K1iSkxvPR3/eNVTlQg6GacodN5AcLIhw6yfolpub+7nJc7EQQhFM0fQP/\n" + + "T6SgAripEnHr9kq0p9jjlCwuIwbWVoQwlJHI6j3MV3HreNsIoVGyUMOyky1XzhyK\n" + + "Aycuc10xiLOfrD/uletXUeti+q9n/RMXTDtQyimrhdU6NjZRnsH5nRabiJqh07Kf\n" + + "LB7Xy3q9Tl9h2gPwB+6cTKevWdlzjeMdkgDeExrjedLqqUvmbAp9qkW48tjKvlzK\n" + + "IueQKZCgfB6nO3rBHGpmXpGx8+k30n0MuTS8dKBFMQPj2dAtIjWBYa54spKMp6DC\n" + + "aKvEJQt8pCW8PvndiBZP/VjAASx48AjnudSY65lCI4vuYEfxz3TL9pILHctN5rSp\n" + + "QsEpPGJkXLLT6LghD5mvC0wQ8dZUuHDLLB8gCj5kQmkhbewwlsnBtvv+PlA6rv04\n" + + "/p+19bNWXCPSQmVsAv8uabbU5LVCMMIpX7H1qFGYusSRwCN0IWBcnu7DqYioBK9b\n" + + "IajnQ9uCz3GIjVPGrtv7cNadz+fg4ftUAKNp00xUAyKgwv2z/ua88MOgubZpIKm0\n" + + "dZrR/tT15ooFtITzNJCkc5a0ZAGGQ0tM/3jpVHT1/MR72UVbTfaw748D6QKtHfwh\n" + + "u4mo6yEIwdWT7qVJ4wBif9JsobQPLj+lxKElImvKM1Tfju2tvXSrhaFLn1mdJN/0\n" + + "LHZYI9S6vX7DZSMt4ZftCF/wbw+WRI4AQyTzVvmHlzGZclp2GNB7otb6QyuFvL/P\n" + + "ZDCBkwIBADATBgcqhkjOPQIBBggqhkjOPQMBBwR5MHcCAQEEIAbQM1Qt/+t1kOGK\n" + + "6OLZpZ7439AhUvHWyngQXOtpCnLXoAoGCCqGSM49AwEHoUQDQgAEx5v+k99ikKsF\n" + + "Za7uEk0RhfsKWSYXn8G8sEZsviiqxJaYXNDZFQPecAcVrnRoEWqB4vivd44DcDwt\n" + + "2NmX0l+cYw==\n" + + "-----END PRIVATE KEY-----"; + + private void checkParseCompositePrivateKey() + { + try + { PEMParser pemParser = new PEMParser(new StringReader(compositePrivateKey)); PrivateKeyInfo privateKeyInfo = (PrivateKeyInfo) pemParser.readObject(); - isEquals(privateKeyInfo.getPrivateKeyAlgorithm().getAlgorithm().toString(), "2.16.840.1.114027.80.7.1.4"); //id-MLDSA44-ECDSA-P256-SHA256 + isEquals(privateKeyInfo.getPrivateKeyAlgorithm().getAlgorithm().toString(), "2.16.840.1.114027.80.8.1.4"); //id-MLDSA44-ECDSA-P256-SHA256 CompositePrivateKey compositePrivateKey = new CompositePrivateKey(privateKeyInfo); isEquals(compositePrivateKey.getPrivateKeys().get(0).getAlgorithm(), "DILITHIUM2"); isEquals(compositePrivateKey.getPrivateKeys().get(1).getAlgorithm(), "ECDSA"); - } catch (Exception e) { + } + catch (Exception e) + { fail("checkParseCompositePrivateKey failed: " + e.getMessage()); } } - private static final String compositeSelfSignedCertificate = "-----BEGIN CERTIFICATE-----\n" + "MIIPxzCCBeagAwIBAgIBBTAPBgtghkgBhvprUAcBBAUAMBIxEDAOBgNVBAMMB1JP\n" + "T1QgQ0EwHhcNMjMxMjAxMTQ0ODQ1WhcNMjMxMjE4MTUyOTE0WjASMRAwDgYDVQQD\n" + "DAdST09UIENBMIIFgTANBgtghkgBhvprUAcBBAOCBW4AMIIFaQOCBSEAh9USnYsL\n" + "xGMgrKkpZBGfLxQCAZikIHPT+z7cqcOq5kYdaL5xlV/DNZ+lQHYrQ4Si0wnarQkf\n" + "dgsXWTHeTwEvXBxKwjTtKaBfnPFEoEMEbgWH9A/M6e6THO1hBf3qeF0XOOLTabqg\n" + "7ihtplIvjvUZZBjvLmBp+pcnibGsFBfjBBpe10v3WgmRRoxOze3Hs1VdhXMPytpg\n" + "E63HtJMQaygOjX17M4RuH0Uyrzwudp4/2MpXkIKakBk+8Tmg6t+6vfNOfejfrGuE\n" + "TSqcgo0mekv/7T/2R3HI2+8wziY/uO0IS0y/v8sHur1iQjGZO4Fbdapwr+bXdSmH\n" + "lO8y/O0iV90vgoneObqGJa9RkadPYYrJSDZp3Y+m5CPIJ9rtaZJHO6VACNVGDK95\n" + "GKvlC56E6NzeSnAxtd/QApDBjMLwhZOCLgpX+ROLIROcDzQNziIhUwpkLZsdPDFZ\n" + "e7iKJWImP2t1QBC5XCNBcO2+gYA3eVsSSWv0fTqmWS26UB3qt0fLET2358TBjzn6\n" + "IZo1yOnm4ZB7s+Gyp9fzVriCP1XAiF14Q4zfiJqN4htTntm4WGE4v8l6Y4xvR1Ad\n" + "PQbn0pxG5ThroH+mcKM5spOtrVyn0fG75O0yAaAwmajF7Wc4YDVkFRb/JV7g/GaI\n" + "IV4DKbYTFbOe3gkK+qr2k0iqd30VlcRdoPKjoqlfIutlF4dCorh1LM0Btmq4wgya\n" + "AlkbRGHX++3fpLtXmOARk3sbd0AsCEiFAuunAQ1UOV7JhXWPZQQtN9peyAqaqGq6\n" + "ZX2V7B3KyC9g233cn/E/QX6ykGDzcUT9nrK7J9+9wODwJH9Hz5wJ3SNigtv7thMi\n" + "y8c6tcJRYd9vobyDlEfqCvANz9GoA49ekG8nXm/KMh5zoPOolq1XzoocnJAa5A9Y\n" + "0fgOKoKtOD8YPSUbL5K7VqfmCGUzxdcQk5BFPdiPMBwS6UEjGC7DnHqJvIrIrS8m\n" + "jeglPbxTNgrwDdfVPTunYUrfXFxtdIYyh8MZ/qszBvXNtlbIQi0qOBlpbfhkVIIU\n" + "oTOxlnfLNnLwS1+LdAfuJJz0oJfZE+z/3zidHXpMrYsUJp/1eXqC5FoiOHVLQ1Bx\n" + "wU6t2q0oEMketCIQbSeeLwpGOCdwDGZOxCqsyIWBumkf1+iUh1vYDH6bulWh6ksY\n" + "nMLs8UukR1q0OH+myOdvcG2oJR69JXlm2hgF3kONNNRze2JkFYrEtJMgtcPcNuNF\n" + "DNJO/dh0HHxggSufIbkFOpCczz2fE0Dhls8PaypBS4VtZypEiUeaTnIxB3vwhFOS\n" + "TJY8FWugRGPiwt/QTxmcyVMZAGW12x5jFAkFyqOOkojpYr2wZ3zoc2aWhlDwyCo6\n" + "117lQD0jJhIrE0Tx47pFvhiE5aw4B7aFrglkmDcv/pM0V6Z1eRISi+OD8IGdC9Ui\n" + "35mQ5U+Fd+LV/3R1OSD+lqmuLMfTSrzbiU2akDiuhcC/LiK/rTVsyvkr9dn0XjYR\n" + "su4drt90Fksor8c6JD39SLuzcNNuVAWs7A9MWChDMUy5xT/L4urrLeIAUQbai8vM\n" + "Q0zO5LSGk6uJ1mfBtzrplCByhftI9e11U3s28SRUJ3dIUstOYaVUqh/PfxrP30Y6\n" + "puvBOF7OMq1GlSQ4afgmpsvk1/P9aniCnleapFPtD9UIzXOqhVZ6sOtKoiiYq3E0\n" + "RSDZ5lkjrYzz8yyfZ6khVYbtEc6yejQqqadE/lhqqknGR53jHpb7cZaLedGnClW1\n" + "YQo99hoPtbXwuwNCAARVBzhm3gjJ8cL86lTEQJ31KYjdhAoOqrt+b4VYQnH5HsU6\n" + "BWTCiL0R0ym7VvCS0vSegrxDSDsjCxFu95wTNF6xMA8GC2CGSAGG+mtQBwEEBQAD\n" + "ggnIADCCCcMDggl1AFh/YwOBfGWu9nfigElSPgkXGGOdjnuUgHKuz2uPb86IpRLz\n" + "qVAQPCY4tzM8A99KooiqmfUcNr5qLZDTxdbJxtXHqkpMiUBLBLRhAmhHUIZVmo+g\n" + "vBSVA1QKd1dmGX/FedR1EFhH11Ge+8Vjml1jH20APByxgFcXSaAFamOxQXn9uCd0\n" + "Mv2kjkLcP4+YqXPJlb2ZH3BTwNiC6VI5HPm/4TNJDZ3idXDOi8NUBk/eQWHVNkiC\n" + "o2pNyJS9cFBypKYodn92s8g4kKPOK0Od4Fo745OpZicRfcQOMRWgR9f+3+nvWXx4\n" + "1LfsT8hr/jQmGj0A/ZBhCYHjGXxc5nR1Bcl1va2rdLimxgimAhOfhm8MLe+gKPDO\n" + "PMMBDMOc/+mKfI6lZHK8UuSpqnui5/2v9oupYk1tBm9rp2xGZaS4uNbNmzjxdy4L\n" + "0hvBuDX03U6c36XzvFmesfEJeOkz3wrpmQl79nlydPHMTlX68DLEUa70W3BK5LG5\n" + "6o2Yor5mCUOChNgsT0oM4UlGur4LWKTlsYuwhUC1W0k+FcTkXgUwv4T4IQCrCBDS\n" + "j676HQsblp+6msVdMh6ilLX62lKGrVmKSVaHDO0R09vccDrF1Gl5D2wKWPSDR68Z\n" + "+Bwvjri+9VsTd5X8LFiDBl6XWGdUDVsZ0cAwHCDtlI1ukNoCn+XMYa2cVX5sn3Jz\n" + "oQf1uLPRc21xitSWYa+VF3QnhnT+bxWaA7tx+rYME2mZh/An2AAhfOUhGKnJtIFC\n" + "oxTwyQHQ3m/G0XsCDHBh+tXL0glr+LuepXSMrCO1wIGv3gRxgSOQVBCKHvf0klNZ\n" + "ICPPuscYlXowR8xZm6a3YT6jZIgPm2jF70Y62RM4rRh27ursapeAYutewlkf6b0c\n" + "07C1ttH3J9GWulfLW/ljN2jWCSEvMMtXPmAXYojjhVyy2y01IntXAoUG37LZELom\n" + "Pjdy4W1D6D1yRBEwZF7olXFb/lxh24quntWxZfFNv2ver3OWlIcJoyPX3DPcE9nq\n" + "NwvtUdZntpXUfAqHT6O9b8i0W5XLK3sZCMV6Zbgq/seJYc4fYg4iENS1iubuvaWU\n" + "Fg2MvsXvaXZ5hoOiQ+y/dZJZHa/LanaxLwD9TSQaT+aMFCjtzFeORCasx5YD14Qt\n" + "aSXfbRRSjEhdDaria2Bd1vz1ktAFg6jHeOvZHa/JzZUQxof8mcAzDsMhkLg3nz3r\n" + "w5K03xGr4npPAUU/VsGeDX6AryjNqP0z6nZwnjmNRZ8aUAsbkq6xy23qbSZn5325\n" + "h0d8BCH5U6dS2qXJR5l4WApjjdYrjIMgDK8w+e90hZGOK67PcicHSjpCF7GgjyUP\n" + "RyTfL2I9NF1proXL2KjD5Q0yaQNCxnzBAFhG9jz03/FZxfLg81y0NYuSjgv7EQxT\n" + "TtACOaL6AhFDxJT0IHLFGzrdsvAaCe0sMr3UNg4DH9NNTsGuMH2556Pb1/Y4XW65\n" + "cKcu9TBGDlk2XdQ5gqrzIBs1VKVfBdXUVIUNgbCtZ+Dmy+ClBgDRMAVXePF+wQOu\n" + "JQWglK4dXFibVrppysbkNdMrVLHKOq0gmnUDK2qbrR6DHD1TZ7Ej2oW4ILgFygSi\n" + "elVWhEW1riltNOaem4kR8Y4wdUthhjr9GFtVbqpcERO84T7b6CYttP3bWvQsv9q4\n" + "FadMKNTjClPjj6b006Nfzx8+8B/Rs5/WPzSvo+m8n6L/oV7l2egvimvrL8yVcIyB\n" + "XIe/jqKJ/AUstUT63tkfcjiCEff140iqTJUzwPqBv8NHqMti/mHehec0rPM5BAOT\n" + "c+nTjgWTf80QipGEC8Ifn1wuT7y2B+MlI+q3zC+P06iym3xTse6yiPpqOQ5Dn93R\n" + "ya2eKkeXcsoa6YbiZo98zRtXxWhT2FWdQizGEOkh+UQsenmsX1MJ7L5dpuZJVESu\n" + "E0eSpnwZiPjPtHA2qZicHXgaQw6MHjwJbGbe4L3am6VVYB9EXcu3+CippGXx7RRH\n" + "JQ4DwUJR62qOYaWII/xoZ9fyUYAHU5h00A4GGtT3q7e6wNYPVMLJQVKm3ZTt2S1Y\n" + "65xJWPeoBmxuiyGWkKkSKczgzCrA980MkAd2YoQfnQpvFkaKqZNP0lxV3xskRrEu\n" + "WF82BrK5vLRni7LifdzblqU5F9UW1l9AEaR8baxfTtWvyjmxZ9xVVhCTuDTU3m4G\n" + "ulccgvNalk/B5WrcqDlt9EIoIM2hL5Jg9KKsYw5n0zxdOyeIQGGspeLOKjQ7HBs0\n" + "5rnMoIr2LEZV2xYp+tCt/7l4Isarqb9J8OvbK06j1ETrD6eI2Tc1SUfjiICHWX/C\n" + "d+0VqjMwmerikO96Hb6+dNDuOr7nVQm+oMlOj294N4xh2QUo7/ay8yiLBIEn1kIA\n" + "5/5qTfhC7VDBHtigUJyv9ksySO7dNHscfIu5lDnTW9ZWEBSwNQIPin1vqbFSomja\n" + "9meE0JRH6rWilEaIFykx/SszIajLoMR41bQUAZ9H2QtzqqAOcyqgsw9im/Zkvlv9\n" + "f7RNbnaUBzN5HFyGsuR53a1ckuWDJFBnibXHXwD0BkZNoN0827e1dIWZZlpGDRJj\n" + "XMSaWFww3UKQ6klVSE5sOCeJ4wev6rpWDlK/kaSuC1KnuPgsVxoPNbftbxKzDemf\n" + "CURmMNvwRirbxo5O0Z+eAEbQWDug3oTClDx5PDiCU6VfafDF6JXgi6gs+pLbreUJ\n" + "Pw5xoP6FlyZboqXzUpb/CG0vdVCIhPfWPSPx3xJhln2s9Op9t3Jp0OwUYiWXjceC\n" + "uLwz72z2svuj8a1AxDiAe52Tx/jU7oNj7qqnMML9Mm1X+9vTH+jjGykNrViNdxE1\n" + "ECIYTZV8HTMcqiJC4T11KEbyxzdMZXTHrKmL4r007pNpifYSk/2aKONhdhoj4BrL\n" + "ZUO9IqF3QI2pL2TRwLbZTDow+6lcKAMzhaiZmraIb6VasLnDSnA2uMfXonUbAjEW\n" + "nJtRlbU2VCxbG9kdtIsgO6L9oB1Tukz5Y8o8z2ehDgeNK/DwQT13pgZxQb4cWCPp\n" + "CukuXSaouDISrNErKY7AjVMn22pDqrvH6wHVA8SGkxNstSG8acU6D40Vm7T6417J\n" + "tKvr0Z2SXUSU+RINvzRV+7G5c7ALYbZFvFsTUsGhC2PkzpNWqq1nnlMXrY8sAEFP\n" + "VWiBo6Xb3vUEBis1N0JLfn+Joa3Excf1BRkiOD9SWl9tnKGwtMv19vsDCiApNlJd\n" + "ZHJ7gp6svMfd5+8AAAAAAAAAAAAAAAAAAAAAAAALGyw+A0gAMEUCIQCHhNVC+uyU\n" + "1h7PRtoP9Plzv+LxQ6AwPCZGQQaj46KEQwIgYhY4yvKFPUB2T9cgLRNffLgvU+F2\n" + "CiYdFNOxL2e2+LU=\n" + "-----END CERTIFICATE-----"; - - private void checkParseAndVerifyCompositeCertificate() { - try { + //FROM RFC, SEEMS WRONG FORMAT +// private static final String compositeSelfSignedCertificate = "-----BEGIN CERTIFICATE-----\n" + +// "MIIP9zCCBhigAwIBAgIUUFXlmVgQD4nQC6Tzr4OlRKxVYYQwDQYLYIZIAYb6a1AI\n" + +// "AQQwEjEQMA4GA1UEAwwHb3FzdGVzdDAeFw0yMzEyMTkxOTIzNDBaFw0yNDEyMTgx\n" + +// "OTIzNDBaMBIxEDAOBgNVBAMMB29xc3Rlc3QwggV/MA0GC2CGSAGG+mtQCAEEA4IF\n" + +// "bAAwggVnBIIFIAD0NNihDKzc9WtrKL3NNqaRPOmp/q+40jn5RowQ2+eurdGmzkua\n" + +// "JDmBJdpAy7QdiNWkIRBVBaX/ydslq8Qt6WSAJWfnbyd0YFBQKECd9/GFF3GBoWY5\n" + +// "vZITJJOcciHpA7VQU87aQaIbH3NToX3FkYoVkUGbwHTvpS9EcJtrD4FO+7ij4qDW\n" + +// "Ks4VE8jeEs3iS7eyLafBZJk2EOiIto9N8l7tNHOIHOcTKudJXcjZeftB0rEhZQU7\n" + +// "A9dYGeeT8UYb8DYd3EamKohbFnSA0s1xv6MLPoJZlImGg4uglZ04PnPKiM8+sfmI\n" + +// "UgYz3qnQ9nia/k+GZkM8D9FMiD89wbWvLCc4lioCxrOe0bISEcQUtF7xBg5URuIG\n" + +// "6/bS03OQVpq6VBF1b5uhK1xbw159KQob/0MWAafJHztbhn+J4cTIi9rgUFqa9Gbr\n" + +// "TGtuUDIjRnsgjiXstNK0PMv+CEWrTpFWuJpq76ZjmVqrysAaZFtaRTE14p4Y5UfG\n" + +// "MYVgHe5oCQd5/Sju1IwyQJJKOINCU2TlF5DGAkyS5NETthE3VsNe//S48+ODvN9r\n" + +// "czS0wIP3BNcWEiTTgcMtVXlYCwfQQro3K12CqeyMYLB9lvb4XD9DK0F6LnQNQEek\n" + +// "gbd1rh0GvFxpFMyJA/M/MvwVoNqxwTRkgkz2KUq/GCrTavIQcsYAsU3x5kPWvrOr\n" + +// "jcoWVHNrKdYFaonbsyJTMrZ2TygL50flzPr7EZcCEsn4yKmg72T10uDyt7d04C5+\n" + +// "wppjkMu66W6jt07ogXusb3FuVuIjNanJ+7fuQm9R3CTfpDOxA0azGkQuTrktpZid\n" + +// "p5tXvArIhpqeIvKy40IbR0hwCJzFE0uClf2OJzmmL4HOUkjUi4+T4Oo4bnuk2dTu\n" + +// "VODeinTwxSyU3J5QfnJpqDwM2wsbu5kfO/GNyp99qpypL6/oVWZtXa0MXTuOfxrv\n" + +// "ngWef9A2Cw1x1/D06/jDtPL6rmdPbCDYuyBsC7M3pvoWJYS4cczD8jlogvlwuPYZ\n" + +// "SmMe2VQcvgoQenFnYnmNsGB6qlNYTLVO49BHfiWvJUBKa57+SaTaWJqHrA0rlFeU\n" + +// "Zry6J0GbtFPxvlKQgyyuiwvH0qkLmUqhvOfy20rU1LLRm4wPD3C2d49RtE4aMS7D\n" + +// "k1r8rVWA7rx0BOP/uuxy/PsL5m5A5Gu3zxf45majLD58QNYChwOeHMjqskgcs8HS\n" + +// "n6tInyJIpmkVlh4jL4IPS3oT3xElAeWXwEmUvImIxPTEDJ6U4zOsIlrIfEPTVovD\n" + +// "oss510VuIhEyriWeLkdriehaZ07YLzTHLcCOyRQQrmxsPwoWX3XQlQfBoa9v+AMK\n" + +// "pb6fXSZFr35wHS1FWOjk5l5KIHTUGRqC7tp/5tG/aLxwFrZmgZXJbfEUUWEiQfMu\n" + +// "AdpT5EtobAkN7SrEq3ApjPlz9ikCwf6Wh0w1XYT8/Me01j6yDQ+KNuU3ohU77KIu\n" + +// "TEmykoiN/QjX6zyFzOHPdCQtF53t1Tae8gOm4lB+CtorJLqtrCWovJajrr88O113\n" + +// "e2eDDnTCcM1mKTSHP+6wNzqjsg3kn2Frtc7S9lCW4xv1HmX5bpEsPadF3iaUpWqb\n" + +// "9h+rRHw8qgiHx/u4tWTWRs3imuR+myiS+pGuWLmHhREbtYI2+nhuD+LUjH8IQSMf\n" + +// "notGPzd2FUHQ7pZeiutkwAKFBKEyHCcSB5JRJoHlq7vFEAz719a8X1yaO7eFdJNP\n" + +// "XO/SjDKhKCnfo4dzLYfPBlfEDtha1ENuExcEQQSRJm9JUOFmUFeECRpMHGWtG3rb\n" + +// "hRGkeUNWt3SeOc+JH3Zc2z41OOO8AiYRMyEQ9tD8o+ym6CLqCSssWFybL86IoyEw\n" + +// "HzAdBgNVHQ4EFgQUhcS/LyOtUFUrF+FJxoSERDrtcXQwDQYLYIZIAYb6a1AIAQQD\n" + +// "ggnIADCCCcMDggl1AMX5C7IKC8y1AX2ANKQWQWycGovPVFkiv+qctjfWt0jaErT1\n" + +// "XnR80WfR3XX1rIIZ6jG1ulkLdUGx2tFcu8Qeb0umxvYWYC6htzvGw+bjxcRm0DES\n" + +// "d+bkwWIBzdK23b9WqBNLqvzNccgAPXvP6PwrLxCz+sEnWcCDDqgeHphbYf3vzedR\n" + +// "uMvIsRYqGO09qt/tWu3JG5nwGiX+6t/YFgE5knii3sXdlHWZQ+nSAnekc2sgtCV4\n" + +// "cA0Lg01kBi+AZGelNuVK3EtgKJ0VTP5DQn5D1dLn/RGbqlMngsNs4xUlIFyvnJ8l\n" + +// "UZp6+VtfE2fWRDW4yQ4ob4Ed2KEWMtWa1GaFtIfUjDGyqYLwMOJUjE5fmhLxioqS\n" + +// "pk/cST+AaK5iNZzlDRC220hGOIOsiyf7UQKw+bFTENVqyXrYgTmns9zg+mc5KeZj\n" + +// "hE6IMFMtkQyJnRVWUL1eRviu1JL90Tcmvw1gvKdGFPDe4A7FWx0tDyAVY1wVd/sd\n" + +// "Lylt5QvBaIqgrtc4rDeS5pHGNdgy3zsi1YYpet5pyfQwZCtmqRggBDTCmH7nTfrV\n" + +// "rXDbsUm0euCK+YMwbi6DbpDV5mQrUqDX1MGk0RFDzlKRtTWrvxhhCVLgV/l/ZVgi\n" + +// "bEuFQg6POuCn0IA2jFJyza2TK8p82RAZbcvtM8XdJVhM0okKIRyi/8lw2kbX/p5L\n" + +// "l7vMmD0xPOezi2FQMxev9460Seb6FtOlvFptsLoTw4grUTQHl9brftzPAhVmUBBY\n" + +// "wGffj4rl70m5fHZzL3YXpxkr4jlqG8tKJc9370Emh9xXV4KMuo2Us+vnRUN+9QeX\n" + +// "tvDaG70jX3+760hTl4qDqMWfXY1nXhCeHWGCCmn2Yq8ULdYtIjZIMcHCXAvy68jv\n" + +// "7vkM5xQzDdgRMXop1Pj3aZLRI0boQ4OuR16sxmmpPUIGanfmDbvrdBBNucNcDYDy\n" + +// "BU5QpuCEZ8yHs94TSWLO9KP9i+IlL35TGG2zIbwbhI15HKOWzZU9ncoC2BOF6zhw\n" + +// "u60tdBvy5O8pinjMBQKVDPMbrIKjfCUK4f0YQ1/Bk4ssPogQNk3sRYJqWZ0MvElk\n" + +// "q3674KpN0OVB/kJFdAB1Uqpk4ARnZ7SsO8B/6u7rRNdthHSRsu4Fhe31EE0VUoUh\n" + +// "x3GQM/7gTk9El2jDBlZxwEpPEtTqARgp0ad6EJnMcIW0PEKr56HUFqfxKVjJWagV\n" + +// "fhtKzskghDS5lRpDY3vPq1Cq8qSl1ojcij5zm0BxI/cJIjh41RnW5D3kjt3r3Fzo\n" + +// "an4pPZkXzZm9/iGAoFAy7BThfg4PXVq2BMCNZPdASQjIiPEWklylW9iX+g/12iCV\n" + +// "Gy7F/JOG0SOH5/2d12gRDDiwn6k1KDwKPDa9htaPBGaNNXLIpr/Wb68GtTkNs1TG\n" + +// "e7Sf9aigE9BtTGgeniJ1Gn/aV9LGQFqRRQsnqB98bMKABZi0RjZ9yebLj6lwSFXU\n" + +// "pTdq/YNnBGwAmOm/HXzksOHJOjh20iDPhLjfMB6Fi+XkWVZ0TWzV2ZwOtM56tY+a\n" + +// "QoauIHR30QYtGZMI38HpVeLSj+iNUEKbE6kY5c69Bjalwa1pCqb9aP5VnKOkMA+3\n" + +// "qQ6c2ggxgudchBSXK/BZw4n4l7IvHu9wEMvsVh9mt/SAGkK53k28RDkNtX7+jfJR\n" + +// "5/q7Qp626ts6Sc8rG6BmZoJIJnUXjeOcqlAoDXYRGuxCw6Jm91DL9j4t3m0bQhub\n" + +// "hUt9diovZ/hw2hOng+xT/oSVvauPHFpxSUu3NVcncjIljD+0U3y6cn9VnE7oFNSU\n" + +// "G3HadJlVTZncMrWYo954Wt3cwNA1Opcq+5Tlu76laOWJ/4eRcvOwmxrKZHUW8Tmu\n" + +// "qPPsAOTagFmMxOBkLzIaq39SZxHkw61SdJxXlKAtmZYnNvwT2NGpauF6P6G0FHAO\n" + +// "Ucfu/DDpAdKZ/GGpVxC2ttfDCzO3iya139M5fbg32RpI0q18swYFhUAqszdAPihc\n" + +// "4lpCGw9JdrO8i1JhB+IORJegJRPs08DYUNv7nzSbOi03iYY/QHtGw7ka5AGLfkY8\n" + +// "ajiLzlXwI2xMB6XBqUsAH2VxTRPJ3N/kGTzFvhiGBOYx8+jO/FqEa5E8+cafU+kW\n" + +// "m9/RCpumizdVzrH5MiFh0NI9iUegdHs+hDW6GDpA3VpGi5MmmeE6Ck8UyOzDNnY9\n" + +// "t53b9QxuwiYgDdw9z0KpYtGt7tRGd0qDARky8uRQZ6HFS4sNXlUFiAG9ko62CFTD\n" + +// "WCALXmhtqvPcjfiDDL6qMRLevi31YnhAua/Kb0Mhja+KDM/UwRIVaB3WHhulzn7U\n" + +// "pFQG0vVnwb0+VWhKsrWVJaJw1Eg9tmy5HJBsnmne+A2qG1ehBFCWJtV2MvyK8H9G\n" + +// "BxaJbq7PpPlte9ID53apvkhyvag843Ar/pOiTc8J6xncJa6w+mVViUi47/ZkZCkU\n" + +// "lipgCv1ZqZhQG/CERDxACulTa+0S8nO+g5CBpW6cuQVa052nRV/qhVUkQ9yzm0Pw\n" + +// "vUOftuX9b/W5QXas/ysUwPAeGd2XPBmK5lByyYaW14d6GBJGmyNYv7vjrbL1xeJr\n" + +// "smjnaRPipOvwEh6IE1OdsrlqfjG27+aXgfZWbCW28DAeTK7ilLB3ubyvPcoTrmX3\n" + +// "DxM7OKF+MT6PAtqSM92l76PfECvyUfv/Rf+cSF/CleTIM7xfe7IOwgxPPdMEw2rH\n" + +// "uS/CeJMsdBW8DwQyRcgK5h17zyaRqztATSAQK3MQ/B2f7MoXf3Z9oLpgqyBT7aiL\n" + +// "/XdYk8UipIyuRK4Y9Cj2UNc3DgYhzFPQY9SO3gO483uC8Tqc2IyoKaGsNS1rWY/W\n" + +// "rleqqraEmlMN9NToAa4ftZvqdWQLqH7sJcCQ1EzfbrkyrTKgjRmvRyA4n3t9Yjry\n" + +// "k+ZI3xkgrUj90xfETb+Vx/JrbegfbfZ70w7yTRnSDB01cbQP4rjI2uGZVRCxXJal\n" + +// "XRtaOUey+c0ZeIRp2aPrYP2DesL0Fmlc/ooSRgC8f+QHJU/7Js+WYuK8MVK/vil9\n" + +// "J9FgwoCJImfRzkA9KXYaix/f4XgvFLopb6kAszAff5Zmpcq72gwWv+nEE/3M78PO\n" + +// "zs9k5+wt65W3h4zelAIUM5hfgmJj4vvq53AeZP42AhcSV+bgsPg2xGM0Im7WAQ0P\n" + +// "IScqN1pepq7T9/0eMEhRdXiKj5ufub/Nztfc+Ao8RVVidXt8oMnv9vf8FxgfLkpj\n" + +// "dn6Mjq7Y5OXz9AAAAAAAAAAAAAAAAAAAAAAAAAAOHy09A0gAMEUCIQDD13F6CblJ\n" + +// "Ll2dp7GZtR5tyKObPtvUc1s16fP3g7xhvgIga8IVcv0k6DUIApPztCsP/UByrm8k\n" + +// "1nbSe/5A4mF87n0=\n" + +// "-----END CERTIFICATE-----"; + + private static final String compositeSelfSignedCertificate = "-----BEGIN CERTIFICATE-----\n" + + "MIIPxzCCBeagAwIBAgIBBTAPBgtghkgBhvprUAgBBAUAMBIxEDAOBgNVBAMMB1JP\n" + + "T1QgQ0EwHhcNMjQwMjA4MTA0MjE2WhcNMjQwMjI1MTEyMjQ1WjASMRAwDgYDVQQD\n" + + "DAdST09UIENBMIIFgTANBgtghkgBhvprUAgBBAOCBW4AMIIFaQOCBSEAbBjwJ4KP\n" + + "/W9bM1qi0wxfk1AtT7QgnRMUaWsdwOGEatOM4qDPJ0aM6hhMJH9t2yBV7uudt+pr\n" + + "tFyYpyZpcDBKjKoWP6SthoriJzGYOIxZLrhwhU2tII3nyUk6v+0pdGAgUizRYRpO\n" + + "Hu/VhmLw1MDDFaGrLcy+HxNAUncExJ8L2QkvEVs8royQnxQ0qRiJopPoqDLTxMHh\n" + + "4tiDwpdSEAIWFPVtLcBoWLn6bBBSgQq+42PZJIg6yj3+26riHSZLFhTBqJhbIH3y\n" + + "kdIcGieQTXMNAxpdVqo6studi5f7hxNs+0H/HEXtyivI0Uw7ySwgljLhHQpXPEM5\n" + + "1MnAnhZU2MmXRGLLUj3o7U1Yr5wjlMbe6h4KDHYpj0yC2CfLXo6GxEp9RaEqK0d+\n" + + "HD1iL9qf3K2DxZ237d6VhjCvO5Bj6BG99ludVvUeqt2ZbsIincZJVKbni+9iQZm5\n" + + "FeidmYDmR0atrwoGSyGpqanx9E6PYS4kX1c8bqBKArhnFCKbVWgSwdiMY/ArgW8P\n" + + "voXVwki63562XAdc4cVYQ7VPUIzh7KV7El/FVrIpYfXg1PWX4Vkl/C+B81HP/NA2\n" + + "z4dpSMdCwEwO8gK/ikAKxKK1wngcfsntJY7y1wMuMnkq0hVCAHm5mqJ98vIdLGqg\n" + + "iNeSPnb+i544s++zzhc57Xl7OUE6oDO/NakNgeC3DCWnOi++niwOtcgjdDUK4f8w\n" + + "SXxoIIkRYZyhPu0rGBg3m6oF5KlZ3qzPhjmdQZmTxa4meRrOiW/JnqQy5CIAjo4B\n" + + "YvB9Pnozx8a2wHOiymplwxnpT2QaAxtKIr9rvXeDq3eV5gb8t/HQ9aG83IqqMets\n" + + "KaSpfDxhAAzyJADw6UCRgb/oEYS4uWEwOHAcf+S/QlMH1l01KXfLIjiveosOVWu8\n" + + "wh5tZUKhqd+PxQUVul62YZryf3QEhf5C8yqBfLVp21jqNjHxnWofcEOhmDbqygVX\n" + + "FUm0bAt+K6kMrtBDfT0jslj66PXgsmLoO4ba4ZUYfPJLu6afcEvLHFw8o/rMLKvR\n" + + "k4ycySCMjACl++IjPxDWfpOx1EBsoIoP8/RRMCnDbJTu/hrzs+wtuwjkaFyoOdQh\n" + + "wwx9vHafwmGrtM34dxubYDRCG4WZ0B3cAXMx5dqxz+a+2zMCHIfzPClYk9CAdoQN\n" + + "R82jY3u84w0lk1VwwAK77LQYZHCGJKUhURiNyCiv+4cn8sbzK9SY+tM+TYp3+Zf1\n" + + "0NVzhVInXjG0ORdPP+QqbSxiUSz8aO2ekHDjKMhr78cTG1n1iMK1l3H5EwHR2xVw\n" + + "r5VbB9FiyMmUOrvuy3wVnrXSK97kI7y2z7AH8JCdVsfuc9IPSVvosZJA2f5maIq7\n" + + "cUktS0SHC4QLCS1DAWwvnp/zaFcNzEdhJdJyZizU4HK3h3If/1ILdMA84EFAj1bH\n" + + "eNti7YDRDHrvnWIAs4N4cQnAmSD7acQL2b8e3ghpFlhLsdb5CQ6u4XejpcOBMw4T\n" + + "45CKsNRFMG8Jt25njRqWjGCA3T3CymCLL9tPub6mynP+2m6BvMpcf5Kt8mx3GKaP\n" + + "7vXQSdnLvy0ryFKpZ6QO2HMTS/d7WpVDqAcgqHo4RHcx2Nen69IJtWe8K4FJa6Ej\n" + + "LliVKImVBS/si/kGkgLNzl4dFMTLLM3pQD58nGHgH67E1GQIoCX64y1+cl04+vS8\n" + + "6v3+wiVNczxMhdFNsj6rlyC1qO0kVnYhhMh3XDEp1Zqw560y7j4Hr+KV/eBEHsl2\n" + + "7BqaapRgmnIsSQNCAAQdf+2mgJr7DjHsZbxexsyKFEpSrkqzVHDw5zUPE3VxKM1G\n" + + "yeFMCC/aREdv4GC2ivN+DROVckhw5LZRGERK6X4LMA8GC2CGSAGG+mtQCAEEBQAD\n" + + "ggnIADCCCcMDggl1AJPi96BeJGm5KTQBOlbLZBEUY1vlzfcR75zsQ+pQAiWNXlCx\n" + + "skULPvlc1HFT8UHJ4cB1ik8vwplUs3z8n2qbfNz+d2i7kJstfkVJF75cw0HqcNx3\n" + + "DqbZnaFw2RLs1n2qMoIaCEi7xxn7MBhE6QrYcP4Hi0V3MtukM1HxcyNMBNcvWhav\n" + + "XurOjXBLZPIcHMhGniMH80apLWc6Z5o/zpT9f2rgeXpUBHw2N2+O/a8jL58feGmX\n" + + "08SA0mVAo5kCHEq0FW+vQ82Kzos0sOuMURoSu7v0J+0AccI8lC5I/hyyzowCdKSz\n" + + "tKV1QiF1ujV70eOkxaEdUJAXDhMfjf8UljMzeHewhPhEN1DvdDBvlhdiH4UsIvJt\n" + + "6bfGBLR+/AIUDWq68LOozDUNwuMPOlAm2CmpoYsb59TySpfVVgS2twSAFA4qTx7h\n" + + "K/qNnrfuOpEXCBDFlHSk9WTyxKgEjCMpJFtiXau5K9Vo9QxC06BCBco12cap2RxA\n" + + "zUudh0AWoHhsRwTkJG0PAX5SAcLJW7FFx2Dmz7Yv6ZPVFo34B09DJ0xm0LoVQNbk\n" + + "R5LwrbomyWDWSwrVybKE9gAB97QUDosOH1XiknAC/rImDBZs5TkZCXHtAk14FopP\n" + + "Yvkb9vzShbKJdYg+ileU9dDpazuT3Ij3fk+wCxjBlltnN+wgaJj4ec8uYDEJJnq4\n" + + "IAzi7uxfUlOz4/tXnrU/drxbXgB2WD4PfTwxjG4SxpCYk9IWbdLVhE8Lwl4+UT9K\n" + + "rBwmi4iAnJGOwIPt4p9V8SO4NupnYgmI70+NVFQh2v06zIRKiduNQ2e7BubppZp2\n" + + "4xabRq6ExyV8m+GjtxByPLqLI5DuvAdnDtBNRSugLKcU7pzLIAaYjAetk8g+w2Rf\n" + + "hkRx9KSwdvCeGYUTq/rqkrOx/v/LWFLwYZ3sCjob/B4m8xJM/hcm92Au+l8DNykI\n" + + "aXds6k3IcvSRFs0X1jLeO93/usguTnaZFbI4u+BvAkx//nM2BXnEBliFXtsythF1\n" + + "8OH2m5T4FgxRIBDs4KssMazf9co0qO+GEljE+HGbzB9/Cx39a0xHk3Ju/NdwTNON\n" + + "M+5gUMR8gBqf2jWhCvvLztGRK9+vZvXXLe5UJAlf1Uql3Er1WAW/2O7D69CMOm17\n" + + "/poPj74p3s2LfnDIxUMESZEcre/c17AbRF26We5hp/ISNxH07rstzdPJrHtqSwJy\n" + + "1ffkUSPQaWmIK1NQJFW0PMyRvM4Z20dj0rXTEHOFOqodUw+xrZjg5VGX00KIfGXU\n" + + "nNpo0l3d4M8DsX7UZeS+ZhE51cjKDouJ9OGrGDDXf5+5z949rTES7mz/6obe05E6\n" + + "Qkpcca34HixK+3kpKXRu/UoPMvn4zkU5dvelA63VyigSF2k3K5mie2LXabnPL7Sz\n" + + "w7GeQdkmI7gqnj1rpp3RWdPI4+bcgwkvGedHbmy0Ue3jE/aZdooB1R3MY5DaNABn\n" + + "gZhMNdPDp6NJm8zYgXjaqOXwzAmcnJfvu647RZA6cXvLisVcq7iYYDqs2FeN+w63\n" + + "FA/C1OGf0fII1BaBPr6hrTZvAtq+ejNY9F3Wh8L3gmeNhLYtNCTz7AAF4HuAWlIi\n" + + "yKoI1wCEEKKB4yQm73LWo9xDYCxtPXyX0PAfod3/GRK1I+rhJuFkqp7b0ztbY3mm\n" + + "H3aiNp6NcBH/OZs8C9MEpESdysxPrsPbWD4o3nLB9zFg8dPlLo2fi1XrFngCybS6\n" + + "66YzB9q+2qhBQpCuYRYGbAWF9xNid5NsS5G7RFM7AdbVN/2xcNnX5MihO5jY2KhP\n" + + "hB6+Ai6tuH9uqvQteg9s8VpWpa1OXf4I8aX5Mc1qDvjnwX18Ke42vrW4i3lSLlHO\n" + + "km8UlY8DcLmwgvLFP1ajiDLZcFVflPz4KbbbYd0fafxxLXY8c2IjLd5gGk2rT0Uk\n" + + "Fjv5ev4MJ7wRo9lTCYvc19nYLxzbm6I0GY2W2E4gkZwze2YPPieNF5rRvXpLcwXg\n" + + "rZjZnjU4D+RYv8wO41LIto/ovJ4oBrfGatkqNRIdk6BgYfUoA5ZHVLvKCPnqDKgn\n" + + "eH26bczbc7KGCsQl1x6Y353ginfVvE+tKxEExZGmvqN8jV6qylRbyr8O2KjnP1QS\n" + + "aFlf+4tmXDUbsItK0uSKa5EOOdivrmC+/I9n2oe2Y0Tyzkf40i3nJ1UiJMW2Q+wl\n" + + "78E1ZligIdqCrMABEiBbUYCsXvlWNG4ZvpWcbbb5K2kinq4LnRYJ9lCnyWPuL9wQ\n" + + "mXFET0fZt2D/derdnwEht6+t7mPAjYlEM+DDfjLUSKjXJ2eRPR7Ck3T/mJvbBAtl\n" + + "U3Ew9zOa824p1yH3nxsh7kwR8BwckyQPXv+9iadp2bz8NOW29BqNXMit6FUhveZ2\n" + + "jt7rG3SHnp3XwXCYTdpYLwVTBOlidvUf6tw1xJtRopb0bbQLkyGjxNr28DMqTkHY\n" + + "1OlFoDqdUuTbdYRdITHtrkC1SJUTEVxLPdewELkUSztp/7lUVpzHPwt8/H0bS2zc\n" + + "qVmLp5VGPlhqP7V5Dq1ZHs8QVz6NLoD+deUCW02YQvH9EVv46kr0XUrLnALagJ0N\n" + + "drbH2johlEiKS9URxGSIjMd0WITyZjH9kWspM8RSSB/msG+zhRndl3wX8rZTU5mq\n" + + "aXSyCETWEIkZ3c3UoyycUkjdOMaV9mDSvItQfBIdweARXhAzKVYqOtzB/bA8qZ/+\n" + + "mefACQ2ijLW0z2Z7GEOeAdRQraht9Y02FWQvtOH0EDv88QbBC6GCch+2n64NZKlx\n" + + "5aDTbdpHopLzOgoR84/mkx3MzWwjMpnZlwlojoDKjjqJgtO7sKObHaaSzNCJoZbN\n" + + "KlwE6kDgaZqc9tMnzwSj4KnflBk+3xUE5ynqYbenWQkJuplZVlPR9IuSY9mqoxuJ\n" + + "pFK6xzPRXHzRRK69NhC+6B3LMPmVwC1dU6ZhN6g9QLaG4UwrXJf6vL56mywzK26+\n" + + "g5bTScFzUrRQamaYIvosGe9+tQoU7z6BXjviao9hqhghkRey9AlRUtlL6MwvHykY\n" + + "AyY9v5QK67UJHWgal1K3ufRcobVd2Mif9+fkUOmHKQml40kWdFP2HJZ7Jo3Jmamv\n" + + "eThJLjAjYlqVgGqd0Enz2M5LFcaBUvZO/OnYwr+kbTS6D/9Nk3J56358/NIYAhRI\n" + + "W2R6fr3FxuHj7RUiUXicocHF6+zy8xETFTlZcHSVore61ufxDSM0N0FTaWyEs7X/\n" + + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANGSczA0gAMEUCIExm7eRgVYXh\n" + + "TLJ0IPHKXNO4oahKkgJPAgDHaMlo6f+fAiEAvW2RaHsZK9g26XWGxaIQvdj2jO1r\n" + + "yIoOD/jVCpxqxEE=\n" + + "-----END CERTIFICATE-----"; + + private void checkParseAndVerifyCompositeCertificate() + { + try + { PEMParser pemParser = new PEMParser(new StringReader(compositeSelfSignedCertificate)); X509CertificateHolder certificateHolder = (X509CertificateHolder) pemParser.readObject(); JcaX509CertificateConverter x509Converter = new JcaX509CertificateConverter().setProvider("BC"); X509Certificate certificate = x509Converter.getCertificate(certificateHolder); - isEquals(certificate.getSigAlgOID(), "2.16.840.1.114027.80.7.1.4"); //id-MLDSA44-ECDSA-P256-SHA256 + isEquals(certificate.getSigAlgOID(), "2.16.840.1.114027.80.8.1.4"); //id-MLDSA44-ECDSA-P256-SHA256 CompositePublicKey compositePublicKey = (CompositePublicKey) certificate.getPublicKey(); @@ -5526,7 +5958,9 @@ private void checkParseAndVerifyCompositeCertificate() { isEquals(compositePublicKey.getPublicKeys().get(1).getAlgorithm(), "ECDSA"); certificate.verify(compositePublicKey); - } catch (Exception e) { + } + catch (Exception e) + { fail("checkParseAndVerifyCompositeCertificate failed: " + e.getMessage()); } } diff --git a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/CompositeSignaturesConstants.java b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/CompositeSignaturesConstants.java index 2da89dfa19..d4fbb1d537 100644 --- a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/CompositeSignaturesConstants.java +++ b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/CompositeSignaturesConstants.java @@ -16,14 +16,46 @@ public abstract class CompositeSignaturesConstants /** * An array of supported identifiers of composite signature schemes. */ - public static final ASN1ObjectIdentifier[] supportedIdentifiers = {MiscObjectIdentifiers.id_MLDSA44_RSA2048_PSS_SHA256, MiscObjectIdentifiers.id_MLDSA44_RSA2048_PKCS15_SHA256, MiscObjectIdentifiers.id_MLDSA44_Ed25519_SHA512, MiscObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256, MiscObjectIdentifiers.id_MLDSA44_ECDSA_brainpoolP256r1_SHA256, MiscObjectIdentifiers.id_MLDSA65_RSA3072_PSS_SHA256, MiscObjectIdentifiers.id_MLDSA65_RSA3072_PKCS15_SHA256, MiscObjectIdentifiers.id_MLDSA65_ECDSA_P256_SHA256, MiscObjectIdentifiers.id_MLDSA65_ECDSA_brainpoolP256r1_SHA256, MiscObjectIdentifiers.id_MLDSA65_Ed25519_SHA512, MiscObjectIdentifiers.id_MLDSA87_ECDSA_P384_SHA384, MiscObjectIdentifiers.id_MLDSA87_ECDSA_brainpoolP384r1_SHA384, MiscObjectIdentifiers.id_MLDSA87_Ed448_SHAKE256, MiscObjectIdentifiers.id_Falcon512_ECDSA_P256_SHA256, MiscObjectIdentifiers.id_Falcon512_ECDSA_brainpoolP256r1_SHA256, MiscObjectIdentifiers.id_Falcon512_Ed25519_SHA512,}; + public static final ASN1ObjectIdentifier[] supportedIdentifiers = { + MiscObjectIdentifiers.id_MLDSA44_RSA2048_PSS_SHA256, + MiscObjectIdentifiers.id_MLDSA44_RSA2048_PKCS15_SHA256, + MiscObjectIdentifiers.id_MLDSA44_Ed25519_SHA512, + MiscObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256, + MiscObjectIdentifiers.id_MLDSA44_ECDSA_brainpoolP256r1_SHA256, + MiscObjectIdentifiers.id_MLDSA65_RSA3072_PSS_SHA512, + MiscObjectIdentifiers.id_MLDSA65_RSA3072_PKCS15_SHA512, + MiscObjectIdentifiers.id_MLDSA65_ECDSA_P256_SHA512, + MiscObjectIdentifiers.id_MLDSA65_ECDSA_brainpoolP256r1_SHA512, + MiscObjectIdentifiers.id_MLDSA65_Ed25519_SHA512, + MiscObjectIdentifiers.id_MLDSA87_ECDSA_P384_SHA512, + MiscObjectIdentifiers.id_MLDSA87_ECDSA_brainpoolP384r1_SHA512, + MiscObjectIdentifiers.id_MLDSA87_Ed448_SHA512, + MiscObjectIdentifiers.id_Falcon512_ECDSA_P256_SHA256, + MiscObjectIdentifiers.id_Falcon512_ECDSA_brainpoolP256r1_SHA256, + MiscObjectIdentifiers.id_Falcon512_Ed25519_SHA512, + }; /** * Enum of supported composited signature schemes. Each one corresponds to a value from supportedIdentifiers. */ public enum CompositeName { - MLDSA44_RSA2048_PSS_SHA256, MLDSA44_RSA2048_PKCS15_SHA256, MLDSA44_ECDSA_P256_SHA256, MLDSA44_ECDSA_brainpoolP256r1_SHA256, MLDSA44_Ed25519_SHA512, MLDSA65_RSA3072_PSS_SHA256, MLDSA65_RSA3072_PKCS15_SHA256, MLDSA65_ECDSA_brainpoolP256r1_SHA256, MLDSA65_ECDSA_P256_SHA256, MLDSA65_Ed25519_SHA512, MLDSA87_ECDSA_P384_SHA384, MLDSA87_ECDSA_brainpoolP384r1_SHA384, MLDSA87_Ed448_SHAKE256, Falcon512_ECDSA_P256_SHA256, Falcon512_ECDSA_brainpoolP256r1_SHA256, Falcon512_Ed25519_SHA512, + MLDSA44_RSA2048_PSS_SHA256, + MLDSA44_RSA2048_PKCS15_SHA256, + MLDSA44_ECDSA_P256_SHA256, + MLDSA44_ECDSA_brainpoolP256r1_SHA256, + MLDSA44_Ed25519_SHA512, + MLDSA65_RSA3072_PSS_SHA512, + MLDSA65_RSA3072_PKCS15_SHA512, + MLDSA65_ECDSA_brainpoolP256r1_SHA512, + MLDSA65_ECDSA_P256_SHA512, + MLDSA65_Ed25519_SHA512, + MLDSA87_ECDSA_P384_SHA512, + MLDSA87_ECDSA_brainpoolP384r1_SHA512, + MLDSA87_Ed448_SHA512, + Falcon512_ECDSA_P256_SHA256, + Falcon512_ECDSA_brainpoolP256r1_SHA256, + Falcon512_Ed25519_SHA512, } /** @@ -39,14 +71,14 @@ public enum CompositeName compositeNameASN1IdentifierMap.put(CompositeName.MLDSA44_ECDSA_P256_SHA256, MiscObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256); compositeNameASN1IdentifierMap.put(CompositeName.MLDSA44_ECDSA_brainpoolP256r1_SHA256, MiscObjectIdentifiers.id_MLDSA44_ECDSA_brainpoolP256r1_SHA256); compositeNameASN1IdentifierMap.put(CompositeName.MLDSA44_Ed25519_SHA512, MiscObjectIdentifiers.id_MLDSA44_Ed25519_SHA512); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_RSA3072_PSS_SHA256, MiscObjectIdentifiers.id_MLDSA65_RSA3072_PSS_SHA256); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_RSA3072_PKCS15_SHA256, MiscObjectIdentifiers.id_MLDSA65_RSA3072_PKCS15_SHA256); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_ECDSA_P256_SHA256, MiscObjectIdentifiers.id_MLDSA65_ECDSA_P256_SHA256); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_ECDSA_brainpoolP256r1_SHA256, MiscObjectIdentifiers.id_MLDSA65_ECDSA_brainpoolP256r1_SHA256); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_RSA3072_PSS_SHA512, MiscObjectIdentifiers.id_MLDSA65_RSA3072_PSS_SHA512); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_RSA3072_PKCS15_SHA512, MiscObjectIdentifiers.id_MLDSA65_RSA3072_PKCS15_SHA512); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_ECDSA_P256_SHA512, MiscObjectIdentifiers.id_MLDSA65_ECDSA_P256_SHA512); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_ECDSA_brainpoolP256r1_SHA512, MiscObjectIdentifiers.id_MLDSA65_ECDSA_brainpoolP256r1_SHA512); compositeNameASN1IdentifierMap.put(CompositeName.MLDSA65_Ed25519_SHA512, MiscObjectIdentifiers.id_MLDSA65_Ed25519_SHA512); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA87_ECDSA_P384_SHA384, MiscObjectIdentifiers.id_MLDSA87_ECDSA_P384_SHA384); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA87_ECDSA_brainpoolP384r1_SHA384, MiscObjectIdentifiers.id_MLDSA87_ECDSA_brainpoolP384r1_SHA384); - compositeNameASN1IdentifierMap.put(CompositeName.MLDSA87_Ed448_SHAKE256, MiscObjectIdentifiers.id_MLDSA87_Ed448_SHAKE256); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA87_ECDSA_P384_SHA512, MiscObjectIdentifiers.id_MLDSA87_ECDSA_P384_SHA512); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA87_ECDSA_brainpoolP384r1_SHA512, MiscObjectIdentifiers.id_MLDSA87_ECDSA_brainpoolP384r1_SHA512); + compositeNameASN1IdentifierMap.put(CompositeName.MLDSA87_Ed448_SHA512, MiscObjectIdentifiers.id_MLDSA87_Ed448_SHA512); compositeNameASN1IdentifierMap.put(CompositeName.Falcon512_ECDSA_P256_SHA256, MiscObjectIdentifiers.id_Falcon512_ECDSA_P256_SHA256); compositeNameASN1IdentifierMap.put(CompositeName.Falcon512_ECDSA_brainpoolP256r1_SHA256, MiscObjectIdentifiers.id_Falcon512_ECDSA_brainpoolP256r1_SHA256); compositeNameASN1IdentifierMap.put(CompositeName.Falcon512_Ed25519_SHA512, MiscObjectIdentifiers.id_Falcon512_Ed25519_SHA512); @@ -66,23 +98,6 @@ public enum CompositeName } } - /** - * Map from CompositeName to OID name from https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-10.html. - * CompositeName enum value is converted to string, prefixed with "id-" and "_" replaced with "-". - * These strings are used in the signing/verification process as a prefix for the message. - */ - public static final HashMap compositeNameOIDStringMap; - - static - { - compositeNameOIDStringMap = new HashMap<>(); - - for (CompositeName algName : CompositeName.values()) - { - compositeNameOIDStringMap.put(algName, "id-" + algName.name().replace("_", "-")); - } - } - /** * Map from ASN1 identifier to a readable string used as the composite signature name for the JCA/JCE API. */ diff --git a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyFactorySpi.java b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyFactorySpi.java index 3055c8fec5..56098b76d3 100644 --- a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyFactorySpi.java +++ b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyFactorySpi.java @@ -178,23 +178,23 @@ private List getKeyFactoriesFromIdentifier(ASN1ObjectIdentifier algo algorithmNames.add("Dilithium"); algorithmNames.add("Ed25519"); break; - case MLDSA87_Ed448_SHAKE256: + case MLDSA87_Ed448_SHA512: algorithmNames.add("Dilithium"); algorithmNames.add("Ed448"); break; case MLDSA44_RSA2048_PSS_SHA256: case MLDSA44_RSA2048_PKCS15_SHA256: - case MLDSA65_RSA3072_PSS_SHA256: - case MLDSA65_RSA3072_PKCS15_SHA256: + case MLDSA65_RSA3072_PSS_SHA512: + case MLDSA65_RSA3072_PKCS15_SHA512: algorithmNames.add("Dilithium"); algorithmNames.add("RSA"); break; case MLDSA44_ECDSA_P256_SHA256: case MLDSA44_ECDSA_brainpoolP256r1_SHA256: - case MLDSA65_ECDSA_P256_SHA256: - case MLDSA65_ECDSA_brainpoolP256r1_SHA256: - case MLDSA87_ECDSA_P384_SHA384: - case MLDSA87_ECDSA_brainpoolP384r1_SHA384: + case MLDSA65_ECDSA_P256_SHA512: + case MLDSA65_ECDSA_brainpoolP256r1_SHA512: + case MLDSA87_ECDSA_P384_SHA512: + case MLDSA87_ECDSA_brainpoolP384r1_SHA512: algorithmNames.add("Dilithium"); algorithmNames.add("ECDSA"); break; @@ -254,28 +254,28 @@ private X509EncodedKeySpec[] getKeysSpecs(ASN1ObjectIdentifier algorithmIdentifi keyInfos[0] = new SubjectPublicKeyInfo(dilithium3Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(ed25519Identifier, subjectPublicKeys[1]); break; - case MLDSA65_ECDSA_P256_SHA256: + case MLDSA65_ECDSA_P256_SHA512: keyInfos[0] = new SubjectPublicKeyInfo(dilithium3Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(ecdsaP256Identifier, subjectPublicKeys[1]); break; - case MLDSA65_ECDSA_brainpoolP256r1_SHA256: + case MLDSA65_ECDSA_brainpoolP256r1_SHA512: keyInfos[0] = new SubjectPublicKeyInfo(dilithium3Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(ecdsaBrainpoolP256r1Identifier, subjectPublicKeys[1]); break; - case MLDSA65_RSA3072_PSS_SHA256: - case MLDSA65_RSA3072_PKCS15_SHA256: + case MLDSA65_RSA3072_PSS_SHA512: + case MLDSA65_RSA3072_PKCS15_SHA512: keyInfos[0] = new SubjectPublicKeyInfo(dilithium3Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(rsaIdentifier, subjectPublicKeys[1]); break; - case MLDSA87_Ed448_SHAKE256: + case MLDSA87_Ed448_SHA512: keyInfos[0] = new SubjectPublicKeyInfo(dilithium5Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(ed448Identifier, subjectPublicKeys[1]); break; - case MLDSA87_ECDSA_P384_SHA384: + case MLDSA87_ECDSA_P384_SHA512: keyInfos[0] = new SubjectPublicKeyInfo(dilithium5Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(ecdsaP384Identifier, subjectPublicKeys[1]); break; - case MLDSA87_ECDSA_brainpoolP384r1_SHA384: + case MLDSA87_ECDSA_brainpoolP384r1_SHA512: keyInfos[0] = new SubjectPublicKeyInfo(dilithium5Identifier, subjectPublicKeys[0]); keyInfos[1] = new SubjectPublicKeyInfo(ecdsaBrainpoolP384r1Identifier, subjectPublicKeys[1]); break; diff --git a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyPairGeneratorSpi.java b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyPairGeneratorSpi.java index 570e43c50d..8650d93408 100644 --- a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyPairGeneratorSpi.java +++ b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyPairGeneratorSpi.java @@ -73,7 +73,7 @@ private void initializeParameters() generators.get(0).initialize(DilithiumParameterSpec.dilithium3, this.secureRandom); generators.get(1).initialize(256, this.secureRandom); break; - case MLDSA87_Ed448_SHAKE256: + case MLDSA87_Ed448_SHA512: generators.add(KeyPairGenerator.getInstance("Dilithium", "BC")); generators.add(KeyPairGenerator.getInstance("Ed448", "BC")); generators.get(0).initialize(DilithiumParameterSpec.dilithium5, this.secureRandom); @@ -86,8 +86,8 @@ private void initializeParameters() generators.get(0).initialize(DilithiumParameterSpec.dilithium2, this.secureRandom); generators.get(1).initialize(2048, this.secureRandom); break; - case MLDSA65_RSA3072_PSS_SHA256: - case MLDSA65_RSA3072_PKCS15_SHA256: + case MLDSA65_RSA3072_PSS_SHA512: + case MLDSA65_RSA3072_PKCS15_SHA512: generators.add(KeyPairGenerator.getInstance("Dilithium", "BC")); generators.add(KeyPairGenerator.getInstance("RSA", "BC")); generators.get(0).initialize(DilithiumParameterSpec.dilithium3, this.secureRandom); @@ -105,25 +105,25 @@ private void initializeParameters() generators.get(0).initialize(DilithiumParameterSpec.dilithium2, this.secureRandom); generators.get(1).initialize(new ECGenParameterSpec("brainpoolP256r1"), this.secureRandom); break; - case MLDSA65_ECDSA_P256_SHA256: + case MLDSA65_ECDSA_P256_SHA512: generators.add(KeyPairGenerator.getInstance("Dilithium", "BC")); generators.add(KeyPairGenerator.getInstance("ECDSA", "BC")); generators.get(0).initialize(DilithiumParameterSpec.dilithium3, this.secureRandom); generators.get(1).initialize(new ECGenParameterSpec("P-256"), this.secureRandom); break; - case MLDSA65_ECDSA_brainpoolP256r1_SHA256: + case MLDSA65_ECDSA_brainpoolP256r1_SHA512: generators.add(KeyPairGenerator.getInstance("Dilithium", "BC")); generators.add(KeyPairGenerator.getInstance("ECDSA", "BC")); generators.get(0).initialize(DilithiumParameterSpec.dilithium3, this.secureRandom); generators.get(1).initialize(new ECGenParameterSpec("brainpoolP256r1"), this.secureRandom); break; - case MLDSA87_ECDSA_P384_SHA384: + case MLDSA87_ECDSA_P384_SHA512: generators.add(KeyPairGenerator.getInstance("Dilithium", "BC")); generators.add(KeyPairGenerator.getInstance("ECDSA", "BC")); generators.get(0).initialize(DilithiumParameterSpec.dilithium5, this.secureRandom); generators.get(1).initialize(new ECGenParameterSpec("P-384"), this.secureRandom); break; - case MLDSA87_ECDSA_brainpoolP384r1_SHA384: + case MLDSA87_ECDSA_brainpoolP384r1_SHA512: generators.add(KeyPairGenerator.getInstance("Dilithium", "BC")); generators.add(KeyPairGenerator.getInstance("ECDSA", "BC")); generators.get(0).initialize(DilithiumParameterSpec.dilithium5, this.secureRandom); @@ -244,7 +244,7 @@ public static final class MLDSA87andEd448 extends KeyPairGeneratorSpi { public MLDSA87andEd448() { - super(CompositeSignaturesConstants.CompositeName.MLDSA87_Ed448_SHAKE256); + super(CompositeSignaturesConstants.CompositeName.MLDSA87_Ed448_SHA512); } } @@ -268,7 +268,7 @@ public static final class MLDSA65andRSA3072PSS extends KeyPairGeneratorSpi { public MLDSA65andRSA3072PSS() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PSS_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PSS_SHA512); } } @@ -276,7 +276,7 @@ public static final class MLDSA65andRSA3072PKCS15 extends KeyPairGeneratorSpi { public MLDSA65andRSA3072PKCS15() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PKCS15_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PKCS15_SHA512); } } @@ -300,7 +300,7 @@ public static final class MLDSA65andECDSAP256 extends KeyPairGeneratorSpi { public MLDSA65andECDSAP256() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_P256_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_P256_SHA512); } } @@ -308,7 +308,7 @@ public static final class MLDSA65andECDSAbrainpoolP256r1 extends KeyPairGenerato { public MLDSA65andECDSAbrainpoolP256r1() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_brainpoolP256r1_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_brainpoolP256r1_SHA512); } } @@ -316,7 +316,7 @@ public static final class MLDSA87andECDSAP384 extends KeyPairGeneratorSpi { public MLDSA87andECDSAP384() { - super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_P384_SHA384); + super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_P384_SHA512); } } @@ -324,7 +324,7 @@ public static final class MLDSA87andECDSAbrainpoolP384r1 extends KeyPairGenerato { public MLDSA87andECDSAbrainpoolP384r1() { - super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_brainpoolP384r1_SHA384); + super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_brainpoolP384r1_SHA512); } } diff --git a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/SignatureSpi.java b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/SignatureSpi.java index 65f532b353..ddc1b83e22 100644 --- a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/SignatureSpi.java +++ b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/SignatureSpi.java @@ -12,7 +12,6 @@ import org.bouncycastle.jcajce.CompositePublicKey; import java.io.IOException; -import java.nio.charset.StandardCharsets; import java.security.PublicKey; import java.security.PrivateKey; import java.security.NoSuchAlgorithmException; @@ -42,6 +41,7 @@ public class SignatureSpi extends java.security.SignatureSpi //Hash function that is used to pre-hash the input message before it is fed into the component Signature. //Each composite signature has a specific hash function https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-10.html private final Digest digest; + private byte[] OIDBytes; SignatureSpi(CompositeSignaturesConstants.CompositeName algorithmIdentifier) @@ -59,36 +59,44 @@ public class SignatureSpi extends java.security.SignatureSpi componentSignatures.add(Signature.getInstance("Ed25519", "BC")); this.digest = DigestFactory.createSHA512(); break; - case MLDSA87_Ed448_SHAKE256: + case MLDSA87_Ed448_SHA512: componentSignatures.add(Signature.getInstance("Dilithium", "BC")); componentSignatures.add(Signature.getInstance("Ed448", "BC")); - this.digest = DigestFactory.createSHAKE256(); + this.digest = DigestFactory.createSHA512(); break; case MLDSA44_RSA2048_PSS_SHA256: - case MLDSA65_RSA3072_PSS_SHA256: componentSignatures.add(Signature.getInstance("Dilithium", "BC")); componentSignatures.add(Signature.getInstance("SHA256withRSA/PSS", "BC")); //PSS with SHA-256 as digest algo and MGF. this.digest = DigestFactory.createSHA256(); break; + case MLDSA65_RSA3072_PSS_SHA512: + componentSignatures.add(Signature.getInstance("Dilithium", "BC")); + componentSignatures.add(Signature.getInstance("SHA512withRSA/PSS", "BC")); //PSS with SHA-512 as digest algo and MGF. + this.digest = DigestFactory.createSHA512(); + break; case MLDSA44_RSA2048_PKCS15_SHA256: - case MLDSA65_RSA3072_PKCS15_SHA256: componentSignatures.add(Signature.getInstance("Dilithium", "BC")); componentSignatures.add(Signature.getInstance("SHA256withRSA", "BC")); //PKCS15 this.digest = DigestFactory.createSHA256(); break; + case MLDSA65_RSA3072_PKCS15_SHA512: + componentSignatures.add(Signature.getInstance("Dilithium", "BC")); + componentSignatures.add(Signature.getInstance("SHA512withRSA", "BC")); //PKCS15 + this.digest = DigestFactory.createSHA512(); + break; case MLDSA44_ECDSA_P256_SHA256: case MLDSA44_ECDSA_brainpoolP256r1_SHA256: - case MLDSA65_ECDSA_P256_SHA256: - case MLDSA65_ECDSA_brainpoolP256r1_SHA256: componentSignatures.add(Signature.getInstance("Dilithium", "BC")); componentSignatures.add(Signature.getInstance("SHA256withECDSA", "BC")); this.digest = DigestFactory.createSHA256(); break; - case MLDSA87_ECDSA_P384_SHA384: - case MLDSA87_ECDSA_brainpoolP384r1_SHA384: + case MLDSA65_ECDSA_P256_SHA512: + case MLDSA65_ECDSA_brainpoolP256r1_SHA512: + case MLDSA87_ECDSA_P384_SHA512: + case MLDSA87_ECDSA_brainpoolP384r1_SHA512: componentSignatures.add(Signature.getInstance("Dilithium", "BC")); - componentSignatures.add(Signature.getInstance("SHA384withECDSA", "BC")); - this.digest = DigestFactory.createSHA384(); + componentSignatures.add(Signature.getInstance("SHA512withECDSA", "BC")); + this.digest = DigestFactory.createSHA512(); break; case Falcon512_ECDSA_P256_SHA256: case Falcon512_ECDSA_brainpoolP256r1_SHA256: @@ -104,8 +112,12 @@ public class SignatureSpi extends java.security.SignatureSpi default: throw new RuntimeException("Unknown composite algorithm."); } + + //get bytes of composite signature algorithm OID in DER + //these bytes are used a prefix to the message digest https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-11.html#name-composite-sign + OIDBytes = this.algorithmIdentifierASN1.getEncoded(ASN1Encoding.DER); } - catch (NoSuchAlgorithmException | NoSuchProviderException e) + catch (NoSuchAlgorithmException | NoSuchProviderException | IOException e) { throw new RuntimeException(e); } @@ -181,13 +193,10 @@ protected byte[] engineSign() throws SignatureException //calculate message digest (pre-hashing of the message) byte[] digestResult = new byte[digest.getDigestSize()]; digest.doFinal(digestResult, 0); - //get bytes of composite signature algorithm name - //these bytes are used a prefix to the message digest https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-10.html#name-composite-sign - byte[] OIDBytes = CompositeSignaturesConstants.compositeNameOIDStringMap.get(this.algorithmIdentifier).getBytes(StandardCharsets.US_ASCII); for (int i = 0; i < this.componentSignatures.size(); i++) { - this.componentSignatures.get(i).update(OIDBytes); + this.componentSignatures.get(i).update(this.OIDBytes); this.componentSignatures.get(i).update(digestResult); //in total, "OID || digest(message)" is the message fed into each component signature byte[] signatureValue = this.componentSignatures.get(i).sign(); signatureSequence.add(new DERBitString(signatureValue)); @@ -224,9 +233,6 @@ protected boolean engineVerify(byte[] signature) throws SignatureException //calculate message digest (pre-hashing of the message) byte[] digestResult = new byte[digest.getDigestSize()]; digest.doFinal(digestResult, 0); - //get bytes of composite signature algorithm name - //these bytes are used a prefix to the message digest https://www.ietf.org/archive/id/draft-ounsworth-pq-composite-sigs-10.html#name-composite-verify - byte[] OIDBytes = CompositeSignaturesConstants.compositeNameOIDStringMap.get(this.algorithmIdentifier).getBytes(StandardCharsets.US_ASCII); // Currently all signatures try to verify even if, e.g., the first is invalid. // If each component verify() is constant time, then this is also, otherwise it does not make sense to iterate over all if one of them already fails. @@ -235,7 +241,7 @@ protected boolean engineVerify(byte[] signature) throws SignatureException for (int i = 0; i < this.componentSignatures.size(); i++) { - this.componentSignatures.get(i).update(OIDBytes); + this.componentSignatures.get(i).update(this.OIDBytes); this.componentSignatures.get(i).update(digestResult); //in total, "OID || digest(message)" is the message fed into each component signature if (!this.componentSignatures.get(i).verify(DERBitString.getInstance(signatureSequence.getObjectAt(i)).getBytes())) { @@ -281,7 +287,7 @@ public final static class MLDSA87andEd448 extends SignatureSpi { public MLDSA87andEd448() { - super(CompositeSignaturesConstants.CompositeName.MLDSA87_Ed448_SHAKE256); + super(CompositeSignaturesConstants.CompositeName.MLDSA87_Ed448_SHA512); } } @@ -305,7 +311,7 @@ public final static class MLDSA65andRSA3072PSS extends SignatureSpi { public MLDSA65andRSA3072PSS() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PSS_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PSS_SHA512); } } @@ -313,7 +319,7 @@ public final static class MLDSA65andRSA3072PKCS15 extends SignatureSpi { public MLDSA65andRSA3072PKCS15() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PKCS15_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_RSA3072_PKCS15_SHA512); } } @@ -337,7 +343,7 @@ public final static class MLDSA65andECDSAP256 extends SignatureSpi { public MLDSA65andECDSAP256() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_P256_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_P256_SHA512); } } @@ -345,7 +351,7 @@ public final static class MLDSA65andECDSAbrainpoolP256r1 extends SignatureSpi { public MLDSA65andECDSAbrainpoolP256r1() { - super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_brainpoolP256r1_SHA256); + super(CompositeSignaturesConstants.CompositeName.MLDSA65_ECDSA_brainpoolP256r1_SHA512); } } @@ -353,7 +359,7 @@ public final static class MLDSA87andECDSAP384 extends SignatureSpi { public MLDSA87andECDSAP384() { - super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_P384_SHA384); + super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_P384_SHA512); } } @@ -361,7 +367,7 @@ public final static class MLDSA87andECDSAbrainpoolP384r1 extends SignatureSpi { public MLDSA87andECDSAbrainpoolP384r1() { - super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_brainpoolP384r1_SHA384); + super(CompositeSignaturesConstants.CompositeName.MLDSA87_ECDSA_brainpoolP384r1_SHA512); } } diff --git a/prov/src/test/java/org/bouncycastle/jcajce/provider/test/CompositeSignaturesTest.java b/prov/src/test/java/org/bouncycastle/jcajce/provider/test/CompositeSignaturesTest.java index f67a2770c9..0c394de669 100644 --- a/prov/src/test/java/org/bouncycastle/jcajce/provider/test/CompositeSignaturesTest.java +++ b/prov/src/test/java/org/bouncycastle/jcajce/provider/test/CompositeSignaturesTest.java @@ -18,22 +18,23 @@ public class CompositeSignaturesTest extends TestCase { - private static String[] compositeSignaturesOIDs = {"2.16.840.1.114027.80.7.1.1", //id-MLDSA44-RSA2048-PSS-SHA256 - "2.16.840.1.114027.80.7.1.2", //id-MLDSA44-RSA2048-PKCS15-SHA256 - "2.16.840.1.114027.80.7.1.3", //id-MLDSA44-Ed25519-SHA512 - "2.16.840.1.114027.80.7.1.4", //id-MLDSA44-ECDSA-P256-SHA256 - "2.16.840.1.114027.80.7.1.5", //id-MLDSA44-ECDSA-brainpoolP256r1-SHA256 - "2.16.840.1.114027.80.7.1.6", //id-MLDSA65-RSA3072-PSS-SHA256 - "2.16.840.1.114027.80.7.1.7", //id-MLDSA65-RSA3072-PKCS15-SHA256 - "2.16.840.1.114027.80.7.1.8", //id-MLDSA65-ECDSA-P256-SHA256 - "2.16.840.1.114027.80.7.1.9", //id-MLDSA65-ECDSA-brainpoolP256r1-SHA256 - "2.16.840.1.114027.80.7.1.10", //id-MLDSA65-Ed25519-SHA512 - "2.16.840.1.114027.80.7.1.11", //id-MLDSA87-ECDSA-P384-SHA384 - "2.16.840.1.114027.80.7.1.12", //id-MLDSA87-ECDSA-brainpoolP384r1-SHA384 - "2.16.840.1.114027.80.7.1.13", //id-MLDSA87-Ed448-SHAKE256 - "2.16.840.1.114027.80.7.1.14", //id-Falcon512-ECDSA-P256-SHA256 - "2.16.840.1.114027.80.7.1.15", //id-Falcon512-ECDSA-brainpoolP256r1-SHA256 - "2.16.840.1.114027.80.7.1.16", //id-Falcon512-Ed25519-SHA512 + private static String[] compositeSignaturesOIDs = { + "2.16.840.1.114027.80.8.1.1", //id-MLDSA44-RSA2048-PSS-SHA256 + "2.16.840.1.114027.80.8.1.2", //id-MLDSA44-RSA2048-PKCS15-SHA256 + "2.16.840.1.114027.80.8.1.3", //id-MLDSA44-Ed25519-SHA512 + "2.16.840.1.114027.80.8.1.4", //id-MLDSA44-ECDSA-P256-SHA256 + "2.16.840.1.114027.80.8.1.5", //id-MLDSA44-ECDSA-brainpoolP256r1-SHA256 + "2.16.840.1.114027.80.8.1.6", //id-MLDSA65-RSA3072-PSS-SHA512 + "2.16.840.1.114027.80.8.1.7", //id-MLDSA65-RSA3072-PKCS15-SHA512 + "2.16.840.1.114027.80.8.1.8", //id-MLDSA65-ECDSA-P256-SHA512 + "2.16.840.1.114027.80.8.1.9", //id-MLDSA65-ECDSA-brainpoolP256r1-SHA512 + "2.16.840.1.114027.80.8.1.10", //id-MLDSA65-Ed25519-SHA512 + "2.16.840.1.114027.80.8.1.11", //id-MLDSA87-ECDSA-P384-SHA512 + "2.16.840.1.114027.80.8.1.12", //id-MLDSA87-ECDSA-brainpoolP384r1-SHA512 + "2.16.840.1.114027.80.8.1.13", //id-MLDSA87-Ed448-SHA512 + "2.16.840.1.114027.80.8.1.14", //id-Falcon512-ECDSA-P256-SHA256 + "2.16.840.1.114027.80.8.1.15", //id-Falcon512-ECDSA-brainpoolP256r1-SHA256 + "2.16.840.1.114027.80.8.1.16", //id-Falcon512-Ed25519-SHA512 }; public static final String messageToBeSigned = "Hello, how was your day?"; @@ -80,8 +81,8 @@ public void testKeyPairGeneration() throws Exception { TestCase.assertEquals("ECDSA", secondPublicKeyAlgorithm); TestCase.assertEquals("ECDSA", secondPrivateKeyAlgorithm); break; - case MLDSA65_RSA3072_PSS_SHA256: - case MLDSA65_RSA3072_PKCS15_SHA256: + case MLDSA65_RSA3072_PSS_SHA512: + case MLDSA65_RSA3072_PKCS15_SHA512: TestCase.assertEquals("DILITHIUM3", firstPublicKeyAlgorithm); TestCase.assertEquals("DILITHIUM3", firstPrivateKeyAlgorithm); TestCase.assertEquals("RSA", secondPublicKeyAlgorithm); @@ -97,21 +98,21 @@ public void testKeyPairGeneration() throws Exception { TestCase.assertEquals("ED25519", secondPublicKeyAlgorithm); TestCase.assertEquals("ED25519", secondPrivateKeyAlgorithm); break; - case MLDSA65_ECDSA_P256_SHA256: - case MLDSA65_ECDSA_brainpoolP256r1_SHA256: + case MLDSA65_ECDSA_P256_SHA512: + case MLDSA65_ECDSA_brainpoolP256r1_SHA512: TestCase.assertEquals("DILITHIUM3", firstPublicKeyAlgorithm); TestCase.assertEquals("DILITHIUM3", firstPrivateKeyAlgorithm); TestCase.assertEquals("ECDSA", secondPublicKeyAlgorithm); TestCase.assertEquals("ECDSA", secondPrivateKeyAlgorithm); break; - case MLDSA87_Ed448_SHAKE256: + case MLDSA87_Ed448_SHA512: TestCase.assertEquals("DILITHIUM5", firstPublicKeyAlgorithm); TestCase.assertEquals("DILITHIUM5", firstPrivateKeyAlgorithm); TestCase.assertEquals("ED448", secondPublicKeyAlgorithm); TestCase.assertEquals("ED448", secondPrivateKeyAlgorithm); break; - case MLDSA87_ECDSA_P384_SHA384: - case MLDSA87_ECDSA_brainpoolP384r1_SHA384: + case MLDSA87_ECDSA_P384_SHA512: + case MLDSA87_ECDSA_brainpoolP384r1_SHA512: TestCase.assertEquals("DILITHIUM5", firstPublicKeyAlgorithm); TestCase.assertEquals("DILITHIUM5", firstPrivateKeyAlgorithm); TestCase.assertEquals("ECDSA", secondPublicKeyAlgorithm); diff --git a/prov/src/test/resources/org/bouncycastle/jcajce/provider/test/compositeSignatures.sample b/prov/src/test/resources/org/bouncycastle/jcajce/provider/test/compositeSignatures.sample index 810c0f316d..1bc7365e51 100644 --- a/prov/src/test/resources/org/bouncycastle/jcajce/provider/test/compositeSignatures.sample +++ b/prov/src/test/resources/org/bouncycastle/jcajce/provider/test/compositeSignatures.sample @@ -1,16 +1,16 @@ -2.16.840.1.114027.80.7.1.1;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.2;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.3;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;MIIFYDANBgtghkgBhvprUAcBAwOCBU0AMIIFSAOCBSEAum17PBBK1MSTN/vhGScJzq95IRFOYn29I3RP8wAqlECqjlioY47LfTaHctmAJnqRvWiQzXsCa40xuqGitVw2xuN+dJ3uZodSpk1XSkr8VJjJD6cRPqKjOaRxQRWWg5Nqihrvh2heIhP4im26AiMKCIxR5HalC8VDvjvRObhCCpSwmZzFksCs6SiR0NEQmlBJhl8UFiJCV7p32c0HzX3u2gPAaZp0m6uu/ONRaZPpi2uJ9kbhpgZ4z0NAE0CiZ1YJXzLNeluqK6CQWBqCqSeBzhffgf+fcN51ObP+5OIc4gPeYgVFP/2EzCvS0wVLork6t/iszTBl0BcXgthgkLa7TOOBS/5lBrmts1xwmvufPyeLhQdxc6VXlsC4FNJNvS29YBTRkZUwRQkdeWDoBfs8PGinFUleb0+Kc6nC/RZ2Yw3pXTxWyqby3nkhnASvClsZfupS9eDHxH8CbFO+mNFyiuX6G737BjNKKPrTFkzVxNkS3OR08horNUthH2oYASs76875vIhXRm6hMKeWBx7vE8COCTUTBJMJ1WybJxtBIH858bXW3jDzKI3fCBqHSyAyKdEKBDkCeiffDglshPZkolN+dF3jW/jApDWrd4OxapK+/kCR/4nJKy/kh8TVwX2Bg5Bfji80RCON5YzaLj2MVFSvv6eD9gXFzaPHvtoKzXHTxnyOGfLw4s11HsZk+gnohxa0JmnPqrt4vFG5pey4ZVb54Yfm9cOb/rL/Ef03fyYR8paZWrhg3sjzrvv91NchsiDHg8s3jdN7cPSKXBGf3DZqf5kSkQxbc2wksAQsaasnj4lFYpaDsaxdQlkyoCcJo6Te08nNGrkR7Ri70C/ha74Z2xmkKFXe+3fiVn5/bUSBM338wKYmkbgLH4E3cg3jkWMrqget6dh64LPXSzpMUTwoZ5dE1HqJqNmQA/EVAc0+jbiSdqMaIpsh8gTR1fNjPpQxkSlF5V3hZ1KGaZuLlIX9Gp5Je6dZP++wBcGeFN/QBsKo4QB2wU7deK5JANUr2dX5g1o5arpR6oukIpPX/QBTmKfHwwaYQkzMEazJAMrrx8gXg9QLpSVWAJz9kFjTOBoQO2kTPgiftXP+AOuGIz/+cwXeSuaHCpboGvCrOZGUW0F4Ivd6s1NYbSJtRGmYzPPvSFRssT5ZQxclsXk6uL7GKCMG7Zz8rmeQZhw1yUD6xI2Mpi5i8Gh6cHuJV5XbRXJyA4/934bU7zkHKthJo/aD1AEXUj2UihLmsGyFHoy7nWFq3pQZJ0yY9tqvn9bqLQz2NJQ2av0iqpHZxSNtm0a4K8MmNrVtOVi2iyEtRpOIwv7ciYlloXGsTtMLCuGpa4JX9p+shDoKCzDBtUO7Wi1o3pu3qW+l6mEY29EBKBGsPja62Wag/w+JxELW1LK+TAlqKolf6i21cvEqtR2rINMT5nKvz9FlqoMOv8hIte7YAXE6cvZgzizCLAvtWa+jyb43mfx17lJiFYyUFtuPwhe50FYe17LjFEKF8tzhwlEeP9RlUixFLIpWnEJH6Dm9Xe6XPtAl1TUQ48yC4Iq5gwNhPjQ2H5D/F7HvW3RTP0haWNJ15nVXlW/EKsRplnjmRiOOO03S7VvKoN0CL41ATZRXgoe9FaVXaIIn+vbTLHvOca4kWUCG7f04PfIZoOrFS4+jjinhFCZE25/tYZaJWpNwIjFBXbRDKyjrq+cak0Bs1o5H/SOTDtOpmwGHppg+AgoSBVNwUTeCITgp/xYnogMhAMrtJ6uNxZizijIDwIBx1GDfF7q/bwHNRjPbd7qk09Pe;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.4;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;MIIFgTANBgtghkgBhvprUAcBBAOCBW4AMIIFaQOCBSEANDsbVYnhZZ97Q+EXQPchUCvxBuhIGGGKLQHRWc563bUzkkGPv2xsPOMCQfsayxehaG1QJ/MyvZVZQaVYdWO2XgV/REB2LK3HJB6ZcSIQUa671gYQ8QxyqRZkbnZnGM1cvyYfXg60er6xibyPA59kz8v05YCi7iRjPZZeyuRpuHLW5HKrY3Vr0LIuWKhC3/mABtE4F3Fy7vgsBwZMvKH9UccH1sgtgz7rQvBtLnbTvK2SEA9i/c+9bVdvj3TLfU6gcm3l3N85lfmNS7/vzFMHn7Dt2DvfPhGtAjlOA/A5eZVTV/D98snqPFLnQ8kj8RfIWTyaDbuW0rt3MDs+drhmfzuT6rEIKAzFEqh5Qph0L+EC69eCOMjS61z2/erdea1tcAbIcVfGyMmV4CL6CHo6E/xAQ3OdhIWMW6m7AfTtX5Vfav7r7eAdBfp0oHEzcaZtjjxDcBd4951LBAMj2B6xgbc8l35F8Gecxy6P23LnO7Rm8q+Sm4gLAVc8DZ6wRqRsYrkNZNrZXLbrOLlLSQcPQKEE1pXrvmJ8WNVfhJDBn9JUaxYyHrfsrAEbC5IHz3UJ6gaQaCPcJ7b6ivnKsSpMMuVahDEQxnfRR7RmuqrAHnrenGEeIDWMS1A4Fup6n8x+bLpVfK9GCPqAk+WfooqhkPaNip3HzIUklH/ml2/f9KH6BLbs5uO4os8UaIa4AAJSk05pQOex0sMWNCXoBxpJ5IEBRI8BVao6nza712TduTqgzkKgdxWQF7+ow1oOe62zyX8vVTJEkzQWiPhaZ09m5bfU16oLlpYeEDirjU9UlGSc+2fLB1pVtxl6UWjZ76MsPT8nE7OKrZi8WuO3uT74oBEnm86+DiH3afPDbWVDvm92ewcNL8cPBXRusQAuECS7j9XSwlay6LKwA/EmXJDx7RquJYWxd+TSf6i5EHIpVcAHT1Vnfxr9SRR36Svlwcvxh7xfRphFakp0pHBN6scLFyAZO9QarYNVfH7rinegXg2sDEgOzMq+6I3bw2A45Zp1Hmj/qsO1WCQlZLQz2McIWs+zDm3XJbHgYX9jHHJklZZflnJ56816okL+FsMoERJtCXYTfaDQI+0qhus6IneBJNE8ZlEoqCHM7kK8mk6d7erXU6r9ELG4QStpt7XNG2vfGGTq5YwfJDlPFKS4eKyrLTCFrv4FVAMMCrFRe5+fGWlzjd7t349agisaHDD2avTSe8gdpr0OIxJX9rD490YpkTjVGGF+tYrOOdluaY/Bv+rRZbx2VN442hQ3/ZjkZDq1EOgJsbCtT91bfwJrKpQtKuc08kAmAOYz9b5ODquxddB4t1X8kp/d/SC2nTDYh85SM6jOnzotzsGeXota+B4b0dOkkbI2LLVl+lAAqMRvLYb27VpU/sYzV9BO3zUAeVOcHlrKTnAvhi5rRzdhbJKn6KcaMZOi1zrYJQTPQenibI/EJwwIj252UBhAmkDHvTtHwN+4Cvvi9Gsnzp3OtG4MSQxB9QDm1PHqOWIAgrzu+fTzWody8CIi00HVxvODPmQLt2DRZCfuKBLvYssUJkTf5GZ1e+AKcy7tHgsaXfKyxTUsc+zrbo0oTcfo9sf4GVU6/F+92SCKKzSMJ/Zsro4qeXul7VQFhTPBECAcsDHcRd12GUIBOP4P0E8XDxXjn1dxt/DSbi+enYh3DBlquznRzkAG5iihIFqY/sXRX/0P8bHCbhGi8ReGwiDJoNLTf2oUHkUgn2w+qfkTjirfW4XrpQNCAAS/+vNJfxcQcTAIOqjD97pVp3NWezFNvu/H1rkHWCw++yF1Pb+1cemCHaAitUs8kKdGxSpHtszb52+tbMutVC6t;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.5;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;MIIFgTANBgtghkgBhvprUAcBBQOCBW4AMIIFaQOCBSEAGvBwbK0MSVs0qgx6h+ZgDCzulwMx/1ZmVfY3yAD7ZkOBBahwHMf2cxs+dDuS3+Pd82z9ZQtlFtccVoBb3Bapn021IRXXYK0HynFmKBTPKsFEQKOvGaBX7i7il7I4+ICamnvnNDCwr94H8uYQdL/wPNrAfrnDMAh4KnBZLGXS8tEz5MdmcyV2J52M01Vkf5oQlPPwHwCNw1VzHaNnld970I//LGD/N7yyaKxSJsZV+yDsGItYTXhDe6IXuaxwlA5kFz/e2bnl3SrlZBCnjUNhdEPUyPLA0X1y0iCw5n8puYJKEVBz9o8uTRL8D1Wj0BAarSW13DPB4qFbQ0cOnTNPJJbLq3BmJTQepYKxacClztCsMBnvDQkF5XE/e3+IfqJ6KpMO7LJFgQmmzRt9QCPVqMXG3VQ/xv9cr/9Oh9kJ0i0BSJhdStOr9PLOSxP2fNP9YlIArkDD2M7+1BOq21uRUUZhFm3FRpDFC1XVpQ0o4xRhw5Plb2XektMQur+Ct10oLtcgw7Z0PHxx1HUoovadjSTgs+TDZcPAW6WobicTGVf6YHFMFXvswC9rLPqDEorNWlnbuvk2S5TSiWDmG2wBJ8JIz8giPWFCQ0m7/5xTcFVqUKQYYXb8NXB16//asyHEnLUO3tNkKGfj4igJOoHq9u9MNXmWjeaQ2VtOyOTxaIO1hn+FW1EajtTFQ57no2LNkmeTJYgpTI7XRydUx4bza2/RkV/vS5bg7tV9f+k7/v6pYoZBkJrhrbzW7JH9nH4I3RPwtz4P6k1JLLQXlVu+XCxPR7Yf5CBank/eXPYSj1Z9qQtTvZH5yTVm9E1hAXn4Sha2cf4km6B73z1GhaawovmS9DXkCEb2fS0R/ibkrdwizDTtuIBmNVELy+EfNy6l8qDQedLgOAa4whgxXzUTNGTPtld8vnFttSuiUuSuZMHRgHuf6cUWgVHHqq0fWzAIzhnmIwMBTPn6z1AMC1IEl9m5BwieJDV/VfsXwcAXSZ0pWjQVUCF7Bs90RGbQphMZkiP9aswMoFQezO+loHa/KLGgPvlZKHFu3Hmd4H1DXWLizgTk7XDpdTHTk2vufyBo0NP08vqQGfw0P5nLRMu0F+r60oMU6gAsMND70d8Qrkap2TgApi/uCS951qepKp4Eav6nljJ+aoIpsAuL8BFN6e7s7gm/WbthdB3NImqIycxw1zWt2C6s3vILRGSve43wKnIxw0LHXnu5+ipJCUUPDvbMnEA0hOkfrj/C1oLneYMCHq8BTnNq0JBIgsDEFd/kBApEc4stif7U19VRqh+ujkkp1VUdxGld7HEodztyexD4740ISjYGXywJPutRjdQJ40bJzCDs44BWPRSMT7ZoJYEPJk82Iod+oWFkq5AXOF13y8cN5ikoKf+SE2UVRSwJoh8pZHoVqi4CJyews2Yxzq0DHGXVqvWplyyjYrj+2Xf8kH1Y8TqG2HmHONgpAwr3/EjY8wsage1MCFGuK8l/3GvqQ7mNm+TuQYXfMH9ykKxxDFNX6EI68FwH7WEkU4lqj81sGyvhxpX9NQKqwA2FRthRPNZa5K18uVxsdbDRHkBr+qWewJMB3gugOafRODI/hqLgaaoah1ErmRQuUiEhW0SaNTe28uqW9eyZj8BrH4zj1Cl9ibGE/fVI0JXYwISNEd8ai7ROreUMYsBpbp6eeSVZiHDdhBpDkHACdOztMQCNuz9sSn/2d8/obnX+C7TXCXnunlLTEFTEMMFGhZJK0gNCAAQQ8qZknJXHeaxivHGfGFRjYYXt38yF25NnaQtLxAPGNQIvBcKrxWDa+qX4K34G9aEXx3XHVCVbYdaWpjV1bWr1;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.6;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.7;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.8;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.9;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.10;MIINNQOCDO4A2Gch447F+9CxzW/MRDNxGhxIdljJjRLBcuxgsnDXEalATykoKRDLPSP1OIgE/KweK1ucID5cJ60+wTNSdFjr9RXGDfZhH5CY5R6gxYO1H5BnDoN51EP5cYbvzpmZGEXGm2lVgIZz+ZhQsSDfNuMdbHb13yNZP41RTxIPTj/rLz7ZSwfjjnPO6wRFCxWKhj01g2ptyHTX9VvKIWttLHOhVk1p+CSvRFizqjHLD79Cqhw1TQwilGS3rt3ksR32ICRzbTG2KIzvqBsl/K02jyDHWQxnV+FwDbXDpEOuiKWIGZTA/uEtuDtzzFIrcPKHUBwDjIRv//eG6qqf5hUmL3O0rL2y2IKBr7WJYIhpeIJkK5yi+BJfrIAAN3FZQvji1MCZDybbNhvYmnL96LB6ZqVHEyHcTCz/Z2yanL/p60M7GCzVsGPR/gwYGhXS8dNhWPqOqxdq0qTtE3asQzbZv42n9x3VXpjkbRMcp2GRUlHHC7U3As01QCFOv6voE9hXxlNNVcOpn4TkwzXHl0ZJD7hpZv/pIHbQe6zEM8NMzqTMltVeEc/16Sh0dIvi/ryCgZikeqxYP9RZjzLG6nvRr6A4G17hAA/5q2VjKATpg7ArP8iRazHJtDwksMwj0SsQqMWn0eXAJe2lJ2vGbPVGYczbKZiQKBv32Z89PyW6nsScoSPEbPw5SwMw/V21zIcS3KqpYo0ThcmY9ALa3BNk3R/rZ7wVPrvvBqpsXNpRzrOtOYAX4pHrXUnRAjZr9hiAiIfI4hIP4k+/DpHFeKYH73z2o8cDJuzbxJEGkiXt+4E+9GGDuoKRulp2rZhbQ+yMx2OK8RfONhRB+8gMTnKo9K4gby9LqSEuUg/IjPTP2wKcyNQLYVrW2Nf10U1o/D3zM7n+6u/BkVw+zkVlE/29AVLLCmQ8poNRCDvjAKLi5XCXi2clV5fURaeAQ+PTIRMrocBpEqDvRDNjhDF2dTlpc+H2Jjy79qC371ZNKvIgD3cW2MuDU3Amc5zmp6AgmCW5q3ylIeK14JvWFQbPxOoILt9/nSmWNeQcJFXiY7vtOtOUvU5rKuxdO9rSyXPvOLgNrpMbXYrow48/bWgxjwAtTf6J/pGBvw3uF0LApbCd+DVbNZcHWEdlaEtavsfU5AMNjgXR5SsxvkxsiT0/2LYBSJQNIKI7gTmiLCFsJwSNg91l+QLeRtfLTlXMElJEQqohvOKgjJQj91WlDHnsqaJahL5XFcqDq0t0HsvRTVK9gtrpgAFTGaAb3vNf83b9M9noYeEybvsq8/fUoKmmSW/jumxFxa4FbX+urifvRkRd6hILhQCZg8Kd1NtbVaMOR4Es0TPdS33stpQG90vteR/scFdIFcXAwltwIeUo91hYwqSqiwNGVjBeIPsyldMT7erKF5zdCguSv35crnfYvuFmo3RAjqAwFDKUoCRqBb+pmteTiDWH3R9TXX4tby4IaiWWu9n/pbaKMerTYEa5ULDEWddWgTpKO5BGMrDyy/ocf2khuJ/YN6oDhBFgqOXOpQmbidsf76O2AWPHacqKh0by1S7GRfKrgPEMFeryxqY6ui5hOpGoTfzM+omvmKD90oUI4zPz6mb2gfKK9dCJKvWbvG4m4bmFao9THUy+UuI+Ly8f23pofXqZdjySlYb7h30i76NVEXvXwG9j6GPl/hjuZT2Rj55eN5bxcQBaF8XpIpRCe5IIfZgcWm2PdXPkh3/glhz72nTkQowvq55A+Qhmf6GIb7R8qi8cEwW+9R5fIc2l7AFW/AVJ/OnLyPHwoZ+SdSuZWHyYeOKUkUGiEVBIfby/6vKB8lv3NSk+M6M6b7wu18QVoLTHfJ6/H13bkXsuFud0EADmq36gGnAgo922yEOwORxruG+rAZvW31gzqwARIH2LA+Ckgo1op3AO34cxvq2X9XB/ksoJvMm0AyMjyfgoiHML+1PwXVJDAHpI0vdyXbvXw5z5gM2fbdOuiKZNnCdNP0zZvBBBr4RRo3zA8HyyNV18dQYU3PPvWXeZzB56Kvz1o1fh3E35bT56GyPeWsVbf9HYGK7mz0Hc3vzGT6tMjPWPYy4VM3k6l7dHUR5M4lM1pr5O0OD4UH16ilAHhSXroMNdJq0QdyQINH09auV2o8Ka7uZTWE+p3CrzdPevT8MSrn+/6gL/SlLA4V6nmEa0hUkArdEF8xGtOAGWf6VwOG/cYmwL+pJBdfVTV5Vx2YtGnL1/3Hn3czORB4HED+tJopNLWBZLgWx2CpUBp88r2AmVzVuzZ4s5GvDxQYy+c3QHJs+VXKdsclcpUpteSZHQels1PyAb7nvPuRHOoHAVTxlPzz59S3duuDMbe+IdydaO77ZqnwgIFAXJrQZwuaebQDjGGNaK6V+L6fn0l+8eY3T+qOoxqPUU+w5Gl2V1YAx524d/B5USoZx/MUnpV8X+EKYQHl2Gq5HqIjWWjvDNzZ3UhvS4lBcMtQxA0ouzYTSndwd7G5D3qJTJOVnnvb2kaCW4WHLxcns1Pc01PhpLwfVIsu7E9UtEJpdk1Ol5Km90TMGGXkmB+2K97LxpnFNApf1t6frC+EngbEkJ0w48GcBY1CmKzzjKy7NJRbetYZJFj+we6NWR67PiHfaYEIszDiN97LI3h+3QhaBi36YJjIF0+5g1Qh5JbVv3665lzBrqk/K5dBET4DMBv7uha0FKxyd6r2NHA6aeAxZWSvO900pir2a7wIC2dv1brEF7ak7bA6tCvJViqbaJv1Bf5DBOs0wWAm1kond5PGJ2FOhi35FS+MR5BSn0ag0XfEb9kSStdh6KGb+IzW5o/3ZhBBQdfG7ynWmC2U2Ydww5/gOPpzxin3eEVOyXylQ2GA68BzMucldZ/EU0Uth32YbCuGJDifBdAZFfIvVhOwrDbpOH35gRWADGf1bagFr9plXBSorvW7SshcDEQr5pZ9RAeUlQ98iH07Flkvfq5ax8YuXSHSZD04XSNd4FqhVNrGKfQpuxd80SA8ZZDddVFALXkTSsjjubOpYD8LsE88zQ3y2Lvw3/DAoCUrzKuTHhXctM0m8pw7i/4MF+9YJPslCNlYw4LSJGXUKUfE6AvzEdQ36hsbUDrKxV3QCghzCu5nfNVBg4/r2OdwDzlnoLoNeoXHE9QaNfCLgoM5N6UIRAMPwxoVwHUbkg+BnvvVOOO/EU0aVZ3HE9qB2Vk/ZcOZZJQhM8kiHriaLKCZBTC2fXYcQAJRPWtB6gFdbVszRW/mLVYF92YO/pVGTA3kgnd28H6lvSN52nLMultejOdeJrzGItBrFkw8XvSFceqwK5zS2Z8xLvEZ3Ec1iq2dv9cBgOQUeUOK3lvxpP1EQed2JTCdVWtYzT0gvP1aFIpLv8Y0fRP0nzxe29raK9wVOlIHe8ZvOfTO0QGLSYWo01zxrMGchBCuUbNBL0hnh9u72yiSQoZq7Py5v5/6phj3uO/MBf+dE03a9f9qG9SX4eQhEn7VgAFalfHQWqb6e7U8f8d6SNxzj5z46VZjfsse4tkkFCDW0Gg+puzNiFZqU+pnxGnJzBmxP6YBtOw9zaDv3+JnPX8WA2sIEQk6bqhWaLyeUBiOgf8GddzycU150619AYWOmrquf667Ov8ALBWZB/WUkc2Lm7aFWNK3pRsJZ+WtV6BWozUOyXPu01euRitrFZZ9KYcYV471jFUpXPfa2SKyPASM/aCYVVFkjI3f37T1a1OTESfMhuvKnpxfwDB26TMimPA03eEYHHbEaDWsgnSzhMIdoThBmtc5imYkbJmCCWD7oFM2FteOl5sh/cxSphmDufutjYooqhXeNa6T8/vC7buVfCmRgJpwBlbB0pIr03A29K0yykvMQyVA7gjZ8s7k3Hh9TmyfS7yhyqGzprTTH1YLZrSpEKtIGFG0O5STEKNPehauE/qVgNxeasakrScbR79ISEa0PpdWPzXVXxbZ5+7I5Xk7L7CAbgYLP+tOmz8Hva2bzyllzo43CMA4/kO/b7zrlogfk01bx6lm8y9EFo5m6YP1jqkgXkQTAxrBEtoFvx+CED9N6EUJQ9KU2haJSFNSQUfIbI2C3HHZfb7ylP5z/U/FZerXHTPyuCOTOpQzFBorXNtqoTz07mkiXc6MrirThH8+bhCRwhpxYID52p0pF6znfOLEKCe/TiZGAivgUnau1L+vcSsnOElEEuG/FaFcWI39l5AUmOpomG5idfstygxgBYurstnQ8KU74c1ShLuAmWxaJoaVsYKNGG+VrI3ETj6lJAIJrnsL7D+sPHVUskuWNLFDmSgFz01k9nF72b6iOLGnTQ/6P3Q6lGHBsFkAnSX6Oxj2jxkYG90aKqG7M2d6MxNmaGoK3w82Fqe/pcZ4OTuvAIHS1Cmp63xt8vOHCYoNXzAAAAAAAAAAAAAAAAAAAAAAAAAwsPFR4lA0EALpHWPDRwpqXmishal2WHlqNxcBnYSoROo4zdHVEjuw4GY3ViMEgiB6na8SjRqn/0tRFAusZwgKU04XW0Q9dTBQ==;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.11;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.12;MIISgQOCEhQAelzU9GZNkQjYVoa5gNdRqLbDGQ2V9qR2clZLPWBTy0E9mEPXLIUXgSVTpFrhry+U0s8W+w4o0wqHFpa3T4AGlsJF2B3WZQrZ/So6M+3T+zxN6MKndUCk3PQ6hd6/nInFtqX9rm6DVtfXpW3fBvhSAt7sj2d4Lvk1TqW+L73juxmlTo/9f5Uf8IxcTAmlAfajkuZwj65eF+DaHaq9vFUO5IWETUXw7BMU+WJ24bNpEGyktjeHUajS6zdATtNDQkGFcpPws5ygkVO0rguFSdqbieFh3imGz6oinyCDp6j3zLIwdKDJdfxf3Fd1ItsGemrBrzEh/e4qeYtQYhRTNJVhWtPUNAJdPgOxIFzN/E9ut//DW4ZsHMmVnwFYd+zYvfgDGA7aY3wrkiGG2WucTlhfxUGwp8JvZN9Mw1sk8D69OAemnsx3zsLFFRGFfrKgTTHSOq3uuSJplowiqBUdud08Xchhax8Bcd1RYWOLzK5CIDuWidAU1RjSrrnm5mN8deTLYvd/ilVpSgnRO6sIcnBSM2sJsIYUbNn+B3QoUQTWWjxlum0gJ3zwYTLlnkdbVsJlsyrW1esi6rpiornSieRgqfSkFC2FIq7vpfOVAPPjS66BoIZidSdelyHBHnQ6UHc8H3dDXwWL/Qs5LMFHDxjJ5TLV/5EAzMTjNLQTYhKyuUZyUiQkY75ECkruVL1ATLAcfXhBrzX9oNYd7+iwrpsh1JmwFe9+/MP4ZK5A6vfn4ISOTPJX0SjIPLjGleyLaxjtAVvpFAOvM7gOPHqOUaQpabCXO5rIivGaxguWu4MrYm8gq+xFN8W4id+1wlYaN0qimAKlluB6JS5tugU6pPUnvy1D9WSHR+bmoqQJWnWei5Lta1b25TURm3EZU6FihaoHR4tL7j1JK+zugayr0hX/qQ2NFwXiyvwGVFlvOSlzmyr4m1wns6e8ZsyMDzXC1A/C7EiZecOB+PbWVdAIwsKU71ZIsaKBgrm0bajuW5N2WWEhYvgmfZSHNNz205v/4QhE5F1SMBmHnZhRH92n95n8TLd0/eAkXqxFAISf8YZjlErN/ZgwNA7HeTC1Cl+ob7TQ6zOSFRbCSBGIrJHslaXGGY4ISn7LVn7mToAcRStRwoVhthbtwVVuJJz3uiXEHc6/LKGWBZa3huVx98t5EDr5SXOF1cu5GD0zN0cie7fUu3H3yo//V3nfEjh8nyyEB4NwYyplsWrcWy86kliVL0V6D2IIOoVE9iRKZtHPdoJzpsiP3Vk3Ih06wIWD55srNoTwddoKmdpyuRzyjiEQLQOHCqH3SqsYGpqxEZsPkaB+eLoSG+r5tDAVdHoIa6LNcHIly9XwqfQXXfCUwN34EyP0GZiUkRANDAecqOICUBGYSlB0e2GybNtejt7wk9tVLOhZsvX70NefyVrlRAIjOlGyqhU2kgQ+HisCo66ofKmkrLZI6YnPGNlIi6kFfh2tx/HbDgNRCHphvNrQ2ocF4zkQfsd6+yYVVbXLJZvbLjQpRAnCYewL78ZOQVhaupAQ2W6tp6UTRP0LEnk3Wh226wFpiArDa1AApmB7mAH+yjxPCPkJvXoR9rwGsfxqE2demZVblRqoKUzgxjPAxbvjWtZt+zTSEdJ8FD0BFkR6OzjdsC9a/8mQeP/hxNTevLGSiKUQmGd3mUFqjulp0PZ7SJBXrrR7K3aDUCqXWhBxZIt4HMeO8m2Y0k5pHDPBHV2k+UKdInl3hXZuHwLfjA7BIaoWqpXwTw6LkikvP8s4mSNTwHoNlSwFSqF99qIw3Gtx9mNoCGZUtWyYUHkCyJ6fQTvJpVYqLNmL0Da9HGXrKu6vsGTlBV+neBRtkMoFUVP62B5N9mMsRBZzFStq1LGQWvRze1IQTg4d+A3WzCZmCUoIew8PDDGakzw0SRxjBmfJMAcQbr4+MZpF14W8z0YVqy6sVGzRG0ic+J+kxxKby2y9LUGtTBjss3+j8Xm1I3X4bKNpz8u5mKvGLw8I0DPXpw5rBrYR02zTh7GFA619BrTYKGD8ZbuarZlVhnJjtr5Krz4WisyvtxB5Z6lGjXg+1aU9nf7yyRSEpCcGXvJbX53aoYng7cj6c7bK9jp4ur8Mp5vl9kBJu2SMMof+6Rgi0wJn1+DCamSdfaWzYVprsdeDvjWSDKu/OKa5zchPtzNhwtCqgXEftGBnLeTJGYQg27v40feaBqYinFHmIRP+oxWiRiAggR9tP95Gku9kcu0NzxqNR7h152VMPgKhnQsD8/Sfyd2+dQJG8c5KV4F3K73nFp9tYolvZKP4SX+XZtnt3JpB6b8flNNs1t32fDBSHXuTnGRsB6kjMylYqk76gioBZoYoJ626vv3ImM0d3YCE+WfUSAWc0tJxah5nGDo0waB0DUMWHuLl3q4Fmyq35/UhkGdqW367nFzXeklhWPS1yM+B6MGoiv5EHj6KwN1qeetlGKOCXYjaIYAZ769loolzR/ec8lo8nm6hT0Uwn8xZ0+Hw9+at2ErA/44Y+fOSCvX6qbEb8Hr71E9HaFPDCu3u9NszGdjsqtP4Z62q/mk6tXnoZbpeZjdOzewVe4wedQir7eLGUU19kueChPKRVvNWjtcUDHLKn4ZkHYnr5HMqC+YmfEoZ40S83o8ZyR1bZDTYMlViRtAX9qukQDQSzj5oWABk+1NtjMnmWR905zaeSRkSDf2ilsgT/LhHl2D2B8B33Mir1aTaxAfk6CozH2cnH5j4PSrUmQtwc5eHTxW9fADxU0weJ/q13hl+vKay9feHCsXyAY0h5/WCFbMI0atvhkLWdvhsLpL9ZlRdw4OM1P0wMymWwZraNAqEU2kUeRbX5gqwN8i1ikUiEQQh2T1uu4KERyklQX7DdfH06hYfwV0oQclC08hcea8p8+HukqYNcmqFqGRB5jUtABrZfS+zco8IaHecRIDHcoLkwdihVen4bYIJ23om7mDzUylw1q2j8eIa6Kf69j6gySHUZevI+koVzlnVx72rpv4xVy0arIjiSrutuYM9RP4laP/xJhjl+GknIbsXTiyQqFPhZFO5rIc5RSG21vondDadbS/WrOc83Sg3WUlflSCvU0Ma6nNE1LBPuPgiWuxpvbBb0dnU0y03dlJaTRvtMMwLlIqrMe3Oo1iKBJuY/3p50yG2laMEuLUufgdcMa+iv9btmO0RHm8S6/JmpZemE85n+HF6p4E9x3nDBVQZj6zcIyyZ1BXxT0LGND6rtg85RDGfBQLWoKFe5IUZvz+/va8hO75ruf0aM5JZio7UVk+ALOb4mEPImfPjYQaju2xIBWcunKZpGvlDrk5ulR3Emq1HPoO/UJy6YbK/UrTnG5gB+92ZqlFXWunbgJVZNPwrRJSKw9strPjfbvGGPcLbnTmWxhGmjkkYRNX7zOPyxQNzXJanDHOvGarFQyCU6TMFegNnFS8mhopg2Ggz1rtjx5ugISlx8QrDkuYhfzctbOcaPqzvw9e4S6WjLNCumQ4KoNTEKLwSlBEr0iYQxAZOktlXYYW/GNP2AFULYsk/XyS1jPfV6Z0eGO2SgIR6R33X0exEQLC2vEcR/CuGjTjDOmKyalFtqPIREZmrJ/7n4lC/I9je3yvwGJ5EyEN3NLttvG9wzKH70vLiD4pLj/M6cYBszIKq7cPsX2WQHbSzEhbpE3Ern9GqcskC2vC9Yzm/u0HU3rhjpiQCA47Q7vJyjPDm+H6QSg4bq4/q+5aLMfulfNXyE3hNJBY690nlCmiJfZk7s4PK0wRzZYNuURhhtvfgasvV3aKiiGBShxxMDS7QktaFt6WmrSDBI1dc/B+io9myxG1o9qFjL91mXJ9Z8vm0LN6o1BnHjp3fpkz7iqXPqTnaZQFIsfmmVPTX/hzJZo2vX3clxWd19o5e86ogEa//V+C5pc6KVwDmTfaxzQq9fMc/koPHlq/7BxlKzMvLlUhksc9omjvJvWE//NDoMzaNO8QRxLd9Oz3zGvxl5nRq1nV68qm5Gd8QR+UXEYPp4cIxyN8jnxXn6UIhpTNHIwwQ2fcDFyKKYBD42tnw515rWOjiKxwoOE2WzYmnX+Y1o0CFV7pbSD8I08ZNnbaUC3hHV6qc8tQ59YLVy0oUybIqCFAjoQgr1Isha2HF2USPjbuZRa5JgsV91vgRP1L8Tpcdh5MpO9dRGyqWGmugwxEuzS3E/2WdGFb8ZK5bHqD2nBnAVNL80CZRk+9nxZNKABO77VXOWJifX0Gv1H31nUwGLDRoZkaKPDwW9D/BFnCnueGJHNjlZbRLgqJla0Y3oxmoYaANrt+Rq42tJF8Zx61eGFOZ8+0uli4uFJc5tOeJeSa3FwFyqbx758V8ez4m85ffmAe7QNRDwc4js681Lp+0cZzYg4Xh159OClqeVD/q1oEVy8iWdOIODjh99HZwzA3uBPyiogm+oy51oM/XJIXq4d5tOzIBgL70rg+msp1TmacIKMySfUZQic3yN+HvLAAqxfCx3FLzQr3RNKNI9lcHsT6CrW0Ml+KsUggugBkWz8gaMz10Y3kkjt6zxBsrtyEkT0/lumGv0HU4RpWUqF6+TwuQSQ0hQElDc/2Qfvhl3nufV4yWRgspy0C2JvS1cF7xHGmk6CWmDmbCTQofN9b+TAKSRBPZb5t9O9h2BIfOGgu8egzLd9Pg+e343G7SMtjcePYD2vCtmETc9iED29f9439B0BXP8NTTrEpP9GgALsxy2/aMKec6I9b/TlexA8L7dcKFz/lzEIZI7jerGRxWsC3ssrOLqx2w3UcHnb6/cnkEZBEyThdsQHKhvcaZ7EakxEn81bLucOBQmqXK3rkKwp8TAoTlNDaBP65iwPVNkFXXYZkTYwIVCH1Gi7lIb0jggy51WztMhf09/avaamLT+AVHD4DlBa4KLPZD/+xXF6hXBegI+GBBhc9iz3g14hFQjNqx3rxuw85flKsE5w9DawbNKptWOs4uM7yHfFc41qVWHwUk0j3dE5zo/d3g1xn+cOsI7YPfbrMVm64BhjK7QY68wJed7VQo6i500HiAm5FMNIKyL++JnKft1fUyw6rjhX5C7M7kJo8lyBnBRcanX6MvcX2R0OIZUuyCo7dtFzbbJN9yH2kmtSBNx3N8LyQn9Qw1K57XZM6NVKJisyrYUMNdzYvlfBpNmXZJ1lCefEAW8dJ78cxuZvzkF9xi6T7m3y1ayc/XIfCVrM7wqfazMpOBl28RLOE9oY29iYreMZ0MxConLgdJ1+pkXIOooE3YQ6tOMNQH27rPyB3BkcCDQpFn6hRkl1l1wEF59sKEgxKckMRn9un7LuHt0jDBIUBErDDTj8B2EaZu9gCgNJ1jAB24yiw3HPKz/cqeMaib31wKObdpjz/+TgOjXeCZYc1APu8myd3I9g4cBth01yBvo9KuduwFm9IWcz5Rbz0YD7/6LAohQXAo7Qt8JNjac5KDbhfacVrdF0gjIAH4MaE8SQrUw09+CJapAorIPuvBp7aRGbo27xjkGPIgxupZ6Y+wTm6Q1byWNERUfID2XkY5J4iwZkFyqywEH0bz1+s85NMqlslsdrqxNIVkLIyQIsOkc3Esjo336K93bUKGoREpEK8lRm94k16cL8QIhAE8K3dz6aDXAMmI04wJntbzvwF3ZvLLzUCzt9CLVib0BAF0ihFiMG5pPCI8JsmQdh6qgoROUtFev2oRW8au3TpQLn2F20ETn0QNjTeza5U1CxLA51v/X5oOYwYiA5JuME7nKrIoxbiC6EobWVtmgv8VNjIAnDWrP8uzPYvaWy400smAyEgk7jsIF3bevCI0+q4/RqvZRU0jW3NI9J6lzEP92Jncoj5ssQtgglw3A7WPVpZF7e56Y/QVdc0tJNKEQPtyaObH96chiF40WUoAqWi94rqYe5mWuJ9rDD/0XmCp069N0iyRcCmgIMdu0rbNRxbRUGgjXQLUlYZE+0C/eMuoWCUK3NJbh3krQRvVEd2yPeU0q1+yr+j3kW9n2M4dvQ7GBJMAUQ8/1ne11vxny8i59M+B086elEt1qIm6b4d57Iftq1cLf0Z6egqfa3UCuQC0WRgcvIq1Z9lOUGd8i7HzHCUnQUpwdoaU2RsngLDFzCZeaXN8tUWP0e44Vl1fc6LfBmNohpCSpM3r+CwwNUSzu93m+QAAAAAAAAAAAAAAAAAAAAAHERcdISgyOwNnADBkAjA4dSkRdVBwnu9b6OPkw1XWKnqNtEjAGgPEPwj2iUnbXuDCBOLqBi/bXJjVHesBYQcCMAR3wHlTJMSz5QWOf1bVY+u5pcYzaXjIrP2Ts7/C/1Pp155omHvfQsLo5gtJAjnpaA==;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.13;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.14;MIIC4AOCApMAOb8CwM0dj04gNLUnGuk3oaFEaqyFL/V8/bjtvl871IOn9M3ZUC4gFD1RXrEfKQHCZ9H9BpEAo15uc7787daDaNFwmcy6ZWDyr0UyFPjk12sUFYtVYWdYx1Vm6IVyMtihTGu7L6VO8KerqknuHwh86xaaQ84msJtl9dL6EszDwCzHb02VcfAJlK6WdLNadGlcuW6mZP8Amxlvw6kVE+gctYQ2LW6m9oFDYypsTZ+4fXQ5QkJnVPR69T/U6qTMO63SYZAWLzB8VRSDVxjHq0lFG3W2RCFa9F20f2UPJvgnLMuTdo4KB8q5wzh4JiLvPi2iS8VGjRaAg2iOdu1ch5MaRilJ5CHoCxj3p4+yLp5KFYlS9wVpCWmyv3UTdCydeNwH4Y83BBZU6nJPqgqILPcckeqGStg898ulbXDcInXaw11hblsl2fdLKQfiEXhIMRQOGXgm6I2vEnvVLRYyimE2jCIXte4bLBkM9apL7Cyqp7LdiXnZDMpai+lXbL6mAb7jrZzuGzSpuNgWFcnCr7RyyJSiXl9xB6kw2YoLmbCFv8lu19R97/KV/vL2aAuD5qmuOuUnZeTdQz6ea721+/P+XcRc6aq+DRE/1xWIeRC75FI0Jw4+DF2XhV+iZYYLaXjY25VWoJC2mIXTc8ywJxkdu4DOwVDNHOoyoODRvMvBE8TJ4FTTFt1+XSTZQlEMWySdM/Qo5cHFfhBWse/MdiGTA+3XixMZrmPqwOykrTdP0p7kkJn2Hl5nGqaawr5tdWwKi+9C9SkGYUOg4znI/RHRoGvqsilsMN9LrdFeGlBIKc3kqb6/KSnKONZ/p4lFdDFtLIF5hKZOBMIwKyhZPaojZusDs7hMatwV7tKE7hxlKjNYgANHADBEAiBepLU0+LY209pkZ3Elhooy8ZGMpOG81rrA0tVNLbYfXgIgKaVssE8WlPuYwOK5XndNhdmtPAOyHC0uIgWdT5a5MFc=;MIID4jANBgtghkgBhvprUAcBDgOCA88AMIIDygOCA4IACStSCSl6kuOyNQAVbMiTHz5opPmKMbx02rDEDZqeuq5GgcM6q+jL94wFcnxB8bb4mMMgGKNJgmUUb9XrIQNdAA/wHkvOST4yUvF4XNXfsDQDo55ojgHtvHEmg0hRxMmYLYeKuqxB51rvKxqsm5rrK7x6wr0IMc2MmzYFJT6en20Ni9UmqPkBsAZYMC0JUU6SSw3gm4UeB+rTZAUmWeJEEYi8eH44xD0GIFtp3pME0gFzyYnxNotfiQKyQlIFgFREltJzXvRSTjVDkZLrLtA+UVVN3xw468dbV9QwKDVg5KHPXISNYKXZEQXlwPKPafkaNedpbeAcWN5CWLdSB1/1M4PV0yZkJVgLnqm4LzEnNzAd5Buqp4WeW6qyhRnooQyDgjROp7yrrqXJqiaVgFFaitTqKmWnVpAqwyVmLzEm3KKIrH4zWkCmHFRgbA3kOEfLGk4ZbUkBBXoaGSMhtxTOqG3oOpJum6UiBNko3N9OvWNWgmbAbW7sgqCXeisYUKv5rCSxRHNRLxFYbjZlhecT2rsh0PIq6YQvwUVYFe2mUH06hA4FRl/IckmSlxsqFIT0hCMuLJzYCGSMHVx5KvO2Sva1IltJD1t8ggVfCtTjJ0str3rkRJFpGcxp9gpzE05JwIpb8na+O0Cxn0dkWE4kQUL3QSQKkOwlMrUaffXuhYe/FKVQT673u1anGdosN7WFDqDK4E8/8KJKr9jzjKDy83QVe6QSDpf7A9p93tO5cMuGpEIhNPmHUXJgvMR+mDlEacMJIU8/dWA/ZLgT2AQ15DMd2ugxTh3yQITgvYkvtYLKaFPFJ7DCZbdcdJ5ksOvKnpSKZ2EQ7gnyEUhh4SVoIa5iG1Z2ZiDYqgxK/62y+ZdqkJxvcnxlcll1Jd1f+iagJrzESdiGqCwySaQDjKn1vvCxBWbN8UKiNuRw6+hciafi4445C0yec7sXmDzKSlHpiZNh2dSLaywBXniwyiWsuAIkvDV02D5VFpFqTmcdaMjh5XtqNVm4jlTbIlWM7NyEF03/Wh0GVsULRyYEWPqE3mABYf4J2kaScU6PQpbRy5+lrcMtaomJwUu7I2pKYFyqIAKEvbKdqFACVC5cqtyDA6nVKPXu8wrD2SaWs0ieQRsgqUvWo8uiv+2oxtqms1J6ICv6w6VQAejLl9k4jATMgKruPQ9EfISY74WUTLYxlWkeA0IABGLrUG5JrHphr6K6bcNhWrkBAWUn9lttI/l1RZwPnLMt4QSkGtHxpAhKig1xAkJy7STIv1UaX31ohwuCXSJHso8=;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.15;MIIC1wOCAooAORs72o0uJy0l8Sy1fKR3oy2fva4GWZ5r0nQ5hunlXVCZUUTQHVN9Y72D96B8fWb2zUaBeimlvYPbO7gW/fLHcJiHGertSoeVmGegeLc2M01iCCuh8fthVrmOt7ex4ppRNiAJqnRR8/Mbs6lqWFFdOh37kUdovIVJNvbUad4UptXooAl+f7iBGzlsjLRz2Y6nUEBXbxfDLnDJVqKz7VaDYNw02bq+UPJ88a9Bq4IhJFqDXKrPTyNUokNIJEXt3Mq5yeKR5iobCSpaqUa+iprbgCI/CkXfWTTRfGjGhmTl61vbjnPlYWtkZM/xy40rTS0vFM/nsHpMf3NBbG3rcjftvjHbGBb5wVQ4n6ZRFb7F+mtyJNay144jGEsSrYYvH+CaqdQkUlqYQZb9dr5PjbEZi+1nX+g2+HRqIP7H8n5p4pfISeXwAhnsbtLpXk4RxKdwPh/J5g+JIkejDwqgP3HZlBKsx+njTpUpNsFKOPVSC7MxXgl0V1Q1jDtpac88S2T1EIQPB03QgFck2gomElK4xrdTD1VJD4+71kxJRX2TplmN4ff7SPeC5TVoESOFjfv2YV1afhZ5JMRGmcW+z5spnGyVLmcueyJX5eY1x70l118fA4L0o3fnIs26ieFfvDTen4i30u9wXzUtYmD1OhWzW8F6uk4bGZBCspBbRqH5+Fi8XajGGXVmqTN+KhJ689onJMJdnRVDOYaOXW0IzW4lH6zWpW4eGSnP5GFsX+kdVKTEcpPH77uQLjxpiIReUN2BXcTBFqaLBx2RnFSpuGJUFu/e6qnO8a1+rXqs+1sGYpccuIAoHbjU0yHEhKWIi7WvU5ES13lC3+W14krgJtFMwDJwYcdycAptngNHADBEAiBdyEWNfhlfF9JCKvsFRuY4DWpGTVIp1zUmpKoJ92+XjQIgYapYq/JDizks4tEieq57rN3Sgomvt7Pe8Aa1dlpCMy0=;MIID4jANBgtghkgBhvprUAcBDwOCA88AMIIDygOCA4IACUtC+mZ0I8o5Cfg2UFjpLUEoEjoVnWisiWBL07m5Lug3S0BNee6e5UFQIWR4hSaTK9i5ISa4EttPekYORTXCHhpJnlknB8FCJfuEEAXHPZWT2kcGHVz9CnuAl/+5ObxRUsX0WOTF0sSYdW8FoeVu6k+PnjkDqMhFbn5NcouB9hqpJGkD5xcTfGfWGq2Cb/6tCuKpKmuVHSg0QxpVVZ0K6Nh7YNzp5ZNP3Cf256aQAip68RcVIlOHf9ZK8vGLPUm0E/WgWYCKZLcw0FIsK6Wht0ZQIibc7GH7SjokUZWQ1abHL8aQ+6xhP6XJkFkrYPV/ThfVbqKBYWIG55sYQnU65BnSTw2ZsZE6DVa2ckqluToSg1twjanZF85XVTtGMWWjjMAA+ilN6AOUPnoQKqd0krkyt1ffpD2wU0FctKPl45EgqPS1/NZjfOA9VIUoFHvgKbgxgbIMYS1gClLCV1CBkujeQqaoSXgQFaW9XksFdelKD8MHSt0VBszVuaiIUzql4tSR0KQIf59pmIV6FlQhbUsd9cQ1qpQDJJz6VuZsBVTuUxHlOASEKine3Gt7ILCYeGBom9pVNcNQxLe5wCAYU/ZNplPV6UsGLTXPShquV53l2UdHoMGIUjT3gRzteAQ/URWgmS2NcBoh4adEIWXF2BcRlyQk1tFrskD+PCNElilZLDC62Ra4GJ3ZsUQX4LS0MekyzpJZoQgmNSy5IYB2+82v7Y7tRzYhju8m5HLTzqLniq1b8VhsrItEhUnJilcauuG5LkdkWsT2IROqDpQqdIHNZwE39H4aYC+XpRGSRQaoerLclrC+0Zdb2s/DOqCxj2EMIjjn4UCCiGrTJKhnJfWLbNKIufTBgrdKlwCl7aJDaxY6HnXZx8gEk5JtaAstEDfBcBiJgVKyvldVXYsUUNKloXjhYaWCkZeYHXtt8V4qnJXGJEEsAmEJ9h8sG9MmFrC/TPyIPI4sMgJkCknc5yFNQDCQaoMswiWHkW+4sVmkK9kVA6Ks3jLvCHsCwETKg5wdJ5wE5B3sFDLGHbihrhApDq7HTeCFoFSkZt4pmEecOVHeRG52jSPhkiIQAbATZZbGOGnEhFajyXQE0WfrEojHZgiCinmKbAj6E4NG4+4vIRwy0muHBECw9l7Oh29U0dnal3lmgGOhEpzCgrHqCsAezX796VAiAoOu9FYl4+tQA0IABHyx22zmrSfPDhaBk/S4QGrqKh0Xi5g7tXnY3F2jKFBeEqHa7KfEBjTg/4nahJ//L0jsokA3zJ7jABv9vAEY/Ew=;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== -2.16.840.1.114027.80.7.1.16;MIIC2gOCApMAOZNoo7yKDdXy+1ybdRzyFoXEdzZhYiXEwVzTqTzKyGIqJ+yMUp59P2BGmGAZ2XQNeHlblkiH7ugrLWXjOr7oko0toNAjfPoaJlD3R4VmzWUTFZ4pYWdS3M4u2ThFHNNS8yIY8qejObnVxKxt6ri+B9YTiOghzN4Aa1O80uHogKB2upMcmC1erPkX3aI4kTiCQAax0oqY1x9fGjDuvd0Af9ove2Gcli9WaTzX6yInWVpTN4ApmEhqXCEUVY5MnyLOHsoAyETaHGPxgTzRXvK9IzKRU4EEJa2T/oZlZ+liKmQFAhSQXBwdDhLTmv3j04Rfp8jFGchkvNC0dvIu99ph7DqCxZTGNIy97IJ288IZyxl3ynpdBRTlfjm515l0g7e+WcW105WUtld7+oedNpVclqa4V2+WShUz3pTTulhFLby1qF8NHqk5smnrCHM6aFME6wKMwMYUaSNb3qvd07OzMenMKN/+d8epDKMUyOcpSMNhsVcJJDbCj9oYOECituusCQzRoamb5wtICERxcLbksxd/pz5o3KvRxnl36up8kWW7XoU2LlMCUikGDWChfeio41rI4iGttCslkUcVXuohs81OHZx1ZfaYDAGTD9dGiTKanlrJLnmmu+v0ikVXOWrcJIzg3qgVniZjximNW+EzdQ24QX/Qm2ogwfWnL8I9Qc3yr1rcHHlriWwRFTLRMllwjjMMi8nN9W1N7qkqhuSLW03H/2Pj5c0QZpESP2lDaGb6cEhfMUiq1+LKi3/Q8uyps9bx0TFfTVz4ZhEZYjsHW3oEKh7DziwJbQ2gNg8hEI2urUK7CbfbWS5WMmsySDKUFmbV0DEk/rVggLWHBaXwqQlPndrqXLtlSupWXCgrP07ioANBAJaCDOH6etDTLBDKcRHVEuRYGmfOaKULtawl1M0OnlK43bYT/GOEXnVGatJKP59stVJt+6YF9d+JiKXgqJe8eQY=;MIIDwTANBgtghkgBhvprUAcBEAOCA64AMIIDqQOCA4IACZO+YJHwWQ4DwlmyyACQrQZi1rEceqUOLpqjal+YNhfDT5mFJ5W3cJ9mlkoWmHZygqBoKH1JnIRDJQ7XIaasLlNVYxnDZcpzjTY5mkCvs8wwEOHM2VySGvgK1V5Nrk/2fYzuODz8aB0bPIPOSNg3xfq5+B3A5GT0XchxVLll6XL8h8vRGThNPsBm6NszG459cK9qKbM2eKZWqJmLkrMrFkjTjgYBtsKuIE4823Oe4gNzbOtj4xdFMhkvx8vauAa4dmkiUyktXdB0NlciYD4PR2Icry788fdVwy5FokeicdaEPJCp9Mhul5/UvonCHHKmtA8H1o0YNB654boOOZJW8hQKIAZvkaSF7k9oKTlw2QZUNrh5G9h0GZwNuPVxDwKjukGSg4Ru3n3ohmj6b1ZPYXCTh+8gSxXdabXCCiOiPmqBkx9gUlglsQ3BVvSxxWudy6z97nP/iuFNrm7XIpwyHyh5CsLfUG58kqlpL+U59gdlFa8FjzkpcezgIXsJ5JiYlAiPjK71rh52DSkb4cYaIz9a8XHJZ0GHIk754pRzKNqbWGQb1nOaX9gTZMet4q2Bd8cee/AdtsUYCYli8UUCrQ+N0onVN825pi6RipzGv4jEh/ukIjeN0a8jM1ocu5UWx4sEKVC8LZkBIzCqDNgrxNeACj6Q5TLrPhJxttDPgiNmFkw0q4dbEwBhU20gxqcqgpv+plhB9dxoywn9kALK0P4OezU0mtcJhp9bTIbWsx65ZQi/KGeGlRnpKPHZa4WMUDY70eQGAXEAAZLXH0u9gnf7b8sfeVBpdImuoHaspIqKOLVZPpbqCLaFgHnVFdrYIwgf212GTrmV9LnQFOCpOpSIPIXPg8SUQ77e1h0UYxgOY3xkHMv2JceVejxncxdHbazVPVHznatOBHmZJeOoP81BIned57cQhyVUJ2BFsCj656vUWobjWtLsc2AswpFekRuAqZUEyYYikHpuQIGnbToFBAaPA3ON3VXXTh/gcxK3x9Mf/Z+ZJbssFdMd6vv3ZWj4C8B9Rv6KDB0YV+ZjANtHDhkyCFYRW9yeIV9oKk5tTerU7JNB3PLz1RwHab1povrhSYTc1IBzh5wTYR72XmQlMhr/VcDSwwuZpafjD84cLNziuI85d9nqUHNI9DCtfMBAZwscSaUkDAS8jhH/aaMU/VulX3eASN0+yBV5yh+HAyEAkA5HCjCNji2kbzW5GdbSPA80Oelz51bF3PORywqko5U=;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== \ No newline at end of file +2.16.840.1.114027.80.8.1.1;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.2;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.3;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;MIIFYDANBgtghkgBhvprUAgBAwOCBU0AMIIFSAOCBSEAyESPVb0FU/bVHWWehKpIt+AJeobWwZDw+m1B5E6hTIBimkvGlb2ljEr/4F0pCYwkTfMqqRbiSwxRiVZRodVJqjF15faLgZaKXfQuu7g2Fy3yDddhNW5zhklBId8yCIrYgmicSNnzU8zs/fxGcIW6USciYBYbUhmrc9B835Z7RFjveGrlAXtccqpLyB59BLYGXi9edtFiuLXS5/nER/Wec5+FF/Jojh/SzBsi3FccFQDbnWH8A0bVwJ1eNoLGiGhRYKjrKFawIIefamvuf+vgTBT7DO82DwMp6T/iaEorCeRwKqJSL4JiJnky1+XwW7GUqO4bc9au3GPW0rwWQc0b2+dSjdJEJxmxWBJlDTIY/YftMPLghvklXB2G/CF1cQddm3ZrnprAIJ5tFTDijWP7atL8vSEna8RcpbF6F2z8iivC9wWoBDrlNAZUvxeVVmaR/gYXvROnLclnAAawGzvji9u5YgHVdvD4w85PK7HTAReBCXnvc+8SZIkJErOJOUANoxmF5yboucwZrk8ejNRkFlsxSAw+OS4xoFXOFE28UYc0MoZ526jAyaImFCOsgEY15n4+ohQpg7sE0gF3GaUT9h8kOJNxUnuWqoWV/Ym9MIwW2Uf/XltVveJ7mrHbL1+aUqqe+lTuUGXJq0E1AYnvDipt+2zd/76lUh4EawK1gw6/TyWm1mrMiXOxPx9ZMSBcqnIWEaJSajcxqGKIbg5HkpFMTHxfeCOQ6TMvQ5kpDZhZR4iPTMGApmo41ir2nIooBmuRYK26lSNiK3doigX/+IOBe3Cz9AqQtUaIvqjxfMen+y2S/4grst35tsk9INg7DgYUub/AjnjqEzOQBEcYw2INSrBclj6261HmTU1FwJ9hS+M3uxt8tsWhNia/h8PRJi8OqyL2qkvpbLYnaVzOkqyXgnv5NDvpVS8VKMJ2BmSLezukAbVMWbGtGFRqT+jFj9UXuhzqL3uAfasigzuguZt4MdX5VamWPNimJjnOm8zHlXw7gk5r8hhnny0Ejo8s5d2gDX3XXSv7iGV1kZHU6WGhD/OUZzqV9GuXc5/X3ggLbinf0oQ4rKzUkpQ1p451H2bK5vM/sOH0GLyvO87jQA29p9YMtiWx/rHgdbua1oACOa84cvZ5MD/duHl2j4la3bst6kghEAZC+bmfiUJet5+r4ihT4koJDzFNqOCSZYK89BUXv4J2UDw+xZVpmm4MsRkpbfiqyqNNkZ1YzRW45EUvb+QdopYEP6SNkf9Oas00G799eN+ahDs+QmOJ1J5+8MaS0a5RFvXi/nt4id39r5jEdEpa3z2vzpmXH5Od7yrS5KALXqmbf5//SvW44OlaPLIJnUWJ/U7BLP3oT4xmYCsQsg4oayfp8OYfrm+t4LuHrt46flq6O6o0Fh62nY38+lfFk20AflhztarSy4KKMTnTTfcQ5pAKnRKAbkb7cEfk51qG4pEBdetqsOnSFjeL/fVPd5WpWGwEfywFQtdF6pwfP9YJ+Y9p5MCE5c2xiKfEM3NAmdgU+0cDhvCH6HL1SF7AXS4dwX035QqiQo0FjqE7NWqDab5TznbSSb3SSLL3RbVx8/UQRdsHGC5yMApRfqKjLLpnpSKCfQI93YW3APLYDHyJ79tvbEbWsXcTN/hZd5ruZEckQUYyLRqPdnsMr1B7w5GcLg+pgQAeCVQES9EbHnlW+sxDsk6DTq5QBFhXQSpLZmi0J3bT3Vq6RuUywTm7rRN7zgJjOKqRfGR+yQMhAPOzCA4bqYj2noA65lVZ0tZ8FA2G0TFPfz0nGTkbw4Wx;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.4;MIIJwwOCCXUAJFrDUL43U7YPorMyp3Uve8qa4VxRUJluKjaEkN63pwyMvF85PE/IDPioPgXA+QUzMGVb3YYJwD8X9FaeRevqnsmZurhOSeGSWSMYCY6G7W5j5SrG7gS3G9cBS4lZ77IcMd30yr24pkZQ3vTCTq5ZAckeDuXOPClH+ZqB8JohVsft4oqMbhiqrjviWKsJUEY9Pv4w8nog9M98K1p3AARKCGYmoIz0YPo2oC8rL5VhhhyS5titskGwq6B57ZPnU8lO2kKXl+b1jLKE7vHY3OpjMbq7FryR/8pkI0hyKZ3NNwmiWtHVxvAFrFLgMjZPXqdXFYFRZ9V2ylgsABNUSBK/ZFcJwcdzlg0a4nLkKvSvEyIx11RVdZORmw+SUZevzAHJNWujetCT6Jx0alMjF/mnLtxPAy/jNUrZQ+dzoYrVyyZafUsuVSHKAbrCqAxa1ahrBAmEQRiM6WoRU1y6aadz5sfqF7TKoVKQUWCh4fVLPANvkyAlvsvauSN6qYSB37Oex4yV5nNrxMwY/epw/IF73T7A1nKpyc8oQIZ3c2oZIEmQEqD56YhxwhbHC0B5YeMGpgituhk5LHpA5neS7QhReR/TmoA3TzKGHoJeInvF0fyLeagH+MeK+YruBa5VtejjlgjQ4DcD+FNJI2StK40PRFia6WpnvNO/KdlfaEPBMwyMKZetatIZJxyZbtqLbHSsh4bgaG8pMuTFl/dkZBblp134TuctStijy+0uUs9kaRpwGBSBN6MDki9EsDvRcsyP0mcqrzPlb3ThiejhyWcG7uh80CS6pQI2ASFYsOCsrW1jefR7o9CD0h4rMTCrA3HuqInPdQiIA8rYGaI1L074Gmhap8zrsLX2JzC83NPxwP0Zp8w/ousRGDk4pb3yQNl33YFN9g+XQ2YaeobjgV7aDjvJDwHTOG5SHvpPr1JCpQD3pBhdKUkzA68G8iWAtdgJNXNbOA730t+Pz20RyKboqA5vtVCbQSIagFUl3uAaE8AS1a9/mTtYzWyHWxriLdl6zwbLbv7nh+P2i5vec3Vt+kzyimQJGXy1GTys5VaH2g3dYpbnenfGH2g01vf1CvIlNrmPQzs9sxos+vTkIQXwtDFhkEpGTtjKx/Ipl2K3oPB8/6K0VFxnyqyg2LJJ4huAwWGwJcVvthBjffcfFB6X2cHhux9bQtwgVt4QhWQCtzrW8cNwZ+KeQokA6KXfB84uEupCjayu3SOR4h6T91B7Dc6PgJ6yqLI6iwefQ2vBDGMkP7wFLq5sm6gGKmuc2cGgNFRl8QcvPI3L5hwa8PXyYhfHIHgLmP3tH5ZOf9JZvtwsxkPsWm6fBWxCizeZtJsvGfwPE1rJZTKy4l46w8xCoYyhfomkUiZAyw9exLwIe8dxBB4ECARtJ9rb6uPRcnJpdPCdJha0zyasowQZUIRgCqIW0k+RKMKfE8kZNih4KOFm1R3bFUO++vX22VZ7334ij45qY7ciWpTbJAcI35VW9btc5z/K9qsanT9nq0wgbiHmeI1uczQe0WlioeoDWQdgqVOuuPu3yAaViT74/QXw9pj7UTbqXegcsLUAvJqvPr5ONvpQ8aeuTpA2eGlwPgKzsoxzBrcuYJhDHJ5FEc3RelUxePbG7BlqhTtlTS7pViPKqyoCnTrULqBMv5YaaU95ypdVv0kHpZmIw7d9p9z4/udVLNj63lsJFpaeurah93+T4VaU/TABVkSjBwJZ4Je5vmPnjdBOhV9k9AH6vwkWdes3KgZLOJCgcEXdVfl42k8ZD8cGc9XtPyGw9I5hK8NHO6SfnmSLoRa5N2tlIAAzKnT15pPE+m8m0tnlq/+E38TZslFhY4FJ/03T9bAM4ZspARBLO7iYipcVGU9yakg0ucZ1Sg71wA64kKvrN43NN7JpH7RZJweRD96VcuynrRupc9CIwxT3ACco24C1HRyooLeazS24a+/aqGZtICo+5smvj+DJQqED5YAvaqWmnwnAKYgJLi4NMOcVEGhmsTaLGAWUzq/X0mz1/6jdSm5UcfPyBksEtVCOGwUvlUcZ8dyXpJrX3KLKiZIbOt6Y+x+5Co2gCm789XMXa9q1AjHgx/dlQbpaT04cCyQuayqDIjEC4OozD/jhsyp4OA/WEckak2MAL0alEWGYqHXQ1DDaaTIdbCos6b6+DXVWxmNddCrwjHbLvm9VB1VPAUQxeE+T7nLM8W0VGY/WDzPFTX/S3XzehiQ+RuktYL9bOC+zIPXogF8h4vxo2O0uUw52j22q8izyNYMZ1vBTZC+7XYeaKWrhPMyxcSU/iCLkC9jCtQDW96zNIMhyg56tBjP2PAnHIFRsAB0AqDnA6VoSV9cFHn0v1DwpOcKluE2y4lsu3RH30cGbUJZtCAASXTVAx4s72YJN/YIFSAiloXiGqGxsb9IUfSrvoIRThf/gdiB5FYsLohv0YDJE1Ja0jwOBtFmvsy7/zjb9wnpZemAizgIye8+H/uKi8sxFj75A4Nd6DAYt9yo86AjKbOdo5UNmlHHHf9KPqxAw5zrbB/j7LCau9cacE1ZZGa2gAr0QZYugVH0ZPCeFbH3/xdqmFLz2cAHeKN7dVe3Jf0rxXqVYyfwZNpjMJPSR/dpdOs7LliPtcUMSxBIAwpyv7wxwuBwg3Rldi6TIsf8csH4fOAbgZQuO1J3uQQq4mKvB0CCkgFiLcB+eNr38kwW/iKx1SVUw/jyU9X3ouuUKl+gZSIEDMUK9tJ0soWiix5pzZpdMMr4AH5n1n61RK/cpGBkWkoo4RxAQfY6L81CkOns5YHEOlY9JdsB6GtbM0dmzbSf9HivUkOyWZOvzV9EPp9YSgZWkMke7vXSPpYFBfAR9SDVojyE/EaMrkLLR+OCE6kVwxElmGDfWpnXelay/OmhPTlUFtH5kGMBIRTKcwIeNAukrNsEqojLks5tVu6WnWltd/WzI46cAKsRGTLgI8+lmEn+UvdJXwOhgLd+WDk3gQCN178UsVtUhbLV8Rvipmbr0uTO2KzFuZOUjLOPR2U61IcP79AwB9HEuRCwasxBIhTInRfdiYPo3e/ZZglibnON+DcmpgxL1uoK8j56vxic4XFrD+gwLAVz6DVVKrfs4Clo7vaETqxAAAQUKCyUpL1hdXnqLm6qt8vwABBUYI2Nud7jGzNHY5/EYIyctW3R2iZaXqdbo6/z+/x0oS05aX2Rnb31/laK3y+7yAAAAAAAAAAAAAAAAABIhMkMDSAAwRQIhALUw5YdDNHC8u7jOf2p/0KvImbxiZcX2kFC/T+MNHbZ/AiApGvGxk/EURjbafLJttvsm3cUfdjjJoW2/m2xqM8V/HQ==;MIIFgTANBgtghkgBhvprUAgBBAOCBW4AMIIFaQOCBSEAU8Y3PnGCbpTRsNHyRb/vepHuxJnNc1zGQfdND0pKCLsh2WhsAWaFerGp7nUsycYbeUMbzaj9+hMj47uftHRdfjLN+72Dgr/Lt49nNPj+QiaIdZuNS8s6IfssXuknsTIToiZk3IhBAOUjTmC1up4xz1tlRxohJCR7ZOIAxFeJM1Ml/jxH5Yg8kAtOIykgY95PD4u1Cq/W5cXMu7vdKdoVn38qzrBQr7vrzb88VqNG81U/J2VANHT8FDxbnt7J1OfpfLV34Hh3nYsN61egep296izot+5im9SvJbkzGByYIpxCEE2pmJKtZjJn9uonOXunNLvFKwXy18dhO1Mpk2VarQn6ZWwjJ36hrgmtpmz2gIBrSsqVfviU5DtEE6ZWMkecpi3zl9NmH9eyq+dCsyf/tDA1C+niD/XxGeLzitH/UjKqD7hYhBJgYKa6GjcQIuV6dimJXuXfkfhIxzGny7Y8fRLFJ13ElElqeDIpODXImU7Q+wQUuya+nFUamP43onmiitC2OBUYflK9S4ggTP/APvWEvPcIidrPMSNYEQAnRDCCGb0OO0AVVVpEWc9c8rQq31xFJVglem3ueOHcTp3ofvwx9g3+va4EGCauCi2azkrP9zseNS3Tl31Fc6U3hgPe6+azVjT/yiyzNcles4TPH5RV0aCnK4ry1iDdPVslSJ3IO8/aSk2mJZEKP8wuX55Ww36m/oOfaLVxAo83WrJoHq0bEcD9CTLPD0kWRzDpBaVTwTO58xhMtajgQvjMa5khHCu7apVd4sYCl4S1QuPjCO/y3Q1j/gvn5xx8aGF9z8yHsv3yROTam7h2CbB6BpM7CR7VQZISk3GBU/i9F2Wpg/zRxM74CPM375HjxU/LbNTOoQZjYGOnJHEXMzrbJjTZ6ZoeYQAV1y64pwUKEFkgGsowko903NuAovLrBvo7bjs1hKWiIrmMrKGHNM7RUFubyIhanRQiudEuJ4Kqi+B/nYQwlnd7mdHwkp+Zd3x3DGsEfy7a2o5oe2Mi8xjrCo8u2103OeHulAFtCW8+190u8VS1BHvDj9dQ4t5V+miuRZYl2RGhGIZHAnonj+q6P6zg2t/wGpqtob7YZLOmj7bGoocc0OBWsUn0dwp26i339HoPIWVM4rronKCNqS1DoceS+22MIIESf8kksmhcPzwyMSk/OW8YaFHJzd6bTUcz3SXY3ohKe9s2hp4dCl/sXNcOiT8FuU4m4N5yEMEyh3pcqaxINy125KIoHaCiOGbzP1XGu2z/eqCgkRQuRqMmkyYviOtSGepojhMnd3ster3cTgzYbJ1F0t1/RKx1QdTd5o0pSTg15JDYtPfox6Qhz9mOGupjd839n4GSPQhuU/BYtzhCLKCu5EoryFGPXurzJnvcBnsJuC1JK4VVY8bd0/evpjyJcZ1Kvwwyx7ZFoq/LwSE2EhCcK1n6T/hHpaL2QgFPVNbVaUUTEyhyM3JMXjxzsZ+Jg0Qrgc/3eZch24CzJcy8CEqtLNBZSJ8tvC3BJzNeqLdTP6Ppzr4p+p6ACNKTXb4UmPt9224mDSKN1qe+Pi3kR+q/PjLZfUGFRcG/zp7rjkRuM2ap18J4PlekBJ7NHknaZORyQOsYTSE2yxDTYW9nwBwCxgxVu+HEqy+XONGJe71HMVh0VqsGjJ/KEU7RjgS2I3DMkEjtb3fALn9O63WbLIqqQWP5aSrqhzW5zfg4nl7+mnKMOoGKRU48B8obeoPVvTjcMd2g6efuBdtGrANCAAQrbuIby+s5BXEQSn7cQ9ES3gOyiUWbSNbbWjzBJde54IQwGcLV2p11frKOYLvd1qnLhpfPglgaZ8Q2sZq6Raon;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.5;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;MIIFgTANBgtghkgBhvprUAgBBQOCBW4AMIIFaQOCBSEAGdF+ts5X/FtbP5OZo0DzYiebnmqF5TJ3gYgBfAWIJz3FQi4I/I2JlHDAnzHO4gMYnA4tMLEj9xmRuaKYpXqBLe94PIgVtnJnctbQj/dCZyfKOsWzEfbdyVrBn1RQJjaGG1XCFeBvjmE6DtDp8VOS5qR23n7eY1nlP7+3Rj+ynsIE/Tdltq7+b/1prxpVNGI6DwbZB/FUOyEJK97xCBL7yHJn6MQycowzsV6Bmsv5PHMmHtyhNe77t+Ddk25Bk+p4JuUU1QnNFSQL5f6QGgz1eggoYvJ9hwF7Bqqmvm19T5qyspEQV9kPjDih+//JLXlTKbS820u/DEQgarIYVJOV3Q/HxaIAF+toAjTTyJRQzRQunNAPTXAG+YhCV4R93bQM2bJg8fLa8EPXbHrzBQWQsIS72QUl06rWG18BfWXCG34LKFzeQt4QOEG0eu5/YpYuidwZ6OFgLwJ9SMkjYcq51523X0dmNwH4DiVheHNmUj06t36/Lsylv/IbBroaHJOizZ8Hcfgy5KDvXJHbTh1UQZS8hZy3bziG+sIY/YYCRefLrJDSsdVlch5bxCYruPom6kZDO1nbFoT6tq7kdmohcwYihq4pm5gA62EA7wJxFWs4fNP27fYWiODWVxtzy4T1IfkPBIOosIQa3XHusGUq0lIIJRqUiG+7zQL9TffWmXfLaBr4VQT2hy1A4xHuYhqhMr/NSEjeTqEJ14uq+ukH5kZfBB+qc/aDEhDocnz8E7mWCCvr5c3TMaDvnxZxk9RUNpd808Q/DEbIg5p7Cww2DMUBXjibX1wul00ULGkRz+BKAZ6qctNF4LRcLqXKjWSYVAlf09aAdMoLwhqJZPZJsD28/Emyi0c7FkDkECLJ0UsUz2DvRdNHirqRzNLCED8g6CMBGUXNI3NG8SluS5SWbCd8sN2wwpFZzfvrVo9301TItFzShUc8nBHiwwrdDlPyqGgg6PoAQFIVd42dvmrUPbANT0N7h8TjK1ILUlW7frCdeEuUK0h1Uu88WUrpvLOqbXiA43FszSWNZjbyjS5cd2vVFRqJmcy66aUcoe2dMGvYhZv0Mpldfavs9h/j0lqkVGAA9V8R35MrPvX6SoRdBJgEZAYXd4TxtI/wbWNa9bLAMqUKCzzReJGsfvw8Qk01RQmGBWLxBqfHkgdiQRf3py+yjLaDz+uRJEkltDtduIBp825otGNOJuzgqXuBGirYZ63YIDuiNTCd2H0cNjZgDLQE0dN6NtohR9L/07jSDuaFekITp1rSMLM6EWPLM87yc23utwgYHFvGx/xc2ABMKi16ht9zK2+5e+6c1EvC9X/whvNEAt0q6NGWQodvlhBVaLcn+e2cZm6doNT1Xd/SA5HVk2wUx1GyaLbx7+PhZmbVwYruoUfqCQHotR3zR64KP68b25l6PMo60v5111RvHhuLK5TgAs9VcDpmlC4bDs3jwxIK0855iMgg9JliyuQh63QGsCeeZZSBaBDRZnSriZUZffySzcYOxPVj0oV1bgYFGTrsav2iDrgUeBqGuBCvujMXk0BOzxtzkXxR5+8uGHcSV9tPiGXZ9QErcvrz+QmA9x8ZoI9LZiQ/cVlvCQT9uBSepmm4wNGQ1SBDAHLd98jblXEpsCLpbXe0P1lIS+aioTyBVtWCoRf316lSeIQUZl6C5+weDjThpYD57V/WQpYwcC3tbmcyhVX1b3BIRlxE7p5GdB9q28V5y38DAhQfkWu93UVAq6UcGCBk+PoD3wNCAASoGMnHHUjXK6E2cMwYwLRSFbHJD0Ld1z0qTJUnxGugT4qDLOOK89Kv+lQZj8TtvHLsK22dBgezoP7r4d9KESJ3;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.6;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.7;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;MIIJUDANBgtghkgBhvprUAgBBwOCCT0AMIIJOAOCB6EAnDnvxWuWBS8nq0RChklX45oS5nD8Yz6Rc4y8oZ0HPKvSZ0PPR/mJ2nohIpxTnCPg/LLY+vLfrG6mLQzGCvQERKWH1y0TQbRk8Ao1PdYDjvq+Il3QwU9XzHNf8CES8Cyftd2zW5WQtdkTm8CpNR9QaDicfVPMvUG92+mmWYhEw4tYHNcoZT5arEUMQefop2bJsf3Jz5BcKci13O+lPjbXJoB6kxdAZq8pGccwmQHBA26fthfPkgaFP5fQnilgWkOFQ5SQyivdeYMA0PkPLMNrWwJVExWt4A3Jbmf2bjQw82XgCkVgJ7H8Cp9G4W4ecMRi62mOA5ErbHbvwVybRuZ+7T8c/QmHvkE8hHp+sdQ83hSJRlq/0a98+1knimykUZa+/pBT7VDW3RS3aIAAd50cKZSMgf5VEWK31oV9xtlvKclNklO+wsbXh5l8PafbDN/wSzy44sJMi1HwJLgrrqRmOEQWTMLdJIFUZpXbe+wqYFoIcTcgarE3pnnqgstrTPmkj5L4E25vpF9Y4vCnll+9AKqeA6IJGxj9h1qnKCXewCK4jUmF0ExYAiBbPS8JvOLsxd082MDezWYI5Qa0vZtinTfj8Xdk/GIfuJ/7oNzMmMBmYL/q+xCPC8HGlISmfBwdANny0kAqN19fz96HpSasYP/YzOhasbmkkNMuKCcw/pao0RuGshutT/0naQTKasmw3h9PbMYk7FuhikljwsScBoaWK6PvgFJcyliOxeqbxUx12fThhepmlnHXTpGlUBmT87Se0MJAEtZ7K38A6UQdHY2QwUd1IKfdsTXESwdIMXzwrJv9qtH6kuT2lc+HApY0juID+KpAWDQfQoKGOButTZeJnpG2qTOxaNjzJBYESeQqggA9f0v58mOhffZa8Pk6XaPYU4uZv4EYND72NrtouPkPcOwt/NoL2Wwct6K2BTzjnQLQu6er6o77teh9evXUwEQKWMLuhaZuCIdAduSPunBgJD0aCl7VjAeRQstuSm+OirqUGFgUxLg/oQCha2dmpL3iFWrF/+ezIrS3zh36cNVFROGjJGt75uhmtADobWnZOyJyg+bcRRMUmRV4l8Xk3+l8OMHRk0PSR5jIUyOt8FaY3ib/ecBt6YsbXHnrHywEEbB1Fjs1dOGakjdmMO2i/+hjrQbYmlX1l3YToWv9x93Gi4uESaQ/5WOCaSAwbjdvykm+7j7tObAxv02ChUx3vPVO29CZKsMq0Q/Cs9ZCfWocJvnUg1Se1pOHMX27huvLlWktbCPCHFjix50O+pehkeyTi4IUXKqWdSm7tGiXFMauPS2NKrHGZUy1t2LNP+0CxisBOMfbrFxPBp5IoqZs8iCmNhmxPG6d3sN3V6lpdJtEgULApfB+eW9j2GPy3rRKmlHESVejQsH1Lon/3WH9dISRfVLkDN3v3xFx8q/7mwxe5FLc6VXuN1CWTP+O6sLWF5mM+rxGMHklTBwq9QnFHtKX5Pc+SBq0dGOB9e8pcbj+j/3t5LOMc3Pm7j2S8h2WZ3PVUTyYn2IdvRTp41fA+KhWB9Fe+6qHtfk2au0Hw9hNLT4YDhZpSvPRb4u8XohP2yl/+yhG5IR8qqauSKOOKYF+L93yQ9q/yRz+poKFbQhUmjwdtmk+V2sO323Tq4X2IfJcg0IAVvultmUWzgeBnCuh8JN+Fi2M3RoZF9AH6qAJZUyiMjp6cMau8VgGh7dgrHzS/7NVazkhShyGoN+v66ddX/rDdJehK0vU/tHcqG69jkpKNjNnzpObwU4KmoYTVfvUKCp0jP+UI6bONdJO3CamF0iay/qycgEsPvP/ZEQGKb1Ra3f/HSJ6/RQrkuA07An5DOjYdf2t0SQMEpJ3cKSpthNzhMnzvl61IOiJW0alXfvrRkv80vwdh7AHBr5uwvEtuIPWQOZrnlyY6GQKNk3LrsecQw5jdIPoGV6q2QAn48yJgcasafWawZACg+r16lPHW3PHrm2IsVSwyKgAroKPva29m+QSbOxcPW4q8p7MpVUAeKLqYB6Mt/wDNQwWTK+Ty8QtYmU/gjWFVEVi22D/5SLnQSxysI3F4y6UFse3lcqgBabVTwlCSl1En+IgSscTJ/5jjw8cqEB0bnYWbiaCtawANyshKI+KNyw+PKDXd7xvjLhmX2rcmpQ5MXcAfFTrlS69PVCJDme0A0mCrsQs5FiVquPPE5eCpWOKAUuzHd96mW8vJoBqb2dOXpfPqkoJvK4EwuQAdactWdfZ4HHOzwx7+qrN9kC9ZaO1aFLzzseMhxPUW8rCKJ95y0OdPMyRhNdh2IyXfXIosl21q7I510n7KYB32YjUr252IXDTKx0aJK0UUGD3Njrh7Vmfa29j+d+oJnWUTGeDvSdqvld2K4R9W9YtrmN2/GLQa1hYIPk3pwR0Sz8nZ9c0jxmgseb66fQwSfaH5rhnSvia5ckepGnenTeNZQcWNndSM0cBv7EqODrJ6VT+6JP+mx5Lb5+lztsOHVGIeHE5lGjDYD7rJIVcpQnUoAri5hn8sNU2cwe8W8LP/YrdNcOMkDasNKBbV3uV37mTNx0tsX+ZiwpWdJwFCIgSVx3v9Kir1SA4wQUlCkNV7qN52puW+7wDggGPADCCAYoCggGBAMpgX7rWU55rDD5mpDwBUyzxtZbHc9m/D4r8k8aS4zrrle2G/GKB0SIp0P2N6xIvGh9kQj2dWMbQWNcjZAhtnJeJZChbdEbWyFLE4aCoWhLE5T2oOHJNWlF9wuDxxbV24ErTXVncrZzsl/hBzLMpiE+1H/lx8SaiiyNte44tIR/YHaT+3wLYQHnc1YTyk3u1Piq/keLVIalYYuUlk2H4141NSDJxdExm7qixyZMdTIvCboX5D+RHNQezlYgV7Dz4zKQTJGXhrjeEpaAzjQ+L3v3cfsb60YTJ95qGpgHgf82RNamlqZ+Y+ax+snlYy2fAyrAMJNC5hrYw1wP0S+hHsLQujtS0zh4cUe8DFf0SY8wKU3xVkJ7RMoKE9kV//K8qWI6lAp2OekRrk6oxVywSqpLWXiGlWuKeHOamkibASk3boWAm+q+889R2oZCtWQb0O/JFCHD2iX8yR1n0LLR8qIkFExU+wxVk4D5N3TGWYI9TAbM7SBeAM2Yhln6ssD2q/QIDAQAB;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.8;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.9;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.10;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.11;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.12;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.13;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;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;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.14;MIIC4gOCApMAOV/sx4VuI2pdmYS6AAzMT6hnT/7GDnob6HzmrVl2HXDvjCHJiFE6as5ly1fpgkLd2+YqLC9JUYWlzJlNxixceGNC1Z6OhGsYYij7Vk5ah+ciVterQzV9twUvWKz7MDb7hlsAcWfftXEt8BCWMp6nrux1ncif4x9mY2c3q1uhztxVTny91nklbwLJEAdGTJKNg3lD6Wt2PjN1cFnR9wIxNWoYos0WQhDMavSy7KYJeQFtVeV1nXJQ1Np2kNNoVvy7bXaGULY1ZjrtNjp3SRLnMt9jfo5/mYwWkmBi6ZK6inGW4jJ7YdOHGEGJwZfskj7lXiSRtJEzSbhsNWk/rnKi/DNEvzCuNAZ5joSHLJYhh9yTZH8Xbjdts1GZxZEP7DIDmM0gYgk4SXTNfPdNe+xjPvPXxWJNlNdCi9RsoU77yynAOYR7hYJL1AQ1CjLcLNKggzYZSf5T1qSVCyVoeigrHiGcLagTobNGmRyqOLtVNGJ4qOwS9Ltg1yKcsue2cVkt+klQ+iFFmSVLGM5GVJ5JmI/yW9Ey7vxO9yuOGHRr3Rpc4PL7kcWPF1yaVdhdub+0rWJn8AShAGPdVHPs7kfsGK2rn5Bf4UumGoL3RY2p7ctJx4YySCSoGz7LIsj2ysow93Rd03HVFzIQ++luszczVGDN9Lstntlmfoh6yex/kaZ5oeGUulW0/G9gim8vK658jUUT4teexRT1MNBXjwxGIn5Mi220vt1eLPoKe/TV/rIrWEym1H3esuNmwqHvPBSicpUYRcCTZPPsSWG3kPoTn4B6cbQYqq2xLQte68PPNBMCLtrrC+2/Jpwmcen7yT/8n2ZthLfID3wXh7pEGGdGPSSEN5pEycuzaHsskc3XY912cgNJADBGAiEAvyY/vhqhrNJKdfn2YOmWKDjyyXhSlo3Yb24xdYh6lJsCIQCNKxnjfEsuO8tiXLGkFab7X0f7k3tnMLSN7x+ZQNQuSg==;MIID4jANBgtghkgBhvprUAgBDgOCA88AMIIDygOCA4IACZ6mzub3HA82yGep6sHXE2Rc4ewuxmcdALSwZTKGWZwkP5dHS5wFSyDhR7SYFtJyG0uffoznVw5mWhHoU2ac+4INdyuRZra99m6F74gMdLW/uFeQTi4se5J5QutOpTuCjx+7Nrn3l6Iauym2ijWnmuK1XX0QvC84NDKLhESgCU+oNcPRQtJ81NhE4BEQB7V90IeMOrfaDFB55c2MusUgbA5cCn4Ix0WGUSlChtbi05doJUyUT63dLFAygi1fvmDdEukwxx8bwdcy2ccybPUqwGRWBZvFqxPEbmBzUn+08m5Ki9KWgZQr0GwaeLkQKgxpptq6gNcfbF4OIn6XW6YMgJKsRpyJ6RuBsIJ9rrXQqzjt3TPhomOZFGV2hSvCfNxTtwTex/WdQV0KsSQuJyO9/bbrZE1chnptWiGDfDatuvVPAFx47T2J/FDKg6wtk3OGZ4zBxQcOyV0BaFvjzOa+Tw3WRQiXYZV6yIjAjSiHZpyksO9aokrCx+9sKXjuBiZ1qZd35Innj5Scaajm8fjMqIOmrNp9mPodsJNn7IB/Jcrtm1gozBxNReTvn4QD5JN67Y6kre4UKVuRrba6HvpQhm+/lsCWsxWQPUH0e+2RbXOds2t4gwE/JDqRQp5HWuHe0kFNjK9oQIKIy7gXBXDz/in3jvpVZpcTw2eMeNFXlAhckBfSoixAeQDhytrDZTzKMPSrhsgj/v52CVHBXoG86yCQzBU6nznc30YE8WNbDG17tqpvJppcWYqsk1s2QRwEvl7VWgwdtvkdyN4U6ld8karWGOw0qhu0mkJGm2Y5Ftyi24U4+9c0LyG96LIBhUCMCOFaMv1RFXz0V7bKLB9YjkZY61ivLnS0lwimOE9iSEUV6mJ1QEcb9cM0aZ4WcjyA/CNSX2mkLsFbyulmNmnBs/lhIqEIAI+QxWqSnG0tlmJgxSOws5lyQ5wemS4Vx5N4mcpBsXthHtYAOXgwUTGm565y11VYkAgsRG0pkFnQUjAv4+gFGEyKo9W/rKZv0Ok32cXyeUohJqhETSfUb7qQzqccni/XOaCjvHh6B0DXUFrQTXNALQuSxXPo4KG7LczYkOsfPCBZOHe4S9KIlrw7PIPrhXKBhe3v36hMUNAFUNgOqDuEIcN/oT2TajpRICCmVCa5WqA0dJG0fekvsQnfA/yKA10OuyhpUmeL1aRiUINlA0IABInqYBEg+iYFVeTT21g4qmllXON+VhF1WJw49IDIKQoS4kBn0tvfP1wg7s0c1v7NQc4vFYMxgZPQBtHUGjWjRdE=;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.15;MIIC3AOCAo8AOUkWu2SIWEtDRM6cFQ+30XXy8ySg8BmAMnIevw2q53Rip+R95Wp5n96dRNg9vBGSgZvpC93h5+NXCgagXeN77t1hDGIrxh2NW+JNwptC2qkf4jO3geTezfIuxUswQzDCSuDKYhre8hFmnbnowp1pt0p/UEzRtm52sySENh+sTaj1ZVF+b3vUKFS/zuFeaZg1D8yJww72Kdr5q5XXKgmwcWZ9Ywcny6QlBjt3sXLaGOIU7tNUu7ziy0OR0+YOvSHcZSbwto7a1BH7X9d3GBbbDkTDSTbbRQq/sLA2UNCeTC5VqPWCEkIozo6jNRZE5qO/q55UYVpdIjsxZoh3WTbt+Tf9FE6+N+nZACl6DIebRW0s7LzpbWAM5dXQoRx8vjmbvC4pf19vY7VRGvMGnsJ1dPtSBqz02HRpQIDN2qZThGCT7HI432QyaWwDHOpb49b4BKmkkEUZMTlySXzxia4s+OfxX8korOTwh5GpCZPh9XoMPokPNEhvr0/qWmRSj/aXDtHQP6py5Mlr5lifbRTcYOQyTo+lDtZGpe+Wn1PCrHJQhipaoMnT7JTLyx9p9pY2AU9Uuskvwa2IqbaCVHp2ZrChQG93XR9puWddJYMStbNsijzKc9m8oaa0aji9NI5xcuDLbzZ1wx9A4jjMyziMHCJ/k0RYYTVuopLLvaT2SI53zksyIsTSesCgfTWE6rEGopdJhiV0a+NOYERVZ6zXZfE7Tn53pHl+/oWBVv9Bcmzia2Cl+aKs65XsJ6nK7KwyG/p5wWIcmt4KcwmwtNCV7Q5dUAYSw1exlic7rzp4ozuli+8VZ5QO5VNfJ0kMVAjHEMoCJ0OxMUZVMcGnSCDWdjFQk0cVvW602dF0TRoSA0cAMEQCID32qNm4OXz4vFlISEFbW9rXocFNYJoTa1a32UZRIHqEAiBuLzkylobN06TuoKoDTGgS9yAV6BQcmHj/n2m0cI3BRg==;MIID4jANBgtghkgBhvprUAgBDwOCA88AMIIDygOCA4IACS9BQAlflXFwhSZ2mxhVm00ziP4rn7CFj3ZSmLlXJRgK89QUJK18Y4oJbrOEsFhoTMO+rtsGStaTIvTq5I3fyDLRhHALm4JxcXl2fSlxu1GzSKzlgQCQxxYKI+qCkYyyN1AKmOCqJ82QQ6627TfKjWtr2BYE7QxLfzkbCBTq1yLN7Mj9k6pQXDv1gO/zSIgy6gyeC2N8p7g+SDgrbIbZwS6ojEBv9mgLyaiRWscLpquzbl6mUZVblhwTdyGDprY9qfGfofkumSllBo0mMd2+2hfFKXKSZElzSdhspEioPqssiMAkV89U0zziL5EZji+kGQJxutxVPtg3hL9bcjcOAGlRoQGRLtIDOCZyGGqid8rlTj+ZPHMfk9WurhxQCYmyYWRTBgQPUDcwfzbSBgQ76O6UCB92II2oJWLPi7YcW3SPplti2qlHaEHlX1WSd+VHzabFQhe+AOxRLtJUluF7N7GZyHqnA1ouSGUmhXK76uDE92TLvk50twuBHXMhQWp0UdQc8SnxhcCzOSp/BxSAT0KMdLNxZ3AtQoJBruBvpRlAaVbYB5KEMcYBSJS7OGaF8ixFkop30JAU5U724EKfGnerslirvQbpS3hkuFcnkYfOsGLIiZyxeodVENKFp1U06V8ZhjDAKSTfm+tJUM9IaI3UgH3zqyHq+BcNhTidWiB48MX6mqrFS6Z/JoKChzuFvjK6R2FhoY0qqdr7TgEfiAJjdidOpZNlL1kDfmGjxGkEesyGyxHQpE5h23lSzT2gSBjZFW2waPqYwAUOnTgE57fp6jIoYUlU58KiPPXmxyMQqnSKNiO8QlFtpJDZ0GG0mLrUcOWpcjUESKCbgxWNHu54rtYcd2lIkqUS9J868zRv6kdPIhbKT28YsDWbalhCry3NLsVg6yRL8FJzBCvYK+T4sLTVMEP+X5qE1dVo4Xmo/2PFaRloc7PVi4JJBPJepl23hWKRVsOOWHUQk0TicSjmXFswxIOc5vV7IZ0xBF1PBCML6LDW41CYyToYgZq5B2LQqQR0A60SQ0xk61uymvpN5DtytwbeP8ktmZHPxAWSI6T1KcoTiFUXDAzPRQ62iZCJ3wr1YRkFSKsMdBdj7qzbPzhbOacsNbC4d+gzb9dVZvFQ56KjiLj/44clKJjVXPcWkoMd0j0YaUyebOhEOJxJJWks50CBl2OVfTvGU6GBA0IABIY0LUXLYSEexjEiRyXRxpP8hLg3nRivJpg1F0DILxKlTF1KVWTXmho1Sa5XuWpPEjpaIPYuXX1iSNeSFC7j/vE=;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== +2.16.840.1.114027.80.8.1.16;MIIC1QOCAo4AOTsr2WiqHZENaYDd+In5E8sXyAp7nv6BDVd4fafv/nDScXn2ibRjcOYYU3NIYGyjbEKGTeZPfMFr9nR4C89dYWCQKxs8r1SP5F42o0BMXV3apXTdBllrYwgkBcGbEV3/DpSqRFALLwin4Fiq9nDH93WQTYNvlHqz9w3v8kGfIXAXBwKS97yFwzuS9XnruVgYihz/Es8Ko+415F/CZt7YY7OEdegal8MsapW9K0hLTVI/qnOU+PJYRx4Oh5NFPEVMvS44sEiPLlmKr1/n9w1WxvrGkX05dc/gkE2k9L4+j8NOy1yyr9xDnKKdmQrBss7i1phobxIKJb4K6Pp9Fyr9DT7mRbXaFoKxZpvce0gGZprMT5kmhn8lbto3AhbPQpRixXFPcktk8yL3zhhV0f2CeZQPvzRuBklDv8T77pxS2E1w6UshZUB2TdJflte+mH+WFE3mGVbEi7xVCuMgaKaNWIOmtl17LiNt3x8iplf7+TnkN4mOleM1GTH/yOuymbaKYzY8/BZnJC87QnHTnCkJFUnCaKr+LalhKhBUBxWE35BijznRTVsY1mIy+dIbpDoOj08l/C0bttnK8y/VSh+zS6Grs4XAr7deaGeoyBkswVBSowcWAup4Wtm6jS6vyB+e0T5+tcjcc5coh0b5UQnyu89hM5PnQR1CFGg93mFujvs4+ImUMMhFobX7HkeVaWSu51MFf9rTcegZ2T8YhLJ2nsP4zsYbJ+pxa4l/58eWj9niVz0s1LFapg0lHM+SVvII7OF/KgYwpJ31bNGkLNKDWYcqfz9nY8zPsTEq3wrxz6cYd76JBFPuLLIF+vxaY9q45RrLxJ668WJOor0Xfkp/0qoyaBmFh1bou4WXTkADQQA4+MPQQyTSq+KDdRcWbr2ZwlCEU0DX+5V38/0to74+yEHthKyGs/A79CSKhRv3vR97hsDsLG2aRVF1RwPKBywI;MIIDwTANBgtghkgBhvprUAgBEAOCA64AMIIDqQOCA4IACVFQ6FHXrNqQtctGTWalePCAd4PmyJukFxfdol+C7l27pixrq0goUaLqThUS1lYfKWyHrUiouMK/fFVbw6HAQJtmLIQuo6ksaK0YZNsUdhlWAiCh+mMsEwtAHywePQ3xduvBgbLoVIlmBSqgTqUKREi9GV3XOKQoazgFU8TCGJ1dqFPlw/eJYjB4xCRCluztytcEfkvB71qcigGEoFmnkMOAs+KPgITDJwPEmDjbSRBKGb0op4MeNjb599CEvQoeyEu8Rr8VfIfBRmp0ANHbQMJDgyQeHTAYTS5BHBxJCFQFijFUFjkuLRPVMVD9z4sxlBT51ZfpSs6hstbDT47wnojr6SOBRGmosqJjdG1Bi2kTpn2ZGYb+iqclRD4rTtoVYy2cJLxCK2/kOtBTkTAuZLvq+9VcINQ/+cMftIzCi3WtgnFQtWWq2iDAXwKRIOnmfVX8XNNnyvKU9ffrgYs2lQWj64+gXbFFQyQuSzY7oprlm1pcCPVao/hL8Zl2ngL0qapwoPrlXa3OAnH2t0vo2lBkjGUZ0ctt3CKpkofHeY13NHwlOXa1wWdNiK+zFTgq+2LULLBQh03rm4b+/dYDJA2wfG8XX2AqUFWUA95c8WqudkHlhJdnJoima22YQ0mLt7AqHX4g8kjsp1KzZCC3U6TfDQl/aPsuo59VH4Ow2lxPAa3g2UkCbKYWwIQkwCudhqSwoctK+rsKSoxplnUaMkeHGbeYcyFDAwporWhTARNrX2JmWP6jJZ9E1RCJElOB7ohopMPeLqRhudkmICUOfFfFiEkgYvQJZ5f5pyYXV4PRwXBU7tKIpiAmSVzWAVgOWukcANBEwg4SIcfubhujEXHL9522f9gkpDDULqIq1LgHa443kVBEhJwMvu7rogQqO28AX+bT151HBjF2GOwzPU3lOaxYWYH5uKVLIkycICxILEvUvN0BiGPN5Tmi0oYTXJNiZr92xxaKuvTk4fFQFAJoiKOarXuBHgD4F1rRQ8zHOP8teynuiEoam1OnVfKk32O7HM3odHPV1xrY6ETLnmO7ymWVt87tmdkT0oeUB53u9aJX1c2oJWznUJOrtkhmpgZpNwz0SmffYIqi8YCFsmvAKyxEBQACsq7oXHCsmDkuRqugvQ+OArzNqQwUu2zIzBvCQQVROmGEStMgmwz4FHXVb2rIcpQQgdKlYRLITxIkAyEAsYftBxFj8nGv4n7o289Cp48Ndgvzc9pfFW6GHs+QQ2U=;SGVsbG8sIGhvdyBhcmUgeW91IHRvZGF5PyA6KQ== \ No newline at end of file