1 /*
2  * hostapd / RADIUS message processing
3  * Copyright (c) 2002-2008, Jouni Malinen <j@w1.fi>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * Alternatively, this software may be distributed under the terms of BSD
10  * license.
11  *
12  * See README and COPYING for more details.
13  */
14 
15 #include "includes.h"
16 
17 #include "common.h"
18 #include "radius.h"
19 #include "md5.h"
20 #include "crypto.h"
21 
22 
23 static struct radius_attr_hdr *
24 radius_get_attr_hdr(struct radius_msg *msg, int idx)
25 {
26 	return (struct radius_attr_hdr *) (msg->buf + msg->attr_pos[idx]);
27 }
28 
29 
30 struct radius_msg *radius_msg_new(u8 code, u8 identifier)
31 {
32 	struct radius_msg *msg;
33 
34 	msg = os_malloc(sizeof(*msg));
35 	if (msg == NULL)
36 		return NULL;
37 
38 	if (radius_msg_initialize(msg, RADIUS_DEFAULT_MSG_SIZE)) {
39 		os_free(msg);
40 		return NULL;
41 	}
42 
43 	radius_msg_set_hdr(msg, code, identifier);
44 
45 	return msg;
46 }
47 
48 
49 int radius_msg_initialize(struct radius_msg *msg, size_t init_len)
50 {
51 	if (msg == NULL || init_len < sizeof(struct radius_hdr))
52 		return -1;
53 
54 	os_memset(msg, 0, sizeof(*msg));
55 	msg->buf = os_zalloc(init_len);
56 	if (msg->buf == NULL)
57 		return -1;
58 
59 	msg->buf_size = init_len;
60 	msg->hdr = (struct radius_hdr *) msg->buf;
61 	msg->buf_used = sizeof(*msg->hdr);
62 
63 	msg->attr_pos =
64 		os_zalloc(RADIUS_DEFAULT_ATTR_COUNT * sizeof(*msg->attr_pos));
65 	if (msg->attr_pos == NULL) {
66 		os_free(msg->buf);
67 		msg->buf = NULL;
68 		msg->hdr = NULL;
69 		return -1;
70 	}
71 
72 	msg->attr_size = RADIUS_DEFAULT_ATTR_COUNT;
73 	msg->attr_used = 0;
74 
75 	return 0;
76 }
77 
78 
79 void radius_msg_set_hdr(struct radius_msg *msg, u8 code, u8 identifier)
80 {
81 	msg->hdr->code = code;
82 	msg->hdr->identifier = identifier;
83 }
84 
85 
86 void radius_msg_free(struct radius_msg *msg)
87 {
88 	os_free(msg->buf);
89 	msg->buf = NULL;
90 	msg->hdr = NULL;
91 	msg->buf_size = msg->buf_used = 0;
92 
93 	os_free(msg->attr_pos);
94 	msg->attr_pos = NULL;
95 	msg->attr_size = msg->attr_used = 0;
96 }
97 
98 
99 static const char *radius_code_string(u8 code)
100 {
101 	switch (code) {
102 	case RADIUS_CODE_ACCESS_REQUEST: return "Access-Request";
103 	case RADIUS_CODE_ACCESS_ACCEPT: return "Access-Accept";
104 	case RADIUS_CODE_ACCESS_REJECT: return "Access-Reject";
105 	case RADIUS_CODE_ACCOUNTING_REQUEST: return "Accounting-Request";
106 	case RADIUS_CODE_ACCOUNTING_RESPONSE: return "Accounting-Response";
107 	case RADIUS_CODE_ACCESS_CHALLENGE: return "Access-Challenge";
108 	case RADIUS_CODE_STATUS_SERVER: return "Status-Server";
109 	case RADIUS_CODE_STATUS_CLIENT: return "Status-Client";
110 	case RADIUS_CODE_RESERVED: return "Reserved";
111 	default: return "?Unknown?";
112 	}
113 }
114 
115 
116 struct radius_attr_type {
117 	u8 type;
118 	char *name;
119 	enum {
120 		RADIUS_ATTR_UNDIST, RADIUS_ATTR_TEXT, RADIUS_ATTR_IP,
121 		RADIUS_ATTR_HEXDUMP, RADIUS_ATTR_INT32, RADIUS_ATTR_IPV6
122 	} data_type;
123 };
124 
125 static struct radius_attr_type radius_attrs[] =
126 {
127 	{ RADIUS_ATTR_USER_NAME, "User-Name", RADIUS_ATTR_TEXT },
128 	{ RADIUS_ATTR_USER_PASSWORD, "User-Password", RADIUS_ATTR_UNDIST },
129 	{ RADIUS_ATTR_NAS_IP_ADDRESS, "NAS-IP-Address", RADIUS_ATTR_IP },
130 	{ RADIUS_ATTR_NAS_PORT, "NAS-Port", RADIUS_ATTR_INT32 },
131 	{ RADIUS_ATTR_FRAMED_MTU, "Framed-MTU", RADIUS_ATTR_INT32 },
132 	{ RADIUS_ATTR_REPLY_MESSAGE, "Reply-Message", RADIUS_ATTR_TEXT },
133 	{ RADIUS_ATTR_STATE, "State", RADIUS_ATTR_UNDIST },
134 	{ RADIUS_ATTR_CLASS, "Class", RADIUS_ATTR_UNDIST },
135 	{ RADIUS_ATTR_VENDOR_SPECIFIC, "Vendor-Specific", RADIUS_ATTR_UNDIST },
136 	{ RADIUS_ATTR_SESSION_TIMEOUT, "Session-Timeout", RADIUS_ATTR_INT32 },
137 	{ RADIUS_ATTR_IDLE_TIMEOUT, "Idle-Timeout", RADIUS_ATTR_INT32 },
138 	{ RADIUS_ATTR_TERMINATION_ACTION, "Termination-Action",
139 	  RADIUS_ATTR_INT32 },
140 	{ RADIUS_ATTR_CALLED_STATION_ID, "Called-Station-Id",
141 	  RADIUS_ATTR_TEXT },
142 	{ RADIUS_ATTR_CALLING_STATION_ID, "Calling-Station-Id",
143 	  RADIUS_ATTR_TEXT },
144 	{ RADIUS_ATTR_NAS_IDENTIFIER, "NAS-Identifier", RADIUS_ATTR_TEXT },
145 	{ RADIUS_ATTR_PROXY_STATE, "Proxy-State", RADIUS_ATTR_UNDIST },
146 	{ RADIUS_ATTR_ACCT_STATUS_TYPE, "Acct-Status-Type",
147 	  RADIUS_ATTR_INT32 },
148 	{ RADIUS_ATTR_ACCT_DELAY_TIME, "Acct-Delay-Time", RADIUS_ATTR_INT32 },
149 	{ RADIUS_ATTR_ACCT_INPUT_OCTETS, "Acct-Input-Octets",
150 	  RADIUS_ATTR_INT32 },
151 	{ RADIUS_ATTR_ACCT_OUTPUT_OCTETS, "Acct-Output-Octets",
152 	  RADIUS_ATTR_INT32 },
153 	{ RADIUS_ATTR_ACCT_SESSION_ID, "Acct-Session-Id", RADIUS_ATTR_TEXT },
154 	{ RADIUS_ATTR_ACCT_AUTHENTIC, "Acct-Authentic", RADIUS_ATTR_INT32 },
155 	{ RADIUS_ATTR_ACCT_SESSION_TIME, "Acct-Session-Time",
156 	  RADIUS_ATTR_INT32 },
157 	{ RADIUS_ATTR_ACCT_INPUT_PACKETS, "Acct-Input-Packets",
158 	  RADIUS_ATTR_INT32 },
159 	{ RADIUS_ATTR_ACCT_OUTPUT_PACKETS, "Acct-Output-Packets",
160 	  RADIUS_ATTR_INT32 },
161 	{ RADIUS_ATTR_ACCT_TERMINATE_CAUSE, "Acct-Terminate-Cause",
162 	  RADIUS_ATTR_INT32 },
163 	{ RADIUS_ATTR_ACCT_MULTI_SESSION_ID, "Acct-Multi-Session-Id",
164 	  RADIUS_ATTR_TEXT },
165 	{ RADIUS_ATTR_ACCT_LINK_COUNT, "Acct-Link-Count", RADIUS_ATTR_INT32 },
166 	{ RADIUS_ATTR_ACCT_INPUT_GIGAWORDS, "Acct-Input-Gigawords",
167 	  RADIUS_ATTR_INT32 },
168 	{ RADIUS_ATTR_ACCT_OUTPUT_GIGAWORDS, "Acct-Output-Gigawords",
169 	  RADIUS_ATTR_INT32 },
170 	{ RADIUS_ATTR_EVENT_TIMESTAMP, "Event-Timestamp",
171 	  RADIUS_ATTR_INT32 },
172 	{ RADIUS_ATTR_NAS_PORT_TYPE, "NAS-Port-Type", RADIUS_ATTR_INT32 },
173 	{ RADIUS_ATTR_TUNNEL_TYPE, "Tunnel-Type", RADIUS_ATTR_HEXDUMP },
174 	{ RADIUS_ATTR_TUNNEL_MEDIUM_TYPE, "Tunnel-Medium-Type",
175 	  RADIUS_ATTR_HEXDUMP },
176 	{ RADIUS_ATTR_CONNECT_INFO, "Connect-Info", RADIUS_ATTR_TEXT },
177 	{ RADIUS_ATTR_EAP_MESSAGE, "EAP-Message", RADIUS_ATTR_UNDIST },
178 	{ RADIUS_ATTR_MESSAGE_AUTHENTICATOR, "Message-Authenticator",
179 	  RADIUS_ATTR_UNDIST },
180 	{ RADIUS_ATTR_TUNNEL_PRIVATE_GROUP_ID, "Tunnel-Private-Group-Id",
181 	  RADIUS_ATTR_HEXDUMP },
182 	{ RADIUS_ATTR_ACCT_INTERIM_INTERVAL, "Acct-Interim-Interval",
183 	  RADIUS_ATTR_INT32 },
184 	{ RADIUS_ATTR_CHARGEABLE_USER_IDENTITY, "Chargable-User-Identity",
185 	  RADIUS_ATTR_TEXT },
186 	{ RADIUS_ATTR_NAS_IPV6_ADDRESS, "NAS-IPv6-Address", RADIUS_ATTR_IPV6 },
187 };
188 #define RADIUS_ATTRS (sizeof(radius_attrs) / sizeof(radius_attrs[0]))
189 
190 
191 static struct radius_attr_type *radius_get_attr_type(u8 type)
192 {
193 	size_t i;
194 
195 	for (i = 0; i < RADIUS_ATTRS; i++) {
196 		if (type == radius_attrs[i].type)
197 			return &radius_attrs[i];
198 	}
199 
200 	return NULL;
201 }
202 
203 
204 static void print_char(char c)
205 {
206 	if (c >= 32 && c < 127)
207 		printf("%c", c);
208 	else
209 		printf("<%02x>", c);
210 }
211 
212 
213 static void radius_msg_dump_attr(struct radius_attr_hdr *hdr)
214 {
215 	struct radius_attr_type *attr;
216 	int i, len;
217 	unsigned char *pos;
218 
219 	attr = radius_get_attr_type(hdr->type);
220 
221 	printf("   Attribute %d (%s) length=%d\n",
222 	       hdr->type, attr ? attr->name : "?Unknown?", hdr->length);
223 
224 	if (attr == NULL)
225 		return;
226 
227 	len = hdr->length - sizeof(struct radius_attr_hdr);
228 	pos = (unsigned char *) (hdr + 1);
229 
230 	switch (attr->data_type) {
231 	case RADIUS_ATTR_TEXT:
232 		printf("      Value: '");
233 		for (i = 0; i < len; i++)
234 			print_char(pos[i]);
235 		printf("'\n");
236 		break;
237 
238 	case RADIUS_ATTR_IP:
239 		if (len == 4) {
240 			struct in_addr addr;
241 			os_memcpy(&addr, pos, 4);
242 			printf("      Value: %s\n", inet_ntoa(addr));
243 		} else
244 			printf("      Invalid IP address length %d\n", len);
245 		break;
246 
247 #ifdef CONFIG_IPV6
248 	case RADIUS_ATTR_IPV6:
249 		if (len == 16) {
250 			char buf[128];
251 			const char *atxt;
252 			struct in6_addr *addr = (struct in6_addr *) pos;
253 			atxt = inet_ntop(AF_INET6, addr, buf, sizeof(buf));
254 			printf("      Value: %s\n", atxt ? atxt : "?");
255 		} else
256 			printf("      Invalid IPv6 address length %d\n", len);
257 		break;
258 #endif /* CONFIG_IPV6 */
259 
260 	case RADIUS_ATTR_HEXDUMP:
261 	case RADIUS_ATTR_UNDIST:
262 		printf("      Value:");
263 		for (i = 0; i < len; i++)
264 			printf(" %02x", pos[i]);
265 		printf("\n");
266 		break;
267 
268 	case RADIUS_ATTR_INT32:
269 		if (len == 4)
270 			printf("      Value: %u\n", WPA_GET_BE32(pos));
271 		else
272 			printf("      Invalid INT32 length %d\n", len);
273 		break;
274 
275 	default:
276 		break;
277 	}
278 }
279 
280 
281 void radius_msg_dump(struct radius_msg *msg)
282 {
283 	size_t i;
284 
285 	printf("RADIUS message: code=%d (%s) identifier=%d length=%d\n",
286 	       msg->hdr->code, radius_code_string(msg->hdr->code),
287 	       msg->hdr->identifier, ntohs(msg->hdr->length));
288 
289 	for (i = 0; i < msg->attr_used; i++) {
290 		struct radius_attr_hdr *attr = radius_get_attr_hdr(msg, i);
291 		radius_msg_dump_attr(attr);
292 	}
293 }
294 
295 
296 int radius_msg_finish(struct radius_msg *msg, const u8 *secret,
297 		      size_t secret_len)
298 {
299 	if (secret) {
300 		u8 auth[MD5_MAC_LEN];
301 		struct radius_attr_hdr *attr;
302 
303 		os_memset(auth, 0, MD5_MAC_LEN);
304 		attr = radius_msg_add_attr(msg,
305 					   RADIUS_ATTR_MESSAGE_AUTHENTICATOR,
306 					   auth, MD5_MAC_LEN);
307 		if (attr == NULL) {
308 			printf("WARNING: Could not add "
309 			       "Message-Authenticator\n");
310 			return -1;
311 		}
312 		msg->hdr->length = htons(msg->buf_used);
313 		hmac_md5(secret, secret_len, msg->buf, msg->buf_used,
314 			 (u8 *) (attr + 1));
315 	} else
316 		msg->hdr->length = htons(msg->buf_used);
317 
318 	if (msg->buf_used > 0xffff) {
319 		printf("WARNING: too long RADIUS message (%lu)\n",
320 		       (unsigned long) msg->buf_used);
321 		return -1;
322 	}
323 	return 0;
324 }
325 
326 
327 int radius_msg_finish_srv(struct radius_msg *msg, const u8 *secret,
328 			  size_t secret_len, const u8 *req_authenticator)
329 {
330 	u8 auth[MD5_MAC_LEN];
331 	struct radius_attr_hdr *attr;
332 	const u8 *addr[4];
333 	size_t len[4];
334 
335 	os_memset(auth, 0, MD5_MAC_LEN);
336 	attr = radius_msg_add_attr(msg, RADIUS_ATTR_MESSAGE_AUTHENTICATOR,
337 				   auth, MD5_MAC_LEN);
338 	if (attr == NULL) {
339 		printf("WARNING: Could not add Message-Authenticator\n");
340 		return -1;
341 	}
342 	msg->hdr->length = htons(msg->buf_used);
343 	os_memcpy(msg->hdr->authenticator, req_authenticator,
344 		  sizeof(msg->hdr->authenticator));
345 	hmac_md5(secret, secret_len, msg->buf, msg->buf_used,
346 		 (u8 *) (attr + 1));
347 
348 	/* ResponseAuth = MD5(Code+ID+Length+RequestAuth+Attributes+Secret) */
349 	addr[0] = (u8 *) msg->hdr;
350 	len[0] = 1 + 1 + 2;
351 	addr[1] = req_authenticator;
352 	len[1] = MD5_MAC_LEN;
353 	addr[2] = (u8 *) (msg->hdr + 1);
354 	len[2] = msg->buf_used - sizeof(*msg->hdr);
355 	addr[3] = secret;
356 	len[3] = secret_len;
357 	md5_vector(4, addr, len, msg->hdr->authenticator);
358 
359 	if (msg->buf_used > 0xffff) {
360 		printf("WARNING: too long RADIUS message (%lu)\n",
361 		       (unsigned long) msg->buf_used);
362 		return -1;
363 	}
364 	return 0;
365 }
366 
367 
368 void radius_msg_finish_acct(struct radius_msg *msg, const u8 *secret,
369 			    size_t secret_len)
370 {
371 	const u8 *addr[2];
372 	size_t len[2];
373 
374 	msg->hdr->length = htons(msg->buf_used);
375 	os_memset(msg->hdr->authenticator, 0, MD5_MAC_LEN);
376 	addr[0] = msg->buf;
377 	len[0] = msg->buf_used;
378 	addr[1] = secret;
379 	len[1] = secret_len;
380 	md5_vector(2, addr, len, msg->hdr->authenticator);
381 
382 	if (msg->buf_used > 0xffff) {
383 		printf("WARNING: too long RADIUS messages (%lu)\n",
384 		       (unsigned long) msg->buf_used);
385 	}
386 }
387 
388 
389 static int radius_msg_add_attr_to_array(struct radius_msg *msg,
390 					struct radius_attr_hdr *attr)
391 {
392 	if (msg->attr_used >= msg->attr_size) {
393 		size_t *nattr_pos;
394 		int nlen = msg->attr_size * 2;
395 
396 		nattr_pos = os_realloc(msg->attr_pos,
397 				       nlen * sizeof(*msg->attr_pos));
398 		if (nattr_pos == NULL)
399 			return -1;
400 
401 		msg->attr_pos = nattr_pos;
402 		msg->attr_size = nlen;
403 	}
404 
405 	msg->attr_pos[msg->attr_used++] = (unsigned char *) attr - msg->buf;
406 
407 	return 0;
408 }
409 
410 
411 struct radius_attr_hdr *radius_msg_add_attr(struct radius_msg *msg, u8 type,
412 					    const u8 *data, size_t data_len)
413 {
414 	size_t buf_needed;
415 	struct radius_attr_hdr *attr;
416 
417 	if (data_len > RADIUS_MAX_ATTR_LEN) {
418 		printf("radius_msg_add_attr: too long attribute (%lu bytes)\n",
419 		       (unsigned long) data_len);
420 		return NULL;
421 	}
422 
423 	buf_needed = msg->buf_used + sizeof(*attr) + data_len;
424 
425 	if (msg->buf_size < buf_needed) {
426 		/* allocate more space for message buffer */
427 		unsigned char *nbuf;
428 		size_t nlen = msg->buf_size;
429 
430 		while (nlen < buf_needed)
431 			nlen *= 2;
432 		nbuf = os_realloc(msg->buf, nlen);
433 		if (nbuf == NULL)
434 			return NULL;
435 		msg->buf = nbuf;
436 		msg->hdr = (struct radius_hdr *) msg->buf;
437 		os_memset(msg->buf + msg->buf_size, 0, nlen - msg->buf_size);
438 		msg->buf_size = nlen;
439 	}
440 
441 	attr = (struct radius_attr_hdr *) (msg->buf + msg->buf_used);
442 	attr->type = type;
443 	attr->length = sizeof(*attr) + data_len;
444 	if (data_len > 0)
445 		os_memcpy(attr + 1, data, data_len);
446 
447 	msg->buf_used += sizeof(*attr) + data_len;
448 
449 	if (radius_msg_add_attr_to_array(msg, attr))
450 		return NULL;
451 
452 	return attr;
453 }
454 
455 
456 struct radius_msg *radius_msg_parse(const u8 *data, size_t len)
457 {
458 	struct radius_msg *msg;
459 	struct radius_hdr *hdr;
460 	struct radius_attr_hdr *attr;
461 	size_t msg_len;
462 	unsigned char *pos, *end;
463 
464 	if (data == NULL || len < sizeof(*hdr))
465 		return NULL;
466 
467 	hdr = (struct radius_hdr *) data;
468 
469 	msg_len = ntohs(hdr->length);
470 	if (msg_len < sizeof(*hdr) || msg_len > len) {
471 		printf("Invalid RADIUS message length\n");
472 		return NULL;
473 	}
474 
475 	if (msg_len < len) {
476 		printf("Ignored %lu extra bytes after RADIUS message\n",
477 		       (unsigned long) len - msg_len);
478 	}
479 
480 	msg = os_malloc(sizeof(*msg));
481 	if (msg == NULL)
482 		return NULL;
483 
484 	if (radius_msg_initialize(msg, msg_len)) {
485 		os_free(msg);
486 		return NULL;
487 	}
488 
489 	os_memcpy(msg->buf, data, msg_len);
490 	msg->buf_size = msg->buf_used = msg_len;
491 
492 	/* parse attributes */
493 	pos = (unsigned char *) (msg->hdr + 1);
494 	end = msg->buf + msg->buf_used;
495 	while (pos < end) {
496 		if ((size_t) (end - pos) < sizeof(*attr))
497 			goto fail;
498 
499 		attr = (struct radius_attr_hdr *) pos;
500 
501 		if (pos + attr->length > end || attr->length < sizeof(*attr))
502 			goto fail;
503 
504 		/* TODO: check that attr->length is suitable for attr->type */
505 
506 		if (radius_msg_add_attr_to_array(msg, attr))
507 			goto fail;
508 
509 		pos += attr->length;
510 	}
511 
512 	return msg;
513 
514  fail:
515 	radius_msg_free(msg);
516 	os_free(msg);
517 	return NULL;
518 }
519 
520 
521 int radius_msg_add_eap(struct radius_msg *msg, const u8 *data, size_t data_len)
522 {
523 	const u8 *pos = data;
524 	size_t left = data_len;
525 
526 	while (left > 0) {
527 		int len;
528 		if (left > RADIUS_MAX_ATTR_LEN)
529 			len = RADIUS_MAX_ATTR_LEN;
530 		else
531 			len = left;
532 
533 		if (!radius_msg_add_attr(msg, RADIUS_ATTR_EAP_MESSAGE,
534 					 pos, len))
535 			return 0;
536 
537 		pos += len;
538 		left -= len;
539 	}
540 
541 	return 1;
542 }
543 
544 
545 u8 *radius_msg_get_eap(struct radius_msg *msg, size_t *eap_len)
546 {
547 	u8 *eap, *pos;
548 	size_t len, i;
549 	struct radius_attr_hdr *attr;
550 
551 	if (msg == NULL)
552 		return NULL;
553 
554 	len = 0;
555 	for (i = 0; i < msg->attr_used; i++) {
556 		attr = radius_get_attr_hdr(msg, i);
557 		if (attr->type == RADIUS_ATTR_EAP_MESSAGE)
558 			len += attr->length - sizeof(struct radius_attr_hdr);
559 	}
560 
561 	if (len == 0)
562 		return NULL;
563 
564 	eap = os_malloc(len);
565 	if (eap == NULL)
566 		return NULL;
567 
568 	pos = eap;
569 	for (i = 0; i < msg->attr_used; i++) {
570 		attr = radius_get_attr_hdr(msg, i);
571 		if (attr->type == RADIUS_ATTR_EAP_MESSAGE) {
572 			int flen = attr->length - sizeof(*attr);
573 			os_memcpy(pos, attr + 1, flen);
574 			pos += flen;
575 		}
576 	}
577 
578 	if (eap_len)
579 		*eap_len = len;
580 
581 	return eap;
582 }
583 
584 
585 int radius_msg_verify_msg_auth(struct radius_msg *msg, const u8 *secret,
586 			       size_t secret_len, const u8 *req_auth)
587 {
588 	u8 auth[MD5_MAC_LEN], orig[MD5_MAC_LEN];
589 	u8 orig_authenticator[16];
590 	struct radius_attr_hdr *attr = NULL, *tmp;
591 	size_t i;
592 
593 	for (i = 0; i < msg->attr_used; i++) {
594 		tmp = radius_get_attr_hdr(msg, i);
595 		if (tmp->type == RADIUS_ATTR_MESSAGE_AUTHENTICATOR) {
596 			if (attr != NULL) {
597 				printf("Multiple Message-Authenticator "
598 				       "attributes in RADIUS message\n");
599 				return 1;
600 			}
601 			attr = tmp;
602 		}
603 	}
604 
605 	if (attr == NULL) {
606 		printf("No Message-Authenticator attribute found\n");
607 		return 1;
608 	}
609 
610 	os_memcpy(orig, attr + 1, MD5_MAC_LEN);
611 	os_memset(attr + 1, 0, MD5_MAC_LEN);
612 	if (req_auth) {
613 		os_memcpy(orig_authenticator, msg->hdr->authenticator,
614 			  sizeof(orig_authenticator));
615 		os_memcpy(msg->hdr->authenticator, req_auth,
616 			  sizeof(msg->hdr->authenticator));
617 	}
618 	hmac_md5(secret, secret_len, msg->buf, msg->buf_used, auth);
619 	os_memcpy(attr + 1, orig, MD5_MAC_LEN);
620 	if (req_auth) {
621 		os_memcpy(msg->hdr->authenticator, orig_authenticator,
622 			  sizeof(orig_authenticator));
623 	}
624 
625 	if (os_memcmp(orig, auth, MD5_MAC_LEN) != 0) {
626 		printf("Invalid Message-Authenticator!\n");
627 		return 1;
628 	}
629 
630 	return 0;
631 }
632 
633 
634 int radius_msg_verify(struct radius_msg *msg, const u8 *secret,
635 		      size_t secret_len, struct radius_msg *sent_msg, int auth)
636 {
637 	const u8 *addr[4];
638 	size_t len[4];
639 	u8 hash[MD5_MAC_LEN];
640 
641 	if (sent_msg == NULL) {
642 		printf("No matching Access-Request message found\n");
643 		return 1;
644 	}
645 
646 	if (auth &&
647 	    radius_msg_verify_msg_auth(msg, secret, secret_len,
648 				       sent_msg->hdr->authenticator)) {
649 		return 1;
650 	}
651 
652 	/* ResponseAuth = MD5(Code+ID+Length+RequestAuth+Attributes+Secret) */
653 	addr[0] = (u8 *) msg->hdr;
654 	len[0] = 1 + 1 + 2;
655 	addr[1] = sent_msg->hdr->authenticator;
656 	len[1] = MD5_MAC_LEN;
657 	addr[2] = (u8 *) (msg->hdr + 1);
658 	len[2] = msg->buf_used - sizeof(*msg->hdr);
659 	addr[3] = secret;
660 	len[3] = secret_len;
661 	md5_vector(4, addr, len, hash);
662 	if (os_memcmp(hash, msg->hdr->authenticator, MD5_MAC_LEN) != 0) {
663 		printf("Response Authenticator invalid!\n");
664 		return 1;
665 	}
666 
667 	return 0;
668 }
669 
670 
671 int radius_msg_copy_attr(struct radius_msg *dst, struct radius_msg *src,
672 			 u8 type)
673 {
674 	struct radius_attr_hdr *attr;
675 	size_t i;
676 	int count = 0;
677 
678 	for (i = 0; i < src->attr_used; i++) {
679 		attr = radius_get_attr_hdr(src, i);
680 		if (attr->type == type) {
681 			if (!radius_msg_add_attr(dst, type, (u8 *) (attr + 1),
682 						 attr->length - sizeof(*attr)))
683 				return -1;
684 			count++;
685 		}
686 	}
687 
688 	return count;
689 }
690 
691 
692 /* Create Request Authenticator. The value should be unique over the lifetime
693  * of the shared secret between authenticator and authentication server.
694  * Use one-way MD5 hash calculated from current timestamp and some data given
695  * by the caller. */
696 void radius_msg_make_authenticator(struct radius_msg *msg,
697 				   const u8 *data, size_t len)
698 {
699 	struct os_time tv;
700 	long int l;
701 	const u8 *addr[3];
702 	size_t elen[3];
703 
704 	os_get_time(&tv);
705 	l = os_random();
706 	addr[0] = (u8 *) &tv;
707 	elen[0] = sizeof(tv);
708 	addr[1] = data;
709 	elen[1] = len;
710 	addr[2] = (u8 *) &l;
711 	elen[2] = sizeof(l);
712 	md5_vector(3, addr, elen, msg->hdr->authenticator);
713 }
714 
715 
716 /* Get Vendor-specific RADIUS Attribute from a parsed RADIUS message.
717  * Returns the Attribute payload and sets alen to indicate the length of the
718  * payload if a vendor attribute with subtype is found, otherwise returns NULL.
719  * The returned payload is allocated with os_malloc() and caller must free it
720  * by calling os_free().
721  */
722 static u8 *radius_msg_get_vendor_attr(struct radius_msg *msg, u32 vendor,
723 				      u8 subtype, size_t *alen)
724 {
725 	u8 *data, *pos;
726 	size_t i, len;
727 
728 	if (msg == NULL)
729 		return NULL;
730 
731 	for (i = 0; i < msg->attr_used; i++) {
732 		struct radius_attr_hdr *attr = radius_get_attr_hdr(msg, i);
733 		size_t left;
734 		u32 vendor_id;
735 		struct radius_attr_vendor *vhdr;
736 
737 		if (attr->type != RADIUS_ATTR_VENDOR_SPECIFIC)
738 			continue;
739 
740 		left = attr->length - sizeof(*attr);
741 		if (left < 4)
742 			continue;
743 
744 		pos = (u8 *) (attr + 1);
745 
746 		os_memcpy(&vendor_id, pos, 4);
747 		pos += 4;
748 		left -= 4;
749 
750 		if (ntohl(vendor_id) != vendor)
751 			continue;
752 
753 		while (left >= sizeof(*vhdr)) {
754 			vhdr = (struct radius_attr_vendor *) pos;
755 			if (vhdr->vendor_length > left ||
756 			    vhdr->vendor_length < sizeof(*vhdr)) {
757 				left = 0;
758 				break;
759 			}
760 			if (vhdr->vendor_type != subtype) {
761 				pos += vhdr->vendor_length;
762 				left -= vhdr->vendor_length;
763 				continue;
764 			}
765 
766 			len = vhdr->vendor_length - sizeof(*vhdr);
767 			data = os_malloc(len);
768 			if (data == NULL)
769 				return NULL;
770 			os_memcpy(data, pos + sizeof(*vhdr), len);
771 			if (alen)
772 				*alen = len;
773 			return data;
774 		}
775 	}
776 
777 	return NULL;
778 }
779 
780 
781 static u8 * decrypt_ms_key(const u8 *key, size_t len,
782 			   const u8 *req_authenticator,
783 			   const u8 *secret, size_t secret_len, size_t *reslen)
784 {
785 	u8 *plain, *ppos, *res;
786 	const u8 *pos;
787 	size_t left, plen;
788 	u8 hash[MD5_MAC_LEN];
789 	int i, first = 1;
790 	const u8 *addr[3];
791 	size_t elen[3];
792 
793 	/* key: 16-bit salt followed by encrypted key info */
794 
795 	if (len < 2 + 16)
796 		return NULL;
797 
798 	pos = key + 2;
799 	left = len - 2;
800 	if (left % 16) {
801 		printf("Invalid ms key len %lu\n", (unsigned long) left);
802 		return NULL;
803 	}
804 
805 	plen = left;
806 	ppos = plain = os_malloc(plen);
807 	if (plain == NULL)
808 		return NULL;
809 	plain[0] = 0;
810 
811 	while (left > 0) {
812 		/* b(1) = MD5(Secret + Request-Authenticator + Salt)
813 		 * b(i) = MD5(Secret + c(i - 1)) for i > 1 */
814 
815 		addr[0] = secret;
816 		elen[0] = secret_len;
817 		if (first) {
818 			addr[1] = req_authenticator;
819 			elen[1] = MD5_MAC_LEN;
820 			addr[2] = key;
821 			elen[2] = 2; /* Salt */
822 		} else {
823 			addr[1] = pos - MD5_MAC_LEN;
824 			elen[1] = MD5_MAC_LEN;
825 		}
826 		md5_vector(first ? 3 : 2, addr, elen, hash);
827 		first = 0;
828 
829 		for (i = 0; i < MD5_MAC_LEN; i++)
830 			*ppos++ = *pos++ ^ hash[i];
831 		left -= MD5_MAC_LEN;
832 	}
833 
834 	if (plain[0] == 0 || plain[0] > plen - 1) {
835 		printf("Failed to decrypt MPPE key\n");
836 		os_free(plain);
837 		return NULL;
838 	}
839 
840 	res = os_malloc(plain[0]);
841 	if (res == NULL) {
842 		os_free(plain);
843 		return NULL;
844 	}
845 	os_memcpy(res, plain + 1, plain[0]);
846 	if (reslen)
847 		*reslen = plain[0];
848 	os_free(plain);
849 	return res;
850 }
851 
852 
853 static void encrypt_ms_key(const u8 *key, size_t key_len, u16 salt,
854 			   const u8 *req_authenticator,
855 			   const u8 *secret, size_t secret_len,
856 			   u8 *ebuf, size_t *elen)
857 {
858 	int i, len, first = 1;
859 	u8 hash[MD5_MAC_LEN], saltbuf[2], *pos;
860 	const u8 *addr[3];
861 	size_t _len[3];
862 
863 	WPA_PUT_BE16(saltbuf, salt);
864 
865 	len = 1 + key_len;
866 	if (len & 0x0f) {
867 		len = (len & 0xf0) + 16;
868 	}
869 	os_memset(ebuf, 0, len);
870 	ebuf[0] = key_len;
871 	os_memcpy(ebuf + 1, key, key_len);
872 
873 	*elen = len;
874 
875 	pos = ebuf;
876 	while (len > 0) {
877 		/* b(1) = MD5(Secret + Request-Authenticator + Salt)
878 		 * b(i) = MD5(Secret + c(i - 1)) for i > 1 */
879 		addr[0] = secret;
880 		_len[0] = secret_len;
881 		if (first) {
882 			addr[1] = req_authenticator;
883 			_len[1] = MD5_MAC_LEN;
884 			addr[2] = saltbuf;
885 			_len[2] = sizeof(saltbuf);
886 		} else {
887 			addr[1] = pos - MD5_MAC_LEN;
888 			_len[1] = MD5_MAC_LEN;
889 		}
890 		md5_vector(first ? 3 : 2, addr, _len, hash);
891 		first = 0;
892 
893 		for (i = 0; i < MD5_MAC_LEN; i++)
894 			*pos++ ^= hash[i];
895 
896 		len -= MD5_MAC_LEN;
897 	}
898 }
899 
900 
901 struct radius_ms_mppe_keys *
902 radius_msg_get_ms_keys(struct radius_msg *msg, struct radius_msg *sent_msg,
903 		       const u8 *secret, size_t secret_len)
904 {
905 	u8 *key;
906 	size_t keylen;
907 	struct radius_ms_mppe_keys *keys;
908 
909 	if (msg == NULL || sent_msg == NULL)
910 		return NULL;
911 
912 	keys = os_zalloc(sizeof(*keys));
913 	if (keys == NULL)
914 		return NULL;
915 
916 	key = radius_msg_get_vendor_attr(msg, RADIUS_VENDOR_ID_MICROSOFT,
917 					 RADIUS_VENDOR_ATTR_MS_MPPE_SEND_KEY,
918 					 &keylen);
919 	if (key) {
920 		keys->send = decrypt_ms_key(key, keylen,
921 					    sent_msg->hdr->authenticator,
922 					    secret, secret_len,
923 					    &keys->send_len);
924 		os_free(key);
925 	}
926 
927 	key = radius_msg_get_vendor_attr(msg, RADIUS_VENDOR_ID_MICROSOFT,
928 					 RADIUS_VENDOR_ATTR_MS_MPPE_RECV_KEY,
929 					 &keylen);
930 	if (key) {
931 		keys->recv = decrypt_ms_key(key, keylen,
932 					    sent_msg->hdr->authenticator,
933 					    secret, secret_len,
934 					    &keys->recv_len);
935 		os_free(key);
936 	}
937 
938 	return keys;
939 }
940 
941 
942 struct radius_ms_mppe_keys *
943 radius_msg_get_cisco_keys(struct radius_msg *msg, struct radius_msg *sent_msg,
944 			  const u8 *secret, size_t secret_len)
945 {
946 	u8 *key;
947 	size_t keylen;
948 	struct radius_ms_mppe_keys *keys;
949 
950 	if (msg == NULL || sent_msg == NULL)
951 		return NULL;
952 
953 	keys = os_zalloc(sizeof(*keys));
954 	if (keys == NULL)
955 		return NULL;
956 
957 	key = radius_msg_get_vendor_attr(msg, RADIUS_VENDOR_ID_CISCO,
958 					 RADIUS_CISCO_AV_PAIR, &keylen);
959 	if (key && keylen == 51 &&
960 	    os_memcmp(key, "leap:session-key=", 17) == 0) {
961 		keys->recv = decrypt_ms_key(key + 17, keylen - 17,
962 					    sent_msg->hdr->authenticator,
963 					    secret, secret_len,
964 					    &keys->recv_len);
965 	}
966 	os_free(key);
967 
968 	return keys;
969 }
970 
971 
972 int radius_msg_add_mppe_keys(struct radius_msg *msg,
973 			     const u8 *req_authenticator,
974 			     const u8 *secret, size_t secret_len,
975 			     const u8 *send_key, size_t send_key_len,
976 			     const u8 *recv_key, size_t recv_key_len)
977 {
978 	struct radius_attr_hdr *attr;
979 	u32 vendor_id = htonl(RADIUS_VENDOR_ID_MICROSOFT);
980 	u8 *buf;
981 	struct radius_attr_vendor *vhdr;
982 	u8 *pos;
983 	size_t elen;
984 	int hlen;
985 	u16 salt;
986 
987 	hlen = sizeof(vendor_id) + sizeof(*vhdr) + 2;
988 
989 	/* MS-MPPE-Send-Key */
990 	buf = os_malloc(hlen + send_key_len + 16);
991 	if (buf == NULL) {
992 		return 0;
993 	}
994 	pos = buf;
995 	os_memcpy(pos, &vendor_id, sizeof(vendor_id));
996 	pos += sizeof(vendor_id);
997 	vhdr = (struct radius_attr_vendor *) pos;
998 	vhdr->vendor_type = RADIUS_VENDOR_ATTR_MS_MPPE_SEND_KEY;
999 	pos = (u8 *) (vhdr + 1);
1000 	salt = os_random() | 0x8000;
1001 	WPA_PUT_BE16(pos, salt);
1002 	pos += 2;
1003 	encrypt_ms_key(send_key, send_key_len, salt, req_authenticator, secret,
1004 		       secret_len, pos, &elen);
1005 	vhdr->vendor_length = hlen + elen - sizeof(vendor_id);
1006 
1007 	attr = radius_msg_add_attr(msg, RADIUS_ATTR_VENDOR_SPECIFIC,
1008 				   buf, hlen + elen);
1009 	os_free(buf);
1010 	if (attr == NULL) {
1011 		return 0;
1012 	}
1013 
1014 	/* MS-MPPE-Recv-Key */
1015 	buf = os_malloc(hlen + send_key_len + 16);
1016 	if (buf == NULL) {
1017 		return 0;
1018 	}
1019 	pos = buf;
1020 	os_memcpy(pos, &vendor_id, sizeof(vendor_id));
1021 	pos += sizeof(vendor_id);
1022 	vhdr = (struct radius_attr_vendor *) pos;
1023 	vhdr->vendor_type = RADIUS_VENDOR_ATTR_MS_MPPE_RECV_KEY;
1024 	pos = (u8 *) (vhdr + 1);
1025 	salt ^= 1;
1026 	WPA_PUT_BE16(pos, salt);
1027 	pos += 2;
1028 	encrypt_ms_key(recv_key, recv_key_len, salt, req_authenticator, secret,
1029 		       secret_len, pos, &elen);
1030 	vhdr->vendor_length = hlen + elen - sizeof(vendor_id);
1031 
1032 	attr = radius_msg_add_attr(msg, RADIUS_ATTR_VENDOR_SPECIFIC,
1033 				   buf, hlen + elen);
1034 	os_free(buf);
1035 	if (attr == NULL) {
1036 		return 0;
1037 	}
1038 
1039 	return 1;
1040 }
1041 
1042 
1043 /* Add User-Password attribute to a RADIUS message and encrypt it as specified
1044  * in RFC 2865, Chap. 5.2 */
1045 struct radius_attr_hdr *
1046 radius_msg_add_attr_user_password(struct radius_msg *msg,
1047 				  const u8 *data, size_t data_len,
1048 				  const u8 *secret, size_t secret_len)
1049 {
1050 	u8 buf[128];
1051 	int padlen, i;
1052 	size_t buf_len, pos;
1053 	const u8 *addr[2];
1054 	size_t len[2];
1055 	u8 hash[16];
1056 
1057 	if (data_len > 128)
1058 		return NULL;
1059 
1060 	os_memcpy(buf, data, data_len);
1061 	buf_len = data_len;
1062 
1063 	padlen = data_len % 16;
1064 	if (padlen) {
1065 		padlen = 16 - padlen;
1066 		os_memset(buf + data_len, 0, padlen);
1067 		buf_len += padlen;
1068 	}
1069 
1070 	addr[0] = secret;
1071 	len[0] = secret_len;
1072 	addr[1] = msg->hdr->authenticator;
1073 	len[1] = 16;
1074 	md5_vector(2, addr, len, hash);
1075 
1076 	for (i = 0; i < 16; i++)
1077 		buf[i] ^= hash[i];
1078 	pos = 16;
1079 
1080 	while (pos < buf_len) {
1081 		addr[0] = secret;
1082 		len[0] = secret_len;
1083 		addr[1] = &buf[pos - 16];
1084 		len[1] = 16;
1085 		md5_vector(2, addr, len, hash);
1086 
1087 		for (i = 0; i < 16; i++)
1088 			buf[pos + i] ^= hash[i];
1089 
1090 		pos += 16;
1091 	}
1092 
1093 	return radius_msg_add_attr(msg, RADIUS_ATTR_USER_PASSWORD,
1094 				   buf, buf_len);
1095 }
1096 
1097 
1098 int radius_msg_get_attr(struct radius_msg *msg, u8 type, u8 *buf, size_t len)
1099 {
1100 	struct radius_attr_hdr *attr = NULL, *tmp;
1101 	size_t i, dlen;
1102 
1103 	for (i = 0; i < msg->attr_used; i++) {
1104 		tmp = radius_get_attr_hdr(msg, i);
1105 		if (tmp->type == type) {
1106 			attr = tmp;
1107 			break;
1108 		}
1109 	}
1110 
1111 	if (!attr)
1112 		return -1;
1113 
1114 	dlen = attr->length - sizeof(*attr);
1115 	if (buf)
1116 		os_memcpy(buf, (attr + 1), dlen > len ? len : dlen);
1117 	return dlen;
1118 }
1119 
1120 
1121 int radius_msg_get_attr_ptr(struct radius_msg *msg, u8 type, u8 **buf,
1122 			    size_t *len, const u8 *start)
1123 {
1124 	size_t i;
1125 	struct radius_attr_hdr *attr = NULL, *tmp;
1126 
1127 	for (i = 0; i < msg->attr_used; i++) {
1128 		tmp = radius_get_attr_hdr(msg, i);
1129 		if (tmp->type == type &&
1130 		    (start == NULL || (u8 *) tmp > start)) {
1131 			attr = tmp;
1132 			break;
1133 		}
1134 	}
1135 
1136 	if (!attr)
1137 		return -1;
1138 
1139 	*buf = (u8 *) (attr + 1);
1140 	*len = attr->length - sizeof(*attr);
1141 	return 0;
1142 }
1143 
1144 
1145 int radius_msg_count_attr(struct radius_msg *msg, u8 type, int min_len)
1146 {
1147 	size_t i;
1148 	int count;
1149 
1150 	for (count = 0, i = 0; i < msg->attr_used; i++) {
1151 		struct radius_attr_hdr *attr = radius_get_attr_hdr(msg, i);
1152 		if (attr->type == type &&
1153 		    attr->length >= sizeof(struct radius_attr_hdr) + min_len)
1154 			count++;
1155 	}
1156 
1157 	return count;
1158 }
1159 
1160 
1161 struct radius_tunnel_attrs {
1162 	int tag_used;
1163 	int type; /* Tunnel-Type */
1164 	int medium_type; /* Tunnel-Medium-Type */
1165 	int vlanid;
1166 };
1167 
1168 
1169 /**
1170  * radius_msg_get_vlanid - Parse RADIUS attributes for VLAN tunnel information
1171  * @msg: RADIUS message
1172  * Returns: VLAN ID for the first tunnel configuration of -1 if none is found
1173  */
1174 int radius_msg_get_vlanid(struct radius_msg *msg)
1175 {
1176 	struct radius_tunnel_attrs tunnel[RADIUS_TUNNEL_TAGS], *tun;
1177 	size_t i;
1178 	struct radius_attr_hdr *attr = NULL;
1179 	const u8 *data;
1180 	char buf[10];
1181 	size_t dlen;
1182 
1183 	os_memset(&tunnel, 0, sizeof(tunnel));
1184 
1185 	for (i = 0; i < msg->attr_used; i++) {
1186 		attr = radius_get_attr_hdr(msg, i);
1187 		data = (const u8 *) (attr + 1);
1188 		dlen = attr->length - sizeof(*attr);
1189 		if (attr->length < 3)
1190 			continue;
1191 		if (data[0] >= RADIUS_TUNNEL_TAGS)
1192 			tun = &tunnel[0];
1193 		else
1194 			tun = &tunnel[data[0]];
1195 
1196 		switch (attr->type) {
1197 		case RADIUS_ATTR_TUNNEL_TYPE:
1198 			if (attr->length != 6)
1199 				break;
1200 			tun->tag_used++;
1201 			tun->type = WPA_GET_BE24(data + 1);
1202 			break;
1203 		case RADIUS_ATTR_TUNNEL_MEDIUM_TYPE:
1204 			if (attr->length != 6)
1205 				break;
1206 			tun->tag_used++;
1207 			tun->medium_type = WPA_GET_BE24(data + 1);
1208 			break;
1209 		case RADIUS_ATTR_TUNNEL_PRIVATE_GROUP_ID:
1210 			if (data[0] < RADIUS_TUNNEL_TAGS) {
1211 				data++;
1212 				dlen--;
1213 			}
1214 			if (dlen >= sizeof(buf))
1215 				break;
1216 			os_memcpy(buf, data, dlen);
1217 			buf[dlen] = '\0';
1218 			tun->tag_used++;
1219 			tun->vlanid = atoi(buf);
1220 			break;
1221 		}
1222 	}
1223 
1224 	for (i = 0; i < RADIUS_TUNNEL_TAGS; i++) {
1225 		tun = &tunnel[i];
1226 		if (tun->tag_used &&
1227 		    tun->type == RADIUS_TUNNEL_TYPE_VLAN &&
1228 		    tun->medium_type == RADIUS_TUNNEL_MEDIUM_TYPE_802 &&
1229 		    tun->vlanid > 0)
1230 			return tun->vlanid;
1231 	}
1232 
1233 	return -1;
1234 }
1235