91524ac9e95da22a39aa909cd13eb43e65397246
[exim.git] / src / src / pdkim / rsa.c
1 /*
2 * The RSA public-key cryptosystem
3 *
4 * Copyright (C) 2006-2009, Paul Bakker <polarssl_maintainer at polarssl.org>
5 * All rights reserved.
6 *
7 * Joined copyright on original XySSL code with: Christophe Devine
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 */
23 /*
24 * RSA was designed by Ron Rivest, Adi Shamir and Len Adleman.
25 *
26 * http://theory.lcs.mit.edu/~rivest/rsapaper.pdf
27 * http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf
28 */
29
30 /* $Cambridge: exim/src/src/pdkim/rsa.c,v 1.3 2009/12/07 13:05:07 tom Exp $ */
31
32 #include "rsa.h"
33 #include "base64.h"
34
35 #include <stdlib.h>
36 #include <string.h>
37 #include <stdio.h>
38
39
40 /* *************** begin copy from x509parse.c ********************/
41 /*
42 * ASN.1 DER decoding routines
43 */
44 static int asn1_get_len( unsigned char **p,
45 unsigned char *end,
46 int *len )
47 {
48 if( ( end - *p ) < 1 )
49 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
50
51 if( ( **p & 0x80 ) == 0 )
52 *len = *(*p)++;
53 else
54 {
55 switch( **p & 0x7F )
56 {
57 case 1:
58 if( ( end - *p ) < 2 )
59 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
60
61 *len = (*p)[1];
62 (*p) += 2;
63 break;
64
65 case 2:
66 if( ( end - *p ) < 3 )
67 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
68
69 *len = ( (*p)[1] << 8 ) | (*p)[2];
70 (*p) += 3;
71 break;
72
73 default:
74 return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
75 break;
76 }
77 }
78
79 if( *len > (int) ( end - *p ) )
80 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
81
82 return( 0 );
83 }
84
85 static int asn1_get_tag( unsigned char **p,
86 unsigned char *end,
87 int *len, int tag )
88 {
89 if( ( end - *p ) < 1 )
90 return( POLARSSL_ERR_ASN1_OUT_OF_DATA );
91
92 if( **p != tag )
93 return( POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
94
95 (*p)++;
96
97 return( asn1_get_len( p, end, len ) );
98 }
99
100 static int asn1_get_int( unsigned char **p,
101 unsigned char *end,
102 int *val )
103 {
104 int ret, len;
105
106 if( ( ret = asn1_get_tag( p, end, &len, ASN1_INTEGER ) ) != 0 )
107 return( ret );
108
109 if( len > (int) sizeof( int ) || ( **p & 0x80 ) != 0 )
110 return( POLARSSL_ERR_ASN1_INVALID_LENGTH );
111
112 *val = 0;
113
114 while( len-- > 0 )
115 {
116 *val = ( *val << 8 ) | **p;
117 (*p)++;
118 }
119
120 return( 0 );
121 }
122
123 static int asn1_get_mpi( unsigned char **p,
124 unsigned char *end,
125 mpi *X )
126 {
127 int ret, len;
128
129 if( ( ret = asn1_get_tag( p, end, &len, ASN1_INTEGER ) ) != 0 )
130 return( ret );
131
132 ret = mpi_read_binary( X, *p, len );
133
134 *p += len;
135
136 return( ret );
137 }
138 /* *************** end copy from x509parse.c ********************/
139
140
141
142 /*
143 * Initialize an RSA context
144 */
145 void rsa_init( rsa_context *ctx,
146 int padding,
147 int hash_id,
148 int (*f_rng)(void *),
149 void *p_rng )
150 {
151 memset( ctx, 0, sizeof( rsa_context ) );
152
153 ctx->padding = padding;
154 ctx->hash_id = hash_id;
155
156 ctx->f_rng = f_rng;
157 ctx->p_rng = p_rng;
158 }
159
160
161 /*
162 * Check a public RSA key
163 */
164 int rsa_check_pubkey( rsa_context *ctx )
165 {
166 if( !ctx->N.p || !ctx->E.p )
167 return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
168
169 if( ( ctx->N.p[0] & 1 ) == 0 ||
170 ( ctx->E.p[0] & 1 ) == 0 )
171 return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
172
173 if( mpi_msb( &ctx->N ) < 128 ||
174 mpi_msb( &ctx->N ) > 4096 )
175 return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
176
177 if( mpi_msb( &ctx->E ) < 2 ||
178 mpi_msb( &ctx->E ) > 64 )
179 return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
180
181 return( 0 );
182 }
183
184 /*
185 * Check a private RSA key
186 */
187 int rsa_check_privkey( rsa_context *ctx )
188 {
189 int ret;
190 mpi PQ, DE, P1, Q1, H, I, G;
191
192 if( ( ret = rsa_check_pubkey( ctx ) ) != 0 )
193 return( ret );
194
195 if( !ctx->P.p || !ctx->Q.p || !ctx->D.p )
196 return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
197
198 mpi_init( &PQ, &DE, &P1, &Q1, &H, &I, &G, NULL );
199
200 MPI_CHK( mpi_mul_mpi( &PQ, &ctx->P, &ctx->Q ) );
201 MPI_CHK( mpi_mul_mpi( &DE, &ctx->D, &ctx->E ) );
202 MPI_CHK( mpi_sub_int( &P1, &ctx->P, 1 ) );
203 MPI_CHK( mpi_sub_int( &Q1, &ctx->Q, 1 ) );
204 MPI_CHK( mpi_mul_mpi( &H, &P1, &Q1 ) );
205 MPI_CHK( mpi_mod_mpi( &I, &DE, &H ) );
206 MPI_CHK( mpi_gcd( &G, &ctx->E, &H ) );
207
208 if( mpi_cmp_mpi( &PQ, &ctx->N ) == 0 &&
209 mpi_cmp_int( &I, 1 ) == 0 &&
210 mpi_cmp_int( &G, 1 ) == 0 )
211 {
212 mpi_free( &G, &I, &H, &Q1, &P1, &DE, &PQ, NULL );
213 return( 0 );
214 }
215
216 cleanup:
217
218 mpi_free( &G, &I, &H, &Q1, &P1, &DE, &PQ, NULL );
219 return( POLARSSL_ERR_RSA_KEY_CHECK_FAILED | ret );
220 }
221
222 /*
223 * Do an RSA public key operation
224 */
225 int rsa_public( rsa_context *ctx,
226 unsigned char *input,
227 unsigned char *output )
228 {
229 int ret, olen;
230 mpi T;
231
232 mpi_init( &T, NULL );
233
234 MPI_CHK( mpi_read_binary( &T, input, ctx->len ) );
235
236 if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
237 {
238 mpi_free( &T, NULL );
239 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
240 }
241
242 olen = ctx->len;
243 MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) );
244 MPI_CHK( mpi_write_binary( &T, output, olen ) );
245
246 cleanup:
247
248 mpi_free( &T, NULL );
249
250 if( ret != 0 )
251 return( POLARSSL_ERR_RSA_PUBLIC_FAILED | ret );
252
253 return( 0 );
254 }
255
256 /*
257 * Do an RSA private key operation
258 */
259 int rsa_private( rsa_context *ctx,
260 unsigned char *input,
261 unsigned char *output )
262 {
263 int ret, olen;
264 mpi T, T1, T2;
265
266 mpi_init( &T, &T1, &T2, NULL );
267
268 MPI_CHK( mpi_read_binary( &T, input, ctx->len ) );
269
270 if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
271 {
272 mpi_free( &T, NULL );
273 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
274 }
275
276 #if 0
277 MPI_CHK( mpi_exp_mod( &T, &T, &ctx->D, &ctx->N, &ctx->RN ) );
278 #else
279 /*
280 * faster decryption using the CRT
281 *
282 * T1 = input ^ dP mod P
283 * T2 = input ^ dQ mod Q
284 */
285 MPI_CHK( mpi_exp_mod( &T1, &T, &ctx->DP, &ctx->P, &ctx->RP ) );
286 MPI_CHK( mpi_exp_mod( &T2, &T, &ctx->DQ, &ctx->Q, &ctx->RQ ) );
287
288 /*
289 * T = (T1 - T2) * (Q^-1 mod P) mod P
290 */
291 MPI_CHK( mpi_sub_mpi( &T, &T1, &T2 ) );
292 MPI_CHK( mpi_mul_mpi( &T1, &T, &ctx->QP ) );
293 MPI_CHK( mpi_mod_mpi( &T, &T1, &ctx->P ) );
294
295 /*
296 * output = T2 + T * Q
297 */
298 MPI_CHK( mpi_mul_mpi( &T1, &T, &ctx->Q ) );
299 MPI_CHK( mpi_add_mpi( &T, &T2, &T1 ) );
300 #endif
301
302 olen = ctx->len;
303 MPI_CHK( mpi_write_binary( &T, output, olen ) );
304
305 cleanup:
306
307 mpi_free( &T, &T1, &T2, NULL );
308
309 if( ret != 0 )
310 return( POLARSSL_ERR_RSA_PRIVATE_FAILED | ret );
311
312 return( 0 );
313 }
314
315 /*
316 * Add the message padding, then do an RSA operation
317 */
318 int rsa_pkcs1_encrypt( rsa_context *ctx,
319 int mode, int ilen,
320 unsigned char *input,
321 unsigned char *output )
322 {
323 int nb_pad, olen;
324 unsigned char *p = output;
325
326 olen = ctx->len;
327
328 switch( ctx->padding )
329 {
330 case RSA_PKCS_V15:
331
332 if( ilen < 0 || olen < ilen + 11 )
333 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
334
335 nb_pad = olen - 3 - ilen;
336
337 *p++ = 0;
338 *p++ = RSA_CRYPT;
339
340 while( nb_pad-- > 0 )
341 {
342 do {
343 *p = (unsigned char) rand();
344 } while( *p == 0 );
345 p++;
346 }
347 *p++ = 0;
348 memcpy( p, input, ilen );
349 break;
350
351 default:
352
353 return( POLARSSL_ERR_RSA_INVALID_PADDING );
354 }
355
356 return( ( mode == RSA_PUBLIC )
357 ? rsa_public( ctx, output, output )
358 : rsa_private( ctx, output, output ) );
359 }
360
361 /*
362 * Do an RSA operation, then remove the message padding
363 */
364 int rsa_pkcs1_decrypt( rsa_context *ctx,
365 int mode, int *olen,
366 unsigned char *input,
367 unsigned char *output,
368 int output_max_len)
369 {
370 int ret, ilen;
371 unsigned char *p;
372 unsigned char buf[1024];
373
374 ilen = ctx->len;
375
376 if( ilen < 16 || ilen > (int) sizeof( buf ) )
377 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
378
379 ret = ( mode == RSA_PUBLIC )
380 ? rsa_public( ctx, input, buf )
381 : rsa_private( ctx, input, buf );
382
383 if( ret != 0 )
384 return( ret );
385
386 p = buf;
387
388 switch( ctx->padding )
389 {
390 case RSA_PKCS_V15:
391
392 if( *p++ != 0 || *p++ != RSA_CRYPT )
393 return( POLARSSL_ERR_RSA_INVALID_PADDING );
394
395 while( *p != 0 )
396 {
397 if( p >= buf + ilen - 1 )
398 return( POLARSSL_ERR_RSA_INVALID_PADDING );
399 p++;
400 }
401 p++;
402 break;
403
404 default:
405
406 return( POLARSSL_ERR_RSA_INVALID_PADDING );
407 }
408
409 if (ilen - (int)(p - buf) > output_max_len)
410 return( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE );
411
412 *olen = ilen - (int)(p - buf);
413 memcpy( output, p, *olen );
414
415 return( 0 );
416 }
417
418 /*
419 * Do an RSA operation to sign the message digest
420 */
421 int rsa_pkcs1_sign( rsa_context *ctx,
422 int mode,
423 int hash_id,
424 int hashlen,
425 unsigned char *hash,
426 unsigned char *sig )
427 {
428 int nb_pad, olen;
429 unsigned char *p = sig;
430
431 olen = ctx->len;
432
433 switch( ctx->padding )
434 {
435 case RSA_PKCS_V15:
436
437 switch( hash_id )
438 {
439 case SIG_RSA_RAW:
440 nb_pad = olen - 3 - hashlen;
441 break;
442
443 case SIG_RSA_MD2:
444 case SIG_RSA_MD4:
445 case SIG_RSA_MD5:
446 nb_pad = olen - 3 - 34;
447 break;
448
449 case SIG_RSA_SHA1:
450 nb_pad = olen - 3 - 35;
451 break;
452
453 case SIG_RSA_SHA224:
454 nb_pad = olen - 3 - 47;
455 break;
456
457 case SIG_RSA_SHA256:
458 nb_pad = olen - 3 - 51;
459 break;
460
461 case SIG_RSA_SHA384:
462 nb_pad = olen - 3 - 67;
463 break;
464
465 case SIG_RSA_SHA512:
466 nb_pad = olen - 3 - 83;
467 break;
468
469
470 default:
471 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
472 }
473
474 if( nb_pad < 8 )
475 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
476
477 *p++ = 0;
478 *p++ = RSA_SIGN;
479 memset( p, 0xFF, nb_pad );
480 p += nb_pad;
481 *p++ = 0;
482 break;
483
484 default:
485
486 return( POLARSSL_ERR_RSA_INVALID_PADDING );
487 }
488
489 switch( hash_id )
490 {
491 case SIG_RSA_RAW:
492 memcpy( p, hash, hashlen );
493 break;
494
495 case SIG_RSA_MD2:
496 memcpy( p, ASN1_HASH_MDX, 18 );
497 memcpy( p + 18, hash, 16 );
498 p[13] = 2; break;
499
500 case SIG_RSA_MD4:
501 memcpy( p, ASN1_HASH_MDX, 18 );
502 memcpy( p + 18, hash, 16 );
503 p[13] = 4; break;
504
505 case SIG_RSA_MD5:
506 memcpy( p, ASN1_HASH_MDX, 18 );
507 memcpy( p + 18, hash, 16 );
508 p[13] = 5; break;
509
510 case SIG_RSA_SHA1:
511 memcpy( p, ASN1_HASH_SHA1, 15 );
512 memcpy( p + 15, hash, 20 );
513 break;
514
515 case SIG_RSA_SHA224:
516 memcpy( p, ASN1_HASH_SHA2X, 19 );
517 memcpy( p + 19, hash, 28 );
518 p[1] += 28; p[14] = 4; p[18] += 28; break;
519
520 case SIG_RSA_SHA256:
521 memcpy( p, ASN1_HASH_SHA2X, 19 );
522 memcpy( p + 19, hash, 32 );
523 p[1] += 32; p[14] = 1; p[18] += 32; break;
524
525 case SIG_RSA_SHA384:
526 memcpy( p, ASN1_HASH_SHA2X, 19 );
527 memcpy( p + 19, hash, 48 );
528 p[1] += 48; p[14] = 2; p[18] += 48; break;
529
530 case SIG_RSA_SHA512:
531 memcpy( p, ASN1_HASH_SHA2X, 19 );
532 memcpy( p + 19, hash, 64 );
533 p[1] += 64; p[14] = 3; p[18] += 64; break;
534
535 default:
536 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
537 }
538
539 return( ( mode == RSA_PUBLIC )
540 ? rsa_public( ctx, sig, sig )
541 : rsa_private( ctx, sig, sig ) );
542 }
543
544 /*
545 * Do an RSA operation and check the message digest
546 */
547 int rsa_pkcs1_verify( rsa_context *ctx,
548 int mode,
549 int hash_id,
550 int hashlen,
551 unsigned char *hash,
552 unsigned char *sig )
553 {
554 int ret, len, siglen;
555 unsigned char *p, c;
556 unsigned char buf[1024];
557
558 siglen = ctx->len;
559
560 if( siglen < 16 || siglen > (int) sizeof( buf ) )
561 return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
562
563 ret = ( mode == RSA_PUBLIC )
564 ? rsa_public( ctx, sig, buf )
565 : rsa_private( ctx, sig, buf );
566
567 if( ret != 0 )
568 return( ret );
569
570 p = buf;
571
572 switch( ctx->padding )
573 {
574 case RSA_PKCS_V15:
575
576 if( *p++ != 0 || *p++ != RSA_SIGN )
577 return( POLARSSL_ERR_RSA_INVALID_PADDING );
578
579 while( *p != 0 )
580 {
581 if( p >= buf + siglen - 1 || *p != 0xFF )
582 return( POLARSSL_ERR_RSA_INVALID_PADDING );
583 p++;
584 }
585 p++;
586 break;
587
588 default:
589
590 return( POLARSSL_ERR_RSA_INVALID_PADDING );
591 }
592
593 len = siglen - (int)( p - buf );
594
595 if( len == 34 )
596 {
597 c = p[13];
598 p[13] = 0;
599
600 if( memcmp( p, ASN1_HASH_MDX, 18 ) != 0 )
601 return( POLARSSL_ERR_RSA_VERIFY_FAILED );
602
603 if( ( c == 2 && hash_id == SIG_RSA_MD2 ) ||
604 ( c == 4 && hash_id == SIG_RSA_MD4 ) ||
605 ( c == 5 && hash_id == SIG_RSA_MD5 ) )
606 {
607 if( memcmp( p + 18, hash, 16 ) == 0 )
608 return( 0 );
609 else
610 return( POLARSSL_ERR_RSA_VERIFY_FAILED );
611 }
612 }
613
614 if( len == 35 && hash_id == SIG_RSA_SHA1 )
615 {
616 if( memcmp( p, ASN1_HASH_SHA1, 15 ) == 0 &&
617 memcmp( p + 15, hash, 20 ) == 0 )
618 return( 0 );
619 else
620 return( POLARSSL_ERR_RSA_VERIFY_FAILED );
621 }
622 if( ( len == 19 + 28 && p[14] == 4 && hash_id == SIG_RSA_SHA224 ) ||
623 ( len == 19 + 32 && p[14] == 1 && hash_id == SIG_RSA_SHA256 ) ||
624 ( len == 19 + 48 && p[14] == 2 && hash_id == SIG_RSA_SHA384 ) ||
625 ( len == 19 + 64 && p[14] == 3 && hash_id == SIG_RSA_SHA512 ) )
626 {
627 c = p[1] - 17;
628 p[1] = 17;
629 p[14] = 0;
630
631 if( p[18] == c &&
632 memcmp( p, ASN1_HASH_SHA2X, 18 ) == 0 &&
633 memcmp( p + 19, hash, c ) == 0 )
634 return( 0 );
635 else
636 return( POLARSSL_ERR_RSA_VERIFY_FAILED );
637 }
638
639 if( len == hashlen && hash_id == SIG_RSA_RAW )
640 {
641 if( memcmp( p, hash, hashlen ) == 0 )
642 return( 0 );
643 else
644 return( POLARSSL_ERR_RSA_VERIFY_FAILED );
645 }
646
647 return( POLARSSL_ERR_RSA_INVALID_PADDING );
648 }
649
650 /*
651 * Free the components of an RSA key
652 */
653 void rsa_free( rsa_context *ctx )
654 {
655 mpi_free( &ctx->RQ, &ctx->RP, &ctx->RN,
656 &ctx->QP, &ctx->DQ, &ctx->DP,
657 &ctx->Q, &ctx->P, &ctx->D,
658 &ctx->E, &ctx->N, NULL );
659 }
660
661 /*
662 * Parse a public RSA key
663
664 OpenSSL RSA public key ASN1 container
665 0:d=0 hl=3 l= 159 cons: SEQUENCE
666 3:d=1 hl=2 l= 13 cons: SEQUENCE
667 5:d=2 hl=2 l= 9 prim: OBJECT:rsaEncryption
668 16:d=2 hl=2 l= 0 prim: NULL
669 18:d=1 hl=3 l= 141 prim: BIT STRING:RSAPublicKey (below)
670
671 RSAPublicKey ASN1 container
672 0:d=0 hl=3 l= 137 cons: SEQUENCE
673 3:d=1 hl=3 l= 129 prim: INTEGER:Public modulus
674 135:d=1 hl=2 l= 3 prim: INTEGER:Public exponent
675 */
676
677 int rsa_parse_public_key( rsa_context *rsa, unsigned char *buf, int buflen )
678 {
679 unsigned char *p, *end;
680 int ret, len;
681
682 p = buf;
683 end = buf+buflen;
684
685 if( ( ret = asn1_get_tag( &p, end, &len,
686 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) {
687 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT | ret );
688 }
689
690 if( ( ret = asn1_get_tag( &p, end, &len,
691 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) == 0 ) {
692 /* Skip over embedded rsaEncryption Object */
693 p+=len;
694
695 /* The RSAPublicKey ASN1 container is wrapped in a BIT STRING */
696 if( ( ret = asn1_get_tag( &p, end, &len,
697 ASN1_BIT_STRING ) ) != 0 ) {
698 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT | ret );
699 }
700
701 /* Limit range to that BIT STRING */
702 end = p + len;
703 p++;
704
705 if( ( ret = asn1_get_tag( &p, end, &len,
706 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) {
707 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT | ret );
708 }
709 }
710
711 if ( ( ( ret = asn1_get_mpi( &p, end, &(rsa->N) ) ) == 0 ) &&
712 ( ( ret = asn1_get_mpi( &p, end, &(rsa->E) ) ) == 0 ) ) {
713 rsa->len = mpi_size( &rsa->N );
714 return 0;
715 }
716
717 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT | ret );
718 }
719
720 /*
721 * Parse a private RSA key
722 */
723 int rsa_parse_key( rsa_context *rsa, unsigned char *buf, int buflen,
724 unsigned char *pwd, int pwdlen )
725 {
726 int ret, len, enc;
727 unsigned char *s1, *s2;
728 unsigned char *p, *end;
729
730 s1 = (unsigned char *) strstr( (char *) buf,
731 "-----BEGIN RSA PRIVATE KEY-----" );
732
733 if( s1 != NULL )
734 {
735 s2 = (unsigned char *) strstr( (char *) buf,
736 "-----END RSA PRIVATE KEY-----" );
737
738 if( s2 == NULL || s2 <= s1 )
739 return( POLARSSL_ERR_X509_KEY_INVALID_PEM );
740
741 s1 += 31;
742 if( *s1 == '\r' ) s1++;
743 if( *s1 == '\n' ) s1++;
744 else return( POLARSSL_ERR_X509_KEY_INVALID_PEM );
745
746 enc = 0;
747
748 if( memcmp( s1, "Proc-Type: 4,ENCRYPTED", 22 ) == 0 )
749 {
750 return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
751 }
752
753 len = 0;
754 ret = base64_decode( NULL, &len, s1, s2 - s1 );
755
756 if( ret == POLARSSL_ERR_BASE64_INVALID_CHARACTER )
757 return( ret | POLARSSL_ERR_X509_KEY_INVALID_PEM );
758
759 if( ( buf = (unsigned char *) malloc( len ) ) == NULL )
760 return( 1 );
761
762 if( ( ret = base64_decode( buf, &len, s1, s2 - s1 ) ) != 0 )
763 {
764 free( buf );
765 return( ret | POLARSSL_ERR_X509_KEY_INVALID_PEM );
766 }
767
768 buflen = len;
769
770 if( enc != 0 )
771 {
772 return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
773 }
774 }
775
776 memset( rsa, 0, sizeof( rsa_context ) );
777
778 p = buf;
779 end = buf + buflen;
780
781 /*
782 * RSAPrivateKey ::= SEQUENCE {
783 * version Version,
784 * modulus INTEGER, -- n
785 * publicExponent INTEGER, -- e
786 * privateExponent INTEGER, -- d
787 * prime1 INTEGER, -- p
788 * prime2 INTEGER, -- q
789 * exponent1 INTEGER, -- d mod (p-1)
790 * exponent2 INTEGER, -- d mod (q-1)
791 * coefficient INTEGER, -- (inverse of q) mod p
792 * otherPrimeInfos OtherPrimeInfos OPTIONAL
793 * }
794 */
795 if( ( ret = asn1_get_tag( &p, end, &len,
796 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
797 {
798 if( s1 != NULL )
799 free( buf );
800
801 rsa_free( rsa );
802 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT | ret );
803 }
804
805 end = p + len;
806
807 if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
808 {
809 if( s1 != NULL )
810 free( buf );
811
812 rsa_free( rsa );
813 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT | ret );
814 }
815
816 if( rsa->ver != 0 )
817 {
818 if( s1 != NULL )
819 free( buf );
820
821 rsa_free( rsa );
822 return( ret | POLARSSL_ERR_X509_KEY_INVALID_VERSION );
823 }
824
825 if( ( ret = asn1_get_mpi( &p, end, &rsa->N ) ) != 0 ||
826 ( ret = asn1_get_mpi( &p, end, &rsa->E ) ) != 0 ||
827 ( ret = asn1_get_mpi( &p, end, &rsa->D ) ) != 0 ||
828 ( ret = asn1_get_mpi( &p, end, &rsa->P ) ) != 0 ||
829 ( ret = asn1_get_mpi( &p, end, &rsa->Q ) ) != 0 ||
830 ( ret = asn1_get_mpi( &p, end, &rsa->DP ) ) != 0 ||
831 ( ret = asn1_get_mpi( &p, end, &rsa->DQ ) ) != 0 ||
832 ( ret = asn1_get_mpi( &p, end, &rsa->QP ) ) != 0 )
833 {
834 if( s1 != NULL )
835 free( buf );
836
837 rsa_free( rsa );
838 return( ret | POLARSSL_ERR_X509_KEY_INVALID_FORMAT );
839 }
840
841 rsa->len = mpi_size( &rsa->N );
842
843 if( p != end )
844 {
845 if( s1 != NULL )
846 free( buf );
847
848 rsa_free( rsa );
849 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT |
850 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
851 }
852
853 if( ( ret = rsa_check_privkey( rsa ) ) != 0 )
854 {
855 if( s1 != NULL )
856 free( buf );
857
858 rsa_free( rsa );
859 return( ret );
860 }
861
862 if( s1 != NULL )
863 free( buf );
864
865 return( 0 );
866 }