check reviewer --reviewer=emilia
[openssl.git] / crypto / rsa / rsa_pss.c
1 /*
2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
3  * 2005.
4  */
5 /* ====================================================================
6  * Copyright (c) 2005 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #include <stdio.h>
60 #include "internal/cryptlib.h"
61 #include <openssl/bn.h>
62 #include <openssl/rsa.h>
63 #include <openssl/evp.h>
64 #include <openssl/rand.h>
65 #include <openssl/sha.h>
66 #include "rsa_locl.h"
67
68 static const unsigned char zeroes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
69
70 #if defined(_MSC_VER) && defined(_ARM_)
71 # pragma optimize("g", off)
72 #endif
73
74 int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
75                          const EVP_MD *Hash, const unsigned char *EM,
76                          int sLen)
77 {
78     return RSA_verify_PKCS1_PSS_mgf1(rsa, mHash, Hash, NULL, EM, sLen);
79 }
80
81 int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
82                               const EVP_MD *Hash, const EVP_MD *mgf1Hash,
83                               const unsigned char *EM, int sLen)
84 {
85     int i;
86     int ret = 0;
87     int hLen, maskedDBLen, MSBits, emLen;
88     const unsigned char *H;
89     unsigned char *DB = NULL;
90     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
91     unsigned char H_[EVP_MAX_MD_SIZE];
92
93
94     if (ctx == NULL)
95         goto err;
96
97     if (mgf1Hash == NULL)
98         mgf1Hash = Hash;
99
100     hLen = EVP_MD_size(Hash);
101     if (hLen < 0)
102         goto err;
103     /*-
104      * Negative sLen has special meanings:
105      *      -1      sLen == hLen
106      *      -2      salt length is autorecovered from signature
107      *      -N      reserved
108      */
109     if (sLen == -1)
110         sLen = hLen;
111     else if (sLen == -2)
112         sLen = -2;
113     else if (sLen < -2) {
114         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_SLEN_CHECK_FAILED);
115         goto err;
116     }
117
118     MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
119     emLen = RSA_size(rsa);
120     if (EM[0] & (0xFF << MSBits)) {
121         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_FIRST_OCTET_INVALID);
122         goto err;
123     }
124     if (MSBits == 0) {
125         EM++;
126         emLen--;
127     }
128     if (emLen < (hLen + sLen + 2)) { /* sLen can be small negative */
129         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_DATA_TOO_LARGE);
130         goto err;
131     }
132     if (EM[emLen - 1] != 0xbc) {
133         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_LAST_OCTET_INVALID);
134         goto err;
135     }
136     maskedDBLen = emLen - hLen - 1;
137     H = EM + maskedDBLen;
138     DB = OPENSSL_malloc(maskedDBLen);
139     if (DB == NULL) {
140         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, ERR_R_MALLOC_FAILURE);
141         goto err;
142     }
143     if (PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash) < 0)
144         goto err;
145     for (i = 0; i < maskedDBLen; i++)
146         DB[i] ^= EM[i];
147     if (MSBits)
148         DB[0] &= 0xFF >> (8 - MSBits);
149     for (i = 0; DB[i] == 0 && i < (maskedDBLen - 1); i++) ;
150     if (DB[i++] != 0x1) {
151         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_SLEN_RECOVERY_FAILED);
152         goto err;
153     }
154     if (sLen >= 0 && (maskedDBLen - i) != sLen) {
155         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_SLEN_CHECK_FAILED);
156         goto err;
157     }
158     if (!EVP_DigestInit_ex(ctx, Hash, NULL)
159         || !EVP_DigestUpdate(ctx, zeroes, sizeof zeroes)
160         || !EVP_DigestUpdate(ctx, mHash, hLen))
161         goto err;
162     if (maskedDBLen - i) {
163         if (!EVP_DigestUpdate(ctx, DB + i, maskedDBLen - i))
164             goto err;
165     }
166     if (!EVP_DigestFinal_ex(ctx, H_, NULL))
167         goto err;
168     if (memcmp(H_, H, hLen)) {
169         RSAerr(RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1, RSA_R_BAD_SIGNATURE);
170         ret = 0;
171     } else
172         ret = 1;
173
174  err:
175     OPENSSL_free(DB);
176     EVP_MD_CTX_free(ctx);
177
178     return ret;
179
180 }
181
182 int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
183                               const unsigned char *mHash,
184                               const EVP_MD *Hash, int sLen)
185 {
186     return RSA_padding_add_PKCS1_PSS_mgf1(rsa, EM, mHash, Hash, NULL, sLen);
187 }
188
189 int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
190                                    const unsigned char *mHash,
191                                    const EVP_MD *Hash, const EVP_MD *mgf1Hash,
192                                    int sLen)
193 {
194     int i;
195     int ret = 0;
196     int hLen, maskedDBLen, MSBits, emLen;
197     unsigned char *H, *salt = NULL, *p;
198     EVP_MD_CTX *ctx = NULL;
199
200     if (mgf1Hash == NULL)
201         mgf1Hash = Hash;
202
203     hLen = EVP_MD_size(Hash);
204     if (hLen < 0)
205         goto err;
206     /*-
207      * Negative sLen has special meanings:
208      *      -1      sLen == hLen
209      *      -2      salt length is maximized
210      *      -N      reserved
211      */
212     if (sLen == -1)
213         sLen = hLen;
214     else if (sLen == -2)
215         sLen = -2;
216     else if (sLen < -2) {
217         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1, RSA_R_SLEN_CHECK_FAILED);
218         goto err;
219     }
220
221     MSBits = (BN_num_bits(rsa->n) - 1) & 0x7;
222     emLen = RSA_size(rsa);
223     if (MSBits == 0) {
224         *EM++ = 0;
225         emLen--;
226     }
227     if (sLen == -2) {
228         sLen = emLen - hLen - 2;
229     } else if (emLen < (hLen + sLen + 2)) {
230         RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1,
231                RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
232         goto err;
233     }
234     if (sLen > 0) {
235         salt = OPENSSL_malloc(sLen);
236         if (salt == NULL) {
237             RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1,
238                    ERR_R_MALLOC_FAILURE);
239             goto err;
240         }
241         if (RAND_bytes(salt, sLen) <= 0)
242             goto err;
243     }
244     maskedDBLen = emLen - hLen - 1;
245     H = EM + maskedDBLen;
246     ctx = EVP_MD_CTX_new();
247     if (ctx == NULL)
248         goto err;
249     if (!EVP_DigestInit_ex(ctx, Hash, NULL)
250         || !EVP_DigestUpdate(ctx, zeroes, sizeof zeroes)
251         || !EVP_DigestUpdate(ctx, mHash, hLen))
252         goto err;
253     if (sLen && !EVP_DigestUpdate(ctx, salt, sLen))
254         goto err;
255     if (!EVP_DigestFinal_ex(ctx, H, NULL))
256         goto err;
257
258     /* Generate dbMask in place then perform XOR on it */
259     if (PKCS1_MGF1(EM, maskedDBLen, H, hLen, mgf1Hash))
260         goto err;
261
262     p = EM;
263
264     /*
265      * Initial PS XORs with all zeroes which is a NOP so just update pointer.
266      * Note from a test above this value is guaranteed to be non-negative.
267      */
268     p += emLen - sLen - hLen - 2;
269     *p++ ^= 0x1;
270     if (sLen > 0) {
271         for (i = 0; i < sLen; i++)
272             *p++ ^= salt[i];
273     }
274     if (MSBits)
275         EM[0] &= 0xFF >> (8 - MSBits);
276
277     /* H is already in place so just set final 0xbc */
278
279     EM[emLen - 1] = 0xbc;
280
281     ret = 1;
282
283  err:
284     EVP_MD_CTX_free(ctx);
285     OPENSSL_free(salt);
286
287     return ret;
288
289 }
290
291 #if defined(_MSC_VER)
292 # pragma optimize("",on)
293 #endif