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