a893142fdb316eef9b39e71871043ac83ab3a33f
[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 = NULL, seed[SHA_DIGEST_LENGTH], phash[SHA_DIGEST_LENGTH];
98
99     if (--num < 2 * SHA_DIGEST_LENGTH + 1)
100         goto decoding_err;
101
102     lzero = num - flen;
103     if (lzero < 0)
104         goto decoding_err;
105     maskeddb = from - lzero + SHA_DIGEST_LENGTH;
106     
107     dblen = num - SHA_DIGEST_LENGTH;
108     db = OPENSSL_malloc(dblen);
109     if (db == NULL)
110         {
111         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
112         return (-1);
113         }
114
115     MGF1(seed, SHA_DIGEST_LENGTH, maskeddb, dblen);
116     for (i = lzero; i < SHA_DIGEST_LENGTH; i++)
117         seed[i] ^= from[i - lzero];
118   
119     MGF1(db, dblen, seed, SHA_DIGEST_LENGTH);
120     for (i = 0; i < dblen; i++)
121         db[i] ^= maskeddb[i];
122
123     SHA1(param, plen, phash);
124
125     if (memcmp(db, phash, SHA_DIGEST_LENGTH) != 0)
126         goto decoding_err;
127     else
128         {
129         for (i = SHA_DIGEST_LENGTH; i < dblen; i++)
130             if (db[i] != 0x00)
131                 break;
132         if (db[i] != 0x01 || i++ >= dblen)
133             RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP,
134                    RSA_R_OAEP_DECODING_ERROR);
135         else
136             {
137             mlen = dblen - i;
138             if (tlen < mlen)
139                 {
140                 RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, RSA_R_DATA_TOO_LARGE);
141                 mlen = -1;
142                 }
143             else
144                 memcpy(to, db + i, mlen);
145             }
146         }
147     OPENSSL_free(db);
148     return (mlen);
149
150 decoding_err:
151     /* to avoid chosen ciphertext attacks, the error message should not reveal
152      * which kind of decoding error happened */
153     RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, RSA_R_OAEP_DECODING_ERROR);
154     if (db != NULL) OPENSSL_free(db);
155     return -1;
156     }
157
158 int MGF1(unsigned char *mask, long len,
159         const unsigned char *seed, long seedlen)
160     {
161     long i, outlen = 0;
162     unsigned char cnt[4];
163     SHA_CTX c;
164     unsigned char md[SHA_DIGEST_LENGTH];
165
166     for (i = 0; outlen < len; i++)
167         {
168         cnt[0] = (i >> 24) & 255, cnt[1] = (i >> 16) & 255,
169           cnt[2] = (i >> 8) & 255, cnt[3] = i & 255;
170         SHA1_Init(&c);
171         SHA1_Update(&c, seed, seedlen);
172         SHA1_Update(&c, cnt, 4);
173         if (outlen + SHA_DIGEST_LENGTH <= len)
174             {
175             SHA1_Final(mask + outlen, &c);
176             outlen += SHA_DIGEST_LENGTH;
177             }
178         else
179             {
180             SHA1_Final(md, &c);
181             memcpy(mask + outlen, md, len - outlen);
182             outlen = len;
183             }
184         }
185     return (0);
186     }
187 #endif