source: azure_iot_hub_mbedtls/trunk/mbedtls-2.16.1/library/pkparse.c@ 398

Last change on this file since 398 was 398, checked in by coas-nagasima, 5 years ago

mbedTLS版Azure IoT Hub接続サンプルのソースコードを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 43.8 KB
Line 
1/*
2 * Public Key layer for parsing key files and structures
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * This file is part of mbed TLS (https://tls.mbed.org)
20 */
21
22#if !defined(MBEDTLS_CONFIG_FILE)
23#include "mbedtls/config.h"
24#else
25#include MBEDTLS_CONFIG_FILE
26#endif
27
28#if defined(MBEDTLS_PK_PARSE_C)
29
30#include "mbedtls/pk.h"
31#include "mbedtls/asn1.h"
32#include "mbedtls/oid.h"
33#include "mbedtls/platform_util.h"
34
35#include <string.h>
36
37#if defined(MBEDTLS_RSA_C)
38#include "mbedtls/rsa.h"
39#endif
40#if defined(MBEDTLS_ECP_C)
41#include "mbedtls/ecp.h"
42#endif
43#if defined(MBEDTLS_ECDSA_C)
44#include "mbedtls/ecdsa.h"
45#endif
46#if defined(MBEDTLS_PEM_PARSE_C)
47#include "mbedtls/pem.h"
48#endif
49#if defined(MBEDTLS_PKCS5_C)
50#include "mbedtls/pkcs5.h"
51#endif
52#if defined(MBEDTLS_PKCS12_C)
53#include "mbedtls/pkcs12.h"
54#endif
55
56#if defined(MBEDTLS_PLATFORM_C)
57#include "mbedtls/platform.h"
58#else
59#include <stdlib.h>
60#define mbedtls_calloc calloc
61#define mbedtls_free free
62#endif
63
64/* Parameter validation macros based on platform_util.h */
65#define PK_VALIDATE_RET( cond ) \
66 MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_PK_BAD_INPUT_DATA )
67#define PK_VALIDATE( cond ) \
68 MBEDTLS_INTERNAL_VALIDATE( cond )
69
70#if defined(MBEDTLS_FS_IO)
71/*
72 * Load all data from a file into a given buffer.
73 *
74 * The file is expected to contain either PEM or DER encoded data.
75 * A terminating null byte is always appended. It is included in the announced
76 * length only if the data looks like it is PEM encoded.
77 */
78int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n )
79{
80 FILE *f;
81 long size;
82
83 PK_VALIDATE_RET( path != NULL );
84 PK_VALIDATE_RET( buf != NULL );
85 PK_VALIDATE_RET( n != NULL );
86
87 if( ( f = fopen( path, "rb" ) ) == NULL )
88 return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
89
90 fseek( f, 0, SEEK_END );
91 if( ( size = ftell( f ) ) == -1 )
92 {
93 fclose( f );
94 return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
95 }
96 fseek( f, 0, SEEK_SET );
97
98 *n = (size_t) size;
99
100 if( *n + 1 == 0 ||
101 ( *buf = mbedtls_calloc( 1, *n + 1 ) ) == NULL )
102 {
103 fclose( f );
104 return( MBEDTLS_ERR_PK_ALLOC_FAILED );
105 }
106
107 if( fread( *buf, 1, *n, f ) != *n )
108 {
109 fclose( f );
110
111 mbedtls_platform_zeroize( *buf, *n );
112 mbedtls_free( *buf );
113
114 return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
115 }
116
117 fclose( f );
118
119 (*buf)[*n] = '\0';
120
121 if( strstr( (const char *) *buf, "-----BEGIN " ) != NULL )
122 ++*n;
123
124 return( 0 );
125}
126
127/*
128 * Load and parse a private key
129 */
130int mbedtls_pk_parse_keyfile( mbedtls_pk_context *ctx,
131 const char *path, const char *pwd )
132{
133 int ret;
134 size_t n;
135 unsigned char *buf;
136
137 PK_VALIDATE_RET( ctx != NULL );
138 PK_VALIDATE_RET( path != NULL );
139
140 if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
141 return( ret );
142
143 if( pwd == NULL )
144 ret = mbedtls_pk_parse_key( ctx, buf, n, NULL, 0 );
145 else
146 ret = mbedtls_pk_parse_key( ctx, buf, n,
147 (const unsigned char *) pwd, strlen( pwd ) );
148
149 mbedtls_platform_zeroize( buf, n );
150 mbedtls_free( buf );
151
152 return( ret );
153}
154
155/*
156 * Load and parse a public key
157 */
158int mbedtls_pk_parse_public_keyfile( mbedtls_pk_context *ctx, const char *path )
159{
160 int ret;
161 size_t n;
162 unsigned char *buf;
163
164 PK_VALIDATE_RET( ctx != NULL );
165 PK_VALIDATE_RET( path != NULL );
166
167 if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
168 return( ret );
169
170 ret = mbedtls_pk_parse_public_key( ctx, buf, n );
171
172 mbedtls_platform_zeroize( buf, n );
173 mbedtls_free( buf );
174
175 return( ret );
176}
177#endif /* MBEDTLS_FS_IO */
178
179#if defined(MBEDTLS_ECP_C)
180/* Minimally parse an ECParameters buffer to and mbedtls_asn1_buf
181 *
182 * ECParameters ::= CHOICE {
183 * namedCurve OBJECT IDENTIFIER
184 * specifiedCurve SpecifiedECDomain -- = SEQUENCE { ... }
185 * -- implicitCurve NULL
186 * }
187 */
188static int pk_get_ecparams( unsigned char **p, const unsigned char *end,
189 mbedtls_asn1_buf *params )
190{
191 int ret;
192
193 if ( end - *p < 1 )
194 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
195 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
196
197 /* Tag may be either OID or SEQUENCE */
198 params->tag = **p;
199 if( params->tag != MBEDTLS_ASN1_OID
200#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
201 && params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE )
202#endif
203 )
204 {
205 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
206 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
207 }
208
209 if( ( ret = mbedtls_asn1_get_tag( p, end, &params->len, params->tag ) ) != 0 )
210 {
211 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
212 }
213
214 params->p = *p;
215 *p += params->len;
216
217 if( *p != end )
218 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
219 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
220
221 return( 0 );
222}
223
224#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
225/*
226 * Parse a SpecifiedECDomain (SEC 1 C.2) and (mostly) fill the group with it.
227 * WARNING: the resulting group should only be used with
228 * pk_group_id_from_specified(), since its base point may not be set correctly
229 * if it was encoded compressed.
230 *
231 * SpecifiedECDomain ::= SEQUENCE {
232 * version SpecifiedECDomainVersion(ecdpVer1 | ecdpVer2 | ecdpVer3, ...),
233 * fieldID FieldID {{FieldTypes}},
234 * curve Curve,
235 * base ECPoint,
236 * order INTEGER,
237 * cofactor INTEGER OPTIONAL,
238 * hash HashAlgorithm OPTIONAL,
239 * ...
240 * }
241 *
242 * We only support prime-field as field type, and ignore hash and cofactor.
243 */
244static int pk_group_from_specified( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
245{
246 int ret;
247 unsigned char *p = params->p;
248 const unsigned char * const end = params->p + params->len;
249 const unsigned char *end_field, *end_curve;
250 size_t len;
251 int ver;
252
253 /* SpecifiedECDomainVersion ::= INTEGER { 1, 2, 3 } */
254 if( ( ret = mbedtls_asn1_get_int( &p, end, &ver ) ) != 0 )
255 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
256
257 if( ver < 1 || ver > 3 )
258 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
259
260 /*
261 * FieldID { FIELD-ID:IOSet } ::= SEQUENCE { -- Finite field
262 * fieldType FIELD-ID.&id({IOSet}),
263 * parameters FIELD-ID.&Type({IOSet}{@fieldType})
264 * }
265 */
266 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
267 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
268 return( ret );
269
270 end_field = p + len;
271
272 /*
273 * FIELD-ID ::= TYPE-IDENTIFIER
274 * FieldTypes FIELD-ID ::= {
275 * { Prime-p IDENTIFIED BY prime-field } |
276 * { Characteristic-two IDENTIFIED BY characteristic-two-field }
277 * }
278 * prime-field OBJECT IDENTIFIER ::= { id-fieldType 1 }
279 */
280 if( ( ret = mbedtls_asn1_get_tag( &p, end_field, &len, MBEDTLS_ASN1_OID ) ) != 0 )
281 return( ret );
282
283 if( len != MBEDTLS_OID_SIZE( MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD ) ||
284 memcmp( p, MBEDTLS_OID_ANSI_X9_62_PRIME_FIELD, len ) != 0 )
285 {
286 return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
287 }
288
289 p += len;
290
291 /* Prime-p ::= INTEGER -- Field of size p. */
292 if( ( ret = mbedtls_asn1_get_mpi( &p, end_field, &grp->P ) ) != 0 )
293 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
294
295 grp->pbits = mbedtls_mpi_bitlen( &grp->P );
296
297 if( p != end_field )
298 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
299 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
300
301 /*
302 * Curve ::= SEQUENCE {
303 * a FieldElement,
304 * b FieldElement,
305 * seed BIT STRING OPTIONAL
306 * -- Shall be present if used in SpecifiedECDomain
307 * -- with version equal to ecdpVer2 or ecdpVer3
308 * }
309 */
310 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
311 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
312 return( ret );
313
314 end_curve = p + len;
315
316 /*
317 * FieldElement ::= OCTET STRING
318 * containing an integer in the case of a prime field
319 */
320 if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 ||
321 ( ret = mbedtls_mpi_read_binary( &grp->A, p, len ) ) != 0 )
322 {
323 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
324 }
325
326 p += len;
327
328 if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 ||
329 ( ret = mbedtls_mpi_read_binary( &grp->B, p, len ) ) != 0 )
330 {
331 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
332 }
333
334 p += len;
335
336 /* Ignore seed BIT STRING OPTIONAL */
337 if( ( ret = mbedtls_asn1_get_tag( &p, end_curve, &len, MBEDTLS_ASN1_BIT_STRING ) ) == 0 )
338 p += len;
339
340 if( p != end_curve )
341 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
342 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
343
344 /*
345 * ECPoint ::= OCTET STRING
346 */
347 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
348 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
349
350 if( ( ret = mbedtls_ecp_point_read_binary( grp, &grp->G,
351 ( const unsigned char *) p, len ) ) != 0 )
352 {
353 /*
354 * If we can't read the point because it's compressed, cheat by
355 * reading only the X coordinate and the parity bit of Y.
356 */
357 if( ret != MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE ||
358 ( p[0] != 0x02 && p[0] != 0x03 ) ||
359 len != mbedtls_mpi_size( &grp->P ) + 1 ||
360 mbedtls_mpi_read_binary( &grp->G.X, p + 1, len - 1 ) != 0 ||
361 mbedtls_mpi_lset( &grp->G.Y, p[0] - 2 ) != 0 ||
362 mbedtls_mpi_lset( &grp->G.Z, 1 ) != 0 )
363 {
364 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
365 }
366 }
367
368 p += len;
369
370 /*
371 * order INTEGER
372 */
373 if( ( ret = mbedtls_asn1_get_mpi( &p, end, &grp->N ) ) != 0 )
374 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
375
376 grp->nbits = mbedtls_mpi_bitlen( &grp->N );
377
378 /*
379 * Allow optional elements by purposefully not enforcing p == end here.
380 */
381
382 return( 0 );
383}
384
385/*
386 * Find the group id associated with an (almost filled) group as generated by
387 * pk_group_from_specified(), or return an error if unknown.
388 */
389static int pk_group_id_from_group( const mbedtls_ecp_group *grp, mbedtls_ecp_group_id *grp_id )
390{
391 int ret = 0;
392 mbedtls_ecp_group ref;
393 const mbedtls_ecp_group_id *id;
394
395 mbedtls_ecp_group_init( &ref );
396
397 for( id = mbedtls_ecp_grp_id_list(); *id != MBEDTLS_ECP_DP_NONE; id++ )
398 {
399 /* Load the group associated to that id */
400 mbedtls_ecp_group_free( &ref );
401 MBEDTLS_MPI_CHK( mbedtls_ecp_group_load( &ref, *id ) );
402
403 /* Compare to the group we were given, starting with easy tests */
404 if( grp->pbits == ref.pbits && grp->nbits == ref.nbits &&
405 mbedtls_mpi_cmp_mpi( &grp->P, &ref.P ) == 0 &&
406 mbedtls_mpi_cmp_mpi( &grp->A, &ref.A ) == 0 &&
407 mbedtls_mpi_cmp_mpi( &grp->B, &ref.B ) == 0 &&
408 mbedtls_mpi_cmp_mpi( &grp->N, &ref.N ) == 0 &&
409 mbedtls_mpi_cmp_mpi( &grp->G.X, &ref.G.X ) == 0 &&
410 mbedtls_mpi_cmp_mpi( &grp->G.Z, &ref.G.Z ) == 0 &&
411 /* For Y we may only know the parity bit, so compare only that */
412 mbedtls_mpi_get_bit( &grp->G.Y, 0 ) == mbedtls_mpi_get_bit( &ref.G.Y, 0 ) )
413 {
414 break;
415 }
416
417 }
418
419cleanup:
420 mbedtls_ecp_group_free( &ref );
421
422 *grp_id = *id;
423
424 if( ret == 0 && *id == MBEDTLS_ECP_DP_NONE )
425 ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
426
427 return( ret );
428}
429
430/*
431 * Parse a SpecifiedECDomain (SEC 1 C.2) and find the associated group ID
432 */
433static int pk_group_id_from_specified( const mbedtls_asn1_buf *params,
434 mbedtls_ecp_group_id *grp_id )
435{
436 int ret;
437 mbedtls_ecp_group grp;
438
439 mbedtls_ecp_group_init( &grp );
440
441 if( ( ret = pk_group_from_specified( params, &grp ) ) != 0 )
442 goto cleanup;
443
444 ret = pk_group_id_from_group( &grp, grp_id );
445
446cleanup:
447 mbedtls_ecp_group_free( &grp );
448
449 return( ret );
450}
451#endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
452
453/*
454 * Use EC parameters to initialise an EC group
455 *
456 * ECParameters ::= CHOICE {
457 * namedCurve OBJECT IDENTIFIER
458 * specifiedCurve SpecifiedECDomain -- = SEQUENCE { ... }
459 * -- implicitCurve NULL
460 */
461static int pk_use_ecparams( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
462{
463 int ret;
464 mbedtls_ecp_group_id grp_id;
465
466 if( params->tag == MBEDTLS_ASN1_OID )
467 {
468 if( mbedtls_oid_get_ec_grp( params, &grp_id ) != 0 )
469 return( MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE );
470 }
471 else
472 {
473#if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
474 if( ( ret = pk_group_id_from_specified( params, &grp_id ) ) != 0 )
475 return( ret );
476#else
477 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
478#endif
479 }
480
481 /*
482 * grp may already be initilialized; if so, make sure IDs match
483 */
484 if( grp->id != MBEDTLS_ECP_DP_NONE && grp->id != grp_id )
485 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
486
487 if( ( ret = mbedtls_ecp_group_load( grp, grp_id ) ) != 0 )
488 return( ret );
489
490 return( 0 );
491}
492
493/*
494 * EC public key is an EC point
495 *
496 * The caller is responsible for clearing the structure upon failure if
497 * desired. Take care to pass along the possible ECP_FEATURE_UNAVAILABLE
498 * return code of mbedtls_ecp_point_read_binary() and leave p in a usable state.
499 */
500static int pk_get_ecpubkey( unsigned char **p, const unsigned char *end,
501 mbedtls_ecp_keypair *key )
502{
503 int ret;
504
505 if( ( ret = mbedtls_ecp_point_read_binary( &key->grp, &key->Q,
506 (const unsigned char *) *p, end - *p ) ) == 0 )
507 {
508 ret = mbedtls_ecp_check_pubkey( &key->grp, &key->Q );
509 }
510
511 /*
512 * We know mbedtls_ecp_point_read_binary consumed all bytes or failed
513 */
514 *p = (unsigned char *) end;
515
516 return( ret );
517}
518#endif /* MBEDTLS_ECP_C */
519
520#if defined(MBEDTLS_RSA_C)
521/*
522 * RSAPublicKey ::= SEQUENCE {
523 * modulus INTEGER, -- n
524 * publicExponent INTEGER -- e
525 * }
526 */
527static int pk_get_rsapubkey( unsigned char **p,
528 const unsigned char *end,
529 mbedtls_rsa_context *rsa )
530{
531 int ret;
532 size_t len;
533
534 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
535 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
536 return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
537
538 if( *p + len != end )
539 return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
540 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
541
542 /* Import N */
543 if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
544 return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
545
546 if( ( ret = mbedtls_rsa_import_raw( rsa, *p, len, NULL, 0, NULL, 0,
547 NULL, 0, NULL, 0 ) ) != 0 )
548 return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
549
550 *p += len;
551
552 /* Import E */
553 if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
554 return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
555
556 if( ( ret = mbedtls_rsa_import_raw( rsa, NULL, 0, NULL, 0, NULL, 0,
557 NULL, 0, *p, len ) ) != 0 )
558 return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
559
560 *p += len;
561
562 if( mbedtls_rsa_complete( rsa ) != 0 ||
563 mbedtls_rsa_check_pubkey( rsa ) != 0 )
564 {
565 return( MBEDTLS_ERR_PK_INVALID_PUBKEY );
566 }
567
568 if( *p != end )
569 return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
570 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
571
572 return( 0 );
573}
574#endif /* MBEDTLS_RSA_C */
575
576/* Get a PK algorithm identifier
577 *
578 * AlgorithmIdentifier ::= SEQUENCE {
579 * algorithm OBJECT IDENTIFIER,
580 * parameters ANY DEFINED BY algorithm OPTIONAL }
581 */
582static int pk_get_pk_alg( unsigned char **p,
583 const unsigned char *end,
584 mbedtls_pk_type_t *pk_alg, mbedtls_asn1_buf *params )
585{
586 int ret;
587 mbedtls_asn1_buf alg_oid;
588
589 memset( params, 0, sizeof(mbedtls_asn1_buf) );
590
591 if( ( ret = mbedtls_asn1_get_alg( p, end, &alg_oid, params ) ) != 0 )
592 return( MBEDTLS_ERR_PK_INVALID_ALG + ret );
593
594 if( mbedtls_oid_get_pk_alg( &alg_oid, pk_alg ) != 0 )
595 return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
596
597 /*
598 * No parameters with RSA (only for EC)
599 */
600 if( *pk_alg == MBEDTLS_PK_RSA &&
601 ( ( params->tag != MBEDTLS_ASN1_NULL && params->tag != 0 ) ||
602 params->len != 0 ) )
603 {
604 return( MBEDTLS_ERR_PK_INVALID_ALG );
605 }
606
607 return( 0 );
608}
609
610/*
611 * SubjectPublicKeyInfo ::= SEQUENCE {
612 * algorithm AlgorithmIdentifier,
613 * subjectPublicKey BIT STRING }
614 */
615int mbedtls_pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
616 mbedtls_pk_context *pk )
617{
618 int ret;
619 size_t len;
620 mbedtls_asn1_buf alg_params;
621 mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
622 const mbedtls_pk_info_t *pk_info;
623
624 PK_VALIDATE_RET( p != NULL );
625 PK_VALIDATE_RET( *p != NULL );
626 PK_VALIDATE_RET( end != NULL );
627 PK_VALIDATE_RET( pk != NULL );
628
629 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
630 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
631 {
632 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
633 }
634
635 end = *p + len;
636
637 if( ( ret = pk_get_pk_alg( p, end, &pk_alg, &alg_params ) ) != 0 )
638 return( ret );
639
640 if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
641 return( MBEDTLS_ERR_PK_INVALID_PUBKEY + ret );
642
643 if( *p + len != end )
644 return( MBEDTLS_ERR_PK_INVALID_PUBKEY +
645 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
646
647 if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
648 return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
649
650 if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 )
651 return( ret );
652
653#if defined(MBEDTLS_RSA_C)
654 if( pk_alg == MBEDTLS_PK_RSA )
655 {
656 ret = pk_get_rsapubkey( p, end, mbedtls_pk_rsa( *pk ) );
657 } else
658#endif /* MBEDTLS_RSA_C */
659#if defined(MBEDTLS_ECP_C)
660 if( pk_alg == MBEDTLS_PK_ECKEY_DH || pk_alg == MBEDTLS_PK_ECKEY )
661 {
662 ret = pk_use_ecparams( &alg_params, &mbedtls_pk_ec( *pk )->grp );
663 if( ret == 0 )
664 ret = pk_get_ecpubkey( p, end, mbedtls_pk_ec( *pk ) );
665 } else
666#endif /* MBEDTLS_ECP_C */
667 ret = MBEDTLS_ERR_PK_UNKNOWN_PK_ALG;
668
669 if( ret == 0 && *p != end )
670 ret = MBEDTLS_ERR_PK_INVALID_PUBKEY
671 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
672
673 if( ret != 0 )
674 mbedtls_pk_free( pk );
675
676 return( ret );
677}
678
679#if defined(MBEDTLS_RSA_C)
680/*
681 * Parse a PKCS#1 encoded private RSA key
682 */
683static int pk_parse_key_pkcs1_der( mbedtls_rsa_context *rsa,
684 const unsigned char *key,
685 size_t keylen )
686{
687 int ret, version;
688 size_t len;
689 unsigned char *p, *end;
690
691 mbedtls_mpi T;
692 mbedtls_mpi_init( &T );
693
694 p = (unsigned char *) key;
695 end = p + keylen;
696
697 /*
698 * This function parses the RSAPrivateKey (PKCS#1)
699 *
700 * RSAPrivateKey ::= SEQUENCE {
701 * version Version,
702 * modulus INTEGER, -- n
703 * publicExponent INTEGER, -- e
704 * privateExponent INTEGER, -- d
705 * prime1 INTEGER, -- p
706 * prime2 INTEGER, -- q
707 * exponent1 INTEGER, -- d mod (p-1)
708 * exponent2 INTEGER, -- d mod (q-1)
709 * coefficient INTEGER, -- (inverse of q) mod p
710 * otherPrimeInfos OtherPrimeInfos OPTIONAL
711 * }
712 */
713 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
714 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
715 {
716 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
717 }
718
719 end = p + len;
720
721 if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
722 {
723 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
724 }
725
726 if( version != 0 )
727 {
728 return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION );
729 }
730
731 /* Import N */
732 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
733 MBEDTLS_ASN1_INTEGER ) ) != 0 ||
734 ( ret = mbedtls_rsa_import_raw( rsa, p, len, NULL, 0, NULL, 0,
735 NULL, 0, NULL, 0 ) ) != 0 )
736 goto cleanup;
737 p += len;
738
739 /* Import E */
740 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
741 MBEDTLS_ASN1_INTEGER ) ) != 0 ||
742 ( ret = mbedtls_rsa_import_raw( rsa, NULL, 0, NULL, 0, NULL, 0,
743 NULL, 0, p, len ) ) != 0 )
744 goto cleanup;
745 p += len;
746
747 /* Import D */
748 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
749 MBEDTLS_ASN1_INTEGER ) ) != 0 ||
750 ( ret = mbedtls_rsa_import_raw( rsa, NULL, 0, NULL, 0, NULL, 0,
751 p, len, NULL, 0 ) ) != 0 )
752 goto cleanup;
753 p += len;
754
755 /* Import P */
756 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
757 MBEDTLS_ASN1_INTEGER ) ) != 0 ||
758 ( ret = mbedtls_rsa_import_raw( rsa, NULL, 0, p, len, NULL, 0,
759 NULL, 0, NULL, 0 ) ) != 0 )
760 goto cleanup;
761 p += len;
762
763 /* Import Q */
764 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
765 MBEDTLS_ASN1_INTEGER ) ) != 0 ||
766 ( ret = mbedtls_rsa_import_raw( rsa, NULL, 0, NULL, 0, p, len,
767 NULL, 0, NULL, 0 ) ) != 0 )
768 goto cleanup;
769 p += len;
770
771 /* Complete the RSA private key */
772 if( ( ret = mbedtls_rsa_complete( rsa ) ) != 0 )
773 goto cleanup;
774
775 /* Check optional parameters */
776 if( ( ret = mbedtls_asn1_get_mpi( &p, end, &T ) ) != 0 ||
777 ( ret = mbedtls_asn1_get_mpi( &p, end, &T ) ) != 0 ||
778 ( ret = mbedtls_asn1_get_mpi( &p, end, &T ) ) != 0 )
779 goto cleanup;
780
781 if( p != end )
782 {
783 ret = MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
784 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ;
785 }
786
787cleanup:
788
789 mbedtls_mpi_free( &T );
790
791 if( ret != 0 )
792 {
793 /* Wrap error code if it's coming from a lower level */
794 if( ( ret & 0xff80 ) == 0 )
795 ret = MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret;
796 else
797 ret = MBEDTLS_ERR_PK_KEY_INVALID_FORMAT;
798
799 mbedtls_rsa_free( rsa );
800 }
801
802 return( ret );
803}
804#endif /* MBEDTLS_RSA_C */
805
806#if defined(MBEDTLS_ECP_C)
807/*
808 * Parse a SEC1 encoded private EC key
809 */
810static int pk_parse_key_sec1_der( mbedtls_ecp_keypair *eck,
811 const unsigned char *key,
812 size_t keylen )
813{
814 int ret;
815 int version, pubkey_done;
816 size_t len;
817 mbedtls_asn1_buf params;
818 unsigned char *p = (unsigned char *) key;
819 unsigned char *end = p + keylen;
820 unsigned char *end2;
821
822 /*
823 * RFC 5915, or SEC1 Appendix C.4
824 *
825 * ECPrivateKey ::= SEQUENCE {
826 * version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
827 * privateKey OCTET STRING,
828 * parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
829 * publicKey [1] BIT STRING OPTIONAL
830 * }
831 */
832 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
833 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
834 {
835 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
836 }
837
838 end = p + len;
839
840 if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
841 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
842
843 if( version != 1 )
844 return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION );
845
846 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
847 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
848
849 if( ( ret = mbedtls_mpi_read_binary( &eck->d, p, len ) ) != 0 )
850 {
851 mbedtls_ecp_keypair_free( eck );
852 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
853 }
854
855 p += len;
856
857 pubkey_done = 0;
858 if( p != end )
859 {
860 /*
861 * Is 'parameters' present?
862 */
863 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
864 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) == 0 )
865 {
866 if( ( ret = pk_get_ecparams( &p, p + len, &params) ) != 0 ||
867 ( ret = pk_use_ecparams( &params, &eck->grp ) ) != 0 )
868 {
869 mbedtls_ecp_keypair_free( eck );
870 return( ret );
871 }
872 }
873 else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
874 {
875 mbedtls_ecp_keypair_free( eck );
876 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
877 }
878 }
879
880 if( p != end )
881 {
882 /*
883 * Is 'publickey' present? If not, or if we can't read it (eg because it
884 * is compressed), create it from the private key.
885 */
886 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
887 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) ) == 0 )
888 {
889 end2 = p + len;
890
891 if( ( ret = mbedtls_asn1_get_bitstring_null( &p, end2, &len ) ) != 0 )
892 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
893
894 if( p + len != end2 )
895 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
896 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
897
898 if( ( ret = pk_get_ecpubkey( &p, end2, eck ) ) == 0 )
899 pubkey_done = 1;
900 else
901 {
902 /*
903 * The only acceptable failure mode of pk_get_ecpubkey() above
904 * is if the point format is not recognized.
905 */
906 if( ret != MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE )
907 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
908 }
909 }
910 else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
911 {
912 mbedtls_ecp_keypair_free( eck );
913 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
914 }
915 }
916
917 if( ! pubkey_done &&
918 ( ret = mbedtls_ecp_mul( &eck->grp, &eck->Q, &eck->d, &eck->grp.G,
919 NULL, NULL ) ) != 0 )
920 {
921 mbedtls_ecp_keypair_free( eck );
922 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
923 }
924
925 if( ( ret = mbedtls_ecp_check_privkey( &eck->grp, &eck->d ) ) != 0 )
926 {
927 mbedtls_ecp_keypair_free( eck );
928 return( ret );
929 }
930
931 return( 0 );
932}
933#endif /* MBEDTLS_ECP_C */
934
935/*
936 * Parse an unencrypted PKCS#8 encoded private key
937 *
938 * Notes:
939 *
940 * - This function does not own the key buffer. It is the
941 * responsibility of the caller to take care of zeroizing
942 * and freeing it after use.
943 *
944 * - The function is responsible for freeing the provided
945 * PK context on failure.
946 *
947 */
948static int pk_parse_key_pkcs8_unencrypted_der(
949 mbedtls_pk_context *pk,
950 const unsigned char* key,
951 size_t keylen )
952{
953 int ret, version;
954 size_t len;
955 mbedtls_asn1_buf params;
956 unsigned char *p = (unsigned char *) key;
957 unsigned char *end = p + keylen;
958 mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
959 const mbedtls_pk_info_t *pk_info;
960
961 /*
962 * This function parses the PrivateKeyInfo object (PKCS#8 v1.2 = RFC 5208)
963 *
964 * PrivateKeyInfo ::= SEQUENCE {
965 * version Version,
966 * privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,
967 * privateKey PrivateKey,
968 * attributes [0] IMPLICIT Attributes OPTIONAL }
969 *
970 * Version ::= INTEGER
971 * PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier
972 * PrivateKey ::= OCTET STRING
973 *
974 * The PrivateKey OCTET STRING is a SEC1 ECPrivateKey
975 */
976
977 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
978 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
979 {
980 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
981 }
982
983 end = p + len;
984
985 if( ( ret = mbedtls_asn1_get_int( &p, end, &version ) ) != 0 )
986 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
987
988 if( version != 0 )
989 return( MBEDTLS_ERR_PK_KEY_INVALID_VERSION + ret );
990
991 if( ( ret = pk_get_pk_alg( &p, end, &pk_alg, &params ) ) != 0 )
992 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
993
994 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
995 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
996
997 if( len < 1 )
998 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT +
999 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
1000
1001 if( ( pk_info = mbedtls_pk_info_from_type( pk_alg ) ) == NULL )
1002 return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
1003
1004 if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 )
1005 return( ret );
1006
1007#if defined(MBEDTLS_RSA_C)
1008 if( pk_alg == MBEDTLS_PK_RSA )
1009 {
1010 if( ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ), p, len ) ) != 0 )
1011 {
1012 mbedtls_pk_free( pk );
1013 return( ret );
1014 }
1015 } else
1016#endif /* MBEDTLS_RSA_C */
1017#if defined(MBEDTLS_ECP_C)
1018 if( pk_alg == MBEDTLS_PK_ECKEY || pk_alg == MBEDTLS_PK_ECKEY_DH )
1019 {
1020 if( ( ret = pk_use_ecparams( &params, &mbedtls_pk_ec( *pk )->grp ) ) != 0 ||
1021 ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ), p, len ) ) != 0 )
1022 {
1023 mbedtls_pk_free( pk );
1024 return( ret );
1025 }
1026 } else
1027#endif /* MBEDTLS_ECP_C */
1028 return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
1029
1030 return( 0 );
1031}
1032
1033/*
1034 * Parse an encrypted PKCS#8 encoded private key
1035 *
1036 * To save space, the decryption happens in-place on the given key buffer.
1037 * Also, while this function may modify the keybuffer, it doesn't own it,
1038 * and instead it is the responsibility of the caller to zeroize and properly
1039 * free it after use.
1040 *
1041 */
1042#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
1043static int pk_parse_key_pkcs8_encrypted_der(
1044 mbedtls_pk_context *pk,
1045 unsigned char *key, size_t keylen,
1046 const unsigned char *pwd, size_t pwdlen )
1047{
1048 int ret, decrypted = 0;
1049 size_t len;
1050 unsigned char *buf;
1051 unsigned char *p, *end;
1052 mbedtls_asn1_buf pbe_alg_oid, pbe_params;
1053#if defined(MBEDTLS_PKCS12_C)
1054 mbedtls_cipher_type_t cipher_alg;
1055 mbedtls_md_type_t md_alg;
1056#endif
1057
1058 p = key;
1059 end = p + keylen;
1060
1061 if( pwdlen == 0 )
1062 return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
1063
1064 /*
1065 * This function parses the EncryptedPrivateKeyInfo object (PKCS#8)
1066 *
1067 * EncryptedPrivateKeyInfo ::= SEQUENCE {
1068 * encryptionAlgorithm EncryptionAlgorithmIdentifier,
1069 * encryptedData EncryptedData
1070 * }
1071 *
1072 * EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
1073 *
1074 * EncryptedData ::= OCTET STRING
1075 *
1076 * The EncryptedData OCTET STRING is a PKCS#8 PrivateKeyInfo
1077 *
1078 */
1079 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
1080 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
1081 {
1082 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
1083 }
1084
1085 end = p + len;
1086
1087 if( ( ret = mbedtls_asn1_get_alg( &p, end, &pbe_alg_oid, &pbe_params ) ) != 0 )
1088 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
1089
1090 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
1091 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT + ret );
1092
1093 buf = p;
1094
1095 /*
1096 * Decrypt EncryptedData with appropriate PBE
1097 */
1098#if defined(MBEDTLS_PKCS12_C)
1099 if( mbedtls_oid_get_pkcs12_pbe_alg( &pbe_alg_oid, &md_alg, &cipher_alg ) == 0 )
1100 {
1101 if( ( ret = mbedtls_pkcs12_pbe( &pbe_params, MBEDTLS_PKCS12_PBE_DECRYPT,
1102 cipher_alg, md_alg,
1103 pwd, pwdlen, p, len, buf ) ) != 0 )
1104 {
1105 if( ret == MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH )
1106 return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
1107
1108 return( ret );
1109 }
1110
1111 decrypted = 1;
1112 }
1113 else if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS12_PBE_SHA1_RC4_128, &pbe_alg_oid ) == 0 )
1114 {
1115 if( ( ret = mbedtls_pkcs12_pbe_sha1_rc4_128( &pbe_params,
1116 MBEDTLS_PKCS12_PBE_DECRYPT,
1117 pwd, pwdlen,
1118 p, len, buf ) ) != 0 )
1119 {
1120 return( ret );
1121 }
1122
1123 // Best guess for password mismatch when using RC4. If first tag is
1124 // not MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE
1125 //
1126 if( *buf != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
1127 return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
1128
1129 decrypted = 1;
1130 }
1131 else
1132#endif /* MBEDTLS_PKCS12_C */
1133#if defined(MBEDTLS_PKCS5_C)
1134 if( MBEDTLS_OID_CMP( MBEDTLS_OID_PKCS5_PBES2, &pbe_alg_oid ) == 0 )
1135 {
1136 if( ( ret = mbedtls_pkcs5_pbes2( &pbe_params, MBEDTLS_PKCS5_DECRYPT, pwd, pwdlen,
1137 p, len, buf ) ) != 0 )
1138 {
1139 if( ret == MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH )
1140 return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
1141
1142 return( ret );
1143 }
1144
1145 decrypted = 1;
1146 }
1147 else
1148#endif /* MBEDTLS_PKCS5_C */
1149 {
1150 ((void) pwd);
1151 }
1152
1153 if( decrypted == 0 )
1154 return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
1155
1156 return( pk_parse_key_pkcs8_unencrypted_der( pk, buf, len ) );
1157}
1158#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
1159
1160/*
1161 * Parse a private key
1162 */
1163int mbedtls_pk_parse_key( mbedtls_pk_context *pk,
1164 const unsigned char *key, size_t keylen,
1165 const unsigned char *pwd, size_t pwdlen )
1166{
1167 int ret;
1168 const mbedtls_pk_info_t *pk_info;
1169#if defined(MBEDTLS_PEM_PARSE_C)
1170 size_t len;
1171 mbedtls_pem_context pem;
1172#endif
1173
1174 PK_VALIDATE_RET( pk != NULL );
1175 if( keylen == 0 )
1176 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
1177 PK_VALIDATE_RET( key != NULL );
1178
1179#if defined(MBEDTLS_PEM_PARSE_C)
1180 mbedtls_pem_init( &pem );
1181
1182#if defined(MBEDTLS_RSA_C)
1183 /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
1184 if( key[keylen - 1] != '\0' )
1185 ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
1186 else
1187 ret = mbedtls_pem_read_buffer( &pem,
1188 "-----BEGIN RSA PRIVATE KEY-----",
1189 "-----END RSA PRIVATE KEY-----",
1190 key, pwd, pwdlen, &len );
1191
1192 if( ret == 0 )
1193 {
1194 pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA );
1195 if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 ||
1196 ( ret = pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ),
1197 pem.buf, pem.buflen ) ) != 0 )
1198 {
1199 mbedtls_pk_free( pk );
1200 }
1201
1202 mbedtls_pem_free( &pem );
1203 return( ret );
1204 }
1205 else if( ret == MBEDTLS_ERR_PEM_PASSWORD_MISMATCH )
1206 return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
1207 else if( ret == MBEDTLS_ERR_PEM_PASSWORD_REQUIRED )
1208 return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
1209 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1210 return( ret );
1211#endif /* MBEDTLS_RSA_C */
1212
1213#if defined(MBEDTLS_ECP_C)
1214 /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
1215 if( key[keylen - 1] != '\0' )
1216 ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
1217 else
1218 ret = mbedtls_pem_read_buffer( &pem,
1219 "-----BEGIN EC PRIVATE KEY-----",
1220 "-----END EC PRIVATE KEY-----",
1221 key, pwd, pwdlen, &len );
1222 if( ret == 0 )
1223 {
1224 pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY );
1225
1226 if( ( ret = mbedtls_pk_setup( pk, pk_info ) ) != 0 ||
1227 ( ret = pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ),
1228 pem.buf, pem.buflen ) ) != 0 )
1229 {
1230 mbedtls_pk_free( pk );
1231 }
1232
1233 mbedtls_pem_free( &pem );
1234 return( ret );
1235 }
1236 else if( ret == MBEDTLS_ERR_PEM_PASSWORD_MISMATCH )
1237 return( MBEDTLS_ERR_PK_PASSWORD_MISMATCH );
1238 else if( ret == MBEDTLS_ERR_PEM_PASSWORD_REQUIRED )
1239 return( MBEDTLS_ERR_PK_PASSWORD_REQUIRED );
1240 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1241 return( ret );
1242#endif /* MBEDTLS_ECP_C */
1243
1244 /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
1245 if( key[keylen - 1] != '\0' )
1246 ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
1247 else
1248 ret = mbedtls_pem_read_buffer( &pem,
1249 "-----BEGIN PRIVATE KEY-----",
1250 "-----END PRIVATE KEY-----",
1251 key, NULL, 0, &len );
1252 if( ret == 0 )
1253 {
1254 if( ( ret = pk_parse_key_pkcs8_unencrypted_der( pk,
1255 pem.buf, pem.buflen ) ) != 0 )
1256 {
1257 mbedtls_pk_free( pk );
1258 }
1259
1260 mbedtls_pem_free( &pem );
1261 return( ret );
1262 }
1263 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1264 return( ret );
1265
1266#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
1267 /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
1268 if( key[keylen - 1] != '\0' )
1269 ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
1270 else
1271 ret = mbedtls_pem_read_buffer( &pem,
1272 "-----BEGIN ENCRYPTED PRIVATE KEY-----",
1273 "-----END ENCRYPTED PRIVATE KEY-----",
1274 key, NULL, 0, &len );
1275 if( ret == 0 )
1276 {
1277 if( ( ret = pk_parse_key_pkcs8_encrypted_der( pk,
1278 pem.buf, pem.buflen,
1279 pwd, pwdlen ) ) != 0 )
1280 {
1281 mbedtls_pk_free( pk );
1282 }
1283
1284 mbedtls_pem_free( &pem );
1285 return( ret );
1286 }
1287 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1288 return( ret );
1289#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
1290#else
1291 ((void) pwd);
1292 ((void) pwdlen);
1293#endif /* MBEDTLS_PEM_PARSE_C */
1294
1295 /*
1296 * At this point we only know it's not a PEM formatted key. Could be any
1297 * of the known DER encoded private key formats
1298 *
1299 * We try the different DER format parsers to see if one passes without
1300 * error
1301 */
1302#if defined(MBEDTLS_PKCS12_C) || defined(MBEDTLS_PKCS5_C)
1303 {
1304 unsigned char *key_copy;
1305
1306 if( ( key_copy = mbedtls_calloc( 1, keylen ) ) == NULL )
1307 return( MBEDTLS_ERR_PK_ALLOC_FAILED );
1308
1309 memcpy( key_copy, key, keylen );
1310
1311 ret = pk_parse_key_pkcs8_encrypted_der( pk, key_copy, keylen,
1312 pwd, pwdlen );
1313
1314 mbedtls_platform_zeroize( key_copy, keylen );
1315 mbedtls_free( key_copy );
1316 }
1317
1318 if( ret == 0 )
1319 return( 0 );
1320
1321 mbedtls_pk_free( pk );
1322 mbedtls_pk_init( pk );
1323
1324 if( ret == MBEDTLS_ERR_PK_PASSWORD_MISMATCH )
1325 {
1326 return( ret );
1327 }
1328#endif /* MBEDTLS_PKCS12_C || MBEDTLS_PKCS5_C */
1329
1330 if( ( ret = pk_parse_key_pkcs8_unencrypted_der( pk, key, keylen ) ) == 0 )
1331 return( 0 );
1332
1333 mbedtls_pk_free( pk );
1334 mbedtls_pk_init( pk );
1335
1336#if defined(MBEDTLS_RSA_C)
1337
1338 pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA );
1339 if( mbedtls_pk_setup( pk, pk_info ) == 0 &&
1340 pk_parse_key_pkcs1_der( mbedtls_pk_rsa( *pk ), key, keylen ) == 0 )
1341 {
1342 return( 0 );
1343 }
1344
1345 mbedtls_pk_free( pk );
1346 mbedtls_pk_init( pk );
1347#endif /* MBEDTLS_RSA_C */
1348
1349#if defined(MBEDTLS_ECP_C)
1350 pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY );
1351 if( mbedtls_pk_setup( pk, pk_info ) == 0 &&
1352 pk_parse_key_sec1_der( mbedtls_pk_ec( *pk ),
1353 key, keylen ) == 0 )
1354 {
1355 return( 0 );
1356 }
1357 mbedtls_pk_free( pk );
1358#endif /* MBEDTLS_ECP_C */
1359
1360 /* If MBEDTLS_RSA_C is defined but MBEDTLS_ECP_C isn't,
1361 * it is ok to leave the PK context initialized but not
1362 * freed: It is the caller's responsibility to call pk_init()
1363 * before calling this function, and to call pk_free()
1364 * when it fails. If MBEDTLS_ECP_C is defined but MBEDTLS_RSA_C
1365 * isn't, this leads to mbedtls_pk_free() being called
1366 * twice, once here and once by the caller, but this is
1367 * also ok and in line with the mbedtls_pk_free() calls
1368 * on failed PEM parsing attempts. */
1369
1370 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
1371}
1372
1373/*
1374 * Parse a public key
1375 */
1376int mbedtls_pk_parse_public_key( mbedtls_pk_context *ctx,
1377 const unsigned char *key, size_t keylen )
1378{
1379 int ret;
1380 unsigned char *p;
1381#if defined(MBEDTLS_RSA_C)
1382 const mbedtls_pk_info_t *pk_info;
1383#endif
1384#if defined(MBEDTLS_PEM_PARSE_C)
1385 size_t len;
1386 mbedtls_pem_context pem;
1387#endif
1388
1389 PK_VALIDATE_RET( ctx != NULL );
1390 if( keylen == 0 )
1391 return( MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
1392 PK_VALIDATE_RET( key != NULL || keylen == 0 );
1393
1394#if defined(MBEDTLS_PEM_PARSE_C)
1395 mbedtls_pem_init( &pem );
1396#if defined(MBEDTLS_RSA_C)
1397 /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
1398 if( key[keylen - 1] != '\0' )
1399 ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
1400 else
1401 ret = mbedtls_pem_read_buffer( &pem,
1402 "-----BEGIN RSA PUBLIC KEY-----",
1403 "-----END RSA PUBLIC KEY-----",
1404 key, NULL, 0, &len );
1405
1406 if( ret == 0 )
1407 {
1408 p = pem.buf;
1409 if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == NULL )
1410 return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
1411
1412 if( ( ret = mbedtls_pk_setup( ctx, pk_info ) ) != 0 )
1413 return( ret );
1414
1415 if ( ( ret = pk_get_rsapubkey( &p, p + pem.buflen, mbedtls_pk_rsa( *ctx ) ) ) != 0 )
1416 mbedtls_pk_free( ctx );
1417
1418 mbedtls_pem_free( &pem );
1419 return( ret );
1420 }
1421 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1422 {
1423 mbedtls_pem_free( &pem );
1424 return( ret );
1425 }
1426#endif /* MBEDTLS_RSA_C */
1427
1428 /* Avoid calling mbedtls_pem_read_buffer() on non-null-terminated string */
1429 if( key[keylen - 1] != '\0' )
1430 ret = MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT;
1431 else
1432 ret = mbedtls_pem_read_buffer( &pem,
1433 "-----BEGIN PUBLIC KEY-----",
1434 "-----END PUBLIC KEY-----",
1435 key, NULL, 0, &len );
1436
1437 if( ret == 0 )
1438 {
1439 /*
1440 * Was PEM encoded
1441 */
1442 p = pem.buf;
1443
1444 ret = mbedtls_pk_parse_subpubkey( &p, p + pem.buflen, ctx );
1445 mbedtls_pem_free( &pem );
1446 return( ret );
1447 }
1448 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1449 {
1450 mbedtls_pem_free( &pem );
1451 return( ret );
1452 }
1453 mbedtls_pem_free( &pem );
1454#endif /* MBEDTLS_PEM_PARSE_C */
1455
1456#if defined(MBEDTLS_RSA_C)
1457 if( ( pk_info = mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == NULL )
1458 return( MBEDTLS_ERR_PK_UNKNOWN_PK_ALG );
1459
1460 if( ( ret = mbedtls_pk_setup( ctx, pk_info ) ) != 0 )
1461 return( ret );
1462
1463 p = (unsigned char *)key;
1464 ret = pk_get_rsapubkey( &p, p + keylen, mbedtls_pk_rsa( *ctx ) );
1465 if( ret == 0 )
1466 {
1467 return( ret );
1468 }
1469 mbedtls_pk_free( ctx );
1470 if( ret != ( MBEDTLS_ERR_PK_INVALID_PUBKEY + MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
1471 {
1472 return( ret );
1473 }
1474#endif /* MBEDTLS_RSA_C */
1475 p = (unsigned char *) key;
1476
1477 ret = mbedtls_pk_parse_subpubkey( &p, p + keylen, ctx );
1478
1479 return( ret );
1480}
1481
1482#endif /* MBEDTLS_PK_PARSE_C */
Note: See TracBrowser for help on using the repository browser.