a3361dc3d76a6d6e197ba65bc99682d68a88c813
[openssl.git] / crypto / rsa / rsa_oaep.c
1 /* crypto/rsa/rsa_oaep.c */
2 /* Written by Ulf Moeller. This software is distributed on an "AS IS"
3    basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. */
4
5 /* EME-OAEP as defined in RFC 2437 (PKCS #1 v2.0) */
6
7 /* See Victor Shoup, "OAEP reconsidered," Nov. 2000,
8  * <URL: http://www.shoup.net/papers/oaep.ps.Z>
9  * for problems with the security proof for the
10  * original OAEP scheme, which EME-OAEP is based on.
11  * 
12  * A new proof can be found in E. Fujisaki, T. Okamoto,
13  * D. Pointcheval, J. Stern, "RSA-OEAP is Still Alive!",
14  * Dec. 2000, <URL: http://eprint.iacr.org/2000/061/>.
15  * The new proof has stronger requirements for the
16  * underlying permutation: "partial-one-wayness" instead
17  * of one-wayness.  For the RSA function, this is
18  * an equivalent notion.
19  */
20
21
22 #if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA1)
23 #include <stdio.h>
24 #include "cryptlib.h"
25 #include <openssl/bn.h>
26 #include <openssl/rsa.h>
27 #include <openssl/sha.h>
28 #include <openssl/rand.h>
29
30 int MGF1(unsigned char *mask, long len,
31         const unsigned char *seed, long seedlen);
32
33 int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
34         const unsigned char *from, int flen,
35         const unsigned char *param, int plen)
36     {
37     int i, emlen = tlen - 1;
38     unsigned char *db, *seed;
39     unsigned char *dbmask, seedmask[SHA_DIGEST_LENGTH];
40
41     if (flen > emlen - 2 * SHA_DIGEST_LENGTH - 1)
42         {
43         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP,
44                RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
45         return (0);
46         }
47
48     if (emlen < 2 * SHA_DIGEST_LENGTH + 1)
49         {
50         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, RSA_R_KEY_SIZE_TOO_SMALL);
51         return (0);
52         }
53     
54     dbmask = OPENSSL_malloc(emlen - SHA_DIGEST_LENGTH);
55     if (dbmask == NULL)
56         {
57         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
58         return (0);
59         }
60
61     to[0] = 0;
62     seed = to + 1;
63     db = to + SHA_DIGEST_LENGTH + 1;
64
65     SHA1(param, plen, db);
66     memset(db + SHA_DIGEST_LENGTH, 0,
67            emlen - flen - 2 * SHA_DIGEST_LENGTH - 1);
68     db[emlen - flen - SHA_DIGEST_LENGTH - 1] = 0x01;
69     memcpy(db + emlen - flen - SHA_DIGEST_LENGTH, from, (unsigned int) flen);
70     if (RAND_bytes(seed, SHA_DIGEST_LENGTH) <= 0)
71         return (0);
72 #ifdef PKCS_TESTVECT
73     memcpy(seed,
74            "\xaa\xfd\x12\xf6\x59\xca\xe6\x34\x89\xb4\x79\xe5\x07\x6d\xde\xc2\xf0\x6c\xb5\x8f",
75            20);
76 #endif
77
78     MGF1(dbmask, emlen - SHA_DIGEST_LENGTH, seed, SHA_DIGEST_LENGTH);
79     for (i = 0; i < emlen - SHA_DIGEST_LENGTH; i++)
80         db[i] ^= dbmask[i];
81
82     MGF1(seedmask, SHA_DIGEST_LENGTH, db, emlen - SHA_DIGEST_LENGTH);
83     for (i = 0; i < SHA_DIGEST_LENGTH; i++)
84         seed[i] ^= seedmask[i];
85
86     OPENSSL_free(dbmask);
87     return (1);
88     }
89
90 int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
91         const unsigned char *from, int flen, int num,
92         const unsigned char *param, int plen)
93     {
94     int i, dblen, mlen = -1;
95     const unsigned char *maskeddb;
96     int lzero;
97     unsigned char *db, seed[SHA_DIGEST_LENGTH], phash[SHA_DIGEST_LENGTH];
98
99     if (--num < 2 * SHA_DIGEST_LENGTH + 1)
100         {
101         RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, RSA_R_OAEP_DECODING_ERROR);
102         return (-1);
103         }
104
105     dblen = num - SHA_DIGEST_LENGTH;
106     db = OPENSSL_malloc(dblen);
107     if (db == NULL)
108         {
109         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
110         return (-1);
111         }
112
113     lzero = num - flen;
114     if (lzero < 0)
115     {
116     RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, RSA_R_OAEP_DECODING_ERROR);
117     return (-1);
118     }
119     maskeddb = from - lzero + SHA_DIGEST_LENGTH;
120     
121     MGF1(seed, SHA_DIGEST_LENGTH, maskeddb, dblen);
122     for (i = lzero; i < SHA_DIGEST_LENGTH; i++)
123         seed[i] ^= from[i - lzero];
124   
125     MGF1(db, dblen, seed, SHA_DIGEST_LENGTH);
126     for (i = 0; i < dblen; i++)
127         db[i] ^= maskeddb[i];
128
129     SHA1(param, plen, phash);
130
131     if (memcmp(db, phash, SHA_DIGEST_LENGTH) != 0)
132         RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, RSA_R_OAEP_DECODING_ERROR);
133     else
134         {
135         for (i = SHA_DIGEST_LENGTH; i < dblen; i++)
136             if (db[i] != 0x00)
137                 break;
138         if (db[i] != 0x01 || i++ >= dblen)
139             RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP,
140                    RSA_R_OAEP_DECODING_ERROR);
141         else
142             {
143             mlen = dblen - i;
144             if (tlen < mlen)
145                 {
146                 RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, RSA_R_DATA_TOO_LARGE);
147                 mlen = -1;
148                 }
149             else
150                 memcpy(to, db + i, mlen);
151             }
152         }
153     OPENSSL_free(db);
154     return (mlen);
155     }
156
157 int MGF1(unsigned char *mask, long len,
158         const unsigned char *seed, long seedlen)
159     {
160     long i, outlen = 0;
161     unsigned char cnt[4];
162     SHA_CTX c;
163     unsigned char md[SHA_DIGEST_LENGTH];
164
165     for (i = 0; outlen < len; i++)
166         {
167         cnt[0] = (i >> 24) & 255, cnt[1] = (i >> 16) & 255,
168           cnt[2] = (i >> 8) & 255, cnt[3] = i & 255;
169         SHA1_Init(&c);
170         SHA1_Update(&c, seed, seedlen);
171         SHA1_Update(&c, cnt, 4);
172         if (outlen + SHA_DIGEST_LENGTH <= len)
173             {
174             SHA1_Final(mask + outlen, &c);
175             outlen += SHA_DIGEST_LENGTH;
176             }
177         else
178             {
179             SHA1_Final(md, &c);
180             memcpy(mask + outlen, md, len - outlen);
181             outlen = len;
182             }
183         }
184     return (0);
185     }
186 #endif