Fix building without scrypt
[openssl.git] / crypto / kdf / scrypt.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdlib.h>
11 #include <string.h>
12 #include <openssl/hmac.h>
13 #include <openssl/kdf.h>
14 #include <openssl/evp.h>
15 #include "internal/cryptlib.h"
16 #include "internal/evp_int.h"
17
18 #ifndef OPENSSL_NO_SCRYPT
19
20 static int atou64(const char *nptr, uint64_t *result);
21
22 typedef struct {
23     unsigned char *pass;
24     size_t pass_len;
25     unsigned char *salt;
26     size_t salt_len;
27     uint64_t N, r, p;
28     uint64_t maxmem_bytes;
29 } SCRYPT_PKEY_CTX;
30
31 /* Custom uint64_t parser since we do not have strtoull */
32 static int atou64(const char *nptr, uint64_t *result)
33 {
34     uint64_t value = 0;
35
36     while (*nptr) {
37         unsigned int digit;
38         uint64_t new_value;
39
40         if ((*nptr < '0') || (*nptr > '9')) {
41             return 0;
42         }
43         digit = (unsigned int)(*nptr - '0');
44         new_value = (value * 10) + digit;
45         if ((new_value < digit) || ((new_value - digit) / 10 != value)) {
46             /* Overflow */
47             return 0;
48         }
49         value = new_value;
50         nptr++;
51     }
52     *result = value;
53     return 1;
54 }
55
56 static int pkey_scrypt_init(EVP_PKEY_CTX *ctx)
57 {
58     SCRYPT_PKEY_CTX *kctx;
59
60     kctx = OPENSSL_zalloc(sizeof(*kctx));
61     if (kctx == NULL)
62         return 0;
63
64     /* Default values are the most conservative recommendation given in the
65      * original paper of C. Percival. Derivation uses roughly 1 GiB of memory
66      * for this parameter choice (approx. 128 * r * (N + p) bytes).
67      */
68     kctx->N = 1 << 20;
69     kctx->r = 8;
70     kctx->p = 1;
71     kctx->maxmem_bytes = 1025 * 1024 * 1024;
72
73     ctx->data = kctx;
74
75     return 1;
76 }
77
78 static void pkey_scrypt_cleanup(EVP_PKEY_CTX *ctx)
79 {
80     SCRYPT_PKEY_CTX *kctx = ctx->data;
81
82     OPENSSL_clear_free(kctx->salt, kctx->salt_len);
83     OPENSSL_clear_free(kctx->pass, kctx->pass_len);
84     OPENSSL_free(kctx);
85 }
86
87 static int pkey_scrypt_set_membuf(unsigned char **buffer, size_t *buflen,
88                                   const unsigned char *new_buffer,
89                                   const int new_buflen)
90 {
91     if (new_buffer == NULL)
92         return 1;
93
94     if (new_buflen < 0)
95         return 0;
96
97     if (*buffer != NULL)
98         OPENSSL_clear_free(*buffer, *buflen);
99
100     if (new_buflen > 0) {
101         *buffer = OPENSSL_memdup(new_buffer, new_buflen);
102     } else {
103         *buffer = OPENSSL_malloc(1);
104     }
105     if (*buffer == NULL)
106         return 0;
107
108     *buflen = new_buflen;
109     return 1;
110 }
111
112 static int is_power_of_two(uint64_t value)
113 {
114     return (value != 0) && ((value & (value - 1)) == 0);
115 }
116
117 static int pkey_scrypt_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
118 {
119     SCRYPT_PKEY_CTX *kctx = ctx->data;
120     uint64_t u64_value;
121
122     switch (type) {
123     case EVP_PKEY_CTRL_PASS:
124         return pkey_scrypt_set_membuf(&kctx->pass, &kctx->pass_len, p2, p1);
125
126     case EVP_PKEY_CTRL_SCRYPT_SALT:
127         return pkey_scrypt_set_membuf(&kctx->salt, &kctx->salt_len, p2, p1);
128
129     case EVP_PKEY_CTRL_SCRYPT_N:
130         u64_value = *((uint64_t *)p2);
131         if ((u64_value <= 1) || !is_power_of_two(u64_value))
132             return 0;
133         kctx->N = u64_value;
134         return 1;
135
136     case EVP_PKEY_CTRL_SCRYPT_R:
137         u64_value = *((uint64_t *)p2);
138         if (u64_value < 1)
139             return 0;
140         kctx->r = u64_value;
141         return 1;
142
143     case EVP_PKEY_CTRL_SCRYPT_P:
144         u64_value = *((uint64_t *)p2);
145         if (u64_value < 1)
146             return 0;
147         kctx->p = u64_value;
148         return 1;
149
150     case EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES:
151         u64_value = *((uint64_t *)p2);
152         if (u64_value < 1)
153             return 0;
154         kctx->maxmem_bytes = u64_value;
155         return 1;
156
157     default:
158         return -2;
159
160     }
161 }
162
163 static int pkey_scrypt_ctrl_uint64(EVP_PKEY_CTX *ctx, int type,
164                                    const char *value)
165 {
166     uint64_t int_value;
167
168     if (!atou64(value, &int_value)) {
169         KDFerr(KDF_F_PKEY_SCRYPT_CTRL_UINT64, KDF_R_VALUE_ERROR);
170         return 0;
171     }
172     return pkey_scrypt_ctrl(ctx, type, 0, &int_value);
173 }
174
175 static int pkey_scrypt_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
176                                 const char *value)
177 {
178     if (value == NULL) {
179         KDFerr(KDF_F_PKEY_SCRYPT_CTRL_STR, KDF_R_VALUE_MISSING);
180         return 0;
181     }
182
183     if (strcmp(type, "pass") == 0)
184         return EVP_PKEY_CTX_str2ctrl(ctx, EVP_PKEY_CTRL_PASS, value);
185
186     if (strcmp(type, "hexpass") == 0)
187         return EVP_PKEY_CTX_hex2ctrl(ctx, EVP_PKEY_CTRL_PASS, value);
188
189     if (strcmp(type, "salt") == 0)
190         return EVP_PKEY_CTX_str2ctrl(ctx, EVP_PKEY_CTRL_SCRYPT_SALT, value);
191
192     if (strcmp(type, "hexsalt") == 0)
193         return EVP_PKEY_CTX_hex2ctrl(ctx, EVP_PKEY_CTRL_SCRYPT_SALT, value);
194
195     if (strcmp(type, "N") == 0)
196         return pkey_scrypt_ctrl_uint64(ctx, EVP_PKEY_CTRL_SCRYPT_N, value);
197
198     if (strcmp(type, "r") == 0)
199         return pkey_scrypt_ctrl_uint64(ctx, EVP_PKEY_CTRL_SCRYPT_R, value);
200
201     if (strcmp(type, "p") == 0)
202         return pkey_scrypt_ctrl_uint64(ctx, EVP_PKEY_CTRL_SCRYPT_P, value);
203
204     if (strcmp(type, "maxmem_bytes") == 0)
205         return pkey_scrypt_ctrl_uint64(ctx, EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES,
206                                        value);
207
208     KDFerr(KDF_F_PKEY_SCRYPT_CTRL_STR, KDF_R_UNKNOWN_PARAMETER_TYPE);
209     return -2;
210 }
211
212 static int pkey_scrypt_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
213                               size_t *keylen)
214 {
215     SCRYPT_PKEY_CTX *kctx = ctx->data;
216
217     if (kctx->pass == NULL) {
218         KDFerr(KDF_F_PKEY_SCRYPT_DERIVE, KDF_R_MISSING_PASS);
219         return 0;
220     }
221
222     if (kctx->salt == NULL) {
223         KDFerr(KDF_F_PKEY_SCRYPT_DERIVE, KDF_R_MISSING_SALT);
224         return 0;
225     }
226
227     return EVP_PBE_scrypt((char *)kctx->pass, kctx->pass_len, kctx->salt,
228                           kctx->salt_len, kctx->N, kctx->r, kctx->p,
229                           kctx->maxmem_bytes, key, *keylen);
230 }
231
232 const EVP_PKEY_METHOD scrypt_pkey_meth = {
233     EVP_PKEY_SCRYPT,
234     0,
235     pkey_scrypt_init,
236     0,
237     pkey_scrypt_cleanup,
238
239     0, 0,
240     0, 0,
241
242     0,
243     0,
244
245     0,
246     0,
247
248     0, 0,
249
250     0, 0, 0, 0,
251
252     0, 0,
253
254     0, 0,
255
256     0,
257     pkey_scrypt_derive,
258     pkey_scrypt_ctrl,
259     pkey_scrypt_ctrl_str
260 };
261
262 #endif