cf26085c1a20d6a3c404a3e6db92357547b22053
[openssl.git] / crypto / evp / p5_crpt2.c
1 /* p5_crpt2.c */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project 1999.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999-2006 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 #include <stdio.h>
59 #include <stdlib.h>
60 #include "cryptlib.h"
61 #if !defined(OPENSSL_NO_HMAC) && !defined(OPENSSL_NO_SHA)
62 #include <openssl/x509.h>
63 #include <openssl/evp.h>
64 #include <openssl/hmac.h>
65 #include "evp_locl.h"
66
67 /* set this to print out info about the keygen algorithm */
68 /* #define DEBUG_PKCS5V2 */
69
70 #ifdef DEBUG_PKCS5V2
71         static void h__dump (const unsigned char *p, int len);
72 #endif
73
74 /* This is an implementation of PKCS#5 v2.0 password based encryption key
75  * derivation function PBKDF2.
76  * SHA1 version verified against test vectors posted by Peter Gutmann
77  * <pgut001@cs.auckland.ac.nz> to the PKCS-TNG <pkcs-tng@rsa.com> mailing list.
78  */
79
80 int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
81                            const unsigned char *salt, int saltlen, int iter,
82                            const EVP_MD *digest,
83                            int keylen, unsigned char *out)
84         {
85         unsigned char digtmp[EVP_MAX_MD_SIZE], *p, itmp[4];
86         int cplen, j, k, tkeylen, mdlen;
87         unsigned long i = 1;
88         HMAC_CTX hctx_tpl, hctx;
89
90         mdlen = EVP_MD_size(digest);
91         if (mdlen < 0)
92                 return 0;
93
94         HMAC_CTX_init(&hctx_tpl);
95         p = out;
96         tkeylen = keylen;
97         if(!pass)
98                 passlen = 0;
99         else if(passlen == -1)
100                 passlen = strlen(pass);
101         if (!HMAC_Init_ex(&hctx_tpl, pass, passlen, digest, NULL))
102                 {
103                 HMAC_CTX_cleanup(&hctx_tpl);
104                 return 0;
105                 }
106         while(tkeylen)
107                 {
108                 if(tkeylen > mdlen)
109                         cplen = mdlen;
110                 else
111                         cplen = tkeylen;
112                 /* We are unlikely to ever use more than 256 blocks (5120 bits!)
113                  * but just in case...
114                  */
115                 itmp[0] = (unsigned char)((i >> 24) & 0xff);
116                 itmp[1] = (unsigned char)((i >> 16) & 0xff);
117                 itmp[2] = (unsigned char)((i >> 8) & 0xff);
118                 itmp[3] = (unsigned char)(i & 0xff);
119                 if (!HMAC_CTX_copy(&hctx, &hctx_tpl))
120                         {
121                         HMAC_CTX_cleanup(&hctx_tpl);
122                         return 0;
123                         }
124                 if (!HMAC_Update(&hctx, salt, saltlen)
125                     || !HMAC_Update(&hctx, itmp, 4)
126                     || !HMAC_Final(&hctx, digtmp, NULL))
127                         {
128                         HMAC_CTX_cleanup(&hctx_tpl);
129                         HMAC_CTX_cleanup(&hctx);
130                         return 0;
131                         }
132                 memcpy(p, digtmp, cplen);
133                 for(j = 1; j < iter; j++)
134                         {
135                         if (!HMAC_CTX_copy(&hctx, &hctx_tpl))
136                                 {
137                                 HMAC_CTX_cleanup(&hctx_tpl);
138                                 return 0;
139                                 }
140                         if (!HMAC_Update(&hctx, digtmp, mdlen)
141                             || !HMAC_Final(&hctx, digtmp, NULL))
142                                 {
143                                 HMAC_CTX_cleanup(&hctx_tpl);
144                                 HMAC_CTX_cleanup(&hctx);
145                                 return 0;
146                                 }
147                         HMAC_CTX_cleanup(&hctx);
148                         for(k = 0; k < cplen; k++)
149                                 p[k] ^= digtmp[k];
150                         }
151                 tkeylen-= cplen;
152                 i++;
153                 p+= cplen;
154                 }
155         HMAC_CTX_cleanup(&hctx_tpl);
156 #ifdef DEBUG_PKCS5V2
157         fprintf(stderr, "Password:\n");
158         h__dump (pass, passlen);
159         fprintf(stderr, "Salt:\n");
160         h__dump (salt, saltlen);
161         fprintf(stderr, "Iteration count %d\n", iter);
162         fprintf(stderr, "Key:\n");
163         h__dump (out, keylen);
164 #endif
165         return 1;
166         }
167
168 int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
169                            const unsigned char *salt, int saltlen, int iter,
170                            int keylen, unsigned char *out)
171         {
172         return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, EVP_sha1(),
173                                         keylen, out);
174         }
175
176 #ifdef DO_TEST
177 main()
178 {
179         unsigned char out[4];
180         unsigned char salt[] = {0x12, 0x34, 0x56, 0x78};
181         PKCS5_PBKDF2_HMAC_SHA1("password", -1, salt, 4, 5, 4, out);
182         fprintf(stderr, "Out %02X %02X %02X %02X\n",
183                                          out[0], out[1], out[2], out[3]);
184 }
185
186 #endif
187
188 /* Now the key derivation function itself. This is a bit evil because
189  * it has to check the ASN1 parameters are valid: and there are quite a
190  * few of them...
191  */
192
193 int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
194                          ASN1_TYPE *param, const EVP_CIPHER *c, const EVP_MD *md,
195                          int en_de)
196 {
197         const unsigned char *pbuf;
198         int plen;
199         PBE2PARAM *pbe2 = NULL;
200         const EVP_CIPHER *cipher;
201
202         int rv = 0;
203
204         if (param == NULL || param->type != V_ASN1_SEQUENCE ||
205             param->value.sequence == NULL) {
206                 EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,EVP_R_DECODE_ERROR);
207                 goto err;
208         }
209
210         pbuf = param->value.sequence->data;
211         plen = param->value.sequence->length;
212         if(!(pbe2 = d2i_PBE2PARAM(NULL, &pbuf, plen))) {
213                 EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,EVP_R_DECODE_ERROR);
214                 goto err;
215         }
216
217         /* See if we recognise the key derivation function */
218
219         if(OBJ_obj2nid(pbe2->keyfunc->algorithm) != NID_id_pbkdf2) {
220                 EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
221                                 EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
222                 goto err;
223         }
224
225         /* lets see if we recognise the encryption algorithm.
226          */
227
228         cipher = EVP_get_cipherbyobj(pbe2->encryption->algorithm);
229
230         if(!cipher) {
231                 EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
232                                                 EVP_R_UNSUPPORTED_CIPHER);
233                 goto err;
234         }
235
236         /* Fixup cipher based on AlgorithmIdentifier */
237         if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, en_de))
238                 goto err;
239         if(EVP_CIPHER_asn1_to_param(ctx, pbe2->encryption->parameter) < 0) {
240                 EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
241                                         EVP_R_CIPHER_PARAMETER_ERROR);
242                 goto err;
243         }
244         rv = PKCS5_v2_PBKDF2_keyivgen(ctx, pass, passlen,
245                                         pbe2->keyfunc->parameter, c, md, en_de);
246         err:
247         PBE2PARAM_free(pbe2);
248         return rv;
249 }
250
251 int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
252                          ASN1_TYPE *param,
253                          const EVP_CIPHER *c, const EVP_MD *md, int en_de)
254 {
255         unsigned char *salt, key[EVP_MAX_KEY_LENGTH];
256         const unsigned char *pbuf;
257         int saltlen, iter, plen;
258         int rv = 0;
259         unsigned int keylen = 0;
260         int prf_nid, hmac_md_nid;
261         PBKDF2PARAM *kdf = NULL;
262         const EVP_MD *prfmd;
263
264         if (EVP_CIPHER_CTX_cipher(ctx) == NULL)
265                 {
266                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,EVP_R_NO_CIPHER_SET);
267                 goto err;
268                 }
269         keylen = EVP_CIPHER_CTX_key_length(ctx);
270         OPENSSL_assert(keylen <= sizeof key);
271
272         /* Decode parameter */
273
274         if(!param || (param->type != V_ASN1_SEQUENCE))
275                 {
276                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,EVP_R_DECODE_ERROR);
277                 goto err;
278                 }
279
280         pbuf = param->value.sequence->data;
281         plen = param->value.sequence->length;
282
283         if(!(kdf = d2i_PBKDF2PARAM(NULL, &pbuf, plen)) ) {
284                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,EVP_R_DECODE_ERROR);
285                 goto err;
286         }
287
288         keylen = EVP_CIPHER_CTX_key_length(ctx);
289
290         /* Now check the parameters of the kdf */
291
292         if(kdf->keylength && (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)){
293                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,
294                                                 EVP_R_UNSUPPORTED_KEYLENGTH);
295                 goto err;
296         }
297
298         if (kdf->prf)
299                 prf_nid = OBJ_obj2nid(kdf->prf->algorithm);
300         else
301                 prf_nid = NID_hmacWithSHA1;
302
303         if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0))
304                 {
305                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
306                 goto err;
307                 }
308
309         prfmd = EVP_get_digestbynid(hmac_md_nid);
310         if (prfmd == NULL)
311                 {
312                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
313                 goto err;
314                 }
315
316         if(kdf->salt->type != V_ASN1_OCTET_STRING) {
317                 EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN,
318                                                 EVP_R_UNSUPPORTED_SALT_TYPE);
319                 goto err;
320         }
321
322         /* it seems that its all OK */
323         salt = kdf->salt->value.octet_string->data;
324         saltlen = kdf->salt->value.octet_string->length;
325         iter = ASN1_INTEGER_get(kdf->iter);
326         if(!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,
327                                                    keylen, key))
328                 goto err;
329         rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de);
330         err:
331         OPENSSL_cleanse(key, keylen);
332         PBKDF2PARAM_free(kdf);
333         return rv;
334 }
335
336 #ifdef DEBUG_PKCS5V2
337 static void h__dump (const unsigned char *p, int len)
338 {
339         for (; len --; p++) fprintf(stderr, "%02X ", *p);
340         fprintf(stderr, "\n");
341 }
342 #endif
343 #endif