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