contrib/hostapd-0.4.9/eap_tls.c

   1 /*
   2  * hostapd / EAP-TLS (RFC 2716)
   3  * Copyright (c) 2004-2005, Jouni Malinen <jkmaline@cc.hut.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <netinet/in.h>
  19
  20 #include "hostapd.h"
  21 #include "common.h"
  22 #include "eap_i.h"
  23 #include "eap_tls_common.h"
  24 #include "tls.h"
  25
  26
  27 static void eap_tls_reset(struct eap_sm *sm, void *priv);
  28
  29
  30 struct eap_tls_data {
  31         struct eap_ssl_data ssl;
  32         enum { START, CONTINUE, SUCCESS, FAILURE } state;
  33 };
  34
  35
  36 static void * eap_tls_init(struct eap_sm *sm)
  37 {
  38         struct eap_tls_data *data;
  39
  40         data = malloc(sizeof(*data));
  41         if (data == NULL)
  42                 return data;
  43         memset(data, 0, sizeof(*data));
  44         data->state = START;
  45
  46         if (eap_tls_ssl_init(sm, &data->ssl, 1)) {
  47                 wpa_printf(MSG_INFO, "EAP-TLS: Failed to initialize SSL.");
  48                 eap_tls_reset(sm, data);
  49                 return NULL;
  50         }
  51
  52         return data;
  53 }
  54
  55
  56 static void eap_tls_reset(struct eap_sm *sm, void *priv)
  57 {
  58         struct eap_tls_data *data = priv;
  59         if (data == NULL)
  60                 return;
  61         eap_tls_ssl_deinit(sm, &data->ssl);
  62         free(data);
  63 }
  64
  65
  66 static u8 * eap_tls_build_start(struct eap_sm *sm, struct eap_tls_data *data,
  67                                 int id, size_t *reqDataLen)
  68 {
  69         struct eap_hdr *req;
  70         u8 *pos;
  71
  72         *reqDataLen = sizeof(*req) + 2;
  73         req = malloc(*reqDataLen);
  74         if (req == NULL) {
  75                 wpa_printf(MSG_ERROR, "EAP-TLS: Failed to allocate memory for "
  76                            "request");
  77                 data->state = FAILURE;
  78                 return NULL;
  79         }
  80
  81         req->code = EAP_CODE_REQUEST;
  82         req->identifier = id;
  83         req->length = htons(*reqDataLen);
  84         pos = (u8 *) (req + 1);
  85         *pos++ = EAP_TYPE_TLS;
  86         *pos = EAP_TLS_FLAGS_START;
  87
  88         data->state = CONTINUE;
  89
  90         return (u8 *) req;
  91 }
  92
  93
  94 static u8 * eap_tls_build_req(struct eap_sm *sm, struct eap_tls_data *data,
  95                               int id, size_t *reqDataLen)
  96 {
  97         int res;
  98         u8 *req;
  99
 100         res = eap_tls_buildReq_helper(sm, &data->ssl, EAP_TYPE_TLS, 0, id,
 101                                       &req, reqDataLen);
 102
 103         if (tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
 104                 wpa_printf(MSG_DEBUG, "EAP-TLS: Done");
 105                 data->state = SUCCESS;
 106         }
 107
 108         if (res == 1)
 109                 return eap_tls_build_ack(reqDataLen, id, EAP_TYPE_TLS, 0);
 110         return req;
 111 }
 112
 113
 114 static u8 * eap_tls_buildReq(struct eap_sm *sm, void *priv, int id,
 115                              size_t *reqDataLen)
 116 {
 117         struct eap_tls_data *data = priv;
 118
 119         switch (data->state) {
 120         case START:
 121                 return eap_tls_build_start(sm, data, id, reqDataLen);
 122         case CONTINUE:
 123                 return eap_tls_build_req(sm, data, id, reqDataLen);
 124         default:
 125                 wpa_printf(MSG_DEBUG, "EAP-TLS: %s - unexpected state %d",
 126                            __func__, data->state);
 127                 return NULL;
 128         }
 129 }
 130
 131
 132 static Boolean eap_tls_check(struct eap_sm *sm, void *priv,
 133                              u8 *respData, size_t respDataLen)
 134 {
 135         struct eap_hdr *resp;
 136         u8 *pos;
 137         size_t len;
 138
 139         resp = (struct eap_hdr *) respData;
 140         pos = (u8 *) (resp + 1);
 141         if (respDataLen < sizeof(*resp) + 2 || *pos != EAP_TYPE_TLS ||
 142             (len = ntohs(resp->length)) > respDataLen) {
 143                 wpa_printf(MSG_INFO, "EAP-TLS: Invalid frame");
 144                 return TRUE;
 145         }
 146
 147         return FALSE;
 148 }
 149
 150
 151 static void eap_tls_process(struct eap_sm *sm, void *priv,
 152                             u8 *respData, size_t respDataLen)
 153 {
 154         struct eap_tls_data *data = priv;
 155         struct eap_hdr *resp;
 156         u8 *pos, flags;
 157         int left;
 158         unsigned int tls_msg_len;
 159
 160         resp = (struct eap_hdr *) respData;
 161         pos = (u8 *) (resp + 1);
 162         pos++;
 163         flags = *pos++;
 164         left = htons(resp->length) - sizeof(struct eap_hdr) - 2;
 165         wpa_printf(MSG_DEBUG, "EAP-TLS: Received packet(len=%lu) - "
 166                    "Flags 0x%02x", (unsigned long) respDataLen, flags);
 167         if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED) {
 168                 if (left < 4) {
 169                         wpa_printf(MSG_INFO, "EAP-TLS: Short frame with TLS "
 170                                    "length");
 171                         data->state = FAILURE;
 172                         return;
 173                 }
 174                 tls_msg_len = (pos[0] << 24) | (pos[1] << 16) | (pos[2] << 8) |
 175                         pos[3];
 176                 wpa_printf(MSG_DEBUG, "EAP-TLS: TLS Message Length: %d",
 177                            tls_msg_len);
 178                 if (data->ssl.tls_in_left == 0) {
 179                         data->ssl.tls_in_total = tls_msg_len;
 180                         data->ssl.tls_in_left = tls_msg_len;
 181                         free(data->ssl.tls_in);
 182                         data->ssl.tls_in = NULL;
 183                         data->ssl.tls_in_len = 0;
 184                 }
 185                 pos += 4;
 186                 left -= 4;
 187         }
 188
 189         if (eap_tls_process_helper(sm, &data->ssl, pos, left) < 0) {
 190                 wpa_printf(MSG_INFO, "EAP-TLS: TLS processing failed");
 191                 data->state = FAILURE;
 192                 return;
 193         }
 194
 195         if (tls_connection_get_write_alerts(sm->ssl_ctx, data->ssl.conn) > 1) {
 196                 wpa_printf(MSG_INFO, "EAP-TLS: Locally detected fatal error "
 197                            "in TLS processing");
 198                 data->state = FAILURE;
 199                 return;
 200         }
 201 }
 202
 203
 204 static Boolean eap_tls_isDone(struct eap_sm *sm, void *priv)
 205 {
 206         struct eap_tls_data *data = priv;
 207         return data->state == SUCCESS || data->state == FAILURE;
 208 }
 209
 210
 211 static u8 * eap_tls_getKey(struct eap_sm *sm, void *priv, size_t *len)
 212 {
 213         struct eap_tls_data *data = priv;
 214         u8 *eapKeyData;
 215
 216         if (data->state != SUCCESS)
 217                 return NULL;
 218
 219         eapKeyData = eap_tls_derive_key(sm, &data->ssl,
 220                                         "client EAP encryption",
 221                                         EAP_TLS_KEY_LEN);
 222         if (eapKeyData) {
 223                 *len = EAP_TLS_KEY_LEN;
 224                 wpa_hexdump(MSG_DEBUG, "EAP-TLS: Derived key",
 225                             eapKeyData, EAP_TLS_KEY_LEN);
 226         } else {
 227                 wpa_printf(MSG_DEBUG, "EAP-TLS: Failed to derive key");
 228         }
 229
 230         return eapKeyData;
 231 }
 232
 233
 234 static Boolean eap_tls_isSuccess(struct eap_sm *sm, void *priv)
 235 {
 236         struct eap_tls_data *data = priv;
 237         return data->state == SUCCESS;
 238 }
 239
 240
 241 const struct eap_method eap_method_tls =
 242 {
 243         .method = EAP_TYPE_TLS,
 244         .name = "TLS",
 245         .init = eap_tls_init,
 246         .reset = eap_tls_reset,
 247         .buildReq = eap_tls_buildReq,
 248         .check = eap_tls_check,
 249         .process = eap_tls_process,
 250         .isDone = eap_tls_isDone,
 251         .getKey = eap_tls_getKey,
 252         .isSuccess = eap_tls_isSuccess,
 253 };