1 /*
2  * EAP-TLS/PEAP/TTLS/FAST server common functions
3  * Copyright (c) 2004-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 "crypto/sha1.h"
13 #include "crypto/tls.h"
14 #include "eap_i.h"
15 #include "eap_tls_common.h"
16 
17 
18 static void eap_server_tls_free_in_buf(struct eap_ssl_data *data);
19 
20 
21 struct wpabuf * eap_tls_msg_alloc(EapType type, size_t payload_len,
22 				  u8 code, u8 identifier)
23 {
24 	if (type == EAP_UNAUTH_TLS_TYPE)
25 		return eap_msg_alloc(EAP_VENDOR_UNAUTH_TLS,
26 				     EAP_VENDOR_TYPE_UNAUTH_TLS, payload_len,
27 				     code, identifier);
28 	else if (type == EAP_WFA_UNAUTH_TLS_TYPE)
29 		return eap_msg_alloc(EAP_VENDOR_WFA_NEW,
30 				     EAP_VENDOR_WFA_UNAUTH_TLS, payload_len,
31 				     code, identifier);
32 	return eap_msg_alloc(EAP_VENDOR_IETF, type, payload_len, code,
33 			     identifier);
34 }
35 
36 
37 #ifdef CONFIG_TLS_INTERNAL
38 static void eap_server_tls_log_cb(void *ctx, const char *msg)
39 {
40 	struct eap_sm *sm = ctx;
41 	eap_log_msg(sm, "TLS: %s", msg);
42 }
43 #endif /* CONFIG_TLS_INTERNAL */
44 
45 
46 int eap_server_tls_ssl_init(struct eap_sm *sm, struct eap_ssl_data *data,
47 			    int verify_peer, int eap_type)
48 {
49 	u8 session_ctx[8];
50 	unsigned int flags = sm->tls_flags;
51 
52 	if (sm->ssl_ctx == NULL) {
53 		wpa_printf(MSG_ERROR, "TLS context not initialized - cannot use TLS-based EAP method");
54 		return -1;
55 	}
56 
57 	data->eap = sm;
58 	data->phase2 = sm->init_phase2;
59 
60 	data->conn = tls_connection_init(sm->ssl_ctx);
61 	if (data->conn == NULL) {
62 		wpa_printf(MSG_INFO, "SSL: Failed to initialize new TLS "
63 			   "connection");
64 		return -1;
65 	}
66 
67 #ifdef CONFIG_TLS_INTERNAL
68 	tls_connection_set_log_cb(data->conn, eap_server_tls_log_cb, sm);
69 #ifdef CONFIG_TESTING_OPTIONS
70 	tls_connection_set_test_flags(data->conn, sm->tls_test_flags);
71 #endif /* CONFIG_TESTING_OPTIONS */
72 #endif /* CONFIG_TLS_INTERNAL */
73 
74 	if (eap_type != EAP_TYPE_FAST)
75 		flags |= TLS_CONN_DISABLE_SESSION_TICKET;
76 	os_memcpy(session_ctx, "hostapd", 7);
77 	session_ctx[7] = (u8) eap_type;
78 	if (tls_connection_set_verify(sm->ssl_ctx, data->conn, verify_peer,
79 				      flags, session_ctx,
80 				      sizeof(session_ctx))) {
81 		wpa_printf(MSG_INFO, "SSL: Failed to configure verification "
82 			   "of TLS peer certificate");
83 		tls_connection_deinit(sm->ssl_ctx, data->conn);
84 		data->conn = NULL;
85 		return -1;
86 	}
87 
88 	data->tls_out_limit = sm->fragment_size > 0 ? sm->fragment_size : 1398;
89 	if (data->phase2) {
90 		/* Limit the fragment size in the inner TLS authentication
91 		 * since the outer authentication with EAP-PEAP does not yet
92 		 * support fragmentation */
93 		if (data->tls_out_limit > 100)
94 			data->tls_out_limit -= 100;
95 	}
96 	return 0;
97 }
98 
99 
100 void eap_server_tls_ssl_deinit(struct eap_sm *sm, struct eap_ssl_data *data)
101 {
102 	tls_connection_deinit(sm->ssl_ctx, data->conn);
103 	eap_server_tls_free_in_buf(data);
104 	wpabuf_free(data->tls_out);
105 	data->tls_out = NULL;
106 }
107 
108 
109 u8 * eap_server_tls_derive_key(struct eap_sm *sm, struct eap_ssl_data *data,
110 			       const char *label, size_t len)
111 {
112 	u8 *out;
113 
114 	out = os_malloc(len);
115 	if (out == NULL)
116 		return NULL;
117 
118 	if (tls_connection_export_key(sm->ssl_ctx, data->conn, label, out,
119 				      len)) {
120 		os_free(out);
121 		return NULL;
122 	}
123 
124 	return out;
125 }
126 
127 
128 /**
129  * eap_server_tls_derive_session_id - Derive a Session-Id based on TLS data
130  * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
131  * @data: Data for TLS processing
132  * @eap_type: EAP method used in Phase 1 (EAP_TYPE_TLS/PEAP/TTLS/FAST)
133  * @len: Pointer to length of the session ID generated
134  * Returns: Pointer to allocated Session-Id on success or %NULL on failure
135  *
136  * This function derive the Session-Id based on the TLS session data
137  * (client/server random and method type).
138  *
139  * The caller is responsible for freeing the returned buffer.
140  */
141 u8 * eap_server_tls_derive_session_id(struct eap_sm *sm,
142 				      struct eap_ssl_data *data, u8 eap_type,
143 				      size_t *len)
144 {
145 	struct tls_random keys;
146 	u8 *out;
147 
148 	if (eap_type == EAP_TYPE_TLS && data->tls_v13) {
149 		*len = 64;
150 		return eap_server_tls_derive_key(sm, data,
151 						 "EXPORTER_EAP_TLS_Session-Id",
152 						 64);
153 	}
154 
155 	if (tls_connection_get_random(sm->ssl_ctx, data->conn, &keys))
156 		return NULL;
157 
158 	if (keys.client_random == NULL || keys.server_random == NULL)
159 		return NULL;
160 
161 	*len = 1 + keys.client_random_len + keys.server_random_len;
162 	out = os_malloc(*len);
163 	if (out == NULL)
164 		return NULL;
165 
166 	/* Session-Id = EAP type || client.random || server.random */
167 	out[0] = eap_type;
168 	os_memcpy(out + 1, keys.client_random, keys.client_random_len);
169 	os_memcpy(out + 1 + keys.client_random_len, keys.server_random,
170 		  keys.server_random_len);
171 
172 	return out;
173 }
174 
175 
176 struct wpabuf * eap_server_tls_build_msg(struct eap_ssl_data *data,
177 					 int eap_type, int version, u8 id)
178 {
179 	struct wpabuf *req;
180 	u8 flags;
181 	size_t send_len, plen;
182 
183 	wpa_printf(MSG_DEBUG, "SSL: Generating Request");
184 	if (data->tls_out == NULL) {
185 		wpa_printf(MSG_ERROR, "SSL: tls_out NULL in %s", __func__);
186 		return NULL;
187 	}
188 
189 	flags = version;
190 	send_len = wpabuf_len(data->tls_out) - data->tls_out_pos;
191 	if (1 + send_len > data->tls_out_limit) {
192 		send_len = data->tls_out_limit - 1;
193 		flags |= EAP_TLS_FLAGS_MORE_FRAGMENTS;
194 		if (data->tls_out_pos == 0) {
195 			flags |= EAP_TLS_FLAGS_LENGTH_INCLUDED;
196 			send_len -= 4;
197 		}
198 	}
199 
200 	plen = 1 + send_len;
201 	if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED)
202 		plen += 4;
203 
204 	req = eap_tls_msg_alloc(eap_type, plen, EAP_CODE_REQUEST, id);
205 	if (req == NULL)
206 		return NULL;
207 
208 	wpabuf_put_u8(req, flags); /* Flags */
209 	if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED)
210 		wpabuf_put_be32(req, wpabuf_len(data->tls_out));
211 
212 	wpabuf_put_data(req, wpabuf_head_u8(data->tls_out) + data->tls_out_pos,
213 			send_len);
214 	data->tls_out_pos += send_len;
215 
216 	if (data->tls_out_pos == wpabuf_len(data->tls_out)) {
217 		wpa_printf(MSG_DEBUG, "SSL: Sending out %lu bytes "
218 			   "(message sent completely)",
219 			   (unsigned long) send_len);
220 		wpabuf_free(data->tls_out);
221 		data->tls_out = NULL;
222 		data->tls_out_pos = 0;
223 		data->state = MSG;
224 	} else {
225 		wpa_printf(MSG_DEBUG, "SSL: Sending out %lu bytes "
226 			   "(%lu more to send)", (unsigned long) send_len,
227 			   (unsigned long) wpabuf_len(data->tls_out) -
228 			   data->tls_out_pos);
229 		data->state = WAIT_FRAG_ACK;
230 	}
231 
232 	return req;
233 }
234 
235 
236 struct wpabuf * eap_server_tls_build_ack(u8 id, int eap_type, int version)
237 {
238 	struct wpabuf *req;
239 
240 	req = eap_tls_msg_alloc(eap_type, 1, EAP_CODE_REQUEST, id);
241 	if (req == NULL)
242 		return NULL;
243 	wpa_printf(MSG_DEBUG, "SSL: Building ACK");
244 	wpabuf_put_u8(req, version); /* Flags */
245 	return req;
246 }
247 
248 
249 static int eap_server_tls_process_cont(struct eap_ssl_data *data,
250 				       const u8 *buf, size_t len)
251 {
252 	/* Process continuation of a pending message */
253 	if (len > wpabuf_tailroom(data->tls_in)) {
254 		wpa_printf(MSG_DEBUG, "SSL: Fragment overflow");
255 		return -1;
256 	}
257 
258 	wpabuf_put_data(data->tls_in, buf, len);
259 	wpa_printf(MSG_DEBUG, "SSL: Received %lu bytes, waiting for %lu "
260 		   "bytes more", (unsigned long) len,
261 		   (unsigned long) wpabuf_tailroom(data->tls_in));
262 
263 	return 0;
264 }
265 
266 
267 static int eap_server_tls_process_fragment(struct eap_ssl_data *data,
268 					   u8 flags, u32 message_length,
269 					   const u8 *buf, size_t len)
270 {
271 	/* Process a fragment that is not the last one of the message */
272 	if (data->tls_in == NULL && !(flags & EAP_TLS_FLAGS_LENGTH_INCLUDED)) {
273 		wpa_printf(MSG_DEBUG, "SSL: No Message Length field in a "
274 			   "fragmented packet");
275 		return -1;
276 	}
277 
278 	if (data->tls_in == NULL) {
279 		/* First fragment of the message */
280 
281 		/* Limit length to avoid rogue peers from causing large
282 		 * memory allocations. */
283 		if (message_length > 65536) {
284 			wpa_printf(MSG_INFO, "SSL: Too long TLS fragment (size"
285 				   " over 64 kB)");
286 			return -1;
287 		}
288 
289 		if (len > message_length) {
290 			wpa_printf(MSG_INFO, "SSL: Too much data (%d bytes) in "
291 				   "first fragment of frame (TLS Message "
292 				   "Length %d bytes)",
293 				   (int) len, (int) message_length);
294 			return -1;
295 		}
296 
297 		data->tls_in = wpabuf_alloc(message_length);
298 		if (data->tls_in == NULL) {
299 			wpa_printf(MSG_DEBUG, "SSL: No memory for message");
300 			return -1;
301 		}
302 		wpabuf_put_data(data->tls_in, buf, len);
303 		wpa_printf(MSG_DEBUG, "SSL: Received %lu bytes in first "
304 			   "fragment, waiting for %lu bytes more",
305 			   (unsigned long) len,
306 			   (unsigned long) wpabuf_tailroom(data->tls_in));
307 	}
308 
309 	return 0;
310 }
311 
312 
313 int eap_server_tls_phase1(struct eap_sm *sm, struct eap_ssl_data *data)
314 {
315 	char buf[20];
316 
317 	if (data->tls_out) {
318 		/* This should not happen.. */
319 		wpa_printf(MSG_INFO, "SSL: pending tls_out data when "
320 			   "processing new message");
321 		wpabuf_free(data->tls_out);
322 		WPA_ASSERT(data->tls_out == NULL);
323 	}
324 
325 	data->tls_out = tls_connection_server_handshake(sm->ssl_ctx,
326 							data->conn,
327 							data->tls_in, NULL);
328 	if (data->tls_out == NULL) {
329 		wpa_printf(MSG_INFO, "SSL: TLS processing failed");
330 		return -1;
331 	}
332 	if (tls_connection_get_failed(sm->ssl_ctx, data->conn)) {
333 		/* TLS processing has failed - return error */
334 		wpa_printf(MSG_DEBUG, "SSL: Failed - tls_out available to "
335 			   "report error");
336 		return -1;
337 	}
338 
339 	if (tls_get_version(sm->ssl_ctx, data->conn, buf, sizeof(buf)) == 0) {
340 		wpa_printf(MSG_DEBUG, "SSL: Using TLS version %s", buf);
341 		data->tls_v13 = os_strcmp(buf, "TLSv1.3") == 0;
342 	}
343 
344 	if (!sm->serial_num &&
345 	    tls_connection_established(sm->ssl_ctx, data->conn))
346 		sm->serial_num = tls_connection_peer_serial_num(sm->ssl_ctx,
347 								data->conn);
348 
349 	return 0;
350 }
351 
352 
353 static int eap_server_tls_reassemble(struct eap_ssl_data *data, u8 flags,
354 				     const u8 **pos, size_t *left)
355 {
356 	unsigned int tls_msg_len = 0;
357 	const u8 *end = *pos + *left;
358 
359 	if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED) {
360 		if (*left < 4) {
361 			wpa_printf(MSG_INFO, "SSL: Short frame with TLS "
362 				   "length");
363 			return -1;
364 		}
365 		tls_msg_len = WPA_GET_BE32(*pos);
366 		wpa_printf(MSG_DEBUG, "SSL: TLS Message Length: %d",
367 			   tls_msg_len);
368 		*pos += 4;
369 		*left -= 4;
370 
371 		if (*left > tls_msg_len) {
372 			wpa_printf(MSG_INFO, "SSL: TLS Message Length (%d "
373 				   "bytes) smaller than this fragment (%d "
374 				   "bytes)", (int) tls_msg_len, (int) *left);
375 			return -1;
376 		}
377 	}
378 
379 	wpa_printf(MSG_DEBUG, "SSL: Received packet: Flags 0x%x "
380 		   "Message Length %u", flags, tls_msg_len);
381 
382 	if (data->state == WAIT_FRAG_ACK) {
383 		if (*left != 0) {
384 			wpa_printf(MSG_DEBUG, "SSL: Unexpected payload in "
385 				   "WAIT_FRAG_ACK state");
386 			return -1;
387 		}
388 		wpa_printf(MSG_DEBUG, "SSL: Fragment acknowledged");
389 		return 1;
390 	}
391 
392 	if (data->tls_in &&
393 	    eap_server_tls_process_cont(data, *pos, end - *pos) < 0)
394 		return -1;
395 
396 	if (flags & EAP_TLS_FLAGS_MORE_FRAGMENTS) {
397 		if (eap_server_tls_process_fragment(data, flags, tls_msg_len,
398 						    *pos, end - *pos) < 0)
399 			return -1;
400 
401 		data->state = FRAG_ACK;
402 		return 1;
403 	}
404 
405 	if (data->state == FRAG_ACK) {
406 		wpa_printf(MSG_DEBUG, "SSL: All fragments received");
407 		data->state = MSG;
408 	}
409 
410 	if (data->tls_in == NULL) {
411 		/* Wrap unfragmented messages as wpabuf without extra copy */
412 		wpabuf_set(&data->tmpbuf, *pos, end - *pos);
413 		data->tls_in = &data->tmpbuf;
414 	}
415 
416 	return 0;
417 }
418 
419 
420 static void eap_server_tls_free_in_buf(struct eap_ssl_data *data)
421 {
422 	if (data->tls_in != &data->tmpbuf)
423 		wpabuf_free(data->tls_in);
424 	data->tls_in = NULL;
425 }
426 
427 
428 struct wpabuf * eap_server_tls_encrypt(struct eap_sm *sm,
429 				       struct eap_ssl_data *data,
430 				       const struct wpabuf *plain)
431 {
432 	struct wpabuf *buf;
433 
434 	buf = tls_connection_encrypt(sm->ssl_ctx, data->conn,
435 				     plain);
436 	if (buf == NULL) {
437 		wpa_printf(MSG_INFO, "SSL: Failed to encrypt Phase 2 data");
438 		return NULL;
439 	}
440 
441 	return buf;
442 }
443 
444 
445 int eap_server_tls_process(struct eap_sm *sm, struct eap_ssl_data *data,
446 			   struct wpabuf *respData, void *priv, int eap_type,
447 			   int (*proc_version)(struct eap_sm *sm, void *priv,
448 					       int peer_version),
449 			   void (*proc_msg)(struct eap_sm *sm, void *priv,
450 					    const struct wpabuf *respData))
451 {
452 	const u8 *pos;
453 	u8 flags;
454 	size_t left;
455 	int ret, res = 0;
456 
457 	if (eap_type == EAP_UNAUTH_TLS_TYPE)
458 		pos = eap_hdr_validate(EAP_VENDOR_UNAUTH_TLS,
459 				       EAP_VENDOR_TYPE_UNAUTH_TLS, respData,
460 				       &left);
461 	else if (eap_type == EAP_WFA_UNAUTH_TLS_TYPE)
462 		pos = eap_hdr_validate(EAP_VENDOR_WFA_NEW,
463 				       EAP_VENDOR_WFA_UNAUTH_TLS, respData,
464 				       &left);
465 	else
466 		pos = eap_hdr_validate(EAP_VENDOR_IETF, eap_type, respData,
467 				       &left);
468 	if (pos == NULL || left < 1)
469 		return 0; /* Should not happen - frame already validated */
470 	flags = *pos++;
471 	left--;
472 	wpa_printf(MSG_DEBUG, "SSL: Received packet(len=%lu) - Flags 0x%02x",
473 		   (unsigned long) wpabuf_len(respData), flags);
474 
475 	if (proc_version &&
476 	    proc_version(sm, priv, flags & EAP_TLS_VERSION_MASK) < 0)
477 		return -1;
478 
479 	ret = eap_server_tls_reassemble(data, flags, &pos, &left);
480 	if (ret < 0) {
481 		res = -1;
482 		goto done;
483 	} else if (ret == 1)
484 		return 0;
485 
486 	if (proc_msg)
487 		proc_msg(sm, priv, respData);
488 
489 	if (tls_connection_get_write_alerts(sm->ssl_ctx, data->conn) > 1) {
490 		wpa_printf(MSG_INFO, "SSL: Locally detected fatal error in "
491 			   "TLS processing");
492 		res = -1;
493 	}
494 
495 done:
496 	eap_server_tls_free_in_buf(data);
497 
498 	return res;
499 }
500