xref: /openbsd/lib/libcrypto/asn1/p5_pbev2.c (revision 78b63d65)
1 /* p5_pbev2.c */
2 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
3  * project 1999.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58 
59 #include <stdio.h>
60 #include "cryptlib.h"
61 #include <openssl/asn1_mac.h>
62 #include <openssl/x509.h>
63 #include <openssl/rand.h>
64 
65 /* PKCS#5 v2.0 password based encryption structures */
66 
67 int i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **pp)
68 {
69 	M_ASN1_I2D_vars(a);
70 	M_ASN1_I2D_len (a->keyfunc, i2d_X509_ALGOR);
71 	M_ASN1_I2D_len (a->encryption, i2d_X509_ALGOR);
72 
73 	M_ASN1_I2D_seq_total ();
74 
75 	M_ASN1_I2D_put (a->keyfunc, i2d_X509_ALGOR);
76 	M_ASN1_I2D_put (a->encryption, i2d_X509_ALGOR);
77 
78 	M_ASN1_I2D_finish();
79 }
80 
81 PBE2PARAM *PBE2PARAM_new(void)
82 {
83 	PBE2PARAM *ret=NULL;
84 	ASN1_CTX c;
85 	M_ASN1_New_Malloc(ret, PBE2PARAM);
86 	M_ASN1_New(ret->keyfunc,X509_ALGOR_new);
87 	M_ASN1_New(ret->encryption,X509_ALGOR_new);
88 	return (ret);
89 	M_ASN1_New_Error(ASN1_F_PBE2PARAM_NEW);
90 }
91 
92 PBE2PARAM *d2i_PBE2PARAM(PBE2PARAM **a, unsigned char **pp, long length)
93 {
94 	M_ASN1_D2I_vars(a,PBE2PARAM *,PBE2PARAM_new);
95 	M_ASN1_D2I_Init();
96 	M_ASN1_D2I_start_sequence();
97 	M_ASN1_D2I_get (ret->keyfunc, d2i_X509_ALGOR);
98 	M_ASN1_D2I_get (ret->encryption, d2i_X509_ALGOR);
99 	M_ASN1_D2I_Finish(a, PBE2PARAM_free, ASN1_F_D2I_PBE2PARAM);
100 }
101 
102 void PBE2PARAM_free (PBE2PARAM *a)
103 {
104 	if(a==NULL) return;
105 	X509_ALGOR_free(a->keyfunc);
106 	X509_ALGOR_free(a->encryption);
107 	OPENSSL_free (a);
108 }
109 
110 int i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **pp)
111 {
112 	M_ASN1_I2D_vars(a);
113 	M_ASN1_I2D_len (a->salt, i2d_ASN1_TYPE);
114 	M_ASN1_I2D_len (a->iter, i2d_ASN1_INTEGER);
115 	M_ASN1_I2D_len (a->keylength, i2d_ASN1_INTEGER);
116 	M_ASN1_I2D_len (a->prf, i2d_X509_ALGOR);
117 
118 	M_ASN1_I2D_seq_total ();
119 
120 	M_ASN1_I2D_put (a->salt, i2d_ASN1_TYPE);
121 	M_ASN1_I2D_put (a->iter, i2d_ASN1_INTEGER);
122 	M_ASN1_I2D_put (a->keylength, i2d_ASN1_INTEGER);
123 	M_ASN1_I2D_put (a->prf, i2d_X509_ALGOR);
124 
125 	M_ASN1_I2D_finish();
126 }
127 
128 PBKDF2PARAM *PBKDF2PARAM_new(void)
129 {
130 	PBKDF2PARAM *ret=NULL;
131 	ASN1_CTX c;
132 	M_ASN1_New_Malloc(ret, PBKDF2PARAM);
133 	M_ASN1_New(ret->salt, ASN1_TYPE_new);
134 	M_ASN1_New(ret->iter, M_ASN1_INTEGER_new);
135 	ret->keylength = NULL;
136 	ret->prf = NULL;
137 	return (ret);
138 	M_ASN1_New_Error(ASN1_F_PBKDF2PARAM_NEW);
139 }
140 
141 PBKDF2PARAM *d2i_PBKDF2PARAM(PBKDF2PARAM **a, unsigned char **pp,
142 	     long length)
143 {
144 	M_ASN1_D2I_vars(a,PBKDF2PARAM *,PBKDF2PARAM_new);
145 	M_ASN1_D2I_Init();
146 	M_ASN1_D2I_start_sequence();
147 	M_ASN1_D2I_get (ret->salt, d2i_ASN1_TYPE);
148 	M_ASN1_D2I_get (ret->iter, d2i_ASN1_INTEGER);
149 	M_ASN1_D2I_get_opt (ret->keylength, d2i_ASN1_INTEGER, V_ASN1_INTEGER);
150 	M_ASN1_D2I_get_opt (ret->prf, d2i_X509_ALGOR, V_ASN1_SEQUENCE);
151 	M_ASN1_D2I_Finish(a, PBKDF2PARAM_free, ASN1_F_D2I_PBKDF2PARAM);
152 }
153 
154 void PBKDF2PARAM_free (PBKDF2PARAM *a)
155 {
156 	if(a==NULL) return;
157 	ASN1_TYPE_free(a->salt);
158 	M_ASN1_INTEGER_free(a->iter);
159 	M_ASN1_INTEGER_free(a->keylength);
160 	X509_ALGOR_free(a->prf);
161 	OPENSSL_free (a);
162 }
163 
164 /* Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm:
165  * yes I know this is horrible!
166  */
167 
168 X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
169 				 unsigned char *salt, int saltlen)
170 {
171 	X509_ALGOR *scheme = NULL, *kalg = NULL, *ret = NULL;
172 	int alg_nid;
173 	EVP_CIPHER_CTX ctx;
174 	unsigned char iv[EVP_MAX_IV_LENGTH];
175 	PBKDF2PARAM *kdf = NULL;
176 	PBE2PARAM *pbe2 = NULL;
177 	ASN1_OCTET_STRING *osalt = NULL;
178 	ASN1_OBJECT *obj;
179 
180 	alg_nid = EVP_CIPHER_type(cipher);
181 	if(alg_nid == NID_undef) {
182 		ASN1err(ASN1_F_PKCS5_PBE2_SET,
183 				ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER);
184 		goto err;
185 	}
186 	obj = OBJ_nid2obj(alg_nid);
187 
188 	if(!(pbe2 = PBE2PARAM_new())) goto merr;
189 
190 	/* Setup the AlgorithmIdentifier for the encryption scheme */
191 	scheme = pbe2->encryption;
192 
193 	scheme->algorithm = obj;
194 	if(!(scheme->parameter = ASN1_TYPE_new())) goto merr;
195 
196 	/* Create random IV */
197 	if (RAND_pseudo_bytes(iv, EVP_CIPHER_iv_length(cipher)) < 0)
198 		goto err;
199 
200 	/* Dummy cipherinit to just setup the IV */
201 	EVP_CipherInit(&ctx, cipher, NULL, iv, 0);
202 	if(EVP_CIPHER_param_to_asn1(&ctx, scheme->parameter) < 0) {
203 		ASN1err(ASN1_F_PKCS5_PBE2_SET,
204 					ASN1_R_ERROR_SETTING_CIPHER_PARAMS);
205 		goto err;
206 	}
207 	EVP_CIPHER_CTX_cleanup(&ctx);
208 
209 	if(!(kdf = PBKDF2PARAM_new())) goto merr;
210 	if(!(osalt = M_ASN1_OCTET_STRING_new())) goto merr;
211 
212 	if (!saltlen) saltlen = PKCS5_SALT_LEN;
213 	if (!(osalt->data = OPENSSL_malloc (saltlen))) goto merr;
214 	osalt->length = saltlen;
215 	if (salt) memcpy (osalt->data, salt, saltlen);
216 	else if (RAND_pseudo_bytes (osalt->data, saltlen) < 0) goto merr;
217 
218 	if(iter <= 0) iter = PKCS5_DEFAULT_ITER;
219 	if(!ASN1_INTEGER_set(kdf->iter, iter)) goto merr;
220 
221 	/* Now include salt in kdf structure */
222 	kdf->salt->value.octet_string = osalt;
223 	kdf->salt->type = V_ASN1_OCTET_STRING;
224 	osalt = NULL;
225 
226 	/* If its RC2 then we'd better setup the key length */
227 
228 	if(alg_nid == NID_rc2_cbc) {
229 		if(!(kdf->keylength = M_ASN1_INTEGER_new())) goto merr;
230 		if(!ASN1_INTEGER_set (kdf->keylength,
231 				 EVP_CIPHER_key_length(cipher))) goto merr;
232 	}
233 
234 	/* prf can stay NULL because we are using hmacWithSHA1 */
235 
236 	/* Now setup the PBE2PARAM keyfunc structure */
237 
238 	pbe2->keyfunc->algorithm = OBJ_nid2obj(NID_id_pbkdf2);
239 
240 	/* Encode PBKDF2PARAM into parameter of pbe2 */
241 
242 	if(!(pbe2->keyfunc->parameter = ASN1_TYPE_new())) goto merr;
243 
244 	if(!ASN1_pack_string(kdf, i2d_PBKDF2PARAM,
245 			 &pbe2->keyfunc->parameter->value.sequence)) goto merr;
246 	pbe2->keyfunc->parameter->type = V_ASN1_SEQUENCE;
247 
248 	PBKDF2PARAM_free(kdf);
249 	kdf = NULL;
250 
251 	/* Now set up top level AlgorithmIdentifier */
252 
253 	if(!(ret = X509_ALGOR_new())) goto merr;
254 	if(!(ret->parameter = ASN1_TYPE_new())) goto merr;
255 
256 	ret->algorithm = OBJ_nid2obj(NID_pbes2);
257 
258 	/* Encode PBE2PARAM into parameter */
259 
260 	if(!ASN1_pack_string(pbe2, i2d_PBE2PARAM,
261 				 &ret->parameter->value.sequence)) goto merr;
262 	ret->parameter->type = V_ASN1_SEQUENCE;
263 
264 	PBE2PARAM_free(pbe2);
265 	pbe2 = NULL;
266 
267 	return ret;
268 
269 	merr:
270 	ASN1err(ASN1_F_PKCS5_PBE2_SET,ERR_R_MALLOC_FAILURE);
271 
272 	err:
273 	PBE2PARAM_free(pbe2);
274 	/* Note 'scheme' is freed as part of pbe2 */
275 	M_ASN1_OCTET_STRING_free(osalt);
276 	PBKDF2PARAM_free(kdf);
277 	X509_ALGOR_free(kalg);
278 	X509_ALGOR_free(ret);
279 
280 	return NULL;
281 
282 }
283