source: trunk/third/moira/util/rsaref/rsa.c @ 23095

Revision 23095, 10.1 KB checked in by ghudson, 16 years ago (diff)
Import the moira package from SIPB Debathena.
RevLine 
[23095]1/* RSA.C - RSA routines for RSAREF
2 */
3
4/* Copyright (C) RSA Laboratories, a division of RSA Data Security,
5     Inc., created 1991. All rights reserved.
6 */
7
8#include "global.h"
9#include "rsaref.h"
10#include "r_random.h"
11#include "rsa.h"
12#include "nn.h"
13
14static int RSAPublicBlock PROTO_LIST
15  ((unsigned char *, unsigned int *, unsigned char *, unsigned int,
16    R_RSA_PUBLIC_KEY *));
17static int RSAPrivateBlock PROTO_LIST
18  ((unsigned char *, unsigned int *, unsigned char *, unsigned int,
19    R_RSA_PRIVATE_KEY *));
20
21/* RSA public-key encryption, according to PKCS #1.
22 */
23int RSAPublicEncrypt
24  (output, outputLen, input, inputLen, publicKey, randomStruct)
25unsigned char *output;                                      /* output block */
26unsigned int *outputLen;                          /* length of output block */
27unsigned char *input;                                        /* input block */
28unsigned int inputLen;                             /* length of input block */
29R_RSA_PUBLIC_KEY *publicKey;                              /* RSA public key */
30R_RANDOM_STRUCT *randomStruct;                          /* random structure */
31{
32  int status;
33  unsigned char byte, pkcsBlock[MAX_RSA_MODULUS_LEN];
34  unsigned int i, modulusLen;
35 
36  modulusLen = (publicKey->bits + 7) / 8;
37  if (inputLen + 11 > modulusLen)
38    return (RE_LEN);
39 
40  pkcsBlock[0] = 0;
41  /* block type 2 */
42  pkcsBlock[1] = 2;
43
44  for (i = 2; i < modulusLen - inputLen - 1; i++) {
45    /* Find nonzero random byte.
46     */
47    do {
48      R_GenerateBytes (&byte, 1, randomStruct);
49    } while (byte == 0);
50    pkcsBlock[i] = byte;
51  }
52  /* separator */
53  pkcsBlock[i++] = 0;
54 
55  R_memcpy ((POINTER)&pkcsBlock[i], (POINTER)input, inputLen);
56 
57  status = RSAPublicBlock
58    (output, outputLen, pkcsBlock, modulusLen, publicKey);
59 
60  /* Zeroize sensitive information.
61   */
62  byte = 0;
63  R_memset ((POINTER)pkcsBlock, 0, sizeof (pkcsBlock));
64 
65  return (status);
66}
67
68/* RSA public-key decryption, according to PKCS #1.
69 */
70int RSAPublicDecrypt (output, outputLen, input, inputLen, publicKey)
71unsigned char *output;                                      /* output block */
72unsigned int *outputLen;                          /* length of output block */
73unsigned char *input;                                        /* input block */
74unsigned int inputLen;                             /* length of input block */
75R_RSA_PUBLIC_KEY *publicKey;                              /* RSA public key */
76{
77  int status;
78  unsigned char pkcsBlock[MAX_RSA_MODULUS_LEN];
79  unsigned int i, modulusLen, pkcsBlockLen;
80 
81  modulusLen = (publicKey->bits + 7) / 8;
82  if (inputLen > modulusLen)
83    return (RE_LEN);
84 
85  if (status = RSAPublicBlock
86      (pkcsBlock, &pkcsBlockLen, input, inputLen, publicKey))
87    return (status);
88 
89  if (pkcsBlockLen != modulusLen)
90    return (RE_LEN);
91 
92  /* Require block type 1.
93   */
94  if ((pkcsBlock[0] != 0) || (pkcsBlock[1] != 1))
95   return (RE_DATA);
96
97  for (i = 2; i < modulusLen-1; i++)
98    if (pkcsBlock[i] != 0xff)
99      break;
100   
101  /* separator */
102  if (pkcsBlock[i++] != 0)
103    return (RE_DATA);
104 
105  *outputLen = modulusLen - i;
106 
107  if (*outputLen + 11 > modulusLen)
108    return (RE_DATA);
109
110  R_memcpy ((POINTER)output, (POINTER)&pkcsBlock[i], *outputLen);
111 
112  /* Zeroize potentially sensitive information.
113   */
114  R_memset ((POINTER)pkcsBlock, 0, sizeof (pkcsBlock));
115 
116  return (0);
117}
118
119/* RSA private-key encryption, according to PKCS #1.
120 */
121int RSAPrivateEncrypt (output, outputLen, input, inputLen, privateKey)
122unsigned char *output;                                      /* output block */
123unsigned int *outputLen;                          /* length of output block */
124unsigned char *input;                                        /* input block */
125unsigned int inputLen;                             /* length of input block */
126R_RSA_PRIVATE_KEY *privateKey;                           /* RSA private key */
127{
128  int status;
129  unsigned char pkcsBlock[MAX_RSA_MODULUS_LEN];
130  unsigned int i, modulusLen;
131 
132  modulusLen = (privateKey->bits + 7) / 8;
133  if (inputLen + 11 > modulusLen)
134    return (RE_LEN);
135 
136  pkcsBlock[0] = 0;
137  /* block type 1 */
138  pkcsBlock[1] = 1;
139
140  for (i = 2; i < modulusLen - inputLen - 1; i++)
141    pkcsBlock[i] = 0xff;
142
143  /* separator */
144  pkcsBlock[i++] = 0;
145 
146  R_memcpy ((POINTER)&pkcsBlock[i], (POINTER)input, inputLen);
147 
148  status = RSAPrivateBlock
149    (output, outputLen, pkcsBlock, modulusLen, privateKey);
150
151  /* Zeroize potentially sensitive information.
152   */
153  R_memset ((POINTER)pkcsBlock, 0, sizeof (pkcsBlock));
154
155  return (status);
156}
157
158/* RSA private-key decryption, according to PKCS #1.
159 */
160int RSAPrivateDecrypt (output, outputLen, input, inputLen, privateKey)
161unsigned char *output;                                      /* output block */
162unsigned int *outputLen;                          /* length of output block */
163unsigned char *input;                                        /* input block */
164unsigned int inputLen;                             /* length of input block */
165R_RSA_PRIVATE_KEY *privateKey;                           /* RSA private key */
166{
167  int status;
168  unsigned char pkcsBlock[MAX_RSA_MODULUS_LEN];
169  unsigned int i, modulusLen, pkcsBlockLen;
170 
171  modulusLen = (privateKey->bits + 7) / 8;
172  if (inputLen > modulusLen)
173    return (RE_LEN);
174 
175  if (status = RSAPrivateBlock
176      (pkcsBlock, &pkcsBlockLen, input, inputLen, privateKey))
177    return (status);
178 
179  if (pkcsBlockLen != modulusLen)
180    return (RE_LEN);
181 
182  /* Require block type 2.
183   */
184  if ((pkcsBlock[0] != 0) || (pkcsBlock[1] != 2))
185   return (RE_DATA);
186
187  for (i = 2; i < modulusLen-1; i++)
188    /* separator */
189    if (pkcsBlock[i] == 0)
190      break;
191   
192  i++;
193  if (i >= modulusLen)
194    return (RE_DATA);
195   
196  *outputLen = modulusLen - i;
197 
198  if (*outputLen + 11 > modulusLen)
199    return (RE_DATA);
200
201  R_memcpy ((POINTER)output, (POINTER)&pkcsBlock[i], *outputLen);
202 
203  /* Zeroize sensitive information.
204   */
205  R_memset ((POINTER)pkcsBlock, 0, sizeof (pkcsBlock));
206 
207  return (0);
208}
209
210/* Raw RSA public-key operation. Output has same length as modulus.
211
212   Assumes inputLen < length of modulus.
213   Requires input < modulus.
214 */
215static int RSAPublicBlock (output, outputLen, input, inputLen, publicKey)
216unsigned char *output;                                      /* output block */
217unsigned int *outputLen;                          /* length of output block */
218unsigned char *input;                                        /* input block */
219unsigned int inputLen;                             /* length of input block */
220R_RSA_PUBLIC_KEY *publicKey;                              /* RSA public key */
221{
222  NN_DIGIT c[MAX_NN_DIGITS], e[MAX_NN_DIGITS], m[MAX_NN_DIGITS],
223    n[MAX_NN_DIGITS];
224  unsigned int eDigits, nDigits;
225
226  NN_Decode (m, MAX_NN_DIGITS, input, inputLen);
227  NN_Decode (n, MAX_NN_DIGITS, publicKey->modulus, MAX_RSA_MODULUS_LEN);
228  NN_Decode (e, MAX_NN_DIGITS, publicKey->exponent, MAX_RSA_MODULUS_LEN);
229  nDigits = NN_Digits (n, MAX_NN_DIGITS);
230  eDigits = NN_Digits (e, MAX_NN_DIGITS);
231 
232  if (NN_Cmp (m, n, nDigits) >= 0)
233    return (RE_DATA);
234 
235  /* Compute c = m^e mod n.
236   */
237  NN_ModExp (c, m, e, eDigits, n, nDigits);
238
239  *outputLen = (publicKey->bits + 7) / 8;
240  NN_Encode (output, *outputLen, c, nDigits);
241 
242  /* Zeroize sensitive information.
243   */
244  R_memset ((POINTER)c, 0, sizeof (c));
245  R_memset ((POINTER)m, 0, sizeof (m));
246
247  return (0);
248}
249
250/* Raw RSA private-key operation. Output has same length as modulus.
251
252   Assumes inputLen < length of modulus.
253   Requires input < modulus.
254 */
255static int RSAPrivateBlock (output, outputLen, input, inputLen, privateKey)
256unsigned char *output;                                      /* output block */
257unsigned int *outputLen;                          /* length of output block */
258unsigned char *input;                                        /* input block */
259unsigned int inputLen;                             /* length of input block */
260R_RSA_PRIVATE_KEY *privateKey;                           /* RSA private key */
261{
262  NN_DIGIT c[MAX_NN_DIGITS], cP[MAX_NN_DIGITS], cQ[MAX_NN_DIGITS],
263    dP[MAX_NN_DIGITS], dQ[MAX_NN_DIGITS], mP[MAX_NN_DIGITS],
264    mQ[MAX_NN_DIGITS], n[MAX_NN_DIGITS], p[MAX_NN_DIGITS], q[MAX_NN_DIGITS],
265    qInv[MAX_NN_DIGITS], t[MAX_NN_DIGITS];
266  unsigned int cDigits, nDigits, pDigits;
267 
268  NN_Decode (c, MAX_NN_DIGITS, input, inputLen);
269  NN_Decode (n, MAX_NN_DIGITS, privateKey->modulus, MAX_RSA_MODULUS_LEN);
270  NN_Decode (p, MAX_NN_DIGITS, privateKey->prime[0], MAX_RSA_PRIME_LEN);
271  NN_Decode (q, MAX_NN_DIGITS, privateKey->prime[1], MAX_RSA_PRIME_LEN);
272  NN_Decode
273    (dP, MAX_NN_DIGITS, privateKey->primeExponent[0], MAX_RSA_PRIME_LEN);
274  NN_Decode
275    (dQ, MAX_NN_DIGITS, privateKey->primeExponent[1], MAX_RSA_PRIME_LEN);
276  NN_Decode (qInv, MAX_NN_DIGITS, privateKey->coefficient, MAX_RSA_PRIME_LEN);
277  cDigits = NN_Digits (c, MAX_NN_DIGITS);
278  nDigits = NN_Digits (n, MAX_NN_DIGITS);
279  pDigits = NN_Digits (p, MAX_NN_DIGITS);
280
281  if (NN_Cmp (c, n, nDigits) >= 0)
282    return (RE_DATA);
283 
284  /* Compute mP = cP^dP mod p  and  mQ = cQ^dQ mod q. (Assumes q has
285     length at most pDigits, i.e., p > q.)
286   */
287  NN_Mod (cP, c, cDigits, p, pDigits);
288  NN_Mod (cQ, c, cDigits, q, pDigits);
289  NN_ModExp (mP, cP, dP, pDigits, p, pDigits);
290  NN_AssignZero (mQ, nDigits);
291  NN_ModExp (mQ, cQ, dQ, pDigits, q, pDigits);
292 
293  /* Chinese Remainder Theorem:
294       m = ((((mP - mQ) mod p) * qInv) mod p) * q + mQ.
295   */
296  if (NN_Cmp (mP, mQ, pDigits) >= 0)
297    NN_Sub (t, mP, mQ, pDigits);
298  else {
299    NN_Sub (t, mQ, mP, pDigits);
300    NN_Sub (t, p, t, pDigits);
301  }
302  NN_ModMult (t, t, qInv, p, pDigits);
303  NN_Mult (t, t, q, pDigits);
304  NN_Add (t, t, mQ, nDigits);
305
306  *outputLen = (privateKey->bits + 7) / 8;
307  NN_Encode (output, *outputLen, t, nDigits);
308
309  /* Zeroize sensitive information.
310   */
311  R_memset ((POINTER)c, 0, sizeof (c));
312  R_memset ((POINTER)cP, 0, sizeof (cP));
313  R_memset ((POINTER)cQ, 0, sizeof (cQ));
314  R_memset ((POINTER)dP, 0, sizeof (dP));
315  R_memset ((POINTER)dQ, 0, sizeof (dQ));
316  R_memset ((POINTER)mP, 0, sizeof (mP));
317  R_memset ((POINTER)mQ, 0, sizeof (mQ));
318  R_memset ((POINTER)p, 0, sizeof (p));
319  R_memset ((POINTER)q, 0, sizeof (q));
320  R_memset ((POINTER)qInv, 0, sizeof (qInv));
321  R_memset ((POINTER)t, 0, sizeof (t));
322
323  return (0);
324}
Note: See TracBrowser for help on using the repository browser.