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