Context Navigation

eap.c

Last change on this file was 1, checked in by AlexLir, 3 years ago

File size: 63.1 KB

Line
1	/*
2	* eap.c - Extensible Authentication Protocol for PPP (RFC 2284)
3	*
4	* Copyright (c) 2001 by Sun Microsystems, Inc.
5	* All rights reserved.
6	*
7	* Non-exclusive rights to redistribute, modify, translate, and use
8	* this software in source and binary forms, in whole or in part, is
9	* hereby granted, provided that the above copyright notice is
10	* duplicated in any source form, and that neither the name of the
11	* copyright holder nor the author is used to endorse or promote
12	* products derived from this software.
13	*
14	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
15	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
16	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17	*
18	* Original version by James Carlson
19	*
20	* This implementation of EAP supports MD5-Challenge and SRP-SHA1
21	* authentication styles. Note that support of MD5-Challenge is a
22	* requirement of RFC 2284, and that it's essentially just a
23	* reimplementation of regular RFC 1994 CHAP using EAP messages.
24	*
25	* As an authenticator ("server"), there are multiple phases for each
26	* style. In the first phase of each style, the unauthenticated peer
27	* name is queried using the EAP Identity request type. If the
28	* "remotename" option is used, then this phase is skipped, because
29	* the peer's name is presumed to be known.
30	*
31	* For MD5-Challenge, there are two phases, and the second phase
32	* consists of sending the challenge itself and handling the
33	* associated response.
34	*
35	* For SRP-SHA1, there are four phases. The second sends 's', 'N',
36	* and 'g'. The reply contains 'A'. The third sends 'B', and the
37	* reply contains 'M1'. The forth sends the 'M2' value.
38	*
39	* As an authenticatee ("client"), there's just a single phase --
40	* responding to the queries generated by the peer. EAP is an
41	* authenticator-driven protocol.
42	*
43	* Based on draft-ietf-pppext-eap-srp-03.txt.
44	*/
45
46	#include "netif/ppp/ppp_opts.h"
47	#if PPP_SUPPORT && EAP_SUPPORT /* don't build if not configured for use in lwipopts.h */
48
49	#include "netif/ppp/ppp_impl.h"
50	#include "netif/ppp/eap.h"
51	#include "netif/ppp/magic.h"
52	#include "netif/ppp/pppcrypt.h"
53
54	#ifdef USE_SRP
55	#include <t_pwd.h>
56	#include <t_server.h>
57	#include <t_client.h>
58	#endif /* USE_SRP */
59
60	#ifndef SHA_DIGESTSIZE
61	#define SHA_DIGESTSIZE 20
62	#endif
63
64	#ifdef USE_SRP
65	static char pn_secret = NULL; / Pseudonym generating secret */
66	#endif
67
68	#if PPP_OPTIONS
69	/*
70	* Command-line options.
71	*/
72	static option_t eap_option_list[] = {
73	{ "eap-restart", o_int, &eap_states[0].es_server.ea_timeout,
74	"Set retransmit timeout for EAP Requests (server)" },
75	{ "eap-max-sreq", o_int, &eap_states[0].es_server.ea_maxrequests,
76	"Set max number of EAP Requests sent (server)" },
77	{ "eap-timeout", o_int, &eap_states[0].es_client.ea_timeout,
78	"Set time limit for peer EAP authentication" },
79	{ "eap-max-rreq", o_int, &eap_states[0].es_client.ea_maxrequests,
80	"Set max number of EAP Requests allows (client)" },
81	{ "eap-interval", o_int, &eap_states[0].es_rechallenge,
82	"Set interval for EAP rechallenge" },
83	#ifdef USE_SRP
84	{ "srp-interval", o_int, &eap_states[0].es_lwrechallenge,
85	"Set interval for SRP lightweight rechallenge" },
86	{ "srp-pn-secret", o_string, &pn_secret,
87	"Long term pseudonym generation secret" },
88	{ "srp-use-pseudonym", o_bool, &eap_states[0].es_usepseudo,
89	"Use pseudonym if offered one by server", 1 },
90	#endif
91	{ NULL }
92	};
93	#endif /* PPP_OPTIONS */
94
95	/*
96	* Protocol entry points.
97	*/
98	static void eap_init(ppp_pcb *pcb);
99	static void eap_input(ppp_pcb pcb, u_char inp, int inlen);
100	static void eap_protrej(ppp_pcb *pcb);
101	static void eap_lowerup(ppp_pcb *pcb);
102	static void eap_lowerdown(ppp_pcb *pcb);
103	#if PRINTPKT_SUPPORT
104	static int eap_printpkt(const u_char *inp, int inlen,
105	void ()(void arg, const char fmt, ...), void arg);
106	#endif /* PRINTPKT_SUPPORT */
107
108	const struct protent eap_protent = {
109	PPP_EAP, /* protocol number */
110	eap_init, /* initialization procedure */
111	eap_input, /* process a received packet */
112	eap_protrej, /* process a received protocol-reject */
113	eap_lowerup, /* lower layer has gone up */
114	eap_lowerdown, /* lower layer has gone down */
115	NULL, /* open the protocol */
116	NULL, /* close the protocol */
117	#if PRINTPKT_SUPPORT
118	eap_printpkt, /* print a packet in readable form */
119	#endif /* PRINTPKT_SUPPORT */
120	#if PPP_DATAINPUT
121	NULL, /* process a received data packet */
122	#endif /* PPP_DATAINPUT */
123	#if PRINTPKT_SUPPORT
124	"EAP", /* text name of protocol */
125	NULL, /* text name of corresponding data protocol */
126	#endif /* PRINTPKT_SUPPORT */
127	#if PPP_OPTIONS
128	eap_option_list, /* list of command-line options */
129	NULL, /* check requested options; assign defaults */
130	#endif /* PPP_OPTIONS */
131	#if DEMAND_SUPPORT
132	NULL, /* configure interface for demand-dial */
133	NULL /* say whether to bring up link for this pkt */
134	#endif /* DEMAND_SUPPORT */
135	};
136
137	#ifdef USE_SRP
138	/*
139	* A well-known 2048 bit modulus.
140	*/
141	static const u_char wkmodulus[] = {
142	0xAC, 0x6B, 0xDB, 0x41, 0x32, 0x4A, 0x9A, 0x9B,
143	0xF1, 0x66, 0xDE, 0x5E, 0x13, 0x89, 0x58, 0x2F,
144	0xAF, 0x72, 0xB6, 0x65, 0x19, 0x87, 0xEE, 0x07,
145	0xFC, 0x31, 0x92, 0x94, 0x3D, 0xB5, 0x60, 0x50,
146	0xA3, 0x73, 0x29, 0xCB, 0xB4, 0xA0, 0x99, 0xED,
147	0x81, 0x93, 0xE0, 0x75, 0x77, 0x67, 0xA1, 0x3D,
148	0xD5, 0x23, 0x12, 0xAB, 0x4B, 0x03, 0x31, 0x0D,
149	0xCD, 0x7F, 0x48, 0xA9, 0xDA, 0x04, 0xFD, 0x50,
150	0xE8, 0x08, 0x39, 0x69, 0xED, 0xB7, 0x67, 0xB0,
151	0xCF, 0x60, 0x95, 0x17, 0x9A, 0x16, 0x3A, 0xB3,
152	0x66, 0x1A, 0x05, 0xFB, 0xD5, 0xFA, 0xAA, 0xE8,
153	0x29, 0x18, 0xA9, 0x96, 0x2F, 0x0B, 0x93, 0xB8,
154	0x55, 0xF9, 0x79, 0x93, 0xEC, 0x97, 0x5E, 0xEA,
155	0xA8, 0x0D, 0x74, 0x0A, 0xDB, 0xF4, 0xFF, 0x74,
156	0x73, 0x59, 0xD0, 0x41, 0xD5, 0xC3, 0x3E, 0xA7,
157	0x1D, 0x28, 0x1E, 0x44, 0x6B, 0x14, 0x77, 0x3B,
158	0xCA, 0x97, 0xB4, 0x3A, 0x23, 0xFB, 0x80, 0x16,
159	0x76, 0xBD, 0x20, 0x7A, 0x43, 0x6C, 0x64, 0x81,
160	0xF1, 0xD2, 0xB9, 0x07, 0x87, 0x17, 0x46, 0x1A,
161	0x5B, 0x9D, 0x32, 0xE6, 0x88, 0xF8, 0x77, 0x48,
162	0x54, 0x45, 0x23, 0xB5, 0x24, 0xB0, 0xD5, 0x7D,
163	0x5E, 0xA7, 0x7A, 0x27, 0x75, 0xD2, 0xEC, 0xFA,
164	0x03, 0x2C, 0xFB, 0xDB, 0xF5, 0x2F, 0xB3, 0x78,
165	0x61, 0x60, 0x27, 0x90, 0x04, 0xE5, 0x7A, 0xE6,
166	0xAF, 0x87, 0x4E, 0x73, 0x03, 0xCE, 0x53, 0x29,
167	0x9C, 0xCC, 0x04, 0x1C, 0x7B, 0xC3, 0x08, 0xD8,
168	0x2A, 0x56, 0x98, 0xF3, 0xA8, 0xD0, 0xC3, 0x82,
169	0x71, 0xAE, 0x35, 0xF8, 0xE9, 0xDB, 0xFB, 0xB6,
170	0x94, 0xB5, 0xC8, 0x03, 0xD8, 0x9F, 0x7A, 0xE4,
171	0x35, 0xDE, 0x23, 0x6D, 0x52, 0x5F, 0x54, 0x75,
172	0x9B, 0x65, 0xE3, 0x72, 0xFC, 0xD6, 0x8E, 0xF2,
173	0x0F, 0xA7, 0x11, 0x1F, 0x9E, 0x4A, 0xFF, 0x73
174	};
175	#endif
176
177	#if PPP_SERVER
178	/* Local forward declarations. */
179	static void eap_server_timeout(void *arg);
180	#endif /* PPP_SERVER */
181
182	/*
183	* Convert EAP state code to printable string for debug.
184	*/
185	static const char * eap_state_name(enum eap_state_code esc)
186	{
187	static const char *state_names[] = { EAP_STATES };
188
189	return (state_names[(int)esc]);
190	}
191
192	/*
193	* eap_init - Initialize state for an EAP user. This is currently
194	* called once by main() during start-up.
195	*/
196	static void eap_init(ppp_pcb *pcb) {
197
198	BZERO(&pcb->eap, sizeof(eap_state));
199	#if PPP_SERVER
200	pcb->eap.es_server.ea_id = magic();
201	#endif /* PPP_SERVER */
202	}
203
204	/*
205	* eap_client_timeout - Give up waiting for the peer to send any
206	* Request messages.
207	*/
208	static void eap_client_timeout(void *arg) {
209	ppp_pcb pcb = (ppp_pcb)arg;
210
211	if (!eap_client_active(pcb))
212	return;
213
214	ppp_error("EAP: timeout waiting for Request from peer");
215	auth_withpeer_fail(pcb, PPP_EAP);
216	pcb->eap.es_client.ea_state = eapBadAuth;
217	}
218
219	/*
220	* eap_authwithpeer - Authenticate to our peer (behave as client).
221	*
222	* Start client state and wait for requests. This is called only
223	* after eap_lowerup.
224	*/
225	void eap_authwithpeer(ppp_pcb pcb, const char localname) {
226
227	if(NULL == localname)
228	return;
229
230	/* Save the peer name we're given */
231	pcb->eap.es_client.ea_name = localname;
232	pcb->eap.es_client.ea_namelen = strlen(localname);
233
234	pcb->eap.es_client.ea_state = eapListen;
235
236	/*
237	* Start a timer so that if the other end just goes
238	* silent, we don't sit here waiting forever.
239	*/
240	if (pcb->settings.eap_req_time > 0)
241	TIMEOUT(eap_client_timeout, pcb,
242	pcb->settings.eap_req_time);
243	}
244
245	#if PPP_SERVER
246	/*
247	* Format a standard EAP Failure message and send it to the peer.
248	* (Server operation)
249	*/
250	static void eap_send_failure(ppp_pcb *pcb) {
251	struct pbuf *p;
252	u_char *outp;
253
254	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + EAP_HEADERLEN), PPP_CTRL_PBUF_TYPE);
255	if(NULL == p)
256	return;
257	if(p->tot_len != p->len) {
258	pbuf_free(p);
259	return;
260	}
261
262	outp = (u_char*)p->payload;
263
264	MAKEHEADER(outp, PPP_EAP);
265
266	PUTCHAR(EAP_FAILURE, outp);
267	pcb->eap.es_server.ea_id++;
268	PUTCHAR(pcb->eap.es_server.ea_id, outp);
269	PUTSHORT(EAP_HEADERLEN, outp);
270
271	ppp_write(pcb, p);
272
273	pcb->eap.es_server.ea_state = eapBadAuth;
274	auth_peer_fail(pcb, PPP_EAP);
275	}
276
277	/*
278	* Format a standard EAP Success message and send it to the peer.
279	* (Server operation)
280	*/
281	static void eap_send_success(ppp_pcb *pcb) {
282	struct pbuf *p;
283	u_char *outp;
284
285	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + EAP_HEADERLEN), PPP_CTRL_PBUF_TYPE);
286	if(NULL == p)
287	return;
288	if(p->tot_len != p->len) {
289	pbuf_free(p);
290	return;
291	}
292
293	outp = (u_char*)p->payload;
294
295	MAKEHEADER(outp, PPP_EAP);
296
297	PUTCHAR(EAP_SUCCESS, outp);
298	pcb->eap.es_server.ea_id++;
299	PUTCHAR(pcb->eap.es_server.ea_id, outp);
300	PUTSHORT(EAP_HEADERLEN, outp);
301
302	ppp_write(pcb, p);
303
304	auth_peer_success(pcb, PPP_EAP, 0,
305	pcb->eap.es_server.ea_peer, pcb->eap.es_server.ea_peerlen);
306	}
307	#endif /* PPP_SERVER */
308
309	#ifdef USE_SRP
310	/*
311	* Set DES key according to pseudonym-generating secret and current
312	* date.
313	*/
314	static bool
315	pncrypt_setkey(int timeoffs)
316	{
317	struct tm *tp;
318	char tbuf[9];
319	SHA1_CTX ctxt;
320	u_char dig[SHA_DIGESTSIZE];
321	time_t reftime;
322
323	if (pn_secret == NULL)
324	return (0);
325	reftime = time(NULL) + timeoffs;
326	tp = localtime(&reftime);
327	SHA1Init(&ctxt);
328	SHA1Update(&ctxt, pn_secret, strlen(pn_secret));
329	strftime(tbuf, sizeof (tbuf), "%Y%m%d", tp);
330	SHA1Update(&ctxt, tbuf, strlen(tbuf));
331	SHA1Final(dig, &ctxt);
332	/* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */
333	return (DesSetkey(dig));
334	}
335
336	static char base64[] =
337	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
338
339	struct b64state {
340	u32_t bs_bits;
341	int bs_offs;
342	};
343
344	static int
345	b64enc(bs, inp, inlen, outp)
346	struct b64state *bs;
347	u_char *inp;
348	int inlen;
349	u_char *outp;
350	{
351	int outlen = 0;
352
353	while (inlen > 0) {
354	bs->bs_bits = (bs->bs_bits << 8) \| *inp++;
355	inlen--;
356	bs->bs_offs += 8;
357	if (bs->bs_offs >= 24) {
358	*outp++ = base64[(bs->bs_bits >> 18) & 0x3F];
359	*outp++ = base64[(bs->bs_bits >> 12) & 0x3F];
360	*outp++ = base64[(bs->bs_bits >> 6) & 0x3F];
361	*outp++ = base64[bs->bs_bits & 0x3F];
362	outlen += 4;
363	bs->bs_offs = 0;
364	bs->bs_bits = 0;
365	}
366	}
367	return (outlen);
368	}
369
370	static int
371	b64flush(bs, outp)
372	struct b64state *bs;
373	u_char *outp;
374	{
375	int outlen = 0;
376
377	if (bs->bs_offs == 8) {
378	*outp++ = base64[(bs->bs_bits >> 2) & 0x3F];
379	*outp++ = base64[(bs->bs_bits << 4) & 0x3F];
380	outlen = 2;
381	} else if (bs->bs_offs == 16) {
382	*outp++ = base64[(bs->bs_bits >> 10) & 0x3F];
383	*outp++ = base64[(bs->bs_bits >> 4) & 0x3F];
384	*outp++ = base64[(bs->bs_bits << 2) & 0x3F];
385	outlen = 3;
386	}
387	bs->bs_offs = 0;
388	bs->bs_bits = 0;
389	return (outlen);
390	}
391
392	static int
393	b64dec(bs, inp, inlen, outp)
394	struct b64state *bs;
395	u_char *inp;
396	int inlen;
397	u_char *outp;
398	{
399	int outlen = 0;
400	char *cp;
401
402	while (inlen > 0) {
403	if ((cp = strchr(base64, *inp++)) == NULL)
404	break;
405	bs->bs_bits = (bs->bs_bits << 6) \| (cp - base64);
406	inlen--;
407	bs->bs_offs += 6;
408	if (bs->bs_offs >= 8) {
409	*outp++ = bs->bs_bits >> (bs->bs_offs - 8);
410	outlen++;
411	bs->bs_offs -= 8;
412	}
413	}
414	return (outlen);
415	}
416	#endif /* USE_SRP */
417
418	#if PPP_SERVER
419	/*
420	* Assume that current waiting server state is complete and figure
421	* next state to use based on available authentication data. 'status'
422	* indicates if there was an error in handling the last query. It is
423	* 0 for success and non-zero for failure.
424	*/
425	static void eap_figure_next_state(ppp_pcb *pcb, int status) {
426	#ifdef USE_SRP
427	unsigned char secbuf[MAXSECRETLEN], clear[8], sp, dp;
428	struct t_pw tpw;
429	struct t_confent *tce, mytce;
430	char cp, cp2;
431	struct t_server *ts;
432	int id, i, plen, toffs;
433	u_char vals[2];
434	struct b64state bs;
435	#endif /* USE_SRP */
436
437	pcb->settings.eap_timeout_time = pcb->eap.es_savedtime;
438	switch (pcb->eap.es_server.ea_state) {
439	case eapBadAuth:
440	return;
441
442	case eapIdentify:
443	#ifdef USE_SRP
444	/* Discard any previous session. */
445	ts = (struct t_server *)pcb->eap.es_server.ea_session;
446	if (ts != NULL) {
447	t_serverclose(ts);
448	pcb->eap.es_server.ea_session = NULL;
449	pcb->eap.es_server.ea_skey = NULL;
450	}
451	#endif /* USE_SRP */
452	if (status != 0) {
453	pcb->eap.es_server.ea_state = eapBadAuth;
454	break;
455	}
456	#ifdef USE_SRP
457	/* If we've got a pseudonym, try to decode to real name. */
458	if (pcb->eap.es_server.ea_peerlen > SRP_PSEUDO_LEN &&
459	strncmp(pcb->eap.es_server.ea_peer, SRP_PSEUDO_ID,
460	SRP_PSEUDO_LEN) == 0 &&
461	(pcb->eap.es_server.ea_peerlen - SRP_PSEUDO_LEN) * 3 / 4 <
462	sizeof (secbuf)) {
463	BZERO(&bs, sizeof (bs));
464	plen = b64dec(&bs,
465	pcb->eap.es_server.ea_peer + SRP_PSEUDO_LEN,
466	pcb->eap.es_server.ea_peerlen - SRP_PSEUDO_LEN,
467	secbuf);
468	toffs = 0;
469	for (i = 0; i < 5; i++) {
470	pncrypt_setkey(toffs);
471	toffs -= 86400;
472	/* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */
473	if (!DesDecrypt(secbuf, clear)) {
474	ppp_dbglog("no DES here; cannot decode "
475	"pseudonym");
476	return;
477	}
478	id = (unsigned char )clear;
479	if (id + 1 <= plen && id + 9 > plen)
480	break;
481	}
482	if (plen % 8 == 0 && i < 5) {
483	/*
484	* Note that this is always shorter than the
485	* original stored string, so there's no need
486	* to realloc.
487	*/
488	if ((i = plen = (unsigned char )clear) > 7)
489	i = 7;
490	pcb->eap.es_server.ea_peerlen = plen;
491	dp = (unsigned char *)pcb->eap.es_server.ea_peer;
492	MEMCPY(dp, clear + 1, i);
493	plen -= i;
494	dp += i;
495	sp = secbuf + 8;
496	while (plen > 0) {
497	/* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */
498	(void) DesDecrypt(sp, dp);
499	sp += 8;
500	dp += 8;
501	plen -= 8;
502	}
503	pcb->eap.es_server.ea_peer[
504	pcb->eap.es_server.ea_peerlen] = '\0';
505	ppp_dbglog("decoded pseudonym to \"%.*q\"",
506	pcb->eap.es_server.ea_peerlen,
507	pcb->eap.es_server.ea_peer);
508	} else {
509	ppp_dbglog("failed to decode real name");
510	/* Stay in eapIdentfy state; requery */
511	break;
512	}
513	}
514	/* Look up user in secrets database. */
515	if (get_srp_secret(pcb->eap.es_unit, pcb->eap.es_server.ea_peer,
516	pcb->eap.es_server.ea_name, (char *)secbuf, 1) != 0) {
517	/* Set up default in case SRP entry is bad */
518	pcb->eap.es_server.ea_state = eapMD5Chall;
519	/* Get t_confent based on index in srp-secrets */
520	id = strtol((char *)secbuf, &cp, 10);
521	if (*cp++ != ':' \|\| id < 0)
522	break;
523	if (id == 0) {
524	mytce.index = 0;
525	mytce.modulus.data = (u_char *)wkmodulus;
526	mytce.modulus.len = sizeof (wkmodulus);
527	mytce.generator.data = (u_char *)"\002";
528	mytce.generator.len = 1;
529	tce = &mytce;
530	} else if ((tce = gettcid(id)) != NULL) {
531	/*
532	* Client will have to verify this modulus/
533	* generator combination, and that will take
534	* a while. Lengthen the timeout here.
535	*/
536	if (pcb->settings.eap_timeout_time > 0 &&
537	pcb->settings.eap_timeout_time < 30)
538	pcb->settings.eap_timeout_time = 30;
539	} else {
540	break;
541	}
542	if ((cp2 = strchr(cp, ':')) == NULL)
543	break;
544	*cp2++ = '\0';
545	tpw.pebuf.name = pcb->eap.es_server.ea_peer;
546	tpw.pebuf.password.len = t_fromb64((char *)tpw.pwbuf,
547	cp);
548	tpw.pebuf.password.data = tpw.pwbuf;
549	tpw.pebuf.salt.len = t_fromb64((char *)tpw.saltbuf,
550	cp2);
551	tpw.pebuf.salt.data = tpw.saltbuf;
552	if ((ts = t_serveropenraw(&tpw.pebuf, tce)) == NULL)
553	break;
554	pcb->eap.es_server.ea_session = (void *)ts;
555	pcb->eap.es_server.ea_state = eapSRP1;
556	vals[0] = pcb->eap.es_server.ea_id + 1;
557	vals[1] = EAPT_SRP;
558	t_serveraddexdata(ts, vals, 2);
559	/* Generate B; must call before t_servergetkey() */
560	t_servergenexp(ts);
561	break;
562	}
563	#endif /* USE_SRP */
564	pcb->eap.es_server.ea_state = eapMD5Chall;
565	break;
566
567	case eapSRP1:
568	#ifdef USE_SRP
569	ts = (struct t_server *)pcb->eap.es_server.ea_session;
570	if (ts != NULL && status != 0) {
571	t_serverclose(ts);
572	pcb->eap.es_server.ea_session = NULL;
573	pcb->eap.es_server.ea_skey = NULL;
574	}
575	#endif /* USE_SRP */
576	if (status == 1) {
577	pcb->eap.es_server.ea_state = eapMD5Chall;
578	} else if (status != 0 \|\| pcb->eap.es_server.ea_session == NULL) {
579	pcb->eap.es_server.ea_state = eapBadAuth;
580	} else {
581	pcb->eap.es_server.ea_state = eapSRP2;
582	}
583	break;
584
585	case eapSRP2:
586	#ifdef USE_SRP
587	ts = (struct t_server *)pcb->eap.es_server.ea_session;
588	if (ts != NULL && status != 0) {
589	t_serverclose(ts);
590	pcb->eap.es_server.ea_session = NULL;
591	pcb->eap.es_server.ea_skey = NULL;
592	}
593	#endif /* USE_SRP */
594	if (status != 0 \|\| pcb->eap.es_server.ea_session == NULL) {
595	pcb->eap.es_server.ea_state = eapBadAuth;
596	} else {
597	pcb->eap.es_server.ea_state = eapSRP3;
598	}
599	break;
600
601	case eapSRP3:
602	case eapSRP4:
603	#ifdef USE_SRP
604	ts = (struct t_server *)pcb->eap.es_server.ea_session;
605	if (ts != NULL && status != 0) {
606	t_serverclose(ts);
607	pcb->eap.es_server.ea_session = NULL;
608	pcb->eap.es_server.ea_skey = NULL;
609	}
610	#endif /* USE_SRP */
611	if (status != 0 \|\| pcb->eap.es_server.ea_session == NULL) {
612	pcb->eap.es_server.ea_state = eapBadAuth;
613	} else {
614	pcb->eap.es_server.ea_state = eapOpen;
615	}
616	break;
617
618	case eapMD5Chall:
619	if (status != 0) {
620	pcb->eap.es_server.ea_state = eapBadAuth;
621	} else {
622	pcb->eap.es_server.ea_state = eapOpen;
623	}
624	break;
625
626	default:
627	pcb->eap.es_server.ea_state = eapBadAuth;
628	break;
629	}
630	if (pcb->eap.es_server.ea_state == eapBadAuth)
631	eap_send_failure(pcb);
632	}
633
634	/*
635	* Format an EAP Request message and send it to the peer. Message
636	* type depends on current state. (Server operation)
637	*/
638	static void eap_send_request(ppp_pcb *pcb) {
639	struct pbuf *p;
640	u_char *outp;
641	u_char *lenloc;
642	int outlen;
643	int len;
644	const char *str;
645	#ifdef USE_SRP
646	struct t_server *ts;
647	u_char clear[8], cipher[8], dig[SHA_DIGESTSIZE], optr, cp;
648	int i, j;
649	struct b64state b64;
650	SHA1_CTX ctxt;
651	#endif /* USE_SRP */
652
653	/* Handle both initial auth and restart */
654	if (pcb->eap.es_server.ea_state < eapIdentify &&
655	pcb->eap.es_server.ea_state != eapInitial) {
656	pcb->eap.es_server.ea_state = eapIdentify;
657	#if PPP_REMOTENAME
658	if (pcb->settings.explicit_remote && pcb->remote_name) {
659	/*
660	* If we already know the peer's
661	* unauthenticated name, then there's no
662	* reason to ask. Go to next state instead.
663	*/
664	int len = (int)strlen(pcb->remote_name);
665	if (len > MAXNAMELEN) {
666	len = MAXNAMELEN;
667	}
668	MEMCPY(pcb->eap.es_server.ea_peer, pcb->remote_name, len);
669	pcb->eap.es_server.ea_peer[len] = '\0';
670	pcb->eap.es_server.ea_peerlen = len;
671	eap_figure_next_state(pcb, 0);
672	}
673	#endif /* PPP_REMOTENAME */
674	}
675
676	if (pcb->settings.eap_max_transmits > 0 &&
677	pcb->eap.es_server.ea_requests >= pcb->settings.eap_max_transmits) {
678	if (pcb->eap.es_server.ea_responses > 0)
679	ppp_error("EAP: too many Requests sent");
680	else
681	ppp_error("EAP: no response to Requests");
682	eap_send_failure(pcb);
683	return;
684	}
685
686	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_CTRL_PBUF_MAX_SIZE), PPP_CTRL_PBUF_TYPE);
687	if(NULL == p)
688	return;
689	if(p->tot_len != p->len) {
690	pbuf_free(p);
691	return;
692	}
693
694	outp = (u_char*)p->payload;
695
696	MAKEHEADER(outp, PPP_EAP);
697
698	PUTCHAR(EAP_REQUEST, outp);
699	PUTCHAR(pcb->eap.es_server.ea_id, outp);
700	lenloc = outp;
701	INCPTR(2, outp);
702
703	switch (pcb->eap.es_server.ea_state) {
704	case eapIdentify:
705	PUTCHAR(EAPT_IDENTITY, outp);
706	str = "Name";
707	len = strlen(str);
708	MEMCPY(outp, str, len);
709	INCPTR(len, outp);
710	break;
711
712	case eapMD5Chall:
713	PUTCHAR(EAPT_MD5CHAP, outp);
714	/*
715	* pick a random challenge length between
716	* EAP_MIN_CHALLENGE_LENGTH and EAP_MAX_CHALLENGE_LENGTH
717	*/
718	pcb->eap.es_challen = EAP_MIN_CHALLENGE_LENGTH +
719	magic_pow(EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH);
720	PUTCHAR(pcb->eap.es_challen, outp);
721	magic_random_bytes(pcb->eap.es_challenge, pcb->eap.es_challen);
722	MEMCPY(outp, pcb->eap.es_challenge, pcb->eap.es_challen);
723	INCPTR(pcb->eap.es_challen, outp);
724	MEMCPY(outp, pcb->eap.es_server.ea_name, pcb->eap.es_server.ea_namelen);
725	INCPTR(pcb->eap.es_server.ea_namelen, outp);
726	break;
727
728	#ifdef USE_SRP
729	case eapSRP1:
730	PUTCHAR(EAPT_SRP, outp);
731	PUTCHAR(EAPSRP_CHALLENGE, outp);
732
733	PUTCHAR(pcb->eap.es_server.ea_namelen, outp);
734	MEMCPY(outp, pcb->eap.es_server.ea_name, pcb->eap.es_server.ea_namelen);
735	INCPTR(pcb->eap.es_server.ea_namelen, outp);
736
737	ts = (struct t_server *)pcb->eap.es_server.ea_session;
738	assert(ts != NULL);
739	PUTCHAR(ts->s.len, outp);
740	MEMCPY(outp, ts->s.data, ts->s.len);
741	INCPTR(ts->s.len, outp);
742
743	if (ts->g.len == 1 && ts->g.data[0] == 2) {
744	PUTCHAR(0, outp);
745	} else {
746	PUTCHAR(ts->g.len, outp);
747	MEMCPY(outp, ts->g.data, ts->g.len);
748	INCPTR(ts->g.len, outp);
749	}
750
751	if (ts->n.len != sizeof (wkmodulus) \|\|
752	BCMP(ts->n.data, wkmodulus, sizeof (wkmodulus)) != 0) {
753	MEMCPY(outp, ts->n.data, ts->n.len);
754	INCPTR(ts->n.len, outp);
755	}
756	break;
757
758	case eapSRP2:
759	PUTCHAR(EAPT_SRP, outp);
760	PUTCHAR(EAPSRP_SKEY, outp);
761
762	ts = (struct t_server *)pcb->eap.es_server.ea_session;
763	assert(ts != NULL);
764	MEMCPY(outp, ts->B.data, ts->B.len);
765	INCPTR(ts->B.len, outp);
766	break;
767
768	case eapSRP3:
769	PUTCHAR(EAPT_SRP, outp);
770	PUTCHAR(EAPSRP_SVALIDATOR, outp);
771	PUTLONG(SRPVAL_EBIT, outp);
772	ts = (struct t_server *)pcb->eap.es_server.ea_session;
773	assert(ts != NULL);
774	MEMCPY(outp, t_serverresponse(ts), SHA_DIGESTSIZE);
775	INCPTR(SHA_DIGESTSIZE, outp);
776
777	if (pncrypt_setkey(0)) {
778	/* Generate pseudonym */
779	optr = outp;
780	cp = (unsigned char *)pcb->eap.es_server.ea_peer;
781	if ((j = i = pcb->eap.es_server.ea_peerlen) > 7)
782	j = 7;
783	clear[0] = i;
784	MEMCPY(clear + 1, cp, j);
785	i -= j;
786	cp += j;
787	/* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */
788	if (!DesEncrypt(clear, cipher)) {
789	ppp_dbglog("no DES here; not generating pseudonym");
790	break;
791	}
792	BZERO(&b64, sizeof (b64));
793	outp++; /* space for pseudonym length */
794	outp += b64enc(&b64, cipher, 8, outp);
795	while (i >= 8) {
796	/* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */
797	(void) DesEncrypt(cp, cipher);
798	outp += b64enc(&b64, cipher, 8, outp);
799	cp += 8;
800	i -= 8;
801	}
802	if (i > 0) {
803	MEMCPY(clear, cp, i);
804	cp += i;
805	magic_random_bytes(cp, 8-i);
806	/* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */
807	(void) DesEncrypt(clear, cipher);
808	outp += b64enc(&b64, cipher, 8, outp);
809	}
810	outp += b64flush(&b64, outp);
811
812	/* Set length and pad out to next 20 octet boundary */
813	i = outp - optr - 1;
814	*optr = i;
815	i %= SHA_DIGESTSIZE;
816	if (i != 0) {
817	magic_random_bytes(outp, SHA_DIGESTSIZE-i);
818	INCPTR(SHA_DIGESTSIZE-i, outp);
819	}
820
821	/* Obscure the pseudonym with SHA1 hash */
822	SHA1Init(&ctxt);
823	SHA1Update(&ctxt, &pcb->eap.es_server.ea_id, 1);
824	SHA1Update(&ctxt, pcb->eap.es_server.ea_skey,
825	SESSION_KEY_LEN);
826	SHA1Update(&ctxt, pcb->eap.es_server.ea_peer,
827	pcb->eap.es_server.ea_peerlen);
828	while (optr < outp) {
829	SHA1Final(dig, &ctxt);
830	cp = dig;
831	while (cp < dig + SHA_DIGESTSIZE)
832	optr++ ^= cp++;
833	SHA1Init(&ctxt);
834	SHA1Update(&ctxt, &pcb->eap.es_server.ea_id, 1);
835	SHA1Update(&ctxt, pcb->eap.es_server.ea_skey,
836	SESSION_KEY_LEN);
837	SHA1Update(&ctxt, optr - SHA_DIGESTSIZE,
838	SHA_DIGESTSIZE);
839	}
840	}
841	break;
842
843	case eapSRP4:
844	PUTCHAR(EAPT_SRP, outp);
845	PUTCHAR(EAPSRP_LWRECHALLENGE, outp);
846	pcb->eap.es_challen = EAP_MIN_CHALLENGE_LENGTH +
847	magic_pow(EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH);
848	magic_random_bytes(pcb->eap.es_challenge, pcb->eap.es_challen);
849	MEMCPY(outp, pcb->eap.es_challenge, pcb->eap.es_challen);
850	INCPTR(pcb->eap.es_challen, outp);
851	break;
852	#endif /* USE_SRP */
853
854	default:
855	return;
856	}
857
858	outlen = (outp - (unsigned char*)p->payload) - PPP_HDRLEN;
859	PUTSHORT(outlen, lenloc);
860
861	pbuf_realloc(p, outlen + PPP_HDRLEN);
862	ppp_write(pcb, p);
863
864	pcb->eap.es_server.ea_requests++;
865
866	if (pcb->settings.eap_timeout_time > 0)
867	TIMEOUT(eap_server_timeout, pcb, pcb->settings.eap_timeout_time);
868	}
869
870	/*
871	* eap_authpeer - Authenticate our peer (behave as server).
872	*
873	* Start server state and send first request. This is called only
874	* after eap_lowerup.
875	*/
876	void eap_authpeer(ppp_pcb pcb, const char localname) {
877
878	/* Save the name we're given. */
879	pcb->eap.es_server.ea_name = localname;
880	pcb->eap.es_server.ea_namelen = strlen(localname);
881
882	pcb->eap.es_savedtime = pcb->settings.eap_timeout_time;
883
884	/* Lower layer up yet? */
885	if (pcb->eap.es_server.ea_state == eapInitial \|\|
886	pcb->eap.es_server.ea_state == eapPending) {
887	pcb->eap.es_server.ea_state = eapPending;
888	return;
889	}
890
891	pcb->eap.es_server.ea_state = eapPending;
892
893	/* ID number not updated here intentionally; hashed into M1 */
894	eap_send_request(pcb);
895	}
896
897	/*
898	* eap_server_timeout - Retransmission timer for sending Requests
899	* expired.
900	*/
901	static void eap_server_timeout(void *arg) {
902	ppp_pcb pcb = (ppp_pcb)arg;
903
904	if (!eap_server_active(pcb))
905	return;
906
907	/* EAP ID number must not change on timeout. */
908	eap_send_request(pcb);
909	}
910
911	/*
912	* When it's time to send rechallenge the peer, this timeout is
913	* called. Once the rechallenge is successful, the response handler
914	* will restart the timer. If it fails, then the link is dropped.
915	*/
916	static void eap_rechallenge(void *arg) {
917	ppp_pcb pcb = (ppp_pcb)arg;
918
919	if (pcb->eap.es_server.ea_state != eapOpen &&
920	pcb->eap.es_server.ea_state != eapSRP4)
921	return;
922
923	pcb->eap.es_server.ea_requests = 0;
924	pcb->eap.es_server.ea_state = eapIdentify;
925	eap_figure_next_state(pcb, 0);
926	pcb->eap.es_server.ea_id++;
927	eap_send_request(pcb);
928	}
929
930	static void srp_lwrechallenge(void *arg) {
931	ppp_pcb pcb = (ppp_pcb)arg;
932
933	if (pcb->eap.es_server.ea_state != eapOpen \|\|
934	pcb->eap.es_server.ea_type != EAPT_SRP)
935	return;
936
937	pcb->eap.es_server.ea_requests = 0;
938	pcb->eap.es_server.ea_state = eapSRP4;
939	pcb->eap.es_server.ea_id++;
940	eap_send_request(pcb);
941	}
942	#endif /* PPP_SERVER */
943
944	/*
945	* eap_lowerup - The lower layer is now up.
946	*
947	* This is called before either eap_authpeer or eap_authwithpeer. See
948	* link_established() in auth.c. All that's necessary here is to
949	* return to closed state so that those two routines will do the right
950	* thing.
951	*/
952	static void eap_lowerup(ppp_pcb *pcb) {
953	pcb->eap.es_client.ea_state = eapClosed;
954	#if PPP_SERVER
955	pcb->eap.es_server.ea_state = eapClosed;
956	#endif /* PPP_SERVER */
957	}
958
959	/*
960	* eap_lowerdown - The lower layer is now down.
961	*
962	* Cancel all timeouts and return to initial state.
963	*/
964	static void eap_lowerdown(ppp_pcb *pcb) {
965
966	if (eap_client_active(pcb) && pcb->settings.eap_req_time > 0) {
967	UNTIMEOUT(eap_client_timeout, pcb);
968	}
969	#if PPP_SERVER
970	if (eap_server_active(pcb)) {
971	if (pcb->settings.eap_timeout_time > 0) {
972	UNTIMEOUT(eap_server_timeout, pcb);
973	}
974	} else {
975	if ((pcb->eap.es_server.ea_state == eapOpen \|\|
976	pcb->eap.es_server.ea_state == eapSRP4) &&
977	pcb->eap.es_rechallenge > 0) {
978	UNTIMEOUT(eap_rechallenge, (void *)pcb);
979	}
980	if (pcb->eap.es_server.ea_state == eapOpen &&
981	pcb->eap.es_lwrechallenge > 0) {
982	UNTIMEOUT(srp_lwrechallenge, (void *)pcb);
983	}
984	}
985
986	pcb->eap.es_client.ea_state = pcb->eap.es_server.ea_state = eapInitial;
987	pcb->eap.es_client.ea_requests = pcb->eap.es_server.ea_requests = 0;
988	#endif /* PPP_SERVER */
989	}
990
991	/*
992	* eap_protrej - Peer doesn't speak this protocol.
993	*
994	* This shouldn't happen. If it does, it represents authentication
995	* failure.
996	*/
997	static void eap_protrej(ppp_pcb *pcb) {
998
999	if (eap_client_active(pcb)) {
1000	ppp_error("EAP authentication failed due to Protocol-Reject");
1001	auth_withpeer_fail(pcb, PPP_EAP);
1002	}
1003	#if PPP_SERVER
1004	if (eap_server_active(pcb)) {
1005	ppp_error("EAP authentication of peer failed on Protocol-Reject");
1006	auth_peer_fail(pcb, PPP_EAP);
1007	}
1008	#endif /* PPP_SERVER */
1009	eap_lowerdown(pcb);
1010	}
1011
1012	/*
1013	* Format and send a regular EAP Response message.
1014	*/
1015	static void eap_send_response(ppp_pcb pcb, u_char id, u_char typenum, const u_char str, int lenstr) {
1016	struct pbuf *p;
1017	u_char *outp;
1018	int msglen;
1019
1020	msglen = EAP_HEADERLEN + sizeof (u_char) + lenstr;
1021	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE);
1022	if(NULL == p)
1023	return;
1024	if(p->tot_len != p->len) {
1025	pbuf_free(p);
1026	return;
1027	}
1028
1029	outp = (u_char*)p->payload;
1030
1031	MAKEHEADER(outp, PPP_EAP);
1032
1033	PUTCHAR(EAP_RESPONSE, outp);
1034	PUTCHAR(id, outp);
1035	pcb->eap.es_client.ea_id = id;
1036	PUTSHORT(msglen, outp);
1037	PUTCHAR(typenum, outp);
1038	if (lenstr > 0) {
1039	MEMCPY(outp, str, lenstr);
1040	}
1041
1042	ppp_write(pcb, p);
1043	}
1044
1045	/*
1046	* Format and send an MD5-Challenge EAP Response message.
1047	*/
1048	static void eap_chap_response(ppp_pcb pcb, u_char id, u_char hash, const char *name, int namelen) {
1049	struct pbuf *p;
1050	u_char *outp;
1051	int msglen;
1052
1053	msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + MD5_SIGNATURE_SIZE +
1054	namelen;
1055	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE);
1056	if(NULL == p)
1057	return;
1058	if(p->tot_len != p->len) {
1059	pbuf_free(p);
1060	return;
1061	}
1062
1063	outp = (u_char*)p->payload;
1064
1065	MAKEHEADER(outp, PPP_EAP);
1066
1067	PUTCHAR(EAP_RESPONSE, outp);
1068	PUTCHAR(id, outp);
1069	pcb->eap.es_client.ea_id = id;
1070	PUTSHORT(msglen, outp);
1071	PUTCHAR(EAPT_MD5CHAP, outp);
1072	PUTCHAR(MD5_SIGNATURE_SIZE, outp);
1073	MEMCPY(outp, hash, MD5_SIGNATURE_SIZE);
1074	INCPTR(MD5_SIGNATURE_SIZE, outp);
1075	if (namelen > 0) {
1076	MEMCPY(outp, name, namelen);
1077	}
1078
1079	ppp_write(pcb, p);
1080	}
1081
1082	#ifdef USE_SRP
1083	/*
1084	* Format and send a SRP EAP Response message.
1085	*/
1086	static void
1087	eap_srp_response(esp, id, subtypenum, str, lenstr)
1088	eap_state *esp;
1089	u_char id;
1090	u_char subtypenum;
1091	u_char *str;
1092	int lenstr;
1093	{
1094	ppp_pcb *pcb = &ppp_pcb_list[pcb->eap.es_unit];
1095	struct pbuf *p;
1096	u_char *outp;
1097	int msglen;
1098
1099	msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + lenstr;
1100	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE);
1101	if(NULL == p)
1102	return;
1103	if(p->tot_len != p->len) {
1104	pbuf_free(p);
1105	return;
1106	}
1107
1108	outp = p->payload;
1109
1110	MAKEHEADER(outp, PPP_EAP);
1111
1112	PUTCHAR(EAP_RESPONSE, outp);
1113	PUTCHAR(id, outp);
1114	pcb->eap.es_client.ea_id = id;
1115	PUTSHORT(msglen, outp);
1116	PUTCHAR(EAPT_SRP, outp);
1117	PUTCHAR(subtypenum, outp);
1118	if (lenstr > 0) {
1119	MEMCPY(outp, str, lenstr);
1120	}
1121
1122	ppp_write(pcb, p);
1123	}
1124
1125	/*
1126	* Format and send a SRP EAP Client Validator Response message.
1127	*/
1128	static void
1129	eap_srpval_response(esp, id, flags, str)
1130	eap_state *esp;
1131	u_char id;
1132	u32_t flags;
1133	u_char *str;
1134	{
1135	ppp_pcb *pcb = &ppp_pcb_list[pcb->eap.es_unit];
1136	struct pbuf *p;
1137	u_char *outp;
1138	int msglen;
1139
1140	msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + sizeof (u32_t) +
1141	SHA_DIGESTSIZE;
1142	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE);
1143	if(NULL == p)
1144	return;
1145	if(p->tot_len != p->len) {
1146	pbuf_free(p);
1147	return;
1148	}
1149
1150	outp = p->payload;
1151
1152	MAKEHEADER(outp, PPP_EAP);
1153
1154	PUTCHAR(EAP_RESPONSE, outp);
1155	PUTCHAR(id, outp);
1156	pcb->eap.es_client.ea_id = id;
1157	PUTSHORT(msglen, outp);
1158	PUTCHAR(EAPT_SRP, outp);
1159	PUTCHAR(EAPSRP_CVALIDATOR, outp);
1160	PUTLONG(flags, outp);
1161	MEMCPY(outp, str, SHA_DIGESTSIZE);
1162
1163	ppp_write(pcb, p);
1164	}
1165	#endif /* USE_SRP */
1166
1167	static void eap_send_nak(ppp_pcb *pcb, u_char id, u_char type) {
1168	struct pbuf *p;
1169	u_char *outp;
1170	int msglen;
1171
1172	msglen = EAP_HEADERLEN + 2 * sizeof (u_char);
1173	p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE);
1174	if(NULL == p)
1175	return;
1176	if(p->tot_len != p->len) {
1177	pbuf_free(p);
1178	return;
1179	}
1180
1181	outp = (u_char*)p->payload;
1182
1183	MAKEHEADER(outp, PPP_EAP);
1184
1185	PUTCHAR(EAP_RESPONSE, outp);
1186	PUTCHAR(id, outp);
1187	pcb->eap.es_client.ea_id = id;
1188	PUTSHORT(msglen, outp);
1189	PUTCHAR(EAPT_NAK, outp);
1190	PUTCHAR(type, outp);
1191
1192	ppp_write(pcb, p);
1193	}
1194
1195	#ifdef USE_SRP
1196	static char *
1197	name_of_pn_file()
1198	{
1199	char user, path, *file;
1200	struct passwd *pw;
1201	size_t pl;
1202	static bool pnlogged = 0;
1203
1204	pw = getpwuid(getuid());
1205	if (pw == NULL \|\| (user = pw->pw_dir) == NULL \|\| user[0] == 0) {
1206	errno = EINVAL;
1207	return (NULL);
1208	}
1209	file = _PATH_PSEUDONYM;
1210	pl = strlen(user) + strlen(file) + 2;
1211	path = malloc(pl);
1212	if (path == NULL)
1213	return (NULL);
1214	(void) slprintf(path, pl, "%s/%s", user, file);
1215	if (!pnlogged) {
1216	ppp_dbglog("pseudonym file: %s", path);
1217	pnlogged = 1;
1218	}
1219	return (path);
1220	}
1221
1222	static int
1223	open_pn_file(modebits)
1224	mode_t modebits;
1225	{
1226	char *path;
1227	int fd, err;
1228
1229	if ((path = name_of_pn_file()) == NULL)
1230	return (-1);
1231	fd = open(path, modebits, S_IRUSR \| S_IWUSR);
1232	err = errno;
1233	free(path);
1234	errno = err;
1235	return (fd);
1236	}
1237
1238	static void
1239	remove_pn_file()
1240	{
1241	char *path;
1242
1243	if ((path = name_of_pn_file()) != NULL) {
1244	(void) unlink(path);
1245	(void) free(path);
1246	}
1247	}
1248
1249	static void
1250	write_pseudonym(esp, inp, len, id)
1251	eap_state *esp;
1252	u_char *inp;
1253	int len, id;
1254	{
1255	u_char val;
1256	u_char datp, digp;
1257	SHA1_CTX ctxt;
1258	u_char dig[SHA_DIGESTSIZE];
1259	int dsize, fd, olen = len;
1260
1261	/*
1262	* Do the decoding by working backwards. This eliminates the need
1263	* to save the decoded output in a separate buffer.
1264	*/
1265	val = id;
1266	while (len > 0) {
1267	if ((dsize = len % SHA_DIGESTSIZE) == 0)
1268	dsize = SHA_DIGESTSIZE;
1269	len -= dsize;
1270	datp = inp + len;
1271	SHA1Init(&ctxt);
1272	SHA1Update(&ctxt, &val, 1);
1273	SHA1Update(&ctxt, pcb->eap.es_client.ea_skey, SESSION_KEY_LEN);
1274	if (len > 0) {
1275	SHA1Update(&ctxt, datp, SHA_DIGESTSIZE);
1276	} else {
1277	SHA1Update(&ctxt, pcb->eap.es_client.ea_name,
1278	pcb->eap.es_client.ea_namelen);
1279	}
1280	SHA1Final(dig, &ctxt);
1281	for (digp = dig; digp < dig + SHA_DIGESTSIZE; digp++)
1282	datp++ ^= digp;
1283	}
1284
1285	/* Now check that the result is sane */
1286	if (olen <= 0 \|\| *inp + 1 > olen) {
1287	ppp_dbglog("EAP: decoded pseudonym is unusable <%.*B>", olen, inp);
1288	return;
1289	}
1290
1291	/* Save it away */
1292	fd = open_pn_file(O_WRONLY \| O_CREAT \| O_TRUNC);
1293	if (fd < 0) {
1294	ppp_dbglog("EAP: error saving pseudonym: %m");
1295	return;
1296	}
1297	len = write(fd, inp + 1, *inp);
1298	if (close(fd) != -1 && len == *inp) {
1299	ppp_dbglog("EAP: saved pseudonym");
1300	pcb->eap.es_usedpseudo = 0;
1301	} else {
1302	ppp_dbglog("EAP: failed to save pseudonym");
1303	remove_pn_file();
1304	}
1305	}
1306	#endif /* USE_SRP */
1307
1308	/*
1309	* eap_request - Receive EAP Request message (client mode).
1310	*/
1311	static void eap_request(ppp_pcb pcb, u_char inp, int id, int len) {
1312	u_char typenum;
1313	u_char vallen;
1314	int secret_len;
1315	char secret[MAXSECRETLEN];
1316	char rhostname[MAXNAMELEN];
1317	lwip_md5_context mdContext;
1318	u_char hash[MD5_SIGNATURE_SIZE];
1319	#ifdef USE_SRP
1320	struct t_client *tc;
1321	struct t_num sval, gval, Nval, *Ap, Bval;
1322	u_char vals[2];
1323	SHA1_CTX ctxt;
1324	u_char dig[SHA_DIGESTSIZE];
1325	int fd;
1326	#endif /* USE_SRP */
1327
1328	/*
1329	* Note: we update es_client.ea_id only if a Response
1330	* message is being generated. Otherwise, we leave it the
1331	* same for duplicate detection purposes.
1332	*/
1333
1334	pcb->eap.es_client.ea_requests++;
1335	if (pcb->settings.eap_allow_req != 0 &&
1336	pcb->eap.es_client.ea_requests > pcb->settings.eap_allow_req) {
1337	ppp_info("EAP: received too many Request messages");
1338	if (pcb->settings.eap_req_time > 0) {
1339	UNTIMEOUT(eap_client_timeout, pcb);
1340	}
1341	auth_withpeer_fail(pcb, PPP_EAP);
1342	return;
1343	}
1344
1345	if (len <= 0) {
1346	ppp_error("EAP: empty Request message discarded");
1347	return;
1348	}
1349
1350	GETCHAR(typenum, inp);
1351	len--;
1352
1353	switch (typenum) {
1354	case EAPT_IDENTITY:
1355	if (len > 0)
1356	ppp_info("EAP: Identity prompt \"%.*q\"", len, inp);
1357	#ifdef USE_SRP
1358	if (pcb->eap.es_usepseudo &&
1359	(pcb->eap.es_usedpseudo == 0 \|\|
1360	(pcb->eap.es_usedpseudo == 1 &&
1361	id == pcb->eap.es_client.ea_id))) {
1362	pcb->eap.es_usedpseudo = 1;
1363	/* Try to get a pseudonym */
1364	if ((fd = open_pn_file(O_RDONLY)) >= 0) {
1365	strcpy(rhostname, SRP_PSEUDO_ID);
1366	len = read(fd, rhostname + SRP_PSEUDO_LEN,
1367	sizeof (rhostname) - SRP_PSEUDO_LEN);
1368	/* XXX NAI unsupported */
1369	if (len > 0) {
1370	eap_send_response(pcb, id, typenum,
1371	rhostname, len + SRP_PSEUDO_LEN);
1372	}
1373	(void) close(fd);
1374	if (len > 0)
1375	break;
1376	}
1377	}
1378	/* Stop using pseudonym now. */
1379	if (pcb->eap.es_usepseudo && pcb->eap.es_usedpseudo != 2) {
1380	remove_pn_file();
1381	pcb->eap.es_usedpseudo = 2;
1382	}
1383	#endif /* USE_SRP */
1384	eap_send_response(pcb, id, typenum, (const u_char*)pcb->eap.es_client.ea_name,
1385	pcb->eap.es_client.ea_namelen);
1386	break;
1387
1388	case EAPT_NOTIFICATION:
1389	if (len > 0)
1390	ppp_info("EAP: Notification \"%.*q\"", len, inp);
1391	eap_send_response(pcb, id, typenum, NULL, 0);
1392	break;
1393
1394	case EAPT_NAK:
1395	/*
1396	* Avoid the temptation to send Response Nak in reply
1397	* to Request Nak here. It can only lead to trouble.
1398	*/
1399	ppp_warn("EAP: unexpected Nak in Request; ignored");
1400	/* Return because we're waiting for something real. */
1401	return;
1402
1403	case EAPT_MD5CHAP:
1404	if (len < 1) {
1405	ppp_error("EAP: received MD5-Challenge with no data");
1406	/* Bogus request; wait for something real. */
1407	return;
1408	}
1409	GETCHAR(vallen, inp);
1410	len--;
1411	if (vallen < 8 \|\| vallen > len) {
1412	ppp_error("EAP: MD5-Challenge with bad length %d (8..%d)",
1413	vallen, len);
1414	/* Try something better. */
1415	eap_send_nak(pcb, id, EAPT_SRP);
1416	break;
1417	}
1418
1419	/* Not so likely to happen. */
1420	if (vallen >= len + sizeof (rhostname)) {
1421	ppp_dbglog("EAP: trimming really long peer name down");
1422	MEMCPY(rhostname, inp + vallen, sizeof (rhostname) - 1);
1423	rhostname[sizeof (rhostname) - 1] = '\0';
1424	} else {
1425	MEMCPY(rhostname, inp + vallen, len - vallen);
1426	rhostname[len - vallen] = '\0';
1427	}
1428
1429	#if PPP_REMOTENAME
1430	/* In case the remote doesn't give us his name. */
1431	if (pcb->settings.explicit_remote \|\|
1432	(pcb->settings.remote_name[0] != '\0' && vallen == len))
1433	strlcpy(rhostname, pcb->settings.remote_name, sizeof (rhostname));
1434	#endif /* PPP_REMOTENAME */
1435
1436	/*
1437	* Get the secret for authenticating ourselves with
1438	* the specified host.
1439	*/
1440	if (!get_secret(pcb, pcb->eap.es_client.ea_name,
1441	rhostname, secret, &secret_len, 0)) {
1442	ppp_dbglog("EAP: no MD5 secret for auth to %q", rhostname);
1443	eap_send_nak(pcb, id, EAPT_SRP);
1444	break;
1445	}
1446	lwip_md5_init(&mdContext);
1447	lwip_md5_starts(&mdContext);
1448	typenum = id;
1449	lwip_md5_update(&mdContext, &typenum, 1);
1450	lwip_md5_update(&mdContext, (u_char *)secret, secret_len);
1451	BZERO(secret, sizeof (secret));
1452	lwip_md5_update(&mdContext, inp, vallen);
1453	lwip_md5_finish(&mdContext, hash);
1454	lwip_md5_free(&mdContext);
1455	eap_chap_response(pcb, id, hash, pcb->eap.es_client.ea_name,
1456	pcb->eap.es_client.ea_namelen);
1457	break;
1458
1459	#ifdef USE_SRP
1460	case EAPT_SRP:
1461	if (len < 1) {
1462	ppp_error("EAP: received empty SRP Request");
1463	/* Bogus request; wait for something real. */
1464	return;
1465	}
1466
1467	/* Get subtype */
1468	GETCHAR(vallen, inp);
1469	len--;
1470	switch (vallen) {
1471	case EAPSRP_CHALLENGE:
1472	tc = NULL;
1473	if (pcb->eap.es_client.ea_session != NULL) {
1474	tc = (struct t_client *)pcb->eap.es_client.
1475	ea_session;
1476	/*
1477	* If this is a new challenge, then start
1478	* over with a new client session context.
1479	* Otherwise, just resend last response.
1480	*/
1481	if (id != pcb->eap.es_client.ea_id) {
1482	t_clientclose(tc);
1483	pcb->eap.es_client.ea_session = NULL;
1484	tc = NULL;
1485	}
1486	}
1487	/* No session key just yet */
1488	pcb->eap.es_client.ea_skey = NULL;
1489	if (tc == NULL) {
1490	int rhostnamelen;
1491
1492	GETCHAR(vallen, inp);
1493	len--;
1494	if (vallen >= len) {
1495	ppp_error("EAP: badly-formed SRP Challenge"
1496	" (name)");
1497	/* Ignore badly-formed messages */
1498	return;
1499	}
1500	MEMCPY(rhostname, inp, vallen);
1501	rhostname[vallen] = '\0';
1502	INCPTR(vallen, inp);
1503	len -= vallen;
1504
1505	/*
1506	* In case the remote doesn't give us his name,
1507	* use configured name.
1508	*/
1509	if (explicit_remote \|\|
1510	(remote_name[0] != '\0' && vallen == 0)) {
1511	strlcpy(rhostname, remote_name,
1512	sizeof (rhostname));
1513	}
1514
1515	rhostnamelen = (int)strlen(rhostname);
1516	if (rhostnamelen > MAXNAMELEN) {
1517	rhostnamelen = MAXNAMELEN;
1518	}
1519	MEMCPY(pcb->eap.es_client.ea_peer, rhostname, rhostnamelen);
1520	pcb->eap.es_client.ea_peer[rhostnamelen] = '\0';
1521	pcb->eap.es_client.ea_peerlen = rhostnamelen;
1522
1523	GETCHAR(vallen, inp);
1524	len--;
1525	if (vallen >= len) {
1526	ppp_error("EAP: badly-formed SRP Challenge"
1527	" (s)");
1528	/* Ignore badly-formed messages */
1529	return;
1530	}
1531	sval.data = inp;
1532	sval.len = vallen;
1533	INCPTR(vallen, inp);
1534	len -= vallen;
1535
1536	GETCHAR(vallen, inp);
1537	len--;
1538	if (vallen > len) {
1539	ppp_error("EAP: badly-formed SRP Challenge"
1540	" (g)");
1541	/* Ignore badly-formed messages */
1542	return;
1543	}
1544	/* If no generator present, then use value 2 */
1545	if (vallen == 0) {
1546	gval.data = (u_char *)"\002";
1547	gval.len = 1;
1548	} else {
1549	gval.data = inp;
1550	gval.len = vallen;
1551	}
1552	INCPTR(vallen, inp);
1553	len -= vallen;
1554
1555	/*
1556	* If no modulus present, then use well-known
1557	* value.
1558	*/
1559	if (len == 0) {
1560	Nval.data = (u_char *)wkmodulus;
1561	Nval.len = sizeof (wkmodulus);
1562	} else {
1563	Nval.data = inp;
1564	Nval.len = len;
1565	}
1566	tc = t_clientopen(pcb->eap.es_client.ea_name,
1567	&Nval, &gval, &sval);
1568	if (tc == NULL) {
1569	eap_send_nak(pcb, id, EAPT_MD5CHAP);
1570	break;
1571	}
1572	pcb->eap.es_client.ea_session = (void *)tc;
1573
1574	/* Add Challenge ID & type to verifier */
1575	vals[0] = id;
1576	vals[1] = EAPT_SRP;
1577	t_clientaddexdata(tc, vals, 2);
1578	}
1579	Ap = t_clientgenexp(tc);
1580	eap_srp_response(esp, id, EAPSRP_CKEY, Ap->data,
1581	Ap->len);
1582	break;
1583
1584	case EAPSRP_SKEY:
1585	tc = (struct t_client *)pcb->eap.es_client.ea_session;
1586	if (tc == NULL) {
1587	ppp_warn("EAP: peer sent Subtype 2 without 1");
1588	eap_send_nak(pcb, id, EAPT_MD5CHAP);
1589	break;
1590	}
1591	if (pcb->eap.es_client.ea_skey != NULL) {
1592	/*
1593	* ID number should not change here. Warn
1594	* if it does (but otherwise ignore).
1595	*/
1596	if (id != pcb->eap.es_client.ea_id) {
1597	ppp_warn("EAP: ID changed from %d to %d "
1598	"in SRP Subtype 2 rexmit",
1599	pcb->eap.es_client.ea_id, id);
1600	}
1601	} else {
1602	if (get_srp_secret(pcb->eap.es_unit,
1603	pcb->eap.es_client.ea_name,
1604	pcb->eap.es_client.ea_peer, secret, 0) == 0) {
1605	/*
1606	* Can't work with this peer because
1607	* the secret is missing. Just give
1608	* up.
1609	*/
1610	eap_send_nak(pcb, id, EAPT_MD5CHAP);
1611	break;
1612	}
1613	Bval.data = inp;
1614	Bval.len = len;
1615	t_clientpasswd(tc, secret);
1616	BZERO(secret, sizeof (secret));
1617	pcb->eap.es_client.ea_skey =
1618	t_clientgetkey(tc, &Bval);
1619	if (pcb->eap.es_client.ea_skey == NULL) {
1620	/* Server is rogue; stop now */
1621	ppp_error("EAP: SRP server is rogue");
1622	goto client_failure;
1623	}
1624	}
1625	eap_srpval_response(esp, id, SRPVAL_EBIT,
1626	t_clientresponse(tc));
1627	break;
1628
1629	case EAPSRP_SVALIDATOR:
1630	tc = (struct t_client *)pcb->eap.es_client.ea_session;
1631	if (tc == NULL \|\| pcb->eap.es_client.ea_skey == NULL) {
1632	ppp_warn("EAP: peer sent Subtype 3 without 1/2");
1633	eap_send_nak(pcb, id, EAPT_MD5CHAP);
1634	break;
1635	}
1636	/*
1637	* If we're already open, then this ought to be a
1638	* duplicate. Otherwise, check that the server is
1639	* who we think it is.
1640	*/
1641	if (pcb->eap.es_client.ea_state == eapOpen) {
1642	if (id != pcb->eap.es_client.ea_id) {
1643	ppp_warn("EAP: ID changed from %d to %d "
1644	"in SRP Subtype 3 rexmit",
1645	pcb->eap.es_client.ea_id, id);
1646	}
1647	} else {
1648	len -= sizeof (u32_t) + SHA_DIGESTSIZE;
1649	if (len < 0 \|\| t_clientverify(tc, inp +
1650	sizeof (u32_t)) != 0) {
1651	ppp_error("EAP: SRP server verification "
1652	"failed");
1653	goto client_failure;
1654	}
1655	GETLONG(pcb->eap.es_client.ea_keyflags, inp);
1656	/* Save pseudonym if user wants it. */
1657	if (len > 0 && pcb->eap.es_usepseudo) {
1658	INCPTR(SHA_DIGESTSIZE, inp);
1659	write_pseudonym(esp, inp, len, id);
1660	}
1661	}
1662	/*
1663	* We've verified our peer. We're now mostly done,
1664	* except for waiting on the regular EAP Success
1665	* message.
1666	*/
1667	eap_srp_response(esp, id, EAPSRP_ACK, NULL, 0);
1668	break;
1669
1670	case EAPSRP_LWRECHALLENGE:
1671	if (len < 4) {
1672	ppp_warn("EAP: malformed Lightweight rechallenge");
1673	return;
1674	}
1675	SHA1Init(&ctxt);
1676	vals[0] = id;
1677	SHA1Update(&ctxt, vals, 1);
1678	SHA1Update(&ctxt, pcb->eap.es_client.ea_skey,
1679	SESSION_KEY_LEN);
1680	SHA1Update(&ctxt, inp, len);
1681	SHA1Update(&ctxt, pcb->eap.es_client.ea_name,
1682	pcb->eap.es_client.ea_namelen);
1683	SHA1Final(dig, &ctxt);
1684	eap_srp_response(esp, id, EAPSRP_LWRECHALLENGE, dig,
1685	SHA_DIGESTSIZE);
1686	break;
1687
1688	default:
1689	ppp_error("EAP: unknown SRP Subtype %d", vallen);
1690	eap_send_nak(pcb, id, EAPT_MD5CHAP);
1691	break;
1692	}
1693	break;
1694	#endif /* USE_SRP */
1695
1696	default:
1697	ppp_info("EAP: unknown authentication type %d; Naking", typenum);
1698	eap_send_nak(pcb, id, EAPT_SRP);
1699	break;
1700	}
1701
1702	if (pcb->settings.eap_req_time > 0) {
1703	UNTIMEOUT(eap_client_timeout, pcb);
1704	TIMEOUT(eap_client_timeout, pcb,
1705	pcb->settings.eap_req_time);
1706	}
1707	return;
1708
1709	#ifdef USE_SRP
1710	client_failure:
1711	pcb->eap.es_client.ea_state = eapBadAuth;
1712	if (pcb->settings.eap_req_time > 0) {
1713	UNTIMEOUT(eap_client_timeout, (void *)esp);
1714	}
1715	pcb->eap.es_client.ea_session = NULL;
1716	t_clientclose(tc);
1717	auth_withpeer_fail(pcb, PPP_EAP);
1718	#endif /* USE_SRP */
1719	}
1720
1721	#if PPP_SERVER
1722	/*
1723	* eap_response - Receive EAP Response message (server mode).
1724	*/
1725	static void eap_response(ppp_pcb pcb, u_char inp, int id, int len) {
1726	u_char typenum;
1727	u_char vallen;
1728	int secret_len;
1729	char secret[MAXSECRETLEN];
1730	char rhostname[MAXNAMELEN];
1731	lwip_md5_context mdContext;
1732	u_char hash[MD5_SIGNATURE_SIZE];
1733	#ifdef USE_SRP
1734	struct t_server *ts;
1735	struct t_num A;
1736	SHA1_CTX ctxt;
1737	u_char dig[SHA_DIGESTSIZE];
1738	#endif /* USE_SRP */
1739
1740	if (pcb->eap.es_server.ea_id != id) {
1741	ppp_dbglog("EAP: discarding Response %d; expected ID %d", id,
1742	pcb->eap.es_server.ea_id);
1743	return;
1744	}
1745
1746	pcb->eap.es_server.ea_responses++;
1747
1748	if (len <= 0) {
1749	ppp_error("EAP: empty Response message discarded");
1750	return;
1751	}
1752
1753	GETCHAR(typenum, inp);
1754	len--;
1755
1756	switch (typenum) {
1757	case EAPT_IDENTITY:
1758	if (pcb->eap.es_server.ea_state != eapIdentify) {
1759	ppp_dbglog("EAP discarding unwanted Identify \"%.q\"", len,
1760	inp);
1761	break;
1762	}
1763	ppp_info("EAP: unauthenticated peer name \"%.*q\"", len, inp);
1764	if (len > MAXNAMELEN) {
1765	len = MAXNAMELEN;
1766	}
1767	MEMCPY(pcb->eap.es_server.ea_peer, inp, len);
1768	pcb->eap.es_server.ea_peer[len] = '\0';
1769	pcb->eap.es_server.ea_peerlen = len;
1770	eap_figure_next_state(pcb, 0);
1771	break;
1772
1773	case EAPT_NOTIFICATION:
1774	ppp_dbglog("EAP unexpected Notification; response discarded");
1775	break;
1776
1777	case EAPT_NAK:
1778	if (len < 1) {
1779	ppp_info("EAP: Nak Response with no suggested protocol");
1780	eap_figure_next_state(pcb, 1);
1781	break;
1782	}
1783
1784	GETCHAR(vallen, inp);
1785	len--;
1786
1787	if (
1788	#if PPP_REMOTENAME
1789	!pcb->explicit_remote &&
1790	#endif /* PPP_REMOTENAME */
1791	pcb->eap.es_server.ea_state == eapIdentify){
1792	/* Peer cannot Nak Identify Request */
1793	eap_figure_next_state(pcb, 1);
1794	break;
1795	}
1796
1797	switch (vallen) {
1798	case EAPT_SRP:
1799	/* Run through SRP validator selection again. */
1800	pcb->eap.es_server.ea_state = eapIdentify;
1801	eap_figure_next_state(pcb, 0);
1802	break;
1803
1804	case EAPT_MD5CHAP:
1805	pcb->eap.es_server.ea_state = eapMD5Chall;
1806	break;
1807
1808	default:
1809	ppp_dbglog("EAP: peer requesting unknown Type %d", vallen);
1810	switch (pcb->eap.es_server.ea_state) {
1811	case eapSRP1:
1812	case eapSRP2:
1813	case eapSRP3:
1814	pcb->eap.es_server.ea_state = eapMD5Chall;
1815	break;
1816	case eapMD5Chall:
1817	case eapSRP4:
1818	pcb->eap.es_server.ea_state = eapIdentify;
1819	eap_figure_next_state(pcb, 0);
1820	break;
1821	default:
1822	break;
1823	}
1824	break;
1825	}
1826	break;
1827
1828	case EAPT_MD5CHAP:
1829	if (pcb->eap.es_server.ea_state != eapMD5Chall) {
1830	ppp_error("EAP: unexpected MD5-Response");
1831	eap_figure_next_state(pcb, 1);
1832	break;
1833	}
1834	if (len < 1) {
1835	ppp_error("EAP: received MD5-Response with no data");
1836	eap_figure_next_state(pcb, 1);
1837	break;
1838	}
1839	GETCHAR(vallen, inp);
1840	len--;
1841	if (vallen != 16 \|\| vallen > len) {
1842	ppp_error("EAP: MD5-Response with bad length %d", vallen);
1843	eap_figure_next_state(pcb, 1);
1844	break;
1845	}
1846
1847	/* Not so likely to happen. */
1848	if (vallen >= len + sizeof (rhostname)) {
1849	ppp_dbglog("EAP: trimming really long peer name down");
1850	MEMCPY(rhostname, inp + vallen, sizeof (rhostname) - 1);
1851	rhostname[sizeof (rhostname) - 1] = '\0';
1852	} else {
1853	MEMCPY(rhostname, inp + vallen, len - vallen);
1854	rhostname[len - vallen] = '\0';
1855	}
1856
1857	#if PPP_REMOTENAME
1858	/* In case the remote doesn't give us his name. */
1859	if (explicit_remote \|\|
1860	(remote_name[0] != '\0' && vallen == len))
1861	strlcpy(rhostname, remote_name, sizeof (rhostname));
1862	#endif /* PPP_REMOTENAME */
1863
1864	/*
1865	* Get the secret for authenticating the specified
1866	* host.
1867	*/
1868	if (!get_secret(pcb, rhostname,
1869	pcb->eap.es_server.ea_name, secret, &secret_len, 1)) {
1870	ppp_dbglog("EAP: no MD5 secret for auth of %q", rhostname);
1871	eap_send_failure(pcb);
1872	break;
1873	}
1874	lwip_md5_init(&mdContext);
1875	lwip_md5_starts(&mdContext);
1876	lwip_md5_update(&mdContext, &pcb->eap.es_server.ea_id, 1);
1877	lwip_md5_update(&mdContext, (u_char *)secret, secret_len);
1878	BZERO(secret, sizeof (secret));
1879	lwip_md5_update(&mdContext, pcb->eap.es_challenge, pcb->eap.es_challen);
1880	lwip_md5_finish(&mdContext, hash);
1881	lwip_md5_free(&mdContext);
1882	if (BCMP(hash, inp, MD5_SIGNATURE_SIZE) != 0) {
1883	eap_send_failure(pcb);
1884	break;
1885	}
1886	pcb->eap.es_server.ea_type = EAPT_MD5CHAP;
1887	eap_send_success(pcb);
1888	eap_figure_next_state(pcb, 0);
1889	if (pcb->eap.es_rechallenge != 0)
1890	TIMEOUT(eap_rechallenge, pcb, pcb->eap.es_rechallenge);
1891	break;
1892
1893	#ifdef USE_SRP
1894	case EAPT_SRP:
1895	if (len < 1) {
1896	ppp_error("EAP: empty SRP Response");
1897	eap_figure_next_state(pcb, 1);
1898	break;
1899	}
1900	GETCHAR(typenum, inp);
1901	len--;
1902	switch (typenum) {
1903	case EAPSRP_CKEY:
1904	if (pcb->eap.es_server.ea_state != eapSRP1) {
1905	ppp_error("EAP: unexpected SRP Subtype 1 Response");
1906	eap_figure_next_state(pcb, 1);
1907	break;
1908	}
1909	A.data = inp;
1910	A.len = len;
1911	ts = (struct t_server *)pcb->eap.es_server.ea_session;
1912	assert(ts != NULL);
1913	pcb->eap.es_server.ea_skey = t_servergetkey(ts, &A);
1914	if (pcb->eap.es_server.ea_skey == NULL) {
1915	/* Client's A value is bogus; terminate now */
1916	ppp_error("EAP: bogus A value from client");
1917	eap_send_failure(pcb);
1918	} else {
1919	eap_figure_next_state(pcb, 0);
1920	}
1921	break;
1922
1923	case EAPSRP_CVALIDATOR:
1924	if (pcb->eap.es_server.ea_state != eapSRP2) {
1925	ppp_error("EAP: unexpected SRP Subtype 2 Response");
1926	eap_figure_next_state(pcb, 1);
1927	break;
1928	}
1929	if (len < sizeof (u32_t) + SHA_DIGESTSIZE) {
1930	ppp_error("EAP: M1 length %d < %d", len,
1931	sizeof (u32_t) + SHA_DIGESTSIZE);
1932	eap_figure_next_state(pcb, 1);
1933	break;
1934	}
1935	GETLONG(pcb->eap.es_server.ea_keyflags, inp);
1936	ts = (struct t_server *)pcb->eap.es_server.ea_session;
1937	assert(ts != NULL);
1938	if (t_serververify(ts, inp)) {
1939	ppp_info("EAP: unable to validate client identity");
1940	eap_send_failure(pcb);
1941	break;
1942	}
1943	eap_figure_next_state(pcb, 0);
1944	break;
1945
1946	case EAPSRP_ACK:
1947	if (pcb->eap.es_server.ea_state != eapSRP3) {
1948	ppp_error("EAP: unexpected SRP Subtype 3 Response");
1949	eap_send_failure(esp);
1950	break;
1951	}
1952	pcb->eap.es_server.ea_type = EAPT_SRP;
1953	eap_send_success(pcb, esp);
1954	eap_figure_next_state(pcb, 0);
1955	if (pcb->eap.es_rechallenge != 0)
1956	TIMEOUT(eap_rechallenge, pcb,
1957	pcb->eap.es_rechallenge);
1958	if (pcb->eap.es_lwrechallenge != 0)
1959	TIMEOUT(srp_lwrechallenge, pcb,
1960	pcb->eap.es_lwrechallenge);
1961	break;
1962
1963	case EAPSRP_LWRECHALLENGE:
1964	if (pcb->eap.es_server.ea_state != eapSRP4) {
1965	ppp_info("EAP: unexpected SRP Subtype 4 Response");
1966	return;
1967	}
1968	if (len != SHA_DIGESTSIZE) {
1969	ppp_error("EAP: bad Lightweight rechallenge "
1970	"response");
1971	return;
1972	}
1973	SHA1Init(&ctxt);
1974	vallen = id;
1975	SHA1Update(&ctxt, &vallen, 1);
1976	SHA1Update(&ctxt, pcb->eap.es_server.ea_skey,
1977	SESSION_KEY_LEN);
1978	SHA1Update(&ctxt, pcb->eap.es_challenge, pcb->eap.es_challen);
1979	SHA1Update(&ctxt, pcb->eap.es_server.ea_peer,
1980	pcb->eap.es_server.ea_peerlen);
1981	SHA1Final(dig, &ctxt);
1982	if (BCMP(dig, inp, SHA_DIGESTSIZE) != 0) {
1983	ppp_error("EAP: failed Lightweight rechallenge");
1984	eap_send_failure(pcb);
1985	break;
1986	}
1987	pcb->eap.es_server.ea_state = eapOpen;
1988	if (pcb->eap.es_lwrechallenge != 0)
1989	TIMEOUT(srp_lwrechallenge, esp,
1990	pcb->eap.es_lwrechallenge);
1991	break;
1992	}
1993	break;
1994	#endif /* USE_SRP */
1995
1996	default:
1997	/* This can't happen. */
1998	ppp_error("EAP: unknown Response type %d; ignored", typenum);
1999	return;
2000	}
2001
2002	if (pcb->settings.eap_timeout_time > 0) {
2003	UNTIMEOUT(eap_server_timeout, pcb);
2004	}
2005
2006	if (pcb->eap.es_server.ea_state != eapBadAuth &&
2007	pcb->eap.es_server.ea_state != eapOpen) {
2008	pcb->eap.es_server.ea_id++;
2009	eap_send_request(pcb);
2010	}
2011	}
2012	#endif /* PPP_SERVER */
2013
2014	/*
2015	* eap_success - Receive EAP Success message (client mode).
2016	*/
2017	static void eap_success(ppp_pcb pcb, u_char inp, int id, int len) {
2018	LWIP_UNUSED_ARG(id);
2019
2020	if (pcb->eap.es_client.ea_state != eapOpen && !eap_client_active(pcb)) {
2021	ppp_dbglog("EAP unexpected success message in state %s (%d)",
2022	eap_state_name(pcb->eap.es_client.ea_state),
2023	pcb->eap.es_client.ea_state);
2024	return;
2025	}
2026
2027	if (pcb->settings.eap_req_time > 0) {
2028	UNTIMEOUT(eap_client_timeout, pcb);
2029	}
2030
2031	if (len > 0) {
2032	/* This is odd. The spec doesn't allow for this. */
2033	PRINTMSG(inp, len);
2034	}
2035
2036	pcb->eap.es_client.ea_state = eapOpen;
2037	auth_withpeer_success(pcb, PPP_EAP, 0);
2038	}
2039
2040	/*
2041	* eap_failure - Receive EAP Failure message (client mode).
2042	*/
2043	static void eap_failure(ppp_pcb pcb, u_char inp, int id, int len) {
2044	LWIP_UNUSED_ARG(id);
2045
2046	if (!eap_client_active(pcb)) {
2047	ppp_dbglog("EAP unexpected failure message in state %s (%d)",
2048	eap_state_name(pcb->eap.es_client.ea_state),
2049	pcb->eap.es_client.ea_state);
2050	}
2051
2052	if (pcb->settings.eap_req_time > 0) {
2053	UNTIMEOUT(eap_client_timeout, pcb);
2054	}
2055
2056	if (len > 0) {
2057	/* This is odd. The spec doesn't allow for this. */
2058	PRINTMSG(inp, len);
2059	}
2060
2061	pcb->eap.es_client.ea_state = eapBadAuth;
2062
2063	ppp_error("EAP: peer reports authentication failure");
2064	auth_withpeer_fail(pcb, PPP_EAP);
2065	}
2066
2067	/*
2068	* eap_input - Handle received EAP message.
2069	*/
2070	static void eap_input(ppp_pcb pcb, u_char inp, int inlen) {
2071	u_char code, id;
2072	int len;
2073
2074	/*
2075	* Parse header (code, id and length). If packet too short,
2076	* drop it.
2077	*/
2078	if (inlen < EAP_HEADERLEN) {
2079	ppp_error("EAP: packet too short: %d < %d", inlen, EAP_HEADERLEN);
2080	return;
2081	}
2082	GETCHAR(code, inp);
2083	GETCHAR(id, inp);
2084	GETSHORT(len, inp);
2085	if (len < EAP_HEADERLEN \|\| len > inlen) {
2086	ppp_error("EAP: packet has illegal length field %d (%d..%d)", len,
2087	EAP_HEADERLEN, inlen);
2088	return;
2089	}
2090	len -= EAP_HEADERLEN;
2091
2092	/* Dispatch based on message code */
2093	switch (code) {
2094	case EAP_REQUEST:
2095	eap_request(pcb, inp, id, len);
2096	break;
2097
2098	#if PPP_SERVER
2099	case EAP_RESPONSE:
2100	eap_response(pcb, inp, id, len);
2101	break;
2102	#endif /* PPP_SERVER */
2103
2104	case EAP_SUCCESS:
2105	eap_success(pcb, inp, id, len);
2106	break;
2107
2108	case EAP_FAILURE:
2109	eap_failure(pcb, inp, id, len);
2110	break;
2111
2112	default: /* XXX Need code reject */
2113	/* Note: it's not legal to send EAP Nak here. */
2114	ppp_warn("EAP: unknown code %d received", code);
2115	break;
2116	}
2117	}
2118
2119	#if PRINTPKT_SUPPORT
2120	/*
2121	* eap_printpkt - print the contents of an EAP packet.
2122	*/
2123	static const char* const eap_codenames[] = {
2124	"Request", "Response", "Success", "Failure"
2125	};
2126
2127	static const char* const eap_typenames[] = {
2128	"Identity", "Notification", "Nak", "MD5-Challenge",
2129	"OTP", "Generic-Token", NULL, NULL,
2130	"RSA", "DSS", "KEA", "KEA-Validate",
2131	"TLS", "Defender", "Windows 2000", "Arcot",
2132	"Cisco", "Nokia", "SRP"
2133	};
2134
2135	static int eap_printpkt(const u_char inp, int inlen, void (printer) (void , const char , ...), void *arg) {
2136	int code, id, len, rtype, vallen;
2137	const u_char *pstart;
2138	u32_t uval;
2139
2140	if (inlen < EAP_HEADERLEN)
2141	return (0);
2142	pstart = inp;
2143	GETCHAR(code, inp);
2144	GETCHAR(id, inp);
2145	GETSHORT(len, inp);
2146	if (len < EAP_HEADERLEN \|\| len > inlen)
2147	return (0);
2148
2149	if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(eap_codenames))
2150	printer(arg, " %s", eap_codenames[code-1]);
2151	else
2152	printer(arg, " code=0x%x", code);
2153	printer(arg, " id=0x%x", id);
2154	len -= EAP_HEADERLEN;
2155	switch (code) {
2156	case EAP_REQUEST:
2157	if (len < 1) {
2158	printer(arg, " <missing type>");
2159	break;
2160	}
2161	GETCHAR(rtype, inp);
2162	len--;
2163	if (rtype >= 1 && rtype <= (int)LWIP_ARRAYSIZE(eap_typenames))
2164	printer(arg, " %s", eap_typenames[rtype-1]);
2165	else
2166	printer(arg, " type=0x%x", rtype);
2167	switch (rtype) {
2168	case EAPT_IDENTITY:
2169	case EAPT_NOTIFICATION:
2170	if (len > 0) {
2171	printer(arg, " <Message ");
2172	ppp_print_string(inp, len, printer, arg);
2173	printer(arg, ">");
2174	INCPTR(len, inp);
2175	len = 0;
2176	} else {
2177	printer(arg, " <No message>");
2178	}
2179	break;
2180
2181	case EAPT_MD5CHAP:
2182	if (len <= 0)
2183	break;
2184	GETCHAR(vallen, inp);
2185	len--;
2186	if (vallen > len)
2187	goto truncated;
2188	printer(arg, " <Value%.*B>", vallen, inp);
2189	INCPTR(vallen, inp);
2190	len -= vallen;
2191	if (len > 0) {
2192	printer(arg, " <Name ");
2193	ppp_print_string(inp, len, printer, arg);
2194	printer(arg, ">");
2195	INCPTR(len, inp);
2196	len = 0;
2197	} else {
2198	printer(arg, " <No name>");
2199	}
2200	break;
2201
2202	case EAPT_SRP:
2203	if (len < 3)
2204	goto truncated;
2205	GETCHAR(vallen, inp);
2206	len--;
2207	printer(arg, "-%d", vallen);
2208	switch (vallen) {
2209	case EAPSRP_CHALLENGE:
2210	GETCHAR(vallen, inp);
2211	len--;
2212	if (vallen >= len)
2213	goto truncated;
2214	if (vallen > 0) {
2215	printer(arg, " <Name ");
2216	ppp_print_string(inp, vallen, printer,
2217	arg);
2218	printer(arg, ">");
2219	} else {
2220	printer(arg, " <No name>");
2221	}
2222	INCPTR(vallen, inp);
2223	len -= vallen;
2224	GETCHAR(vallen, inp);
2225	len--;
2226	if (vallen >= len)
2227	goto truncated;
2228	printer(arg, " <s%.*B>", vallen, inp);
2229	INCPTR(vallen, inp);
2230	len -= vallen;
2231	GETCHAR(vallen, inp);
2232	len--;
2233	if (vallen > len)
2234	goto truncated;
2235	if (vallen == 0) {
2236	printer(arg, " <Default g=2>");
2237	} else {
2238	printer(arg, " <g%.*B>", vallen, inp);
2239	}
2240	INCPTR(vallen, inp);
2241	len -= vallen;
2242	if (len == 0) {
2243	printer(arg, " <Default N>");
2244	} else {
2245	printer(arg, " <N%.*B>", len, inp);
2246	INCPTR(len, inp);
2247	len = 0;
2248	}
2249	break;
2250
2251	case EAPSRP_SKEY:
2252	printer(arg, " <B%.*B>", len, inp);
2253	INCPTR(len, inp);
2254	len = 0;
2255	break;
2256
2257	case EAPSRP_SVALIDATOR:
2258	if (len < (int)sizeof (u32_t))
2259	break;
2260	GETLONG(uval, inp);
2261	len -= sizeof (u32_t);
2262	if (uval & SRPVAL_EBIT) {
2263	printer(arg, " E");
2264	uval &= ~SRPVAL_EBIT;
2265	}
2266	if (uval != 0) {
2267	printer(arg, " f<%X>", uval);
2268	}
2269	if ((vallen = len) > SHA_DIGESTSIZE)
2270	vallen = SHA_DIGESTSIZE;
2271	printer(arg, " <M2%.*B%s>", len, inp,
2272	len < SHA_DIGESTSIZE ? "?" : "");
2273	INCPTR(vallen, inp);
2274	len -= vallen;
2275	if (len > 0) {
2276	printer(arg, " <PN%.*B>", len, inp);
2277	INCPTR(len, inp);
2278	len = 0;
2279	}
2280	break;
2281
2282	case EAPSRP_LWRECHALLENGE:
2283	printer(arg, " <Challenge%.*B>", len, inp);
2284	INCPTR(len, inp);
2285	len = 0;
2286	break;
2287	default:
2288	break;
2289	}
2290	break;
2291	default:
2292	break;
2293	}
2294	break;
2295
2296	case EAP_RESPONSE:
2297	if (len < 1)
2298	break;
2299	GETCHAR(rtype, inp);
2300	len--;
2301	if (rtype >= 1 && rtype <= (int)LWIP_ARRAYSIZE(eap_typenames))
2302	printer(arg, " %s", eap_typenames[rtype-1]);
2303	else
2304	printer(arg, " type=0x%x", rtype);
2305	switch (rtype) {
2306	case EAPT_IDENTITY:
2307	if (len > 0) {
2308	printer(arg, " <Name ");
2309	ppp_print_string(inp, len, printer, arg);
2310	printer(arg, ">");
2311	INCPTR(len, inp);
2312	len = 0;
2313	}
2314	break;
2315
2316	case EAPT_NAK:
2317	if (len <= 0) {
2318	printer(arg, " <missing hint>");
2319	break;
2320	}
2321	GETCHAR(rtype, inp);
2322	len--;
2323	printer(arg, " <Suggested-type %02X", rtype);
2324	if (rtype >= 1 && rtype < (int)LWIP_ARRAYSIZE(eap_typenames))
2325	printer(arg, " (%s)", eap_typenames[rtype-1]);
2326	printer(arg, ">");
2327	break;
2328
2329	case EAPT_MD5CHAP:
2330	if (len <= 0) {
2331	printer(arg, " <missing length>");
2332	break;
2333	}
2334	GETCHAR(vallen, inp);
2335	len--;
2336	if (vallen > len)
2337	goto truncated;
2338	printer(arg, " <Value%.*B>", vallen, inp);
2339	INCPTR(vallen, inp);
2340	len -= vallen;
2341	if (len > 0) {
2342	printer(arg, " <Name ");
2343	ppp_print_string(inp, len, printer, arg);
2344	printer(arg, ">");
2345	INCPTR(len, inp);
2346	len = 0;
2347	} else {
2348	printer(arg, " <No name>");
2349	}
2350	break;
2351
2352	case EAPT_SRP:
2353	if (len < 1)
2354	goto truncated;
2355	GETCHAR(vallen, inp);
2356	len--;
2357	printer(arg, "-%d", vallen);
2358	switch (vallen) {
2359	case EAPSRP_CKEY:
2360	printer(arg, " <A%.*B>", len, inp);
2361	INCPTR(len, inp);
2362	len = 0;
2363	break;
2364
2365	case EAPSRP_CVALIDATOR:
2366	if (len < (int)sizeof (u32_t))
2367	break;
2368	GETLONG(uval, inp);
2369	len -= sizeof (u32_t);
2370	if (uval & SRPVAL_EBIT) {
2371	printer(arg, " E");
2372	uval &= ~SRPVAL_EBIT;
2373	}
2374	if (uval != 0) {
2375	printer(arg, " f<%X>", uval);
2376	}
2377	printer(arg, " <M1%.*B%s>", len, inp,
2378	len == SHA_DIGESTSIZE ? "" : "?");
2379	INCPTR(len, inp);
2380	len = 0;
2381	break;
2382
2383	case EAPSRP_ACK:
2384	break;
2385
2386	case EAPSRP_LWRECHALLENGE:
2387	printer(arg, " <Response%.*B%s>", len, inp,
2388	len == SHA_DIGESTSIZE ? "" : "?");
2389	if ((vallen = len) > SHA_DIGESTSIZE)
2390	vallen = SHA_DIGESTSIZE;
2391	INCPTR(vallen, inp);
2392	len -= vallen;
2393	break;
2394	default:
2395	break;
2396	}
2397	break;
2398	default:
2399	break;
2400	}
2401	break;
2402
2403	case EAP_SUCCESS: /* No payload expected for these! */
2404	case EAP_FAILURE:
2405	default:
2406	break;
2407
2408	truncated:
2409	printer(arg, " <truncated>");
2410	break;
2411	}
2412
2413	if (len > 8)
2414	printer(arg, "%8B...", inp);
2415	else if (len > 0)
2416	printer(arg, "%.*B", len, inp);
2417	INCPTR(len, inp);
2418
2419	return (inp - pstart);
2420	}
2421	#endif /* PRINTPKT_SUPPORT */
2422
2423	#endif /* PPP_SUPPORT && EAP_SUPPORT */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: S-port/trunk/Middlewares/Third_Party/LwIP/src/netif/ppp/eap.c

Download in other formats: