src/modules/rlm_eap/types/rlm_eap_leap/eap_leap.c

   1 /*
   2  * eap_leap.c  EAP LEAP functionality.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2003 Alan DeKok <aland@freeradius.org>
  21  * Copyright 2006 The FreeRADIUS server project
  22  */
  23
  24 /*
  25  *
  26  *  LEAP Packet Format in EAP Type-Data
  27  *  --- ------ ------ -- --- ---------
  28  *    0                   1                   2                 3
  29  *   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  30  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  31  *  |     Type 0x11 |  Version 0x01 | Unused 0x00   | Count 0x08    |
  32  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  33  *  |               Peer Challenge                                 |
  34  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  35  *  |               Peer Challenge                                 |
  36  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  37  *  |   User Name .....
  38  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-
  39  *
  40  *  Count is 8 octets since the Peer challenge is 8 bytes.
  41  *  Count is 24 for EAP response, with MSCHAP response.
  42  *  Length is the total number of octets in the EAP-Message.
  43  *
  44  *  The LEAP type (0x11) is *not* included in the type data...
  45  */
  46
  47 #include <freeradius-devel/ident.h>
  48 RCSID("$Id$")
  49
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include "eap.h"
  53 #include "eap_leap.h"
  54
  55 /*
  56  *      Allocate a new LEAP_PACKET
  57  */
  58 LEAP_PACKET *eapleap_alloc(void)
  59 {
  60         LEAP_PACKET   *rp;
  61
  62         if ((rp = malloc(sizeof(LEAP_PACKET))) == NULL) {
  63                 radlog(L_ERR, "rlm_eap_leap: out of memory");
  64                 return NULL;
  65         }
  66         memset(rp, 0, sizeof(LEAP_PACKET));
  67         return rp;
  68 }
  69
  70 /*
  71  *      Free LEAP_PACKET
  72  */
  73 void eapleap_free(LEAP_PACKET **leap_packet_ptr)
  74 {
  75         LEAP_PACKET *leap_packet;
  76
  77         if (!leap_packet_ptr) return;
  78         leap_packet = *leap_packet_ptr;
  79         if (leap_packet == NULL) return;
  80
  81         if (leap_packet->challenge) free(leap_packet->challenge);
  82         if (leap_packet->name) free(leap_packet->name);
  83
  84         free(leap_packet);
  85
  86         *leap_packet_ptr = NULL;
  87 }
  88
  89 /*
  90  *   Extract the data from the LEAP packet.
  91  */
  92 LEAP_PACKET *eapleap_extract(EAP_DS *eap_ds)
  93 {
  94         leap_packet_t   *data;
  95         LEAP_PACKET     *packet;
  96         int             name_len;
  97
  98         /*
  99          *      LEAP can have EAP-Response or EAP-Request (step 5)
 100          *      messages sent to it.
 101          */
 102         if (!eap_ds ||
 103             !eap_ds->response ||
 104             ((eap_ds->response->code != PW_EAP_RESPONSE) &&
 105              (eap_ds->response->code != PW_EAP_REQUEST)) ||
 106             eap_ds->response->type.type != PW_EAP_LEAP ||
 107             !eap_ds->response->type.data ||
 108             (eap_ds->response->length < LEAP_HEADER_LEN) ||
 109             (eap_ds->response->type.data[0] != 0x01)) { /* version 1 */
 110                 radlog(L_ERR, "rlm_eap_leap: corrupted data");
 111                 return NULL;
 112         }
 113
 114         /*
 115          *      Hmm... this cast isn't the best thing to do.
 116          */
 117         data = (leap_packet_t *)eap_ds->response->type.data;
 118
 119         /*
 120          *      Some simple sanity checks on the incoming packet.
 121          *
 122          *      See 'leap.txt' in this directory for a description
 123          *      of the stages.
 124          */
 125         switch (eap_ds->response->code) {
 126         case PW_EAP_RESPONSE:
 127                 if (data->count != 24) {
 128                         radlog(L_ERR, "rlm_eap_leap: Bad NTChallengeResponse in LEAP stage 3");
 129                         return NULL;
 130                 }
 131                 break;
 132
 133         case PW_EAP_REQUEST:
 134                 if (data->count != 8) {
 135                         radlog(L_ERR, "rlm_eap_leap: Bad AP Challenge in LEAP stage 5");
 136                         return NULL;
 137                 }
 138                 break;
 139
 140         default:
 141                 radlog(L_ERR, "rlm_eap_leap: Invalid EAP code %d",
 142                        eap_ds->response->code);
 143                 return NULL;
 144                 break;
 145         }
 146
 147         packet = eapleap_alloc();
 148         if (!packet) return NULL;
 149
 150         /*
 151          *      Remember code, length, and id.
 152          */
 153         packet->code = eap_ds->response->code;
 154         packet->id = eap_ds->response->id;
 155
 156         /*
 157          *      The size of the LEAP portion of the packet, not
 158          *      counting the EAP header and the type.
 159          */
 160         packet->length = eap_ds->response->length - EAP_HEADER_LEN - 1;
 161
 162         /*
 163          *      Remember the length of the challenge.
 164          */
 165         packet->count = data->count;
 166
 167         packet->challenge = malloc(packet->count);
 168         if (packet->challenge == NULL) {
 169                 radlog(L_ERR, "rlm_eap_leap: out of memory");
 170                 eapleap_free(&packet);
 171                 return NULL;
 172         }
 173         memcpy(packet->challenge, data->challenge, packet->count);
 174
 175         /*
 176          *      The User-Name comes after the challenge.
 177          *
 178          *      Length of the EAP-LEAP portion of the packet, minus
 179          *      3 octets for data, minus the challenge size, is the
 180          *      length of the user name.
 181          */
 182         name_len = packet->length - 3 - packet->count;
 183         if (name_len > 0) {
 184                 packet->name = malloc(name_len + 1);
 185                 if (!packet->name) {
 186                         radlog(L_ERR, "rlm_eap_leap: out of memory");
 187                         eapleap_free(&packet);
 188                         return NULL;
 189                 }
 190                 memcpy(packet->name, &data->challenge[packet->count],
 191                        name_len);
 192                 packet->name[name_len] = '\0';
 193                 packet->name_len = name_len;
 194         }
 195
 196         return packet;
 197 }
 198
 199 /*
 200  *  Get the NT-Password hash.
 201  */
 202 static int eapleap_ntpwdhash(unsigned char *ntpwdhash, VALUE_PAIR *password)
 203 {
 204         if (password->attribute == PW_PASSWORD) {
 205                 int i;
 206                 unsigned char unicode[512];
 207
 208                 /*
 209                  *      Convert the password to NT's weird Unicode format.
 210                  */
 211                 memset(unicode, 0, sizeof(unicode));
 212                 for (i = 0; i < password->length; i++) {
 213                         /*
 214                          *  Yes, the *even* bytes have the values,
 215                          *  and the *odd* bytes are zero.
 216                          */
 217                         unicode[(i << 1)] = password->vp_strvalue[i];
 218                 }
 219
 220                 /*
 221                  *  Get the NT Password hash.
 222                  */
 223                 md4_calc(ntpwdhash, unicode, password->length * 2);
 224
 225         } else {                /* MUST be NT-Password */
 226                 if (password->length == 32) {
 227                         password->length = lrad_hex2bin(password->vp_strvalue,
 228                                                         password->vp_strvalue,
 229                                                         16);
 230                 }
 231                 if (password->length != 16) {
 232                         radlog(L_ERR, "rlm_eap_leap: Bad NT-Password");
 233                         return 0;
 234                 }
 235
 236                 memcpy(ntpwdhash, password->vp_strvalue, 16);
 237         }
 238         return 1;
 239 }
 240
 241
 242 /*
 243  *      Verify the MS-CHAP response from the user.
 244  */
 245 int eapleap_stage4(LEAP_PACKET *packet, VALUE_PAIR* password,
 246                    leap_session_t *session)
 247 {
 248         unsigned char ntpwdhash[16];
 249         unsigned char response[24];
 250
 251
 252         /*
 253          *      No password or previous packet.  Die.
 254          */
 255         if ((password == NULL) || (session == NULL)) {
 256                 return 0;
 257         }
 258
 259         if (!eapleap_ntpwdhash(ntpwdhash, password)) {
 260                 return 0;
 261         }
 262
 263         /*
 264          *      Calculate and verify the CHAP challenge.
 265          */
 266         eapleap_mschap(ntpwdhash, session->peer_challenge, response);
 267         if (memcmp(response, packet->challenge, 24) == 0) {
 268                 DEBUG2("  rlm_eap_leap: NtChallengeResponse from AP is valid");
 269                 memcpy(session->peer_response, response, sizeof(response));
 270                 return 1;
 271         }
 272
 273         DEBUG2("  rlm_eap_leap: FAILED incorrect NtChallengeResponse from AP");
 274         return 0;
 275 }
 276
 277 /*
 278  *      Verify ourselves to the AP
 279  */
 280 LEAP_PACKET *eapleap_stage6(LEAP_PACKET *packet, REQUEST *request,
 281                             VALUE_PAIR *user_name, VALUE_PAIR* password,
 282                             leap_session_t *session, VALUE_PAIR **reply_vps)
 283 {
 284         int i;
 285         unsigned char ntpwdhash[16], ntpwdhashhash[16];
 286         unsigned char buffer[256];
 287         LEAP_PACKET *reply;
 288         char *p;
 289         VALUE_PAIR *vp;
 290
 291         /*
 292          *      No password or previous packet.  Die.
 293          */
 294         if ((password == NULL) || (session == NULL)) {
 295                 return NULL;
 296         }
 297
 298         reply = eapleap_alloc();
 299         if (!reply) return NULL;
 300
 301         reply->code = PW_EAP_RESPONSE;
 302         reply->length = LEAP_HEADER_LEN + 24 + user_name->length;
 303         reply->count = 24;
 304
 305         reply->challenge = malloc(reply->count);
 306         if (reply->challenge == NULL) {
 307                 radlog(L_ERR, "rlm_eap_leap: out of memory");
 308                 eapleap_free(&reply);
 309                 return NULL;
 310         }
 311
 312         /*
 313          *      The LEAP packet also contains the user name.
 314          */
 315         reply->name = malloc(user_name->length + 1);
 316         if (reply->name == NULL) {
 317                 radlog(L_ERR, "rlm_eap_leap: out of memory");
 318                 eapleap_free(&reply);
 319                 return NULL;
 320         }
 321
 322         /*
 323          *      Copy the name over, and ensure it's NUL terminated.
 324          */
 325         memcpy(reply->name, user_name->vp_strvalue, user_name->length);
 326         reply->name[user_name->length] = '\0';
 327         reply->name_len = user_name->length;
 328
 329         /*
 330          *  MPPE hash = ntpwdhash(ntpwdhash(unicode(pw)))
 331          */
 332         if (!eapleap_ntpwdhash(ntpwdhash, password)) {
 333                 eapleap_free(&reply);
 334                 return NULL;
 335         }
 336         md4_calc(ntpwdhashhash, ntpwdhash, 16);
 337
 338         /*
 339          *      Calculate our response, to authenticate ourselves
 340          *      to the AP.
 341          */
 342         eapleap_mschap(ntpwdhashhash, packet->challenge, reply->challenge);
 343
 344         /*
 345          *  Calculate the leap:session-key attribute
 346          */
 347         vp = pairmake("Cisco-AVPair", "leap:session-key=", T_OP_ADD);
 348         if (!vp) {
 349                 radlog(L_ERR, "rlm_eap_leap: Failed to create Cisco-AVPair attribute.  LEAP cancelled.");
 350                 eapleap_free(&reply);
 351                 return NULL;
 352         }
 353
 354         /*
 355          *      And calculate the MPPE session key.
 356          */
 357         p = buffer;
 358         memcpy(p, ntpwdhashhash, 16); /* MPPEHASH */
 359         p += 16;
 360         memcpy(p, packet->challenge, 8); /* APC */
 361         p += 8;
 362         memcpy(p, reply->challenge, 24); /* APR */
 363         p += 24;
 364         memcpy(p, session->peer_challenge, 8); /* PC */
 365         p += 8;
 366         memcpy(p, session->peer_response, 24); /* PR */
 367         p += 24;
 368
 369         /*
 370          *      These 16 bytes are the session key to use.
 371          */
 372         librad_md5_calc(ntpwdhash, buffer, 16 + 8 + 24 + 8 + 24);
 373
 374         memcpy(vp->vp_strvalue + vp->length, ntpwdhash, 16);
 375         memset(vp->vp_strvalue + vp->length + 16, 0,
 376                sizeof(vp->vp_strvalue) - (vp->length + 16));
 377
 378         i = 16;
 379         rad_tunnel_pwencode(vp->vp_strvalue + vp->length, &i,
 380                             request->secret, request->packet->vector);
 381         vp->length += i;
 382         pairadd(reply_vps, vp);
 383
 384         return reply;
 385 }
 386
 387 /*
 388  *      If an EAP LEAP request needs to be initiated then
 389  *      create such a packet.
 390  */
 391 LEAP_PACKET *eapleap_initiate(UNUSED EAP_DS *eap_ds, VALUE_PAIR *user_name)
 392 {
 393         int i;
 394         LEAP_PACKET     *reply;
 395
 396         reply = eapleap_alloc();
 397         if (reply == NULL)  {
 398                 radlog(L_ERR, "rlm_eap_leap: out of memory");
 399                 return NULL;
 400         }
 401
 402         reply->code = PW_EAP_REQUEST;
 403         reply->length = LEAP_HEADER_LEN + 8 + user_name->length;
 404         reply->count = 8;       /* random challenge */
 405
 406         reply->challenge = malloc(reply->count);
 407         if (reply->challenge == NULL) {
 408                 radlog(L_ERR, "rlm_eap_leap: out of memory");
 409                 eapleap_free(&reply);
 410                 return NULL;
 411         }
 412
 413         /*
 414          *      Fill the challenge with random bytes.
 415          */
 416         for (i = 0; i < reply->count; i++) {
 417                 reply->challenge[i] = lrad_rand();
 418         }
 419
 420         DEBUG2("  rlm_eap_leap: Issuing AP Challenge");
 421
 422         /*
 423          *      The LEAP packet also contains the user name.
 424          */
 425         reply->name = malloc(user_name->length + 1);
 426         if (reply->name == NULL) {
 427                 radlog(L_ERR, "rlm_eap_leap: out of memory");
 428                 eapleap_free(&reply);
 429                 return NULL;
 430         }
 431
 432         /*
 433          *      Copy the name over, and ensure it's NUL terminated.
 434          */
 435         memcpy(reply->name, user_name->vp_strvalue, user_name->length);
 436         reply->name[user_name->length] = '\0';
 437         reply->name_len = user_name->length;
 438
 439         return reply;
 440 }
 441
 442 /*
 443  * compose the LEAP reply packet in the EAP reply typedata
 444  */
 445 int eapleap_compose(EAP_DS *eap_ds, LEAP_PACKET *reply)
 446 {
 447         leap_packet_t *data;
 448
 449         /*
 450          *  We need the name and the challenge.
 451          */
 452         switch (reply->code) {
 453         case PW_EAP_REQUEST:
 454         case PW_EAP_RESPONSE:
 455                 eap_ds->request->type.type = PW_EAP_LEAP;
 456                 eap_ds->request->type.length = reply->length;
 457
 458                 eap_ds->request->type.data = malloc(reply->length);
 459                 if (eap_ds->request->type.data == NULL) {
 460                         radlog(L_ERR, "rlm_eap_leap: out of memory");
 461                         return 0;
 462                 }
 463                 data = (leap_packet_t *) eap_ds->request->type.data;
 464                 data->version = 0x01;
 465                 data->unused = 0;
 466                 data->count = reply->count;
 467
 468                 /*
 469                  *      N bytes of the challenge, followed by the user name.
 470                  */
 471                 memcpy(&data->challenge[0], reply->challenge, reply->count);
 472                 memcpy(&data->challenge[reply->count],
 473                        reply->name, reply->name_len);
 474                 break;
 475
 476                 /*
 477                  *      EAP-Success packets don't contain any data
 478                  *      other than the header.
 479                  */
 480         case PW_EAP_SUCCESS:
 481                 eap_ds->request->type.length = 0;
 482                 break;
 483
 484         default:
 485                 radlog(L_ERR, "rlm_eap_leap: Internal sanity check failed");
 486                 return 0;
 487                 break;
 488         }
 489
 490         /*
 491          *      Set the EAP code.
 492          */
 493         eap_ds->request->code = reply->code;
 494
 495         return 1;
 496 }