kris
/
boringssl
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2230 Commits
12 Branches
38 MiB
 
 
 
 
 
 
Tree: acb2451807
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'acb2451807'
${ noResults }
boringssl/crypto/evp/evp_extra_test.cc

950 lines
44 KiB
Raw Blame History 

  1. /* Copyright (c) 2014, 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 <stdint.h>

  16. #include <stdio.h>

  17. #include <stdlib.h>

  18. #include <string.h>

  19. 

  20. #include <utility>

  21. #include <vector>

  22. 

  23. #include <openssl/bytestring.h>

  24. #include <openssl/crypto.h>

  25. #include <openssl/digest.h>

  26. #include <openssl/err.h>

  27. #include <openssl/evp.h>

  28. #include <openssl/rsa.h>

  29. #include <openssl/x509.h>

  30. 

  31. #include "../test/scoped_types.h"

  32. 

  33. 

  34. // kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you

  35. // should never use this key anywhere but in an example.

  36. static const uint8_t kExampleRSAKeyDER[] = {

  37.     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,

  38.     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,

  39.     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,

  40.     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,

  41.     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,

  42.     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,

  43.     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,

  44.     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,

  45.     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,

  46.     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,

  47.     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,

  48.     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,

  49.     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,

  50.     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,

  51.     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,

  52.     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,

  53.     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,

  54.     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,

  55.     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,

  56.     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,

  57.     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,

  58.     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,

  59.     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,

  60.     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,

  61.     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,

  62.     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,

  63.     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,

  64.     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,

  65.     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,

  66.     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,

  67.     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,

  68.     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,

  69.     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,

  70.     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,

  71.     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,

  72.     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,

  73.     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,

  74.     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,

  75.     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,

  76.     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,

  77.     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,

  78.     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,

  79.     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,

  80.     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,

  81.     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,

  82.     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,

  83.     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,

  84.     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,

  85.     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,

  86.     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,

  87.     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,

  88. };

  89. 

  90. static const uint8_t kExampleDSAKeyDER[] = {

  91.     0x30, 0x82, 0x03, 0x56, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,

  92.     0x9e, 0x12, 0xfa, 0xb3, 0xde, 0x12, 0x21, 0x35, 0x01, 0xdd, 0x82, 0xaa,

  93.     0x10, 0xca, 0x2d, 0x10, 0x1d, 0x2d, 0x4e, 0xbf, 0xef, 0x4d, 0x2a, 0x3f,

  94.     0x8d, 0xaa, 0x0f, 0xe0, 0xce, 0xda, 0xd8, 0xd6, 0xaf, 0x85, 0x61, 0x6a,

  95.     0xa2, 0xf3, 0x25, 0x2c, 0x0a, 0x2b, 0x5a, 0x6d, 0xb0, 0x9e, 0x6f, 0x14,

  96.     0x90, 0x0e, 0x0d, 0xdb, 0x83, 0x11, 0x87, 0x6d, 0xd8, 0xf9, 0x66, 0x95,

  97.     0x25, 0xf9, 0x9e, 0xd6, 0x59, 0x49, 0xe1, 0x84, 0xd5, 0x06, 0x47, 0x93,

  98.     0x27, 0x11, 0x69, 0xa2, 0x28, 0x68, 0x0b, 0x95, 0xec, 0x12, 0xf5, 0x9a,

  99.     0x8e, 0x20, 0xb2, 0x1f, 0x2b, 0x58, 0xeb, 0x2a, 0x20, 0x12, 0xd3, 0x5b,

  100.     0xde, 0x2e, 0xe3, 0x51, 0x82, 0x2f, 0xe8, 0xf3, 0x2d, 0x0a, 0x33, 0x05,

  101.     0x65, 0xdc, 0xce, 0x5c, 0x67, 0x2b, 0x72, 0x59, 0xc1, 0x4b, 0x24, 0x33,

  102.     0xd0, 0xb5, 0xb2, 0xca, 0x2b, 0x2d, 0xb0, 0xab, 0x62, 0x6e, 0x8f, 0x13,

  103.     0xf4, 0x7f, 0xe0, 0x34, 0x5d, 0x90, 0x4e, 0x72, 0x94, 0xbb, 0x03, 0x8e,

  104.     0x9c, 0xe2, 0x1a, 0x9e, 0x58, 0x0b, 0x83, 0x35, 0x62, 0x78, 0x70, 0x6c,

  105.     0xfe, 0x76, 0x84, 0x36, 0xc6, 0x9d, 0xe1, 0x49, 0xcc, 0xff, 0x98, 0xb4,

  106.     0xaa, 0xb8, 0xcb, 0x4f, 0x63, 0x85, 0xc9, 0xf1, 0x02, 0xce, 0x59, 0x34,

  107.     0x6e, 0xae, 0xef, 0x27, 0xe0, 0xad, 0x22, 0x2d, 0x53, 0xd6, 0xe8, 0x9c,

  108.     0xc8, 0xcd, 0xe5, 0x77, 0x6d, 0xd0, 0x00, 0x57, 0xb0, 0x3f, 0x2d, 0x88,

  109.     0xab, 0x3c, 0xed, 0xba, 0xfd, 0x7b, 0x58, 0x5f, 0x0b, 0x7f, 0x78, 0x35,

  110.     0xe1, 0x7a, 0x37, 0x28, 0xbb, 0xf2, 0x5e, 0xa6, 0x25, 0x72, 0xf2, 0x45,

  111.     0xdc, 0x11, 0x1f, 0x3c, 0xe3, 0x9c, 0xb6, 0xff, 0xac, 0xc3, 0x1b, 0x0a,

  112.     0x27, 0x90, 0xe7, 0xbd, 0xe9, 0x02, 0x24, 0xea, 0x9b, 0x09, 0x31, 0x53,

  113.     0x62, 0xaf, 0x3d, 0x2b, 0x02, 0x21, 0x00, 0xf3, 0x81, 0xdc, 0xf5, 0x3e,

  114.     0xbf, 0x72, 0x4f, 0x8b, 0x2e, 0x5c, 0xa8, 0x2c, 0x01, 0x0f, 0xb4, 0xb5,

  115.     0xed, 0xa9, 0x35, 0x8d, 0x0f, 0xd8, 0x8e, 0xd2, 0x78, 0x58, 0x94, 0x88,

  116.     0xb5, 0x4f, 0xc3, 0x02, 0x82, 0x01, 0x00, 0x0c, 0x40, 0x2a, 0x72, 0x5d,

  117.     0xcc, 0x3a, 0x62, 0xe0, 0x2b, 0xf4, 0xcf, 0x43, 0xcd, 0x17, 0xf4, 0xa4,

  118.     0x93, 0x59, 0x12, 0x20, 0x22, 0x36, 0x69, 0xcf, 0x41, 0x93, 0xed, 0xab,

  119.     0x42, 0x3a, 0xd0, 0x8d, 0xfb, 0x55, 0x2e, 0x30, 0x8a, 0x6a, 0x57, 0xa5,

  120.     0xff, 0xbc, 0x7c, 0xd0, 0xfb, 0x20, 0x87, 0xf8, 0x1f, 0x8d, 0xf0, 0xcb,

  121.     0x08, 0xab, 0x21, 0x33, 0x28, 0x7d, 0x2b, 0x69, 0x68, 0x71, 0x4a, 0x94,

  122.     0xf6, 0x33, 0xc9, 0x40, 0x84, 0x5a, 0x48, 0xa3, 0xe1, 0x67, 0x08, 0xdd,

  123.     0xe7, 0x61, 0xcc, 0x6a, 0x8e, 0xab, 0x2d, 0x84, 0xdb, 0x21, 0xb6, 0xea,

  124.     0x5b, 0x07, 0x68, 0x14, 0x93, 0xcc, 0x9c, 0x31, 0xfb, 0xc3, 0x68, 0xb2,

  125.     0x43, 0xf6, 0xdd, 0xf8, 0xc9, 0x32, 0xa8, 0xb4, 0x03, 0x8f, 0x44, 0xe7,

  126.     0xb1, 0x5c, 0xa8, 0x76, 0x34, 0x4a, 0x14, 0x78, 0x59, 0xf2, 0xb4, 0x3b,

  127.     0x39, 0x45, 0x86, 0x68, 0xad, 0x5e, 0x0a, 0x1a, 0x9a, 0x66, 0x95, 0x46,

  128.     0xdd, 0x28, 0x12, 0xe3, 0xb3, 0x61, 0x7a, 0x0a, 0xef, 0x99, 0xd5, 0x8e,

  129.     0x3b, 0xb4, 0xcc, 0x87, 0xfd, 0x94, 0x22, 0x5e, 0x01, 0xd2, 0xdc, 0xc4,

  130.     0x69, 0xa7, 0x72, 0x68, 0x14, 0x6c, 0x51, 0x91, 0x8f, 0x18, 0xe8, 0xb4,

  131.     0xd7, 0x0a, 0xa1, 0xf0, 0xc7, 0x62, 0x3b, 0xcc, 0x52, 0xcf, 0x37, 0x31,

  132.     0xd3, 0x86, 0x41, 0xb2, 0xd2, 0x83, 0x0b, 0x7e, 0xec, 0xb2, 0xf0, 0x95,

  133.     0x52, 0xff, 0x13, 0x7d, 0x04, 0x6e, 0x49, 0x4e, 0x7f, 0x33, 0xc3, 0x59,

  134.     0x00, 0x02, 0xb1, 0x6d, 0x1b, 0x97, 0xd9, 0x36, 0xfd, 0xa2, 0x8f, 0x90,

  135.     0xc3, 0xed, 0x3c, 0xa3, 0x53, 0x38, 0x16, 0x8a, 0xc1, 0x6f, 0x77, 0xc3,

  136.     0xc5, 0x7a, 0xdc, 0x2e, 0x8f, 0x7c, 0x6c, 0x22, 0x56, 0xe4, 0x1a, 0x5f,

  137.     0x65, 0x45, 0x05, 0x90, 0xdb, 0xb5, 0xbc, 0xf0, 0x6d, 0x66, 0x61, 0x02,

  138.     0x82, 0x01, 0x00, 0x31, 0x97, 0x31, 0xa1, 0x4e, 0x38, 0x56, 0x88, 0xdb,

  139.     0x94, 0x1d, 0xbf, 0x65, 0x5c, 0xda, 0x4b, 0xc2, 0x10, 0xde, 0x74, 0x20,

  140.     0x03, 0xce, 0x13, 0x60, 0xf2, 0x25, 0x1d, 0x55, 0x7c, 0x5d, 0x94, 0x82,

  141.     0x54, 0x08, 0x53, 0xdb, 0x85, 0x95, 0xbf, 0xdd, 0x5e, 0x50, 0xd5, 0x96,

  142.     0xe0, 0x79, 0x51, 0x1b, 0xbf, 0x4d, 0x4e, 0xb9, 0x3a, 0xc5, 0xee, 0xc4,

  143.     0x5e, 0x98, 0x75, 0x7b, 0xbe, 0xff, 0x30, 0xe6, 0xd0, 0x7b, 0xa6, 0xf1,

  144.     0xbc, 0x29, 0xea, 0xdf, 0xec, 0xf3, 0x8b, 0xfa, 0x83, 0x11, 0x9f, 0x3f,

  145.     0xf0, 0x5d, 0x06, 0x51, 0x32, 0xaa, 0x21, 0xfc, 0x26, 0x17, 0xe7, 0x50,

  146.     0xc2, 0x16, 0xba, 0xfa, 0x54, 0xb7, 0x7e, 0x1d, 0x2c, 0xa6, 0xa3, 0x41,

  147.     0x66, 0x33, 0x94, 0x83, 0xb9, 0xbf, 0xa0, 0x4f, 0xbd, 0xa6, 0xfd, 0x2c,

  148.     0x81, 0x58, 0x35, 0x33, 0x39, 0xc0, 0x6d, 0x33, 0x40, 0x56, 0x64, 0x12,

  149.     0x5a, 0xcd, 0x35, 0x53, 0x21, 0x78, 0x8f, 0x27, 0x24, 0x37, 0x66, 0x8a,

  150.     0xdf, 0x5e, 0x5f, 0x63, 0xfc, 0x8b, 0x2d, 0xef, 0x57, 0xdb, 0x40, 0x25,

  151.     0xd5, 0x17, 0x53, 0x0b, 0xe4, 0xa5, 0xae, 0x54, 0xbf, 0x46, 0x4f, 0xa6,

  152.     0x79, 0xc3, 0x74, 0xfa, 0x1f, 0x85, 0x34, 0x64, 0x6d, 0xc5, 0x03, 0xeb,

  153.     0x72, 0x98, 0x80, 0x7b, 0xc0, 0x8f, 0x35, 0x11, 0xa7, 0x09, 0xeb, 0x51,

  154.     0xe0, 0xb0, 0xac, 0x92, 0x14, 0xf2, 0xad, 0x37, 0x95, 0x5a, 0xba, 0x8c,

  155.     0xc4, 0xdb, 0xed, 0xc4, 0x4e, 0x8b, 0x8f, 0x84, 0x33, 0x64, 0xf8, 0x57,

  156.     0x12, 0xd7, 0x08, 0x7e, 0x90, 0x66, 0xdf, 0x91, 0x50, 0x23, 0xf2, 0x73,

  157.     0xc0, 0x6b, 0xb1, 0x15, 0xdd, 0x64, 0xd7, 0xc9, 0x75, 0x17, 0x73, 0x72,

  158.     0xda, 0x33, 0xc4, 0x6f, 0xa5, 0x47, 0xa1, 0xcc, 0xd1, 0xc6, 0x62, 0xe5,

  159.     0xca, 0xab, 0x5f, 0x2a, 0x8f, 0x6b, 0xcc, 0x02, 0x21, 0x00, 0xb0, 0xc7,

  160.     0x68, 0x70, 0x27, 0x43, 0xbc, 0x51, 0x24, 0x29, 0x93, 0xa9, 0x71, 0xa5,

  161.     0x28, 0x89, 0x79, 0x54, 0x44, 0xf7, 0xc6, 0x45, 0x22, 0x03, 0xd0, 0xce,

  162.     0x84, 0xfe, 0x61, 0x17, 0xd4, 0x6e,

  163. };

  164. 

  165. static const uint8_t kMsg[] = {1, 2, 3, 4};

  166. 

  167. static const uint8_t kSignature[] = {

  168.     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,

  169.     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,

  170.     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,

  171.     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,

  172.     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,

  173.     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,

  174.     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,

  175.     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,

  176.     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,

  177.     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,

  178.     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,

  179. };

  180. 

  181. // kExamplePSSCert is an example self-signed certificate, signed with

  182. // kExampleRSAKeyDER using RSA-PSS with default hash functions.

  183. static const uint8_t kExamplePSSCert[] = {

  184.     0x30, 0x82, 0x02, 0x62, 0x30, 0x82, 0x01, 0xc6, 0xa0, 0x03, 0x02, 0x01,

  185.     0x02, 0x02, 0x09, 0x00, 0x8d, 0xea, 0x53, 0x24, 0xfa, 0x48, 0x87, 0xf3,

  186.     0x30, 0x12, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,

  187.     0x0a, 0x30, 0x05, 0xa2, 0x03, 0x02, 0x01, 0x6a, 0x30, 0x45, 0x31, 0x0b,

  188.     0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31,

  189.     0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f,

  190.     0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f,

  191.     0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72,

  192.     0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20,

  193.     0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x30, 0x1e, 0x17, 0x0d, 0x31,

  194.     0x34, 0x31, 0x30, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39, 0x35, 0x35, 0x5a,

  195.     0x17, 0x0d, 0x31, 0x35, 0x31, 0x30, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39,

  196.     0x35, 0x35, 0x5a, 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,

  197.     0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,

  198.     0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74,

  199.     0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a,

  200.     0x0c, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57,

  201.     0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c,

  202.     0x74, 0x64, 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48,

  203.     0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00,

  204.     0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4,

  205.     0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d,

  206.     0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83,

  207.     0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c,

  208.     0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf,

  209.     0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33,

  210.     0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7,

  211.     0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76, 0x20, 0xfa, 0x16, 0x77,

  212.     0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52,

  213.     0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c,

  214.     0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64,

  215.     0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x50, 0x30, 0x4e,

  216.     0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xd0,

  217.     0x41, 0xfb, 0x89, 0x41, 0x1e, 0xa7, 0xad, 0x5a, 0xec, 0x34, 0x5d, 0x49,

  218.     0x11, 0xf9, 0x55, 0x81, 0x78, 0x1f, 0x13, 0x30, 0x1f, 0x06, 0x03, 0x55,

  219.     0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xd0, 0x41, 0xfb, 0x89,

  220.     0x41, 0x1e, 0xa7, 0xad, 0x5a, 0xec, 0x34, 0x5d, 0x49, 0x11, 0xf9, 0x55,

  221.     0x81, 0x78, 0x1f, 0x13, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04,

  222.     0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x12, 0x06, 0x09, 0x2a, 0x86,

  223.     0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0a, 0x30, 0x05, 0xa2, 0x03, 0x02,

  224.     0x01, 0x6a, 0x03, 0x81, 0x81, 0x00, 0x49, 0x4c, 0xb6, 0x45, 0x97, 0x20,

  225.     0x35, 0xb3, 0x50, 0x64, 0x0d, 0x3f, 0xec, 0x5f, 0x95, 0xd5, 0x84, 0xcb,

  226.     0x11, 0x7c, 0x03, 0xd7, 0xa6, 0xe6, 0xfa, 0x24, 0x95, 0x9f, 0x31, 0xb0,

  227.     0xb5, 0xec, 0x66, 0x41, 0x51, 0x18, 0x21, 0x91, 0xbb, 0xe0, 0xaf, 0xf0,

  228.     0xc5, 0xb7, 0x59, 0x41, 0xd4, 0xdb, 0xa4, 0xd2, 0x64, 0xa7, 0x54, 0x0f,

  229.     0x8c, 0xf7, 0xe1, 0xd3, 0x3b, 0x1a, 0xb7, 0x0e, 0x9d, 0x9a, 0xde, 0x50,

  230.     0xa1, 0x9f, 0x0a, 0xf0, 0xda, 0x34, 0x0e, 0x34, 0x7d, 0x76, 0x07, 0xfe,

  231.     0x5a, 0xfb, 0xf9, 0x58, 0x9b, 0xc9, 0x50, 0x84, 0x01, 0xa0, 0x05, 0x4d,

  232.     0x67, 0x42, 0x0b, 0xf8, 0xe4, 0x05, 0xcf, 0xaf, 0x8b, 0x71, 0x31, 0xf1,

  233.     0x0f, 0x6e, 0xc9, 0x24, 0x27, 0x9b, 0xac, 0x04, 0xd7, 0x64, 0x0d, 0x30,

  234.     0x4e, 0x11, 0x93, 0x40, 0x39, 0xbb, 0x72, 0xb2, 0xfe, 0x6b, 0xe4, 0xae,

  235.     0x8c, 0x16,

  236. };

  237. 

  238. // kBadPSSCert is an example RSA-PSS certificate with bad parameters.

  239. static const uint8_t kBadPSSCert[] = {

  240.     0x30, 0x82, 0x03, 0x76, 0x30, 0x82, 0x02, 0x3a, 0xa0, 0x03, 0x02, 0x01,

  241.     0x02, 0x02, 0x09, 0x00, 0xd7, 0x30, 0x64, 0xbc, 0x9f, 0x12, 0xfe, 0xc3,

  242.     0x30, 0x3e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,

  243.     0x0a, 0x30, 0x31, 0xa0, 0x0d, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48,

  244.     0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0xa1, 0x1a, 0x30, 0x18, 0x06, 0x09,

  245.     0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x08, 0x30, 0x0b, 0x06,

  246.     0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0xa2, 0x04,

  247.     0x02, 0x02, 0x00, 0xde, 0x30, 0x27, 0x31, 0x25, 0x30, 0x23, 0x06, 0x03,

  248.     0x55, 0x04, 0x03, 0x0c, 0x1c, 0x54, 0x65, 0x73, 0x74, 0x20, 0x49, 0x6e,

  249.     0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x50, 0x53, 0x53, 0x20, 0x63, 0x65,

  250.     0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x30, 0x1e, 0x17,

  251.     0x0d, 0x31, 0x35, 0x31, 0x31, 0x30, 0x34, 0x31, 0x36, 0x30, 0x32, 0x33,

  252.     0x35, 0x5a, 0x17, 0x0d, 0x31, 0x35, 0x31, 0x32, 0x30, 0x34, 0x31, 0x36,

  253.     0x30, 0x32, 0x33, 0x35, 0x5a, 0x30, 0x27, 0x31, 0x25, 0x30, 0x23, 0x06,

  254.     0x03, 0x55, 0x04, 0x03, 0x0c, 0x1c, 0x54, 0x65, 0x73, 0x74, 0x20, 0x49,

  255.     0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x50, 0x53, 0x53, 0x20, 0x63,

  256.     0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x30, 0x82,

  257.     0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,

  258.     0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82,

  259.     0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xc4, 0xda, 0x33, 0xb5, 0x87,

  260.     0xa9, 0x50, 0x80, 0x18, 0x02, 0x00, 0xfb, 0x32, 0xf5, 0x29, 0x6b, 0xef,

  261.     0x01, 0x24, 0xeb, 0x86, 0x5a, 0xbe, 0xd5, 0xe3, 0xdd, 0x3b, 0xbc, 0x2c,

  262.     0xad, 0x65, 0xf6, 0x2a, 0x26, 0x28, 0x4d, 0x8a, 0xc9, 0x61, 0x39, 0xf1,

  263.     0x84, 0xb9, 0xe7, 0xd3, 0x0a, 0xc7, 0xa8, 0x0a, 0x6d, 0xef, 0xd9, 0xcb,

  264.     0x20, 0x11, 0xbb, 0x71, 0xf4, 0xa1, 0xc9, 0x9a, 0x85, 0x1c, 0xe6, 0x3f,

  265.     0x23, 0x39, 0x58, 0x3c, 0xc5, 0x6d, 0xfa, 0x03, 0xe8, 0xdb, 0xdd, 0xe0,

  266.     0xc3, 0xde, 0x85, 0x76, 0xce, 0x49, 0x06, 0xc8, 0xe1, 0x8e, 0x4c, 0x86,

  267.     0x9c, 0xec, 0xab, 0xf4, 0xe5, 0x27, 0xb4, 0x5a, 0xaf, 0xc4, 0x36, 0xd3,

  268.     0x20, 0x81, 0x54, 0xee, 0x8f, 0x48, 0x77, 0x10, 0xf8, 0x79, 0xd6, 0xaa,

  269.     0x8d, 0x1b, 0xfe, 0x7d, 0xe8, 0x15, 0x13, 0xe0, 0x7b, 0xf6, 0x90, 0xe4,

  270.     0xe2, 0xcd, 0x2e, 0x8e, 0xc9, 0x3a, 0x75, 0x42, 0xed, 0x0a, 0x0f, 0x51,

  271.     0xb2, 0xdd, 0x2e, 0x70, 0x61, 0x68, 0xd7, 0xd9, 0xab, 0xf9, 0xbe, 0xe4,

  272.     0x75, 0xb7, 0xe7, 0xf2, 0x96, 0x7b, 0xd9, 0x93, 0x43, 0x24, 0xfb, 0x9e,

  273.     0x55, 0xda, 0xd4, 0x01, 0x6c, 0x3d, 0xa2, 0x59, 0x7a, 0xd5, 0x47, 0x18,

  274.     0x7e, 0x4e, 0xf9, 0x5d, 0xda, 0xcb, 0x93, 0xa2, 0x65, 0x2f, 0x8d, 0x46,

  275.     0xad, 0x81, 0xdc, 0xf0, 0xa9, 0x5f, 0x5d, 0xfe, 0x37, 0x80, 0x64, 0x2a,

  276.     0x41, 0xfa, 0xe9, 0x1e, 0x48, 0x38, 0x22, 0x1d, 0x9c, 0x23, 0xa5, 0xad,

  277.     0xda, 0x78, 0x45, 0x18, 0x0c, 0xeb, 0x95, 0xca, 0x2b, 0xcc, 0xb9, 0x62,

  278.     0x40, 0x85, 0x09, 0x44, 0x88, 0x4c, 0xf2, 0x1e, 0x08, 0x80, 0x37, 0xe9,

  279.     0x06, 0x96, 0x8f, 0x75, 0x54, 0x0b, 0xa9, 0x2d, 0xa9, 0x15, 0xb5, 0xda,

  280.     0xe5, 0xe4, 0x23, 0xaa, 0x2c, 0x89, 0xc1, 0xa9, 0x36, 0xbc, 0x9f, 0x02,

  281.     0x03, 0x01, 0x00, 0x01, 0xa3, 0x50, 0x30, 0x4e, 0x30, 0x1d, 0x06, 0x03,

  282.     0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x2b, 0x75, 0xf3, 0x43, 0x78,

  283.     0xa0, 0x65, 0x2d, 0xe4, 0xb6, 0xf3, 0x07, 0x04, 0x38, 0x21, 0xaf, 0xb6,

  284.     0xe1, 0x5f, 0x7b, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18,

  285.     0x30, 0x16, 0x80, 0x14, 0x2b, 0x75, 0xf3, 0x43, 0x78, 0xa0, 0x65, 0x2d,

  286.     0xe4, 0xb6, 0xf3, 0x07, 0x04, 0x38, 0x21, 0xaf, 0xb6, 0xe1, 0x5f, 0x7b,

  287.     0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01,

  288.     0x01, 0xff, 0x30, 0x31, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,

  289.     0x01, 0x01, 0x0a, 0x30, 0x24, 0xa0, 0x0d, 0x30, 0x0b, 0x06, 0x09, 0x60,

  290.     0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0xa1, 0x0d, 0x30, 0x0b,

  291.     0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x08, 0xa2,

  292.     0x04, 0x02, 0x02, 0x00, 0xde, 0x03, 0x82, 0x01, 0x01, 0x00, 0x08, 0xc1,

  293.     0xb6, 0x6f, 0x74, 0x94, 0x6c, 0x60, 0x75, 0xd8, 0xdc, 0xe1, 0x7b, 0xbf,

  294.     0x9d, 0xb5, 0xd7, 0x14, 0x75, 0x6c, 0xdb, 0x35, 0x5c, 0x1e, 0xff, 0xe6,

  295.     0xa8, 0xe6, 0x68, 0x42, 0x41, 0x81, 0xf6, 0xbf, 0xc1, 0x56, 0x02, 0xdb,

  296.     0xc6, 0x11, 0xeb, 0x15, 0x9d, 0xa9, 0x1c, 0x61, 0x25, 0x6d, 0x46, 0x0f,

  297.     0x7e, 0x27, 0xdd, 0x4b, 0xdc, 0xed, 0x07, 0xbd, 0xde, 0xd5, 0xde, 0x09,

  298.     0xf8, 0xfd, 0xbd, 0xa3, 0x4c, 0x81, 0xa9, 0xf7, 0x78, 0xff, 0x01, 0x80,

  299.     0x73, 0xf2, 0x40, 0xf2, 0xa8, 0x27, 0xe8, 0x00, 0x04, 0x3b, 0xf5, 0xe7,

  300.     0xa6, 0x58, 0x45, 0x79, 0x34, 0x49, 0x42, 0xd2, 0xd9, 0x56, 0x5e, 0xf9,

  301.     0x0a, 0x41, 0xd7, 0x81, 0x41, 0x94, 0x77, 0x78, 0x7e, 0x00, 0x3b, 0xca,

  302.     0xb5, 0xc0, 0x6e, 0x5b, 0xd7, 0x52, 0x52, 0x77, 0x1a, 0x52, 0xb8, 0x0d,

  303.     0x29, 0x1f, 0x2e, 0xfe, 0x1f, 0xf6, 0xb0, 0xc1, 0xb7, 0xf1, 0x15, 0x98,

  304.     0x0f, 0x30, 0x5d, 0x74, 0x2f, 0xfa, 0xe9, 0x84, 0xda, 0xde, 0xbe, 0xca,

  305.     0x91, 0x55, 0x1f, 0x5b, 0xbc, 0xaa, 0x45, 0x07, 0xc4, 0x2e, 0x21, 0x8a,

  306.     0x75, 0xc9, 0xbe, 0x6e, 0x39, 0x53, 0x10, 0xcb, 0x2f, 0x4b, 0xe1, 0x21,

  307.     0x1e, 0xea, 0x7d, 0x0b, 0x36, 0xe9, 0xa0, 0x2c, 0x76, 0x17, 0x1f, 0x69,

  308.     0x34, 0xfb, 0x45, 0x63, 0x7c, 0x84, 0x39, 0xb4, 0x21, 0x98, 0xbd, 0x49,

  309.     0xca, 0x80, 0x91, 0x5a, 0xa0, 0x44, 0xef, 0x91, 0xb3, 0x14, 0xf6, 0xd1,

  310.     0x6a, 0x2b, 0xb1, 0xe5, 0x4a, 0x44, 0x92, 0x7b, 0x3e, 0x8b, 0x7b, 0x6b,

  311.     0x90, 0x6b, 0x2c, 0x67, 0x3b, 0x0e, 0xb9, 0x5a, 0x87, 0x35, 0x33, 0x59,

  312.     0x94, 0x2f, 0x7e, 0xf6, 0x13, 0xc7, 0x22, 0x87, 0x3d, 0x50, 0xc9, 0x80,

  313.     0x40, 0xda, 0x35, 0xbc, 0x62, 0x16, 0xdc, 0xd5, 0x95, 0xa1, 0xe1, 0x9b,

  314.     0x68, 0x9f,

  315. };

  316. 

  317. // kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8

  318. // PrivateKeyInfo.

  319. static const uint8_t kExampleRSAKeyPKCS8[] = {

  320.     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,

  321.     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,

  322.     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,

  323.     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,

  324.     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,

  325.     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,

  326.     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,

  327.     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,

  328.     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,

  329.     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,

  330.     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,

  331.     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,

  332.     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,

  333.     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,

  334.     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,

  335.     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,

  336.     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,

  337.     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,

  338.     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,

  339.     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,

  340.     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,

  341.     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,

  342.     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,

  343.     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,

  344.     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,

  345.     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,

  346.     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,

  347.     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,

  348.     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,

  349.     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,

  350.     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,

  351.     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,

  352.     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,

  353.     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,

  354.     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,

  355.     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,

  356.     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,

  357.     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,

  358.     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,

  359.     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,

  360.     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,

  361.     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,

  362.     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,

  363.     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,

  364.     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,

  365.     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,

  366.     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,

  367.     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,

  368.     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,

  369.     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,

  370.     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,

  371.     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,

  372.     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,

  373. };

  374. 

  375. // kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey

  376. // structure.

  377. static const uint8_t kExampleECKeyDER[] = {

  378.     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,

  379.     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,

  380.     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,

  381.     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,

  382.     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,

  383.     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,

  384.     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,

  385.     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,

  386.     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,

  387.     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,

  388.     0xc1,

  389. };

  390. 

  391. // kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey

  392. // structure. The private key is equal to the order and will fail to import.

  393. static const uint8_t kExampleBadECKeyDER[] = {

  394.     0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,

  395.     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,

  396.     0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,

  397.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  398.     0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,

  399.     0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,

  400.     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,

  401.     0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,

  402.     0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51

  403. };

  404. 

  405. // kExampleBadECKeyDER2 is a sample EC private key encoded as an ECPrivateKey

  406. // structure, but with the curve OID swapped out for 1.1.1.1.1.1.1.1.1. It is

  407. // then concatenated with an ECPrivateKey wrapped in a PrivateKeyInfo,

  408. // optional public key omitted, and with the private key chopped off.

  409. static const uint8_t kExampleBadECKeyDER2[] = {

  410.     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,

  411.     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,

  412.     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,

  413.     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x29, 0x01, 0x01, 0x01, 0x01,

  414.     0x01, 0x01, 0x01, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,

  415.     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,

  416.     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,

  417.     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,

  418.     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,

  419.     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,

  420.     0xc1, 0x30, 0x41, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,

  421.     0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,

  422.     0x03, 0x01, 0x07, 0x04, 0x27, 0x30, 0x25, 0x02, 0x01, 0x01, 0x04, 0x20,

  423.     0x07,

  424. };

  425. 

  426. // kInvalidPrivateKey is an invalid private key. See

  427. // https://rt.openssl.org/Ticket/Display.html?id=4131.

  428. static const uint8_t kInvalidPrivateKey[] = {

  429.     0x30, 0x39, 0x02, 0x01, 0x02, 0x30, 0x09, 0x06, 0x01, 0x38, 0x08,

  430.     0x04, 0x69, 0x30, 0x30, 0x80, 0x30, 0x19, 0x01, 0x02, 0x9f, 0xf8,

  431.     0x8b, 0x29, 0x80, 0x30, 0xb0, 0x1b, 0x06, 0x09, 0x22, 0xbe, 0x08,

  432.     0x04, 0xe9, 0x30, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x3a, 0x01, 0x80,

  433.     0x09, 0x30, 0x80, 0x06, 0x01, 0x02, 0x30, 0x80, 0x30, 0x01, 0x3b,

  434.     0x02, 0x00, 0x00, 0x04, 0x20, 0x30, 0x82, 0x04, 0xe9, 0x30, 0xc3,

  435.     0xe8, 0x30, 0x01, 0x05, 0x30, 0x80, 0x30, 0x01, 0x3b, 0x01, 0x04,

  436.     0x02, 0x02, 0xff, 0x00, 0x30, 0x29, 0x02, 0x11, 0x03, 0x29, 0x29,

  437.     0x02, 0x00, 0x99, 0x30, 0x80, 0x06, 0x21, 0x02, 0x24, 0x04, 0xe8,

  438.     0x30, 0x01, 0x01, 0x04, 0x30, 0x80, 0x1b, 0x06, 0x09, 0x2a, 0x86,

  439.     0x48, 0x30, 0x01, 0xaa, 0x02, 0x86, 0xc0, 0x30, 0xdf, 0xe9, 0x80,

  440. };

  441. 

  442. static ScopedEVP_PKEY LoadExampleRSAKey() {

  443.   ScopedRSA rsa(RSA_private_key_from_bytes(kExampleRSAKeyDER,

  444.                                            sizeof(kExampleRSAKeyDER)));

  445.   if (!rsa) {

  446.     return nullptr;

  447.   }

  448.   ScopedEVP_PKEY pkey(EVP_PKEY_new());

  449.   if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get())) {

  450.     return nullptr;

  451.   }

  452.   return pkey;

  453. }

  454. 

  455. static bool TestEVP_DigestSignInit(void) {

  456.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  457.   ScopedEVP_MD_CTX md_ctx;

  458.   if (!pkey ||

  459.       !EVP_DigestSignInit(md_ctx.get(), NULL, EVP_sha256(), NULL, pkey.get()) ||

  460.       !EVP_DigestSignUpdate(md_ctx.get(), kMsg, sizeof(kMsg))) {

  461.     return false;

  462.   }

  463.   // Determine the size of the signature.

  464.   size_t sig_len = 0;

  465.   if (!EVP_DigestSignFinal(md_ctx.get(), NULL, &sig_len)) {

  466.     return false;

  467.   }

  468.   // Sanity check for testing.

  469.   if (sig_len != (size_t)EVP_PKEY_size(pkey.get())) {

  470.     fprintf(stderr, "sig_len mismatch\n");

  471.     return false;

  472.   }

  473. 

  474.   std::vector<uint8_t> sig;

  475.   sig.resize(sig_len);

  476.   if (!EVP_DigestSignFinal(md_ctx.get(), sig.data(), &sig_len)) {

  477.     return false;

  478.   }

  479.   sig.resize(sig_len);

  480. 

  481.   // Ensure that the signature round-trips.

  482.   md_ctx.Reset();

  483.   if (!EVP_DigestVerifyInit(md_ctx.get(), NULL, EVP_sha256(), NULL,

  484.                             pkey.get()) ||

  485.       !EVP_DigestVerifyUpdate(md_ctx.get(), kMsg, sizeof(kMsg)) ||

  486.       !EVP_DigestVerifyFinal(md_ctx.get(), sig.data(), sig_len)) {

  487.     return false;

  488.   }

  489. 

  490.   return true;

  491. }

  492. 

  493. static bool TestEVP_DigestVerifyInit(void) {

  494.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  495.   ScopedEVP_MD_CTX md_ctx;

  496.   if (!pkey ||

  497.       !EVP_DigestVerifyInit(md_ctx.get(), NULL, EVP_sha256(), NULL,

  498.                             pkey.get()) ||

  499.       !EVP_DigestVerifyUpdate(md_ctx.get(), kMsg, sizeof(kMsg)) ||

  500.       !EVP_DigestVerifyFinal(md_ctx.get(), kSignature, sizeof(kSignature))) {

  501.     return false;

  502.   }

  503.   return true;

  504. }

  505. 

  506. // TestAlgorithmRoundtrip signs a message using an already-initialized

  507. // |md_ctx|, sampling the AlgorithmIdentifier. It then uses |pkey| and the

  508. // AlgorithmIdentifier to verify the signature.

  509. static bool TestAlgorithmRoundtrip(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) {

  510.   if (!EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {

  511.     return false;

  512.   }

  513. 

  514.   // Save the algorithm.

  515.   ScopedX509_ALGOR algor(X509_ALGOR_new());

  516.   if (!algor || !EVP_DigestSignAlgorithm(md_ctx, algor.get())) {

  517.     return false;

  518.   }

  519. 

  520.   // Determine the size of the signature.

  521.   size_t sig_len = 0;

  522.   if (!EVP_DigestSignFinal(md_ctx, NULL, &sig_len)) {

  523.     return false;

  524.   }

  525.   // Sanity check for testing.

  526.   if (sig_len != (size_t)EVP_PKEY_size(pkey)) {

  527.     fprintf(stderr, "sig_len mismatch\n");

  528.     return false;

  529.   }

  530. 

  531.   std::vector<uint8_t> sig;

  532.   sig.resize(sig_len);

  533.   if (!EVP_DigestSignFinal(md_ctx, sig.data(), &sig_len)) {

  534.     return false;

  535.   }

  536.   sig.resize(sig_len);

  537. 

  538.   // Ensure that the signature round-trips.

  539.   ScopedEVP_MD_CTX md_ctx_verify;

  540.   if (!EVP_DigestVerifyInitFromAlgorithm(md_ctx_verify.get(), algor.get(),

  541.                                          pkey) ||

  542.       !EVP_DigestVerifyUpdate(md_ctx_verify.get(), kMsg, sizeof(kMsg)) ||

  543.       !EVP_DigestVerifyFinal(md_ctx_verify.get(), sig.data(), sig_len)) {

  544.     return false;

  545.   }

  546. 

  547.   return true;

  548. }

  549. 

  550. static bool TestEVP_DigestSignAlgorithm(void) {

  551.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  552. 

  553.   // Test a simple AlgorithmIdentifier.

  554.   ScopedEVP_MD_CTX md_ctx;

  555.   if (!pkey ||

  556.       !EVP_DigestSignInit(md_ctx.get(), NULL, EVP_sha256(), NULL, pkey.get()) ||

  557.       !TestAlgorithmRoundtrip(md_ctx.get(), pkey.get())) {

  558.     fprintf(stderr, "RSA with SHA-256 failed\n");

  559.     return false;

  560.   }

  561. 

  562.   // Test RSA-PSS with custom parameters.

  563.   md_ctx.Reset();

  564.   EVP_PKEY_CTX *pkey_ctx;

  565.   if (!EVP_DigestSignInit(md_ctx.get(), &pkey_ctx, EVP_sha256(), NULL,

  566.                           pkey.get()) ||

  567.       !EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) ||

  568.       !EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, EVP_sha512()) ||

  569.       !TestAlgorithmRoundtrip(md_ctx.get(), pkey.get())) {

  570.     fprintf(stderr, "RSA-PSS failed\n");

  571.     return false;

  572.   }

  573. 

  574.   return true;

  575. }

  576. 

  577. static bool ParseCertificate(CBS *out_tbs_cert,

  578.                              ScopedEVP_PKEY *out_pubkey,

  579.                              ScopedX509_ALGOR *out_algor,

  580.                              CBS *out_signature,

  581.                              const CBS *in_) {

  582.   CBS in = *in_;

  583.   CBS cert_body, tbs_cert, algorithm, signature;

  584.   if (!CBS_get_asn1(&in, &cert_body, CBS_ASN1_SEQUENCE) ||

  585.       CBS_len(&in) != 0 ||

  586.       !CBS_get_any_asn1_element(&cert_body, &tbs_cert, NULL, NULL) ||

  587.       !CBS_get_asn1_element(&cert_body, &algorithm, CBS_ASN1_SEQUENCE) ||

  588.       !CBS_get_asn1(&cert_body, &signature, CBS_ASN1_BITSTRING) ||

  589.       CBS_len(&cert_body) != 0) {

  590.     return false;

  591.   }

  592. 

  593.   CBS tbs_cert_copy = tbs_cert;

  594.   CBS tbs_cert_body, discard, spki;

  595.   if (!CBS_get_asn1(&tbs_cert_copy, &tbs_cert_body, CBS_ASN1_SEQUENCE) ||

  596.       CBS_len(&tbs_cert_copy) != 0 ||

  597.       !CBS_get_optional_asn1(

  598.           &tbs_cert_body, &discard, NULL,

  599.           CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 0) ||

  600.       !CBS_get_asn1(&tbs_cert_body, &discard /* serialNumber */,

  601.                     CBS_ASN1_INTEGER) ||

  602.       !CBS_get_asn1(&tbs_cert_body, &discard /* signature */,

  603.                     CBS_ASN1_SEQUENCE) ||

  604.       !CBS_get_any_asn1_element(&tbs_cert_body, &discard /* issuer */,

  605.                                 NULL, NULL) ||

  606.       !CBS_get_asn1(&tbs_cert_body, &discard /* validity */,

  607.                     CBS_ASN1_SEQUENCE) ||

  608.       !CBS_get_any_asn1_element(&tbs_cert_body, &discard /* subject */,

  609.                                 NULL, NULL) ||

  610.       !CBS_get_asn1_element(&tbs_cert_body, &spki, CBS_ASN1_SEQUENCE)) {

  611.     return false;

  612.   }

  613. 

  614.   const uint8_t *derp = CBS_data(&spki);

  615.   ScopedEVP_PKEY pubkey(d2i_PUBKEY(NULL, &derp, CBS_len(&spki)));

  616.   if (!pubkey || derp != CBS_data(&spki) + CBS_len(&spki)) {

  617.     return false;

  618.   }

  619. 

  620.   derp = CBS_data(&algorithm);

  621.   ScopedX509_ALGOR algor(d2i_X509_ALGOR(NULL, &derp, CBS_len(&algorithm)));

  622.   if (!algor || derp != CBS_data(&algorithm) + CBS_len(&algorithm)) {

  623.     return false;

  624.   }

  625. 

  626.   // Signatures are BIT STRINGs, but they have are multiple of 8 bytes, so the

  627.   // leading phase byte is just a zero.

  628.   uint8_t padding;

  629.   if (!CBS_get_u8(&signature, &padding) || padding != 0) {

  630.     return false;

  631.   }

  632. 

  633.   *out_tbs_cert = tbs_cert;

  634.   *out_pubkey = std::move(pubkey);

  635.   *out_algor = std::move(algor);

  636.   *out_signature = signature;

  637.   return true;

  638. }

  639. 

  640. static bool TestEVP_DigestVerifyInitFromAlgorithm(void) {

  641.   CBS in, tbs_cert, signature;

  642.   ScopedEVP_PKEY pkey;

  643.   ScopedX509_ALGOR algor;

  644.   CBS_init(&in, kExamplePSSCert, sizeof(kExamplePSSCert));

  645.   if (!ParseCertificate(&tbs_cert, &pkey, &algor, &signature, &in)) {

  646.     fprintf(stderr, "Failed to parse certificate\n");

  647.     return false;

  648.   }

  649. 

  650.   ScopedEVP_MD_CTX md_ctx;

  651.   if (!EVP_DigestVerifyInitFromAlgorithm(md_ctx.get(), algor.get(),

  652.                                          pkey.get()) ||

  653.       !EVP_DigestVerifyUpdate(md_ctx.get(), CBS_data(&tbs_cert),

  654.                               CBS_len(&tbs_cert)) ||

  655.       !EVP_DigestVerifyFinal(md_ctx.get(), CBS_data(&signature),

  656.                              CBS_len(&signature))) {

  657.     return false;

  658.   }

  659.   return true;

  660. }

  661. 

  662. static bool TestVerifyRecover() {

  663.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  664.   if (!pkey) {

  665.     return false;

  666.   }

  667. 

  668.   ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey.get()));

  669.   if (!rsa) {

  670.     return false;

  671.   }

  672. 

  673.   const uint8_t kDummyHash[32] = {0};

  674.   uint8_t sig[2048/8];

  675.   unsigned sig_len = sizeof(sig);

  676. 

  677.   if (!RSA_sign(NID_sha256, kDummyHash, sizeof(kDummyHash), sig, &sig_len,

  678.                 rsa.get())) {

  679.     fprintf(stderr, "RSA_sign failed.\n");

  680.     ERR_print_errors_fp(stderr);

  681.     return false;

  682.   }

  683. 

  684.   size_t out_len;

  685.   ScopedEVP_PKEY_CTX ctx(EVP_PKEY_CTX_new(pkey.get(), nullptr));

  686.   if (!EVP_PKEY_verify_recover_init(ctx.get()) ||

  687.       !EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PADDING) ||

  688.       !EVP_PKEY_CTX_set_signature_md(ctx.get(), EVP_sha256()) ||

  689.       !EVP_PKEY_verify_recover(ctx.get(), nullptr, &out_len, sig, sig_len)) {

  690.     fprintf(stderr, "verify_recover failed will nullptr buffer.\n");

  691.     ERR_print_errors_fp(stderr);

  692.     return false;

  693.   }

  694. 

  695.   std::vector<uint8_t> recovered;

  696.   recovered.resize(out_len);

  697. 

  698.   if (!EVP_PKEY_verify_recover(ctx.get(), recovered.data(), &out_len, sig,

  699.                                sig_len)) {

  700.     fprintf(stderr, "verify_recover failed.\n");

  701.     ERR_print_errors_fp(stderr);

  702.     return false;

  703.   }

  704. 

  705.   if (out_len != sizeof(kDummyHash)) {

  706.     fprintf(stderr, "verify_recover length is %u, expected %u.\n",

  707.             static_cast<unsigned>(out_len),

  708.             static_cast<unsigned>(sizeof(kDummyHash)));

  709.     return false;

  710.   }

  711. 

  712.   if (memcmp(recovered.data(), kDummyHash, sizeof(kDummyHash)) != 0) {

  713.     fprintf(stderr, "verify_recover got wrong value.\n");

  714.     ERR_print_errors_fp(stderr);

  715.     return false;

  716.   }

  717. 

  718.   out_len = recovered.size();

  719.   if (!EVP_PKEY_CTX_set_signature_md(ctx.get(), nullptr) ||

  720.       !EVP_PKEY_verify_recover(ctx.get(), recovered.data(), &out_len, sig,

  721.                                sig_len)) {

  722.     fprintf(stderr, "verify_recover failed with NULL MD.\n");

  723.     ERR_print_errors_fp(stderr);

  724.     return false;

  725.   }

  726. 

  727.   /* The size of a SHA-256 hash plus PKCS#1 v1.5 ASN.1 stuff happens to be 51

  728.    * bytes. */

  729.   static const size_t kExpectedASN1Size = 51;

  730.   if (out_len != kExpectedASN1Size) {

  731.     fprintf(stderr, "verify_recover length without MD is %u, expected %u.\n",

  732.             static_cast<unsigned>(out_len),

  733.             static_cast<unsigned>(kExpectedASN1Size));

  734.     return false;

  735.   }

  736. 

  737.   return true;

  738. }

  739. 

  740. static bool TestBadPSSParameters(void) {

  741.   CBS in, tbs_cert, signature;

  742.   ScopedEVP_PKEY pkey;

  743.   ScopedX509_ALGOR algor;

  744.   CBS_init(&in, kBadPSSCert, sizeof(kBadPSSCert));

  745.   if (!ParseCertificate(&tbs_cert, &pkey, &algor, &signature, &in)) {

  746.     fprintf(stderr, "Failed to parse certificate\n");

  747.     return false;

  748.   }

  749. 

  750.   ScopedEVP_MD_CTX md_ctx;

  751.   if (EVP_DigestVerifyInitFromAlgorithm(md_ctx.get(), algor.get(),

  752.                                         pkey.get())) {

  753.     fprintf(stderr, "Unexpectedly processed bad signature parameters\n");

  754.     return false;

  755.   }

  756.   ERR_clear_error();

  757.   return true;

  758. }

  759. 

  760. static bool TestValidPrivateKey(const uint8_t *input, size_t input_len,

  761.                                 int expected_id) {

  762.   const uint8_t *p = input;

  763.   ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, input_len));

  764.   if (!pkey || p != input + input_len) {

  765.     fprintf(stderr, "d2i_AutoPrivateKey failed\n");

  766.     return false;

  767.   }

  768. 

  769.   if (EVP_PKEY_id(pkey.get()) != expected_id) {

  770.     fprintf(stderr, "Did not decode expected type\n");

  771.     return false;

  772.   }

  773. 

  774.   return true;

  775. }

  776. 

  777. static bool Testd2i_AutoPrivateKey() {

  778.   if (!TestValidPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),

  779.                            EVP_PKEY_RSA)) {

  780.     fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");

  781.     return false;

  782.   }

  783. 

  784.   if (!TestValidPrivateKey(kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8),

  785.                            EVP_PKEY_RSA)) {

  786.     fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");

  787.     return false;

  788.   }

  789. 

  790.   if (!TestValidPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),

  791.                            EVP_PKEY_EC)) {

  792.     fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");

  793.     return false;

  794.   }

  795. 

  796.   if (!TestValidPrivateKey(kExampleDSAKeyDER, sizeof(kExampleDSAKeyDER),

  797.                            EVP_PKEY_DSA)) {

  798.     fprintf(stderr, "d2i_AutoPrivateKey(kExampleDSAKeyDER) failed\n");

  799.     return false;

  800.   }

  801. 

  802.   const uint8_t *p = kInvalidPrivateKey;

  803.   ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, sizeof(kInvalidPrivateKey)));

  804.   if (pkey) {

  805.     fprintf(stderr, "Parsed invalid private key\n");

  806.     return false;

  807.   }

  808.   ERR_clear_error();

  809. 

  810.   return true;

  811. }

  812. 

  813. // TestEVP_PKCS82PKEY tests loading a bad key in PKCS8 format.

  814. static bool TestEVP_PKCS82PKEY(void) {

  815.   const uint8_t *derp = kExampleBadECKeyDER;

  816.   ScopedPKCS8_PRIV_KEY_INFO p8inf(

  817.       d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER)));

  818.   if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {

  819.     fprintf(stderr, "Failed to parse key\n");

  820.     return false;

  821.   }

  822. 

  823.   ScopedEVP_PKEY pkey(EVP_PKCS82PKEY(p8inf.get()));

  824.   if (pkey) {

  825.     fprintf(stderr, "Imported invalid EC key\n");

  826.     return false;

  827.   }

  828.   ERR_clear_error();

  829. 

  830.   return true;

  831. }

  832. 

  833. // Testd2i_PrivateKey tests |d2i_PrivateKey|.

  834. static bool Testd2i_PrivateKey(void) {

  835.   const uint8_t *derp = kExampleRSAKeyDER;

  836.   ScopedEVP_PKEY pkey(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &derp,

  837.                                      sizeof(kExampleRSAKeyDER)));

  838.   if (!pkey || derp != kExampleRSAKeyDER + sizeof(kExampleRSAKeyDER)) {

  839.     fprintf(stderr, "Failed to import raw RSA key.\n");

  840.     return false;

  841.   }

  842. 

  843.   derp = kExampleDSAKeyDER;

  844.   pkey.reset(d2i_PrivateKey(EVP_PKEY_DSA, nullptr, &derp,

  845.              sizeof(kExampleDSAKeyDER)));

  846.   if (!pkey || derp != kExampleDSAKeyDER + sizeof(kExampleDSAKeyDER)) {

  847.     fprintf(stderr, "Failed to import raw DSA key.\n");

  848.     return false;

  849.   }

  850. 

  851.   derp = kExampleRSAKeyPKCS8;

  852.   pkey.reset(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &derp,

  853.              sizeof(kExampleRSAKeyPKCS8)));

  854.   if (!pkey || derp != kExampleRSAKeyPKCS8 + sizeof(kExampleRSAKeyPKCS8)) {

  855.     fprintf(stderr, "Failed to import PKCS#8 RSA key.\n");

  856.     return false;

  857.   }

  858. 

  859.   derp = kExampleECKeyDER;

  860.   pkey.reset(d2i_PrivateKey(EVP_PKEY_EC, nullptr, &derp,

  861.              sizeof(kExampleECKeyDER)));

  862.   if (!pkey || derp != kExampleECKeyDER + sizeof(kExampleECKeyDER)) {

  863.     fprintf(stderr, "Failed to import raw EC key.\n");

  864.     return false;

  865.   }

  866. 

  867.   derp = kExampleBadECKeyDER;

  868.   pkey.reset(d2i_PrivateKey(EVP_PKEY_EC, nullptr, &derp,

  869.              sizeof(kExampleBadECKeyDER)));

  870.   if (pkey) {

  871.     fprintf(stderr, "Imported invalid EC key.\n");

  872.     return false;

  873.   }

  874.   ERR_clear_error();

  875. 

  876.   // Copy the input into a |malloc|'d vector to flag memory errors.

  877.   std::vector<uint8_t> copy(kExampleBadECKeyDER2, kExampleBadECKeyDER2 +

  878.                                                   sizeof(kExampleBadECKeyDER2));

  879.   derp = copy.data();

  880.   pkey.reset(d2i_PrivateKey(EVP_PKEY_EC, nullptr, &derp, copy.size()));

  881.   if (pkey) {

  882.     fprintf(stderr, "Imported invalid EC key #2.\n");

  883.     return false;

  884.   }

  885.   ERR_clear_error();

  886. 

  887.   return true;

  888. }

  889. 

  890. int main(void) {

  891.   CRYPTO_library_init();

  892. 

  893.   if (!TestEVP_DigestSignInit()) {

  894.     fprintf(stderr, "EVP_DigestSignInit failed\n");

  895.     ERR_print_errors_fp(stderr);

  896.     return 1;

  897.   }

  898. 

  899.   if (!TestEVP_DigestVerifyInit()) {

  900.     fprintf(stderr, "EVP_DigestVerifyInit failed\n");

  901.     ERR_print_errors_fp(stderr);

  902.     return 1;

  903.   }

  904. 

  905.   if (!TestEVP_DigestSignAlgorithm()) {

  906.     fprintf(stderr, "EVP_DigestSignInit failed\n");

  907.     ERR_print_errors_fp(stderr);

  908.     return 1;

  909.   }

  910. 

  911.   if (!TestEVP_DigestVerifyInitFromAlgorithm()) {

  912.     fprintf(stderr, "EVP_DigestVerifyInitFromAlgorithm failed\n");

  913.     ERR_print_errors_fp(stderr);

  914.     return 1;

  915.   }

  916. 

  917.   if (!TestVerifyRecover()) {

  918.     fprintf(stderr, "EVP_PKEY_verify_recover failed\n");

  919.     ERR_print_errors_fp(stderr);

  920.     return 1;

  921.   }

  922. 

  923.   if (!TestBadPSSParameters()) {

  924.     fprintf(stderr, "TestBadPSSParameters failed\n");

  925.     ERR_print_errors_fp(stderr);

  926.     return 1;

  927.   }

  928. 

  929.   if (!Testd2i_AutoPrivateKey()) {

  930.     fprintf(stderr, "Testd2i_AutoPrivateKey failed\n");

  931.     ERR_print_errors_fp(stderr);

  932.     return 1;

  933.   }

  934. 

  935.   if (!TestEVP_PKCS82PKEY()) {

  936.     fprintf(stderr, "TestEVP_PKCS82PKEY failed\n");

  937.     ERR_print_errors_fp(stderr);

  938.     return 1;

  939.   }

  940. 

  941.   if (!Testd2i_PrivateKey()) {

  942.     fprintf(stderr, "Testd2i_PrivateKey failed\n");

  943.     ERR_print_errors_fp(stderr);

  944.     return 1;

  945.   }

  946. 

  947.   printf("PASS\n");

  948.   return 0;

  949. }