src/modules/rlm_eap/libeap/eap_tls.c

   1 /*
   2  * eap_tls.c
   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 2001  hereUare Communications, Inc. <raghud@hereuare.com>
  21  * Copyright 2003  Alan DeKok <aland@freeradius.org>
  22  * Copyright 2006  The FreeRADIUS server project
  23  */
  24
  25 /*
  26  *
  27  *  TLS Packet Format in EAP
  28  *  --- ------ ------ -- ---
  29  * 0                   1                   2                   3
  30  * 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
  31  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  32  * |     Code      |   Identifier  |            Length             |
  33  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  34  * |     Type      |     Flags     |      TLS Message Length
  35  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  36  * |     TLS Message Length        |       TLS Data...
  37  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  38  *
  39  */
  40
  41 #include <freeradius-devel/ident.h>
  42 RCSID("$Id$")
  43
  44 #include <freeradius-devel/autoconf.h>
  45 #include <assert.h>
  46 #include "eap_tls.h"
  47
  48 /*
  49  *      Allocate a new TLS_PACKET
  50  */
  51 EAPTLS_PACKET *eaptls_alloc(void)
  52 {
  53         EAPTLS_PACKET   *rp;
  54
  55         if ((rp = malloc(sizeof(EAPTLS_PACKET))) == NULL) {
  56                 radlog(L_ERR, "rlm_eap_tls: out of memory");
  57                 return NULL;
  58         }
  59         memset(rp, 0, sizeof(EAPTLS_PACKET));
  60         return rp;
  61 }
  62
  63 /*
  64  *      Free EAPTLS_PACKET
  65  */
  66 void eaptls_free(EAPTLS_PACKET **eaptls_packet_ptr)
  67 {
  68         EAPTLS_PACKET *eaptls_packet;
  69
  70         if (!eaptls_packet_ptr) return;
  71         eaptls_packet = *eaptls_packet_ptr;
  72         if (eaptls_packet == NULL) return;
  73
  74         if (eaptls_packet->data) {
  75                 free(eaptls_packet->data);
  76                 eaptls_packet->data = NULL;
  77         }
  78
  79         free(eaptls_packet);
  80         *eaptls_packet_ptr = NULL;
  81 }
  82
  83 /*
  84    The S flag is set only within the EAP-TLS start message
  85    sent from the EAP server to the peer.
  86 */
  87 int eaptls_start(EAP_DS *eap_ds, int peap_flag)
  88 {
  89         EAPTLS_PACKET   reply;
  90
  91         reply.code = EAPTLS_START;
  92         reply.length = TLS_HEADER_LEN + 1/*flags*/;
  93
  94         reply.flags = peap_flag;
  95         reply.flags = SET_START(reply.flags);
  96
  97         reply.data = NULL;
  98         reply.dlen = 0;
  99
 100         eaptls_compose(eap_ds, &reply);
 101
 102         return 1;
 103 }
 104
 105 int eaptls_success(EAP_DS *eap_ds, int peap_flag)
 106 {
 107         EAPTLS_PACKET   reply;
 108
 109         reply.code = EAPTLS_SUCCESS;
 110         reply.length = TLS_HEADER_LEN;
 111         reply.flags = peap_flag;
 112         reply.data = NULL;
 113         reply.dlen = 0;
 114
 115         eaptls_compose(eap_ds, &reply);
 116
 117         return 1;
 118 }
 119
 120 int eaptls_fail(EAP_DS *eap_ds, int peap_flag)
 121 {
 122         EAPTLS_PACKET   reply;
 123
 124         reply.code = EAPTLS_FAIL;
 125         reply.length = TLS_HEADER_LEN;
 126         reply.flags = peap_flag;
 127         reply.data = NULL;
 128         reply.dlen = 0;
 129
 130         eaptls_compose(eap_ds, &reply);
 131
 132         return 1;
 133 }
 134
 135 /*
 136    A single TLS record may be up to 16384 octets in length, but a TLS
 137    message may span multiple TLS records, and a TLS certificate message
 138    may in principle be as long as 16MB.
 139 */
 140
 141 /*
 142  *      Frame the Dirty data that needs to be send to the client in an
 143  *      EAP-Request.  We always embed the TLS-length in all EAP-TLS
 144  *      packets that we send, for easy reference purpose.  Handle
 145  *      fragmentation and sending the next fragment etc.
 146  */
 147 int eaptls_request(EAP_DS *eap_ds, tls_session_t *ssn)
 148 {
 149         EAPTLS_PACKET   reply;
 150         unsigned int    size;
 151         unsigned int    nlen;
 152         unsigned int    lbit = 0;
 153
 154         /* This value determines whether we set (L)ength flag for
 155                 EVERY packet we send and add corresponding
 156                 "TLS Message Length" field.
 157
 158         length_flag = TRUE;
 159                 This means we include L flag and "TLS Msg Len" in EVERY
 160                 packet we send out.
 161
 162         length_flag = FALSE;
 163                 This means we include L flag and "TLS Msg Len" **ONLY**
 164                 in First packet of a fragment series. We do not use
 165                 it anywhere else.
 166
 167                 Having L flag in every packet is prefered.
 168
 169         */
 170         if (ssn->length_flag) {
 171                 lbit = 4;
 172         }
 173         if (ssn->fragment == 0) {
 174                 ssn->tls_msg_len = ssn->dirty_out.used;
 175         }
 176
 177         reply.code = EAPTLS_REQUEST;
 178         reply.flags = ssn->peap_flag;
 179
 180         /* Send data, NOT more than the FRAGMENT size */
 181         if (ssn->dirty_out.used > ssn->offset) {
 182                 size = ssn->offset;
 183                 reply.flags = SET_MORE_FRAGMENTS(reply.flags);
 184                 /* Length MUST be included if it is the First Fragment */
 185                 if (ssn->fragment == 0) {
 186                         lbit = 4;
 187                 }
 188                 ssn->fragment = 1;
 189         } else {
 190                 size = ssn->dirty_out.used;
 191                 ssn->fragment = 0;
 192         }
 193
 194         reply.dlen = lbit + size;
 195         reply.length = TLS_HEADER_LEN + 1/*flags*/ + reply.dlen;
 196
 197         reply.data = malloc(reply.dlen);
 198         if (lbit) {
 199                 nlen = htonl(ssn->tls_msg_len);
 200                 memcpy(reply.data, &nlen, lbit);
 201                 reply.flags = SET_LENGTH_INCLUDED(reply.flags);
 202         }
 203         (ssn->record_minus)(&ssn->dirty_out, reply.data + lbit, size);
 204
 205         eaptls_compose(eap_ds, &reply);
 206         free(reply.data);
 207         reply.data = NULL;
 208
 209         return 1;
 210 }
 211
 212 /*
 213  * Acknowledge received is for one of the following messages sent earlier
 214  * 1. Handshake completed Message, so now send, EAP-Success
 215  * 2. Alert Message, now send, EAP-Failure
 216  * 3. Fragment Message, now send, next Fragment
 217  */
 218 static eaptls_status_t eaptls_ack_handler(EAP_HANDLER *handler)
 219 {
 220         tls_session_t *tls_session;
 221
 222         tls_session = (tls_session_t *)handler->opaque;
 223         if (tls_session == NULL){
 224                 radlog(L_ERR, "rlm_eap_tls: Unexpected ACK received");
 225                 return EAPTLS_FAIL;
 226         }
 227         if (tls_session->info.initialized == 0) {
 228                 DEBUG("  rlm_eap_tls: No SSL info available. Waiting for more SSL data.");
 229                 return EAPTLS_REQUEST;
 230         }
 231         if (tls_session->info.origin == 0) {
 232                 radlog(L_ERR, "rlm_eap_tls: Unexpected ACK received");
 233                 return EAPTLS_FAIL;
 234         }
 235
 236         switch (tls_session->info.content_type) {
 237         case alert:
 238                 DEBUG2("  rlm_eap_tls: ack alert");
 239                 eaptls_fail(handler->eap_ds, tls_session->peap_flag);
 240                 return EAPTLS_FAIL;
 241
 242         case handshake:
 243                 if ((tls_session->info.handshake_type == finished) &&
 244                     (tls_session->dirty_out.used == 0)) {
 245                         DEBUG2("  rlm_eap_tls: ack handshake is finished");
 246                         return EAPTLS_SUCCESS;
 247                 } /* else more data to send */
 248
 249                 DEBUG2("  rlm_eap_tls: ack handshake fragment handler");
 250                 /* Fragmentation handler, send next fragment */
 251                 return EAPTLS_REQUEST;
 252
 253                 /*
 254                  *      For the rest of the conditions, switch over
 255                  *      to the default section below.
 256                  */
 257         default:
 258                 DEBUG2("  rlm_eap_tls: ack default");
 259                 radlog(L_ERR, "rlm_eap_tls: Invalid ACK received: %d",
 260                        tls_session->info.content_type);
 261                 return EAPTLS_FAIL;
 262         }
 263 }
 264
 265 /*
 266  *      Similarly, when the EAP server receives an EAP-Response with
 267  *      the M bit set, it MUST respond with an EAP-Request with
 268  *      EAP-Type=EAP-TLS and no data. This serves as a fragment ACK.
 269  *
 270  *      In order to prevent errors in the processing of fragments, the
 271  *      EAP server MUST use increment the Identifier value for each
 272  *      fragment ACK contained within an EAP-Request, and the peer
 273  *      MUST include this Identifier value in the subsequent fragment
 274  *      contained within an EAP- Reponse.
 275  *
 276  *      EAP server sends an ACK when it determines there are More
 277  *      fragments to receive to make the complete
 278  *      TLS-record/TLS-Message
 279  */
 280 static int eaptls_send_ack(EAP_DS *eap_ds, int peap_flag)
 281 {
 282         EAPTLS_PACKET   reply;
 283
 284         reply.code = EAPTLS_ACK;
 285         reply.length = TLS_HEADER_LEN + 1/*flags*/;
 286         reply.flags = peap_flag;
 287         reply.data = NULL;
 288         reply.dlen = 0;
 289
 290         eaptls_compose(eap_ds, &reply);
 291
 292         return 1;
 293 }
 294
 295 /*
 296  *      The S flag is set only within the EAP-TLS start message sent
 297  *      from the EAP server to the peer.
 298  *
 299  *      Similarly, when the EAP server receives an EAP-Response with
 300  *      the M bit set, it MUST respond with an EAP-Request with
 301  *      EAP-Type=EAP-TLS and no data. This serves as a fragment
 302  *      ACK. The EAP peer MUST wait.
 303  */
 304 static eaptls_status_t eaptls_verify(EAP_HANDLER *handler)
 305 {
 306         EAP_DS *eap_ds = handler->eap_ds;
 307         EAP_DS *prev_eap_ds = handler->prev_eapds;
 308         eaptls_packet_t *eaptls_packet, *eaptls_prev = NULL;
 309
 310         /*
 311          *      We don't check ANY of the input parameters.  It's all
 312          *      code which works together, so if something is wrong,
 313          *      we SHOULD core dump.
 314          *
 315          *      e.g. if eap_ds is NULL, of if eap_ds->response is
 316          *      NULL, of if it's NOT an EAP-Response, or if the packet
 317          *      is too short.  See eap_validation()., in ../../eap.c
 318          *
 319          *      Also, eaptype_select() takes care of selecting the
 320          *      appropriate type, so we don't need to check
 321          *      eap_ds->response->type.type == PW_EAP_TLS, or anything
 322          *      else.
 323          */
 324         eaptls_packet = (eaptls_packet_t *)eap_ds->response->type.data;
 325         if (prev_eap_ds && prev_eap_ds->response)
 326                 eaptls_prev = (eaptls_packet_t *)prev_eap_ds->response->type.data;
 327
 328         /*
 329          *      check for ACK
 330          *
 331          *      If there's no TLS data, or there's 1 byte of TLS data,
 332          *      with the flags set to zero, then it's an ACK.
 333          *
 334          *      Find if this is a reply to the previous request sent
 335          */
 336         if ((eaptls_packet == NULL) ||
 337             ((eap_ds->response->length == EAP_HEADER_LEN + 2) &&
 338              ((eaptls_packet->flags & 0xc0) == 0x00))) {
 339
 340 #if 0
 341                 /*
 342                  *      Un-comment this for TLS inside of TTLS/PEAP
 343                  */
 344                 DEBUG2("rlm_eap_tls: Received EAP-TLS ACK message");
 345                 return eaptls_ack_handler(handler);
 346 #else
 347                 if (prev_eap_ds->request->id == eap_ds->response->id) {
 348                         /*
 349                          *      Run the ACK handler directly from here.
 350                          */
 351                         DEBUG2("rlm_eap_tls: Received EAP-TLS ACK message");
 352                         return eaptls_ack_handler(handler);
 353                 } else {
 354                         radlog(L_ERR, "rlm_eap_tls: Received Invalid EAP-TLS ACK message");
 355                         return EAPTLS_INVALID;
 356                 }
 357 #endif
 358         }
 359
 360         /*
 361          *      We send TLS_START, but do not receive it.
 362          */
 363         if (TLS_START(eaptls_packet->flags)) {
 364                 radlog(L_ERR, "rlm_eap_tls:  Received unexpected EAP-TLS Start message");
 365                 return EAPTLS_INVALID;
 366         }
 367
 368         /*
 369          *      The L bit (length included) is set to indicate the
 370          *      presence of the four octet TLS Message Length field,
 371          *      and MUST be set for the first fragment of a fragmented
 372          *      TLS message or set of messages.
 373          *
 374          *      The M bit (more fragments) is set on all but the last
 375          *      fragment.
 376          *
 377          *      The S bit (EAP-TLS start) is set in an EAP-TLS Start
 378          *      message. This differentiates the EAP-TLS Start message
 379          *      from a fragment acknowledgement.
 380          */
 381         if (TLS_LENGTH_INCLUDED(eaptls_packet->flags)) {
 382                 DEBUG2("  TLS Length %d",
 383                        eaptls_packet->data[2] * 256 | eaptls_packet->data[3]);
 384                 if (TLS_MORE_FRAGMENTS(eaptls_packet->flags)) {
 385                         /*
 386                          * FIRST_FRAGMENT is identified
 387                          * 1. If there is no previous EAP-response received.
 388                          * 2. If EAP-response received, then its M bit not set.
 389                          *      (It is because Last fragment will not have M bit set)
 390                          */
 391                         if (!prev_eap_ds ||
 392                             (prev_eap_ds->response == NULL) ||
 393                             (eaptls_prev == NULL) ||
 394                             !TLS_MORE_FRAGMENTS(eaptls_prev->flags)) {
 395
 396                                 DEBUG2("rlm_eap_tls:  Received EAP-TLS First Fragment of the message");
 397                                 return EAPTLS_FIRST_FRAGMENT;
 398                         } else {
 399
 400                                 DEBUG2("rlm_eap_tls:  More Fragments with length included");
 401                                 return EAPTLS_MORE_FRAGMENTS_WITH_LENGTH;
 402                         }
 403                 } else {
 404                         DEBUG2("rlm_eap_tls:  Length Included");
 405                         return EAPTLS_LENGTH_INCLUDED;
 406                 }
 407         }
 408
 409         if (TLS_MORE_FRAGMENTS(eaptls_packet->flags)) {
 410                 DEBUG2("rlm_eap_tls:  More fragments to follow");
 411                 return EAPTLS_MORE_FRAGMENTS;
 412         }
 413
 414         /*
 415          *      None of the flags are set, but it's still a valid
 416          *      EAPTLS packet.
 417          */
 418         return EAPTLS_OK;
 419 }
 420
 421 /*
 422  * EAPTLS_PACKET
 423  * code   =  EAP-code
 424  * id     =  EAP-id
 425  * length = code + id + length + flags + tlsdata
 426  *        =  1   +  1 +   2    +  1    +  X
 427  * length = EAP-length - 1(EAP-Type = 1 octet)
 428  * flags  = EAP-typedata[0] (1 octet)
 429  * dlen   = EAP-typedata[1-4] (4 octets), if L flag set
 430  *        = length - 5(code+id+length+flags), otherwise
 431  * data   = EAP-typedata[5-n], if L flag set
 432  *        = EAP-typedata[1-n], otherwise
 433  * packet = EAP-typedata (complete typedata)
 434  *
 435  * Points to consider during EAP-TLS data extraction
 436  * 1. In the received packet, No data will be present incase of ACK-NAK
 437  * 2. Incase if more fragments need to be received then ACK after retreiving this fragment.
 438  *
 439  *  RFC 2716 Section 4.2.  PPP EAP TLS Request Packet
 440  *
 441  *  0                   1                   2                   3
 442  *  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
 443  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 444  *  |     Code      |   Identifier  |            Length             |
 445  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 446  *  |     Type      |     Flags     |      TLS Message Length
 447  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 448  *  |     TLS Message Length        |       TLS Data...
 449  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 450  *
 451  *  The Length field is two octets and indicates the length of the EAP
 452  *  packet including the Code, Identifir, Length, Type, and TLS data
 453  *  fields.
 454  */
 455 static EAPTLS_PACKET *eaptls_extract(EAP_DS *eap_ds, eaptls_status_t status)
 456 {
 457         EAPTLS_PACKET   *tlspacket;
 458         uint32_t        data_len = 0;
 459         uint32_t        len = 0;
 460         uint8_t         *data = NULL;
 461
 462         if (status  == EAPTLS_INVALID)
 463                 return NULL;
 464
 465         /*
 466          *      The main EAP code & eaptls_verify() take care of
 467          *      ensuring that the packet is OK, and that we can
 468          *      extract the various fields we want.
 469          *
 470          *      e.g. a TLS packet with zero data is allowed as an ACK,
 471          *      but we will never see it here, as we will simply
 472          *      send another fragment, instead of trying to extract
 473          *      the data.
 474          *
 475          *      MUST have TLS type octet, followed by flags, followed
 476          *      by data.
 477          */
 478         assert(eap_ds->response->length > 2);
 479
 480         tlspacket = eaptls_alloc();
 481         if (tlspacket == NULL) return NULL;
 482
 483         /*
 484          *      Code & id for EAPTLS & EAP are same
 485          *      but eaptls_length = eap_length - 1(EAP-Type = 1 octet)
 486          *
 487          *      length = code + id + length + type + tlsdata
 488          *             =  1   +  1 +   2    +  1    +  X
 489          */
 490         tlspacket->code = eap_ds->response->code;
 491         tlspacket->id = eap_ds->response->id;
 492         tlspacket->length = eap_ds->response->length - 1; /* EAP type */
 493         tlspacket->flags = eap_ds->response->type.data[0];
 494
 495         /*
 496          *      A quick sanity check of the flags.  If we've been told
 497          *      that there's a length, and there isn't one, then stop.
 498          */
 499         if (TLS_LENGTH_INCLUDED(tlspacket->flags) &&
 500             (tlspacket->length < 5)) { /* flags + TLS message length */
 501                 radlog(L_ERR, "rlm_eap_tls: Invalid EAP-TLS packet received.  (Length bit is set, but no length was found.)");
 502                 eaptls_free(&tlspacket);
 503                 return NULL;
 504         }
 505
 506         /*
 507          *      If the final TLS packet is larger than we can handle, die
 508          *      now.
 509          *
 510          *      Likewise, if the EAP packet says N bytes, and the TLS
 511          *      packet says there's fewer bytes, it's a problem.
 512          *
 513          *      FIXME: Try to ensure that the claimed length is
 514          *      consistent across multiple TLS fragments.
 515          */
 516         if (TLS_LENGTH_INCLUDED(tlspacket->flags)) {
 517                 memcpy(&data_len, &eap_ds->response->type.data[1], 4);
 518                 data_len = ntohl(data_len);
 519                 if (data_len > MAX_RECORD_SIZE) {
 520                         radlog(L_ERR, "rlm_eap_tls: The EAP-TLS packet will contain more data than we can process.");
 521                         eaptls_free(&tlspacket);
 522                         return NULL;
 523                 }
 524
 525 #if 0
 526                 DEBUG2(" TLS: %d %d\n", data_len, tlspacket->length);
 527
 528                 if (data_len < tlspacket->length) {
 529                         radlog(L_ERR, "rlm_eap_tls: EAP-TLS packet claims to be smaller than the encapsulating EAP packet.");
 530                         eaptls_free(&tlspacket);
 531                         return NULL;
 532                 }
 533 #endif
 534         }
 535
 536         switch (status) {
 537         /*
 538          *      The TLS Message Length field is four octets, and
 539          *      provides the total length of the TLS message or set of
 540          *      messages that is being fragmented; this simplifies
 541          *      buffer allocation.
 542          *
 543          *      Dynamic allocation of buffers as & when we know the
 544          *      length should solve the problem.
 545          */
 546         case EAPTLS_FIRST_FRAGMENT:
 547         case EAPTLS_LENGTH_INCLUDED:
 548         case EAPTLS_MORE_FRAGMENTS_WITH_LENGTH:
 549                 if (tlspacket->length < 5) { /* flags + TLS message length */
 550                         radlog(L_ERR, "rlm_eap_tls: Invalid EAP-TLS packet received.  (Expected length, got none.)");
 551                         eaptls_free(&tlspacket);
 552                         return NULL;
 553                 }
 554
 555                 /*
 556                  *      Extract all the TLS fragments from the
 557                  *      previous eap_ds Start appending this
 558                  *      fragment to the above ds
 559                  */
 560                 memcpy(&data_len, &eap_ds->response->type.data[1], sizeof(uint32_t));
 561                 data_len = ntohl(data_len);
 562                 data = (eap_ds->response->type.data + 5/*flags+TLS-Length*/);
 563                 len = eap_ds->response->type.length - 5/*flags+TLS-Length*/;
 564
 565                 /*
 566                  *      Hmm... this should be an error, too.
 567                  */
 568                 if (data_len > len) {
 569                         data_len = len;
 570                 }
 571                 break;
 572
 573                 /*
 574                  *      Data length is implicit, from the EAP header.
 575                  */
 576         case EAPTLS_MORE_FRAGMENTS:
 577         case EAPTLS_OK:
 578                 data_len = eap_ds->response->type.length - 1/*flags*/;
 579                 data = eap_ds->response->type.data + 1/*flags*/;
 580                 break;
 581
 582         default:
 583                 radlog(L_ERR, "rlm_eap_tls: Invalid EAP-TLS packet received");
 584                 eaptls_free(&tlspacket);
 585                 return NULL;
 586         }
 587
 588         tlspacket->dlen = data_len;
 589         if (data_len) {
 590                 tlspacket->data = (unsigned char *)malloc(data_len);
 591                 if (tlspacket->data == NULL) {
 592                         radlog(L_ERR, "rlm_eap_tls: out of memory");
 593                         eaptls_free(&tlspacket);
 594                         return NULL;
 595                 }
 596                 memcpy(tlspacket->data, data, data_len);
 597         }
 598
 599         return tlspacket;
 600 }
 601
 602
 603
 604 /*
 605  * To process the TLS,
 606  *  INCOMING DATA:
 607  *      1. EAP-TLS should get the compelete TLS data from the peer.
 608  *      2. Store that data in a data structure with any other required info
 609  *      3. Handle that data structure to the TLS module.
 610  *      4. TLS module will perform its operations on the data and
 611  *      handle back to EAP-TLS
 612  *
 613  *  OUTGOING DATA:
 614  *      1. EAP-TLS if necessary will fragment it and send it to the
 615  *      destination.
 616  *
 617  *      During EAP-TLS initialization, TLS Context object will be
 618  *      initialized and stored.  For every new authentication
 619  *      requests, TLS will open a new session object and that session
 620  *      object should be maintained even after the session is
 621  *      completed for session resumption. (Probably later as a feature
 622  *      as we donot know who maintains these session objects ie,
 623  *      SSL_CTX (internally) or TLS module(explicitly). If TLS module,
 624  *      then how to let SSL API know about these sessions.)
 625  */
 626 static void eaptls_operation(EAPTLS_PACKET *eaptls_packet UNUSED,
 627                              eaptls_status_t status, EAP_HANDLER *handler)
 628 {
 629         tls_session_t *tls_session;
 630
 631         tls_session = (tls_session_t *)handler->opaque;
 632
 633         if ((status == EAPTLS_MORE_FRAGMENTS) ||
 634             (status == EAPTLS_MORE_FRAGMENTS_WITH_LENGTH) ||
 635             (status == EAPTLS_FIRST_FRAGMENT)) {
 636                 /*
 637                  * Send the ACK.
 638                  */
 639                 eaptls_send_ack(handler->eap_ds, tls_session->peap_flag);
 640         } else {
 641                 int rcode;
 642
 643                 /*
 644                  *      We have the complete TLS-data or TLS-message.
 645                  *
 646                  *      Clean the dirty message.
 647                  *
 648                  *      Authenticate the user and send
 649                  *      Success/Failure.
 650                  *
 651                  *      If more info
 652                  *      is required then send another request.
 653                  */
 654                 rcode = tls_handshake_recv(tls_session);
 655                 if (rcode == 1) {
 656                         /*
 657                          *      FIXME: return success/fail.
 658                          *
 659                          *      TLS proper can decide what to do, then.
 660                          */
 661                         eaptls_request(handler->eap_ds, tls_session);
 662
 663                         /*
 664                          *      TLS returns 0 or 1.
 665                          *      anything else is application-specific.
 666                          *
 667                          *      In our code, this means "session
 668                          *      resumption was OK".
 669                          */
 670                 } else if (rcode == 0xea) {
 671                         /*
 672                          *      FIXME: hard-code key based on EAP type.
 673                          *      Also, this code is duplicated all over
 674                          *      the place...
 675                          */
 676                         eaptls_success(handler->eap_ds, 0);
 677                         eaptls_gen_mppe_keys(&handler->request->reply->vps,
 678                                              tls_session->ssl,
 679                                              "client EAP encryption");
 680
 681                 } else {
 682                         eaptls_fail(handler->eap_ds, tls_session->peap_flag);
 683
 684                 }
 685         }
 686         return;
 687 }
 688
 689
 690 /*
 691  * In the actual authentication first verify the packet and then create the data structure
 692  */
 693 /*
 694  * To process the TLS,
 695  *  INCOMING DATA:
 696  *      1. EAP-TLS should get the compelete TLS data from the peer.
 697  *      2. Store that data in a data structure with any other required info
 698  *      3. Hand this data structure to the TLS module.
 699  *      4. TLS module will perform its operations on the data and hands back to EAP-TLS
 700  *  OUTGOING DATA:
 701  *      1. EAP-TLS if necessary will fragment it and send it to the destination.
 702  *
 703  *      During EAP-TLS initialization, TLS Context object will be
 704  *      initialized and stored.  For every new authentication
 705  *      requests, TLS will open a new session object and that
 706  *      session object SHOULD be maintained even after the session
 707  *      is completed, for session resumption. (Probably later as a
 708  *      feature, as we do not know who maintains these session
 709  *      objects ie, SSL_CTX (internally) or TLS module (explicitly). If
 710  *      TLS module, then how to let SSL API know about these
 711  *      sessions.)
 712  */
 713
 714 /*
 715  *      Process an EAP request
 716  */
 717 eaptls_status_t eaptls_process(EAP_HANDLER *handler)
 718 {
 719         tls_session_t *tls_session = (tls_session_t *) handler->opaque;
 720         EAPTLS_PACKET   *tlspacket;
 721         eaptls_status_t status;
 722
 723         DEBUG2("  rlm_eap_tls: processing TLS");
 724
 725         /* This case is when SSL generates Alert then we
 726          * send that alert to the client and then send the EAP-Failure
 727          */
 728         status = eaptls_verify(handler);
 729         DEBUG2("  eaptls_verify returned %d\n", status);
 730
 731         switch (status) {
 732         default:
 733         case EAPTLS_INVALID:
 734         case EAPTLS_FAIL:
 735
 736                 /*
 737                  *      Success means that we're done the initial
 738                  *      handshake.  For TTLS, this means send stuff
 739                  *      back to the client, and the client sends us
 740                  *      more tunneled data.
 741                  */
 742         case EAPTLS_SUCCESS:
 743                 return status;
 744                 break;
 745
 746                 /*
 747                  *      Normal TLS request, continue with the "get rest
 748                  *      of fragments" phase.
 749                  */
 750         case EAPTLS_REQUEST:
 751                 eaptls_request(handler->eap_ds, tls_session);
 752                 return EAPTLS_HANDLED;
 753                 break;
 754
 755                 /*
 756                  *      The handshake is done, and we're in the "tunnel
 757                  *      data" phase.
 758                  */
 759         case EAPTLS_OK:
 760                 DEBUG2("  rlm_eap_tls: Done initial handshake");
 761
 762                 /*
 763                  *      Get the rest of the fragments.
 764                  */
 765         case EAPTLS_FIRST_FRAGMENT:
 766         case EAPTLS_MORE_FRAGMENTS:
 767         case EAPTLS_LENGTH_INCLUDED:
 768         case EAPTLS_MORE_FRAGMENTS_WITH_LENGTH:
 769                 break;
 770         }
 771
 772         /*
 773          *      Extract the TLS packet from the buffer.
 774          */
 775         if ((tlspacket = eaptls_extract(handler->eap_ds, status)) == NULL)
 776                 return EAPTLS_FAIL;
 777
 778         /*
 779          *      Get the session struct from the handler
 780          *
 781          *      update the dirty_in buffer
 782          *
 783          *      NOTE: This buffer will contain partial data when M bit is set.
 784          *
 785          *      CAUTION while reinitializing this buffer, it should be
 786          *      reinitialized only when this M bit is NOT set.
 787          */
 788         if (tlspacket->dlen !=
 789             (tls_session->record_plus)(&tls_session->dirty_in, tlspacket->data, tlspacket->dlen)) {
 790                 eaptls_free(&tlspacket);
 791                 radlog(L_ERR, "rlm_eap_tls: Exceeded maximum record size");
 792                 return EAPTLS_FAIL;
 793         }
 794
 795         /*
 796          *      SSL initalization is done.  Return.
 797          *
 798          *      The TLS data will be in the tls_session structure.
 799          */
 800         if (SSL_is_init_finished(tls_session->ssl) && (status == EAPTLS_OK)) {
 801                 eaptls_free(&tlspacket);
 802                 return EAPTLS_OK;
 803         }
 804
 805         /*
 806          *      Continue the handshake.
 807          */
 808         eaptls_operation(tlspacket, status, handler);
 809
 810         eaptls_free(&tlspacket);
 811         return EAPTLS_HANDLED;
 812 }
 813
 814
 815 /*
 816  *      compose the TLS reply packet in the EAP reply typedata
 817  */
 818 int eaptls_compose(EAP_DS *eap_ds, EAPTLS_PACKET *reply)
 819 {
 820         uint8_t *ptr;
 821
 822         /*
 823          *      Don't set eap_ds->request->type.type, as the main EAP
 824          *      handler will do that for us.  This allows the TLS
 825          *      module to be called from TTLS & PEAP.
 826          */
 827
 828         /*
 829          *      When the EAP server receives an EAP-Response with the
 830          *      M bit set, it MUST respond with an EAP-Request with
 831          *      EAP-Type=EAP-TLS and no data. This serves as a
 832          *      fragment ACK. The EAP peer MUST wait until it receives
 833          *      the EAP-Request before sending another fragment.
 834          *
 835          *      In order to prevent errors in the processing of
 836          *      fragments, the EAP server MUST use increment the
 837          *      Identifier value for each fragment ACK contained
 838          *      within an EAP-Request, and the peer MUST include this
 839          *      Identifier value in the subsequent fragment contained
 840          *      within an EAP- Reponse.
 841          */
 842         eap_ds->request->type.data = malloc(reply->length - TLS_HEADER_LEN + 1);
 843         if (eap_ds->request->type.data == NULL) {
 844                 radlog(L_ERR, "rlm_eap_tls: out of memory");
 845                 return 0;
 846         }
 847
 848         /* EAPTLS Header length is excluded while computing EAP typelen */
 849         eap_ds->request->type.length = reply->length - TLS_HEADER_LEN;
 850
 851         ptr = eap_ds->request->type.data;
 852         *ptr++ = (uint8_t)(reply->flags & 0xFF);
 853
 854         if (reply->dlen) memcpy(ptr, reply->data, reply->dlen);
 855
 856         switch (reply->code) {
 857         case EAPTLS_ACK:
 858         case EAPTLS_START:
 859         case EAPTLS_REQUEST:
 860                 eap_ds->request->code = PW_EAP_REQUEST;
 861                 break;
 862         case EAPTLS_SUCCESS:
 863                 eap_ds->request->code = PW_EAP_SUCCESS;
 864                 break;
 865         case EAPTLS_FAIL:
 866                 eap_ds->request->code = PW_EAP_FAILURE;
 867                 break;
 868         default:
 869                 /* Should never enter here */
 870                 eap_ds->request->code = PW_EAP_FAILURE;
 871                 break;
 872         }
 873
 874         return 1;
 875 }