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