Home | History | Annotate | Line # | Download | only in test
      1 /*
      2  * Copyright 2019-2022 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 
     14 #include "internal/nelem.h"
     15 #include <openssl/crypto.h>
     16 #include <openssl/bio.h>
     17 #include <openssl/bn.h>
     18 #include <openssl/rand.h>
     19 #include <openssl/err.h>
     20 #include <openssl/evp.h>
     21 #include <openssl/ec.h>
     22 #include "testutil.h"
     23 
     24 #if defined(OPENSSL_NO_DH) && defined(OPENSSL_NO_DSA) && defined(OPENSSL_NO_EC)
     25 # define OPENSSL_NO_KEYPARAMS
     26 #endif
     27 
     28 #ifndef OPENSSL_NO_KEYPARAMS
     29 
     30 struct pubkey {
     31     int bad;
     32     const unsigned char *key_bin;
     33     size_t key_bin_len;
     34 };
     35 
     36 # ifndef OPENSSL_NO_DH
     37 static const unsigned char dhparam_bin[] = {
     38 0x30,0x82,0x01,0x08,0x02,0x82,0x01,0x01,0x00,0xc0,0xd1,0x2e,0x14,0x18,0xbd,0x03,
     39 0xfd,0x39,0xe1,0x99,0xf4,0x93,0x06,0x2d,0x49,0xc6,0xb5,0xb9,0xf0,0x91,0xcb,0x2f,
     40 0x48,0x54,0x79,0x7d,0xc4,0x65,0x11,0x55,0xf7,0x99,0xde,0x42,0x83,0x84,0xc0,0xf8,
     41 0x88,0x89,0xa0,0xff,0xff,0x7d,0xe8,0xef,0x9e,0xbc,0xf7,0x1d,0x70,0x6d,0x3a,0x33,
     42 0x49,0x28,0xa1,0xa3,0xe1,0x41,0xc4,0x8b,0x91,0xf9,0xf2,0xb6,0xe2,0x77,0x79,0x38,
     43 0x7d,0x21,0xb3,0xdf,0x79,0x9c,0x5e,0x65,0x16,0x00,0x16,0x82,0xb2,0x36,0x46,0x21,
     44 0xac,0xaf,0x86,0xc7,0xe3,0x10,0x44,0x48,0xfb,0xbd,0xad,0x4e,0x11,0x73,0x4c,0x25,
     45 0xb0,0x8c,0x1c,0x1e,0x8e,0x58,0x50,0x5e,0x43,0x89,0xe4,0xd9,0x34,0xf8,0x3b,0xcc,
     46 0x36,0x2c,0x1b,0xb3,0xb2,0x77,0x0c,0xa5,0x96,0xc1,0x8a,0x38,0xd4,0xe3,0x9c,0x2a,
     47 0xde,0x49,0x46,0xc7,0xd4,0xa2,0x47,0xc9,0x0a,0xbd,0x84,0xd4,0x1c,0xbc,0xb6,0x19,
     48 0x04,0x94,0x64,0xfa,0x8a,0x11,0x9c,0x5f,0x4a,0x4c,0x0f,0x58,0x81,0x02,0xbf,0xcf,
     49 0x87,0x27,0x2b,0xae,0x8e,0xe2,0x61,0x7a,0xdb,0xba,0x23,0x39,0x25,0x44,0xdc,0x22,
     50 0x75,0xc3,0x28,0xd9,0x12,0x33,0x84,0x32,0xd4,0x5d,0xd9,0x77,0xf8,0x04,0x90,0x38,
     51 0x0a,0xec,0x84,0x93,0x43,0xce,0xe7,0x07,0x42,0x7d,0x2d,0xe0,0x21,0x3b,0x19,0x22,
     52 0xa7,0x8f,0x50,0x31,0xda,0xd0,0x0d,0xd3,0x0b,0xdb,0xad,0xed,0x94,0x92,0xff,0x83,
     53 0x06,0x7f,0x7f,0xd7,0x7b,0x42,0x5b,0xba,0x93,0x7a,0xeb,0x43,0x5f,0xce,0x59,0x26,
     54 0xe8,0x76,0xdc,0xee,0xe2,0xbe,0x36,0x7a,0x83,0x02,0x01,0x02
     55 };
     56 static const unsigned char dhkey_1[] = {
     57     0x7a, 0x49, 0xcb, 0xc3, 0x25, 0x67, 0x7a, 0x61,
     58     0xd0, 0x60, 0x81, 0x0f, 0xf6, 0xbd, 0x38, 0x82,
     59     0xe7, 0x38, 0x8c, 0xe9, 0xd1, 0x04, 0x33, 0xbf,
     60     0x8a, 0x03, 0x63, 0xb3, 0x05, 0x04, 0xb5, 0x1f,
     61     0xba, 0x9f, 0x1a, 0x5f, 0x31, 0x3e, 0x96, 0x79,
     62     0x88, 0x7d, 0x3f, 0x59, 0x6d, 0x3b, 0xf3, 0x2f,
     63     0xf2, 0xa6, 0x43, 0x48, 0x64, 0x5a, 0x6a, 0x32,
     64     0x1f, 0x24, 0x37, 0x62, 0x54, 0x3a, 0x7d, 0xab,
     65     0x26, 0x77, 0x7c, 0xec, 0x57, 0x3c, 0xa4, 0xbd,
     66     0x96, 0x9d, 0xaa, 0x3b, 0x0e, 0x9a, 0x55, 0x7e,
     67     0x1d, 0xb4, 0x47, 0x5b, 0xea, 0x20, 0x3c, 0x6d,
     68     0xbe, 0xd6, 0x70, 0x7d, 0xa8, 0x9e, 0x84, 0xb4,
     69     0x03, 0x52, 0xf2, 0x08, 0x4c, 0x98, 0xd3, 0x4f,
     70     0x58, 0xb3, 0xdf, 0xb4, 0xe6, 0xdc, 0x2c, 0x43,
     71     0x55, 0xd1, 0xce, 0x2a, 0xb3, 0xfc, 0xe0, 0x29,
     72     0x97, 0xd8, 0xd8, 0x62, 0xc6, 0x87, 0x0a, 0x1b,
     73     0xfd, 0x72, 0x74, 0xe0, 0xa9, 0xfb, 0xfa, 0x91,
     74     0xf2, 0xc1, 0x09, 0x93, 0xea, 0x63, 0xf6, 0x9a,
     75     0x4b, 0xdf, 0x4e, 0xdf, 0x6b, 0xf9, 0xeb, 0xf6,
     76     0x66, 0x3c, 0xfd, 0x6f, 0x68, 0xcb, 0xdb, 0x6e,
     77     0x40, 0x65, 0xf7, 0xf2, 0x46, 0xe5, 0x0d, 0x9a,
     78     0xd9, 0x6f, 0xcf, 0x28, 0x22, 0x8f, 0xca, 0x0b,
     79     0x30, 0xa0, 0x9e, 0xa5, 0x13, 0xba, 0x72, 0x7f,
     80     0x85, 0x3d, 0x02, 0x9c, 0x97, 0x8e, 0x6f, 0xea,
     81     0x6d, 0x35, 0x4e, 0xd1, 0x78, 0x7d, 0x73, 0x60,
     82     0x92, 0xa9, 0x12, 0xf4, 0x2a, 0xac, 0x17, 0x97,
     83     0xf3, 0x7b, 0x79, 0x08, 0x69, 0xd1, 0x9e, 0xb5,
     84     0xf8, 0x2a, 0x0a, 0x2b, 0x00, 0x7b, 0x16, 0x8d,
     85     0x41, 0x82, 0x3a, 0x72, 0x58, 0x57, 0x80, 0x65,
     86     0xae, 0x17, 0xbc, 0x3a, 0x5b, 0x7e, 0x5c, 0x2d,
     87     0xae, 0xb2, 0xc2, 0x26, 0x20, 0x9a, 0xaa, 0x57,
     88     0x4b, 0x7d, 0x43, 0x41, 0x96, 0x3f, 0xf0, 0x0d
     89 };
     90 /* smaller but still valid key */
     91 static const unsigned char dhkey_2[] = {
     92     0x73, 0xb2, 0x22, 0x91, 0x27, 0xb9, 0x45, 0xb0,
     93     0xfd, 0x17, 0x66, 0x79, 0x9b, 0x32, 0x71, 0x92,
     94     0x97, 0x1d, 0x70, 0x02, 0x37, 0x70, 0x79, 0x63,
     95     0xed, 0x11, 0x22, 0xe9, 0xe6, 0xf8, 0xeb, 0xd7,
     96     0x90, 0x00, 0xe6, 0x5c, 0x47, 0x02, 0xfb, 0x13,
     97     0xca, 0x29, 0x14, 0x1e, 0xf4, 0x61, 0x58, 0xf6,
     98     0xaa, 0xbb, 0xcf, 0xa7, 0x82, 0x9a, 0x9e, 0x7c,
     99     0x4a, 0x05, 0x42, 0xed, 0x55, 0xd8, 0x08, 0x37,
    100     0x06, 0x49, 0x9b, 0xda, 0xb3, 0xb9, 0xc9, 0xc0,
    101     0x56, 0x26, 0xda, 0x60, 0x1d, 0xbc, 0x06, 0x0b,
    102     0xb0, 0x94, 0x4b, 0x4e, 0x95, 0xf9, 0xb4, 0x2f,
    103     0x4e, 0xad, 0xf8, 0xab, 0x2d, 0x19, 0xa2, 0xe6,
    104     0x6d, 0x11, 0xfd, 0x9b, 0x5a, 0x2a, 0xb0, 0x81,
    105     0x42, 0x4d, 0x86, 0x76, 0xd5, 0x9e, 0xaf, 0xf9,
    106     0x6f, 0x79, 0xab, 0x1d, 0xfe, 0xd8, 0xc8, 0xba,
    107     0xb6, 0xce, 0x03, 0x61, 0x48, 0x53, 0xd8, 0x0b,
    108     0x83, 0xf0, 0xb0, 0x46, 0xa0, 0xea, 0x46, 0x60,
    109     0x7a, 0x39, 0x4e, 0x46, 0x6a, 0xbb, 0x07, 0x6c,
    110     0x8c, 0x7d, 0xb7, 0x7d, 0x5b, 0xe5, 0x24, 0xa5,
    111     0xab, 0x41, 0x8a, 0xc4, 0x63, 0xf9, 0xce, 0x20,
    112     0x6f, 0x58, 0x4f, 0x0e, 0x42, 0x82, 0x9e, 0x17,
    113     0x53, 0xa6, 0xd6, 0x42, 0x3e, 0x80, 0x66, 0x6f,
    114     0x2a, 0x1c, 0x30, 0x08, 0x01, 0x99, 0x5a, 0x4f,
    115     0x72, 0x16, 0xed, 0xb0, 0xd6, 0x8c, 0xf0, 0x7a,
    116     0x33, 0x15, 0xc4, 0x95, 0x65, 0xba, 0x11, 0x37,
    117     0xa0, 0xcc, 0xe7, 0x45, 0x65, 0x4f, 0x17, 0x0a,
    118     0x2c, 0x62, 0xc0, 0x65, 0x3b, 0x65, 0x2a, 0x56,
    119     0xf7, 0x29, 0x8a, 0x9b, 0x1b, 0xbb, 0x0c, 0x40,
    120     0xcd, 0x66, 0x4b, 0x4f, 0x2f, 0xba, 0xdb, 0x59,
    121     0x93, 0x6d, 0x34, 0xf3, 0x8d, 0xde, 0x68, 0x99,
    122     0x78, 0xfc, 0xac, 0x95, 0xd9, 0xa3, 0x74, 0xe6,
    123     0x24, 0x96, 0x98, 0x6f, 0x64, 0x71, 0x76
    124 };
    125 /* 1 is not a valid key */
    126 static const unsigned char dhkey_3[] = {
    127     0x01
    128 };
    129 # endif
    130 
    131 # ifndef OPENSSL_NO_DSA
    132 static const unsigned char dsaparam_bin[] = {
    133 0x30,0x82,0x02,0x28,0x02,0x82,0x01,0x01,0x00,0xf2,0x85,0x01,0xa5,0xb9,0x56,0x65,
    134 0x19,0xff,0x9a,0x7d,0xf9,0x90,0xd6,0xaa,0x73,0xac,0xf7,0x94,0xfa,0x8a,0x64,0x6d,
    135 0xa0,0x01,0x42,0xe5,0x45,0xfc,0x53,0x72,0xb0,0x7c,0xe6,0x3b,0xfb,0x09,0x33,0x41,
    136 0x27,0xbd,0x00,0xb5,0x18,0x87,0x62,0xa8,0x2b,0xfc,0xd0,0x52,0x4a,0x14,0x2d,0xaa,
    137 0x36,0xc6,0xf3,0xa9,0xe3,0x90,0x1b,0x74,0xdf,0x0a,0x6d,0x33,0xba,0xf4,0x32,0x6d,
    138 0xba,0x36,0x68,0x1d,0x83,0x36,0x50,0xc6,0x62,0xc0,0x40,0x67,0x0e,0xf6,0x22,0x00,
    139 0x62,0x1b,0x76,0x72,0x62,0x5f,0xa0,0xdf,0x38,0xb1,0x1d,0x26,0x70,0x9b,0x84,0x64,
    140 0xbb,0x16,0x15,0xc2,0x66,0xb9,0x97,0xd0,0x07,0xf1,0x4b,0x70,0x02,0x03,0xf1,0xd2,
    141 0x03,0xdb,0x78,0x8b,0xb4,0xda,0x6f,0x3c,0xe2,0x31,0xa8,0x1c,0x99,0xea,0x9c,0x75,
    142 0x28,0x96,0x82,0x16,0x77,0xac,0x79,0x32,0x61,0x87,0xec,0xb7,0xb4,0xc3,0xea,0x12,
    143 0x62,0x1f,0x08,0xb8,0x16,0xab,0xcc,0xef,0x28,0xdf,0x06,0x07,0xbe,0xb0,0xdc,0x78,
    144 0x83,0x8a,0x70,0x80,0x34,0xe6,0x91,0xe3,0xd3,0x92,0xd9,0xf4,0x56,0x53,0x52,0xb7,
    145 0x35,0xf6,0x2a,0xec,0x4b,0xcb,0xa2,0x3c,0xc3,0x0c,0x94,0xa7,0x4e,0x1c,0x42,0x9c,
    146 0x72,0x99,0x60,0x8c,0xfe,0xfb,0x60,0x57,0x75,0xf5,0x23,0x11,0x12,0xba,0x97,0xcd,
    147 0xad,0x5a,0x0b,0xa6,0x1f,0x6a,0x48,0x2e,0x8d,0xda,0x95,0xc6,0x0e,0x14,0xde,0xf7,
    148 0x22,0x55,0xa8,0x6b,0x25,0xdf,0xa2,0xab,0x33,0x65,0x56,0xfc,0x78,0x4f,0x62,0xdf,
    149 0x48,0xdd,0xce,0x8b,0xe1,0x76,0xf4,0xf6,0x7f,0x02,0x1d,0x00,0xac,0xb0,0xb8,0x92,
    150 0x3b,0x6b,0x61,0xcf,0x36,0x6d,0xf2,0x1e,0x5d,0xe0,0x7b,0xf5,0x73,0x48,0xa3,0x8b,
    151 0x86,0x9e,0x88,0xce,0x40,0xf8,0x27,0x6d,0x02,0x82,0x01,0x00,0x77,0x6b,0x89,0xd6,
    152 0x8f,0x3d,0xce,0x52,0x30,0x74,0xb2,0xa1,0x13,0x96,0xd5,0x92,0xf2,0xf1,0x6b,0x10,
    153 0x31,0x0b,0xf3,0x69,0xaa,0xbf,0x4b,0x6c,0xcb,0x3f,0x6d,0x58,0x76,0x44,0x09,0xf9,
    154 0x28,0xef,0xa0,0xe4,0x55,0x77,0x57,0xe0,0xfb,0xcc,0x9a,0x6a,0x2c,0x90,0xec,0x72,
    155 0x24,0x0b,0x43,0xc5,0xbc,0x31,0xed,0x1a,0x46,0x2c,0x76,0x42,0x9e,0xc0,0x82,0xfc,
    156 0xff,0xf9,0x7e,0xe2,0x1f,0x39,0xf3,0x3b,0xdb,0x27,0x36,0xe7,0xf5,0x3b,0xc2,0x23,
    157 0xb6,0xd0,0xcf,0x5b,0x85,0x2e,0x1b,0x00,0x5b,0x31,0xaa,0x72,0x8f,0x37,0xee,0x56,
    158 0x71,0xc4,0xfd,0x3c,0x8d,0xfa,0x5b,0xab,0xb1,0xa9,0x52,0x76,0xa0,0xe4,0xe3,0x78,
    159 0x83,0x64,0x5d,0xd7,0x6c,0xec,0x9b,0x40,0x65,0xe2,0x0a,0x11,0x19,0x60,0xdd,0xce,
    160 0x29,0x9f,0xc6,0x1d,0x0a,0xab,0x8e,0x59,0x25,0xc5,0x0b,0x9c,0x02,0x45,0xba,0x99,
    161 0x74,0x22,0x1d,0xc1,0x57,0xca,0x50,0x8c,0x5e,0xdf,0xd8,0x5d,0x43,0xae,0x06,0x28,
    162 0x29,0x82,0xf6,0x5a,0xa9,0x51,0xa2,0x04,0x1d,0xbf,0x88,0x15,0x98,0xce,0x8a,0xb4,
    163 0x3b,0xe5,0x30,0x29,0xce,0x0c,0x9b,0xf8,0xdb,0xbf,0x06,0x9f,0xd0,0x59,0x18,0xd4,
    164 0x0b,0x94,0xbf,0xe9,0x67,0x6b,0x9e,0xf0,0x72,0xc6,0xbf,0x79,0x8f,0x1e,0xa3,0x95,
    165 0x24,0xe3,0xcb,0x58,0xb5,0x67,0xd3,0xae,0x79,0xb0,0x28,0x9c,0x9a,0xd0,0xa4,0xe7,
    166 0x22,0x15,0xc1,0x8b,0x04,0xb9,0x8a,0xa8,0xb7,0x1b,0x62,0x44,0xc6,0xef,0x4b,0x74,
    167 0xd0,0xfd,0xa9,0xb4,0x4e,0xdd,0x7d,0x38,0x60,0xd1,0x40,0xcd
    168 };
    169 # endif
    170 
    171 # ifndef OPENSSL_NO_EC
    172 static const unsigned char ecparam_bin[] = {
    173 0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x03,0x01,0x07
    174 };
    175 static const unsigned char eckey_1[] = {
    176     0x04, 0xc8, 0x65, 0x45, 0x63, 0x73, 0xe5, 0x0a,
    177     0x61, 0x1d, 0xcf, 0x60, 0x76, 0x2c, 0xe7, 0x36,
    178     0x0b, 0x76, 0xc2, 0x92, 0xfc, 0xa4, 0x56, 0xee,
    179     0xc2, 0x62, 0x05, 0x00, 0x80, 0xe4, 0x4f, 0x07,
    180     0x3b, 0xf4, 0x59, 0xb8, 0xc3, 0xb3, 0x1f, 0x77,
    181     0x36, 0x16, 0x4c, 0x72, 0x2a, 0xc0, 0x89, 0x89,
    182     0xd6, 0x16, 0x14, 0xee, 0x2f, 0x5a, 0xde, 0x9e,
    183     0x83, 0xc5, 0x78, 0xd0, 0x0b, 0x69, 0xb4, 0xb9,
    184     0xf1
    185 };
    186 /* a modified key */
    187 static const unsigned char eckey_2[] = {
    188     0x04, 0xc8, 0x65, 0x45, 0x63, 0x73, 0xe5, 0x0a,
    189     0x61, 0x1d, 0xcf, 0x60, 0x76, 0x2c, 0xe7, 0x36,
    190     0x0b, 0x77, 0xc2, 0x92, 0xfc, 0xa4, 0x56, 0xee,
    191     0xc2, 0x62, 0x05, 0x00, 0x80, 0xe4, 0x4f, 0x07,
    192     0x3b, 0xf4, 0x59, 0xb8, 0xc3, 0xb3, 0x1f, 0x77,
    193     0x36, 0x16, 0x4c, 0x72, 0x2a, 0xc0, 0x89, 0x89,
    194     0xd6, 0x16, 0x14, 0xee, 0x2f, 0x5a, 0xde, 0x9e,
    195     0x83, 0xc5, 0x78, 0xd0, 0x0b, 0x69, 0xb4, 0xb9,
    196     0xf1
    197 };
    198 /* an added byte */
    199 static const unsigned char eckey_3[] = {
    200     0x04, 0xc8, 0x65, 0x45, 0x63, 0x73, 0xe5, 0x0a,
    201     0x61, 0x1d, 0xcf, 0x60, 0x76, 0x2c, 0xe7, 0x36,
    202     0x0b, 0x76, 0xc2, 0x92, 0xfc, 0xa4, 0x56, 0xee,
    203     0xc2, 0x62, 0x05, 0x00, 0x80, 0xe4, 0x4f, 0x07,
    204     0x3b, 0xf4, 0x59, 0xb8, 0xc3, 0xb3, 0x1f, 0x77,
    205     0x36, 0x16, 0x4c, 0x72, 0x2a, 0xc0, 0x89, 0x89,
    206     0xd6, 0x16, 0x14, 0xee, 0x2f, 0x5a, 0xde, 0x9e,
    207     0x83, 0xc5, 0x78, 0xd0, 0x0b, 0x69, 0xb4, 0xb9,
    208     0xf1, 0xaa
    209 };
    210 # endif
    211 
    212 #define NUM_KEYS 10
    213 
    214 static const struct {
    215     int type;
    216     const unsigned char *param_bin;
    217     size_t param_bin_len;
    218     struct pubkey keys[NUM_KEYS];
    219 } pkey_params [] = {
    220 # ifndef OPENSSL_NO_DH
    221     { EVP_PKEY_DH, dhparam_bin, sizeof(dhparam_bin),
    222         { { 0, dhkey_1, sizeof(dhkey_1) },
    223           { 0, dhkey_2, sizeof(dhkey_2) },
    224           { 1, dhkey_3, sizeof(dhkey_3) },
    225           { 1, dhkey_1, 0 },
    226           { 1, dhparam_bin, sizeof(dhparam_bin) }
    227         }
    228     },
    229 # endif
    230 # ifndef OPENSSL_NO_DSA
    231     { EVP_PKEY_DSA, dsaparam_bin, sizeof(dsaparam_bin) },
    232 # endif
    233 # ifndef OPENSSL_NO_EC
    234     { EVP_PKEY_EC, ecparam_bin, sizeof(ecparam_bin),
    235         { { 0, eckey_1, sizeof(eckey_1) },
    236           { 1, eckey_2, sizeof(eckey_2) },
    237           { 1, eckey_3, sizeof(eckey_3) },
    238           { 1, eckey_1, 0 },
    239           { 1, eckey_1, sizeof(eckey_1) - 1 }
    240         }
    241     }
    242 # endif
    243 };
    244 
    245 static int params_bio_test(int id)
    246 {
    247     int ret, out_len;
    248     BIO *in = NULL, *out = NULL;
    249     EVP_PKEY *in_key = NULL, *out_key = NULL;
    250     unsigned char *out_bin;
    251     int type = pkey_params[id].type;
    252 
    253     ret = TEST_ptr(in = BIO_new_mem_buf(pkey_params[id].param_bin,
    254                                         (int)pkey_params[id].param_bin_len))
    255         /* Load in pkey params from binary */
    256         && TEST_ptr(d2i_KeyParams_bio(type, &in_key, in))
    257         && TEST_ptr(out = BIO_new(BIO_s_mem()))
    258         /* Save pkey params to binary */
    259         && TEST_int_gt(i2d_KeyParams_bio(out, in_key), 0)
    260         /* test the output binary is the expected value */
    261         && TEST_int_gt(out_len = BIO_get_mem_data(out, &out_bin), 0)
    262         && TEST_mem_eq(pkey_params[id].param_bin,
    263                        (int)pkey_params[id].param_bin_len,
    264                        out_bin, out_len);
    265 
    266     BIO_free(in);
    267     BIO_free(out);
    268     EVP_PKEY_free(in_key);
    269     EVP_PKEY_free(out_key);
    270     return ret;
    271 }
    272 
    273 static int set_enc_pubkey_test(int id)
    274 {
    275     int ret, i;
    276     BIO *in = NULL;
    277     EVP_PKEY *in_key = NULL;
    278     int type = pkey_params[id].type;
    279     const struct pubkey *keys = pkey_params[id].keys;
    280 
    281     if (keys[0].key_bin == NULL)
    282         return TEST_skip("Not applicable test");
    283 
    284     ret = TEST_ptr(in = BIO_new_mem_buf(pkey_params[id].param_bin,
    285                                         (int)pkey_params[id].param_bin_len))
    286         /* Load in pkey params from binary */
    287         && TEST_ptr(d2i_KeyParams_bio(type, &in_key, in));
    288 
    289     for (i = 0; ret && i < NUM_KEYS && keys[i].key_bin != NULL; i++) {
    290         if (keys[i].bad) {
    291             ERR_set_mark();
    292             ret = ret
    293                 && TEST_int_le(EVP_PKEY_set1_encoded_public_key(in_key,
    294                                                                 keys[i].key_bin,
    295                                                                 keys[i].key_bin_len),
    296                                0);
    297             ERR_pop_to_mark();
    298         } else {
    299             ret = ret
    300                 && TEST_int_gt(EVP_PKEY_set1_encoded_public_key(in_key,
    301                                                                 keys[i].key_bin,
    302                                                                 keys[i].key_bin_len),
    303                                0);
    304         }
    305         if (!ret)
    306             TEST_info("Test key index #%d", i);
    307     }
    308 
    309     BIO_free(in);
    310     EVP_PKEY_free(in_key);
    311     return ret;
    312 }
    313 #endif
    314 
    315 int setup_tests(void)
    316 {
    317 #ifdef OPENSSL_NO_KEYPARAMS
    318     TEST_note("No DH/DSA/EC support");
    319 #else
    320     ADD_ALL_TESTS(params_bio_test, OSSL_NELEM(pkey_params));
    321     ADD_ALL_TESTS(set_enc_pubkey_test, OSSL_NELEM(pkey_params));
    322 #endif
    323     return 1;
    324 }
    325