Compiler masochism compliance.
[exim.git] / src / src / pdkim / bignum.c
1 /*
2  *  Multi-precision integer library
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  *  This MPI implementation is based on:
25  *
26  *  http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
27  *  http://www.stillhq.com/extracted/gnupg-api/mpi/
28  *  http://math.libtomcrypt.com/files/tommath.pdf
29  */
30
31 /* $Cambridge: exim/src/src/pdkim/bignum.c,v 1.3 2009/12/07 13:05:07 tom Exp $ */
32
33
34 #include "bignum.h"
35 #include "bn_mul.h"
36
37 #include <string.h>
38 #include <stdlib.h>
39 #include <stdarg.h>
40
41 #define ciL    ((int) sizeof(t_int))    /* chars in limb  */
42 #define biL    (ciL << 3)               /* bits  in limb  */
43 #define biH    (ciL << 2)               /* half limb size */
44
45 /*
46  * Convert between bits/chars and number of limbs
47  */
48 #define BITS_TO_LIMBS(i)  (((i) + biL - 1) / biL)
49 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
50
51 /*
52  * Initialize one or more mpi
53  */
54 void mpi_init( mpi *X, ... )
55 {
56     va_list args;
57
58     va_start( args, X );
59
60     while( X != NULL )
61     {
62         X->s = 1;
63         X->n = 0;
64         X->p = NULL;
65
66         X = va_arg( args, mpi* );
67     }
68
69     va_end( args );
70 }
71
72 /*
73  * Unallocate one or more mpi
74  */
75 void mpi_free( mpi *X, ... )
76 {
77     va_list args;
78
79     va_start( args, X );
80
81     while( X != NULL )
82     {
83         if( X->p != NULL )
84         {
85             memset( X->p, 0, X->n * ciL );
86             free( X->p );
87         }
88
89         X->s = 1;
90         X->n = 0;
91         X->p = NULL;
92
93         X = va_arg( args, mpi* );
94     }
95
96     va_end( args );
97 }
98
99 /*
100  * Enlarge to the specified number of limbs
101  */
102 int mpi_grow( mpi *X, int nblimbs )
103 {
104     t_int *p;
105
106     if( X->n < nblimbs )
107     {
108         if( ( p = (t_int *) malloc( nblimbs * ciL ) ) == NULL )
109             return( 1 );
110
111         memset( p, 0, nblimbs * ciL );
112
113         if( X->p != NULL )
114         {
115             memcpy( p, X->p, X->n * ciL );
116             memset( X->p, 0, X->n * ciL );
117             free( X->p );
118         }
119
120         X->n = nblimbs;
121         X->p = p;
122     }
123
124     return( 0 );
125 }
126
127 /*
128  * Copy the contents of Y into X
129  */
130 int mpi_copy( mpi *X, mpi *Y )
131 {
132     int ret, i;
133
134     if( X == Y )
135         return( 0 );
136
137     for( i = Y->n - 1; i > 0; i-- )
138         if( Y->p[i] != 0 )
139             break;
140     i++;
141
142     X->s = Y->s;
143
144     MPI_CHK( mpi_grow( X, i ) );
145
146     memset( X->p, 0, X->n * ciL );
147     memcpy( X->p, Y->p, i * ciL );
148
149 cleanup:
150
151     return( ret );
152 }
153
154 /*
155  * Swap the contents of X and Y
156  */
157 void mpi_swap( mpi *X, mpi *Y )
158 {
159     mpi T;
160
161     memcpy( &T,  X, sizeof( mpi ) );
162     memcpy(  X,  Y, sizeof( mpi ) );
163     memcpy(  Y, &T, sizeof( mpi ) );
164 }
165
166 /*
167  * Set value from integer
168  */
169 int mpi_lset( mpi *X, int z )
170 {
171     int ret;
172
173     MPI_CHK( mpi_grow( X, 1 ) );
174     memset( X->p, 0, X->n * ciL );
175
176     X->p[0] = ( z < 0 ) ? -z : z;
177     X->s    = ( z < 0 ) ? -1 : 1;
178
179 cleanup:
180
181     return( ret );
182 }
183
184 /*
185  * Return the number of least significant bits
186  */
187 int mpi_lsb( mpi *X )
188 {
189     int i, j, count = 0;
190
191     for( i = 0; i < X->n; i++ )
192         for( j = 0; j < (int) biL; j++, count++ )
193             if( ( ( X->p[i] >> j ) & 1 ) != 0 )
194                 return( count );
195
196     return( 0 );
197 }
198
199 /*
200  * Return the number of most significant bits
201  */
202 int mpi_msb( mpi *X )
203 {
204     int i, j;
205
206     for( i = X->n - 1; i > 0; i-- )
207         if( X->p[i] != 0 )
208             break;
209
210     for( j = biL - 1; j >= 0; j-- )
211         if( ( ( X->p[i] >> j ) & 1 ) != 0 )
212             break;
213
214     return( ( i * biL ) + j + 1 );
215 }
216
217 /*
218  * Return the total size in bytes
219  */
220 int mpi_size( mpi *X )
221 {
222     return( ( mpi_msb( X ) + 7 ) >> 3 );
223 }
224
225 /*
226  * Convert an ASCII character to digit value
227  */
228 static int mpi_get_digit( t_int *d, int radix, char c )
229 {
230     *d = 255;
231
232     if( c >= 0x30 && c <= 0x39 ) *d = c - 0x30;
233     if( c >= 0x41 && c <= 0x46 ) *d = c - 0x37;
234     if( c >= 0x61 && c <= 0x66 ) *d = c - 0x57;
235
236     if( *d >= (t_int) radix )
237         return( POLARSSL_ERR_MPI_INVALID_CHARACTER );
238
239     return( 0 );
240 }
241
242 /*
243  * Import from an ASCII string
244  */
245 int mpi_read_string( mpi *X, int radix, char *s )
246 {
247     int ret, i, j, n;
248     t_int d;
249     mpi T;
250
251     if( radix < 2 || radix > 16 )
252         return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
253
254     mpi_init( &T, NULL );
255
256     if( radix == 16 )
257     {
258         n = BITS_TO_LIMBS( strlen( s ) << 2 );
259
260         MPI_CHK( mpi_grow( X, n ) );
261         MPI_CHK( mpi_lset( X, 0 ) );
262
263         for( i = strlen( s ) - 1, j = 0; i >= 0; i--, j++ )
264         {
265             if( i == 0 && s[i] == '-' )
266             {
267                 X->s = -1;
268                 break;
269             }
270
271             MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
272             X->p[j / (2 * ciL)] |= d << ( (j % (2 * ciL)) << 2 );
273         }
274     }
275     else
276     {
277         MPI_CHK( mpi_lset( X, 0 ) );
278
279         for( i = 0; i < (int) strlen( s ); i++ )
280         {
281             if( i == 0 && s[i] == '-' )
282             {
283                 X->s = -1;
284                 continue;
285             }
286
287             MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
288             MPI_CHK( mpi_mul_int( &T, X, radix ) );
289
290             if( X->s == 1 )
291             {
292                 MPI_CHK( mpi_add_int( X, &T, d ) );
293             }
294             else
295             {
296                 MPI_CHK( mpi_sub_int( X, &T, d ) );
297             }
298         }
299     }
300
301 cleanup:
302
303     mpi_free( &T, NULL );
304
305     return( ret );
306 }
307
308 /*
309  * Helper to write the digits high-order first
310  */
311 static int mpi_write_hlp( mpi *X, int radix, char **p )
312 {
313     int ret;
314     t_int r;
315
316     if( radix < 2 || radix > 16 )
317         return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
318
319     MPI_CHK( mpi_mod_int( &r, X, radix ) );
320     MPI_CHK( mpi_div_int( X, NULL, X, radix ) );
321
322     if( mpi_cmp_int( X, 0 ) != 0 )
323         MPI_CHK( mpi_write_hlp( X, radix, p ) );
324
325     if( r < 10 )
326         *(*p)++ = (char)( r + 0x30 );
327     else
328         *(*p)++ = (char)( r + 0x37 );
329
330 cleanup:
331
332     return( ret );
333 }
334
335 /*
336  * Export into an ASCII string
337  */
338 int mpi_write_string( mpi *X, int radix, char *s, int *slen )
339 {
340     int ret = 0, n;
341     char *p;
342     mpi T;
343
344     if( radix < 2 || radix > 16 )
345         return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
346
347     n = mpi_msb( X );
348     if( radix >=  4 ) n >>= 1;
349     if( radix >= 16 ) n >>= 1;
350     n += 3;
351
352     if( *slen < n )
353     {
354         *slen = n;
355         return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
356     }
357
358     p = s;
359     mpi_init( &T, NULL );
360
361     if( X->s == -1 )
362         *p++ = '-';
363
364     if( radix == 16 )
365     {
366         int c, i, j, k;
367
368         for( i = X->n - 1, k = 0; i >= 0; i-- )
369         {
370             for( j = ciL - 1; j >= 0; j-- )
371             {
372                 c = ( X->p[i] >> (j << 3) ) & 0xFF;
373
374                 if( c == 0 && k == 0 && (i + j) != 0 )
375                     continue;
376
377                 p += sprintf( p, "%02X", c );
378                 k = 1;
379             }
380         }
381     }
382     else
383     {
384         MPI_CHK( mpi_copy( &T, X ) );
385
386         if( T.s == -1 )
387             T.s = 1;
388
389         MPI_CHK( mpi_write_hlp( &T, radix, &p ) );
390     }
391
392     *p++ = '\0';
393     *slen = p - s;
394
395 cleanup:
396
397     mpi_free( &T, NULL );
398
399     return( ret );
400 }
401
402 /*
403  * Read X from an opened file
404  */
405 int mpi_read_file( mpi *X, int radix, FILE *fin )
406 {
407     t_int d;
408     int slen;
409     char *p;
410     char s[1024];
411
412     memset( s, 0, sizeof( s ) );
413     if( fgets( s, sizeof( s ) - 1, fin ) == NULL )
414         return( POLARSSL_ERR_MPI_FILE_IO_ERROR );
415
416     slen = strlen( s );
417     if( s[slen - 1] == '\n' ) { slen--; s[slen] = '\0'; }
418     if( s[slen - 1] == '\r' ) { slen--; s[slen] = '\0'; }
419
420     p = s + slen;
421     while( --p >= s )
422         if( mpi_get_digit( &d, radix, *p ) != 0 )
423             break;
424
425     return( mpi_read_string( X, radix, p + 1 ) );
426 }
427
428 /*
429  * Write X into an opened file (or stdout if fout == NULL)
430  */
431 int mpi_write_file( const char *p, mpi *X, int radix, FILE *fout )
432 {
433     int n, ret;
434     size_t slen;
435     size_t plen;
436     char s[1024];
437
438     n = sizeof( s );
439     memset( s, 0, n );
440     n -= 2;
441
442     MPI_CHK( mpi_write_string( X, radix, s, (int *) &n ) );
443
444     if( p == NULL ) p = "";
445
446     plen = strlen( p );
447     slen = strlen( s );
448     s[slen++] = '\r';
449     s[slen++] = '\n';
450
451     if( fout != NULL )
452     {
453         if( fwrite( p, 1, plen, fout ) != plen ||
454             fwrite( s, 1, slen, fout ) != slen )
455             return( POLARSSL_ERR_MPI_FILE_IO_ERROR );
456     }
457     else
458         printf( "%s%s", p, s );
459
460 cleanup:
461
462     return( ret );
463 }
464
465 /*
466  * Import X from unsigned binary data, big endian
467  */
468 int mpi_read_binary( mpi *X, unsigned char *buf, int buflen )
469 {
470     int ret, i, j, n;
471
472     for( n = 0; n < buflen; n++ )
473         if( buf[n] != 0 )
474             break;
475
476     MPI_CHK( mpi_grow( X, CHARS_TO_LIMBS( buflen - n ) ) );
477     MPI_CHK( mpi_lset( X, 0 ) );
478
479     for( i = buflen - 1, j = 0; i >= n; i--, j++ )
480         X->p[j / ciL] |= ((t_int) buf[i]) << ((j % ciL) << 3);
481
482 cleanup:
483
484     return( ret );
485 }
486
487 /*
488  * Export X into unsigned binary data, big endian
489  */
490 int mpi_write_binary( mpi *X, unsigned char *buf, int buflen )
491 {
492     int i, j, n;
493
494     n = mpi_size( X );
495
496     if( buflen < n )
497         return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
498
499     memset( buf, 0, buflen );
500
501     for( i = buflen - 1, j = 0; n > 0; i--, j++, n-- )
502         buf[i] = (unsigned char)( X->p[j / ciL] >> ((j % ciL) << 3) );
503
504     return( 0 );
505 }
506
507 /*
508  * Left-shift: X <<= count
509  */
510 int mpi_shift_l( mpi *X, int count )
511 {
512     int ret, i, v0, t1;
513     t_int r0 = 0, r1;
514
515     v0 = count / (biL    );
516     t1 = count & (biL - 1);
517
518     i = mpi_msb( X ) + count;
519
520     if( X->n * (int) biL < i )
521         MPI_CHK( mpi_grow( X, BITS_TO_LIMBS( i ) ) );
522
523     ret = 0;
524
525     /*
526      * shift by count / limb_size
527      */
528     if( v0 > 0 )
529     {
530         for( i = X->n - 1; i >= v0; i-- )
531             X->p[i] = X->p[i - v0];
532
533         for( ; i >= 0; i-- )
534             X->p[i] = 0;
535     }
536
537     /*
538      * shift by count % limb_size
539      */
540     if( t1 > 0 )
541     {
542         for( i = v0; i < X->n; i++ )
543         {
544             r1 = X->p[i] >> (biL - t1);
545             X->p[i] <<= t1;
546             X->p[i] |= r0;
547             r0 = r1;
548         }
549     }
550
551 cleanup:
552
553     return( ret );
554 }
555
556 /*
557  * Right-shift: X >>= count
558  */
559 int mpi_shift_r( mpi *X, int count )
560 {
561     int i, v0, v1;
562     t_int r0 = 0, r1;
563
564     v0 = count /  biL;
565     v1 = count & (biL - 1);
566
567     /*
568      * shift by count / limb_size
569      */
570     if( v0 > 0 )
571     {
572         for( i = 0; i < X->n - v0; i++ )
573             X->p[i] = X->p[i + v0];
574
575         for( ; i < X->n; i++ )
576             X->p[i] = 0;
577     }
578
579     /*
580      * shift by count % limb_size
581      */
582     if( v1 > 0 )
583     {
584         for( i = X->n - 1; i >= 0; i-- )
585         {
586             r1 = X->p[i] << (biL - v1);
587             X->p[i] >>= v1;
588             X->p[i] |= r0;
589             r0 = r1;
590         }
591     }
592
593     return( 0 );
594 }
595
596 /*
597  * Compare unsigned values
598  */
599 int mpi_cmp_abs( mpi *X, mpi *Y )
600 {
601     int i, j;
602
603     for( i = X->n - 1; i >= 0; i-- )
604         if( X->p[i] != 0 )
605             break;
606
607     for( j = Y->n - 1; j >= 0; j-- )
608         if( Y->p[j] != 0 )
609             break;
610
611     if( i < 0 && j < 0 )
612         return( 0 );
613
614     if( i > j ) return(  1 );
615     if( j > i ) return( -1 );
616
617     for( ; i >= 0; i-- )
618     {
619         if( X->p[i] > Y->p[i] ) return(  1 );
620         if( X->p[i] < Y->p[i] ) return( -1 );
621     }
622
623     return( 0 );
624 }
625
626 /*
627  * Compare signed values
628  */
629 int mpi_cmp_mpi( mpi *X, mpi *Y )
630 {
631     int i, j;
632
633     for( i = X->n - 1; i >= 0; i-- )
634         if( X->p[i] != 0 )
635             break;
636
637     for( j = Y->n - 1; j >= 0; j-- )
638         if( Y->p[j] != 0 )
639             break;
640
641     if( i < 0 && j < 0 )
642         return( 0 );
643
644     if( i > j ) return(  X->s );
645     if( j > i ) return( -X->s );
646
647     if( X->s > 0 && Y->s < 0 ) return(  1 );
648     if( Y->s > 0 && X->s < 0 ) return( -1 );
649
650     for( ; i >= 0; i-- )
651     {
652         if( X->p[i] > Y->p[i] ) return(  X->s );
653         if( X->p[i] < Y->p[i] ) return( -X->s );
654     }
655
656     return( 0 );
657 }
658
659 /*
660  * Compare signed values
661  */
662 int mpi_cmp_int( mpi *X, int z )
663 {
664     mpi Y;
665     t_int p[1];
666
667     *p  = ( z < 0 ) ? -z : z;
668     Y.s = ( z < 0 ) ? -1 : 1;
669     Y.n = 1;
670     Y.p = p;
671
672     return( mpi_cmp_mpi( X, &Y ) );
673 }
674
675 /*
676  * Unsigned addition: X = |A| + |B|  (HAC 14.7)
677  */
678 int mpi_add_abs( mpi *X, mpi *A, mpi *B )
679 {
680     int ret, i, j;
681     t_int *o, *p, c;
682
683     if( X == B )
684     {
685         mpi *T = A; A = X; B = T;
686     }
687
688     if( X != A )
689         MPI_CHK( mpi_copy( X, A ) );
690
691     /*
692      * X should always be positive as a result of unsigned additions.
693      */
694     X->s = 1;
695
696     for( j = B->n - 1; j >= 0; j-- )
697         if( B->p[j] != 0 )
698             break;
699
700     MPI_CHK( mpi_grow( X, j + 1 ) );
701
702     o = B->p; p = X->p; c = 0;
703
704     for( i = 0; i <= j; i++, o++, p++ )
705     {
706         *p +=  c; c  = ( *p <  c );
707         *p += *o; c += ( *p < *o );
708     }
709
710     while( c != 0 )
711     {
712         if( i >= X->n )
713         {
714             MPI_CHK( mpi_grow( X, i + 1 ) );
715             p = X->p + i;
716         }
717
718         *p += c; c = ( *p < c ); i++;
719     }
720
721 cleanup:
722
723     return( ret );
724 }
725
726 /*
727  * Helper for mpi substraction
728  */
729 static void mpi_sub_hlp( int n, t_int *s, t_int *d )
730 {
731     int i;
732     t_int c, z;
733
734     for( i = c = 0; i < n; i++, s++, d++ )
735     {
736         z = ( *d <  c );     *d -=  c;
737         c = ( *d < *s ) + z; *d -= *s;
738     }
739
740     while( c != 0 )
741     {
742         z = ( *d < c ); *d -= c;
743         c = z; i++; d++;
744     }
745 }
746
747 /*
748  * Unsigned substraction: X = |A| - |B|  (HAC 14.9)
749  */
750 int mpi_sub_abs( mpi *X, mpi *A, mpi *B )
751 {
752     mpi TB;
753     int ret, n;
754
755     if( mpi_cmp_abs( A, B ) < 0 )
756         return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
757
758     mpi_init( &TB, NULL );
759
760     if( X == B )
761     {
762         MPI_CHK( mpi_copy( &TB, B ) );
763         B = &TB;
764     }
765
766     if( X != A )
767         MPI_CHK( mpi_copy( X, A ) );
768
769     /*
770      * X should always be positive as a result of unsigned substractions.
771      */
772     X->s = 1;
773
774     ret = 0;
775
776     for( n = B->n - 1; n >= 0; n-- )
777         if( B->p[n] != 0 )
778             break;
779
780     mpi_sub_hlp( n + 1, B->p, X->p );
781
782 cleanup:
783
784     mpi_free( &TB, NULL );
785
786     return( ret );
787 }
788
789 /*
790  * Signed addition: X = A + B
791  */
792 int mpi_add_mpi( mpi *X, mpi *A, mpi *B )
793 {
794     int ret, s = A->s;
795
796     if( A->s * B->s < 0 )
797     {
798         if( mpi_cmp_abs( A, B ) >= 0 )
799         {
800             MPI_CHK( mpi_sub_abs( X, A, B ) );
801             X->s =  s;
802         }
803         else
804         {
805             MPI_CHK( mpi_sub_abs( X, B, A ) );
806             X->s = -s;
807         }
808     }
809     else
810     {
811         MPI_CHK( mpi_add_abs( X, A, B ) );
812         X->s = s;
813     }
814
815 cleanup:
816
817     return( ret );
818 }
819
820 /*
821  * Signed substraction: X = A - B
822  */
823 int mpi_sub_mpi( mpi *X, mpi *A, mpi *B )
824 {
825     int ret, s = A->s;
826
827     if( A->s * B->s > 0 )
828     {
829         if( mpi_cmp_abs( A, B ) >= 0 )
830         {
831             MPI_CHK( mpi_sub_abs( X, A, B ) );
832             X->s =  s;
833         }
834         else
835         {
836             MPI_CHK( mpi_sub_abs( X, B, A ) );
837             X->s = -s;
838         }
839     }
840     else
841     {
842         MPI_CHK( mpi_add_abs( X, A, B ) );
843         X->s = s;
844     }
845
846 cleanup:
847
848     return( ret );
849 }
850
851 /*
852  * Signed addition: X = A + b
853  */
854 int mpi_add_int( mpi *X, mpi *A, int b )
855 {
856     mpi _B;
857     t_int p[1];
858
859     p[0] = ( b < 0 ) ? -b : b;
860     _B.s = ( b < 0 ) ? -1 : 1;
861     _B.n = 1;
862     _B.p = p;
863
864     return( mpi_add_mpi( X, A, &_B ) );
865 }
866
867 /*
868  * Signed substraction: X = A - b
869  */
870 int mpi_sub_int( mpi *X, mpi *A, int b )
871 {
872     mpi _B;
873     t_int p[1];
874
875     p[0] = ( b < 0 ) ? -b : b;
876     _B.s = ( b < 0 ) ? -1 : 1;
877     _B.n = 1;
878     _B.p = p;
879
880     return( mpi_sub_mpi( X, A, &_B ) );
881 }
882
883 /*
884  * Helper for mpi multiplication
885  */
886 static void mpi_mul_hlp( int i, t_int *s, t_int *d, t_int b )
887 {
888     t_int c = 0, t = 0;
889
890 #if defined(MULADDC_HUIT)
891     for( ; i >= 8; i -= 8 )
892     {
893         MULADDC_INIT
894         MULADDC_HUIT
895         MULADDC_STOP
896     }
897
898     for( ; i > 0; i-- )
899     {
900         MULADDC_INIT
901         MULADDC_CORE
902         MULADDC_STOP
903     }
904 #else
905     for( ; i >= 16; i -= 16 )
906     {
907         MULADDC_INIT
908         MULADDC_CORE   MULADDC_CORE
909         MULADDC_CORE   MULADDC_CORE
910         MULADDC_CORE   MULADDC_CORE
911         MULADDC_CORE   MULADDC_CORE
912
913         MULADDC_CORE   MULADDC_CORE
914         MULADDC_CORE   MULADDC_CORE
915         MULADDC_CORE   MULADDC_CORE
916         MULADDC_CORE   MULADDC_CORE
917         MULADDC_STOP
918     }
919
920     for( ; i >= 8; i -= 8 )
921     {
922         MULADDC_INIT
923         MULADDC_CORE   MULADDC_CORE
924         MULADDC_CORE   MULADDC_CORE
925
926         MULADDC_CORE   MULADDC_CORE
927         MULADDC_CORE   MULADDC_CORE
928         MULADDC_STOP
929     }
930
931     for( ; i > 0; i-- )
932     {
933         MULADDC_INIT
934         MULADDC_CORE
935         MULADDC_STOP
936     }
937 #endif
938
939     t++;
940
941     do {
942         *d += c; c = ( *d < c ); d++;
943     }
944     while( c != 0 );
945 }
946
947 /*
948  * Baseline multiplication: X = A * B  (HAC 14.12)
949  */
950 int mpi_mul_mpi( mpi *X, mpi *A, mpi *B )
951 {
952     int ret, i, j;
953     mpi TA, TB;
954
955     mpi_init( &TA, &TB, NULL );
956
957     if( X == A ) { MPI_CHK( mpi_copy( &TA, A ) ); A = &TA; }
958     if( X == B ) { MPI_CHK( mpi_copy( &TB, B ) ); B = &TB; }
959
960     for( i = A->n - 1; i >= 0; i-- )
961         if( A->p[i] != 0 )
962             break;
963
964     for( j = B->n - 1; j >= 0; j-- )
965         if( B->p[j] != 0 )
966             break;
967
968     MPI_CHK( mpi_grow( X, i + j + 2 ) );
969     MPI_CHK( mpi_lset( X, 0 ) );
970
971     for( i++; j >= 0; j-- )
972         mpi_mul_hlp( i, A->p, X->p + j, B->p[j] );
973
974     X->s = A->s * B->s;
975
976 cleanup:
977
978     mpi_free( &TB, &TA, NULL );
979
980     return( ret );
981 }
982
983 /*
984  * Baseline multiplication: X = A * b
985  */
986 int mpi_mul_int( mpi *X, mpi *A, t_int b )
987 {
988     mpi _B;
989     t_int p[1];
990
991     _B.s = 1;
992     _B.n = 1;
993     _B.p = p;
994     p[0] = b;
995
996     return( mpi_mul_mpi( X, A, &_B ) );
997 }
998
999 /*
1000  * Division by mpi: A = Q * B + R  (HAC 14.20)
1001  */
1002 int mpi_div_mpi( mpi *Q, mpi *R, mpi *A, mpi *B )
1003 {
1004     int ret, i, n, t, k;
1005     mpi X, Y, Z, T1, T2;
1006
1007     if( mpi_cmp_int( B, 0 ) == 0 )
1008         return( POLARSSL_ERR_MPI_DIVISION_BY_ZERO );
1009
1010     mpi_init( &X, &Y, &Z, &T1, &T2, NULL );
1011
1012     if( mpi_cmp_abs( A, B ) < 0 )
1013     {
1014         if( Q != NULL ) MPI_CHK( mpi_lset( Q, 0 ) );
1015         if( R != NULL ) MPI_CHK( mpi_copy( R, A ) );
1016         return( 0 );
1017     }
1018
1019     MPI_CHK( mpi_copy( &X, A ) );
1020     MPI_CHK( mpi_copy( &Y, B ) );
1021     X.s = Y.s = 1;
1022
1023     MPI_CHK( mpi_grow( &Z, A->n + 2 ) );
1024     MPI_CHK( mpi_lset( &Z,  0 ) );
1025     MPI_CHK( mpi_grow( &T1, 2 ) );
1026     MPI_CHK( mpi_grow( &T2, 3 ) );
1027
1028     k = mpi_msb( &Y ) % biL;
1029     if( k < (int) biL - 1 )
1030     {
1031         k = biL - 1 - k;
1032         MPI_CHK( mpi_shift_l( &X, k ) );
1033         MPI_CHK( mpi_shift_l( &Y, k ) );
1034     }
1035     else k = 0;
1036
1037     n = X.n - 1;
1038     t = Y.n - 1;
1039     mpi_shift_l( &Y, biL * (n - t) );
1040
1041     while( mpi_cmp_mpi( &X, &Y ) >= 0 )
1042     {
1043         Z.p[n - t]++;
1044         mpi_sub_mpi( &X, &X, &Y );
1045     }
1046     mpi_shift_r( &Y, biL * (n - t) );
1047
1048     for( i = n; i > t ; i-- )
1049     {
1050         if( X.p[i] >= Y.p[t] )
1051             Z.p[i - t - 1] = ~0;
1052         else
1053         {
1054 #if defined(POLARSSL_HAVE_LONGLONG)
1055             t_dbl r;
1056
1057             r  = (t_dbl) X.p[i] << biL;
1058             r |= (t_dbl) X.p[i - 1];
1059             r /= Y.p[t];
1060             if( r > ((t_dbl) 1 << biL) - 1)
1061                 r = ((t_dbl) 1 << biL) - 1;
1062
1063             Z.p[i - t - 1] = (t_int) r;
1064 #else
1065             /*
1066              * __udiv_qrnnd_c, from gmp/longlong.h
1067              */
1068             t_int q0, q1, r0, r1;
1069             t_int d0, d1, d, m;
1070
1071             d  = Y.p[t];
1072             d0 = ( d << biH ) >> biH;
1073             d1 = ( d >> biH );
1074
1075             q1 = X.p[i] / d1;
1076             r1 = X.p[i] - d1 * q1;
1077             r1 <<= biH;
1078             r1 |= ( X.p[i - 1] >> biH );
1079
1080             m = q1 * d0;
1081             if( r1 < m )
1082             {
1083                 q1--, r1 += d;
1084                 while( r1 >= d && r1 < m )
1085                     q1--, r1 += d;
1086             }
1087             r1 -= m;
1088
1089             q0 = r1 / d1;
1090             r0 = r1 - d1 * q0;
1091             r0 <<= biH;
1092             r0 |= ( X.p[i - 1] << biH ) >> biH;
1093
1094             m = q0 * d0;
1095             if( r0 < m )
1096             {
1097                 q0--, r0 += d;
1098                 while( r0 >= d && r0 < m )
1099                     q0--, r0 += d;
1100             }
1101             r0 -= m;
1102
1103             Z.p[i - t - 1] = ( q1 << biH ) | q0;
1104 #endif
1105         }
1106
1107         Z.p[i - t - 1]++;
1108         do
1109         {
1110             Z.p[i - t - 1]--;
1111
1112             MPI_CHK( mpi_lset( &T1, 0 ) );
1113             T1.p[0] = (t < 1) ? 0 : Y.p[t - 1];
1114             T1.p[1] = Y.p[t];
1115             MPI_CHK( mpi_mul_int( &T1, &T1, Z.p[i - t - 1] ) );
1116
1117             MPI_CHK( mpi_lset( &T2, 0 ) );
1118             T2.p[0] = (i < 2) ? 0 : X.p[i - 2];
1119             T2.p[1] = (i < 1) ? 0 : X.p[i - 1];
1120             T2.p[2] = X.p[i];
1121         }
1122         while( mpi_cmp_mpi( &T1, &T2 ) > 0 );
1123
1124         MPI_CHK( mpi_mul_int( &T1, &Y, Z.p[i - t - 1] ) );
1125         MPI_CHK( mpi_shift_l( &T1,  biL * (i - t - 1) ) );
1126         MPI_CHK( mpi_sub_mpi( &X, &X, &T1 ) );
1127
1128         if( mpi_cmp_int( &X, 0 ) < 0 )
1129         {
1130             MPI_CHK( mpi_copy( &T1, &Y ) );
1131             MPI_CHK( mpi_shift_l( &T1, biL * (i - t - 1) ) );
1132             MPI_CHK( mpi_add_mpi( &X, &X, &T1 ) );
1133             Z.p[i - t - 1]--;
1134         }
1135     }
1136
1137     if( Q != NULL )
1138     {
1139         mpi_copy( Q, &Z );
1140         Q->s = A->s * B->s;
1141     }
1142
1143     if( R != NULL )
1144     {
1145         mpi_shift_r( &X, k );
1146         mpi_copy( R, &X );
1147
1148         R->s = A->s;
1149         if( mpi_cmp_int( R, 0 ) == 0 )
1150             R->s = 1;
1151     }
1152
1153 cleanup:
1154
1155     mpi_free( &X, &Y, &Z, &T1, &T2, NULL );
1156
1157     return( ret );
1158 }
1159
1160 /*
1161  * Division by int: A = Q * b + R
1162  *
1163  * Returns 0 if successful
1164  *         1 if memory allocation failed
1165  *         POLARSSL_ERR_MPI_DIVISION_BY_ZERO if b == 0
1166  */
1167 int mpi_div_int( mpi *Q, mpi *R, mpi *A, int b )
1168 {
1169     mpi _B;
1170     t_int p[1];
1171
1172     p[0] = ( b < 0 ) ? -b : b;
1173     _B.s = ( b < 0 ) ? -1 : 1;
1174     _B.n = 1;
1175     _B.p = p;
1176
1177     return( mpi_div_mpi( Q, R, A, &_B ) );
1178 }
1179
1180 /*
1181  * Modulo: R = A mod B
1182  */
1183 int mpi_mod_mpi( mpi *R, mpi *A, mpi *B )
1184 {
1185     int ret;
1186
1187     if( mpi_cmp_int( B, 0 ) < 0 )
1188         return POLARSSL_ERR_MPI_NEGATIVE_VALUE;
1189
1190     MPI_CHK( mpi_div_mpi( NULL, R, A, B ) );
1191
1192     while( mpi_cmp_int( R, 0 ) < 0 )
1193       MPI_CHK( mpi_add_mpi( R, R, B ) );
1194
1195     while( mpi_cmp_mpi( R, B ) >= 0 )
1196       MPI_CHK( mpi_sub_mpi( R, R, B ) );
1197
1198 cleanup:
1199
1200     return( ret );
1201 }
1202
1203 /*
1204  * Modulo: r = A mod b
1205  */
1206 int mpi_mod_int( t_int *r, mpi *A, int b )
1207 {
1208     int i;
1209     t_int x, y, z;
1210
1211     if( b == 0 )
1212         return( POLARSSL_ERR_MPI_DIVISION_BY_ZERO );
1213
1214     if( b < 0 )
1215         return POLARSSL_ERR_MPI_NEGATIVE_VALUE;
1216
1217     /*
1218      * handle trivial cases
1219      */
1220     if( b == 1 )
1221     {
1222         *r = 0;
1223         return( 0 );
1224     }
1225
1226     if( b == 2 )
1227     {
1228         *r = A->p[0] & 1;
1229         return( 0 );
1230     }
1231
1232     /*
1233      * general case
1234      */
1235     for( i = A->n - 1, y = 0; i >= 0; i-- )
1236     {
1237         x  = A->p[i];
1238         y  = ( y << biH ) | ( x >> biH );
1239         z  = y / b;
1240         y -= z * b;
1241
1242         x <<= biH;
1243         y  = ( y << biH ) | ( x >> biH );
1244         z  = y / b;
1245         y -= z * b;
1246     }
1247
1248     /*
1249      * If A is negative, then the current y represents a negative value.
1250      * Flipping it to the positive side.
1251      */
1252     if( A->s < 0 && y != 0 )
1253         y = b - y;
1254
1255     *r = y;
1256
1257     return( 0 );
1258 }
1259
1260 /*
1261  * Fast Montgomery initialization (thanks to Tom St Denis)
1262  */
1263 static void mpi_montg_init( t_int *mm, mpi *N )
1264 {
1265     t_int x, m0 = N->p[0];
1266
1267     x  = m0;
1268     x += ( ( m0 + 2 ) & 4 ) << 1;
1269     x *= ( 2 - ( m0 * x ) );
1270
1271     if( biL >= 16 ) x *= ( 2 - ( m0 * x ) );
1272     if( biL >= 32 ) x *= ( 2 - ( m0 * x ) );
1273     if( biL >= 64 ) x *= ( 2 - ( m0 * x ) );
1274
1275     *mm = ~x + 1;
1276 }
1277
1278 /*
1279  * Montgomery multiplication: A = A * B * R^-1 mod N  (HAC 14.36)
1280  */
1281 static void mpi_montmul( mpi *A, mpi *B, mpi *N, t_int mm, mpi *T )
1282 {
1283     int i, n, m;
1284     t_int u0, u1, *d;
1285
1286     memset( T->p, 0, T->n * ciL );
1287
1288     d = T->p;
1289     n = N->n;
1290     m = ( B->n < n ) ? B->n : n;
1291
1292     for( i = 0; i < n; i++ )
1293     {
1294         /*
1295          * T = (T + u0*B + u1*N) / 2^biL
1296          */
1297         u0 = A->p[i];
1298         u1 = ( d[0] + u0 * B->p[0] ) * mm;
1299
1300         mpi_mul_hlp( m, B->p, d, u0 );
1301         mpi_mul_hlp( n, N->p, d, u1 );
1302
1303         *d++ = u0; d[n + 1] = 0;
1304     }
1305
1306     memcpy( A->p, d, (n + 1) * ciL );
1307
1308     if( mpi_cmp_abs( A, N ) >= 0 )
1309         mpi_sub_hlp( n, N->p, A->p );
1310     else
1311         /* prevent timing attacks */
1312         mpi_sub_hlp( n, A->p, T->p );
1313 }
1314
1315 /*
1316  * Montgomery reduction: A = A * R^-1 mod N
1317  */
1318 static void mpi_montred( mpi *A, mpi *N, t_int mm, mpi *T )
1319 {
1320     t_int z = 1;
1321     mpi U;
1322
1323     U.n = U.s = z;
1324     U.p = &z;
1325
1326     mpi_montmul( A, &U, N, mm, T );
1327 }
1328
1329 /*
1330  * Sliding-window exponentiation: X = A^E mod N  (HAC 14.85)
1331  */
1332 int mpi_exp_mod( mpi *X, mpi *A, mpi *E, mpi *N, mpi *_RR )
1333 {
1334     int ret, i, j, wsize, wbits;
1335     int bufsize, nblimbs, nbits;
1336     t_int ei, mm, state;
1337     mpi RR, T, W[64];
1338
1339     if( mpi_cmp_int( N, 0 ) < 0 || ( N->p[0] & 1 ) == 0 )
1340         return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
1341
1342     /*
1343      * Init temps and window size
1344      */
1345     mpi_montg_init( &mm, N );
1346     mpi_init( &RR, &T, NULL );
1347     memset( W, 0, sizeof( W ) );
1348
1349     i = mpi_msb( E );
1350
1351     wsize = ( i > 671 ) ? 6 : ( i > 239 ) ? 5 :
1352             ( i >  79 ) ? 4 : ( i >  23 ) ? 3 : 1;
1353
1354     j = N->n + 1;
1355     MPI_CHK( mpi_grow( X, j ) );
1356     MPI_CHK( mpi_grow( &W[1],  j ) );
1357     MPI_CHK( mpi_grow( &T, j * 2 ) );
1358
1359     /*
1360      * If 1st call, pre-compute R^2 mod N
1361      */
1362     if( _RR == NULL || _RR->p == NULL )
1363     {
1364         MPI_CHK( mpi_lset( &RR, 1 ) );
1365         MPI_CHK( mpi_shift_l( &RR, N->n * 2 * biL ) );
1366         MPI_CHK( mpi_mod_mpi( &RR, &RR, N ) );
1367
1368         if( _RR != NULL )
1369             memcpy( _RR, &RR, sizeof( mpi ) );
1370     }
1371     else
1372         memcpy( &RR, _RR, sizeof( mpi ) );
1373
1374     /*
1375      * W[1] = A * R^2 * R^-1 mod N = A * R mod N
1376      */
1377     if( mpi_cmp_mpi( A, N ) >= 0 )
1378         mpi_mod_mpi( &W[1], A, N );
1379     else   mpi_copy( &W[1], A );
1380
1381     mpi_montmul( &W[1], &RR, N, mm, &T );
1382
1383     /*
1384      * X = R^2 * R^-1 mod N = R mod N
1385      */
1386     MPI_CHK( mpi_copy( X, &RR ) );
1387     mpi_montred( X, N, mm, &T );
1388
1389     if( wsize > 1 )
1390     {
1391         /*
1392          * W[1 << (wsize - 1)] = W[1] ^ (wsize - 1)
1393          */
1394         j =  1 << (wsize - 1);
1395
1396         MPI_CHK( mpi_grow( &W[j], N->n + 1 ) );
1397         MPI_CHK( mpi_copy( &W[j], &W[1]    ) );
1398
1399         for( i = 0; i < wsize - 1; i++ )
1400             mpi_montmul( &W[j], &W[j], N, mm, &T );
1401
1402         /*
1403          * W[i] = W[i - 1] * W[1]
1404          */
1405         for( i = j + 1; i < (1 << wsize); i++ )
1406         {
1407             MPI_CHK( mpi_grow( &W[i], N->n + 1 ) );
1408             MPI_CHK( mpi_copy( &W[i], &W[i - 1] ) );
1409
1410             mpi_montmul( &W[i], &W[1], N, mm, &T );
1411         }
1412     }
1413
1414     nblimbs = E->n;
1415     bufsize = 0;
1416     nbits   = 0;
1417     wbits   = 0;
1418     state   = 0;
1419
1420     while( 1 )
1421     {
1422         if( bufsize == 0 )
1423         {
1424             if( nblimbs-- == 0 )
1425                 break;
1426
1427             bufsize = sizeof( t_int ) << 3;
1428         }
1429
1430         bufsize--;
1431
1432         ei = (E->p[nblimbs] >> bufsize) & 1;
1433
1434         /*
1435          * skip leading 0s
1436          */
1437         if( ei == 0 && state == 0 )
1438             continue;
1439
1440         if( ei == 0 && state == 1 )
1441         {
1442             /*
1443              * out of window, square X
1444              */
1445             mpi_montmul( X, X, N, mm, &T );
1446             continue;
1447         }
1448
1449         /*
1450          * add ei to current window
1451          */
1452         state = 2;
1453
1454         nbits++;
1455         wbits |= (ei << (wsize - nbits));
1456
1457         if( nbits == wsize )
1458         {
1459             /*
1460              * X = X^wsize R^-1 mod N
1461              */
1462             for( i = 0; i < wsize; i++ )
1463                 mpi_montmul( X, X, N, mm, &T );
1464
1465             /*
1466              * X = X * W[wbits] R^-1 mod N
1467              */
1468             mpi_montmul( X, &W[wbits], N, mm, &T );
1469
1470             state--;
1471             nbits = 0;
1472             wbits = 0;
1473         }
1474     }
1475
1476     /*
1477      * process the remaining bits
1478      */
1479     for( i = 0; i < nbits; i++ )
1480     {
1481         mpi_montmul( X, X, N, mm, &T );
1482
1483         wbits <<= 1;
1484
1485         if( (wbits & (1 << wsize)) != 0 )
1486             mpi_montmul( X, &W[1], N, mm, &T );
1487     }
1488
1489     /*
1490      * X = A^E * R * R^-1 mod N = A^E mod N
1491      */
1492     mpi_montred( X, N, mm, &T );
1493
1494 cleanup:
1495
1496     for( i = (1 << (wsize - 1)); i < (1 << wsize); i++ )
1497         mpi_free( &W[i], NULL );
1498
1499     if( _RR != NULL )
1500          mpi_free( &W[1], &T, NULL );
1501     else mpi_free( &W[1], &T, &RR, NULL );
1502
1503     return( ret );
1504 }
1505
1506 /*
1507  * Greatest common divisor: G = gcd(A, B)  (HAC 14.54)
1508  */
1509 int mpi_gcd( mpi *G, mpi *A, mpi *B )
1510 {
1511     int ret, lz, lzt;
1512     mpi TG, TA, TB;
1513
1514     mpi_init( &TG, &TA, &TB, NULL );
1515
1516     MPI_CHK( mpi_copy( &TA, A ) );
1517     MPI_CHK( mpi_copy( &TB, B ) );
1518
1519     lz = mpi_lsb( &TA );
1520     lzt = mpi_lsb( &TB );
1521
1522     if ( lzt < lz )
1523         lz = lzt;
1524
1525     MPI_CHK( mpi_shift_r( &TA, lz ) );
1526     MPI_CHK( mpi_shift_r( &TB, lz ) );
1527
1528     TA.s = TB.s = 1;
1529
1530     while( mpi_cmp_int( &TA, 0 ) != 0 )
1531     {
1532         MPI_CHK( mpi_shift_r( &TA, mpi_lsb( &TA ) ) );
1533         MPI_CHK( mpi_shift_r( &TB, mpi_lsb( &TB ) ) );
1534
1535         if( mpi_cmp_mpi( &TA, &TB ) >= 0 )
1536         {
1537             MPI_CHK( mpi_sub_abs( &TA, &TA, &TB ) );
1538             MPI_CHK( mpi_shift_r( &TA, 1 ) );
1539         }
1540         else
1541         {
1542             MPI_CHK( mpi_sub_abs( &TB, &TB, &TA ) );
1543             MPI_CHK( mpi_shift_r( &TB, 1 ) );
1544         }
1545     }
1546
1547     MPI_CHK( mpi_shift_l( &TB, lz ) );
1548     MPI_CHK( mpi_copy( G, &TB ) );
1549
1550 cleanup:
1551
1552     mpi_free( &TB, &TA, &TG, NULL );
1553
1554     return( ret );
1555 }
1556
1557 #if defined(POLARSSL_GENPRIME)
1558
1559 /*
1560  * Modular inverse: X = A^-1 mod N  (HAC 14.61 / 14.64)
1561  */
1562 int mpi_inv_mod( mpi *X, mpi *A, mpi *N )
1563 {
1564     int ret;
1565     mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
1566
1567     if( mpi_cmp_int( N, 0 ) <= 0 )
1568         return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
1569
1570     mpi_init( &TA, &TU, &U1, &U2, &G,
1571               &TB, &TV, &V1, &V2, NULL );
1572
1573     MPI_CHK( mpi_gcd( &G, A, N ) );
1574
1575     if( mpi_cmp_int( &G, 1 ) != 0 )
1576     {
1577         ret = POLARSSL_ERR_MPI_NOT_ACCEPTABLE;
1578         goto cleanup;
1579     }
1580
1581     MPI_CHK( mpi_mod_mpi( &TA, A, N ) );
1582     MPI_CHK( mpi_copy( &TU, &TA ) );
1583     MPI_CHK( mpi_copy( &TB, N ) );
1584     MPI_CHK( mpi_copy( &TV, N ) );
1585
1586     MPI_CHK( mpi_lset( &U1, 1 ) );
1587     MPI_CHK( mpi_lset( &U2, 0 ) );
1588     MPI_CHK( mpi_lset( &V1, 0 ) );
1589     MPI_CHK( mpi_lset( &V2, 1 ) );
1590
1591     do
1592     {
1593         while( ( TU.p[0] & 1 ) == 0 )
1594         {
1595             MPI_CHK( mpi_shift_r( &TU, 1 ) );
1596
1597             if( ( U1.p[0] & 1 ) != 0 || ( U2.p[0] & 1 ) != 0 )
1598             {
1599                 MPI_CHK( mpi_add_mpi( &U1, &U1, &TB ) );
1600                 MPI_CHK( mpi_sub_mpi( &U2, &U2, &TA ) );
1601             }
1602
1603             MPI_CHK( mpi_shift_r( &U1, 1 ) );
1604             MPI_CHK( mpi_shift_r( &U2, 1 ) );
1605         }
1606
1607         while( ( TV.p[0] & 1 ) == 0 )
1608         {
1609             MPI_CHK( mpi_shift_r( &TV, 1 ) );
1610
1611             if( ( V1.p[0] & 1 ) != 0 || ( V2.p[0] & 1 ) != 0 )
1612             {
1613                 MPI_CHK( mpi_add_mpi( &V1, &V1, &TB ) );
1614                 MPI_CHK( mpi_sub_mpi( &V2, &V2, &TA ) );
1615             }
1616
1617             MPI_CHK( mpi_shift_r( &V1, 1 ) );
1618             MPI_CHK( mpi_shift_r( &V2, 1 ) );
1619         }
1620
1621         if( mpi_cmp_mpi( &TU, &TV ) >= 0 )
1622         {
1623             MPI_CHK( mpi_sub_mpi( &TU, &TU, &TV ) );
1624             MPI_CHK( mpi_sub_mpi( &U1, &U1, &V1 ) );
1625             MPI_CHK( mpi_sub_mpi( &U2, &U2, &V2 ) );
1626         }
1627         else
1628         {
1629             MPI_CHK( mpi_sub_mpi( &TV, &TV, &TU ) );
1630             MPI_CHK( mpi_sub_mpi( &V1, &V1, &U1 ) );
1631             MPI_CHK( mpi_sub_mpi( &V2, &V2, &U2 ) );
1632         }
1633     }
1634     while( mpi_cmp_int( &TU, 0 ) != 0 );
1635
1636     while( mpi_cmp_int( &V1, 0 ) < 0 )
1637         MPI_CHK( mpi_add_mpi( &V1, &V1, N ) );
1638
1639     while( mpi_cmp_mpi( &V1, N ) >= 0 )
1640         MPI_CHK( mpi_sub_mpi( &V1, &V1, N ) );
1641
1642     MPI_CHK( mpi_copy( X, &V1 ) );
1643
1644 cleanup:
1645
1646     mpi_free( &V2, &V1, &TV, &TB, &G,
1647               &U2, &U1, &TU, &TA, NULL );
1648
1649     return( ret );
1650 }
1651
1652 static const int small_prime[] =
1653 {
1654         3,    5,    7,   11,   13,   17,   19,   23,
1655        29,   31,   37,   41,   43,   47,   53,   59,
1656        61,   67,   71,   73,   79,   83,   89,   97,
1657       101,  103,  107,  109,  113,  127,  131,  137,
1658       139,  149,  151,  157,  163,  167,  173,  179,
1659       181,  191,  193,  197,  199,  211,  223,  227,
1660       229,  233,  239,  241,  251,  257,  263,  269,
1661       271,  277,  281,  283,  293,  307,  311,  313,
1662       317,  331,  337,  347,  349,  353,  359,  367,
1663       373,  379,  383,  389,  397,  401,  409,  419,
1664       421,  431,  433,  439,  443,  449,  457,  461,
1665       463,  467,  479,  487,  491,  499,  503,  509,
1666       521,  523,  541,  547,  557,  563,  569,  571,
1667       577,  587,  593,  599,  601,  607,  613,  617,
1668       619,  631,  641,  643,  647,  653,  659,  661,
1669       673,  677,  683,  691,  701,  709,  719,  727,
1670       733,  739,  743,  751,  757,  761,  769,  773,
1671       787,  797,  809,  811,  821,  823,  827,  829,
1672       839,  853,  857,  859,  863,  877,  881,  883,
1673       887,  907,  911,  919,  929,  937,  941,  947,
1674       953,  967,  971,  977,  983,  991,  997, -103
1675 };
1676
1677 /*
1678  * Miller-Rabin primality test  (HAC 4.24)
1679  */
1680 int mpi_is_prime( mpi *X, int (*f_rng)(void *), void *p_rng )
1681 {
1682     int ret, i, j, n, s, xs;
1683     mpi W, R, T, A, RR;
1684     unsigned char *p;
1685
1686     if( mpi_cmp_int( X, 0 ) == 0 ||
1687         mpi_cmp_int( X, 1 ) == 0 )
1688         return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
1689
1690     if( mpi_cmp_int( X, 2 ) == 0 )
1691         return( 0 );
1692
1693     mpi_init( &W, &R, &T, &A, &RR, NULL );
1694
1695     xs = X->s; X->s = 1;
1696
1697     /*
1698      * test trivial factors first
1699      */
1700     if( ( X->p[0] & 1 ) == 0 )
1701         return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
1702
1703     for( i = 0; small_prime[i] > 0; i++ )
1704     {
1705         t_int r;
1706
1707         if( mpi_cmp_int( X, small_prime[i] ) <= 0 )
1708             return( 0 );
1709
1710         MPI_CHK( mpi_mod_int( &r, X, small_prime[i] ) );
1711
1712         if( r == 0 )
1713             return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
1714     }
1715
1716     /*
1717      * W = |X| - 1
1718      * R = W >> lsb( W )
1719      */
1720     s = mpi_lsb( &W );
1721     MPI_CHK( mpi_sub_int( &W, X, 1 ) );
1722     MPI_CHK( mpi_copy( &R, &W ) );
1723     MPI_CHK( mpi_shift_r( &R, s ) );
1724
1725     i = mpi_msb( X );
1726     /*
1727      * HAC, table 4.4
1728      */
1729     n = ( ( i >= 1300 ) ?  2 : ( i >=  850 ) ?  3 :
1730           ( i >=  650 ) ?  4 : ( i >=  350 ) ?  8 :
1731           ( i >=  250 ) ? 12 : ( i >=  150 ) ? 18 : 27 );
1732
1733     for( i = 0; i < n; i++ )
1734     {
1735         /*
1736          * pick a random A, 1 < A < |X| - 1
1737          */
1738         MPI_CHK( mpi_grow( &A, X->n ) );
1739
1740         p = (unsigned char *) A.p;
1741         for( j = 0; j < A.n * ciL; j++ )
1742             *p++ = (unsigned char) f_rng( p_rng );
1743
1744         j = mpi_msb( &A ) - mpi_msb( &W );
1745         MPI_CHK( mpi_shift_r( &A, j + 1 ) );
1746         A.p[0] |= 3;
1747
1748         /*
1749          * A = A^R mod |X|
1750          */
1751         MPI_CHK( mpi_exp_mod( &A, &A, &R, X, &RR ) );
1752
1753         if( mpi_cmp_mpi( &A, &W ) == 0 ||
1754             mpi_cmp_int( &A,  1 ) == 0 )
1755             continue;
1756
1757         j = 1;
1758         while( j < s && mpi_cmp_mpi( &A, &W ) != 0 )
1759         {
1760             /*
1761              * A = A * A mod |X|
1762              */
1763             MPI_CHK( mpi_mul_mpi( &T, &A, &A ) );
1764             MPI_CHK( mpi_mod_mpi( &A, &T, X  ) );
1765
1766             if( mpi_cmp_int( &A, 1 ) == 0 )
1767                 break;
1768
1769             j++;
1770         }
1771
1772         /*
1773          * not prime if A != |X| - 1 or A == 1
1774          */
1775         if( mpi_cmp_mpi( &A, &W ) != 0 ||
1776             mpi_cmp_int( &A,  1 ) == 0 )
1777         {
1778             ret = POLARSSL_ERR_MPI_NOT_ACCEPTABLE;
1779             break;
1780         }
1781     }
1782
1783 cleanup:
1784
1785     X->s = xs;
1786
1787     mpi_free( &RR, &A, &T, &R, &W, NULL );
1788
1789     return( ret );
1790 }
1791
1792 /*
1793  * Prime number generation
1794  */
1795 int mpi_gen_prime( mpi *X, int nbits, int dh_flag,
1796                    int (*f_rng)(void *), void *p_rng )
1797 {
1798     int ret, k, n;
1799     unsigned char *p;
1800     mpi Y;
1801
1802     if( nbits < 3 )
1803         return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
1804
1805     mpi_init( &Y, NULL );
1806
1807     n = BITS_TO_LIMBS( nbits );
1808
1809     MPI_CHK( mpi_grow( X, n ) );
1810     MPI_CHK( mpi_lset( X, 0 ) );
1811
1812     p = (unsigned char *) X->p;
1813     for( k = 0; k < X->n * ciL; k++ )
1814         *p++ = (unsigned char) f_rng( p_rng );
1815
1816     k = mpi_msb( X );
1817     if( k < nbits ) MPI_CHK( mpi_shift_l( X, nbits - k ) );
1818     if( k > nbits ) MPI_CHK( mpi_shift_r( X, k - nbits ) );
1819
1820     X->p[0] |= 3;
1821
1822     if( dh_flag == 0 )
1823     {
1824         while( ( ret = mpi_is_prime( X, f_rng, p_rng ) ) != 0 )
1825         {
1826             if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
1827                 goto cleanup;
1828
1829             MPI_CHK( mpi_add_int( X, X, 2 ) );
1830         }
1831     }
1832     else
1833     {
1834         MPI_CHK( mpi_sub_int( &Y, X, 1 ) );
1835         MPI_CHK( mpi_shift_r( &Y, 1 ) );
1836
1837         while( 1 )
1838         {
1839             if( ( ret = mpi_is_prime( X, f_rng, p_rng ) ) == 0 )
1840             {
1841                 if( ( ret = mpi_is_prime( &Y, f_rng, p_rng ) ) == 0 )
1842                     break;
1843
1844                 if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
1845                     goto cleanup;
1846             }
1847
1848             if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
1849                 goto cleanup;
1850
1851             MPI_CHK( mpi_add_int( &Y, X, 1 ) );
1852             MPI_CHK( mpi_add_int(  X, X, 2 ) );
1853             MPI_CHK( mpi_shift_r( &Y, 1 ) );
1854         }
1855     }
1856
1857 cleanup:
1858
1859     mpi_free( &Y, NULL );
1860
1861     return( ret );
1862 }
1863
1864 #endif