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.
2555 Commits
12 Branches
38 MiB
 
 
 
 
 
 
Tree: f01fb5dc0e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f01fb5dc0e'
${ noResults }
boringssl/crypto/evp/evp_extra_test.cc

722 lines
33 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. 

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

  31. 

  32. 

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

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

  35. static const uint8_t kExampleRSAKeyDER[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  87. };

  88. 

  89. static const uint8_t kExampleDSAKeyDER[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  162. };

  163. 

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

  165. 

  166. static const uint8_t kSignature[] = {

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

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

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

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

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

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

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

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

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

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

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

  178. };

  179. 

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

  181. // PrivateKeyInfo.

  182. static const uint8_t kExampleRSAKeyPKCS8[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  236. };

  237. 

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

  239. // structure.

  240. static const uint8_t kExampleECKeyDER[] = {

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

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

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

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

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

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

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

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

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

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

  251.     0xc1,

  252. };

  253. 

  254. // kExampleECKeyPKCS8 is a sample EC private key encoded as a PKCS#8

  255. // PrivateKeyInfo.

  256. static const uint8_t kExampleECKeyPKCS8[] = {

  257.     0x30, 0x81, 0x87, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,

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

  259.     0x03, 0x01, 0x07, 0x04, 0x6d, 0x30, 0x6b, 0x02, 0x01, 0x01, 0x04, 0x20,

  260.     0x43, 0x09, 0xc0, 0x67, 0x75, 0x21, 0x47, 0x9d, 0xa8, 0xfa, 0x16, 0xdf,

  261.     0x15, 0x73, 0x61, 0x34, 0x68, 0x6f, 0xe3, 0x8e, 0x47, 0x91, 0x95, 0xab,

  262.     0x79, 0x4a, 0x72, 0x14, 0xcb, 0xe2, 0x49, 0x4f, 0xa1, 0x44, 0x03, 0x42,

  263.     0x00, 0x04, 0xde, 0x09, 0x08, 0x07, 0x03, 0x2e, 0x8f, 0x37, 0x9a, 0xd5,

  264.     0xad, 0xe5, 0xc6, 0x9d, 0xd4, 0x63, 0xc7, 0x4a, 0xe7, 0x20, 0xcb, 0x90,

  265.     0xa0, 0x1f, 0x18, 0x18, 0x72, 0xb5, 0x21, 0x88, 0x38, 0xc0, 0xdb, 0xba,

  266.     0xf6, 0x99, 0xd8, 0xa5, 0x3b, 0x83, 0xe9, 0xe3, 0xd5, 0x61, 0x99, 0x73,

  267.     0x42, 0xc6, 0x6c, 0xe8, 0x0a, 0x95, 0x40, 0x41, 0x3b, 0x0d, 0x10, 0xa7,

  268.     0x4a, 0x93, 0xdb, 0x5a, 0xe7, 0xec,

  269. };

  270. 

  271. // kExampleECKeySpecifiedCurvePKCS8 is a sample EC private key encoded as a

  272. // PKCS#8 PrivateKeyInfo with P-256's parameters spelled out rather than using

  273. // the curve OID.

  274. static const uint8_t kExampleECKeySpecifiedCurvePKCS8[] = {

  275.     0x30, 0x82, 0x01, 0x79, 0x02, 0x01, 0x00, 0x30, 0x82, 0x01, 0x03, 0x06,

  276.     0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x30, 0x81, 0xf7, 0x02,

  277.     0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01,

  278.     0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01,

  279.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  280.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

  281.     0x30, 0x5b, 0x04, 0x20, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01,

  282.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  283.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc,

  284.     0x04, 0x20, 0x5a, 0xc6, 0x35, 0xd8, 0xaa, 0x3a, 0x93, 0xe7, 0xb3, 0xeb,

  285.     0xbd, 0x55, 0x76, 0x98, 0x86, 0xbc, 0x65, 0x1d, 0x06, 0xb0, 0xcc, 0x53,

  286.     0xb0, 0xf6, 0x3b, 0xce, 0x3c, 0x3e, 0x27, 0xd2, 0x60, 0x4b, 0x03, 0x15,

  287.     0x00, 0xc4, 0x9d, 0x36, 0x08, 0x86, 0xe7, 0x04, 0x93, 0x6a, 0x66, 0x78,

  288.     0xe1, 0x13, 0x9d, 0x26, 0xb7, 0x81, 0x9f, 0x7e, 0x90, 0x04, 0x41, 0x04,

  289.     0x6b, 0x17, 0xd1, 0xf2, 0xe1, 0x2c, 0x42, 0x47, 0xf8, 0xbc, 0xe6, 0xe5,

  290.     0x63, 0xa4, 0x40, 0xf2, 0x77, 0x03, 0x7d, 0x81, 0x2d, 0xeb, 0x33, 0xa0,

  291.     0xf4, 0xa1, 0x39, 0x45, 0xd8, 0x98, 0xc2, 0x96, 0x4f, 0xe3, 0x42, 0xe2,

  292.     0xfe, 0x1a, 0x7f, 0x9b, 0x8e, 0xe7, 0xeb, 0x4a, 0x7c, 0x0f, 0x9e, 0x16,

  293.     0x2b, 0xce, 0x33, 0x57, 0x6b, 0x31, 0x5e, 0xce, 0xcb, 0xb6, 0x40, 0x68,

  294.     0x37, 0xbf, 0x51, 0xf5, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00,

  295.     0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc,

  296.     0xe6, 0xfa, 0xad, 0xa7, 0x17, 0x9e, 0x84, 0xf3, 0xb9, 0xca, 0xc2, 0xfc,

  297.     0x63, 0x25, 0x51, 0x02, 0x01, 0x01, 0x04, 0x6d, 0x30, 0x6b, 0x02, 0x01,

  298.     0x01, 0x04, 0x20, 0x43, 0x09, 0xc0, 0x67, 0x75, 0x21, 0x47, 0x9d, 0xa8,

  299.     0xfa, 0x16, 0xdf, 0x15, 0x73, 0x61, 0x34, 0x68, 0x6f, 0xe3, 0x8e, 0x47,

  300.     0x91, 0x95, 0xab, 0x79, 0x4a, 0x72, 0x14, 0xcb, 0xe2, 0x49, 0x4f, 0xa1,

  301.     0x44, 0x03, 0x42, 0x00, 0x04, 0xde, 0x09, 0x08, 0x07, 0x03, 0x2e, 0x8f,

  302.     0x37, 0x9a, 0xd5, 0xad, 0xe5, 0xc6, 0x9d, 0xd4, 0x63, 0xc7, 0x4a, 0xe7,

  303.     0x20, 0xcb, 0x90, 0xa0, 0x1f, 0x18, 0x18, 0x72, 0xb5, 0x21, 0x88, 0x38,

  304.     0xc0, 0xdb, 0xba, 0xf6, 0x99, 0xd8, 0xa5, 0x3b, 0x83, 0xe9, 0xe3, 0xd5,

  305.     0x61, 0x99, 0x73, 0x42, 0xc6, 0x6c, 0xe8, 0x0a, 0x95, 0x40, 0x41, 0x3b,

  306.     0x0d, 0x10, 0xa7, 0x4a, 0x93, 0xdb, 0x5a, 0xe7, 0xec,

  307. };

  308. 

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

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

  311. static const uint8_t kExampleBadECKeyDER[] = {

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

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

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

  315.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

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

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

  318.     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,

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

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

  321. };

  322. 

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

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

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

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

  327. static const uint8_t kExampleBadECKeyDER2[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

  341.     0x07,

  342. };

  343. 

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

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

  346. static const uint8_t kInvalidPrivateKey[] = {

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

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

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

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

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

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

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

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

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

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

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

  358. };

  359. 

  360. static ScopedEVP_PKEY LoadExampleRSAKey() {

  361.   ScopedRSA rsa(RSA_private_key_from_bytes(kExampleRSAKeyDER,

  362.                                            sizeof(kExampleRSAKeyDER)));

  363.   if (!rsa) {

  364.     return nullptr;

  365.   }

  366.   ScopedEVP_PKEY pkey(EVP_PKEY_new());

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

  368.     return nullptr;

  369.   }

  370.   return pkey;

  371. }

  372. 

  373. static bool TestEVP_DigestSignInit(void) {

  374.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  375.   ScopedEVP_MD_CTX md_ctx;

  376.   if (!pkey ||

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

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

  379.     return false;

  380.   }

  381.   // Determine the size of the signature.

  382.   size_t sig_len = 0;

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

  384.     return false;

  385.   }

  386.   // Sanity check for testing.

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

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

  389.     return false;

  390.   }

  391. 

  392.   std::vector<uint8_t> sig;

  393.   sig.resize(sig_len);

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

  395.     return false;

  396.   }

  397.   sig.resize(sig_len);

  398. 

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

  400.   md_ctx.Reset();

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

  402.                             pkey.get()) ||

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

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

  405.     return false;

  406.   }

  407. 

  408.   return true;

  409. }

  410. 

  411. static bool TestEVP_DigestVerifyInit(void) {

  412.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  413.   ScopedEVP_MD_CTX md_ctx;

  414.   if (!pkey ||

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

  416.                             pkey.get()) ||

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

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

  419.     return false;

  420.   }

  421.   return true;

  422. }

  423. 

  424. static bool TestVerifyRecover() {

  425.   ScopedEVP_PKEY pkey = LoadExampleRSAKey();

  426.   if (!pkey) {

  427.     return false;

  428.   }

  429. 

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

  431.   if (!rsa) {

  432.     return false;

  433.   }

  434. 

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

  436.   uint8_t sig[2048/8];

  437.   unsigned sig_len = sizeof(sig);

  438. 

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

  440.                 rsa.get())) {

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

  442.     ERR_print_errors_fp(stderr);

  443.     return false;

  444.   }

  445. 

  446.   size_t out_len;

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

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

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

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

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

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

  453.     ERR_print_errors_fp(stderr);

  454.     return false;

  455.   }

  456. 

  457.   std::vector<uint8_t> recovered;

  458.   recovered.resize(out_len);

  459. 

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

  461.                                sig_len)) {

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

  463.     ERR_print_errors_fp(stderr);

  464.     return false;

  465.   }

  466. 

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

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

  469.             static_cast<unsigned>(out_len),

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

  471.     return false;

  472.   }

  473. 

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

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

  476.     ERR_print_errors_fp(stderr);

  477.     return false;

  478.   }

  479. 

  480.   out_len = recovered.size();

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

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

  483.                                sig_len)) {

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

  485.     ERR_print_errors_fp(stderr);

  486.     return false;

  487.   }

  488. 

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

  490.    * bytes. */

  491.   static const size_t kExpectedASN1Size = 51;

  492.   if (out_len != kExpectedASN1Size) {

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

  494.             static_cast<unsigned>(out_len),

  495.             static_cast<unsigned>(kExpectedASN1Size));

  496.     return false;

  497.   }

  498. 

  499.   return true;

  500. }

  501. 

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

  503.                                 int expected_id) {

  504.   const uint8_t *p = input;

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

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

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

  508.     return false;

  509.   }

  510. 

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

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

  513.     return false;

  514.   }

  515. 

  516.   return true;

  517. }

  518. 

  519. static bool Testd2i_AutoPrivateKey() {

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

  521.                            EVP_PKEY_RSA)) {

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

  523.     return false;

  524.   }

  525. 

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

  527.                            EVP_PKEY_RSA)) {

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

  529.     return false;

  530.   }

  531. 

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

  533.                            EVP_PKEY_EC)) {

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

  535.     return false;

  536.   }

  537. 

  538.   if (!TestValidPrivateKey(kExampleECKeyPKCS8, sizeof(kExampleECKeyPKCS8),

  539.                            EVP_PKEY_EC)) {

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

  541.     return false;

  542.   }

  543. 

  544.   if (!TestValidPrivateKey(kExampleECKeySpecifiedCurvePKCS8,

  545.                            sizeof(kExampleECKeySpecifiedCurvePKCS8),

  546.                            EVP_PKEY_EC)) {

  547.     fprintf(stderr,

  548.             "d2i_AutoPrivateKey(kExampleECKeySpecifiedCurvePKCS8) failed\n");

  549.     return false;

  550.   }

  551. 

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

  553.                            EVP_PKEY_DSA)) {

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

  555.     return false;

  556.   }

  557. 

  558.   const uint8_t *p = kInvalidPrivateKey;

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

  560.   if (pkey) {

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

  562.     return false;

  563.   }

  564.   ERR_clear_error();

  565. 

  566.   return true;

  567. }

  568. 

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

  570. static bool TestEVP_PKCS82PKEY(void) {

  571.   const uint8_t *derp = kExampleBadECKeyDER;

  572.   ScopedPKCS8_PRIV_KEY_INFO p8inf(

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

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

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

  576.     return false;

  577.   }

  578. 

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

  580.   if (pkey) {

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

  582.     return false;

  583.   }

  584.   ERR_clear_error();

  585. 

  586.   return true;

  587. }

  588. 

  589. // TestEVPMarshalEmptyPublicKey tests |EVP_marshal_public_key| on an empty key.

  590. static bool TestEVPMarshalEmptyPublicKey(void) {

  591.   ScopedEVP_PKEY empty(EVP_PKEY_new());

  592.   if (!empty) {

  593.     return false;

  594.   }

  595.   ScopedCBB cbb;

  596.   if (EVP_marshal_public_key(cbb.get(), empty.get())) {

  597.     fprintf(stderr, "Marshalled empty public key.\n");

  598.     return false;

  599.   }

  600.   if (ERR_GET_REASON(ERR_peek_last_error()) != EVP_R_UNSUPPORTED_ALGORITHM) {

  601.     fprintf(stderr, "Marshalling an empty public key gave wrong error.\n");

  602.     return false;

  603.   }

  604.   ERR_clear_error();

  605.   return true;

  606. }

  607. 

  608. // Testd2i_PrivateKey tests |d2i_PrivateKey|.

  609. static bool Testd2i_PrivateKey(void) {

  610.   const uint8_t *derp = kExampleRSAKeyDER;

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

  612.                                      sizeof(kExampleRSAKeyDER)));

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

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

  615.     return false;

  616.   }

  617. 

  618.   derp = kExampleDSAKeyDER;

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

  620.              sizeof(kExampleDSAKeyDER)));

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

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

  623.     return false;

  624.   }

  625. 

  626.   derp = kExampleRSAKeyPKCS8;

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

  628.              sizeof(kExampleRSAKeyPKCS8)));

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

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

  631.     return false;

  632.   }

  633. 

  634.   derp = kExampleECKeyDER;

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

  636.              sizeof(kExampleECKeyDER)));

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

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

  639.     return false;

  640.   }

  641. 

  642.   derp = kExampleBadECKeyDER;

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

  644.              sizeof(kExampleBadECKeyDER)));

  645.   if (pkey) {

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

  647.     return false;

  648.   }

  649.   ERR_clear_error();

  650. 

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

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

  653.                                                   sizeof(kExampleBadECKeyDER2));

  654.   derp = copy.data();

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

  656.   if (pkey) {

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

  658.     return false;

  659.   }

  660.   ERR_clear_error();

  661. 

  662.   derp = kExampleRSAKeyPKCS8;

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

  664.              sizeof(kExampleRSAKeyPKCS8)));

  665.   if (pkey) {

  666.     fprintf(stderr, "Imported RSA key as EC key.\n");

  667.     return false;

  668.   }

  669.   ERR_clear_error();

  670. 

  671.   return true;

  672. }

  673. 

  674. int main(void) {

  675.   CRYPTO_library_init();

  676. 

  677.   if (!TestEVP_DigestSignInit()) {

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

  679.     ERR_print_errors_fp(stderr);

  680.     return 1;

  681.   }

  682. 

  683.   if (!TestEVP_DigestVerifyInit()) {

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

  685.     ERR_print_errors_fp(stderr);

  686.     return 1;

  687.   }

  688. 

  689.   if (!TestVerifyRecover()) {

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

  691.     ERR_print_errors_fp(stderr);

  692.     return 1;

  693.   }

  694. 

  695.   if (!Testd2i_AutoPrivateKey()) {

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

  697.     ERR_print_errors_fp(stderr);

  698.     return 1;

  699.   }

  700. 

  701.   if (!TestEVP_PKCS82PKEY()) {

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

  703.     ERR_print_errors_fp(stderr);

  704.     return 1;

  705.   }

  706. 

  707.   if (!TestEVPMarshalEmptyPublicKey()) {

  708.     fprintf(stderr, "TestEVPMarshalEmptyPublicKey failed\n");

  709.     ERR_print_errors_fp(stderr);

  710.     return 1;

  711.   }

  712. 

  713.   if (!Testd2i_PrivateKey()) {

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

  715.     ERR_print_errors_fp(stderr);

  716.     return 1;

  717.   }

  718. 

  719.   printf("PASS\n");

  720.   return 0;

  721. }