1/* BEGIN_HEADER */ 2#include "mbedtls/bignum.h" 3#include "mbedtls/x509_crt.h" 4#include "mbedtls/x509_csr.h" 5#include "mbedtls/pem.h" 6#include "mbedtls/oid.h" 7#include "mbedtls/rsa.h" 8 9#if defined(MBEDTLS_RSA_C) 10int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen, 11 const unsigned char *input, unsigned char *output, 12 size_t output_max_len ) 13{ 14 return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx, NULL, NULL, mode, olen, 15 input, output, output_max_len ) ); 16} 17int mbedtls_rsa_sign_func( void *ctx, 18 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, 19 int mode, mbedtls_md_type_t md_alg, unsigned int hashlen, 20 const unsigned char *hash, unsigned char *sig ) 21{ 22 return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx, f_rng, p_rng, mode, 23 md_alg, hashlen, hash, sig ) ); 24} 25size_t mbedtls_rsa_key_len_func( void *ctx ) 26{ 27 return( ((const mbedtls_rsa_context *) ctx)->len ); 28} 29#endif /* MBEDTLS_RSA_C */ 30 31#if defined(MBEDTLS_USE_PSA_CRYPTO) && \ 32 defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CSR_WRITE_C) 33static int x509_crt_verifycsr( const unsigned char *buf, size_t buflen ) 34{ 35 unsigned char hash[MBEDTLS_MD_MAX_SIZE]; 36 const mbedtls_md_info_t *md_info; 37 mbedtls_x509_csr csr; 38 int ret = 0; 39 40 mbedtls_x509_csr_init( &csr ); 41 42 if( mbedtls_x509_csr_parse( &csr, buf, buflen ) != 0 ) 43 { 44 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; 45 goto cleanup; 46 } 47 48 md_info = mbedtls_md_info_from_type( csr.sig_md ); 49 if( mbedtls_md( md_info, csr.cri.p, csr.cri.len, hash ) != 0 ) 50 { 51 /* Note: this can't happen except after an internal error */ 52 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; 53 goto cleanup; 54 } 55 56 if( mbedtls_pk_verify_ext( csr.sig_pk, csr.sig_opts, &csr.pk, 57 csr.sig_md, hash, mbedtls_md_get_size( md_info ), 58 csr.sig.p, csr.sig.len ) != 0 ) 59 { 60 ret = MBEDTLS_ERR_X509_CERT_VERIFY_FAILED; 61 goto cleanup; 62 } 63 64cleanup: 65 66 mbedtls_x509_csr_free( &csr ); 67 return( ret ); 68} 69#endif /* MBEDTLS_USE_PSA_CRYPTO && MBEDTLS_PEM_WRITE_C && MBEDTLS_X509_CSR_WRITE_C */ 70 71/* END_HEADER */ 72 73/* BEGIN_DEPENDENCIES 74 * depends_on:MBEDTLS_BIGNUM_C:MBEDTLS_FS_IO:MBEDTLS_PK_PARSE_C 75 * END_DEPENDENCIES 76 */ 77 78/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CSR_WRITE_C */ 79void x509_csr_check( char * key_file, char * cert_req_check_file, int md_type, 80 int key_usage, int set_key_usage, int cert_type, 81 int set_cert_type ) 82{ 83 mbedtls_pk_context key; 84 mbedtls_x509write_csr req; 85 unsigned char buf[4096]; 86 unsigned char check_buf[4000]; 87 int ret; 88 size_t olen = 0, pem_len = 0, buf_index; 89 int der_len = -1; 90 FILE *f; 91 const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; 92 mbedtls_test_rnd_pseudo_info rnd_info; 93 94 memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) ); 95 96 mbedtls_pk_init( &key ); 97 TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 ); 98 99 mbedtls_x509write_csr_init( &req ); 100 mbedtls_x509write_csr_set_md_alg( &req, md_type ); 101 mbedtls_x509write_csr_set_key( &req, &key ); 102 TEST_ASSERT( mbedtls_x509write_csr_set_subject_name( &req, subject_name ) == 0 ); 103 if( set_key_usage != 0 ) 104 TEST_ASSERT( mbedtls_x509write_csr_set_key_usage( &req, key_usage ) == 0 ); 105 if( set_cert_type != 0 ) 106 TEST_ASSERT( mbedtls_x509write_csr_set_ns_cert_type( &req, cert_type ) == 0 ); 107 108 ret = mbedtls_x509write_csr_pem( &req, buf, sizeof( buf ), 109 mbedtls_test_rnd_pseudo_rand, &rnd_info ); 110 TEST_ASSERT( ret == 0 ); 111 112 pem_len = strlen( (char *) buf ); 113 114 for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index ) 115 { 116 TEST_ASSERT( buf[buf_index] == 0 ); 117 } 118 119 f = fopen( cert_req_check_file, "r" ); 120 TEST_ASSERT( f != NULL ); 121 olen = fread( check_buf, 1, sizeof( check_buf ), f ); 122 fclose( f ); 123 124 TEST_ASSERT( olen >= pem_len - 1 ); 125 TEST_ASSERT( memcmp( buf, check_buf, pem_len - 1 ) == 0 ); 126 127 der_len = mbedtls_x509write_csr_der( &req, buf, sizeof( buf ), 128 mbedtls_test_rnd_pseudo_rand, 129 &rnd_info ); 130 TEST_ASSERT( der_len >= 0 ); 131 132 if( der_len == 0 ) 133 goto exit; 134 135 ret = mbedtls_x509write_csr_der( &req, buf, (size_t)( der_len - 1 ), 136 mbedtls_test_rnd_pseudo_rand, &rnd_info ); 137 TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); 138 139exit: 140 mbedtls_x509write_csr_free( &req ); 141 mbedtls_pk_free( &key ); 142} 143/* END_CASE */ 144 145/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CSR_WRITE_C:MBEDTLS_USE_PSA_CRYPTO */ 146void x509_csr_check_opaque( char *key_file, int md_type, int key_usage, 147 int cert_type ) 148{ 149 mbedtls_pk_context key; 150 mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT; 151 psa_algorithm_t md_alg_psa; 152 mbedtls_x509write_csr req; 153 unsigned char buf[4096]; 154 int ret; 155 size_t pem_len = 0; 156 const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; 157 mbedtls_test_rnd_pseudo_info rnd_info; 158 159 PSA_INIT( ); 160 memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) ); 161 162 md_alg_psa = mbedtls_psa_translate_md( (mbedtls_md_type_t) md_type ); 163 TEST_ASSERT( md_alg_psa != MBEDTLS_MD_NONE ); 164 165 mbedtls_pk_init( &key ); 166 TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 ); 167 TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &key, &key_id, md_alg_psa ) == 0 ); 168 169 mbedtls_x509write_csr_init( &req ); 170 mbedtls_x509write_csr_set_md_alg( &req, md_type ); 171 mbedtls_x509write_csr_set_key( &req, &key ); 172 TEST_ASSERT( mbedtls_x509write_csr_set_subject_name( &req, subject_name ) == 0 ); 173 if( key_usage != 0 ) 174 TEST_ASSERT( mbedtls_x509write_csr_set_key_usage( &req, key_usage ) == 0 ); 175 if( cert_type != 0 ) 176 TEST_ASSERT( mbedtls_x509write_csr_set_ns_cert_type( &req, cert_type ) == 0 ); 177 178 ret = mbedtls_x509write_csr_pem( &req, buf, sizeof( buf ) - 1, 179 mbedtls_test_rnd_pseudo_rand, &rnd_info ); 180 181 TEST_ASSERT( ret == 0 ); 182 183 pem_len = strlen( (char *) buf ); 184 buf[pem_len] = '\0'; 185 TEST_ASSERT( x509_crt_verifycsr( buf, pem_len + 1 ) == 0 ); 186 187 188exit: 189 mbedtls_x509write_csr_free( &req ); 190 mbedtls_pk_free( &key ); 191 psa_destroy_key( key_id ); 192 PSA_DONE( ); 193} 194/* END_CASE */ 195 196/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CRT_WRITE_C:MBEDTLS_SHA1_C */ 197void x509_crt_check( char *subject_key_file, char *subject_pwd, 198 char *subject_name, char *issuer_key_file, 199 char *issuer_pwd, char *issuer_name, 200 char *serial_str, char *not_before, char *not_after, 201 int md_type, int key_usage, int set_key_usage, 202 int cert_type, int set_cert_type, int auth_ident, 203 int ver, char *cert_check_file, int rsa_alt, int is_ca ) 204{ 205 mbedtls_pk_context subject_key, issuer_key, issuer_key_alt; 206 mbedtls_pk_context *key = &issuer_key; 207 208 mbedtls_x509write_cert crt; 209 unsigned char buf[4096]; 210 unsigned char check_buf[5000]; 211 mbedtls_mpi serial; 212 int ret; 213 size_t olen = 0, pem_len = 0, buf_index = 0; 214 int der_len = -1; 215 FILE *f; 216 mbedtls_test_rnd_pseudo_info rnd_info; 217 218 memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) ); 219 mbedtls_mpi_init( &serial ); 220 221 mbedtls_pk_init( &subject_key ); 222 mbedtls_pk_init( &issuer_key ); 223 mbedtls_pk_init( &issuer_key_alt ); 224 225 mbedtls_x509write_crt_init( &crt ); 226 227 TEST_ASSERT( mbedtls_pk_parse_keyfile( &subject_key, subject_key_file, 228 subject_pwd ) == 0 ); 229 230 TEST_ASSERT( mbedtls_pk_parse_keyfile( &issuer_key, issuer_key_file, 231 issuer_pwd ) == 0 ); 232 233#if defined(MBEDTLS_RSA_C) 234 /* For RSA PK contexts, create a copy as an alternative RSA context. */ 235 if( rsa_alt == 1 && mbedtls_pk_get_type( &issuer_key ) == MBEDTLS_PK_RSA ) 236 { 237 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &issuer_key_alt, 238 mbedtls_pk_rsa( issuer_key ), 239 mbedtls_rsa_decrypt_func, 240 mbedtls_rsa_sign_func, 241 mbedtls_rsa_key_len_func ) == 0 ); 242 243 key = &issuer_key_alt; 244 } 245#else 246 (void) rsa_alt; 247#endif 248 249 TEST_ASSERT( mbedtls_test_read_mpi( &serial, 10, serial_str ) == 0 ); 250 251 if( ver != -1 ) 252 mbedtls_x509write_crt_set_version( &crt, ver ); 253 254 TEST_ASSERT( mbedtls_x509write_crt_set_serial( &crt, &serial ) == 0 ); 255 TEST_ASSERT( mbedtls_x509write_crt_set_validity( &crt, not_before, 256 not_after ) == 0 ); 257 mbedtls_x509write_crt_set_md_alg( &crt, md_type ); 258 TEST_ASSERT( mbedtls_x509write_crt_set_issuer_name( &crt, issuer_name ) == 0 ); 259 TEST_ASSERT( mbedtls_x509write_crt_set_subject_name( &crt, subject_name ) == 0 ); 260 mbedtls_x509write_crt_set_subject_key( &crt, &subject_key ); 261 262 mbedtls_x509write_crt_set_issuer_key( &crt, key ); 263 264 if( crt.version >= MBEDTLS_X509_CRT_VERSION_3 ) 265 { 266 /* For the CA case, a path length of -1 means unlimited. */ 267 TEST_ASSERT( mbedtls_x509write_crt_set_basic_constraints( &crt, is_ca, 268 (is_ca ? -1 : 0) ) == 0 ); 269 TEST_ASSERT( mbedtls_x509write_crt_set_subject_key_identifier( &crt ) == 0 ); 270 if( auth_ident ) 271 TEST_ASSERT( mbedtls_x509write_crt_set_authority_key_identifier( &crt ) == 0 ); 272 if( set_key_usage != 0 ) 273 TEST_ASSERT( mbedtls_x509write_crt_set_key_usage( &crt, key_usage ) == 0 ); 274 if( set_cert_type != 0 ) 275 TEST_ASSERT( mbedtls_x509write_crt_set_ns_cert_type( &crt, cert_type ) == 0 ); 276 } 277 278 ret = mbedtls_x509write_crt_pem( &crt, buf, sizeof( buf ), 279 mbedtls_test_rnd_pseudo_rand, &rnd_info ); 280 TEST_ASSERT( ret == 0 ); 281 282 pem_len = strlen( (char *) buf ); 283 284 // check that the rest of the buffer remains clear 285 for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index ) 286 { 287 TEST_ASSERT( buf[buf_index] == 0 ); 288 } 289 290 f = fopen( cert_check_file, "r" ); 291 TEST_ASSERT( f != NULL ); 292 olen = fread( check_buf, 1, sizeof( check_buf ), f ); 293 fclose( f ); 294 TEST_ASSERT( olen < sizeof( check_buf ) ); 295 296 TEST_ASSERT( olen >= pem_len - 1 ); 297 TEST_ASSERT( memcmp( buf, check_buf, pem_len - 1 ) == 0 ); 298 299 der_len = mbedtls_x509write_crt_der( &crt, buf, sizeof( buf ), 300 mbedtls_test_rnd_pseudo_rand, 301 &rnd_info ); 302 TEST_ASSERT( der_len >= 0 ); 303 304 if( der_len == 0 ) 305 goto exit; 306 307 ret = mbedtls_x509write_crt_der( &crt, buf, (size_t)( der_len - 1 ), 308 mbedtls_test_rnd_pseudo_rand, &rnd_info ); 309 TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); 310 311exit: 312 mbedtls_x509write_crt_free( &crt ); 313 mbedtls_pk_free( &issuer_key_alt ); 314 mbedtls_pk_free( &subject_key ); 315 mbedtls_pk_free( &issuer_key ); 316 mbedtls_mpi_free( &serial ); 317} 318/* END_CASE */ 319 320/* BEGIN_CASE depends_on:MBEDTLS_X509_CREATE_C:MBEDTLS_X509_USE_C */ 321void mbedtls_x509_string_to_names( char * name, char * parsed_name, int result 322 ) 323{ 324 int ret; 325 size_t len = 0; 326 mbedtls_asn1_named_data *names = NULL; 327 mbedtls_x509_name parsed, *parsed_cur, *parsed_prv; 328 unsigned char buf[1024], out[1024], *c; 329 330 memset( &parsed, 0, sizeof( parsed ) ); 331 memset( out, 0, sizeof( out ) ); 332 memset( buf, 0, sizeof( buf ) ); 333 c = buf + sizeof( buf ); 334 335 ret = mbedtls_x509_string_to_names( &names, name ); 336 TEST_ASSERT( ret == result ); 337 338 if( ret != 0 ) 339 goto exit; 340 341 ret = mbedtls_x509_write_names( &c, buf, names ); 342 TEST_ASSERT( ret > 0 ); 343 344 TEST_ASSERT( mbedtls_asn1_get_tag( &c, buf + sizeof( buf ), &len, 345 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) == 0 ); 346 TEST_ASSERT( mbedtls_x509_get_name( &c, buf + sizeof( buf ), &parsed ) == 0 ); 347 348 ret = mbedtls_x509_dn_gets( (char *) out, sizeof( out ), &parsed ); 349 TEST_ASSERT( ret > 0 ); 350 351 TEST_ASSERT( strcmp( (char *) out, parsed_name ) == 0 ); 352 353exit: 354 mbedtls_asn1_free_named_data_list( &names ); 355 356 parsed_cur = parsed.next; 357 while( parsed_cur != 0 ) 358 { 359 parsed_prv = parsed_cur; 360 parsed_cur = parsed_cur->next; 361 mbedtls_free( parsed_prv ); 362 } 363} 364/* END_CASE */ 365