test/evp_extra_test.c

   1 /*
   2  * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 #include <openssl/pem.h>
  20 #include <openssl/kdf.h>
  21 #include "testutil.h"
  22 #include "internal/nelem.h"
  23 #include "internal/evp_int.h"
  24
  25 /*
  26  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  27  * should never use this key anywhere but in an example.
  28  */
  29 static const unsigned char kExampleRSAKeyDER[] = {
  30     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  31     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  32     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  33     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  34     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  35     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  36     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  37     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  38     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  39     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  40     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  41     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  42     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  43     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  44     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  45     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  46     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  47     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  48     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  49     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  50     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  51     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  52     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  53     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  54     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  55     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  56     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  57     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  58     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  59     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  60     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  61     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  62     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  63     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  64     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  65     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  66     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  67     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  68     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  69     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  70     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  71     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  72     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  73     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  74     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  75     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  76     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  77     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  78     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
  79     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
  80     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
  81 };
  82
  83 /*
  84  * kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
  85  * components are not correct.
  86  */
  87 static const unsigned char kExampleBadRSAKeyDER[] = {
  88     0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
  89     0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
  90     0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
  91     0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
  92     0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
  93     0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
  94     0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
  95     0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
  96     0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
  97     0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
  98     0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
  99     0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
 100     0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
 101     0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
 102     0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
 103     0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
 104     0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
 105     0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
 106     0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
 107     0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
 108     0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
 109     0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
 110     0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
 111     0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
 112     0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
 113     0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
 114     0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
 115     0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
 116     0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
 117     0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
 118     0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
 119     0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
 120     0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
 121     0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
 122     0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
 123     0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
 124     0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
 125     0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
 126     0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
 127     0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
 128     0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
 129     0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
 130     0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
 131     0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
 132     0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
 133     0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
 134     0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
 135     0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
 136     0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
 137     0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
 138     0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
 139     0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
 140     0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
 141     0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
 142     0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
 143     0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
 144     0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
 145     0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
 146     0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
 147     0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
 148     0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
 149     0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
 150     0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
 151     0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
 152     0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
 153     0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
 154     0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
 155     0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
 156     0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
 157     0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
 158     0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
 159     0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
 160     0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
 161     0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
 162     0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
 163     0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
 164     0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
 165     0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
 166     0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
 167     0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
 168     0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
 169     0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
 170     0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
 171     0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
 172     0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
 173     0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
 174     0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
 175     0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
 176     0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
 177 };
 178
 179 static const unsigned char kMsg[] = { 1, 2, 3, 4 };
 180
 181 static const unsigned char kSignature[] = {
 182     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
 183     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
 184     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
 185     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
 186     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
 187     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
 188     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
 189     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
 190     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
 191     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
 192     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
 193 };
 194
 195 /*
 196  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
 197  * PrivateKeyInfo.
 198  */
 199 static const unsigned char kExampleRSAKeyPKCS8[] = {
 200     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 201     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 202     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
 203     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 204     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 205     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 206     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 207     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 208     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 209     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 210     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 211     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 212     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 213     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 214     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 215     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 216     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 217     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 218     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 219     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 220     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 221     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 222     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 223     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 224     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 225     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 226     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 227     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 228     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 229     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 230     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 231     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 232     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 233     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 234     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 235     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 236     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 237     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 238     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 239     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 240     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 241     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 242     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 243     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 244     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 245     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 246     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 247     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 248     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 249     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 250     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 251     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 252     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 253 };
 254
 255 #ifndef OPENSSL_NO_EC
 256 /*
 257  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 258  * structure.
 259  */
 260 static const unsigned char kExampleECKeyDER[] = {
 261     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 262     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 263     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 264     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 265     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 266     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 267     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 268     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 269     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 270     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 271     0xc1,
 272 };
 273
 274 /*
 275  * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
 276  * structure. The private key is equal to the order and will fail to import
 277  */
 278 static const unsigned char kExampleBadECKeyDER[] = {
 279     0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
 280     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
 281     0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
 282     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 283     0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
 284     0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
 285     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
 286     0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 287     0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 288 };
 289
 290 /* prime256v1 */
 291 static const unsigned char kExampleECPubKeyDER[] = {
 292     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 293     0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 294     0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
 295     0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
 296     0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
 297     0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
 298     0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
 299     0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
 300 };
 301
 302 static const unsigned char pExampleECParamDER[] = {
 303     0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
 304 };
 305 #endif
 306
 307 typedef struct APK_DATA_st {
 308     const unsigned char *kder;
 309     size_t size;
 310     int evptype;
 311     int check;
 312     int pub_check;
 313     int param_check;
 314     int type; /* 0 for private, 1 for public, 2 for params */
 315 } APK_DATA;
 316
 317 static APK_DATA keydata[] = {
 318     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
 319     {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
 320 #ifndef OPENSSL_NO_EC
 321     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
 322 #endif
 323 };
 324
 325 static APK_DATA keycheckdata[] = {
 326     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA, 1, -2, -2, 0},
 327     {kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), EVP_PKEY_RSA,
 328      0, -2, -2, 0},
 329 #ifndef OPENSSL_NO_EC
 330     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC, 1, 1, 1, 0},
 331     /* group is also associated in our pub key */
 332     {kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), EVP_PKEY_EC, 0, 1, 1, 1},
 333     {pExampleECParamDER, sizeof(pExampleECParamDER), EVP_PKEY_EC, 0, 0, 1, 2}
 334 #endif
 335 };
 336
 337 static EVP_PKEY *load_example_rsa_key(void)
 338 {
 339     EVP_PKEY *ret = NULL;
 340     const unsigned char *derp = kExampleRSAKeyDER;
 341     EVP_PKEY *pkey = NULL;
 342     RSA *rsa = NULL;
 343
 344     if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
 345         return NULL;
 346
 347     if (!TEST_ptr(pkey = EVP_PKEY_new())
 348             || !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
 349         goto end;
 350
 351     ret = pkey;
 352     pkey = NULL;
 353
 354 end:
 355     EVP_PKEY_free(pkey);
 356     RSA_free(rsa);
 357
 358     return ret;
 359 }
 360
 361 static int test_EVP_Enveloped(void)
 362 {
 363     int ret = 0;
 364     EVP_CIPHER_CTX *ctx = NULL;
 365     EVP_PKEY *keypair = NULL;
 366     unsigned char *kek = NULL;
 367     unsigned char iv[EVP_MAX_IV_LENGTH];
 368     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 369     int len, kek_len, ciphertext_len, plaintext_len;
 370     unsigned char ciphertext[32], plaintext[16];
 371     const EVP_CIPHER *type = EVP_aes_256_cbc();
 372
 373     if (!TEST_ptr(keypair = load_example_rsa_key())
 374             || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_size(keypair)))
 375             || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 376             || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
 377                                        &keypair, 1))
 378             || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
 379                                          msg, sizeof(msg)))
 380             || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
 381                                         &len)))
 382         goto err;
 383
 384     ciphertext_len += len;
 385
 386     if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
 387             || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
 388                                          ciphertext, ciphertext_len))
 389             || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
 390         goto err;
 391
 392     plaintext_len += len;
 393     if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
 394         goto err;
 395
 396     ret = 1;
 397 err:
 398     OPENSSL_free(kek);
 399     EVP_PKEY_free(keypair);
 400     EVP_CIPHER_CTX_free(ctx);
 401     return ret;
 402 }
 403
 404
 405 static int test_EVP_DigestSignInit(void)
 406 {
 407     int ret = 0;
 408     EVP_PKEY *pkey = NULL;
 409     unsigned char *sig = NULL;
 410     size_t sig_len = 0;
 411     EVP_MD_CTX *md_ctx, *md_ctx_verify = NULL;
 412
 413     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 414             || !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
 415             || !TEST_ptr(pkey = load_example_rsa_key()))
 416         goto out;
 417
 418     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 419             || !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 420         goto out;
 421
 422     /* Determine the size of the signature. */
 423     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
 424             || !TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
 425         goto out;
 426
 427     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
 428             || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 429         goto out;
 430
 431     /* Ensure that the signature round-trips. */
 432     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
 433                                         NULL, pkey))
 434             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
 435                                                  kMsg, sizeof(kMsg)))
 436             || !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 437         goto out;
 438
 439     ret = 1;
 440
 441  out:
 442     EVP_MD_CTX_free(md_ctx);
 443     EVP_MD_CTX_free(md_ctx_verify);
 444     EVP_PKEY_free(pkey);
 445     OPENSSL_free(sig);
 446
 447     return ret;
 448 }
 449
 450 static int test_EVP_DigestVerifyInit(void)
 451 {
 452     int ret = 0;
 453     EVP_PKEY *pkey = NULL;
 454     EVP_MD_CTX *md_ctx = NULL;
 455
 456     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 457             || !TEST_ptr(pkey = load_example_rsa_key()))
 458         goto out;
 459
 460     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 461             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
 462             || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
 463                                                  sizeof(kSignature))))
 464         goto out;
 465     ret = 1;
 466
 467  out:
 468     EVP_MD_CTX_free(md_ctx);
 469     EVP_PKEY_free(pkey);
 470     return ret;
 471 }
 472
 473 static int test_d2i_AutoPrivateKey(int i)
 474 {
 475     int ret = 0;
 476     const unsigned char *p;
 477     EVP_PKEY *pkey = NULL;
 478     const APK_DATA *ak = &keydata[i];
 479     const unsigned char *input = ak->kder;
 480     size_t input_len = ak->size;
 481     int expected_id = ak->evptype;
 482
 483     p = input;
 484     if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 485             || !TEST_ptr_eq(p, input + input_len)
 486             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
 487         goto done;
 488
 489     ret = 1;
 490
 491  done:
 492     EVP_PKEY_free(pkey);
 493     return ret;
 494 }
 495
 496 #ifndef OPENSSL_NO_EC
 497 /* Tests loading a bad key in PKCS8 format */
 498 static int test_EVP_PKCS82PKEY(void)
 499 {
 500     int ret = 0;
 501     const unsigned char *derp = kExampleBadECKeyDER;
 502     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
 503     EVP_PKEY *pkey = NULL;
 504
 505     if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
 506                                               sizeof(kExampleBadECKeyDER))))
 507         goto done;
 508
 509     if (!TEST_ptr_eq(derp,
 510                      kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
 511         goto done;
 512
 513     if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
 514         goto done;
 515
 516     ret = 1;
 517
 518  done:
 519     PKCS8_PRIV_KEY_INFO_free(p8inf);
 520     EVP_PKEY_free(pkey);
 521
 522     return ret;
 523 }
 524 #endif
 525
 526 #ifndef OPENSSL_NO_SM2
 527
 528 static int test_EVP_SM2_verify(void)
 529 {
 530     /* From https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02#appendix-A */
 531     const char *pubkey =
 532        "-----BEGIN PUBLIC KEY-----\n"
 533        "MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEAhULWnkwETxjouSQ1\n"
 534        "v2/33kVyg5FcRVF9ci7biwjx38MwRAQgeHlotPoyw/0kF4Quc7v+/y88hItoMdfg\n"
 535        "7GUiizk35JgEIGPkxtOyOwyEnPhCQUhL/kj2HVmlsWugbm4S0donxSSaBEEEQh3r\n"
 536        "1hti6rZ0ZDTrw8wxXjIiCzut1QvcTE5sFH/t1D0GgFEry7QsB9RzSdIVO3DE5df9\n"
 537        "/L+jbqGoWEG55G4JogIhAIVC1p5MBE8Y6LkkNb9v990pdyBjBIVijVrnTufDLnm3\n"
 538        "AgEBA0IABArkx3mKoPEZRxvuEYJb5GICu3nipYRElel8BP9N8lSKfAJA+I8c1OFj\n"
 539        "Uqc8F7fxbwc1PlOhdtaEqf4Ma7eY6Fc=\n"
 540        "-----END PUBLIC KEY-----\n";
 541
 542     const char *msg = "message digest";
 543     const char *id = "ALICE123@YAHOO.COM";
 544
 545     const uint8_t signature[] = {
 546        0x30, 0x44, 0x02, 0x20,
 547
 548        0x40, 0xF1, 0xEC, 0x59, 0xF7, 0x93, 0xD9, 0xF4, 0x9E, 0x09, 0xDC,
 549        0xEF, 0x49, 0x13, 0x0D, 0x41, 0x94, 0xF7, 0x9F, 0xB1, 0xEE, 0xD2,
 550        0xCA, 0xA5, 0x5B, 0xAC, 0xDB, 0x49, 0xC4, 0xE7, 0x55, 0xD1,
 551
 552        0x02, 0x20,
 553
 554        0x6F, 0xC6, 0xDA, 0xC3, 0x2C, 0x5D, 0x5C, 0xF1, 0x0C, 0x77, 0xDF,
 555        0xB2, 0x0F, 0x7C, 0x2E, 0xB6, 0x67, 0xA4, 0x57, 0x87, 0x2F, 0xB0,
 556        0x9E, 0xC5, 0x63, 0x27, 0xA6, 0x7E, 0xC7, 0xDE, 0xEB, 0xE7
 557     };
 558
 559     int rc = 0;
 560     BIO *bio = NULL;
 561     EVP_PKEY *pkey = NULL;
 562     EVP_MD_CTX *mctx = NULL;
 563     EVP_PKEY_CTX *pctx = NULL;
 564
 565     bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
 566     if (!TEST_true(bio != NULL))
 567         goto done;
 568
 569     pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
 570     if (!TEST_true(pkey != NULL))
 571         goto done;
 572
 573     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 574         goto done;
 575
 576     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
 577         goto done;
 578
 579     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new(pkey, NULL)))
 580         goto done;
 581
 582     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, (const uint8_t *)id,
 583                                           strlen(id)), 0))
 584         goto done;
 585
 586     EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
 587
 588     if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey)))
 589         goto done;
 590
 591     if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
 592         goto done;
 593
 594     if (!TEST_true(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature))))
 595         goto done;
 596     rc = 1;
 597
 598  done:
 599     BIO_free(bio);
 600     EVP_PKEY_free(pkey);
 601     EVP_PKEY_CTX_free(pctx);
 602     EVP_MD_CTX_free(mctx);
 603     return rc;
 604 }
 605
 606 static int test_EVP_SM2(void)
 607 {
 608     int ret = 0;
 609     EVP_PKEY *pkey = NULL;
 610     EVP_PKEY *params = NULL;
 611     EVP_PKEY_CTX *pctx = NULL;
 612     EVP_PKEY_CTX *kctx = NULL;
 613     EVP_PKEY_CTX *sctx = NULL;
 614     size_t sig_len = 0;
 615     unsigned char *sig = NULL;
 616     EVP_MD_CTX *md_ctx = NULL;
 617     EVP_MD_CTX *md_ctx_verify = NULL;
 618     EVP_PKEY_CTX *cctx = NULL;
 619
 620     uint8_t ciphertext[128];
 621     size_t ctext_len = sizeof(ciphertext);
 622
 623     uint8_t plaintext[8];
 624     size_t ptext_len = sizeof(plaintext);
 625
 626     uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
 627
 628     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
 629     if (!TEST_ptr(pctx))
 630         goto done;
 631
 632     if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
 633         goto done;
 634
 635     if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
 636         goto done;
 637
 638     if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
 639         goto done;
 640
 641     kctx = EVP_PKEY_CTX_new(params, NULL);
 642     if (!TEST_ptr(kctx))
 643         goto done;
 644
 645     if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
 646         goto done;
 647
 648     if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
 649         goto done;
 650
 651     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 652         goto done;
 653
 654     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
 655         goto done;
 656
 657     if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
 658         goto done;
 659
 660     if (!TEST_ptr(sctx = EVP_PKEY_CTX_new(pkey, NULL)))
 661         goto done;
 662
 663     EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
 664     EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
 665
 666     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
 667         goto done;
 668
 669     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
 670         goto done;
 671
 672     if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 673         goto done;
 674
 675     /* Determine the size of the signature. */
 676     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
 677         goto done;
 678
 679     if (!TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
 680         goto done;
 681
 682     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
 683         goto done;
 684
 685     if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 686         goto done;
 687
 688     /* Ensure that the signature round-trips. */
 689
 690     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
 691         goto done;
 692
 693     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
 694         goto done;
 695
 696     if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 697         goto done;
 698
 699     /* now check encryption/decryption */
 700
 701     if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
 702         goto done;
 703
 704     if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
 705         goto done;
 706
 707     if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
 708         goto done;
 709
 710     if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
 711         goto done;
 712
 713     if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
 714         goto done;
 715
 716     if (!TEST_true(ptext_len == sizeof(kMsg)))
 717         goto done;
 718
 719     if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
 720         goto done;
 721
 722     ret = 1;
 723 done:
 724     EVP_PKEY_CTX_free(pctx);
 725     EVP_PKEY_CTX_free(kctx);
 726     EVP_PKEY_CTX_free(sctx);
 727     EVP_PKEY_CTX_free(cctx);
 728     EVP_PKEY_free(pkey);
 729     EVP_PKEY_free(params);
 730     EVP_MD_CTX_free(md_ctx);
 731     EVP_MD_CTX_free(md_ctx_verify);
 732     OPENSSL_free(sig);
 733     return ret;
 734 }
 735
 736 #endif
 737
 738 static struct keys_st {
 739     int type;
 740     char *priv;
 741     char *pub;
 742 } keys[] = {
 743     {
 744         EVP_PKEY_HMAC, "0123456789", NULL
 745     }, {
 746         EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
 747     }, {
 748         EVP_PKEY_SIPHASH, "0123456789012345", NULL
 749     },
 750 #ifndef OPENSSL_NO_EC
 751     {
 752         EVP_PKEY_X25519, "01234567890123456789012345678901",
 753         "abcdefghijklmnopqrstuvwxyzabcdef"
 754     }, {
 755         EVP_PKEY_ED25519, "01234567890123456789012345678901",
 756         "abcdefghijklmnopqrstuvwxyzabcdef"
 757     }, {
 758         EVP_PKEY_X448,
 759         "01234567890123456789012345678901234567890123456789012345",
 760         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
 761     }, {
 762         EVP_PKEY_ED448,
 763         "012345678901234567890123456789012345678901234567890123456",
 764         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
 765     }
 766 #endif
 767 };
 768
 769 static int test_set_get_raw_keys_int(int tst, int pub)
 770 {
 771     int ret = 0;
 772     unsigned char buf[80];
 773     unsigned char *in;
 774     size_t inlen, len = 0;
 775     EVP_PKEY *pkey;
 776
 777     /* Check if this algorithm supports public keys */
 778     if (keys[tst].pub == NULL)
 779         return 1;
 780
 781     memset(buf, 0, sizeof(buf));
 782
 783     if (pub) {
 784         inlen = strlen(keys[tst].pub);
 785         in = (unsigned char *)keys[tst].pub;
 786         pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
 787                                            NULL,
 788                                            in,
 789                                            inlen);
 790     } else {
 791         inlen = strlen(keys[tst].priv);
 792         in = (unsigned char *)keys[tst].priv;
 793         pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
 794                                             NULL,
 795                                             in,
 796                                             inlen);
 797     }
 798
 799     if (!TEST_ptr(pkey)
 800             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
 801             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
 802             || !TEST_true(len == inlen)
 803             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
 804             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
 805             || !TEST_mem_eq(in, inlen, buf, len))
 806         goto done;
 807
 808     ret = 1;
 809  done:
 810     EVP_PKEY_free(pkey);
 811     return ret;
 812 }
 813
 814 static int test_set_get_raw_keys(int tst)
 815 {
 816     return test_set_get_raw_keys_int(tst, 0)
 817            && test_set_get_raw_keys_int(tst, 1);
 818 }
 819
 820 static int pkey_custom_check(EVP_PKEY *pkey)
 821 {
 822     return 0xbeef;
 823 }
 824
 825 static int pkey_custom_pub_check(EVP_PKEY *pkey)
 826 {
 827     return 0xbeef;
 828 }
 829
 830 static int pkey_custom_param_check(EVP_PKEY *pkey)
 831 {
 832     return 0xbeef;
 833 }
 834
 835 static EVP_PKEY_METHOD *custom_pmeth;
 836
 837 static int test_EVP_PKEY_check(int i)
 838 {
 839     int ret = 0;
 840     const unsigned char *p;
 841     EVP_PKEY *pkey = NULL;
 842 #ifndef OPENSSL_NO_EC
 843     EC_KEY *eckey = NULL;
 844 #endif
 845     EVP_PKEY_CTX *ctx = NULL;
 846     EVP_PKEY_CTX *ctx2 = NULL;
 847     const APK_DATA *ak = &keycheckdata[i];
 848     const unsigned char *input = ak->kder;
 849     size_t input_len = ak->size;
 850     int expected_id = ak->evptype;
 851     int expected_check = ak->check;
 852     int expected_pub_check = ak->pub_check;
 853     int expected_param_check = ak->param_check;
 854     int type = ak->type;
 855     BIO *pubkey = NULL;
 856
 857     p = input;
 858
 859     switch (type) {
 860     case 0:
 861         if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 862             || !TEST_ptr_eq(p, input + input_len)
 863             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
 864             goto done;
 865         break;
 866 #ifndef OPENSSL_NO_EC
 867     case 1:
 868         if (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
 869             || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
 870             || !TEST_ptr(pkey = EVP_PKEY_new())
 871             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
 872             goto done;
 873         break;
 874     case 2:
 875         if (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
 876             || !TEST_ptr_eq(p, input + input_len)
 877             || !TEST_ptr(pkey = EVP_PKEY_new())
 878             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
 879             goto done;
 880         break;
 881 #endif
 882     default:
 883         return 0;
 884     }
 885
 886     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
 887         goto done;
 888
 889     if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
 890         goto done;
 891
 892     if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
 893         goto done;
 894
 895     if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
 896         goto done;
 897
 898     ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
 899     /* assign the pkey directly, as an internal test */
 900     EVP_PKEY_up_ref(pkey);
 901     ctx2->pkey = pkey;
 902
 903     if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
 904         goto done;
 905
 906     if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
 907         goto done;
 908
 909     if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
 910         goto done;
 911
 912     ret = 1;
 913
 914  done:
 915     EVP_PKEY_CTX_free(ctx);
 916     EVP_PKEY_CTX_free(ctx2);
 917     EVP_PKEY_free(pkey);
 918     BIO_free(pubkey);
 919     return ret;
 920 }
 921
 922 static int test_HKDF(void)
 923 {
 924     EVP_PKEY_CTX *pctx;
 925     unsigned char out[20];
 926     size_t outlen;
 927     int i, ret = 0;
 928     unsigned char salt[] = "0123456789";
 929     unsigned char key[] = "012345678901234567890123456789";
 930     unsigned char info[] = "infostring";
 931     const unsigned char expected[] = {
 932         0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
 933         0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
 934     };
 935     size_t expectedlen = sizeof(expected);
 936
 937     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
 938         goto done;
 939
 940     /* We do this twice to test reuse of the EVP_PKEY_CTX */
 941     for (i = 0; i < 2; i++) {
 942         outlen = sizeof(out);
 943         memset(out, 0, outlen);
 944
 945         if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
 946                 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
 947                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
 948                                                             sizeof(salt) - 1), 0)
 949                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
 950                                                            sizeof(key) - 1), 0)
 951                 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
 952                                                             sizeof(info) - 1), 0)
 953                 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
 954                 || !TEST_mem_eq(out, outlen, expected, expectedlen))
 955             goto done;
 956     }
 957
 958     ret = 1;
 959
 960  done:
 961     EVP_PKEY_CTX_free(pctx);
 962
 963     return ret;
 964 }
 965
 966 int setup_tests(void)
 967 {
 968     ADD_TEST(test_EVP_DigestSignInit);
 969     ADD_TEST(test_EVP_DigestVerifyInit);
 970     ADD_TEST(test_EVP_Enveloped);
 971     ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
 972 #ifndef OPENSSL_NO_EC
 973     ADD_TEST(test_EVP_PKCS82PKEY);
 974 #endif
 975 #ifndef OPENSSL_NO_SM2
 976     ADD_TEST(test_EVP_SM2);
 977     ADD_TEST(test_EVP_SM2_verify);
 978 #endif
 979     ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
 980     custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
 981     if (!TEST_ptr(custom_pmeth))
 982         return 0;
 983     EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
 984     EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
 985     EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
 986     if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
 987         return 0;
 988     ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
 989     ADD_TEST(test_HKDF);
 990     return 1;
 991 }