Add test case for SCRYPT and rework the code.
[libgcrypt.git] / cipher / kdf.c
1 /* kdf.c  - Key Derivation Functions
2  * Copyright (C) 1998, 2011 Free Software Foundation, Inc.
3  * Copyright (C) 2013 g10 Code GmbH
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "g10lib.h"
28 #include "cipher.h"
29 #include "ath.h"
30 #include "kdf-internal.h"
31
32
33 /* Transform a passphrase into a suitable key of length KEYSIZE and
34    store this key in the caller provided buffer KEYBUFFER.  The caller
35    must provide an HASHALGO, a valid ALGO and depending on that algo a
36    SALT of 8 bytes and the number of ITERATIONS.  Code taken from
37    gnupg/agent/protect.c:hash_passphrase.  */
38 static gpg_err_code_t
39 openpgp_s2k (const void *passphrase, size_t passphraselen,
40              int algo, int hashalgo,
41              const void *salt, size_t saltlen,
42              unsigned long iterations,
43              size_t keysize, void *keybuffer)
44 {
45   gpg_err_code_t ec;
46   gcry_md_hd_t md;
47   char *key = keybuffer;
48   int pass, i;
49   int used = 0;
50   int secmode;
51
52   if ((algo == GCRY_KDF_SALTED_S2K || algo == GCRY_KDF_ITERSALTED_S2K)
53       && (!salt || saltlen != 8))
54     return GPG_ERR_INV_VALUE;
55
56   secmode = gcry_is_secure (passphrase) || gcry_is_secure (keybuffer);
57
58   ec = gpg_err_code (gcry_md_open (&md, hashalgo,
59                                    secmode? GCRY_MD_FLAG_SECURE : 0));
60   if (ec)
61     return ec;
62
63   for (pass=0; used < keysize; pass++)
64     {
65       if (pass)
66         {
67           gcry_md_reset (md);
68           for (i=0; i < pass; i++) /* Preset the hash context.  */
69             gcry_md_putc (md, 0);
70         }
71
72       if (algo == GCRY_KDF_SALTED_S2K || algo == GCRY_KDF_ITERSALTED_S2K)
73         {
74           int len2 = passphraselen + 8;
75           unsigned long count = len2;
76
77           if (algo == GCRY_KDF_ITERSALTED_S2K)
78             {
79               count = iterations;
80               if (count < len2)
81                 count = len2;
82             }
83
84           while (count > len2)
85             {
86               gcry_md_write (md, salt, saltlen);
87               gcry_md_write (md, passphrase, passphraselen);
88               count -= len2;
89             }
90           if (count < saltlen)
91             gcry_md_write (md, salt, count);
92           else
93             {
94               gcry_md_write (md, salt, saltlen);
95               count -= saltlen;
96               gcry_md_write (md, passphrase, count);
97             }
98         }
99       else
100         gcry_md_write (md, passphrase, passphraselen);
101
102       gcry_md_final (md);
103       i = gcry_md_get_algo_dlen (hashalgo);
104       if (i > keysize - used)
105         i = keysize - used;
106       memcpy (key+used, gcry_md_read (md, hashalgo), i);
107       used += i;
108     }
109   gcry_md_close (md);
110   return 0;
111 }
112
113
114 /* Transform a passphrase into a suitable key of length KEYSIZE and
115    store this key in the caller provided buffer KEYBUFFER.  The caller
116    must provide PRFALGO which indicates the pseudorandom function to
117    use: This shall be the algorithms id of a hash algorithm; it is
118    used in HMAC mode.  SALT is a salt of length SALTLEN and ITERATIONS
119    gives the number of iterations.  */
120 gpg_err_code_t
121 _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
122                  int hashalgo,
123                  const void *salt, size_t saltlen,
124                  unsigned long iterations,
125                  size_t keysize, void *keybuffer)
126 {
127   gpg_err_code_t ec;
128   gcry_md_hd_t md;
129   int secmode;
130   unsigned int dklen = keysize;
131   char *dk = keybuffer;
132   unsigned int hlen;   /* Output length of the digest function.  */
133   unsigned int l;      /* Rounded up number of blocks.  */
134   unsigned int r;      /* Number of octets in the last block.  */
135   char *sbuf;          /* Malloced buffer to concatenate salt and iter
136                           as well as space to hold TBUF and UBUF.  */
137   char *tbuf;          /* Buffer for T; ptr into SBUF, size is HLEN. */
138   char *ubuf;          /* Buffer for U; ptr into SBUF, size is HLEN. */
139   unsigned int lidx;   /* Current block number.  */
140   unsigned long iter;  /* Current iteration number.  */
141   unsigned int i;
142
143   /* NWe allow for a saltlen of 0 here to support scrypt.  It is not
144      clear whether rfc2898 allows for this this, thus we do a test on
145      saltlen > 0 only in gcry_kdf_derive.  */
146   if (!salt || !iterations || !dklen)
147     return GPG_ERR_INV_VALUE;
148
149   hlen = gcry_md_get_algo_dlen (hashalgo);
150   if (!hlen)
151     return GPG_ERR_DIGEST_ALGO;
152
153   secmode = gcry_is_secure (passphrase) || gcry_is_secure (keybuffer);
154
155   /* We ignore step 1 from pksc5v2.1 which demands a check that dklen
156      is not larger that 0xffffffff * hlen.  */
157
158   /* Step 2 */
159   l = ((dklen - 1)/ hlen) + 1;
160   r = dklen - (l - 1) * hlen;
161
162   /* Setup buffers and prepare a hash context.  */
163   sbuf = (secmode
164           ? gcry_malloc_secure (saltlen + 4 + hlen + hlen)
165           : gcry_malloc (saltlen + 4 + hlen + hlen));
166   if (!sbuf)
167     return gpg_err_code_from_syserror ();
168   tbuf = sbuf + saltlen + 4;
169   ubuf = tbuf + hlen;
170
171   ec = gpg_err_code (gcry_md_open (&md, hashalgo,
172                                    (GCRY_MD_FLAG_HMAC
173                                     | (secmode?GCRY_MD_FLAG_SECURE:0))));
174   if (ec)
175     {
176       gcry_free (sbuf);
177       return ec;
178     }
179
180   /* Step 3 and 4. */
181   memcpy (sbuf, salt, saltlen);
182   for (lidx = 1; lidx <= l; lidx++)
183     {
184       for (iter = 0; iter < iterations; iter++)
185         {
186           ec = gpg_err_code (gcry_md_setkey (md, passphrase, passphraselen));
187           if (ec)
188             {
189               gcry_md_close (md);
190               gcry_free (sbuf);
191               return ec;
192             }
193           if (!iter) /* Compute U_1:  */
194             {
195               sbuf[saltlen]     = (lidx >> 24);
196               sbuf[saltlen + 1] = (lidx >> 16);
197               sbuf[saltlen + 2] = (lidx >> 8);
198               sbuf[saltlen + 3] = lidx;
199               gcry_md_write (md, sbuf, saltlen + 4);
200               memcpy (ubuf, gcry_md_read (md, 0), hlen);
201               memcpy (tbuf, ubuf, hlen);
202             }
203           else /* Compute U_(2..c):  */
204             {
205               gcry_md_write (md, ubuf, hlen);
206               memcpy (ubuf, gcry_md_read (md, 0), hlen);
207               for (i=0; i < hlen; i++)
208                 tbuf[i] ^= ubuf[i];
209             }
210         }
211       if (lidx == l)  /* Last block.  */
212         memcpy (dk, tbuf, r);
213       else
214         {
215           memcpy (dk, tbuf, hlen);
216           dk += hlen;
217         }
218     }
219
220   gcry_md_close (md);
221   gcry_free (sbuf);
222   return 0;
223 }
224
225
226 /* Derive a key from a passphrase.  KEYSIZE gives the requested size
227    of the keys in octets.  KEYBUFFER is a caller provided buffer
228    filled on success with the derived key.  The input passphrase is
229    taken from (PASSPHRASE,PASSPHRASELEN) which is an arbitrary memory
230    buffer.  ALGO specifies the KDF algorithm to use; these are the
231    constants GCRY_KDF_*.  SUBALGO specifies an algorithm used
232    internally by the KDF algorithms; this is usually a hash algorithm
233    but certain KDF algorithm may use it differently.  {SALT,SALTLEN}
234    is a salt as needed by most KDF algorithms.  ITERATIONS is a
235    positive integer parameter to most KDFs.  0 is returned on success,
236    or an error code on failure.  */
237 gpg_error_t
238 gcry_kdf_derive (const void *passphrase, size_t passphraselen,
239                  int algo, int subalgo,
240                  const void *salt, size_t saltlen,
241                  unsigned long iterations,
242                  size_t keysize, void *keybuffer)
243 {
244   gpg_err_code_t ec;
245
246   if (!passphrase)
247     {
248       ec = GPG_ERR_INV_DATA;
249       goto leave;
250     }
251
252   if (!keybuffer || !keysize)
253     {
254       ec = GPG_ERR_INV_VALUE;
255       goto leave;
256     }
257
258
259   switch (algo)
260     {
261     case GCRY_KDF_SIMPLE_S2K:
262     case GCRY_KDF_SALTED_S2K:
263     case GCRY_KDF_ITERSALTED_S2K:
264       if (!passphraselen)
265         ec = GPG_ERR_INV_DATA;
266       else
267         ec = openpgp_s2k (passphrase, passphraselen, algo, subalgo,
268                           salt, saltlen, iterations, keysize, keybuffer);
269       break;
270
271     case GCRY_KDF_PBKDF1:
272       ec = GPG_ERR_UNSUPPORTED_ALGORITHM;
273       break;
274
275     case GCRY_KDF_PBKDF2:
276       if (!saltlen)
277         ec = GPG_ERR_INV_VALUE;
278       else
279         ec = _gcry_kdf_pkdf2 (passphrase, passphraselen, subalgo,
280                               salt, saltlen, iterations, keysize, keybuffer);
281       break;
282
283     case 41:
284     case GCRY_KDF_SCRYPT:
285 #if USE_SCRYPT
286       ec = _gcry_kdf_scrypt (passphrase, passphraselen, algo, subalgo,
287                              salt, saltlen, iterations, keysize, keybuffer);
288 #else
289       ec = GPG_ERR_UNSUPPORTED_ALGORITHM;
290 #endif /*USE_SCRYPT*/
291       break;
292
293     default:
294       ec = GPG_ERR_UNKNOWN_ALGORITHM;
295       break;
296     }
297
298  leave:
299   return gpg_error (ec);
300 }