xref: /freebsd/sys/netgraph/ng_mppc.c (revision af7ab18437a61045335acabb11e3fef6c62dbb31)
1af7ab184SArchie Cobbs 
2af7ab184SArchie Cobbs /*
3af7ab184SArchie Cobbs  * ng_mppc.c
4af7ab184SArchie Cobbs  *
5af7ab184SArchie Cobbs  * Copyright (c) 1996-2000 Whistle Communications, Inc.
6af7ab184SArchie Cobbs  * All rights reserved.
7af7ab184SArchie Cobbs  *
8af7ab184SArchie Cobbs  * Subject to the following obligations and disclaimer of warranty, use and
9af7ab184SArchie Cobbs  * redistribution of this software, in source or object code forms, with or
10af7ab184SArchie Cobbs  * without modifications are expressly permitted by Whistle Communications;
11af7ab184SArchie Cobbs  * provided, however, that:
12af7ab184SArchie Cobbs  * 1. Any and all reproductions of the source or object code must include the
13af7ab184SArchie Cobbs  *    copyright notice above and the following disclaimer of warranties; and
14af7ab184SArchie Cobbs  * 2. No rights are granted, in any manner or form, to use Whistle
15af7ab184SArchie Cobbs  *    Communications, Inc. trademarks, including the mark "WHISTLE
16af7ab184SArchie Cobbs  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
17af7ab184SArchie Cobbs  *    such appears in the above copyright notice or in the software.
18af7ab184SArchie Cobbs  *
19af7ab184SArchie Cobbs  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
20af7ab184SArchie Cobbs  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
21af7ab184SArchie Cobbs  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
22af7ab184SArchie Cobbs  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
23af7ab184SArchie Cobbs  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
24af7ab184SArchie Cobbs  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
25af7ab184SArchie Cobbs  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
26af7ab184SArchie Cobbs  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
27af7ab184SArchie Cobbs  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
28af7ab184SArchie Cobbs  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
29af7ab184SArchie Cobbs  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
30af7ab184SArchie Cobbs  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
31af7ab184SArchie Cobbs  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
32af7ab184SArchie Cobbs  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33af7ab184SArchie Cobbs  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34af7ab184SArchie Cobbs  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
35af7ab184SArchie Cobbs  * OF SUCH DAMAGE.
36af7ab184SArchie Cobbs  *
37af7ab184SArchie Cobbs  * Author: Archie Cobbs <archie@whistle.com>
38af7ab184SArchie Cobbs  *
39af7ab184SArchie Cobbs  * $Whistle: ng_mppc.c,v 1.4 1999/11/25 00:10:12 archie Exp $
40af7ab184SArchie Cobbs  * $FreeBSD$
41af7ab184SArchie Cobbs  */
42af7ab184SArchie Cobbs 
43af7ab184SArchie Cobbs /*
44af7ab184SArchie Cobbs  * Microsoft PPP compression (MPPC) and encryption (MPPE) netgraph node type.
45af7ab184SArchie Cobbs  *
46af7ab184SArchie Cobbs  * You must define one or both of the NETGRAPH_MPPC_COMPRESSION and/or
47af7ab184SArchie Cobbs  * NETGRAPH_MPPC_ENCRYPTION options for this node type to be useful.
48af7ab184SArchie Cobbs  */
49af7ab184SArchie Cobbs 
50af7ab184SArchie Cobbs #include <sys/param.h>
51af7ab184SArchie Cobbs #include <sys/systm.h>
52af7ab184SArchie Cobbs #include <sys/kernel.h>
53af7ab184SArchie Cobbs #include <sys/conf.h>
54af7ab184SArchie Cobbs #include <sys/mbuf.h>
55af7ab184SArchie Cobbs #include <sys/malloc.h>
56af7ab184SArchie Cobbs #include <sys/protosw.h>
57af7ab184SArchie Cobbs #include <sys/errno.h>
58af7ab184SArchie Cobbs #include <sys/syslog.h>
59af7ab184SArchie Cobbs 
60af7ab184SArchie Cobbs #include <netgraph/ng_message.h>
61af7ab184SArchie Cobbs #include <netgraph/netgraph.h>
62af7ab184SArchie Cobbs #include <netgraph/ng_mppc.h>
63af7ab184SArchie Cobbs 
64af7ab184SArchie Cobbs #include "opt_netgraph.h"
65af7ab184SArchie Cobbs 
66af7ab184SArchie Cobbs #if !defined(NETGRAPH_MPPC_COMPRESSION) && !defined(NETGRAPH_MPPC_ENCRYPTION)
67af7ab184SArchie Cobbs #error Need either NETGRAPH_MPPC_COMPRESSION or NETGRAPH_MPPC_ENCRYPTION
68af7ab184SArchie Cobbs #endif
69af7ab184SArchie Cobbs 
70af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
71af7ab184SArchie Cobbs /* XXX this file doesn't exist yet, but hopefully someday it will... */
72af7ab184SArchie Cobbs #include <net/mppc.h>
73af7ab184SArchie Cobbs #endif
74af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
75af7ab184SArchie Cobbs #include <crypto/rc4/rc4.h>
76af7ab184SArchie Cobbs #endif
77af7ab184SArchie Cobbs #include <crypto/sha1.h>
78af7ab184SArchie Cobbs 
79af7ab184SArchie Cobbs /* Decompression blowup */
80af7ab184SArchie Cobbs #define MPPC_DECOMP_BUFSIZE	8092            /* allocate buffer this big */
81af7ab184SArchie Cobbs #define MPPC_DECOMP_SAFETY	100             /*   plus this much margin */
82af7ab184SArchie Cobbs 
83af7ab184SArchie Cobbs /* MPPC/MPPE header length */
84af7ab184SArchie Cobbs #define MPPC_HDRLEN		2
85af7ab184SArchie Cobbs 
86af7ab184SArchie Cobbs /* Key length */
87af7ab184SArchie Cobbs #define KEYLEN(b)		(((b) & MPPE_128) ? 16 : 8)
88af7ab184SArchie Cobbs 
89af7ab184SArchie Cobbs /* What sequence number jump is too far */
90af7ab184SArchie Cobbs #define MPPC_INSANE_JUMP	256
91af7ab184SArchie Cobbs 
92af7ab184SArchie Cobbs /* MPPC packet header bits */
93af7ab184SArchie Cobbs #define MPPC_FLAG_FLUSHED	0x8000		/* xmitter reset state */
94af7ab184SArchie Cobbs #define MPPC_FLAG_RESTART	0x4000		/* compress history restart */
95af7ab184SArchie Cobbs #define MPPC_FLAG_COMPRESSED	0x2000		/* packet is compresed */
96af7ab184SArchie Cobbs #define MPPC_FLAG_ENCRYPTED	0x1000		/* packet is encrypted */
97af7ab184SArchie Cobbs #define MPPC_CCOUNT_MASK	0x0fff		/* sequence number mask */
98af7ab184SArchie Cobbs 
99af7ab184SArchie Cobbs #define MPPE_UPDATE_MASK	0xff		/* coherency count when we're */
100af7ab184SArchie Cobbs #define MPPE_UPDATE_FLAG	0xff		/*   supposed to update key */
101af7ab184SArchie Cobbs 
102af7ab184SArchie Cobbs #define MPPC_COMP_OK		0x05
103af7ab184SArchie Cobbs #define MPPC_DECOMP_OK		0x05
104af7ab184SArchie Cobbs 
105af7ab184SArchie Cobbs /* Per direction info */
106af7ab184SArchie Cobbs struct ng_mppc_dir {
107af7ab184SArchie Cobbs 	struct ng_mppc_config	cfg;		/* configuration */
108af7ab184SArchie Cobbs 	hook_p			hook;		/* netgraph hook */
109af7ab184SArchie Cobbs 	u_int16_t		cc:12;		/* coherency count */
110af7ab184SArchie Cobbs 	u_char			flushed;	/* clean history (xmit only) */
111af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
112af7ab184SArchie Cobbs 	u_char			*history;	/* compression history */
113af7ab184SArchie Cobbs #endif
114af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
115af7ab184SArchie Cobbs 	u_char			key[MPPE_KEY_LEN];	/* session key */
116af7ab184SArchie Cobbs 	struct rc4_state	rc4;			/* rc4 state */
117af7ab184SArchie Cobbs #endif
118af7ab184SArchie Cobbs };
119af7ab184SArchie Cobbs 
120af7ab184SArchie Cobbs /* Node private data */
121af7ab184SArchie Cobbs struct ng_mppc_private {
122af7ab184SArchie Cobbs 	struct ng_mppc_dir	xmit;		/* compress/encrypt config */
123af7ab184SArchie Cobbs 	struct ng_mppc_dir	recv;		/* decompress/decrypt config */
124af7ab184SArchie Cobbs 	char			*ctrlpath;	/* path to controlling node */
125af7ab184SArchie Cobbs };
126af7ab184SArchie Cobbs typedef struct ng_mppc_private *priv_p;
127af7ab184SArchie Cobbs 
128af7ab184SArchie Cobbs /* Netgraph node methods */
129af7ab184SArchie Cobbs static ng_constructor_t	ng_mppc_constructor;
130af7ab184SArchie Cobbs static ng_rcvmsg_t	ng_mppc_rcvmsg;
131af7ab184SArchie Cobbs static ng_shutdown_t	ng_mppc_rmnode;
132af7ab184SArchie Cobbs static ng_newhook_t	ng_mppc_newhook;
133af7ab184SArchie Cobbs static ng_rcvdata_t	ng_mppc_rcvdata;
134af7ab184SArchie Cobbs static ng_disconnect_t	ng_mppc_disconnect;
135af7ab184SArchie Cobbs 
136af7ab184SArchie Cobbs /* Helper functions */
137af7ab184SArchie Cobbs static int	ng_mppc_compress(node_p node,
138af7ab184SArchie Cobbs 			struct mbuf *m, struct mbuf **resultp);
139af7ab184SArchie Cobbs static int	ng_mppc_decompress(node_p node,
140af7ab184SArchie Cobbs 			struct mbuf *m, struct mbuf **resultp);
141af7ab184SArchie Cobbs static void	ng_mppc_getkey(const u_char *h, u_char *h2, int len);
142af7ab184SArchie Cobbs static void	ng_mppc_updatekey(u_int32_t bits,
143af7ab184SArchie Cobbs 			u_char *key0, u_char *key, struct rc4_state *rc4);
144af7ab184SArchie Cobbs static void	ng_mppc_reset_req(node_p node);
145af7ab184SArchie Cobbs 
146af7ab184SArchie Cobbs /* Node type descriptor */
147af7ab184SArchie Cobbs static struct ng_type ng_mppc_typestruct = {
148af7ab184SArchie Cobbs 	NG_VERSION,
149af7ab184SArchie Cobbs 	NG_MPPC_NODE_TYPE,
150af7ab184SArchie Cobbs 	NULL,
151af7ab184SArchie Cobbs 	ng_mppc_constructor,
152af7ab184SArchie Cobbs 	ng_mppc_rcvmsg,
153af7ab184SArchie Cobbs 	ng_mppc_rmnode,
154af7ab184SArchie Cobbs 	ng_mppc_newhook,
155af7ab184SArchie Cobbs 	NULL,
156af7ab184SArchie Cobbs 	NULL,
157af7ab184SArchie Cobbs 	ng_mppc_rcvdata,
158af7ab184SArchie Cobbs 	ng_mppc_rcvdata,
159af7ab184SArchie Cobbs 	ng_mppc_disconnect,
160af7ab184SArchie Cobbs 	NULL
161af7ab184SArchie Cobbs };
162af7ab184SArchie Cobbs NETGRAPH_INIT(mppc, &ng_mppc_typestruct);
163af7ab184SArchie Cobbs 
164af7ab184SArchie Cobbs /* Fixed bit pattern to weaken keysize down to 40 bits */
165af7ab184SArchie Cobbs static const u_char ng_mppe_weakenkey[3] = { 0xd1, 0x26, 0x9e };
166af7ab184SArchie Cobbs 
167af7ab184SArchie Cobbs #define ERROUT(x)	do { error = (x); goto done; } while (0)
168af7ab184SArchie Cobbs 
169af7ab184SArchie Cobbs /************************************************************************
170af7ab184SArchie Cobbs 			NETGRAPH NODE STUFF
171af7ab184SArchie Cobbs  ************************************************************************/
172af7ab184SArchie Cobbs 
173af7ab184SArchie Cobbs /*
174af7ab184SArchie Cobbs  * Node type constructor
175af7ab184SArchie Cobbs  */
176af7ab184SArchie Cobbs static int
177af7ab184SArchie Cobbs ng_mppc_constructor(node_p *nodep)
178af7ab184SArchie Cobbs {
179af7ab184SArchie Cobbs 	priv_p priv;
180af7ab184SArchie Cobbs 	int error;
181af7ab184SArchie Cobbs 
182af7ab184SArchie Cobbs 	/* Allocate private structure */
183af7ab184SArchie Cobbs 	MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK);
184af7ab184SArchie Cobbs 	if (priv == NULL)
185af7ab184SArchie Cobbs 		return (ENOMEM);
186af7ab184SArchie Cobbs 	bzero(priv, sizeof(*priv));
187af7ab184SArchie Cobbs 
188af7ab184SArchie Cobbs 	/* Call generic node constructor */
189af7ab184SArchie Cobbs 	if ((error = ng_make_node_common(&ng_mppc_typestruct, nodep))) {
190af7ab184SArchie Cobbs 		FREE(priv, M_NETGRAPH);
191af7ab184SArchie Cobbs 		return (error);
192af7ab184SArchie Cobbs 	}
193af7ab184SArchie Cobbs 	(*nodep)->private = priv;
194af7ab184SArchie Cobbs 
195af7ab184SArchie Cobbs 	/* Done */
196af7ab184SArchie Cobbs 	return (0);
197af7ab184SArchie Cobbs }
198af7ab184SArchie Cobbs 
199af7ab184SArchie Cobbs /*
200af7ab184SArchie Cobbs  * Give our OK for a hook to be added
201af7ab184SArchie Cobbs  */
202af7ab184SArchie Cobbs static int
203af7ab184SArchie Cobbs ng_mppc_newhook(node_p node, hook_p hook, const char *name)
204af7ab184SArchie Cobbs {
205af7ab184SArchie Cobbs 	const priv_p priv = node->private;
206af7ab184SArchie Cobbs 	hook_p *hookPtr;
207af7ab184SArchie Cobbs 
208af7ab184SArchie Cobbs 	/* Check hook name */
209af7ab184SArchie Cobbs 	if (strcmp(name, NG_MPPC_HOOK_COMP) == 0)
210af7ab184SArchie Cobbs 		hookPtr = &priv->xmit.hook;
211af7ab184SArchie Cobbs 	else if (strcmp(name, NG_MPPC_HOOK_DECOMP) == 0)
212af7ab184SArchie Cobbs 		hookPtr = &priv->recv.hook;
213af7ab184SArchie Cobbs 	else
214af7ab184SArchie Cobbs 		return (EINVAL);
215af7ab184SArchie Cobbs 
216af7ab184SArchie Cobbs 	/* See if already connected */
217af7ab184SArchie Cobbs 	if (*hookPtr != NULL)
218af7ab184SArchie Cobbs 		return (EISCONN);
219af7ab184SArchie Cobbs 
220af7ab184SArchie Cobbs 	/* OK */
221af7ab184SArchie Cobbs 	*hookPtr = hook;
222af7ab184SArchie Cobbs 	return (0);
223af7ab184SArchie Cobbs }
224af7ab184SArchie Cobbs 
225af7ab184SArchie Cobbs /*
226af7ab184SArchie Cobbs  * Receive a control message
227af7ab184SArchie Cobbs  */
228af7ab184SArchie Cobbs static int
229af7ab184SArchie Cobbs ng_mppc_rcvmsg(node_p node, struct ng_mesg *msg,
230af7ab184SArchie Cobbs 	      const char *raddr, struct ng_mesg **rptr)
231af7ab184SArchie Cobbs {
232af7ab184SArchie Cobbs 	const priv_p priv = node->private;
233af7ab184SArchie Cobbs 	struct ng_mesg *resp = NULL;
234af7ab184SArchie Cobbs 	int error = 0;
235af7ab184SArchie Cobbs 
236af7ab184SArchie Cobbs 	switch (msg->header.typecookie) {
237af7ab184SArchie Cobbs 	case NGM_MPPC_COOKIE:
238af7ab184SArchie Cobbs 		switch (msg->header.cmd) {
239af7ab184SArchie Cobbs 		case NGM_MPPC_CONFIG_COMP:
240af7ab184SArchie Cobbs 		case NGM_MPPC_CONFIG_DECOMP:
241af7ab184SArchie Cobbs 		    {
242af7ab184SArchie Cobbs 			struct ng_mppc_config *const cfg
243af7ab184SArchie Cobbs 			    = (struct ng_mppc_config *)msg->data;
244af7ab184SArchie Cobbs 			const int isComp =
245af7ab184SArchie Cobbs 			    msg->header.cmd == NGM_MPPC_CONFIG_COMP;
246af7ab184SArchie Cobbs 			struct ng_mppc_dir *const d = isComp ?
247af7ab184SArchie Cobbs 			    &priv->xmit : &priv->recv;
248af7ab184SArchie Cobbs 
249af7ab184SArchie Cobbs 			/* Check configuration */
250af7ab184SArchie Cobbs 			if (msg->header.arglen != sizeof(*cfg))
251af7ab184SArchie Cobbs 				ERROUT(EINVAL);
252af7ab184SArchie Cobbs 			if (cfg->enable) {
253af7ab184SArchie Cobbs 				if ((cfg->bits & ~MPPC_VALID_BITS) != 0)
254af7ab184SArchie Cobbs 					ERROUT(EINVAL);
255af7ab184SArchie Cobbs #ifndef NETGRAPH_MPPC_COMPRESSION
256af7ab184SArchie Cobbs 				if ((cfg->bits & MPPC_BIT) != 0)
257af7ab184SArchie Cobbs 					ERROUT(EPROTONOSUPPORT);
258af7ab184SArchie Cobbs #endif
259af7ab184SArchie Cobbs #ifndef NETGRAPH_MPPC_ENCRYPTION
260af7ab184SArchie Cobbs 				if ((cfg->bits & MPPE_BITS) != 0)
261af7ab184SArchie Cobbs 					ERROUT(EPROTONOSUPPORT);
262af7ab184SArchie Cobbs #endif
263af7ab184SArchie Cobbs 			} else
264af7ab184SArchie Cobbs 				cfg->bits = 0;
265af7ab184SArchie Cobbs 
266af7ab184SArchie Cobbs 			/* Save return address so we can send reset-req's */
267af7ab184SArchie Cobbs 			if (priv->ctrlpath != NULL) {
268af7ab184SArchie Cobbs 				FREE(priv->ctrlpath, M_NETGRAPH);
269af7ab184SArchie Cobbs 				priv->ctrlpath = NULL;
270af7ab184SArchie Cobbs 			}
271af7ab184SArchie Cobbs 			if (!isComp && raddr != NULL) {
272af7ab184SArchie Cobbs 				MALLOC(priv->ctrlpath, char *,
273af7ab184SArchie Cobbs 				    strlen(raddr) + 1, M_NETGRAPH, M_NOWAIT);
274af7ab184SArchie Cobbs 				if (priv->ctrlpath == NULL)
275af7ab184SArchie Cobbs 					ERROUT(ENOMEM);
276af7ab184SArchie Cobbs 				strcpy(priv->ctrlpath, raddr);
277af7ab184SArchie Cobbs 			}
278af7ab184SArchie Cobbs 
279af7ab184SArchie Cobbs 			/* Configuration is OK, reset to it */
280af7ab184SArchie Cobbs 			d->cfg = *cfg;
281af7ab184SArchie Cobbs 
282af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
283af7ab184SArchie Cobbs 			/* Initialize state buffers for compression */
284af7ab184SArchie Cobbs 			if (d->history != NULL) {
285af7ab184SArchie Cobbs 				FREE(d->history, M_NETGRAPH);
286af7ab184SArchie Cobbs 				d->history = NULL;
287af7ab184SArchie Cobbs 			}
288af7ab184SArchie Cobbs 			if ((cfg->bits & MPPC_BIT) != 0) {
289af7ab184SArchie Cobbs 				MALLOC(d->history, u_char *,
290af7ab184SArchie Cobbs 				    isComp ? MPPC_SizeOfCompressionHistory() :
291af7ab184SArchie Cobbs 				    MPPC_SizeOfDecompressionHistory(),
292af7ab184SArchie Cobbs 				    M_NETGRAPH, M_NOWAIT);
293af7ab184SArchie Cobbs 				if (d->history == NULL)
294af7ab184SArchie Cobbs 					ERROUT(ENOMEM);
295af7ab184SArchie Cobbs 				if (isComp)
296af7ab184SArchie Cobbs 					MPPC_InitCompressionHistory(d->history);
297af7ab184SArchie Cobbs 				else {
298af7ab184SArchie Cobbs 					MPPC_InitDecompressionHistory(
299af7ab184SArchie Cobbs 					    d->history);
300af7ab184SArchie Cobbs 				}
301af7ab184SArchie Cobbs 			}
302af7ab184SArchie Cobbs #endif
303af7ab184SArchie Cobbs 
304af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
305af7ab184SArchie Cobbs 			/* Generate initial session keys for encryption */
306af7ab184SArchie Cobbs 			if ((cfg->bits & MPPE_BITS) != 0) {
307af7ab184SArchie Cobbs 				const int keylen = KEYLEN(cfg->bits);
308af7ab184SArchie Cobbs 
309af7ab184SArchie Cobbs 				bcopy(cfg->startkey, d->key, keylen);
310af7ab184SArchie Cobbs 				ng_mppc_getkey(cfg->startkey, d->key, keylen);
311af7ab184SArchie Cobbs 				if ((cfg->bits & MPPE_128) == 0) {
312af7ab184SArchie Cobbs 					bcopy(&ng_mppe_weakenkey, d->key,
313af7ab184SArchie Cobbs 					    sizeof(ng_mppe_weakenkey));
314af7ab184SArchie Cobbs 				}
315af7ab184SArchie Cobbs 				rc4_init(&d->rc4, d->key, keylen);
316af7ab184SArchie Cobbs 			}
317af7ab184SArchie Cobbs #endif
318af7ab184SArchie Cobbs 
319af7ab184SArchie Cobbs 			/* Initialize other state */
320af7ab184SArchie Cobbs 			d->cc = 0;
321af7ab184SArchie Cobbs 			d->flushed = 0;
322af7ab184SArchie Cobbs 			break;
323af7ab184SArchie Cobbs 		    }
324af7ab184SArchie Cobbs 
325af7ab184SArchie Cobbs 		case NGM_MPPC_RESETREQ:
326af7ab184SArchie Cobbs 			ng_mppc_reset_req(node);
327af7ab184SArchie Cobbs 			break;
328af7ab184SArchie Cobbs 
329af7ab184SArchie Cobbs 		default:
330af7ab184SArchie Cobbs 			error = EINVAL;
331af7ab184SArchie Cobbs 			break;
332af7ab184SArchie Cobbs 		}
333af7ab184SArchie Cobbs 		break;
334af7ab184SArchie Cobbs 	default:
335af7ab184SArchie Cobbs 		error = EINVAL;
336af7ab184SArchie Cobbs 		break;
337af7ab184SArchie Cobbs 	}
338af7ab184SArchie Cobbs 	if (rptr)
339af7ab184SArchie Cobbs 		*rptr = resp;
340af7ab184SArchie Cobbs 	else if (resp)
341af7ab184SArchie Cobbs 		FREE(resp, M_NETGRAPH);
342af7ab184SArchie Cobbs 
343af7ab184SArchie Cobbs done:
344af7ab184SArchie Cobbs 	FREE(msg, M_NETGRAPH);
345af7ab184SArchie Cobbs 	return (error);
346af7ab184SArchie Cobbs }
347af7ab184SArchie Cobbs 
348af7ab184SArchie Cobbs /*
349af7ab184SArchie Cobbs  * Receive incoming data on our hook.
350af7ab184SArchie Cobbs  */
351af7ab184SArchie Cobbs static int
352af7ab184SArchie Cobbs ng_mppc_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
353af7ab184SArchie Cobbs {
354af7ab184SArchie Cobbs 	const node_p node = hook->node;
355af7ab184SArchie Cobbs 	const priv_p priv = node->private;
356af7ab184SArchie Cobbs 	struct mbuf *out;
357af7ab184SArchie Cobbs 	int error;
358af7ab184SArchie Cobbs 
359af7ab184SArchie Cobbs 	/* Compress and/or encrypt */
360af7ab184SArchie Cobbs 	if (hook == priv->xmit.hook) {
361af7ab184SArchie Cobbs 		if (!priv->xmit.cfg.enable) {
362af7ab184SArchie Cobbs 			NG_FREE_DATA(m, meta);
363af7ab184SArchie Cobbs 			return (ENXIO);
364af7ab184SArchie Cobbs 		}
365af7ab184SArchie Cobbs 		if ((error = ng_mppc_compress(node, m, &out)) != 0) {
366af7ab184SArchie Cobbs 			NG_FREE_DATA(m, meta);
367af7ab184SArchie Cobbs 			return(error);
368af7ab184SArchie Cobbs 		}
369af7ab184SArchie Cobbs 		m_freem(m);
370af7ab184SArchie Cobbs 		NG_SEND_DATA(error, priv->xmit.hook, out, meta);
371af7ab184SArchie Cobbs 		return (error);
372af7ab184SArchie Cobbs 	}
373af7ab184SArchie Cobbs 
374af7ab184SArchie Cobbs 	/* Decompress and/or decrypt */
375af7ab184SArchie Cobbs 	if (hook == priv->recv.hook) {
376af7ab184SArchie Cobbs 		if (!priv->recv.cfg.enable) {
377af7ab184SArchie Cobbs 			NG_FREE_DATA(m, meta);
378af7ab184SArchie Cobbs 			return (ENXIO);
379af7ab184SArchie Cobbs 		}
380af7ab184SArchie Cobbs 		if ((error = ng_mppc_decompress(node, m, &out)) != 0) {
381af7ab184SArchie Cobbs 			NG_FREE_DATA(m, meta);
382af7ab184SArchie Cobbs 			if (error == EINVAL && priv->ctrlpath != NULL) {
383af7ab184SArchie Cobbs 				struct ng_mesg *msg;
384af7ab184SArchie Cobbs 
385af7ab184SArchie Cobbs 				/* Need to send a reset-request */
386af7ab184SArchie Cobbs 				NG_MKMESSAGE(msg, NGM_MPPC_COOKIE,
387af7ab184SArchie Cobbs 				    NGM_MPPC_RESETREQ, 0, M_NOWAIT);
388af7ab184SArchie Cobbs 				if (msg == NULL)
389af7ab184SArchie Cobbs 					return (error);
390af7ab184SArchie Cobbs 				ng_send_msg(node, msg, priv->ctrlpath, NULL);
391af7ab184SArchie Cobbs 			}
392af7ab184SArchie Cobbs 			return (error);
393af7ab184SArchie Cobbs 		}
394af7ab184SArchie Cobbs 		m_freem(m);
395af7ab184SArchie Cobbs 		NG_SEND_DATA(error, priv->recv.hook, out, meta);
396af7ab184SArchie Cobbs 		return (error);
397af7ab184SArchie Cobbs 	}
398af7ab184SArchie Cobbs 
399af7ab184SArchie Cobbs 	/* Oops */
400af7ab184SArchie Cobbs 	panic("%s: unknown hook", __FUNCTION__);
401af7ab184SArchie Cobbs }
402af7ab184SArchie Cobbs 
403af7ab184SArchie Cobbs /*
404af7ab184SArchie Cobbs  * Destroy node
405af7ab184SArchie Cobbs  */
406af7ab184SArchie Cobbs static int
407af7ab184SArchie Cobbs ng_mppc_rmnode(node_p node)
408af7ab184SArchie Cobbs {
409af7ab184SArchie Cobbs 	const priv_p priv = node->private;
410af7ab184SArchie Cobbs 
411af7ab184SArchie Cobbs 	/* Take down netgraph node */
412af7ab184SArchie Cobbs 	node->flags |= NG_INVALID;
413af7ab184SArchie Cobbs 	ng_cutlinks(node);
414af7ab184SArchie Cobbs 	ng_unname(node);
415af7ab184SArchie Cobbs 	if (priv->ctrlpath != NULL)
416af7ab184SArchie Cobbs 		FREE(priv->ctrlpath, M_NETGRAPH);
417af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
418af7ab184SArchie Cobbs 	if (priv->xmit.history != NULL)
419af7ab184SArchie Cobbs 		FREE(priv->xmit.history, M_NETGRAPH);
420af7ab184SArchie Cobbs 	if (priv->recv.history != NULL)
421af7ab184SArchie Cobbs 		FREE(priv->recv.history, M_NETGRAPH);
422af7ab184SArchie Cobbs #endif
423af7ab184SArchie Cobbs 	bzero(priv, sizeof(*priv));
424af7ab184SArchie Cobbs 	FREE(priv, M_NETGRAPH);
425af7ab184SArchie Cobbs 	node->private = NULL;
426af7ab184SArchie Cobbs 	ng_unref(node);		/* let the node escape */
427af7ab184SArchie Cobbs 	return (0);
428af7ab184SArchie Cobbs }
429af7ab184SArchie Cobbs 
430af7ab184SArchie Cobbs /*
431af7ab184SArchie Cobbs  * Hook disconnection
432af7ab184SArchie Cobbs  */
433af7ab184SArchie Cobbs static int
434af7ab184SArchie Cobbs ng_mppc_disconnect(hook_p hook)
435af7ab184SArchie Cobbs {
436af7ab184SArchie Cobbs 	const node_p node = hook->node;
437af7ab184SArchie Cobbs 	const priv_p priv = node->private;
438af7ab184SArchie Cobbs 
439af7ab184SArchie Cobbs 	/* Zero out hook pointer */
440af7ab184SArchie Cobbs 	if (hook == priv->xmit.hook)
441af7ab184SArchie Cobbs 		priv->xmit.hook = NULL;
442af7ab184SArchie Cobbs 	if (hook == priv->recv.hook)
443af7ab184SArchie Cobbs 		priv->recv.hook = NULL;
444af7ab184SArchie Cobbs 
445af7ab184SArchie Cobbs 	/* Go away if no longer connected */
446af7ab184SArchie Cobbs 	if (node->numhooks == 0)
447af7ab184SArchie Cobbs 		ng_rmnode(node);
448af7ab184SArchie Cobbs 	return (0);
449af7ab184SArchie Cobbs }
450af7ab184SArchie Cobbs 
451af7ab184SArchie Cobbs /************************************************************************
452af7ab184SArchie Cobbs 			HELPER STUFF
453af7ab184SArchie Cobbs  ************************************************************************/
454af7ab184SArchie Cobbs 
455af7ab184SArchie Cobbs /*
456af7ab184SArchie Cobbs  * Compress/encrypt a packet and put the result in a new mbuf at *resultp.
457af7ab184SArchie Cobbs  * The original mbuf is not free'd.
458af7ab184SArchie Cobbs  */
459af7ab184SArchie Cobbs static int
460af7ab184SArchie Cobbs ng_mppc_compress(node_p node, struct mbuf *m, struct mbuf **resultp)
461af7ab184SArchie Cobbs {
462af7ab184SArchie Cobbs 	const priv_p priv = node->private;
463af7ab184SArchie Cobbs 	struct ng_mppc_dir *const d = &priv->xmit;
464af7ab184SArchie Cobbs 	u_char *inbuf, *outbuf;
465af7ab184SArchie Cobbs 	int outlen, inlen;
466af7ab184SArchie Cobbs 	u_int16_t header;
467af7ab184SArchie Cobbs 
468af7ab184SArchie Cobbs 	/* Initialize */
469af7ab184SArchie Cobbs 	*resultp = NULL;
470af7ab184SArchie Cobbs 	header = d->cc;
471af7ab184SArchie Cobbs 	if (d->flushed) {
472af7ab184SArchie Cobbs 		header |= MPPC_FLAG_FLUSHED;
473af7ab184SArchie Cobbs 		d->flushed = 0;
474af7ab184SArchie Cobbs 	}
475af7ab184SArchie Cobbs 
476af7ab184SArchie Cobbs 	/* Work with contiguous regions of memory */
477af7ab184SArchie Cobbs 	inlen = m->m_pkthdr.len;
478af7ab184SArchie Cobbs 	MALLOC(inbuf, u_char *, inlen, M_NETGRAPH, M_NOWAIT);
479af7ab184SArchie Cobbs 	if (inbuf == NULL)
480af7ab184SArchie Cobbs 		return (ENOMEM);
481af7ab184SArchie Cobbs 	m_copydata(m, 0, inlen, (caddr_t)inbuf);
482af7ab184SArchie Cobbs 	if ((d->cfg.bits & MPPC_BIT) != 0)
483af7ab184SArchie Cobbs 		outlen = MPPC_MAX_BLOWUP(inlen);
484af7ab184SArchie Cobbs 	else
485af7ab184SArchie Cobbs 		outlen = MPPC_HDRLEN + inlen;
486af7ab184SArchie Cobbs 	MALLOC(outbuf, u_char *, outlen, M_NETGRAPH, M_WAITOK);
487af7ab184SArchie Cobbs 	if (outbuf == NULL) {
488af7ab184SArchie Cobbs 		FREE(inbuf, M_NETGRAPH);
489af7ab184SArchie Cobbs 		return (ENOMEM);
490af7ab184SArchie Cobbs 	}
491af7ab184SArchie Cobbs 
492af7ab184SArchie Cobbs 	/* Compress "inbuf" into "outbuf" (if compression enabled) */
493af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
494af7ab184SArchie Cobbs 	if ((d->cfg.bits & MPPC_BIT) != 0) {
495af7ab184SArchie Cobbs 		u_short flags = MPPC_MANDATORY_COMPRESS_FLAGS;
496af7ab184SArchie Cobbs 		u_char *source, *dest;
497af7ab184SArchie Cobbs 		u_long sourceCnt, destCnt;
498af7ab184SArchie Cobbs 		int rtn;
499af7ab184SArchie Cobbs 
500af7ab184SArchie Cobbs 		/* Prepare to compress */
501af7ab184SArchie Cobbs 		source = inbuf;
502af7ab184SArchie Cobbs 		sourceCnt = inlen;
503af7ab184SArchie Cobbs 		dest = outbuf + MPPC_HDRLEN;
504af7ab184SArchie Cobbs 		destCnt = outlen - MPPC_HDRLEN;
505af7ab184SArchie Cobbs 		if ((d->cfg.bits & MPPE_STATELESS) == 0)
506af7ab184SArchie Cobbs 			flags |= MPPC_SAVE_HISTORY;
507af7ab184SArchie Cobbs 
508af7ab184SArchie Cobbs 		/* Compress */
509af7ab184SArchie Cobbs 		rtn = MPPC_Compress(&source, &dest, &sourceCnt,
510af7ab184SArchie Cobbs 			&destCnt, d->history, flags, 0);
511af7ab184SArchie Cobbs 
512af7ab184SArchie Cobbs 		/* Check return value */
513af7ab184SArchie Cobbs 		KASSERT(rtn != MPPC_INVALID, ("%s: invalid", __FUNCTION__));
514af7ab184SArchie Cobbs 		if ((rtn & MPPC_EXPANDED) == 0
515af7ab184SArchie Cobbs 		    && (rtn & MPPC_COMP_OK) == MPPC_COMP_OK) {
516af7ab184SArchie Cobbs 			outlen -= destCnt;
517af7ab184SArchie Cobbs 			header |= MPPC_FLAG_COMPRESSED;
518af7ab184SArchie Cobbs 			if ((rtn & MPPC_RESTART_HISTORY) != 0)
519af7ab184SArchie Cobbs 				header |= MPPC_FLAG_RESTART;
520af7ab184SArchie Cobbs 		}
521af7ab184SArchie Cobbs 		d->flushed = (rtn & MPPC_EXPANDED) != 0
522af7ab184SArchie Cobbs 		    || (flags & MPPC_SAVE_HISTORY) == 0;
523af7ab184SArchie Cobbs 	}
524af7ab184SArchie Cobbs #endif
525af7ab184SArchie Cobbs 
526af7ab184SArchie Cobbs 	/* If we did not compress this packet, copy it to output buffer */
527af7ab184SArchie Cobbs 	if ((header & MPPC_FLAG_COMPRESSED) == 0) {
528af7ab184SArchie Cobbs 		bcopy(inbuf, outbuf + MPPC_HDRLEN, inlen);
529af7ab184SArchie Cobbs 		outlen = MPPC_HDRLEN + inlen;
530af7ab184SArchie Cobbs 	}
531af7ab184SArchie Cobbs 	FREE(inbuf, M_NETGRAPH);
532af7ab184SArchie Cobbs 
533af7ab184SArchie Cobbs 	/* Always set the flushed bit in stateless mode */
534af7ab184SArchie Cobbs 	if ((d->cfg.bits & MPPE_STATELESS) != 0)
535af7ab184SArchie Cobbs 		header |= MPPC_FLAG_FLUSHED;
536af7ab184SArchie Cobbs 
537af7ab184SArchie Cobbs 	/* Now encrypt packet (if encryption enabled) */
538af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
539af7ab184SArchie Cobbs 	if ((d->cfg.bits & MPPE_BITS) != 0) {
540af7ab184SArchie Cobbs 
541af7ab184SArchie Cobbs 		/* Set header bits; need to reset key if we say we did */
542af7ab184SArchie Cobbs 		header |= MPPC_FLAG_ENCRYPTED;
543af7ab184SArchie Cobbs 		if ((header & MPPC_FLAG_FLUSHED) != 0)
544af7ab184SArchie Cobbs 			rc4_init(&d->rc4, d->key, KEYLEN(d->cfg.bits));
545af7ab184SArchie Cobbs 
546af7ab184SArchie Cobbs 		/* Update key if it's time */
547af7ab184SArchie Cobbs 		if ((d->cfg.bits & MPPE_STATELESS) != 0
548af7ab184SArchie Cobbs 		    || (d->cc & MPPE_UPDATE_MASK) == MPPE_UPDATE_FLAG) {
549af7ab184SArchie Cobbs 			  ng_mppc_updatekey(d->cfg.bits,
550af7ab184SArchie Cobbs 			      d->cfg.startkey, d->key, &d->rc4);
551af7ab184SArchie Cobbs 		}
552af7ab184SArchie Cobbs 
553af7ab184SArchie Cobbs 		/* Encrypt packet */
554af7ab184SArchie Cobbs 		rc4_crypt(&d->rc4, outbuf + MPPC_HDRLEN,
555af7ab184SArchie Cobbs 			outbuf + MPPC_HDRLEN, outlen - MPPC_HDRLEN);
556af7ab184SArchie Cobbs 	}
557af7ab184SArchie Cobbs #endif
558af7ab184SArchie Cobbs 
559af7ab184SArchie Cobbs 	/* Update sequence number */
560af7ab184SArchie Cobbs 	d->cc++;
561af7ab184SArchie Cobbs 
562af7ab184SArchie Cobbs 	/* Install header */
563af7ab184SArchie Cobbs 	*((u_int16_t *)outbuf) = htons(header);
564af7ab184SArchie Cobbs 
565af7ab184SArchie Cobbs 	/* Return packet in an mbuf */
566af7ab184SArchie Cobbs 	*resultp = m_devget((caddr_t)outbuf, outlen, 0, NULL, NULL);
567af7ab184SArchie Cobbs 	FREE(outbuf, M_NETGRAPH);
568af7ab184SArchie Cobbs 	return (*resultp == NULL ? ENOBUFS : 0);
569af7ab184SArchie Cobbs }
570af7ab184SArchie Cobbs 
571af7ab184SArchie Cobbs /*
572af7ab184SArchie Cobbs  * Decompress/decrypt packet and put the result in a new mbuf at *resultp.
573af7ab184SArchie Cobbs  * The original mbuf is not free'd.
574af7ab184SArchie Cobbs  */
575af7ab184SArchie Cobbs static int
576af7ab184SArchie Cobbs ng_mppc_decompress(node_p node, struct mbuf *m, struct mbuf **resultp)
577af7ab184SArchie Cobbs {
578af7ab184SArchie Cobbs 	const priv_p priv = node->private;
579af7ab184SArchie Cobbs 	struct ng_mppc_dir *const d = &priv->recv;
580af7ab184SArchie Cobbs 	u_int16_t header, cc, numLost;
581af7ab184SArchie Cobbs 	u_char *buf;
582af7ab184SArchie Cobbs 	int len;
583af7ab184SArchie Cobbs 
584af7ab184SArchie Cobbs 	/* Pull off header */
585af7ab184SArchie Cobbs 	if (m->m_pkthdr.len < MPPC_HDRLEN)
586af7ab184SArchie Cobbs 		return (EINVAL);
587af7ab184SArchie Cobbs 	m_copydata(m, 0, MPPC_HDRLEN, (caddr_t)&header);
588af7ab184SArchie Cobbs 	NTOHS(header);
589af7ab184SArchie Cobbs 	cc = (header & MPPC_CCOUNT_MASK);
590af7ab184SArchie Cobbs 
591af7ab184SArchie Cobbs 	/* Copy payload into a contiguous region of memory */
592af7ab184SArchie Cobbs 	len = m->m_pkthdr.len - MPPC_HDRLEN;
593af7ab184SArchie Cobbs 	MALLOC(buf, u_char *, len, M_NETGRAPH, M_NOWAIT);
594af7ab184SArchie Cobbs 	if (buf == NULL)
595af7ab184SArchie Cobbs 		return (ENOMEM);
596af7ab184SArchie Cobbs 	m_copydata(m, MPPC_HDRLEN, len, (caddr_t)buf);
597af7ab184SArchie Cobbs 
598af7ab184SArchie Cobbs 	/* Check for insane jumps in sequence numbering (D.O.S. attack) */
599af7ab184SArchie Cobbs 	numLost = ((cc - d->cc) & MPPC_CCOUNT_MASK);
600af7ab184SArchie Cobbs 	if (numLost >= MPPC_INSANE_JUMP) {
601af7ab184SArchie Cobbs 		log(LOG_ERR, "%s: insane jump %d", __FUNCTION__, numLost);
602af7ab184SArchie Cobbs 		priv->recv.cfg.enable = 0;
603af7ab184SArchie Cobbs 		goto failed;
604af7ab184SArchie Cobbs 	}
605af7ab184SArchie Cobbs 
606af7ab184SArchie Cobbs 	/* If flushed bit set, we can always handle packet */
607af7ab184SArchie Cobbs 	if ((header & MPPC_FLAG_FLUSHED) != 0) {
608af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
609af7ab184SArchie Cobbs 		if (d->history != NULL)
610af7ab184SArchie Cobbs 			MPPC_InitDecompressionHistory(d->history);
611af7ab184SArchie Cobbs #endif
612af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
613af7ab184SArchie Cobbs 		if ((d->cfg.bits & MPPE_BITS) != 0) {
614af7ab184SArchie Cobbs 
615af7ab184SArchie Cobbs 			/* Resync as necessary, skipping lost packets */
616af7ab184SArchie Cobbs 			while (d->cc != cc) {
617af7ab184SArchie Cobbs 				if ((d->cfg.bits & MPPE_STATELESS)
618af7ab184SArchie Cobbs 				    || (d->cc & MPPE_UPDATE_MASK)
619af7ab184SArchie Cobbs 				      == MPPE_UPDATE_FLAG) {
620af7ab184SArchie Cobbs 					ng_mppc_updatekey(d->cfg.bits,
621af7ab184SArchie Cobbs 					    d->cfg.startkey, d->key, &d->rc4);
622af7ab184SArchie Cobbs 				}
623af7ab184SArchie Cobbs 				d->cc++;
624af7ab184SArchie Cobbs 			}
625af7ab184SArchie Cobbs 
626af7ab184SArchie Cobbs 			/* Reset key (except in stateless mode, see below) */
627af7ab184SArchie Cobbs 			if ((d->cfg.bits & MPPE_STATELESS) == 0)
628af7ab184SArchie Cobbs 				rc4_init(&d->rc4, d->key, KEYLEN(d->cfg.bits));
629af7ab184SArchie Cobbs 		}
630af7ab184SArchie Cobbs #endif
631af7ab184SArchie Cobbs 		d->cc = cc;		/* skip over lost seq numbers */
632af7ab184SArchie Cobbs 		numLost = 0;		/* act like no packets were lost */
633af7ab184SArchie Cobbs 	}
634af7ab184SArchie Cobbs 
635af7ab184SArchie Cobbs 	/* Can't decode non-sequential packets without a flushed bit */
636af7ab184SArchie Cobbs 	if (numLost != 0)
637af7ab184SArchie Cobbs 		goto failed;
638af7ab184SArchie Cobbs 
639af7ab184SArchie Cobbs 	/* Decrypt packet */
640af7ab184SArchie Cobbs 	if ((header & MPPC_FLAG_ENCRYPTED) != 0) {
641af7ab184SArchie Cobbs 
642af7ab184SArchie Cobbs 		/* Are we not expecting encryption? */
643af7ab184SArchie Cobbs 		if ((d->cfg.bits & MPPE_BITS) == 0) {
644af7ab184SArchie Cobbs 			log(LOG_ERR, "%s: rec'd unexpectedly %s packet",
645af7ab184SArchie Cobbs 				__FUNCTION__, "encrypted");
646af7ab184SArchie Cobbs 			goto failed;
647af7ab184SArchie Cobbs 		}
648af7ab184SArchie Cobbs 
649af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
650af7ab184SArchie Cobbs 		/* Update key if it's time (always in stateless mode) */
651af7ab184SArchie Cobbs 		if ((d->cfg.bits & MPPE_STATELESS) != 0
652af7ab184SArchie Cobbs 		    || (d->cc & MPPE_UPDATE_MASK) == MPPE_UPDATE_FLAG) {
653af7ab184SArchie Cobbs 			ng_mppc_updatekey(d->cfg.bits,
654af7ab184SArchie Cobbs 			    d->cfg.startkey, d->key, &d->rc4);
655af7ab184SArchie Cobbs 		}
656af7ab184SArchie Cobbs 
657af7ab184SArchie Cobbs 		/* Decrypt packet */
658af7ab184SArchie Cobbs 		rc4_crypt(&d->rc4, buf, buf, len);
659af7ab184SArchie Cobbs #endif
660af7ab184SArchie Cobbs 	} else {
661af7ab184SArchie Cobbs 
662af7ab184SArchie Cobbs 		/* Are we expecting encryption? */
663af7ab184SArchie Cobbs 		if ((d->cfg.bits & MPPE_BITS) != 0) {
664af7ab184SArchie Cobbs 			log(LOG_ERR, "%s: rec'd unexpectedly %s packet",
665af7ab184SArchie Cobbs 				__FUNCTION__, "unencrypted");
666af7ab184SArchie Cobbs 			goto failed;
667af7ab184SArchie Cobbs 		}
668af7ab184SArchie Cobbs 	}
669af7ab184SArchie Cobbs 
670af7ab184SArchie Cobbs 	/* Update coherency count for next time (12 bit arithmetic) */
671af7ab184SArchie Cobbs 	d->cc++;
672af7ab184SArchie Cobbs 
673af7ab184SArchie Cobbs 	/* Check for unexpected compressed packet */
674af7ab184SArchie Cobbs 	if ((header & MPPC_FLAG_COMPRESSED) != 0
675af7ab184SArchie Cobbs 	    && (d->cfg.bits & MPPC_BIT) == 0) {
676af7ab184SArchie Cobbs 		log(LOG_ERR, "%s: rec'd unexpectedly %s packet",
677af7ab184SArchie Cobbs 			__FUNCTION__, "compressed");
678af7ab184SArchie Cobbs failed:
679af7ab184SArchie Cobbs 		FREE(buf, M_NETGRAPH);
680af7ab184SArchie Cobbs 		return (EINVAL);
681af7ab184SArchie Cobbs 	}
682af7ab184SArchie Cobbs 
683af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
684af7ab184SArchie Cobbs 	/* Decompress packet */
685af7ab184SArchie Cobbs 	if ((header & MPPC_FLAG_COMPRESSED) != 0) {
686af7ab184SArchie Cobbs 		int flags = MPPC_MANDATORY_DECOMPRESS_FLAGS;
687af7ab184SArchie Cobbs 		u_char *decompbuf, *source, *dest;
688af7ab184SArchie Cobbs 		u_long sourceCnt, destCnt;
689af7ab184SArchie Cobbs 		int decomplen, rtn;
690af7ab184SArchie Cobbs 
691af7ab184SArchie Cobbs 		/* Allocate a buffer for decompressed data */
692af7ab184SArchie Cobbs 		MALLOC(decompbuf, u_char *, MPPC_DECOMP_BUFSIZE
693af7ab184SArchie Cobbs 		    + MPPC_DECOMP_SAFETY, M_NETGRAPH, M_NOWAIT);
694af7ab184SArchie Cobbs 		if (decompbuf == NULL) {
695af7ab184SArchie Cobbs 			FREE(buf, M_NETGRAPH);
696af7ab184SArchie Cobbs 			return (ENOMEM);
697af7ab184SArchie Cobbs 		}
698af7ab184SArchie Cobbs 		decomplen = MPPC_DECOMP_BUFSIZE;
699af7ab184SArchie Cobbs 
700af7ab184SArchie Cobbs 		/* Prepare to decompress */
701af7ab184SArchie Cobbs 		source = buf;
702af7ab184SArchie Cobbs 		sourceCnt = len;
703af7ab184SArchie Cobbs 		dest = decompbuf;
704af7ab184SArchie Cobbs 		destCnt = decomplen;
705af7ab184SArchie Cobbs 		if ((header & MPPC_FLAG_RESTART) != 0)
706af7ab184SArchie Cobbs 			flags |= MPPC_RESTART_HISTORY;
707af7ab184SArchie Cobbs 
708af7ab184SArchie Cobbs 		/* Decompress */
709af7ab184SArchie Cobbs 		rtn = MPPC_Decompress(&source, &dest,
710af7ab184SArchie Cobbs 			&sourceCnt, &destCnt, d->history, flags);
711af7ab184SArchie Cobbs 
712af7ab184SArchie Cobbs 		/* Check return value */
713af7ab184SArchie Cobbs 		KASSERT(rtn != MPPC_INVALID, ("%s: invalid", __FUNCTION__));
714af7ab184SArchie Cobbs 		if ((rtn & MPPC_DEST_EXHAUSTED) != 0
715af7ab184SArchie Cobbs 		    || (rtn & MPPC_DECOMP_OK) != MPPC_DECOMP_OK) {
716af7ab184SArchie Cobbs 			log(LOG_ERR, "%s: decomp returned 0x%x",
717af7ab184SArchie Cobbs 			    __FUNCTION__, rtn);
718af7ab184SArchie Cobbs 			FREE(decompbuf, M_NETGRAPH);
719af7ab184SArchie Cobbs 			goto failed;
720af7ab184SArchie Cobbs 		}
721af7ab184SArchie Cobbs 
722af7ab184SArchie Cobbs 		/* Replace compressed data with decompressed data */
723af7ab184SArchie Cobbs 		FREE(buf, M_NETGRAPH);
724af7ab184SArchie Cobbs 		buf = decompbuf;
725af7ab184SArchie Cobbs 		len = decomplen - destCnt;
726af7ab184SArchie Cobbs 	}
727af7ab184SArchie Cobbs #endif
728af7ab184SArchie Cobbs 
729af7ab184SArchie Cobbs 	/* Return result in an mbuf */
730af7ab184SArchie Cobbs 	*resultp = m_devget((caddr_t)buf, len, 0, NULL, NULL);
731af7ab184SArchie Cobbs 	FREE(buf, M_NETGRAPH);
732af7ab184SArchie Cobbs 	return (*resultp == NULL ? ENOBUFS : 0);
733af7ab184SArchie Cobbs }
734af7ab184SArchie Cobbs 
735af7ab184SArchie Cobbs /*
736af7ab184SArchie Cobbs  * The peer has sent us a CCP ResetRequest, so reset our transmit state.
737af7ab184SArchie Cobbs  */
738af7ab184SArchie Cobbs static void
739af7ab184SArchie Cobbs ng_mppc_reset_req(node_p node)
740af7ab184SArchie Cobbs {
741af7ab184SArchie Cobbs 	const priv_p priv = node->private;
742af7ab184SArchie Cobbs 	struct ng_mppc_dir *const d = &priv->xmit;
743af7ab184SArchie Cobbs 
744af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_COMPRESSION
745af7ab184SArchie Cobbs 	if (d->history != NULL)
746af7ab184SArchie Cobbs 		MPPC_InitCompressionHistory(d->history);
747af7ab184SArchie Cobbs #endif
748af7ab184SArchie Cobbs #ifdef NETGRAPH_MPPC_ENCRYPTION
749af7ab184SArchie Cobbs 	if ((d->cfg.bits & MPPE_STATELESS) == 0)
750af7ab184SArchie Cobbs 		rc4_init(&d->rc4, d->key, KEYLEN(d->cfg.bits));
751af7ab184SArchie Cobbs #endif
752af7ab184SArchie Cobbs 	d->flushed = 1;
753af7ab184SArchie Cobbs }
754af7ab184SArchie Cobbs 
755af7ab184SArchie Cobbs /*
756af7ab184SArchie Cobbs  * Generate a new encryption key
757af7ab184SArchie Cobbs  */
758af7ab184SArchie Cobbs static void
759af7ab184SArchie Cobbs ng_mppc_getkey(const u_char *h, u_char *h2, int len)
760af7ab184SArchie Cobbs {
761af7ab184SArchie Cobbs 	static const u_char pad1[10] =
762af7ab184SArchie Cobbs 	    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
763af7ab184SArchie Cobbs 	static const u_char pad2[10] =
764af7ab184SArchie Cobbs 	    { 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, };
765af7ab184SArchie Cobbs 	u_char hash[20];
766af7ab184SArchie Cobbs 	SHA1_CTX c;
767af7ab184SArchie Cobbs 	int k;
768af7ab184SArchie Cobbs 
769af7ab184SArchie Cobbs 	bzero(&hash, sizeof(hash));
770af7ab184SArchie Cobbs 	SHA1Init(&c);
771af7ab184SArchie Cobbs 	SHA1Update(&c, h, len);
772af7ab184SArchie Cobbs 	for (k = 0; k < 4; k++)
773af7ab184SArchie Cobbs 		SHA1Update(&c, pad1, sizeof(pad2));
774af7ab184SArchie Cobbs 	SHA1Update(&c, h2, len);
775af7ab184SArchie Cobbs 	for (k = 0; k < 4; k++)
776af7ab184SArchie Cobbs 		SHA1Update(&c, pad2, sizeof(pad2));
777af7ab184SArchie Cobbs 	SHA1Final(hash, &c);
778af7ab184SArchie Cobbs 	bcopy(hash, h2, len);
779af7ab184SArchie Cobbs }
780af7ab184SArchie Cobbs 
781af7ab184SArchie Cobbs /*
782af7ab184SArchie Cobbs  * Update the encryption key
783af7ab184SArchie Cobbs  */
784af7ab184SArchie Cobbs static void
785af7ab184SArchie Cobbs ng_mppc_updatekey(u_int32_t bits,
786af7ab184SArchie Cobbs 	u_char *key0, u_char *key, struct rc4_state *rc4)
787af7ab184SArchie Cobbs {
788af7ab184SArchie Cobbs 	const int keylen = KEYLEN(bits);
789af7ab184SArchie Cobbs 
790af7ab184SArchie Cobbs 	ng_mppc_getkey(key0, key, keylen);
791af7ab184SArchie Cobbs 	rc4_init(rc4, key, keylen);
792af7ab184SArchie Cobbs 	rc4_crypt(rc4, key, key, keylen);
793af7ab184SArchie Cobbs 	if ((bits & MPPE_128) == 0)
794af7ab184SArchie Cobbs 		bcopy(&ng_mppe_weakenkey, key, sizeof(ng_mppe_weakenkey));
795af7ab184SArchie Cobbs 	rc4_init(rc4, key, keylen);
796af7ab184SArchie Cobbs }
797af7ab184SArchie Cobbs 
798