1 /*- 2 * Copyright (c) 2000 Semen Ustimenko <semenu@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: src/usr.sbin/ppp/mppe.c,v 1.4.2.6 2002/09/01 02:12:29 brian Exp $ 27 */ 28 29 #include <sys/param.h> 30 31 #include <sys/socket.h> 32 #include <netinet/in_systm.h> 33 #include <netinet/in.h> 34 #include <netinet/ip.h> 35 #include <sys/un.h> 36 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <string.h> 40 #include <termios.h> 41 #include <openssl/rc4.h> 42 43 #include "defs.h" 44 #include "mbuf.h" 45 #include "log.h" 46 #include "timer.h" 47 #include "fsm.h" 48 #include "lqr.h" 49 #include "hdlc.h" 50 #include "lcp.h" 51 #include "ccp.h" 52 #include "throughput.h" 53 #include "layer.h" 54 #include "link.h" 55 #include "chap_ms.h" 56 #include "proto.h" 57 #include "mppe.h" 58 #include "ua.h" 59 #include "descriptor.h" 60 #ifndef NORADIUS 61 #include "radius.h" 62 #endif 63 #include "ncpaddr.h" 64 #include "iplist.h" 65 #include "slcompress.h" 66 #include "ipcp.h" 67 #include "ipv6cp.h" 68 #include "filter.h" 69 #include "mp.h" 70 #include "ncp.h" 71 #include "bundle.h" 72 73 /* 74 * Documentation: 75 * 76 * draft-ietf-pppext-mppe-04.txt 77 * draft-ietf-pppext-mppe-keys-02.txt 78 */ 79 80 #define MPPE_OPT_STATELESS 0x1000000 81 #define MPPE_OPT_COMPRESSED 0x01 82 #define MPPE_OPT_40BIT 0x20 83 #define MPPE_OPT_56BIT 0x80 84 #define MPPE_OPT_128BIT 0x40 85 #define MPPE_OPT_BITMASK 0xe0 86 #define MPPE_OPT_MASK (MPPE_OPT_STATELESS | MPPE_OPT_BITMASK) 87 88 #define MPPE_FLUSHED 0x8000 89 #define MPPE_ENCRYPTED 0x1000 90 #define MPPE_HEADER_BITMASK 0xf000 91 #define MPPE_HEADER_FLAG 0x00ff 92 #define MPPE_HEADER_FLAGMASK 0x00ff 93 #define MPPE_HEADER_FLAGSHIFT 8 94 #define MPPE_HEADER_STATEFUL_KEYCHANGES 16 95 96 struct mppe_state { 97 unsigned stateless : 1; 98 unsigned flushnext : 1; 99 unsigned flushrequired : 1; 100 int cohnum; 101 unsigned keylen; /* 8 or 16 bytes */ 102 int keybits; /* 40, 56 or 128 bits */ 103 char sesskey[MPPE_KEY_LEN]; 104 char mastkey[MPPE_KEY_LEN]; 105 RC4_KEY rc4key; 106 }; 107 108 int MPPE_MasterKeyValid = 0; 109 int MPPE_IsServer = 0; 110 char MPPE_MasterKey[MPPE_KEY_LEN]; 111 112 /* 113 * The peer has missed a packet. Mark the next output frame to be FLUSHED 114 */ 115 static int 116 MPPEResetOutput(void *v) 117 { 118 struct mppe_state *mop = (struct mppe_state *)v; 119 120 if (mop->stateless) 121 log_Printf(LogCCP, "MPPE: Unexpected output channel reset\n"); 122 else { 123 log_Printf(LogCCP, "MPPE: Output channel reset\n"); 124 mop->flushnext = 1; 125 } 126 127 return 0; /* Ask FSM not to ACK */ 128 } 129 130 static void 131 MPPEReduceSessionKey(struct mppe_state *mp) 132 { 133 switch(mp->keybits) { 134 case 40: 135 mp->sesskey[2] = 0x9e; 136 mp->sesskey[1] = 0x26; 137 /* FALLTHROUGH */ 138 case 56: 139 mp->sesskey[0] = 0xd1; 140 case 128: 141 break; 142 } 143 } 144 145 static void 146 MPPEKeyChange(struct mppe_state *mp) 147 { 148 char InterimKey[MPPE_KEY_LEN]; 149 RC4_KEY RC4Key; 150 151 GetNewKeyFromSHA(mp->mastkey, mp->sesskey, mp->keylen, InterimKey); 152 RC4_set_key(&RC4Key, mp->keylen, InterimKey); 153 RC4(&RC4Key, mp->keylen, InterimKey, mp->sesskey); 154 155 MPPEReduceSessionKey(mp); 156 } 157 158 static struct mbuf * 159 MPPEOutput(void *v, struct ccp *ccp, struct link *l __unused, int pri __unused, 160 u_short *proto, struct mbuf *mp) 161 { 162 struct mppe_state *mop = (struct mppe_state *)v; 163 struct mbuf *mo; 164 u_short nproto, prefix; 165 int dictinit, ilen, len; 166 char *rp; 167 168 ilen = m_length(mp); 169 dictinit = 0; 170 171 log_Printf(LogDEBUG, "MPPE: Output: Proto %02x (%d bytes)\n", *proto, ilen); 172 if (*proto < 0x21 || *proto > 0xFA) { 173 log_Printf(LogDEBUG, "MPPE: Output: Not encrypting\n"); 174 ccp->compout += ilen; 175 ccp->uncompout += ilen; 176 return mp; 177 } 178 179 log_DumpBp(LogDEBUG, "MPPE: Output: Encrypt packet:", mp); 180 181 /* Get mbuf for prefixes */ 182 mo = m_get(4, MB_CCPOUT); 183 mo->m_next = mp; 184 185 rp = MBUF_CTOP(mo); 186 prefix = MPPE_ENCRYPTED | mop->cohnum; 187 188 if (mop->stateless || 189 (mop->cohnum & MPPE_HEADER_FLAGMASK) == MPPE_HEADER_FLAG) { 190 /* Change our key */ 191 log_Printf(LogDEBUG, "MPPEOutput: Key changed [%d]\n", mop->cohnum); 192 MPPEKeyChange(mop); 193 dictinit = 1; 194 } 195 196 if (mop->stateless || mop->flushnext) { 197 prefix |= MPPE_FLUSHED; 198 dictinit = 1; 199 mop->flushnext = 0; 200 } 201 202 if (dictinit) { 203 /* Initialise our dictionary */ 204 log_Printf(LogDEBUG, "MPPEOutput: Dictionary initialised [%d]\n", 205 mop->cohnum); 206 RC4_set_key(&mop->rc4key, mop->keylen, mop->sesskey); 207 } 208 209 /* Set MPPE packet prefix */ 210 ua_htons(&prefix, rp); 211 212 /* Save encrypted protocol number */ 213 nproto = htons(*proto); 214 RC4(&mop->rc4key, 2, (char *)&nproto, rp + 2); 215 216 /* Encrypt main packet */ 217 rp = MBUF_CTOP(mp); 218 RC4(&mop->rc4key, ilen, rp, rp); 219 220 mop->cohnum++; 221 mop->cohnum &= ~MPPE_HEADER_BITMASK; 222 223 /* Set the protocol number */ 224 *proto = ccp_Proto(ccp); 225 len = m_length(mo); 226 ccp->uncompout += ilen; 227 ccp->compout += len; 228 229 log_Printf(LogDEBUG, "MPPE: Output: Encrypted: Proto %02x (%d bytes)\n", 230 *proto, len); 231 232 return mo; 233 } 234 235 static void 236 MPPEResetInput(void *v __unused) 237 { 238 log_Printf(LogCCP, "MPPE: Unexpected input channel ack\n"); 239 } 240 241 static struct mbuf * 242 MPPEInput(void *v, struct ccp *ccp, u_short *proto, struct mbuf *mp) 243 { 244 struct mppe_state *mip = (struct mppe_state *)v; 245 u_short prefix; 246 char *rp; 247 int dictinit, flushed, ilen, len, n; 248 249 ilen = m_length(mp); 250 dictinit = 0; 251 ccp->compin += ilen; 252 253 log_Printf(LogDEBUG, "MPPE: Input: Proto %02x (%d bytes)\n", *proto, ilen); 254 log_DumpBp(LogDEBUG, "MPPE: Input: Packet:", mp); 255 256 mp = mbuf_Read(mp, &prefix, 2); 257 prefix = ntohs(prefix); 258 flushed = prefix & MPPE_FLUSHED; 259 prefix &= ~flushed; 260 if ((prefix & MPPE_HEADER_BITMASK) != MPPE_ENCRYPTED) { 261 log_Printf(LogERROR, "MPPE: Input: Invalid packet (flags = 0x%x)\n", 262 (prefix & MPPE_HEADER_BITMASK) | flushed); 263 m_freem(mp); 264 return NULL; 265 } 266 267 prefix &= ~MPPE_HEADER_BITMASK; 268 269 if (!flushed && mip->stateless) { 270 log_Printf(LogCCP, "MPPEInput: Packet without MPPE_FLUSHED set" 271 " in stateless mode\n"); 272 flushed = MPPE_FLUSHED; 273 /* Should we really continue ? */ 274 } 275 276 if (mip->stateless) { 277 /* Change our key for each missed packet in stateless mode */ 278 while (prefix != mip->cohnum) { 279 log_Printf(LogDEBUG, "MPPEInput: Key changed [%u]\n", prefix); 280 MPPEKeyChange(mip); 281 /* 282 * mip->cohnum contains what we received last time in stateless 283 * mode. 284 */ 285 mip->cohnum++; 286 mip->cohnum &= ~MPPE_HEADER_BITMASK; 287 } 288 dictinit = 1; 289 } else { 290 if (flushed) { 291 /* 292 * We can always process a flushed packet. 293 * Catch up on any outstanding key changes. 294 */ 295 n = (prefix >> MPPE_HEADER_FLAGSHIFT) - 296 (mip->cohnum >> MPPE_HEADER_FLAGSHIFT); 297 if (n < 0) 298 n += MPPE_HEADER_STATEFUL_KEYCHANGES; 299 while (n--) { 300 log_Printf(LogDEBUG, "MPPEInput: Key changed during catchup [%u]\n", 301 prefix); 302 MPPEKeyChange(mip); 303 } 304 mip->flushrequired = 0; 305 mip->cohnum = prefix; 306 dictinit = 1; 307 } 308 309 if (mip->flushrequired) { 310 /* 311 * Perhaps we should be lenient if 312 * (prefix & MPPE_HEADER_FLAGMASK) == MPPE_HEADER_FLAG 313 * The spec says that we shouldn't be though.... 314 */ 315 log_Printf(LogDEBUG, "MPPE: Not flushed - discarded\n"); 316 fsm_Output(&ccp->fsm, CODE_RESETREQ, ccp->fsm.reqid++, NULL, 0, 317 MB_CCPOUT); 318 m_freem(mp); 319 return NULL; 320 } 321 322 if (prefix != mip->cohnum) { 323 /* 324 * We're in stateful mode and didn't receive the expected 325 * packet. Send a reset request, but don't tell the CCP layer 326 * about it as we don't expect to receive a Reset ACK ! 327 * Guess what... M$ invented this ! 328 */ 329 log_Printf(LogCCP, "MPPE: Input: Got seq %u, not %u\n", 330 prefix, mip->cohnum); 331 fsm_Output(&ccp->fsm, CODE_RESETREQ, ccp->fsm.reqid++, NULL, 0, 332 MB_CCPOUT); 333 mip->flushrequired = 1; 334 m_freem(mp); 335 return NULL; 336 } 337 338 if ((prefix & MPPE_HEADER_FLAGMASK) == MPPE_HEADER_FLAG) { 339 log_Printf(LogDEBUG, "MPPEInput: Key changed [%u]\n", prefix); 340 MPPEKeyChange(mip); 341 dictinit = 1; 342 } else if (flushed) 343 dictinit = 1; 344 345 /* 346 * mip->cohnum contains what we expect to receive next time in stateful 347 * mode. 348 */ 349 mip->cohnum++; 350 mip->cohnum &= ~MPPE_HEADER_BITMASK; 351 } 352 353 if (dictinit) { 354 log_Printf(LogDEBUG, "MPPEInput: Dictionary initialised [%u]\n", prefix); 355 RC4_set_key(&mip->rc4key, mip->keylen, mip->sesskey); 356 } 357 358 mp = mbuf_Read(mp, proto, 2); 359 RC4(&mip->rc4key, 2, (char *)proto, (char *)proto); 360 *proto = ntohs(*proto); 361 362 rp = MBUF_CTOP(mp); 363 len = m_length(mp); 364 RC4(&mip->rc4key, len, rp, rp); 365 366 log_Printf(LogDEBUG, "MPPEInput: Decrypted: Proto %02x (%d bytes)\n", 367 *proto, len); 368 log_DumpBp(LogDEBUG, "MPPEInput: Decrypted: Packet:", mp); 369 370 ccp->uncompin += len; 371 372 return mp; 373 } 374 375 static void 376 MPPEDictSetup(void *v __unused, struct ccp *ccp __unused, 377 u_short proto __unused, struct mbuf *mp __unused) 378 { 379 /* Nothing to see here */ 380 } 381 382 static const char * 383 MPPEDispOpts(struct fsm_opt *o) 384 { 385 static char buf[70]; 386 u_int32_t val; 387 char ch; 388 int len, n; 389 390 ua_ntohl(o->data, &val); 391 len = 0; 392 if ((n = snprintf(buf, sizeof buf, "value 0x%08x ", (unsigned)val)) > 0) 393 len += n; 394 if (!(val & MPPE_OPT_BITMASK)) { 395 if ((n = snprintf(buf + len, sizeof buf - len, "(0")) > 0) 396 len += n; 397 } else { 398 ch = '('; 399 if (val & MPPE_OPT_128BIT) { 400 if ((n = snprintf(buf + len, sizeof buf - len, "%c128", ch)) > 0) 401 len += n; 402 ch = '/'; 403 } 404 if (val & MPPE_OPT_56BIT) { 405 if ((n = snprintf(buf + len, sizeof buf - len, "%c56", ch)) > 0) 406 len += n; 407 ch = '/'; 408 } 409 if (val & MPPE_OPT_40BIT) { 410 if ((n = snprintf(buf + len, sizeof buf - len, "%c40", ch)) > 0) 411 len += n; 412 ch = '/'; 413 } 414 } 415 416 if ((n = snprintf(buf + len, sizeof buf - len, " bits, state%s", 417 (val & MPPE_OPT_STATELESS) ? "less" : "ful")) > 0) 418 len += n; 419 420 if (val & MPPE_OPT_COMPRESSED) { 421 if ((n = snprintf(buf + len, sizeof buf - len, ", compressed")) > 0) 422 len += n; 423 } 424 425 snprintf(buf + len, sizeof buf - len, ")"); 426 427 return buf; 428 } 429 430 static int 431 MPPEUsable(struct fsm *fp) 432 { 433 int ok; 434 #ifndef NORADIUS 435 struct radius *r = &fp->bundle->radius; 436 437 /* 438 * If the radius server gave us RAD_MICROSOFT_MS_MPPE_ENCRYPTION_TYPES, 439 * use that instead of our configuration value. 440 */ 441 if (*r->cfg.file) { 442 ok = r->mppe.sendkeylen && r->mppe.recvkeylen; 443 if (!ok) 444 log_Printf(LogCCP, "MPPE: Not permitted by RADIUS server\n"); 445 } else 446 #endif 447 { 448 struct lcp *lcp = &fp->link->lcp; 449 ok = (lcp->want_auth == PROTO_CHAP && lcp->want_authtype == 0x81) || 450 (lcp->his_auth == PROTO_CHAP && lcp->his_authtype == 0x81); 451 if (!ok) 452 log_Printf(LogCCP, "MPPE: Not usable without CHAP81\n"); 453 } 454 455 return ok; 456 } 457 458 static int 459 MPPERequired(struct fsm *fp) 460 { 461 #ifndef NORADIUS 462 /* 463 * If the radius server gave us RAD_MICROSOFT_MS_MPPE_ENCRYPTION_POLICY, 464 * use that instead of our configuration value. 465 */ 466 if (*fp->bundle->radius.cfg.file && fp->bundle->radius.mppe.policy) 467 return fp->bundle->radius.mppe.policy == MPPE_POLICY_REQUIRED ? 1 : 0; 468 #endif 469 470 return fp->link->ccp.cfg.mppe.required; 471 } 472 473 static u_int32_t 474 MPPE_ConfigVal(struct bundle *bundle, const struct ccp_config *cfg) 475 { 476 u_int32_t val; 477 478 val = cfg->mppe.state == MPPE_STATELESS ? MPPE_OPT_STATELESS : 0; 479 #ifndef NORADIUS 480 /* 481 * If the radius server gave us RAD_MICROSOFT_MS_MPPE_ENCRYPTION_TYPES, 482 * use that instead of our configuration value. 483 */ 484 if (*bundle->radius.cfg.file && bundle->radius.mppe.types) { 485 if (bundle->radius.mppe.types & MPPE_TYPE_40BIT) 486 val |= MPPE_OPT_40BIT; 487 if (bundle->radius.mppe.types & MPPE_TYPE_128BIT) 488 val |= MPPE_OPT_128BIT; 489 } else 490 #endif 491 switch(cfg->mppe.keybits) { 492 case 128: 493 val |= MPPE_OPT_128BIT; 494 break; 495 case 56: 496 val |= MPPE_OPT_56BIT; 497 break; 498 case 40: 499 val |= MPPE_OPT_40BIT; 500 break; 501 case 0: 502 val |= MPPE_OPT_128BIT | MPPE_OPT_56BIT | MPPE_OPT_40BIT; 503 break; 504 } 505 506 return val; 507 } 508 509 /* 510 * What options should we use for our first configure request 511 */ 512 static void 513 MPPEInitOptsOutput(struct bundle *bundle, struct fsm_opt *o, 514 const struct ccp_config *cfg) 515 { 516 u_int32_t mval; 517 518 o->hdr.len = 6; 519 520 if (!MPPE_MasterKeyValid) { 521 log_Printf(LogCCP, "MPPE: MasterKey is invalid," 522 " MPPE is available only with CHAP81 authentication\n"); 523 mval = 0; 524 ua_htonl(&mval, o->data); 525 return; 526 } 527 528 529 mval = MPPE_ConfigVal(bundle, cfg); 530 ua_htonl(&mval, o->data); 531 } 532 533 /* 534 * Our CCP request was NAK'd with the given options 535 */ 536 static int 537 MPPESetOptsOutput(struct bundle *bundle, struct fsm_opt *o, 538 const struct ccp_config *cfg) 539 { 540 u_int32_t mval, peer; 541 542 ua_ntohl(o->data, &peer); 543 544 if (!MPPE_MasterKeyValid) 545 /* Treat their NAK as a REJ */ 546 return MODE_NAK; 547 548 mval = MPPE_ConfigVal(bundle, cfg); 549 550 /* 551 * If we haven't been configured with a specific number of keybits, allow 552 * whatever the peer asks for. 553 */ 554 if (!cfg->mppe.keybits) { 555 mval &= ~MPPE_OPT_BITMASK; 556 mval |= (peer & MPPE_OPT_BITMASK); 557 if (!(mval & MPPE_OPT_BITMASK)) 558 mval |= MPPE_OPT_128BIT; 559 } 560 561 /* Adjust our statelessness */ 562 if (cfg->mppe.state == MPPE_ANYSTATE) { 563 mval &= ~MPPE_OPT_STATELESS; 564 mval |= (peer & MPPE_OPT_STATELESS); 565 } 566 567 ua_htonl(&mval, o->data); 568 569 return MODE_ACK; 570 } 571 572 /* 573 * The peer has requested the given options 574 */ 575 static int 576 MPPESetOptsInput(struct bundle *bundle, struct fsm_opt *o, 577 const struct ccp_config *cfg) 578 { 579 u_int32_t mval, peer; 580 int res = MODE_ACK; 581 582 ua_ntohl(o->data, &peer); 583 if (!MPPE_MasterKeyValid) { 584 if (peer != 0) { 585 peer = 0; 586 ua_htonl(&peer, o->data); 587 return MODE_NAK; 588 } else 589 return MODE_ACK; 590 } 591 592 mval = MPPE_ConfigVal(bundle, cfg); 593 594 if (peer & ~MPPE_OPT_MASK) 595 /* He's asking for bits we don't know about */ 596 res = MODE_NAK; 597 598 if (peer & MPPE_OPT_STATELESS) { 599 if (cfg->mppe.state == MPPE_STATEFUL) 600 /* Peer can't have stateless */ 601 res = MODE_NAK; 602 else 603 /* Peer wants stateless, that's ok */ 604 mval |= MPPE_OPT_STATELESS; 605 } else { 606 if (cfg->mppe.state == MPPE_STATELESS) 607 /* Peer must have stateless */ 608 res = MODE_NAK; 609 else 610 /* Peer doesn't want stateless, that's ok */ 611 mval &= ~MPPE_OPT_STATELESS; 612 } 613 614 /* If we've got a configured number of keybits - the peer must use that */ 615 if (cfg->mppe.keybits) { 616 ua_htonl(&mval, o->data); 617 return peer == mval ? res : MODE_NAK; 618 } 619 620 /* If a specific number of bits hasn't been requested, we'll need to NAK */ 621 switch (peer & MPPE_OPT_BITMASK) { 622 case MPPE_OPT_128BIT: 623 case MPPE_OPT_56BIT: 624 case MPPE_OPT_40BIT: 625 break; 626 default: 627 res = MODE_NAK; 628 } 629 630 /* Suggest the best number of bits */ 631 mval &= ~MPPE_OPT_BITMASK; 632 if (peer & MPPE_OPT_128BIT) 633 mval |= MPPE_OPT_128BIT; 634 else if (peer & MPPE_OPT_56BIT) 635 mval |= MPPE_OPT_56BIT; 636 else if (peer & MPPE_OPT_40BIT) 637 mval |= MPPE_OPT_40BIT; 638 else 639 mval |= MPPE_OPT_128BIT; 640 ua_htonl(&mval, o->data); 641 642 return res; 643 } 644 645 static struct mppe_state * 646 MPPE_InitState(struct fsm_opt *o) 647 { 648 struct mppe_state *mp; 649 u_int32_t val; 650 651 if ((mp = calloc(1, sizeof *mp)) != NULL) { 652 ua_ntohl(o->data, &val); 653 654 switch (val & MPPE_OPT_BITMASK) { 655 case MPPE_OPT_128BIT: 656 mp->keylen = 16; 657 mp->keybits = 128; 658 break; 659 case MPPE_OPT_56BIT: 660 mp->keylen = 8; 661 mp->keybits = 56; 662 break; 663 case MPPE_OPT_40BIT: 664 mp->keylen = 8; 665 mp->keybits = 40; 666 break; 667 default: 668 log_Printf(LogWARN, "Unexpected MPPE options 0x%08x\n", val); 669 free(mp); 670 return NULL; 671 } 672 673 mp->stateless = !!(val & MPPE_OPT_STATELESS); 674 } 675 676 return mp; 677 } 678 679 static void * 680 MPPEInitInput(struct bundle *bundle, struct fsm_opt *o) 681 { 682 struct mppe_state *mip; 683 684 if (!MPPE_MasterKeyValid) { 685 log_Printf(LogWARN, "MPPE: Cannot initialise without CHAP81\n"); 686 return NULL; 687 } 688 689 if ((mip = MPPE_InitState(o)) == NULL) { 690 log_Printf(LogWARN, "MPPEInput: Cannot initialise - unexpected options\n"); 691 return NULL; 692 } 693 694 log_Printf(LogDEBUG, "MPPE: InitInput: %d-bits\n", mip->keybits); 695 696 #ifndef NORADIUS 697 if (*bundle->radius.cfg.file && bundle->radius.mppe.recvkey) { 698 if (mip->keylen > bundle->radius.mppe.recvkeylen) 699 mip->keylen = bundle->radius.mppe.recvkeylen; 700 if (mip->keylen > sizeof mip->mastkey) 701 mip->keylen = sizeof mip->mastkey; 702 memcpy(mip->mastkey, bundle->radius.mppe.recvkey, mip->keylen); 703 } else 704 #endif 705 GetAsymetricStartKey(MPPE_MasterKey, mip->mastkey, mip->keylen, 0, 706 MPPE_IsServer); 707 708 GetNewKeyFromSHA(mip->mastkey, mip->mastkey, mip->keylen, mip->sesskey); 709 710 MPPEReduceSessionKey(mip); 711 712 log_Printf(LogCCP, "MPPE: Input channel initiated\n"); 713 714 if (!mip->stateless) { 715 /* 716 * We need to initialise our dictionary here as the first packet we 717 * receive is unlikely to have the FLUSHED bit set. 718 */ 719 log_Printf(LogDEBUG, "MPPEInitInput: Dictionary initialised [%d]\n", 720 mip->cohnum); 721 RC4_set_key(&mip->rc4key, mip->keylen, mip->sesskey); 722 } else { 723 /* 724 * We do the first key change here as the first packet is expected 725 * to have a sequence number of 0 and we'll therefore not expect 726 * to have to change the key at that point. 727 */ 728 log_Printf(LogDEBUG, "MPPEInitInput: Key changed [%d]\n", mip->cohnum); 729 MPPEKeyChange(mip); 730 } 731 732 return mip; 733 } 734 735 static void * 736 MPPEInitOutput(struct bundle *bundle, struct fsm_opt *o) 737 { 738 struct mppe_state *mop; 739 740 if (!MPPE_MasterKeyValid) { 741 log_Printf(LogWARN, "MPPE: Cannot initialise without CHAP81\n"); 742 return NULL; 743 } 744 745 if ((mop = MPPE_InitState(o)) == NULL) { 746 log_Printf(LogWARN, "MPPEOutput: Cannot initialise - unexpected options\n"); 747 return NULL; 748 } 749 750 log_Printf(LogDEBUG, "MPPE: InitOutput: %d-bits\n", mop->keybits); 751 752 #ifndef NORADIUS 753 if (*bundle->radius.cfg.file && bundle->radius.mppe.sendkey) { 754 if (mop->keylen > bundle->radius.mppe.sendkeylen) 755 mop->keylen = bundle->radius.mppe.sendkeylen; 756 if (mop->keylen > sizeof mop->mastkey) 757 mop->keylen = sizeof mop->mastkey; 758 memcpy(mop->mastkey, bundle->radius.mppe.sendkey, mop->keylen); 759 } else 760 #endif 761 GetAsymetricStartKey(MPPE_MasterKey, mop->mastkey, mop->keylen, 1, 762 MPPE_IsServer); 763 764 GetNewKeyFromSHA(mop->mastkey, mop->mastkey, mop->keylen, mop->sesskey); 765 766 MPPEReduceSessionKey(mop); 767 768 log_Printf(LogCCP, "MPPE: Output channel initiated\n"); 769 770 if (!mop->stateless) { 771 /* 772 * We need to initialise our dictionary now as the first packet we 773 * send won't have the FLUSHED bit set. 774 */ 775 log_Printf(LogDEBUG, "MPPEInitOutput: Dictionary initialised [%d]\n", 776 mop->cohnum); 777 RC4_set_key(&mop->rc4key, mop->keylen, mop->sesskey); 778 } 779 780 return mop; 781 } 782 783 static void 784 MPPETermInput(void *v) 785 { 786 free(v); 787 } 788 789 static void 790 MPPETermOutput(void *v) 791 { 792 free(v); 793 } 794 795 const struct ccp_algorithm MPPEAlgorithm = { 796 TY_MPPE, 797 CCP_NEG_MPPE, 798 MPPEDispOpts, 799 MPPEUsable, 800 MPPERequired, 801 { 802 MPPESetOptsInput, 803 MPPEInitInput, 804 MPPETermInput, 805 MPPEResetInput, 806 MPPEInput, 807 MPPEDictSetup 808 }, 809 { 810 2, 811 MPPEInitOptsOutput, 812 MPPESetOptsOutput, 813 MPPEInitOutput, 814 MPPETermOutput, 815 MPPEResetOutput, 816 MPPEOutput 817 }, 818 }; 819