| 1 |
/* Copyright (c) 2016, Google Inc. |
| 2 |
* |
| 3 |
* Permission to use, copy, modify, and/or distribute this software for any |
| 4 |
* purpose with or without fee is hereby granted, provided that the above |
| 5 |
* copyright notice and this permission notice appear in all copies. |
| 6 |
* |
| 7 |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 8 |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 9 |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| 10 |
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 11 |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 12 |
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 13 |
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| 14 |
|
| 15 |
#include <vector> |
| 16 |
|
| 17 |
#include <assert.h> |
| 18 |
#include <string.h> |
| 19 |
|
| 20 |
#include <openssl/crypto.h> |
| 21 |
#include <openssl/digest.h> |
| 22 |
#include <openssl/err.h> |
| 23 |
#include <openssl/evp.h> |
| 24 |
#include <openssl/pem.h> |
| 25 |
#include <openssl/x509.h> |
| 26 |
|
| 27 |
#include "../test/scoped_types.h" |
| 28 |
|
| 29 |
|
| 30 |
static const char kCrossSigningRootPEM[] = |
| 31 |
"-----BEGIN CERTIFICATE-----\n" |
| 32 |
"MIICcTCCAdqgAwIBAgIIagJHiPvE0MowDQYJKoZIhvcNAQELBQAwPDEaMBgGA1UE\n" |
| 33 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxHjAcBgNVBAMTFUNyb3NzLXNpZ25pbmcgUm9v\n" |
| 34 |
"dCBDQTAgFw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowPDEaMBgGA1UE\n" |
| 35 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxHjAcBgNVBAMTFUNyb3NzLXNpZ25pbmcgUm9v\n" |
| 36 |
"dCBDQTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwo3qFvSB9Zmlbpzn9wJp\n" |
| 37 |
"ikI75Rxkatez8VkLqyxbOhPYl2Haz8F5p1gDG96dCI6jcLGgu3AKT9uhEQyyUko5\n" |
| 38 |
"EKYasazSeA9CQrdyhPg0mkTYVETnPM1W/ebid1YtqQbq1CMWlq2aTDoSGAReGFKP\n" |
| 39 |
"RTdXAbuAXzpCfi/d8LqV13UCAwEAAaN6MHgwDgYDVR0PAQH/BAQDAgIEMB0GA1Ud\n" |
| 40 |
"JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAPBgNVHRMBAf8EBTADAQH/MBkGA1Ud\n" |
| 41 |
"DgQSBBBHKHC7V3Z/3oLvEZx0RZRwMBsGA1UdIwQUMBKAEEcocLtXdn/egu8RnHRF\n" |
| 42 |
"lHAwDQYJKoZIhvcNAQELBQADgYEAnglibsy6mGtpIXivtlcz4zIEnHw/lNW+r/eC\n" |
| 43 |
"CY7evZTmOoOuC/x9SS3MF9vawt1HFUummWM6ZgErqVBOXIB4//ykrcCgf5ZbF5Hr\n" |
| 44 |
"+3EFprKhBqYiXdD8hpBkrBoXwn85LPYWNd2TceCrx0YtLIprE2R5MB2RIq8y4Jk3\n" |
| 45 |
"YFXvkME=\n" |
| 46 |
"-----END CERTIFICATE-----\n"; |
| 47 |
|
| 48 |
static const char kRootCAPEM[] = |
| 49 |
"-----BEGIN CERTIFICATE-----\n" |
| 50 |
"MIICVTCCAb6gAwIBAgIIAj5CwoHlWuYwDQYJKoZIhvcNAQELBQAwLjEaMBgGA1UE\n" |
| 51 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxEDAOBgNVBAMTB1Jvb3QgQ0EwIBcNMTUwMTAx\n" |
| 52 |
"MDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMC4xGjAYBgNVBAoTEUJvcmluZ1NTTCBU\n" |
| 53 |
"RVNUSU5HMRAwDgYDVQQDEwdSb290IENBMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\n" |
| 54 |
"iQKBgQDpDn8RDOZa5oaDcPZRBy4CeBH1siSSOO4mYgLHlPE+oXdqwI/VImi2XeJM\n" |
| 55 |
"2uCFETXCknJJjYG0iJdrt/yyRFvZTQZw+QzGj+mz36NqhGxDWb6dstB2m8PX+plZ\n" |
| 56 |
"w7jl81MDvUnWs8yiQ/6twgu5AbhWKZQDJKcNKCEpqa6UW0r5nwIDAQABo3oweDAO\n" |
| 57 |
"BgNVHQ8BAf8EBAMCAgQwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMA8G\n" |
| 58 |
"A1UdEwEB/wQFMAMBAf8wGQYDVR0OBBIEEEA31wH7QC+4HH5UBCeMWQEwGwYDVR0j\n" |
| 59 |
"BBQwEoAQQDfXAftAL7gcflQEJ4xZATANBgkqhkiG9w0BAQsFAAOBgQDXylEK77Za\n" |
| 60 |
"kKeY6ZerrScWyZhrjIGtHFu09qVpdJEzrk87k2G7iHHR9CAvSofCgEExKtWNS9dN\n" |
| 61 |
"+9WiZp/U48iHLk7qaYXdEuO07No4BYtXn+lkOykE+FUxmA4wvOF1cTd2tdj3MzX2\n" |
| 62 |
"kfGIBAYhzGZWhY3JbhIfTEfY1PNM1pWChQ==\n" |
| 63 |
"-----END CERTIFICATE-----\n"; |
| 64 |
|
| 65 |
static const char kRootCrossSignedPEM[] = |
| 66 |
"-----BEGIN CERTIFICATE-----\n" |
| 67 |
"MIICYzCCAcygAwIBAgIIAj5CwoHlWuYwDQYJKoZIhvcNAQELBQAwPDEaMBgGA1UE\n" |
| 68 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxHjAcBgNVBAMTFUNyb3NzLXNpZ25pbmcgUm9v\n" |
| 69 |
"dCBDQTAgFw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowLjEaMBgGA1UE\n" |
| 70 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxEDAOBgNVBAMTB1Jvb3QgQ0EwgZ8wDQYJKoZI\n" |
| 71 |
"hvcNAQEBBQADgY0AMIGJAoGBAOkOfxEM5lrmhoNw9lEHLgJ4EfWyJJI47iZiAseU\n" |
| 72 |
"8T6hd2rAj9UiaLZd4kza4IURNcKSckmNgbSIl2u3/LJEW9lNBnD5DMaP6bPfo2qE\n" |
| 73 |
"bENZvp2y0Habw9f6mVnDuOXzUwO9SdazzKJD/q3CC7kBuFYplAMkpw0oISmprpRb\n" |
| 74 |
"SvmfAgMBAAGjejB4MA4GA1UdDwEB/wQEAwICBDAdBgNVHSUEFjAUBggrBgEFBQcD\n" |
| 75 |
"AQYIKwYBBQUHAwIwDwYDVR0TAQH/BAUwAwEB/zAZBgNVHQ4EEgQQQDfXAftAL7gc\n" |
| 76 |
"flQEJ4xZATAbBgNVHSMEFDASgBBHKHC7V3Z/3oLvEZx0RZRwMA0GCSqGSIb3DQEB\n" |
| 77 |
"CwUAA4GBAErTxYJ0en9HVRHAAr5OO5wuk5Iq3VMc79TMyQLCXVL8YH8Uk7KEwv+q\n" |
| 78 |
"9MEKZv2eR/Vfm4HlXlUuIqfgUXbwrAYC/YVVX86Wnbpy/jc73NYVCq8FEZeO+0XU\n" |
| 79 |
"90SWAPDdp+iL7aZdimnMtG1qlM1edmz8AKbrhN/R3IbA2CL0nCWV\n" |
| 80 |
"-----END CERTIFICATE-----\n"; |
| 81 |
|
| 82 |
static const char kIntermediatePEM[] = |
| 83 |
"-----BEGIN CERTIFICATE-----\n" |
| 84 |
"MIICXjCCAcegAwIBAgIJAKJMH+7rscPcMA0GCSqGSIb3DQEBCwUAMC4xGjAYBgNV\n" |
| 85 |
"BAoTEUJvcmluZ1NTTCBURVNUSU5HMRAwDgYDVQQDEwdSb290IENBMCAXDTE1MDEw\n" |
| 86 |
"MTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjA2MRowGAYDVQQKExFCb3JpbmdTU0wg\n" |
| 87 |
"VEVTVElORzEYMBYGA1UEAxMPSW50ZXJtZWRpYXRlIENBMIGfMA0GCSqGSIb3DQEB\n" |
| 88 |
"AQUAA4GNADCBiQKBgQC7YtI0l8ocTYJ0gKyXTtPL4iMJCNY4OcxXl48jkncVG1Hl\n" |
| 89 |
"blicgNUa1r9m9YFtVkxvBinb8dXiUpEGhVg4awRPDcatlsBSEBuJkiZGYbRcAmSu\n" |
| 90 |
"CmZYnf6u3aYQ18SU8WqVERPpE4cwVVs+6kwlzRw0+XDoZAczu8ZezVhCUc6NbQID\n" |
| 91 |
"AQABo3oweDAOBgNVHQ8BAf8EBAMCAgQwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsG\n" |
| 92 |
"AQUFBwMCMA8GA1UdEwEB/wQFMAMBAf8wGQYDVR0OBBIEEIwaaKi1dttdV3sfjRSy\n" |
| 93 |
"BqMwGwYDVR0jBBQwEoAQQDfXAftAL7gcflQEJ4xZATANBgkqhkiG9w0BAQsFAAOB\n" |
| 94 |
"gQCvnolNWEHuQS8PFVVyuLR+FKBeUUdrVbSfHSzTqNAqQGp0C9fk5oCzDq6ZgTfY\n" |
| 95 |
"ESXM4cJhb3IAnW0UM0NFsYSKQJ50JZL2L3z5ZLQhHdbs4RmODGoC40BVdnJ4/qgB\n" |
| 96 |
"aGSh09eQRvAVmbVCviDK2ipkWNegdyI19jFfNP5uIkGlYg==\n" |
| 97 |
"-----END CERTIFICATE-----\n"; |
| 98 |
|
| 99 |
static const char kIntermediateSelfSignedPEM[] = |
| 100 |
"-----BEGIN CERTIFICATE-----\n" |
| 101 |
"MIICZjCCAc+gAwIBAgIJAKJMH+7rscPcMA0GCSqGSIb3DQEBCwUAMDYxGjAYBgNV\n" |
| 102 |
"BAoTEUJvcmluZ1NTTCBURVNUSU5HMRgwFgYDVQQDEw9JbnRlcm1lZGlhdGUgQ0Ew\n" |
| 103 |
"IBcNMTUwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMDYxGjAYBgNVBAoTEUJv\n" |
| 104 |
"cmluZ1NTTCBURVNUSU5HMRgwFgYDVQQDEw9JbnRlcm1lZGlhdGUgQ0EwgZ8wDQYJ\n" |
| 105 |
"KoZIhvcNAQEBBQADgY0AMIGJAoGBALti0jSXyhxNgnSArJdO08viIwkI1jg5zFeX\n" |
| 106 |
"jyOSdxUbUeVuWJyA1RrWv2b1gW1WTG8GKdvx1eJSkQaFWDhrBE8Nxq2WwFIQG4mS\n" |
| 107 |
"JkZhtFwCZK4KZlid/q7dphDXxJTxapURE+kThzBVWz7qTCXNHDT5cOhkBzO7xl7N\n" |
| 108 |
"WEJRzo1tAgMBAAGjejB4MA4GA1UdDwEB/wQEAwICBDAdBgNVHSUEFjAUBggrBgEF\n" |
| 109 |
"BQcDAQYIKwYBBQUHAwIwDwYDVR0TAQH/BAUwAwEB/zAZBgNVHQ4EEgQQjBpoqLV2\n" |
| 110 |
"211Xex+NFLIGozAbBgNVHSMEFDASgBCMGmiotXbbXVd7H40UsgajMA0GCSqGSIb3\n" |
| 111 |
"DQEBCwUAA4GBALcccSrAQ0/EqQBsx0ZDTUydHXXNP2DrUkpUKmAXIe8McqIVSlkT\n" |
| 112 |
"6H4xz7z8VRKBo9j+drjjtCw2i0CQc8aOLxRb5WJ8eVLnaW2XRlUqAzhF0CrulfVI\n" |
| 113 |
"E4Vs6ZLU+fra1WAuIj6qFiigRja+3YkZArG8tMA9vtlhTX/g7YBZIkqH\n" |
| 114 |
"-----END CERTIFICATE-----\n"; |
| 115 |
|
| 116 |
static const char kLeafPEM[] = |
| 117 |
"-----BEGIN CERTIFICATE-----\n" |
| 118 |
"MIICXjCCAcegAwIBAgIIWjO48ufpunYwDQYJKoZIhvcNAQELBQAwNjEaMBgGA1UE\n" |
| 119 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxGDAWBgNVBAMTD0ludGVybWVkaWF0ZSBDQTAg\n" |
| 120 |
"Fw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowMjEaMBgGA1UEChMRQm9y\n" |
| 121 |
"aW5nU1NMIFRFU1RJTkcxFDASBgNVBAMTC2V4YW1wbGUuY29tMIGfMA0GCSqGSIb3\n" |
| 122 |
"DQEBAQUAA4GNADCBiQKBgQDD0U0ZYgqShJ7oOjsyNKyVXEHqeafmk/bAoPqY/h1c\n" |
| 123 |
"oPw2E8KmeqiUSoTPjG5IXSblOxcqpbAXgnjPzo8DI3GNMhAf8SYNYsoH7gc7Uy7j\n" |
| 124 |
"5x8bUrisGnuTHqkqH6d4/e7ETJ7i3CpR8bvK16DggEvQTudLipz8FBHtYhFakfdh\n" |
| 125 |
"TwIDAQABo3cwdTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEG\n" |
| 126 |
"CCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwGQYDVR0OBBIEEKN5pvbur7mlXjeMEYA0\n" |
| 127 |
"4nUwGwYDVR0jBBQwEoAQjBpoqLV2211Xex+NFLIGozANBgkqhkiG9w0BAQsFAAOB\n" |
| 128 |
"gQBj/p+JChp//LnXWC1k121LM/ii7hFzQzMrt70bny406SGz9jAjaPOX4S3gt38y\n" |
| 129 |
"rhjpPukBlSzgQXFg66y6q5qp1nQTD1Cw6NkKBe9WuBlY3iYfmsf7WT8nhlT1CttU\n" |
| 130 |
"xNCwyMX9mtdXdQicOfNjIGUCD5OLV5PgHFPRKiHHioBAhg==\n" |
| 131 |
"-----END CERTIFICATE-----\n"; |
| 132 |
|
| 133 |
static const char kLeafNoKeyUsagePEM[] = |
| 134 |
"-----BEGIN CERTIFICATE-----\n" |
| 135 |
"MIICNTCCAZ6gAwIBAgIJAIFQGaLQ0G2mMA0GCSqGSIb3DQEBCwUAMDYxGjAYBgNV\n" |
| 136 |
"BAoTEUJvcmluZ1NTTCBURVNUSU5HMRgwFgYDVQQDEw9JbnRlcm1lZGlhdGUgQ0Ew\n" |
| 137 |
"IBcNMTUwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMDcxGjAYBgNVBAoTEUJv\n" |
| 138 |
"cmluZ1NTTCBURVNUSU5HMRkwFwYDVQQDExBldmlsLmV4YW1wbGUuY29tMIGfMA0G\n" |
| 139 |
"CSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOKoZe75NPz77EOaMMl4/0s3PyQw++zJvp\n" |
| 140 |
"ejHAxZiTPCJgMbEHLrSzNoHdopg+CLUH5bE4wTXM8w9Inv5P8OAFJt7gJuPUunmk\n" |
| 141 |
"j+NoU3QfzOR6BroePcz1vXX9jyVHRs087M/sLqWRHu9IR+/A+UTcBaWaFiDVUxtJ\n" |
| 142 |
"YOwFMwjNPQIDAQABo0gwRjAMBgNVHRMBAf8EAjAAMBkGA1UdDgQSBBBJfLEUWHq1\n" |
| 143 |
"27rZ1AVx2J5GMBsGA1UdIwQUMBKAEIwaaKi1dttdV3sfjRSyBqMwDQYJKoZIhvcN\n" |
| 144 |
"AQELBQADgYEALVKN2Y3LZJOtu6SxFIYKxbLaXhTGTdIjxipZhmbBRDFjbZjZZOTe\n" |
| 145 |
"6Oo+VDNPYco4rBexK7umYXJyfTqoY0E8dbiImhTcGTEj7OAB3DbBomgU1AYe+t2D\n" |
| 146 |
"uwBqh4Y3Eto+Zn4pMVsxGEfUpjzjZDel7bN1/oU/9KWPpDfywfUmjgk=\n" |
| 147 |
"-----END CERTIFICATE-----\n"; |
| 148 |
|
| 149 |
static const char kForgeryPEM[] = |
| 150 |
"-----BEGIN CERTIFICATE-----\n" |
| 151 |
"MIICZzCCAdCgAwIBAgIIdTlMzQoKkeMwDQYJKoZIhvcNAQELBQAwNzEaMBgGA1UE\n" |
| 152 |
"ChMRQm9yaW5nU1NMIFRFU1RJTkcxGTAXBgNVBAMTEGV2aWwuZXhhbXBsZS5jb20w\n" |
| 153 |
"IBcNMTUwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMDoxGjAYBgNVBAoTEUJv\n" |
| 154 |
"cmluZ1NTTCBURVNUSU5HMRwwGgYDVQQDExNmb3JnZXJ5LmV4YW1wbGUuY29tMIGf\n" |
| 155 |
"MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDADTwruBQZGb7Ay6s9HiYv5d1lwtEy\n" |
| 156 |
"xQdA2Sy8Rn8uA20Q4KgqwVY7wzIZ+z5Butrsmwb70gdG1XU+yRaDeE7XVoW6jSpm\n" |
| 157 |
"0sw35/5vJbTcL4THEFbnX0OPZnvpuZDFUkvVtq5kxpDWsVyM24G8EEq7kPih3Sa3\n" |
| 158 |
"OMhXVXF8kso6UQIDAQABo3cwdTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYI\n" |
| 159 |
"KwYBBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwGQYDVR0OBBIEEEYJ/WHM\n" |
| 160 |
"8p64erPWIg4/liwwGwYDVR0jBBQwEoAQSXyxFFh6tdu62dQFcdieRjANBgkqhkiG\n" |
| 161 |
"9w0BAQsFAAOBgQA+zH7bHPElWRWJvjxDqRexmYLn+D3Aivs8XgXQJsM94W0EzSUf\n" |
| 162 |
"DSLfRgaQwcb2gg2xpDFoG+W0vc6O651uF23WGt5JaFFJJxqjII05IexfCNhuPmp4\n" |
| 163 |
"4UZAXPttuJXpn74IY1tuouaM06B3vXKZR+/ityKmfJvSwxacmFcK+2ziAg==\n" |
| 164 |
"-----END CERTIFICATE-----\n"; |
| 165 |
|
| 166 |
// kExamplePSSCert is an example RSA-PSS self-signed certificate, signed with |
| 167 |
// the default hash functions. |
| 168 |
static const char kExamplePSSCert[] = |
| 169 |
"-----BEGIN CERTIFICATE-----\n" |
| 170 |
"MIICYjCCAcagAwIBAgIJAI3qUyT6SIfzMBIGCSqGSIb3DQEBCjAFogMCAWowRTEL\n" |
| 171 |
"MAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVy\n" |
| 172 |
"bmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0xNDEwMDkxOTA5NTVaFw0xNTEwMDkxOTA5\n" |
| 173 |
"NTVaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQK\n" |
| 174 |
"DBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwgZ8wDQYJKoZIhvcNAQEBBQADgY0A\n" |
| 175 |
"MIGJAoGBAPi4bIO0vNmoV8CltFl2jFQdeesiUgR+0zfrQf2D+fCmhRU0dXFahKg8\n" |
| 176 |
"0u9aTtPel4rd/7vPCqqGkr64UOTNb4AzMHYTj8p73OxaymPHAyXvqIqDWHYg+hZ3\n" |
| 177 |
"13mSYwFIGth7Z/FSVUlO1m5KXNd6NzYM3t2PROjCpywrta9kS2EHAgMBAAGjUDBO\n" |
| 178 |
"MB0GA1UdDgQWBBTQQfuJQR6nrVrsNF1JEflVgXgfEzAfBgNVHSMEGDAWgBTQQfuJ\n" |
| 179 |
"QR6nrVrsNF1JEflVgXgfEzAMBgNVHRMEBTADAQH/MBIGCSqGSIb3DQEBCjAFogMC\n" |
| 180 |
"AWoDgYEASUy2RZcgNbNQZA0/7F+V1YTLEXwD16bm+iSVnzGwtexmQVEYIZG74K/w\n" |
| 181 |
"xbdZQdTbpNJkp1QPjPfh0zsatw6dmt5QoZ8K8No0DjR9dgf+Wvv5WJvJUIQBoAVN\n" |
| 182 |
"Z0IL+OQFz6+LcTHxD27JJCebrATXZA0wThGTQDm7crL+a+SujBY=\n" |
| 183 |
"-----END CERTIFICATE-----\n"; |
| 184 |
|
| 185 |
// kBadPSSCertPEM is a self-signed RSA-PSS certificate with bad parameters. |
| 186 |
static const char kBadPSSCertPEM[] = |
| 187 |
"-----BEGIN CERTIFICATE-----\n" |
| 188 |
"MIIDdjCCAjqgAwIBAgIJANcwZLyfEv7DMD4GCSqGSIb3DQEBCjAxoA0wCwYJYIZI\n" |
| 189 |
"AWUDBAIBoRowGAYJKoZIhvcNAQEIMAsGCWCGSAFlAwQCAaIEAgIA3jAnMSUwIwYD\n" |
| 190 |
"VQQDDBxUZXN0IEludmFsaWQgUFNTIGNlcnRpZmljYXRlMB4XDTE1MTEwNDE2MDIz\n" |
| 191 |
"NVoXDTE1MTIwNDE2MDIzNVowJzElMCMGA1UEAwwcVGVzdCBJbnZhbGlkIFBTUyBj\n" |
| 192 |
"ZXJ0aWZpY2F0ZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMTaM7WH\n" |
| 193 |
"qVCAGAIA+zL1KWvvASTrhlq+1ePdO7wsrWX2KiYoTYrJYTnxhLnn0wrHqApt79nL\n" |
| 194 |
"IBG7cfShyZqFHOY/IzlYPMVt+gPo293gw96Fds5JBsjhjkyGnOyr9OUntFqvxDbT\n" |
| 195 |
"IIFU7o9IdxD4edaqjRv+fegVE+B79pDk4s0ujsk6dULtCg9Rst0ucGFo19mr+b7k\n" |
| 196 |
"dbfn8pZ72ZNDJPueVdrUAWw9oll61UcYfk75XdrLk6JlL41GrYHc8KlfXf43gGQq\n" |
| 197 |
"QfrpHkg4Ih2cI6Wt2nhFGAzrlcorzLliQIUJRIhM8h4IgDfpBpaPdVQLqS2pFbXa\n" |
| 198 |
"5eQjqiyJwak2vJ8CAwEAAaNQME4wHQYDVR0OBBYEFCt180N4oGUt5LbzBwQ4Ia+2\n" |
| 199 |
"4V97MB8GA1UdIwQYMBaAFCt180N4oGUt5LbzBwQ4Ia+24V97MAwGA1UdEwQFMAMB\n" |
| 200 |
"Af8wMQYJKoZIhvcNAQEKMCSgDTALBglghkgBZQMEAgGhDTALBgkqhkiG9w0BAQii\n" |
| 201 |
"BAICAN4DggEBAAjBtm90lGxgddjc4Xu/nbXXFHVs2zVcHv/mqOZoQkGB9r/BVgLb\n" |
| 202 |
"xhHrFZ2pHGElbUYPfifdS9ztB73e1d4J+P29o0yBqfd4/wGAc/JA8qgn6AAEO/Xn\n" |
| 203 |
"plhFeTRJQtLZVl75CkHXgUGUd3h+ADvKtcBuW9dSUncaUrgNKR8u/h/2sMG38RWY\n" |
| 204 |
"DzBddC/66YTa3r7KkVUfW7yqRQfELiGKdcm+bjlTEMsvS+EhHup9CzbpoCx2Fx9p\n" |
| 205 |
"NPtFY3yEObQhmL1JyoCRWqBE75GzFPbRaiux5UpEkns+i3trkGssZzsOuVqHNTNZ\n" |
| 206 |
"lC9+9hPHIoc9UMmAQNo1vGIW3NWVoeGbaJ8=\n" |
| 207 |
"-----END CERTIFICATE-----\n"; |
| 208 |
|
| 209 |
static const char kRSAKey[] = |
| 210 |
"-----BEGIN RSA PRIVATE KEY-----\n" |
| 211 |
"MIICXgIBAAKBgQDYK8imMuRi/03z0K1Zi0WnvfFHvwlYeyK9Na6XJYaUoIDAtB92\n" |
| 212 |
"kWdGMdAQhLciHnAjkXLI6W15OoV3gA/ElRZ1xUpxTMhjP6PyY5wqT5r6y8FxbiiF\n" |
| 213 |
"KKAnHmUcrgfVW28tQ+0rkLGMryRtrukXOgXBv7gcrmU7G1jC2a7WqmeI8QIDAQAB\n" |
| 214 |
"AoGBAIBy09Fd4DOq/Ijp8HeKuCMKTHqTW1xGHshLQ6jwVV2vWZIn9aIgmDsvkjCe\n" |
| 215 |
"i6ssZvnbjVcwzSoByhjN8ZCf/i15HECWDFFh6gt0P5z0MnChwzZmvatV/FXCT0j+\n" |
| 216 |
"WmGNB/gkehKjGXLLcjTb6dRYVJSCZhVuOLLcbWIV10gggJQBAkEA8S8sGe4ezyyZ\n" |
| 217 |
"m4e9r95g6s43kPqtj5rewTsUxt+2n4eVodD+ZUlCULWVNAFLkYRTBCASlSrm9Xhj\n" |
| 218 |
"QpmWAHJUkQJBAOVzQdFUaewLtdOJoPCtpYoY1zd22eae8TQEmpGOR11L6kbxLQsk\n" |
| 219 |
"aMly/DOnOaa82tqAGTdqDEZgSNmCeKKknmECQAvpnY8GUOVAubGR6c+W90iBuQLj\n" |
| 220 |
"LtFp/9ihd2w/PoDwrHZaoUYVcT4VSfJQog/k7kjE4MYXYWL8eEKg3WTWQNECQQDk\n" |
| 221 |
"104Wi91Umd1PzF0ijd2jXOERJU1wEKe6XLkYYNHWQAe5l4J4MWj9OdxFXAxIuuR/\n" |
| 222 |
"tfDwbqkta4xcux67//khAkEAvvRXLHTaa6VFzTaiiO8SaFsHV3lQyXOtMrBpB5jd\n" |
| 223 |
"moZWgjHvB2W9Ckn7sDqsPB+U2tyX0joDdQEyuiMECDY8oQ==\n" |
| 224 |
"-----END RSA PRIVATE KEY-----\n"; |
| 225 |
|
| 226 |
|
| 227 |
// CertFromPEM parses the given, NUL-terminated pem block and returns an |
| 228 |
// |X509*|. |
| 229 |
static ScopedX509 CertFromPEM(const char *pem) { |
| 230 |
ScopedBIO bio(BIO_new_mem_buf(pem, strlen(pem))); |
| 231 |
return ScopedX509(PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr)); |
| 232 |
} |
| 233 |
|
| 234 |
// PrivateKeyFromPEM parses the given, NUL-terminated pem block and returns an |
| 235 |
// |EVP_PKEY*|. |
| 236 |
static ScopedEVP_PKEY PrivateKeyFromPEM(const char *pem) { |
| 237 |
ScopedBIO bio(BIO_new_mem_buf(const_cast<char *>(pem), strlen(pem))); |
| 238 |
return ScopedEVP_PKEY( |
| 239 |
PEM_read_bio_PrivateKey(bio.get(), nullptr, nullptr, nullptr)); |
| 240 |
} |
| 241 |
|
| 242 |
// CertsToStack converts a vector of |X509*| to an OpenSSL STACK_OF(X509*), |
| 243 |
// bumping the reference counts for each certificate in question. |
| 244 |
static STACK_OF(X509)* CertsToStack(const std::vector<X509*> &certs) { |
| 245 |
ScopedX509Stack stack(sk_X509_new_null()); |
| 246 |
if (!stack) { |
| 247 |
return nullptr; |
| 248 |
} |
| 249 |
for (auto cert : certs) { |
| 250 |
if (!sk_X509_push(stack.get(), cert)) { |
| 251 |
return nullptr; |
| 252 |
} |
| 253 |
X509_up_ref(cert); |
| 254 |
} |
| 255 |
|
| 256 |
return stack.release(); |
| 257 |
} |
| 258 |
|
| 259 |
static bool Verify(X509 *leaf, const std::vector<X509 *> &roots, |
| 260 |
const std::vector<X509 *> &intermediates, |
| 261 |
unsigned long flags = 0) { |
| 262 |
ScopedX509Stack roots_stack(CertsToStack(roots)); |
| 263 |
ScopedX509Stack intermediates_stack(CertsToStack(intermediates)); |
| 264 |
if (!roots_stack || |
| 265 |
!intermediates_stack) { |
| 266 |
return false; |
| 267 |
} |
| 268 |
|
| 269 |
ScopedX509_STORE_CTX ctx(X509_STORE_CTX_new()); |
| 270 |
if (!ctx) { |
| 271 |
return false; |
| 272 |
} |
| 273 |
if (!X509_STORE_CTX_init(ctx.get(), nullptr /* no X509_STORE */, leaf, |
| 274 |
intermediates_stack.get())) { |
| 275 |
return false; |
| 276 |
} |
| 277 |
|
| 278 |
X509_STORE_CTX_trusted_stack(ctx.get(), roots_stack.get()); |
| 279 |
|
| 280 |
X509_VERIFY_PARAM *param = X509_VERIFY_PARAM_new(); |
| 281 |
if (param == nullptr) { |
| 282 |
return false; |
| 283 |
} |
| 284 |
X509_VERIFY_PARAM_set_time(param, 1452807555 /* Jan 14th, 2016 */); |
| 285 |
X509_VERIFY_PARAM_set_depth(param, 16); |
| 286 |
if (flags) { |
| 287 |
X509_VERIFY_PARAM_set_flags(param, flags); |
| 288 |
} |
| 289 |
X509_STORE_CTX_set0_param(ctx.get(), param); |
| 290 |
|
| 291 |
ERR_clear_error(); |
| 292 |
return X509_verify_cert(ctx.get()) == 1; |
| 293 |
} |
| 294 |
|
| 295 |
static bool TestVerify() { |
| 296 |
ScopedX509 cross_signing_root(CertFromPEM(kCrossSigningRootPEM)); |
| 297 |
ScopedX509 root(CertFromPEM(kRootCAPEM)); |
| 298 |
ScopedX509 root_cross_signed(CertFromPEM(kRootCrossSignedPEM)); |
| 299 |
ScopedX509 intermediate(CertFromPEM(kIntermediatePEM)); |
| 300 |
ScopedX509 intermediate_self_signed(CertFromPEM(kIntermediateSelfSignedPEM)); |
| 301 |
ScopedX509 leaf(CertFromPEM(kLeafPEM)); |
| 302 |
ScopedX509 leaf_no_key_usage(CertFromPEM(kLeafNoKeyUsagePEM)); |
| 303 |
ScopedX509 forgery(CertFromPEM(kForgeryPEM)); |
| 304 |
|
| 305 |
if (!cross_signing_root || |
| 306 |
!root || |
| 307 |
!root_cross_signed || |
| 308 |
!intermediate || |
| 309 |
!intermediate_self_signed || |
| 310 |
!leaf || |
| 311 |
!leaf_no_key_usage || |
| 312 |
!forgery) { |
| 313 |
fprintf(stderr, "Failed to parse certificates\n"); |
| 314 |
return false; |
| 315 |
} |
| 316 |
|
| 317 |
std::vector<X509*> empty; |
| 318 |
if (Verify(leaf.get(), empty, empty)) { |
| 319 |
fprintf(stderr, "Leaf verified with no roots!\n"); |
| 320 |
return false; |
| 321 |
} |
| 322 |
|
| 323 |
if (Verify(leaf.get(), empty, {intermediate.get()})) { |
| 324 |
fprintf(stderr, "Leaf verified with no roots!\n"); |
| 325 |
return false; |
| 326 |
} |
| 327 |
|
| 328 |
if (!Verify(leaf.get(), {root.get()}, {intermediate.get()})) { |
| 329 |
ERR_print_errors_fp(stderr); |
| 330 |
fprintf(stderr, "Basic chain didn't verify.\n"); |
| 331 |
return false; |
| 332 |
} |
| 333 |
|
| 334 |
if (!Verify(leaf.get(), {cross_signing_root.get()}, |
| 335 |
{intermediate.get(), root_cross_signed.get()})) { |
| 336 |
ERR_print_errors_fp(stderr); |
| 337 |
fprintf(stderr, "Cross-signed chain didn't verify.\n"); |
| 338 |
return false; |
| 339 |
} |
| 340 |
|
| 341 |
if (!Verify(leaf.get(), {cross_signing_root.get(), root.get()}, |
| 342 |
{intermediate.get(), root_cross_signed.get()})) { |
| 343 |
ERR_print_errors_fp(stderr); |
| 344 |
fprintf(stderr, "Cross-signed chain with root didn't verify.\n"); |
| 345 |
return false; |
| 346 |
} |
| 347 |
|
| 348 |
/* This is the “altchains” test – we remove the cross-signing CA but include |
| 349 |
* the cross-sign in the intermediates. */ |
| 350 |
if (!Verify(leaf.get(), {root.get()}, |
| 351 |
{intermediate.get(), root_cross_signed.get()})) { |
| 352 |
ERR_print_errors_fp(stderr); |
| 353 |
fprintf(stderr, "Chain with cross-sign didn't backtrack to find root.\n"); |
| 354 |
return false; |
| 355 |
} |
| 356 |
|
| 357 |
if (Verify(leaf.get(), {root.get()}, |
| 358 |
{intermediate.get(), root_cross_signed.get()}, |
| 359 |
X509_V_FLAG_NO_ALT_CHAINS)) { |
| 360 |
fprintf(stderr, "Altchains test still passed when disabled.\n"); |
| 361 |
return false; |
| 362 |
} |
| 363 |
|
| 364 |
if (Verify(forgery.get(), {intermediate_self_signed.get()}, |
| 365 |
{leaf_no_key_usage.get()})) { |
| 366 |
fprintf(stderr, "Basic constraints weren't checked.\n"); |
| 367 |
return false; |
| 368 |
} |
| 369 |
|
| 370 |
/* Test that one cannot skip Basic Constraints checking with a contorted set |
| 371 |
* of roots and intermediates. This is a regression test for CVE-2015-1793. */ |
| 372 |
if (Verify(forgery.get(), |
| 373 |
{intermediate_self_signed.get(), root_cross_signed.get()}, |
| 374 |
{leaf_no_key_usage.get(), intermediate.get()})) { |
| 375 |
fprintf(stderr, "Basic constraints weren't checked.\n"); |
| 376 |
return false; |
| 377 |
} |
| 378 |
|
| 379 |
return true; |
| 380 |
} |
| 381 |
|
| 382 |
static bool TestPSS() { |
| 383 |
ScopedX509 cert(CertFromPEM(kExamplePSSCert)); |
| 384 |
if (!cert) { |
| 385 |
return false; |
| 386 |
} |
| 387 |
|
| 388 |
ScopedEVP_PKEY pkey(X509_get_pubkey(cert.get())); |
| 389 |
if (!pkey) { |
| 390 |
return false; |
| 391 |
} |
| 392 |
|
| 393 |
if (!X509_verify(cert.get(), pkey.get())) { |
| 394 |
fprintf(stderr, "Could not verify certificate.\n"); |
| 395 |
return false; |
| 396 |
} |
| 397 |
return true; |
| 398 |
} |
| 399 |
|
| 400 |
static bool TestBadPSSParameters() { |
| 401 |
ScopedX509 cert(CertFromPEM(kBadPSSCertPEM)); |
| 402 |
if (!cert) { |
| 403 |
return false; |
| 404 |
} |
| 405 |
|
| 406 |
ScopedEVP_PKEY pkey(X509_get_pubkey(cert.get())); |
| 407 |
if (!pkey) { |
| 408 |
return false; |
| 409 |
} |
| 410 |
|
| 411 |
if (X509_verify(cert.get(), pkey.get())) { |
| 412 |
fprintf(stderr, "Unexpectedly verified bad certificate.\n"); |
| 413 |
return false; |
| 414 |
} |
| 415 |
ERR_clear_error(); |
| 416 |
return true; |
| 417 |
} |
| 418 |
|
| 419 |
static bool SignatureRoundTrips(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) { |
| 420 |
// Make a certificate like signed with |md_ctx|'s settings.' |
| 421 |
ScopedX509 cert(CertFromPEM(kLeafPEM)); |
| 422 |
if (!cert || !X509_sign_ctx(cert.get(), md_ctx)) { |
| 423 |
return false; |
| 424 |
} |
| 425 |
|
| 426 |
// Ensure that |pkey| may still be used to verify the resulting signature. All |
| 427 |
// settings in |md_ctx| must have been serialized appropriately. |
| 428 |
return !!X509_verify(cert.get(), pkey); |
| 429 |
} |
| 430 |
|
| 431 |
static bool TestSignCtx() { |
| 432 |
ScopedEVP_PKEY pkey(PrivateKeyFromPEM(kRSAKey)); |
| 433 |
if (!pkey) { |
| 434 |
return false; |
| 435 |
} |
| 436 |
|
| 437 |
// Test PKCS#1 v1.5. |
| 438 |
ScopedEVP_MD_CTX md_ctx; |
| 439 |
if (!EVP_DigestSignInit(md_ctx.get(), NULL, EVP_sha256(), NULL, pkey.get()) || |
| 440 |
!SignatureRoundTrips(md_ctx.get(), pkey.get())) { |
| 441 |
fprintf(stderr, "RSA PKCS#1 with SHA-256 failed\n"); |
| 442 |
return false; |
| 443 |
} |
| 444 |
|
| 445 |
// Test RSA-PSS with custom parameters. |
| 446 |
md_ctx.Reset(); |
| 447 |
EVP_PKEY_CTX *pkey_ctx; |
| 448 |
if (!EVP_DigestSignInit(md_ctx.get(), &pkey_ctx, EVP_sha256(), NULL, |
| 449 |
pkey.get()) || |
| 450 |
!EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) || |
| 451 |
!EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, EVP_sha512()) || |
| 452 |
!SignatureRoundTrips(md_ctx.get(), pkey.get())) { |
| 453 |
fprintf(stderr, "RSA-PSS failed\n"); |
| 454 |
return false; |
| 455 |
} |
| 456 |
|
| 457 |
return true; |
| 458 |
} |
| 459 |
|
| 460 |
int main(int argc, char **argv) { |
| 461 |
CRYPTO_library_init(); |
| 462 |
|
| 463 |
if (!TestVerify() || |
| 464 |
!TestPSS() || |
| 465 |
!TestBadPSSParameters() || |
| 466 |
!TestSignCtx()) { |
| 467 |
return 1; |
| 468 |
} |
| 469 |
|
| 470 |
printf("PASS\n"); |
| 471 |
return 0; |
| 472 |
} |