doc: Fix typo.
[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 "kdf-internal.h"
30
31
32 /* Transform a passphrase into a suitable key of length KEYSIZE and
33    store this key in the caller provided buffer KEYBUFFER.  The caller
34    must provide an HASHALGO, a valid ALGO and depending on that algo a
35    SALT of 8 bytes and the number of ITERATIONS.  Code taken from
36    gnupg/agent/protect.c:hash_passphrase.  */
37 static gpg_err_code_t
38 openpgp_s2k (const void *passphrase, size_t passphraselen,
39              int algo, int hashalgo,
40              const void *salt, size_t saltlen,
41              unsigned long iterations,
42              size_t keysize, void *keybuffer)
43 {
44   gpg_err_code_t ec;
45   gcry_md_hd_t md;
46   char *key = keybuffer;
47   int pass, i;
48   int used = 0;
49   int secmode;
50
51   if ((algo == GCRY_KDF_SALTED_S2K || algo == GCRY_KDF_ITERSALTED_S2K)
52       && (!salt || saltlen != 8))
53     return GPG_ERR_INV_VALUE;
54
55   secmode = _gcry_is_secure (passphrase) || _gcry_is_secure (keybuffer);
56
57   ec = _gcry_md_open (&md, hashalgo, secmode? GCRY_MD_FLAG_SECURE : 0);
58   if (ec)
59     return ec;
60
61   for (pass=0; used < keysize; pass++)
62     {
63       if (pass)
64         {
65           _gcry_md_reset (md);
66           for (i=0; i < pass; i++) /* Preset the hash context.  */
67             _gcry_md_putc (md, 0);
68         }
69
70       if (algo == GCRY_KDF_SALTED_S2K || algo == GCRY_KDF_ITERSALTED_S2K)
71         {
72           int len2 = passphraselen + 8;
73           unsigned long count = len2;
74
75           if (algo == GCRY_KDF_ITERSALTED_S2K)
76             {
77               count = iterations;
78               if (count < len2)
79                 count = len2;
80             }
81
82           while (count > len2)
83             {
84               _gcry_md_write (md, salt, saltlen);
85               _gcry_md_write (md, passphrase, passphraselen);
86               count -= len2;
87             }
88           if (count < saltlen)
89             _gcry_md_write (md, salt, count);
90           else
91             {
92               _gcry_md_write (md, salt, saltlen);
93               count -= saltlen;
94               _gcry_md_write (md, passphrase, count);
95             }
96         }
97       else
98         _gcry_md_write (md, passphrase, passphraselen);
99
100       _gcry_md_final (md);
101       i = _gcry_md_get_algo_dlen (hashalgo);
102       if (i > keysize - used)
103         i = keysize - used;
104       memcpy (key+used, _gcry_md_read (md, hashalgo), i);
105       used += i;
106     }
107   _gcry_md_close (md);
108   return 0;
109 }
110
111
112 /* Transform a passphrase into a suitable key of length KEYSIZE and
113    store this key in the caller provided buffer KEYBUFFER.  The caller
114    must provide PRFALGO which indicates the pseudorandom function to
115    use: This shall be the algorithms id of a hash algorithm; it is
116    used in HMAC mode.  SALT is a salt of length SALTLEN and ITERATIONS
117    gives the number of iterations.  */
118 gpg_err_code_t
119 _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
120                  int hashalgo,
121                  const void *salt, size_t saltlen,
122                  unsigned long iterations,
123                  size_t keysize, void *keybuffer)
124 {
125   gpg_err_code_t ec;
126   gcry_md_hd_t md;
127   int secmode;
128   unsigned int dklen = keysize;
129   char *dk = keybuffer;
130   unsigned int hlen;   /* Output length of the digest function.  */
131   unsigned int l;      /* Rounded up number of blocks.  */
132   unsigned int r;      /* Number of octets in the last block.  */
133   char *sbuf;          /* Malloced buffer to concatenate salt and iter
134                           as well as space to hold TBUF and UBUF.  */
135   char *tbuf;          /* Buffer for T; ptr into SBUF, size is HLEN. */
136   char *ubuf;          /* Buffer for U; ptr into SBUF, size is HLEN. */
137   unsigned int lidx;   /* Current block number.  */
138   unsigned long iter;  /* Current iteration number.  */
139   unsigned int i;
140
141   /* NWe allow for a saltlen of 0 here to support scrypt.  It is not
142      clear whether rfc2898 allows for this this, thus we do a test on
143      saltlen > 0 only in gcry_kdf_derive.  */
144   if (!salt || !iterations || !dklen)
145     return GPG_ERR_INV_VALUE;
146
147   hlen = _gcry_md_get_algo_dlen (hashalgo);
148   if (!hlen)
149     return GPG_ERR_DIGEST_ALGO;
150
151   secmode = _gcry_is_secure (passphrase) || _gcry_is_secure (keybuffer);
152
153   /* We ignore step 1 from pksc5v2.1 which demands a check that dklen
154      is not larger that 0xffffffff * hlen.  */
155
156   /* Step 2 */
157   l = ((dklen - 1)/ hlen) + 1;
158   r = dklen - (l - 1) * hlen;
159
160   /* Setup buffers and prepare a hash context.  */
161   sbuf = (secmode
162           ? xtrymalloc_secure (saltlen + 4 + hlen + hlen)
163           : xtrymalloc (saltlen + 4 + hlen + hlen));
164   if (!sbuf)
165     return gpg_err_code_from_syserror ();
166   tbuf = sbuf + saltlen + 4;
167   ubuf = tbuf + hlen;
168
169   ec = _gcry_md_open (&md, hashalgo, (GCRY_MD_FLAG_HMAC
170                                       | (secmode?GCRY_MD_FLAG_SECURE:0)));
171   if (ec)
172     {
173       xfree (sbuf);
174       return ec;
175     }
176
177   ec = _gcry_md_setkey (md, passphrase, passphraselen);
178   if (ec)
179     {
180       _gcry_md_close (md);
181       xfree (sbuf);
182       return ec;
183     }
184
185   /* Step 3 and 4. */
186   memcpy (sbuf, salt, saltlen);
187   for (lidx = 1; lidx <= l; lidx++)
188     {
189       for (iter = 0; iter < iterations; iter++)
190         {
191           _gcry_md_reset (md);
192           if (!iter) /* Compute U_1:  */
193             {
194               sbuf[saltlen]     = (lidx >> 24);
195               sbuf[saltlen + 1] = (lidx >> 16);
196               sbuf[saltlen + 2] = (lidx >> 8);
197               sbuf[saltlen + 3] = lidx;
198               _gcry_md_write (md, sbuf, saltlen + 4);
199               memcpy (ubuf, _gcry_md_read (md, 0), hlen);
200               memcpy (tbuf, ubuf, hlen);
201             }
202           else /* Compute U_(2..c):  */
203             {
204               _gcry_md_write (md, ubuf, hlen);
205               memcpy (ubuf, _gcry_md_read (md, 0), hlen);
206               for (i=0; i < hlen; i++)
207                 tbuf[i] ^= ubuf[i];
208             }
209         }
210       if (lidx == l)  /* Last block.  */
211         memcpy (dk, tbuf, r);
212       else
213         {
214           memcpy (dk, tbuf, hlen);
215           dk += hlen;
216         }
217     }
218
219   _gcry_md_close (md);
220   xfree (sbuf);
221   return 0;
222 }
223
224
225 /* Derive a key from a passphrase.  KEYSIZE gives the requested size
226    of the keys in octets.  KEYBUFFER is a caller provided buffer
227    filled on success with the derived key.  The input passphrase is
228    taken from (PASSPHRASE,PASSPHRASELEN) which is an arbitrary memory
229    buffer.  ALGO specifies the KDF algorithm to use; these are the
230    constants GCRY_KDF_*.  SUBALGO specifies an algorithm used
231    internally by the KDF algorithms; this is usually a hash algorithm
232    but certain KDF algorithm may use it differently.  {SALT,SALTLEN}
233    is a salt as needed by most KDF algorithms.  ITERATIONS is a
234    positive integer parameter to most KDFs.  0 is returned on success,
235    or an error code on failure.  */
236 gpg_err_code_t
237 _gcry_kdf_derive (const void *passphrase, size_t passphraselen,
238                   int algo, int subalgo,
239                   const void *salt, size_t saltlen,
240                   unsigned long iterations,
241                   size_t keysize, void *keybuffer)
242 {
243   gpg_err_code_t ec;
244
245   if (!passphrase)
246     {
247       ec = GPG_ERR_INV_DATA;
248       goto leave;
249     }
250
251   if (!keybuffer || !keysize)
252     {
253       ec = GPG_ERR_INV_VALUE;
254       goto leave;
255     }
256
257
258   switch (algo)
259     {
260     case GCRY_KDF_SIMPLE_S2K:
261     case GCRY_KDF_SALTED_S2K:
262     case GCRY_KDF_ITERSALTED_S2K:
263       if (!passphraselen)
264         ec = GPG_ERR_INV_DATA;
265       else
266         ec = openpgp_s2k (passphrase, passphraselen, algo, subalgo,
267                           salt, saltlen, iterations, keysize, keybuffer);
268       break;
269
270     case GCRY_KDF_PBKDF1:
271       ec = GPG_ERR_UNSUPPORTED_ALGORITHM;
272       break;
273
274     case GCRY_KDF_PBKDF2:
275       if (!saltlen)
276         ec = GPG_ERR_INV_VALUE;
277       else
278         ec = _gcry_kdf_pkdf2 (passphrase, passphraselen, subalgo,
279                               salt, saltlen, iterations, keysize, keybuffer);
280       break;
281
282     case 41:
283     case GCRY_KDF_SCRYPT:
284 #if USE_SCRYPT
285       ec = _gcry_kdf_scrypt (passphrase, passphraselen, algo, subalgo,
286                              salt, saltlen, iterations, keysize, keybuffer);
287 #else
288       ec = GPG_ERR_UNSUPPORTED_ALGORITHM;
289 #endif /*USE_SCRYPT*/
290       break;
291
292     default:
293       ec = GPG_ERR_UNKNOWN_ALGORITHM;
294       break;
295     }
296
297  leave:
298   return ec;
299 }