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