test/evp_extra_test.c

   1 /*
   2  * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <openssl/bio.h>
  14 #include <openssl/crypto.h>
  15 #include <openssl/err.h>
  16 #include <openssl/evp.h>
  17 #include <openssl/rsa.h>
  18 #include <openssl/x509.h>
  19
  20 /*
  21  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  22  * should never use this key anywhere but in an example.
  23  */
  24 static const unsigned char kExampleRSAKeyDER[] = {
  25     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  26     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  27     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  28     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  29     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  30     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  31     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  32     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  33     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  34     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  35     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  36     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  37     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  38     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  39     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  40     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  41     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  42     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  43     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  44     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  45     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  46     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  47     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  48     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  49     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  50     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  51     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  52     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  53     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  54     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  55     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  56     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  57     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  58     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  59     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  60     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  61     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  62     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  63     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  64     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  65     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  66     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  67     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  68     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  69     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  70     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  71     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  72     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  73     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
  74     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
  75     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
  76 };
  77
  78 static const unsigned char kMsg[] = { 1, 2, 3, 4 };
  79
  80 static const unsigned char kSignature[] = {
  81     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
  82     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
  83     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
  84     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
  85     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
  86     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
  87     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
  88     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
  89     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
  90     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
  91     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
  92 };
  93
  94 /*
  95  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
  96  * PrivateKeyInfo.
  97  */
  98 static const unsigned char kExampleRSAKeyPKCS8[] = {
  99     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 100     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 101     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
 102     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 103     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 104     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 105     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 106     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 107     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 108     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 109     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 110     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 111     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 112     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 113     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 114     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 115     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 116     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 117     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 118     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 119     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 120     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 121     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 122     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 123     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 124     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 125     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 126     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 127     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 128     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 129     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 130     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 131     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 132     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 133     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 134     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 135     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 136     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 137     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 138     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 139     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 140     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 141     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 142     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 143     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 144     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 145     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 146     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 147     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 148     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 149     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 150     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 151     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 152 };
 153
 154 #ifndef OPENSSL_NO_EC
 155 /*
 156  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 157  * structure.
 158  */
 159 static const unsigned char kExampleECKeyDER[] = {
 160     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 161     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 162     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 163     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 164     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 165     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 166     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 167     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 168     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 169     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 170     0xc1,
 171 };
 172
 173 /*
 174  * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
 175  * structure. The private key is equal to the order and will fail to import
 176  */
 177 static const unsigned char kExampleBadECKeyDER[] = {
 178     0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
 179     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
 180     0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
 181     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 182     0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
 183     0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
 184     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
 185     0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 186     0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 187 };
 188 #endif
 189
 190 static EVP_PKEY *load_example_rsa_key(void)
 191 {
 192     EVP_PKEY *ret = NULL;
 193     const unsigned char *derp = kExampleRSAKeyDER;
 194     EVP_PKEY *pkey = NULL;
 195     RSA *rsa = NULL;
 196
 197     if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) {
 198         return NULL;
 199     }
 200
 201     pkey = EVP_PKEY_new();
 202     if (pkey == NULL || !EVP_PKEY_set1_RSA(pkey, rsa)) {
 203         goto out;
 204     }
 205
 206     ret = pkey;
 207     pkey = NULL;
 208
 209  out:
 210     EVP_PKEY_free(pkey);
 211     RSA_free(rsa);
 212
 213     return ret;
 214 }
 215
 216 static int test_EVP_DigestSignInit(void)
 217 {
 218     int ret = 0;
 219     EVP_PKEY *pkey = NULL;
 220     unsigned char *sig = NULL;
 221     size_t sig_len = 0;
 222     EVP_MD_CTX *md_ctx, *md_ctx_verify;
 223
 224     md_ctx = EVP_MD_CTX_new();
 225     md_ctx_verify = EVP_MD_CTX_new();
 226     if (md_ctx == NULL || md_ctx_verify == NULL)
 227         goto out;
 228
 229     pkey = load_example_rsa_key();
 230     if (pkey == NULL ||
 231         !EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
 232         !EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {
 233         goto out;
 234     }
 235     /* Determine the size of the signature. */
 236     if (!EVP_DigestSignFinal(md_ctx, NULL, &sig_len)) {
 237         goto out;
 238     }
 239     /* Sanity check for testing. */
 240     if (sig_len != (size_t)EVP_PKEY_size(pkey)) {
 241         fprintf(stderr, "sig_len mismatch\n");
 242         goto out;
 243     }
 244
 245     sig = OPENSSL_malloc(sig_len);
 246     if (sig == NULL || !EVP_DigestSignFinal(md_ctx, sig, &sig_len)) {
 247         goto out;
 248     }
 249
 250     /* Ensure that the signature round-trips. */
 251     if (!EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(), NULL, pkey)
 252         || !EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))
 253         || !EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)) {
 254         goto out;
 255     }
 256
 257     ret = 1;
 258
 259  out:
 260     if (!ret) {
 261         ERR_print_errors_fp(stderr);
 262     }
 263
 264     EVP_MD_CTX_free(md_ctx);
 265     EVP_MD_CTX_free(md_ctx_verify);
 266     EVP_PKEY_free(pkey);
 267     OPENSSL_free(sig);
 268
 269     return ret;
 270 }
 271
 272 static int test_EVP_DigestVerifyInit(void)
 273 {
 274     int ret = 0;
 275     EVP_PKEY *pkey = NULL;
 276     EVP_MD_CTX *md_ctx;
 277
 278     md_ctx = EVP_MD_CTX_new();
 279
 280     pkey = load_example_rsa_key();
 281     if (pkey == NULL ||
 282         !EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
 283         !EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)) ||
 284         !EVP_DigestVerifyFinal(md_ctx, kSignature, sizeof(kSignature))) {
 285         goto out;
 286     }
 287     ret = 1;
 288
 289  out:
 290     if (!ret) {
 291         ERR_print_errors_fp(stderr);
 292     }
 293
 294     EVP_MD_CTX_free(md_ctx);
 295     EVP_PKEY_free(pkey);
 296
 297     return ret;
 298 }
 299
 300 static int test_d2i_AutoPrivateKey(const unsigned char *input,
 301                                    size_t input_len, int expected_id)
 302 {
 303     int ret = 0;
 304     const unsigned char *p;
 305     EVP_PKEY *pkey = NULL;
 306
 307     p = input;
 308     pkey = d2i_AutoPrivateKey(NULL, &p, input_len);
 309     if (pkey == NULL || p != input + input_len) {
 310         fprintf(stderr, "d2i_AutoPrivateKey failed\n");
 311         goto done;
 312     }
 313
 314     if (EVP_PKEY_id(pkey) != expected_id) {
 315         fprintf(stderr, "Did not decode expected type\n");
 316         goto done;
 317     }
 318
 319     ret = 1;
 320
 321  done:
 322     if (!ret) {
 323         ERR_print_errors_fp(stderr);
 324     }
 325
 326     EVP_PKEY_free(pkey);
 327     return ret;
 328 }
 329
 330 static int test_EVP_Enveloped(void)
 331 {
 332     int ret = 0;
 333     EVP_CIPHER_CTX *ctx = NULL;
 334     EVP_PKEY *keypair = NULL;
 335     unsigned char *kek = NULL;
 336     int kek_len;
 337     unsigned char iv[EVP_MAX_IV_LENGTH];
 338     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 339     int len, ciphertext_len, plaintext_len;
 340     unsigned char ciphertext[32], plaintext[16];
 341     const EVP_CIPHER *type = EVP_aes_256_cbc();
 342
 343     if ((keypair = load_example_rsa_key()) == NULL
 344             || (kek = OPENSSL_zalloc(EVP_PKEY_size(keypair))) == NULL
 345             || (ctx = EVP_CIPHER_CTX_new()) == NULL
 346             || !EVP_SealInit(ctx, type, &kek, &kek_len, iv, &keypair, 1)
 347             || !EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
 348                                msg, sizeof(msg))
 349             || !EVP_SealFinal(ctx, ciphertext + ciphertext_len, &len))
 350         goto err;
 351
 352     ciphertext_len += len;
 353     if (!EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair)
 354             || !EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
 355                                ciphertext, ciphertext_len)
 356             || !EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)
 357             || (plaintext_len += len) != sizeof(msg)
 358             || memcmp(msg, plaintext, sizeof(msg)) != 0)
 359         goto err;
 360
 361     ret = 1;
 362
 363 err:
 364     OPENSSL_free(kek);
 365     EVP_PKEY_free(keypair);
 366     EVP_CIPHER_CTX_free(ctx);
 367     return ret;
 368 }
 369
 370 #ifndef OPENSSL_NO_EC
 371 /* Tests loading a bad key in PKCS8 format */
 372 static int test_EVP_PKCS82PKEY(void)
 373 {
 374     int ret = 0;
 375     const unsigned char *derp = kExampleBadECKeyDER;
 376     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
 377     EVP_PKEY *pkey = NULL;
 378
 379     p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER));
 380
 381     if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {
 382         fprintf(stderr, "Failed to parse key\n");
 383         goto done;
 384     }
 385
 386     pkey = EVP_PKCS82PKEY(p8inf);
 387     if (pkey) {
 388         fprintf(stderr, "Imported invalid EC key\n");
 389         goto done;
 390     }
 391
 392     ret = 1;
 393
 394  done:
 395     PKCS8_PRIV_KEY_INFO_free(p8inf);
 396     EVP_PKEY_free(pkey);
 397
 398     return ret;
 399 }
 400 #endif
 401
 402 int main(void)
 403 {
 404     CRYPTO_set_mem_debug(1);
 405     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
 406
 407
 408     if (!test_EVP_DigestSignInit()) {
 409         fprintf(stderr, "EVP_DigestSignInit failed\n");
 410         return 1;
 411     }
 412
 413     if (!test_EVP_DigestVerifyInit()) {
 414         fprintf(stderr, "EVP_DigestVerifyInit failed\n");
 415         return 1;
 416     }
 417
 418     if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),
 419                                  EVP_PKEY_RSA)) {
 420         fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");
 421         return 1;
 422     }
 423
 424     if (!test_d2i_AutoPrivateKey
 425         (kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA)) {
 426         fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");
 427         return 1;
 428     }
 429
 430     if (!test_EVP_Enveloped()) {
 431         fprintf(stderr, "test_EVP_Enveloped failed\n");
 432         return 1;
 433     }
 434
 435 #ifndef OPENSSL_NO_EC
 436     if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),
 437                                  EVP_PKEY_EC)) {
 438         fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");
 439         return 1;
 440     }
 441
 442     if (!test_EVP_PKCS82PKEY()) {
 443         fprintf(stderr, "test_EVP_PKCS82PKEY failed\n");
 444         return 1;
 445     }
 446 #endif
 447
 448 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
 449     if (CRYPTO_mem_leaks_fp(stderr) <= 0)
 450         return 1;
 451 #endif
 452
 453     printf("PASS\n");
 454     return 0;
 455 }