1 /*
2 * ppp_mppe.c - interface MPPE to the PPP code.
3 * This version is for use with Linux kernel 2.6.14+
4 *
5 * By Frank Cusack <fcusack@fcusack.com>.
6 * Copyright (c) 2002,2003,2004 Google, Inc.
7 * All rights reserved.
8 *
9 * License:
10 * Permission to use, copy, modify, and distribute this software and its
11 * documentation is hereby granted, provided that the above copyright
12 * notice appears in all copies. This software is provided without any
13 * warranty, express or implied.
14 *
15 * ALTERNATIVELY, provided that this notice is retained in full, this product
16 * may be distributed under the terms of the GNU General Public License (GPL),
17 * in which case the provisions of the GPL apply INSTEAD OF those given above.
18 *
19 * This program is free software; you can redistribute it and/or modify
20 * it under the terms of the GNU General Public License as published by
21 * the Free Software Foundation; either version 2 of the License, or
22 * (at your option) any later version.
23 *
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, see <http://www.gnu.org/licenses/>.
31 *
32 *
33 * Changelog:
34 * 08/12/05 - Matt Domsch <Matt_Domsch@dell.com>
35 * Only need extra skb padding on transmit, not receive.
36 * 06/18/04 - Matt Domsch <Matt_Domsch@dell.com>, Oleg Makarenko <mole@quadra.ru>
37 * Use Linux kernel 2.6 arc4 and sha1 routines rather than
38 * providing our own.
39 * 2/15/04 - TS: added #include <version.h> and testing for Kernel
40 * version before using
41 * MOD_DEC_USAGE_COUNT/MOD_INC_USAGE_COUNT which are
42 * deprecated in 2.6
43 */
44
45 #include <crypto/hash.h>
46 #include <crypto/skcipher.h>
47 #include <linux/err.h>
48 #include <linux/module.h>
49 #include <linux/kernel.h>
50 #include <linux/init.h>
51 #include <linux/types.h>
52 #include <linux/slab.h>
53 #include <linux/string.h>
54 #include <linux/mm.h>
55 #include <linux/ppp_defs.h>
56 #include <linux/ppp-comp.h>
57 #include <linux/scatterlist.h>
58 #include <asm/unaligned.h>
59
60 #include "ppp_mppe.h"
61
62 MODULE_AUTHOR("Frank Cusack <fcusack@fcusack.com>");
63 MODULE_DESCRIPTION("Point-to-Point Protocol Microsoft Point-to-Point Encryption support");
64 MODULE_LICENSE("Dual BSD/GPL");
65 MODULE_ALIAS("ppp-compress-" __stringify(CI_MPPE));
66 MODULE_VERSION("1.0.2");
67
68 static unsigned int
setup_sg(struct scatterlist * sg,const void * address,unsigned int length)69 setup_sg(struct scatterlist *sg, const void *address, unsigned int length)
70 {
71 sg_set_buf(sg, address, length);
72 return length;
73 }
74
75 #define SHA1_PAD_SIZE 40
76
77 /*
78 * kernel crypto API needs its arguments to be in kmalloc'd memory, not in the module
79 * static data area. That means sha_pad needs to be kmalloc'd.
80 */
81
82 struct sha_pad {
83 unsigned char sha_pad1[SHA1_PAD_SIZE];
84 unsigned char sha_pad2[SHA1_PAD_SIZE];
85 };
86 static struct sha_pad *sha_pad;
87
sha_pad_init(struct sha_pad * shapad)88 static inline void sha_pad_init(struct sha_pad *shapad)
89 {
90 memset(shapad->sha_pad1, 0x00, sizeof(shapad->sha_pad1));
91 memset(shapad->sha_pad2, 0xF2, sizeof(shapad->sha_pad2));
92 }
93
94 /*
95 * State for an MPPE (de)compressor.
96 */
97 struct ppp_mppe_state {
98 struct crypto_skcipher *arc4;
99 struct shash_desc *sha1;
100 unsigned char *sha1_digest;
101 unsigned char master_key[MPPE_MAX_KEY_LEN];
102 unsigned char session_key[MPPE_MAX_KEY_LEN];
103 unsigned keylen; /* key length in bytes */
104 /* NB: 128-bit == 16, 40-bit == 8! */
105 /* If we want to support 56-bit, */
106 /* the unit has to change to bits */
107 unsigned char bits; /* MPPE control bits */
108 unsigned ccount; /* 12-bit coherency count (seqno) */
109 unsigned stateful; /* stateful mode flag */
110 int discard; /* stateful mode packet loss flag */
111 int sanity_errors; /* take down LCP if too many */
112 int unit;
113 int debug;
114 struct compstat stats;
115 };
116
117 /* struct ppp_mppe_state.bits definitions */
118 #define MPPE_BIT_A 0x80 /* Encryption table were (re)inititalized */
119 #define MPPE_BIT_B 0x40 /* MPPC only (not implemented) */
120 #define MPPE_BIT_C 0x20 /* MPPC only (not implemented) */
121 #define MPPE_BIT_D 0x10 /* This is an encrypted frame */
122
123 #define MPPE_BIT_FLUSHED MPPE_BIT_A
124 #define MPPE_BIT_ENCRYPTED MPPE_BIT_D
125
126 #define MPPE_BITS(p) ((p)[4] & 0xf0)
127 #define MPPE_CCOUNT(p) ((((p)[4] & 0x0f) << 8) + (p)[5])
128 #define MPPE_CCOUNT_SPACE 0x1000 /* The size of the ccount space */
129
130 #define MPPE_OVHD 2 /* MPPE overhead/packet */
131 #define SANITY_MAX 1600 /* Max bogon factor we will tolerate */
132
133 /*
134 * Key Derivation, from RFC 3078, RFC 3079.
135 * Equivalent to Get_Key() for MS-CHAP as described in RFC 3079.
136 */
get_new_key_from_sha(struct ppp_mppe_state * state)137 static void get_new_key_from_sha(struct ppp_mppe_state * state)
138 {
139 crypto_shash_init(state->sha1);
140 crypto_shash_update(state->sha1, state->master_key,
141 state->keylen);
142 crypto_shash_update(state->sha1, sha_pad->sha_pad1,
143 sizeof(sha_pad->sha_pad1));
144 crypto_shash_update(state->sha1, state->session_key,
145 state->keylen);
146 crypto_shash_update(state->sha1, sha_pad->sha_pad2,
147 sizeof(sha_pad->sha_pad2));
148 crypto_shash_final(state->sha1, state->sha1_digest);
149 }
150
151 /*
152 * Perform the MPPE rekey algorithm, from RFC 3078, sec. 7.3.
153 * Well, not what's written there, but rather what they meant.
154 */
mppe_rekey(struct ppp_mppe_state * state,int initial_key)155 static void mppe_rekey(struct ppp_mppe_state * state, int initial_key)
156 {
157 struct scatterlist sg_in[1], sg_out[1];
158 SKCIPHER_REQUEST_ON_STACK(req, state->arc4);
159
160 skcipher_request_set_tfm(req, state->arc4);
161 skcipher_request_set_callback(req, 0, NULL, NULL);
162
163 get_new_key_from_sha(state);
164 if (!initial_key) {
165 crypto_skcipher_setkey(state->arc4, state->sha1_digest,
166 state->keylen);
167 sg_init_table(sg_in, 1);
168 sg_init_table(sg_out, 1);
169 setup_sg(sg_in, state->sha1_digest, state->keylen);
170 setup_sg(sg_out, state->session_key, state->keylen);
171 skcipher_request_set_crypt(req, sg_in, sg_out, state->keylen,
172 NULL);
173 if (crypto_skcipher_encrypt(req))
174 printk(KERN_WARNING "mppe_rekey: cipher_encrypt failed\n");
175 } else {
176 memcpy(state->session_key, state->sha1_digest, state->keylen);
177 }
178 if (state->keylen == 8) {
179 /* See RFC 3078 */
180 state->session_key[0] = 0xd1;
181 state->session_key[1] = 0x26;
182 state->session_key[2] = 0x9e;
183 }
184 crypto_skcipher_setkey(state->arc4, state->session_key, state->keylen);
185 skcipher_request_zero(req);
186 }
187
188 /*
189 * Allocate space for a (de)compressor.
190 */
mppe_alloc(unsigned char * options,int optlen)191 static void *mppe_alloc(unsigned char *options, int optlen)
192 {
193 struct ppp_mppe_state *state;
194 struct crypto_shash *shash;
195 unsigned int digestsize;
196
197 if (optlen != CILEN_MPPE + sizeof(state->master_key) ||
198 options[0] != CI_MPPE || options[1] != CILEN_MPPE)
199 goto out;
200
201 state = kzalloc(sizeof(*state), GFP_KERNEL);
202 if (state == NULL)
203 goto out;
204
205
206 state->arc4 = crypto_alloc_skcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
207 if (IS_ERR(state->arc4)) {
208 state->arc4 = NULL;
209 goto out_free;
210 }
211
212 shash = crypto_alloc_shash("sha1", 0, 0);
213 if (IS_ERR(shash))
214 goto out_free;
215
216 state->sha1 = kmalloc(sizeof(*state->sha1) +
217 crypto_shash_descsize(shash),
218 GFP_KERNEL);
219 if (!state->sha1) {
220 crypto_free_shash(shash);
221 goto out_free;
222 }
223 state->sha1->tfm = shash;
224 state->sha1->flags = 0;
225
226 digestsize = crypto_shash_digestsize(shash);
227 if (digestsize < MPPE_MAX_KEY_LEN)
228 goto out_free;
229
230 state->sha1_digest = kmalloc(digestsize, GFP_KERNEL);
231 if (!state->sha1_digest)
232 goto out_free;
233
234 /* Save keys. */
235 memcpy(state->master_key, &options[CILEN_MPPE],
236 sizeof(state->master_key));
237 memcpy(state->session_key, state->master_key,
238 sizeof(state->master_key));
239
240 /*
241 * We defer initial key generation until mppe_init(), as mppe_alloc()
242 * is called frequently during negotiation.
243 */
244
245 return (void *)state;
246
247 out_free:
248 kfree(state->sha1_digest);
249 if (state->sha1) {
250 crypto_free_shash(state->sha1->tfm);
251 kzfree(state->sha1);
252 }
253 crypto_free_skcipher(state->arc4);
254 kfree(state);
255 out:
256 return NULL;
257 }
258
259 /*
260 * Deallocate space for a (de)compressor.
261 */
mppe_free(void * arg)262 static void mppe_free(void *arg)
263 {
264 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
265 if (state) {
266 kfree(state->sha1_digest);
267 crypto_free_shash(state->sha1->tfm);
268 kzfree(state->sha1);
269 crypto_free_skcipher(state->arc4);
270 kfree(state);
271 }
272 }
273
274 /*
275 * Initialize (de)compressor state.
276 */
277 static int
mppe_init(void * arg,unsigned char * options,int optlen,int unit,int debug,const char * debugstr)278 mppe_init(void *arg, unsigned char *options, int optlen, int unit, int debug,
279 const char *debugstr)
280 {
281 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
282 unsigned char mppe_opts;
283
284 if (optlen != CILEN_MPPE ||
285 options[0] != CI_MPPE || options[1] != CILEN_MPPE)
286 return 0;
287
288 MPPE_CI_TO_OPTS(&options[2], mppe_opts);
289 if (mppe_opts & MPPE_OPT_128)
290 state->keylen = 16;
291 else if (mppe_opts & MPPE_OPT_40)
292 state->keylen = 8;
293 else {
294 printk(KERN_WARNING "%s[%d]: unknown key length\n", debugstr,
295 unit);
296 return 0;
297 }
298 if (mppe_opts & MPPE_OPT_STATEFUL)
299 state->stateful = 1;
300
301 /* Generate the initial session key. */
302 mppe_rekey(state, 1);
303
304 if (debug) {
305 printk(KERN_DEBUG "%s[%d]: initialized with %d-bit %s mode\n",
306 debugstr, unit, (state->keylen == 16) ? 128 : 40,
307 (state->stateful) ? "stateful" : "stateless");
308 printk(KERN_DEBUG
309 "%s[%d]: keys: master: %*phN initial session: %*phN\n",
310 debugstr, unit,
311 (int)sizeof(state->master_key), state->master_key,
312 (int)sizeof(state->session_key), state->session_key);
313 }
314
315 /*
316 * Initialize the coherency count. The initial value is not specified
317 * in RFC 3078, but we can make a reasonable assumption that it will
318 * start at 0. Setting it to the max here makes the comp/decomp code
319 * do the right thing (determined through experiment).
320 */
321 state->ccount = MPPE_CCOUNT_SPACE - 1;
322
323 /*
324 * Note that even though we have initialized the key table, we don't
325 * set the FLUSHED bit. This is contrary to RFC 3078, sec. 3.1.
326 */
327 state->bits = MPPE_BIT_ENCRYPTED;
328
329 state->unit = unit;
330 state->debug = debug;
331
332 return 1;
333 }
334
335 static int
mppe_comp_init(void * arg,unsigned char * options,int optlen,int unit,int hdrlen,int debug)336 mppe_comp_init(void *arg, unsigned char *options, int optlen, int unit,
337 int hdrlen, int debug)
338 {
339 /* ARGSUSED */
340 return mppe_init(arg, options, optlen, unit, debug, "mppe_comp_init");
341 }
342
343 /*
344 * We received a CCP Reset-Request (actually, we are sending a Reset-Ack),
345 * tell the compressor to rekey. Note that we MUST NOT rekey for
346 * every CCP Reset-Request; we only rekey on the next xmit packet.
347 * We might get multiple CCP Reset-Requests if our CCP Reset-Ack is lost.
348 * So, rekeying for every CCP Reset-Request is broken as the peer will not
349 * know how many times we've rekeyed. (If we rekey and THEN get another
350 * CCP Reset-Request, we must rekey again.)
351 */
mppe_comp_reset(void * arg)352 static void mppe_comp_reset(void *arg)
353 {
354 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
355
356 state->bits |= MPPE_BIT_FLUSHED;
357 }
358
359 /*
360 * Compress (encrypt) a packet.
361 * It's strange to call this a compressor, since the output is always
362 * MPPE_OVHD + 2 bytes larger than the input.
363 */
364 static int
mppe_compress(void * arg,unsigned char * ibuf,unsigned char * obuf,int isize,int osize)365 mppe_compress(void *arg, unsigned char *ibuf, unsigned char *obuf,
366 int isize, int osize)
367 {
368 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
369 SKCIPHER_REQUEST_ON_STACK(req, state->arc4);
370 int proto;
371 int err;
372 struct scatterlist sg_in[1], sg_out[1];
373
374 /*
375 * Check that the protocol is in the range we handle.
376 */
377 proto = PPP_PROTOCOL(ibuf);
378 if (proto < 0x0021 || proto > 0x00fa)
379 return 0;
380
381 /* Make sure we have enough room to generate an encrypted packet. */
382 if (osize < isize + MPPE_OVHD + 2) {
383 /* Drop the packet if we should encrypt it, but can't. */
384 printk(KERN_DEBUG "mppe_compress[%d]: osize too small! "
385 "(have: %d need: %d)\n", state->unit,
386 osize, osize + MPPE_OVHD + 2);
387 return -1;
388 }
389
390 osize = isize + MPPE_OVHD + 2;
391
392 /*
393 * Copy over the PPP header and set control bits.
394 */
395 obuf[0] = PPP_ADDRESS(ibuf);
396 obuf[1] = PPP_CONTROL(ibuf);
397 put_unaligned_be16(PPP_COMP, obuf + 2);
398 obuf += PPP_HDRLEN;
399
400 state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE;
401 if (state->debug >= 7)
402 printk(KERN_DEBUG "mppe_compress[%d]: ccount %d\n", state->unit,
403 state->ccount);
404 put_unaligned_be16(state->ccount, obuf);
405
406 if (!state->stateful || /* stateless mode */
407 ((state->ccount & 0xff) == 0xff) || /* "flag" packet */
408 (state->bits & MPPE_BIT_FLUSHED)) { /* CCP Reset-Request */
409 /* We must rekey */
410 if (state->debug && state->stateful)
411 printk(KERN_DEBUG "mppe_compress[%d]: rekeying\n",
412 state->unit);
413 mppe_rekey(state, 0);
414 state->bits |= MPPE_BIT_FLUSHED;
415 }
416 obuf[0] |= state->bits;
417 state->bits &= ~MPPE_BIT_FLUSHED; /* reset for next xmit */
418
419 obuf += MPPE_OVHD;
420 ibuf += 2; /* skip to proto field */
421 isize -= 2;
422
423 /* Encrypt packet */
424 sg_init_table(sg_in, 1);
425 sg_init_table(sg_out, 1);
426 setup_sg(sg_in, ibuf, isize);
427 setup_sg(sg_out, obuf, osize);
428
429 skcipher_request_set_tfm(req, state->arc4);
430 skcipher_request_set_callback(req, 0, NULL, NULL);
431 skcipher_request_set_crypt(req, sg_in, sg_out, isize, NULL);
432 err = crypto_skcipher_encrypt(req);
433 skcipher_request_zero(req);
434 if (err) {
435 printk(KERN_DEBUG "crypto_cypher_encrypt failed\n");
436 return -1;
437 }
438
439 state->stats.unc_bytes += isize;
440 state->stats.unc_packets++;
441 state->stats.comp_bytes += osize;
442 state->stats.comp_packets++;
443
444 return osize;
445 }
446
447 /*
448 * Since every frame grows by MPPE_OVHD + 2 bytes, this is always going
449 * to look bad ... and the longer the link is up the worse it will get.
450 */
mppe_comp_stats(void * arg,struct compstat * stats)451 static void mppe_comp_stats(void *arg, struct compstat *stats)
452 {
453 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
454
455 *stats = state->stats;
456 }
457
458 static int
mppe_decomp_init(void * arg,unsigned char * options,int optlen,int unit,int hdrlen,int mru,int debug)459 mppe_decomp_init(void *arg, unsigned char *options, int optlen, int unit,
460 int hdrlen, int mru, int debug)
461 {
462 /* ARGSUSED */
463 return mppe_init(arg, options, optlen, unit, debug, "mppe_decomp_init");
464 }
465
466 /*
467 * We received a CCP Reset-Ack. Just ignore it.
468 */
mppe_decomp_reset(void * arg)469 static void mppe_decomp_reset(void *arg)
470 {
471 /* ARGSUSED */
472 return;
473 }
474
475 /*
476 * Decompress (decrypt) an MPPE packet.
477 */
478 static int
mppe_decompress(void * arg,unsigned char * ibuf,int isize,unsigned char * obuf,int osize)479 mppe_decompress(void *arg, unsigned char *ibuf, int isize, unsigned char *obuf,
480 int osize)
481 {
482 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
483 SKCIPHER_REQUEST_ON_STACK(req, state->arc4);
484 unsigned ccount;
485 int flushed = MPPE_BITS(ibuf) & MPPE_BIT_FLUSHED;
486 struct scatterlist sg_in[1], sg_out[1];
487
488 if (isize <= PPP_HDRLEN + MPPE_OVHD) {
489 if (state->debug)
490 printk(KERN_DEBUG
491 "mppe_decompress[%d]: short pkt (%d)\n",
492 state->unit, isize);
493 return DECOMP_ERROR;
494 }
495
496 /*
497 * Make sure we have enough room to decrypt the packet.
498 * Note that for our test we only subtract 1 byte whereas in
499 * mppe_compress() we added 2 bytes (+MPPE_OVHD);
500 * this is to account for possible PFC.
501 */
502 if (osize < isize - MPPE_OVHD - 1) {
503 printk(KERN_DEBUG "mppe_decompress[%d]: osize too small! "
504 "(have: %d need: %d)\n", state->unit,
505 osize, isize - MPPE_OVHD - 1);
506 return DECOMP_ERROR;
507 }
508 osize = isize - MPPE_OVHD - 2; /* assume no PFC */
509
510 ccount = MPPE_CCOUNT(ibuf);
511 if (state->debug >= 7)
512 printk(KERN_DEBUG "mppe_decompress[%d]: ccount %d\n",
513 state->unit, ccount);
514
515 /* sanity checks -- terminate with extreme prejudice */
516 if (!(MPPE_BITS(ibuf) & MPPE_BIT_ENCRYPTED)) {
517 printk(KERN_DEBUG
518 "mppe_decompress[%d]: ENCRYPTED bit not set!\n",
519 state->unit);
520 state->sanity_errors += 100;
521 goto sanity_error;
522 }
523 if (!state->stateful && !flushed) {
524 printk(KERN_DEBUG "mppe_decompress[%d]: FLUSHED bit not set in "
525 "stateless mode!\n", state->unit);
526 state->sanity_errors += 100;
527 goto sanity_error;
528 }
529 if (state->stateful && ((ccount & 0xff) == 0xff) && !flushed) {
530 printk(KERN_DEBUG "mppe_decompress[%d]: FLUSHED bit not set on "
531 "flag packet!\n", state->unit);
532 state->sanity_errors += 100;
533 goto sanity_error;
534 }
535
536 /*
537 * Check the coherency count.
538 */
539
540 if (!state->stateful) {
541 /* Discard late packet */
542 if ((ccount - state->ccount) % MPPE_CCOUNT_SPACE
543 > MPPE_CCOUNT_SPACE / 2) {
544 state->sanity_errors++;
545 goto sanity_error;
546 }
547
548 /* RFC 3078, sec 8.1. Rekey for every packet. */
549 while (state->ccount != ccount) {
550 mppe_rekey(state, 0);
551 state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE;
552 }
553 } else {
554 /* RFC 3078, sec 8.2. */
555 if (!state->discard) {
556 /* normal state */
557 state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE;
558 if (ccount != state->ccount) {
559 /*
560 * (ccount > state->ccount)
561 * Packet loss detected, enter the discard state.
562 * Signal the peer to rekey (by sending a CCP Reset-Request).
563 */
564 state->discard = 1;
565 return DECOMP_ERROR;
566 }
567 } else {
568 /* discard state */
569 if (!flushed) {
570 /* ccp.c will be silent (no additional CCP Reset-Requests). */
571 return DECOMP_ERROR;
572 } else {
573 /* Rekey for every missed "flag" packet. */
574 while ((ccount & ~0xff) !=
575 (state->ccount & ~0xff)) {
576 mppe_rekey(state, 0);
577 state->ccount =
578 (state->ccount +
579 256) % MPPE_CCOUNT_SPACE;
580 }
581
582 /* reset */
583 state->discard = 0;
584 state->ccount = ccount;
585 /*
586 * Another problem with RFC 3078 here. It implies that the
587 * peer need not send a Reset-Ack packet. But RFC 1962
588 * requires it. Hopefully, M$ does send a Reset-Ack; even
589 * though it isn't required for MPPE synchronization, it is
590 * required to reset CCP state.
591 */
592 }
593 }
594 if (flushed)
595 mppe_rekey(state, 0);
596 }
597
598 /*
599 * Fill in the first part of the PPP header. The protocol field
600 * comes from the decrypted data.
601 */
602 obuf[0] = PPP_ADDRESS(ibuf); /* +1 */
603 obuf[1] = PPP_CONTROL(ibuf); /* +1 */
604 obuf += 2;
605 ibuf += PPP_HDRLEN + MPPE_OVHD;
606 isize -= PPP_HDRLEN + MPPE_OVHD; /* -6 */
607 /* net osize: isize-4 */
608
609 /*
610 * Decrypt the first byte in order to check if it is
611 * a compressed or uncompressed protocol field.
612 */
613 sg_init_table(sg_in, 1);
614 sg_init_table(sg_out, 1);
615 setup_sg(sg_in, ibuf, 1);
616 setup_sg(sg_out, obuf, 1);
617
618 skcipher_request_set_tfm(req, state->arc4);
619 skcipher_request_set_callback(req, 0, NULL, NULL);
620 skcipher_request_set_crypt(req, sg_in, sg_out, 1, NULL);
621 if (crypto_skcipher_decrypt(req)) {
622 printk(KERN_DEBUG "crypto_cypher_decrypt failed\n");
623 osize = DECOMP_ERROR;
624 goto out_zap_req;
625 }
626
627 /*
628 * Do PFC decompression.
629 * This would be nicer if we were given the actual sk_buff
630 * instead of a char *.
631 */
632 if ((obuf[0] & 0x01) != 0) {
633 obuf[1] = obuf[0];
634 obuf[0] = 0;
635 obuf++;
636 osize++;
637 }
638
639 /* And finally, decrypt the rest of the packet. */
640 setup_sg(sg_in, ibuf + 1, isize - 1);
641 setup_sg(sg_out, obuf + 1, osize - 1);
642 skcipher_request_set_crypt(req, sg_in, sg_out, isize - 1, NULL);
643 if (crypto_skcipher_decrypt(req)) {
644 printk(KERN_DEBUG "crypto_cypher_decrypt failed\n");
645 osize = DECOMP_ERROR;
646 goto out_zap_req;
647 }
648
649 state->stats.unc_bytes += osize;
650 state->stats.unc_packets++;
651 state->stats.comp_bytes += isize;
652 state->stats.comp_packets++;
653
654 /* good packet credit */
655 state->sanity_errors >>= 1;
656
657 out_zap_req:
658 skcipher_request_zero(req);
659 return osize;
660
661 sanity_error:
662 if (state->sanity_errors < SANITY_MAX)
663 return DECOMP_ERROR;
664 else
665 /* Take LCP down if the peer is sending too many bogons.
666 * We don't want to do this for a single or just a few
667 * instances since it could just be due to packet corruption.
668 */
669 return DECOMP_FATALERROR;
670 }
671
672 /*
673 * Incompressible data has arrived (this should never happen!).
674 * We should probably drop the link if the protocol is in the range
675 * of what should be encrypted. At the least, we should drop this
676 * packet. (How to do this?)
677 */
mppe_incomp(void * arg,unsigned char * ibuf,int icnt)678 static void mppe_incomp(void *arg, unsigned char *ibuf, int icnt)
679 {
680 struct ppp_mppe_state *state = (struct ppp_mppe_state *) arg;
681
682 if (state->debug &&
683 (PPP_PROTOCOL(ibuf) >= 0x0021 && PPP_PROTOCOL(ibuf) <= 0x00fa))
684 printk(KERN_DEBUG
685 "mppe_incomp[%d]: incompressible (unencrypted) data! "
686 "(proto %04x)\n", state->unit, PPP_PROTOCOL(ibuf));
687
688 state->stats.inc_bytes += icnt;
689 state->stats.inc_packets++;
690 state->stats.unc_bytes += icnt;
691 state->stats.unc_packets++;
692 }
693
694 /*************************************************************
695 * Module interface table
696 *************************************************************/
697
698 /*
699 * Procedures exported to if_ppp.c.
700 */
701 static struct compressor ppp_mppe = {
702 .compress_proto = CI_MPPE,
703 .comp_alloc = mppe_alloc,
704 .comp_free = mppe_free,
705 .comp_init = mppe_comp_init,
706 .comp_reset = mppe_comp_reset,
707 .compress = mppe_compress,
708 .comp_stat = mppe_comp_stats,
709 .decomp_alloc = mppe_alloc,
710 .decomp_free = mppe_free,
711 .decomp_init = mppe_decomp_init,
712 .decomp_reset = mppe_decomp_reset,
713 .decompress = mppe_decompress,
714 .incomp = mppe_incomp,
715 .decomp_stat = mppe_comp_stats,
716 .owner = THIS_MODULE,
717 .comp_extra = MPPE_PAD,
718 };
719
720 /*
721 * ppp_mppe_init()
722 *
723 * Prior to allowing load, try to load the arc4 and sha1 crypto
724 * libraries. The actual use will be allocated later, but
725 * this way the module will fail to insmod if they aren't available.
726 */
727
ppp_mppe_init(void)728 static int __init ppp_mppe_init(void)
729 {
730 int answer;
731 if (!(crypto_has_skcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC) &&
732 crypto_has_ahash("sha1", 0, CRYPTO_ALG_ASYNC)))
733 return -ENODEV;
734
735 sha_pad = kmalloc(sizeof(struct sha_pad), GFP_KERNEL);
736 if (!sha_pad)
737 return -ENOMEM;
738 sha_pad_init(sha_pad);
739
740 answer = ppp_register_compressor(&ppp_mppe);
741
742 if (answer == 0)
743 printk(KERN_INFO "PPP MPPE Compression module registered\n");
744 else
745 kfree(sha_pad);
746
747 return answer;
748 }
749
ppp_mppe_cleanup(void)750 static void __exit ppp_mppe_cleanup(void)
751 {
752 ppp_unregister_compressor(&ppp_mppe);
753 kfree(sha_pad);
754 }
755
756 module_init(ppp_mppe_init);
757 module_exit(ppp_mppe_cleanup);
758
