1 /*
2  * TLSv1 credentials
3  * Copyright (c) 2006-2009, Jouni Malinen <j@w1.fi>
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8 
9 #include "includes.h"
10 
11 #include "common.h"
12 #include "base64.h"
13 #include "crypto/crypto.h"
14 #include "x509v3.h"
15 #include "tlsv1_cred.h"
16 
17 
18 struct tlsv1_credentials * tlsv1_cred_alloc(void)
19 {
20 	struct tlsv1_credentials *cred;
21 	cred = os_zalloc(sizeof(*cred));
22 	return cred;
23 }
24 
25 
26 void tlsv1_cred_free(struct tlsv1_credentials *cred)
27 {
28 	if (cred == NULL)
29 		return;
30 
31 	x509_certificate_chain_free(cred->trusted_certs);
32 	x509_certificate_chain_free(cred->cert);
33 	crypto_private_key_free(cred->key);
34 	os_free(cred->dh_p);
35 	os_free(cred->dh_g);
36 	os_free(cred);
37 }
38 
39 
40 static int tlsv1_add_cert_der(struct x509_certificate **chain,
41 			      const u8 *buf, size_t len)
42 {
43 	struct x509_certificate *cert, *p;
44 	char name[128];
45 
46 	cert = x509_certificate_parse(buf, len);
47 	if (cert == NULL) {
48 		wpa_printf(MSG_INFO, "TLSv1: %s - failed to parse certificate",
49 			   __func__);
50 		return -1;
51 	}
52 
53 	p = *chain;
54 	while (p && p->next)
55 		p = p->next;
56 	if (p && x509_name_compare(&cert->subject, &p->issuer) == 0) {
57 		/*
58 		 * The new certificate is the issuer of the last certificate in
59 		 * the chain - add the new certificate to the end.
60 		 */
61 		p->next = cert;
62 	} else {
63 		/* Add to the beginning of the chain */
64 		cert->next = *chain;
65 		*chain = cert;
66 	}
67 
68 	x509_name_string(&cert->subject, name, sizeof(name));
69 	wpa_printf(MSG_DEBUG, "TLSv1: Added certificate: %s", name);
70 
71 	return 0;
72 }
73 
74 
75 static const char *pem_cert_begin = "-----BEGIN CERTIFICATE-----";
76 static const char *pem_cert_end = "-----END CERTIFICATE-----";
77 static const char *pem_key_begin = "-----BEGIN RSA PRIVATE KEY-----";
78 static const char *pem_key_end = "-----END RSA PRIVATE KEY-----";
79 static const char *pem_key2_begin = "-----BEGIN PRIVATE KEY-----";
80 static const char *pem_key2_end = "-----END PRIVATE KEY-----";
81 static const char *pem_key_enc_begin = "-----BEGIN ENCRYPTED PRIVATE KEY-----";
82 static const char *pem_key_enc_end = "-----END ENCRYPTED PRIVATE KEY-----";
83 
84 
85 static const u8 * search_tag(const char *tag, const u8 *buf, size_t len)
86 {
87 	size_t i, plen;
88 
89 	plen = os_strlen(tag);
90 	if (len < plen)
91 		return NULL;
92 
93 	for (i = 0; i < len - plen; i++) {
94 		if (os_memcmp(buf + i, tag, plen) == 0)
95 			return buf + i;
96 	}
97 
98 	return NULL;
99 }
100 
101 
102 static int tlsv1_add_cert(struct x509_certificate **chain,
103 			  const u8 *buf, size_t len)
104 {
105 	const u8 *pos, *end;
106 	unsigned char *der;
107 	size_t der_len;
108 
109 	pos = search_tag(pem_cert_begin, buf, len);
110 	if (!pos) {
111 		wpa_printf(MSG_DEBUG, "TLSv1: No PEM certificate tag found - "
112 			   "assume DER format");
113 		return tlsv1_add_cert_der(chain, buf, len);
114 	}
115 
116 	wpa_printf(MSG_DEBUG, "TLSv1: Converting PEM format certificate into "
117 		   "DER format");
118 
119 	while (pos) {
120 		pos += os_strlen(pem_cert_begin);
121 		end = search_tag(pem_cert_end, pos, buf + len - pos);
122 		if (end == NULL) {
123 			wpa_printf(MSG_INFO, "TLSv1: Could not find PEM "
124 				   "certificate end tag (%s)", pem_cert_end);
125 			return -1;
126 		}
127 
128 		der = base64_decode(pos, end - pos, &der_len);
129 		if (der == NULL) {
130 			wpa_printf(MSG_INFO, "TLSv1: Could not decode PEM "
131 				   "certificate");
132 			return -1;
133 		}
134 
135 		if (tlsv1_add_cert_der(chain, der, der_len) < 0) {
136 			wpa_printf(MSG_INFO, "TLSv1: Failed to parse PEM "
137 				   "certificate after DER conversion");
138 			os_free(der);
139 			return -1;
140 		}
141 
142 		os_free(der);
143 
144 		end += os_strlen(pem_cert_end);
145 		pos = search_tag(pem_cert_begin, end, buf + len - end);
146 	}
147 
148 	return 0;
149 }
150 
151 
152 static int tlsv1_set_cert_chain(struct x509_certificate **chain,
153 				const char *cert, const u8 *cert_blob,
154 				size_t cert_blob_len)
155 {
156 	if (cert_blob)
157 		return tlsv1_add_cert(chain, cert_blob, cert_blob_len);
158 
159 	if (cert) {
160 		u8 *buf;
161 		size_t len;
162 		int ret;
163 
164 		buf = (u8 *) os_readfile(cert, &len);
165 		if (buf == NULL) {
166 			wpa_printf(MSG_INFO, "TLSv1: Failed to read '%s'",
167 				   cert);
168 			return -1;
169 		}
170 
171 		ret = tlsv1_add_cert(chain, buf, len);
172 		os_free(buf);
173 		return ret;
174 	}
175 
176 	return 0;
177 }
178 
179 
180 /**
181  * tlsv1_set_ca_cert - Set trusted CA certificate(s)
182  * @cred: TLSv1 credentials from tlsv1_cred_alloc()
183  * @cert: File or reference name for X.509 certificate in PEM or DER format
184  * @cert_blob: cert as inlined data or %NULL if not used
185  * @cert_blob_len: ca_cert_blob length
186  * @path: Path to CA certificates (not yet supported)
187  * Returns: 0 on success, -1 on failure
188  */
189 int tlsv1_set_ca_cert(struct tlsv1_credentials *cred, const char *cert,
190 		      const u8 *cert_blob, size_t cert_blob_len,
191 		      const char *path)
192 {
193 	if (tlsv1_set_cert_chain(&cred->trusted_certs, cert,
194 				 cert_blob, cert_blob_len) < 0)
195 		return -1;
196 
197 	if (path) {
198 		/* TODO: add support for reading number of certificate files */
199 		wpa_printf(MSG_INFO, "TLSv1: Use of CA certificate directory "
200 			   "not yet supported");
201 		return -1;
202 	}
203 
204 	return 0;
205 }
206 
207 
208 /**
209  * tlsv1_set_cert - Set certificate
210  * @cred: TLSv1 credentials from tlsv1_cred_alloc()
211  * @cert: File or reference name for X.509 certificate in PEM or DER format
212  * @cert_blob: cert as inlined data or %NULL if not used
213  * @cert_blob_len: cert_blob length
214  * Returns: 0 on success, -1 on failure
215  */
216 int tlsv1_set_cert(struct tlsv1_credentials *cred, const char *cert,
217 		   const u8 *cert_blob, size_t cert_blob_len)
218 {
219 	return tlsv1_set_cert_chain(&cred->cert, cert,
220 				    cert_blob, cert_blob_len);
221 }
222 
223 
224 static struct crypto_private_key * tlsv1_set_key_pem(const u8 *key, size_t len)
225 {
226 	const u8 *pos, *end;
227 	unsigned char *der;
228 	size_t der_len;
229 	struct crypto_private_key *pkey;
230 
231 	pos = search_tag(pem_key_begin, key, len);
232 	if (!pos) {
233 		pos = search_tag(pem_key2_begin, key, len);
234 		if (!pos)
235 			return NULL;
236 		pos += os_strlen(pem_key2_begin);
237 		end = search_tag(pem_key2_end, pos, key + len - pos);
238 		if (!end)
239 			return NULL;
240 	} else {
241 		const u8 *pos2;
242 		pos += os_strlen(pem_key_begin);
243 		end = search_tag(pem_key_end, pos, key + len - pos);
244 		if (!end)
245 			return NULL;
246 		pos2 = search_tag("Proc-Type: 4,ENCRYPTED", pos, end - pos);
247 		if (pos2) {
248 			wpa_printf(MSG_DEBUG, "TLSv1: Unsupported private key "
249 				   "format (Proc-Type/DEK-Info)");
250 			return NULL;
251 		}
252 	}
253 
254 	der = base64_decode(pos, end - pos, &der_len);
255 	if (!der)
256 		return NULL;
257 	pkey = crypto_private_key_import(der, der_len, NULL);
258 	os_free(der);
259 	return pkey;
260 }
261 
262 
263 static struct crypto_private_key * tlsv1_set_key_enc_pem(const u8 *key,
264 							 size_t len,
265 							 const char *passwd)
266 {
267 	const u8 *pos, *end;
268 	unsigned char *der;
269 	size_t der_len;
270 	struct crypto_private_key *pkey;
271 
272 	if (passwd == NULL)
273 		return NULL;
274 	pos = search_tag(pem_key_enc_begin, key, len);
275 	if (!pos)
276 		return NULL;
277 	pos += os_strlen(pem_key_enc_begin);
278 	end = search_tag(pem_key_enc_end, pos, key + len - pos);
279 	if (!end)
280 		return NULL;
281 
282 	der = base64_decode(pos, end - pos, &der_len);
283 	if (!der)
284 		return NULL;
285 	pkey = crypto_private_key_import(der, der_len, passwd);
286 	os_free(der);
287 	return pkey;
288 }
289 
290 
291 static int tlsv1_set_key(struct tlsv1_credentials *cred,
292 			 const u8 *key, size_t len, const char *passwd)
293 {
294 	cred->key = crypto_private_key_import(key, len, passwd);
295 	if (cred->key == NULL)
296 		cred->key = tlsv1_set_key_pem(key, len);
297 	if (cred->key == NULL)
298 		cred->key = tlsv1_set_key_enc_pem(key, len, passwd);
299 	if (cred->key == NULL) {
300 		wpa_printf(MSG_INFO, "TLSv1: Failed to parse private key");
301 		return -1;
302 	}
303 	return 0;
304 }
305 
306 
307 /**
308  * tlsv1_set_private_key - Set private key
309  * @cred: TLSv1 credentials from tlsv1_cred_alloc()
310  * @private_key: File or reference name for the key in PEM or DER format
311  * @private_key_passwd: Passphrase for decrypted private key, %NULL if no
312  * passphrase is used.
313  * @private_key_blob: private_key as inlined data or %NULL if not used
314  * @private_key_blob_len: private_key_blob length
315  * Returns: 0 on success, -1 on failure
316  */
317 int tlsv1_set_private_key(struct tlsv1_credentials *cred,
318 			  const char *private_key,
319 			  const char *private_key_passwd,
320 			  const u8 *private_key_blob,
321 			  size_t private_key_blob_len)
322 {
323 	crypto_private_key_free(cred->key);
324 	cred->key = NULL;
325 
326 	if (private_key_blob)
327 		return tlsv1_set_key(cred, private_key_blob,
328 				     private_key_blob_len,
329 				     private_key_passwd);
330 
331 	if (private_key) {
332 		u8 *buf;
333 		size_t len;
334 		int ret;
335 
336 		buf = (u8 *) os_readfile(private_key, &len);
337 		if (buf == NULL) {
338 			wpa_printf(MSG_INFO, "TLSv1: Failed to read '%s'",
339 				   private_key);
340 			return -1;
341 		}
342 
343 		ret = tlsv1_set_key(cred, buf, len, private_key_passwd);
344 		os_free(buf);
345 		return ret;
346 	}
347 
348 	return 0;
349 }
350 
351 
352 static int tlsv1_set_dhparams_der(struct tlsv1_credentials *cred,
353 				  const u8 *dh, size_t len)
354 {
355 	struct asn1_hdr hdr;
356 	const u8 *pos, *end;
357 
358 	pos = dh;
359 	end = dh + len;
360 
361 	/*
362 	 * DHParameter ::= SEQUENCE {
363 	 *   prime INTEGER, -- p
364 	 *   base INTEGER, -- g
365 	 *   privateValueLength INTEGER OPTIONAL }
366 	 */
367 
368 	/* DHParamer ::= SEQUENCE */
369 	if (asn1_get_next(pos, len, &hdr) < 0 ||
370 	    hdr.class != ASN1_CLASS_UNIVERSAL ||
371 	    hdr.tag != ASN1_TAG_SEQUENCE) {
372 		wpa_printf(MSG_DEBUG, "DH: DH parameters did not start with a "
373 			   "valid SEQUENCE - found class %d tag 0x%x",
374 			   hdr.class, hdr.tag);
375 		return -1;
376 	}
377 	pos = hdr.payload;
378 
379 	/* prime INTEGER */
380 	if (asn1_get_next(pos, end - pos, &hdr) < 0)
381 		return -1;
382 
383 	if (hdr.class != ASN1_CLASS_UNIVERSAL ||
384 	    hdr.tag != ASN1_TAG_INTEGER) {
385 		wpa_printf(MSG_DEBUG, "DH: No INTEGER tag found for p; "
386 			   "class=%d tag=0x%x", hdr.class, hdr.tag);
387 		return -1;
388 	}
389 
390 	wpa_hexdump(MSG_MSGDUMP, "DH: prime (p)", hdr.payload, hdr.length);
391 	if (hdr.length == 0)
392 		return -1;
393 	os_free(cred->dh_p);
394 	cred->dh_p = os_malloc(hdr.length);
395 	if (cred->dh_p == NULL)
396 		return -1;
397 	os_memcpy(cred->dh_p, hdr.payload, hdr.length);
398 	cred->dh_p_len = hdr.length;
399 	pos = hdr.payload + hdr.length;
400 
401 	/* base INTEGER */
402 	if (asn1_get_next(pos, end - pos, &hdr) < 0)
403 		return -1;
404 
405 	if (hdr.class != ASN1_CLASS_UNIVERSAL ||
406 	    hdr.tag != ASN1_TAG_INTEGER) {
407 		wpa_printf(MSG_DEBUG, "DH: No INTEGER tag found for g; "
408 			   "class=%d tag=0x%x", hdr.class, hdr.tag);
409 		return -1;
410 	}
411 
412 	wpa_hexdump(MSG_MSGDUMP, "DH: base (g)", hdr.payload, hdr.length);
413 	if (hdr.length == 0)
414 		return -1;
415 	os_free(cred->dh_g);
416 	cred->dh_g = os_malloc(hdr.length);
417 	if (cred->dh_g == NULL)
418 		return -1;
419 	os_memcpy(cred->dh_g, hdr.payload, hdr.length);
420 	cred->dh_g_len = hdr.length;
421 
422 	return 0;
423 }
424 
425 
426 static const char *pem_dhparams_begin = "-----BEGIN DH PARAMETERS-----";
427 static const char *pem_dhparams_end = "-----END DH PARAMETERS-----";
428 
429 
430 static int tlsv1_set_dhparams_blob(struct tlsv1_credentials *cred,
431 				   const u8 *buf, size_t len)
432 {
433 	const u8 *pos, *end;
434 	unsigned char *der;
435 	size_t der_len;
436 
437 	pos = search_tag(pem_dhparams_begin, buf, len);
438 	if (!pos) {
439 		wpa_printf(MSG_DEBUG, "TLSv1: No PEM dhparams tag found - "
440 			   "assume DER format");
441 		return tlsv1_set_dhparams_der(cred, buf, len);
442 	}
443 
444 	wpa_printf(MSG_DEBUG, "TLSv1: Converting PEM format dhparams into DER "
445 		   "format");
446 
447 	pos += os_strlen(pem_dhparams_begin);
448 	end = search_tag(pem_dhparams_end, pos, buf + len - pos);
449 	if (end == NULL) {
450 		wpa_printf(MSG_INFO, "TLSv1: Could not find PEM dhparams end "
451 			   "tag (%s)", pem_dhparams_end);
452 		return -1;
453 	}
454 
455 	der = base64_decode(pos, end - pos, &der_len);
456 	if (der == NULL) {
457 		wpa_printf(MSG_INFO, "TLSv1: Could not decode PEM dhparams");
458 		return -1;
459 	}
460 
461 	if (tlsv1_set_dhparams_der(cred, der, der_len) < 0) {
462 		wpa_printf(MSG_INFO, "TLSv1: Failed to parse PEM dhparams "
463 			   "DER conversion");
464 		os_free(der);
465 		return -1;
466 	}
467 
468 	os_free(der);
469 
470 	return 0;
471 }
472 
473 
474 /**
475  * tlsv1_set_dhparams - Set Diffie-Hellman parameters
476  * @cred: TLSv1 credentials from tlsv1_cred_alloc()
477  * @dh_file: File or reference name for the DH params in PEM or DER format
478  * @dh_blob: DH params as inlined data or %NULL if not used
479  * @dh_blob_len: dh_blob length
480  * Returns: 0 on success, -1 on failure
481  */
482 int tlsv1_set_dhparams(struct tlsv1_credentials *cred, const char *dh_file,
483 		       const u8 *dh_blob, size_t dh_blob_len)
484 {
485 	if (dh_blob)
486 		return tlsv1_set_dhparams_blob(cred, dh_blob, dh_blob_len);
487 
488 	if (dh_file) {
489 		u8 *buf;
490 		size_t len;
491 		int ret;
492 
493 		buf = (u8 *) os_readfile(dh_file, &len);
494 		if (buf == NULL) {
495 			wpa_printf(MSG_INFO, "TLSv1: Failed to read '%s'",
496 				   dh_file);
497 			return -1;
498 		}
499 
500 		ret = tlsv1_set_dhparams_blob(cred, buf, len);
501 		os_free(buf);
502 		return ret;
503 	}
504 
505 	return 0;
506 }
507