Check for overlows and error return from ASN1_object_size()
[openssl.git] / crypto / asn1 / p5_scrypt.c
1 /*
2  * Copyright 2015-2016 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 <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/asn1t.h>
13 #include <openssl/err.h>
14 #include <openssl/evp.h>
15 #include <openssl/x509.h>
16 #include <openssl/rand.h>
17
18 #ifndef OPENSSL_NO_SCRYPT
19 /* PKCS#5 scrypt password based encryption structures */
20
21 typedef struct {
22     ASN1_OCTET_STRING *salt;
23     ASN1_INTEGER *costParameter;
24     ASN1_INTEGER *blockSize;
25     ASN1_INTEGER *parallelizationParameter;
26     ASN1_INTEGER *keyLength;
27 } SCRYPT_PARAMS;
28
29 ASN1_SEQUENCE(SCRYPT_PARAMS) = {
30         ASN1_SIMPLE(SCRYPT_PARAMS, salt, ASN1_OCTET_STRING),
31         ASN1_SIMPLE(SCRYPT_PARAMS, costParameter, ASN1_INTEGER),
32         ASN1_SIMPLE(SCRYPT_PARAMS, blockSize, ASN1_INTEGER),
33         ASN1_SIMPLE(SCRYPT_PARAMS, parallelizationParameter, ASN1_INTEGER),
34         ASN1_OPT(SCRYPT_PARAMS, keyLength, ASN1_INTEGER),
35 } static_ASN1_SEQUENCE_END(SCRYPT_PARAMS)
36
37 DECLARE_ASN1_ALLOC_FUNCTIONS(SCRYPT_PARAMS)
38 IMPLEMENT_ASN1_ALLOC_FUNCTIONS(SCRYPT_PARAMS)
39
40 static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, size_t saltlen,
41                                     size_t keylen, uint64_t N, uint64_t r,
42                                     uint64_t p);
43
44 /*
45  * Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm using scrypt
46  */
47
48 X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
49                                   const unsigned char *salt, int saltlen,
50                                   unsigned char *aiv, uint64_t N, uint64_t r,
51                                   uint64_t p)
52 {
53     X509_ALGOR *scheme = NULL, *kalg = NULL, *ret = NULL;
54     int alg_nid;
55     size_t keylen = 0;
56     EVP_CIPHER_CTX *ctx = NULL;
57     unsigned char iv[EVP_MAX_IV_LENGTH];
58     PBE2PARAM *pbe2 = NULL;
59     ASN1_OBJECT *obj;
60
61     if (!cipher) {
62         ASN1err(ASN1_F_PKCS5_PBE2_SET_SCRYPT, ERR_R_PASSED_NULL_PARAMETER);
63         goto err;
64     }
65
66     if (EVP_PBE_scrypt(NULL, 0, NULL, 0, N, r, p, 0, NULL, 0) == 0) {
67         ASN1err(ASN1_F_PKCS5_PBE2_SET_SCRYPT,
68                 ASN1_R_INVALID_SCRYPT_PARAMETERS);
69         goto err;
70     }
71
72     alg_nid = EVP_CIPHER_type(cipher);
73     if (alg_nid == NID_undef) {
74         ASN1err(ASN1_F_PKCS5_PBE2_SET_SCRYPT,
75                 ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER);
76         goto err;
77     }
78     obj = OBJ_nid2obj(alg_nid);
79     pbe2 = PBE2PARAM_new();
80     if (pbe2 == NULL)
81         goto merr;
82
83     /* Setup the AlgorithmIdentifier for the encryption scheme */
84     scheme = pbe2->encryption;
85
86     scheme->algorithm = obj;
87     scheme->parameter = ASN1_TYPE_new();
88     if (scheme->parameter == NULL)
89         goto merr;
90
91     /* Create random IV */
92     if (EVP_CIPHER_iv_length(cipher)) {
93         if (aiv)
94             memcpy(iv, aiv, EVP_CIPHER_iv_length(cipher));
95         else if (RAND_bytes(iv, EVP_CIPHER_iv_length(cipher)) < 0)
96             goto err;
97     }
98
99     ctx = EVP_CIPHER_CTX_new();
100     if (ctx == NULL)
101         goto merr;
102
103     /* Dummy cipherinit to just setup the IV */
104     if (EVP_CipherInit_ex(ctx, cipher, NULL, NULL, iv, 0) == 0)
105         goto err;
106     if (EVP_CIPHER_param_to_asn1(ctx, scheme->parameter) < 0) {
107         ASN1err(ASN1_F_PKCS5_PBE2_SET_SCRYPT,
108                 ASN1_R_ERROR_SETTING_CIPHER_PARAMS);
109         goto err;
110     }
111     EVP_CIPHER_CTX_free(ctx);
112     ctx = NULL;
113
114     /* If its RC2 then we'd better setup the key length */
115
116     if (alg_nid == NID_rc2_cbc)
117         keylen = EVP_CIPHER_key_length(cipher);
118
119     /* Setup keyfunc */
120
121     X509_ALGOR_free(pbe2->keyfunc);
122
123     pbe2->keyfunc = pkcs5_scrypt_set(salt, saltlen, keylen, N, r, p);
124
125     if (pbe2->keyfunc == NULL)
126         goto merr;
127
128     /* Now set up top level AlgorithmIdentifier */
129
130     ret = X509_ALGOR_new();
131     if (ret == NULL)
132         goto merr;
133
134     ret->algorithm = OBJ_nid2obj(NID_pbes2);
135
136     /* Encode PBE2PARAM into parameter */
137
138     if (ASN1_TYPE_pack_sequence(ASN1_ITEM_rptr(PBE2PARAM), pbe2,
139                                 &ret->parameter) == NULL)
140         goto merr;
141
142     PBE2PARAM_free(pbe2);
143     pbe2 = NULL;
144
145     return ret;
146
147  merr:
148     ASN1err(ASN1_F_PKCS5_PBE2_SET_SCRYPT, ERR_R_MALLOC_FAILURE);
149
150  err:
151     PBE2PARAM_free(pbe2);
152     X509_ALGOR_free(kalg);
153     X509_ALGOR_free(ret);
154     EVP_CIPHER_CTX_free(ctx);
155
156     return NULL;
157
158 }
159
160 static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, size_t saltlen,
161                                     size_t keylen, uint64_t N, uint64_t r,
162                                     uint64_t p)
163 {
164     X509_ALGOR *keyfunc = NULL;
165     SCRYPT_PARAMS *sparam = NULL;
166
167     sparam = SCRYPT_PARAMS_new();
168     if (sparam == NULL)
169         goto merr;
170
171     if (!saltlen)
172         saltlen = PKCS5_SALT_LEN;
173
174     /* This will either copy salt or grow the buffer */
175     if (ASN1_STRING_set(sparam->salt, salt, saltlen) == 0)
176         goto merr;
177
178     if (salt == NULL && RAND_bytes(sparam->salt->data, saltlen) <= 0)
179         goto err;
180
181     if (ASN1_INTEGER_set_uint64(sparam->costParameter, N) == 0)
182         goto merr;
183
184     if (ASN1_INTEGER_set_uint64(sparam->blockSize, r) == 0)
185         goto merr;
186
187     if (ASN1_INTEGER_set_uint64(sparam->parallelizationParameter, p) == 0)
188         goto merr;
189
190     /* If have a key len set it up */
191
192     if (keylen > 0) {
193         sparam->keyLength = ASN1_INTEGER_new();
194         if (sparam->keyLength == NULL)
195             goto merr;
196         if (ASN1_INTEGER_set_int64(sparam->keyLength, keylen) == 0)
197             goto merr;
198     }
199
200     /* Finally setup the keyfunc structure */
201
202     keyfunc = X509_ALGOR_new();
203     if (keyfunc == NULL)
204         goto merr;
205
206     keyfunc->algorithm = OBJ_nid2obj(NID_id_scrypt);
207
208     /* Encode SCRYPT_PARAMS into parameter of pbe2 */
209
210     if (ASN1_TYPE_pack_sequence(ASN1_ITEM_rptr(SCRYPT_PARAMS), sparam,
211                                 &keyfunc->parameter) == NULL)
212         goto merr;
213
214     SCRYPT_PARAMS_free(sparam);
215     return keyfunc;
216
217  merr:
218     ASN1err(ASN1_F_PKCS5_SCRYPT_SET, ERR_R_MALLOC_FAILURE);
219  err:
220     SCRYPT_PARAMS_free(sparam);
221     X509_ALGOR_free(keyfunc);
222     return NULL;
223 }
224
225 int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
226                              int passlen, ASN1_TYPE *param,
227                              const EVP_CIPHER *c, const EVP_MD *md, int en_de)
228 {
229     unsigned char *salt, key[EVP_MAX_KEY_LENGTH];
230     uint64_t p, r, N;
231     size_t saltlen;
232     size_t keylen = 0;
233     int rv = 0;
234     SCRYPT_PARAMS *sparam = NULL;
235
236     if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
237         EVPerr(EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN, EVP_R_NO_CIPHER_SET);
238         goto err;
239     }
240
241     /* Decode parameter */
242
243     sparam = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(SCRYPT_PARAMS), param);
244
245     if (sparam == NULL) {
246         EVPerr(EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN, EVP_R_DECODE_ERROR);
247         goto err;
248     }
249
250     keylen = EVP_CIPHER_CTX_key_length(ctx);
251
252     /* Now check the parameters of sparam */
253
254     if (sparam->keyLength) {
255         uint64_t spkeylen;
256         if ((ASN1_INTEGER_get_uint64(&spkeylen, sparam->keyLength) == 0)
257             || (spkeylen != keylen)) {
258             EVPerr(EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN,
259                    EVP_R_UNSUPPORTED_KEYLENGTH);
260             goto err;
261         }
262     }
263     /* Check all parameters fit in uint64_t and are acceptable to scrypt */
264     if (ASN1_INTEGER_get_uint64(&N, sparam->costParameter) == 0
265         || ASN1_INTEGER_get_uint64(&r, sparam->blockSize) == 0
266         || ASN1_INTEGER_get_uint64(&p, sparam->parallelizationParameter) == 0
267         || EVP_PBE_scrypt(NULL, 0, NULL, 0, N, r, p, 0, NULL, 0) == 0) {
268         EVPerr(EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN,
269                EVP_R_ILLEGAL_SCRYPT_PARAMETERS);
270         goto err;
271     }
272
273     /* it seems that its all OK */
274
275     salt = sparam->salt->data;
276     saltlen = sparam->salt->length;
277     if (EVP_PBE_scrypt(pass, passlen, salt, saltlen, N, r, p, 0, key, keylen)
278         == 0)
279         goto err;
280     rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de);
281  err:
282     if (keylen)
283         OPENSSL_cleanse(key, keylen);
284     SCRYPT_PARAMS_free(sparam);
285     return rv;
286 }
287 #endif /* OPENSSL_NO_SCRYPT */