usr.sbin/ppp/mppe.c

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