MFC: An off-by-one malloc size was corrupting the installer's memory,

[dragonfly.git] / contrib / wpa_supplicant-0.5.8 / eap_tls_common.c

/*
 * EAP peer: EAP-TLS/PEAP/TTLS/FAST common functions
 * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#include "includes.h"

#include "common.h"
#include "eap_i.h"
#include "eap_tls_common.h"
#include "config_ssid.h"
#include "md5.h"
#include "sha1.h"
#include "tls.h"
#include "config.h"


static int eap_tls_check_blob(struct eap_sm *sm, const char **name,
                              const u8 **data, size_t *data_len)
{
        const struct wpa_config_blob *blob;

        if (*name == NULL || os_strncmp(*name, "blob://", 7) != 0)
                return 0;

        blob = eap_get_config_blob(sm, *name + 7);
        if (blob == NULL) {
                wpa_printf(MSG_ERROR, "%s: Named configuration blob '%s' not "
                           "found", __func__, *name + 7);
                return -1;
        }

        *name = NULL;
        *data = blob->data;
        *data_len = blob->len;

        return 0;
}


static void eap_tls_params_from_conf1(struct tls_connection_params *params,
                                      struct wpa_ssid *config)
{
        params->ca_cert = (char *) config->ca_cert;
        params->ca_path = (char *) config->ca_path;
        params->client_cert = (char *) config->client_cert;
        params->private_key = (char *) config->private_key;
        params->private_key_passwd = (char *) config->private_key_passwd;
        params->dh_file = (char *) config->dh_file;
        params->subject_match = (char *) config->subject_match;
        params->altsubject_match = (char *) config->altsubject_match;
        params->engine_id = config->engine_id;
        params->pin = config->pin;
        params->key_id = config->key_id;
}


static void eap_tls_params_from_conf2(struct tls_connection_params *params,
                                      struct wpa_ssid *config)
{
        params->ca_cert = (char *) config->ca_cert2;
        params->ca_path = (char *) config->ca_path2;
        params->client_cert = (char *) config->client_cert2;
        params->private_key = (char *) config->private_key2;
        params->private_key_passwd = (char *) config->private_key2_passwd;
        params->dh_file = (char *) config->dh_file2;
        params->subject_match = (char *) config->subject_match2;
        params->altsubject_match = (char *) config->altsubject_match2;
}


static int eap_tls_params_from_conf(struct eap_sm *sm,
                                    struct eap_ssl_data *data,
                                    struct tls_connection_params *params,
                                    struct wpa_ssid *config, int phase2)
{
        os_memset(params, 0, sizeof(*params));
        params->engine = config->engine;
        if (phase2)
                eap_tls_params_from_conf2(params, config);
        else
                eap_tls_params_from_conf1(params, config);
        params->tls_ia = data->tls_ia;


        if (eap_tls_check_blob(sm, &params->ca_cert, &params->ca_cert_blob,
                               &params->ca_cert_blob_len) ||
            eap_tls_check_blob(sm, &params->client_cert,
                               &params->client_cert_blob,
                               &params->client_cert_blob_len) ||
            eap_tls_check_blob(sm, &params->private_key,
                               &params->private_key_blob,
                               &params->private_key_blob_len) ||
            eap_tls_check_blob(sm, &params->dh_file, &params->dh_blob,
                               &params->dh_blob_len)) {
                wpa_printf(MSG_INFO, "SSL: Failed to get configuration blobs");
                return -1;
        }

        return 0;
}


static int eap_tls_init_connection(struct eap_sm *sm,
                                   struct eap_ssl_data *data,
                                   struct wpa_ssid *config,
                                   struct tls_connection_params *params)
{
        int res;

        data->conn = tls_connection_init(sm->ssl_ctx);
        if (data->conn == NULL) {
                wpa_printf(MSG_INFO, "SSL: Failed to initialize new TLS "
                           "connection");
                return -1;
        }

        res = tls_connection_set_params(sm->ssl_ctx, data->conn, params);
        if (res == TLS_SET_PARAMS_ENGINE_PRV_INIT_FAILED) {
                /* At this point with the pkcs11 engine the PIN might be wrong.
                 * We reset the PIN in the configuration to be sure to not use
                 * it again and the calling function must request a new one */
                os_free(config->pin);
                config->pin = NULL;
        } else if (res == TLS_SET_PARAMS_ENGINE_PRV_VERIFY_FAILED) {
                wpa_printf(MSG_INFO, "TLS: Failed to load private key");
                /* We don't know exactly but maybe the PIN was wrong,
                 * so ask for a new one. */
                os_free(config->pin);
                config->pin = NULL;
                eap_sm_request_pin(sm);
                sm->ignore = TRUE;
                return -1;
        } else if (res) {
                wpa_printf(MSG_INFO, "TLS: Failed to set TLS connection "
                           "parameters");
                return -1;
        }

        return 0;
}


/**
 * eap_tls_ssl_init - Initialize shared TLS functionality
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * @config: Pointer to the network configuration
 * Returns: 0 on success, -1 on failure
 *
 * This function is used to initialize shared TLS functionality for EAP-TLS,
 * EAP-PEAP, EAP-TTLS, and EAP-FAST.
 */
int eap_tls_ssl_init(struct eap_sm *sm, struct eap_ssl_data *data,
                     struct wpa_ssid *config)
{
        int ret = -1;
        struct tls_connection_params params;

        if (config == NULL)
                return -1;

        data->eap = sm;
        data->phase2 = sm->init_phase2;
        if (eap_tls_params_from_conf(sm, data, &params, config, data->phase2) <
            0)
                goto done;

        if (eap_tls_init_connection(sm, data, config, &params) < 0)
                goto done;

        data->tls_out_limit = config->fragment_size;
        if (data->phase2) {
                /* Limit the fragment size in the inner TLS authentication
                 * since the outer authentication with EAP-PEAP does not yet
                 * support fragmentation */
                if (data->tls_out_limit > 100)
                        data->tls_out_limit -= 100;
        }

        if (config->phase1 &&
            os_strstr(config->phase1, "include_tls_length=1")) {
                wpa_printf(MSG_DEBUG, "TLS: Include TLS Message Length in "
                           "unfragmented packets");
                data->include_tls_length = 1;
        }

        ret = 0;

done:
        return ret;
}


/**
 * eap_tls_ssl_deinit - Deinitialize shared TLS functionality
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 *
 * This function deinitializes shared TLS functionality that was initialized
 * with eap_tls_ssl_init().
 */
void eap_tls_ssl_deinit(struct eap_sm *sm, struct eap_ssl_data *data)
{
        tls_connection_deinit(sm->ssl_ctx, data->conn);
        os_free(data->tls_in);
        os_free(data->tls_out);
}


/**
 * eap_tls_derive_key - Derive a key based on TLS session data
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * @label: Label string for deriving the keys, e.g., "client EAP encryption"
 * @len: Length of the key material to generate (usually 64 for MSK)
 * Returns: Pointer to allocated key on success or %NULL on failure
 *
 * This function uses TLS-PRF to generate pseudo-random data based on the TLS
 * session data (client/server random and master key). Each key type may use a
 * different label to bind the key usage into the generated material.
 *
 * The caller is responsible for freeing the returned buffer.
 */
u8 * eap_tls_derive_key(struct eap_sm *sm, struct eap_ssl_data *data,
                        const char *label, size_t len)
{
        struct tls_keys keys;
        u8 *rnd = NULL, *out;

        out = os_malloc(len);
        if (out == NULL)
                return NULL;

        /* First, try to use TLS library function for PRF, if available. */
        if (tls_connection_prf(sm->ssl_ctx, data->conn, label, 0, out, len) ==
            0)
                return out;

        /*
         * TLS library did not support key generation, so get the needed TLS
         * session parameters and use an internal implementation of TLS PRF to
         * derive the key.
         */
        if (tls_connection_get_keys(sm->ssl_ctx, data->conn, &keys))
                goto fail;

        if (keys.client_random == NULL || keys.server_random == NULL ||
            keys.master_key == NULL)
                goto fail;

        rnd = os_malloc(keys.client_random_len + keys.server_random_len);
        if (rnd == NULL)
                goto fail;
        os_memcpy(rnd, keys.client_random, keys.client_random_len);
        os_memcpy(rnd + keys.client_random_len, keys.server_random,
                  keys.server_random_len);

        if (tls_prf(keys.master_key, keys.master_key_len,
                    label, rnd, keys.client_random_len +
                    keys.server_random_len, out, len))
                goto fail;

        os_free(rnd);
        return out;

fail:
        os_free(out);
        os_free(rnd);
        return NULL;
}


/**
 * eap_tls_data_reassemble - Reassemble TLS data
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * @in_data: Next incoming TLS segment
 * @in_len: Length of in_data
 * @out_len: Variable for returning output data length
 * @need_more_input: Variable for returning whether more input data is needed
 * to reassemble this TLS packet
 * Returns: Pointer to output data, %NULL on error or when more data is needed
 * for the full message (in which case, *need_more_input is also set to 1).
 *
 * This function reassembles TLS fragments. Caller must not free the returned
 * data buffer since an internal pointer to it is maintained.
 */
const u8 * eap_tls_data_reassemble(
        struct eap_sm *sm, struct eap_ssl_data *data, const u8 *in_data,
        size_t in_len, size_t *out_len, int *need_more_input)
{
        u8 *buf;

        *need_more_input = 0;

        if (data->tls_in_left > in_len || data->tls_in) {
                if (data->tls_in_len + in_len == 0) {
                        os_free(data->tls_in);
                        data->tls_in = NULL;
                        data->tls_in_len = 0;
                        wpa_printf(MSG_WARNING, "SSL: Invalid reassembly "
                                   "state: tls_in_left=%lu tls_in_len=%lu "
                                   "in_len=%lu",
                                   (unsigned long) data->tls_in_left,
                                   (unsigned long) data->tls_in_len,
                                   (unsigned long) in_len);
                        return NULL;
                }
                if (data->tls_in_len + in_len > 65536) {
                        /* Limit length to avoid rogue servers from causing
                         * large memory allocations. */
                        os_free(data->tls_in);
                        data->tls_in = NULL;
                        data->tls_in_len = 0;
                        wpa_printf(MSG_INFO, "SSL: Too long TLS fragment (size"
                                   " over 64 kB)");
                        return NULL;
                }
                buf = os_realloc(data->tls_in, data->tls_in_len + in_len);
                if (buf == NULL) {
                        os_free(data->tls_in);
                        data->tls_in = NULL;
                        data->tls_in_len = 0;
                        wpa_printf(MSG_INFO, "SSL: Could not allocate memory "
                                   "for TLS data");
                        return NULL;
                }
                os_memcpy(buf + data->tls_in_len, in_data, in_len);
                data->tls_in = buf;
                data->tls_in_len += in_len;
                if (in_len > data->tls_in_left) {
                        wpa_printf(MSG_INFO, "SSL: more data than TLS message "
                                   "length indicated");
                        data->tls_in_left = 0;
                        return NULL;
                }
                data->tls_in_left -= in_len;
                if (data->tls_in_left > 0) {
                        wpa_printf(MSG_DEBUG, "SSL: Need %lu bytes more input "
                                   "data", (unsigned long) data->tls_in_left);
                        *need_more_input = 1;
                        return NULL;
                }
        } else {
                data->tls_in_left = 0;
                data->tls_in = os_malloc(in_len ? in_len : 1);
                if (data->tls_in == NULL)
                        return NULL;
                os_memcpy(data->tls_in, in_data, in_len);
                data->tls_in_len = in_len;
        }

        *out_len = data->tls_in_len;
        return data->tls_in;
}


static int eap_tls_process_input(struct eap_sm *sm, struct eap_ssl_data *data,
                                 const u8 *in_data, size_t in_len,
                                 u8 **out_data, size_t *out_len)
{
        const u8 *msg;
        size_t msg_len;
        int need_more_input;
        u8 *appl_data;
        size_t appl_data_len;

        msg = eap_tls_data_reassemble(sm, data, in_data, in_len,
                                      &msg_len, &need_more_input);
        if (msg == NULL)
                return need_more_input ? 1 : -1;

        /* Full TLS message reassembled - continue handshake processing */
        if (data->tls_out) {
                /* This should not happen.. */
                wpa_printf(MSG_INFO, "SSL: eap_tls_process_helper - pending "
                           "tls_out data even though tls_out_len = 0");
                os_free(data->tls_out);
                WPA_ASSERT(data->tls_out == NULL);
        }
        appl_data = NULL;
        data->tls_out = tls_connection_handshake(sm->ssl_ctx, data->conn,
                                                 msg, msg_len,
                                                 &data->tls_out_len,
                                                 &appl_data, &appl_data_len);

        /* Clear reassembled input data (if the buffer was needed). */
        data->tls_in_left = data->tls_in_total = data->tls_in_len = 0;
        os_free(data->tls_in);
        data->tls_in = NULL;

        if (appl_data &&
            tls_connection_established(sm->ssl_ctx, data->conn) &&
            !tls_connection_get_failed(sm->ssl_ctx, data->conn)) {
                wpa_hexdump_key(MSG_MSGDUMP, "SSL: Application data",
                                appl_data, appl_data_len);
                *out_data = appl_data;
                *out_len = appl_data_len;
                return 2;
        }

        os_free(appl_data);

        return 0;
}


static int eap_tls_process_output(struct eap_ssl_data *data, EapType eap_type,
                                  int peap_version, u8 id, int ret,
                                  u8 **out_data, size_t *out_len)
{
        size_t len;
        u8 *pos, *flags;
        int more_fragments, length_included;
        
        wpa_printf(MSG_DEBUG, "SSL: %lu bytes left to be sent out (of total "
                   "%lu bytes)",
                   (unsigned long) data->tls_out_len - data->tls_out_pos,
                   (unsigned long) data->tls_out_len);

        len = data->tls_out_len - data->tls_out_pos;
        if (len > data->tls_out_limit) {
                more_fragments = 1;
                len = data->tls_out_limit;
                wpa_printf(MSG_DEBUG, "SSL: sending %lu bytes, more fragments "
                           "will follow", (unsigned long) len);
        } else
                more_fragments = 0;

        length_included = data->tls_out_pos == 0 &&
                (data->tls_out_len > data->tls_out_limit ||
                 data->include_tls_length);

        *out_data = (u8 *)
                eap_msg_alloc(EAP_VENDOR_IETF, eap_type, out_len,
                              1 + length_included * 4 + len, EAP_CODE_RESPONSE,
                              id, &pos);
        if (*out_data == NULL)
                return -1;

        flags = pos++;
        *flags = peap_version;
        if (more_fragments)
                *flags |= EAP_TLS_FLAGS_MORE_FRAGMENTS;
        if (length_included) {
                *flags |= EAP_TLS_FLAGS_LENGTH_INCLUDED;
                WPA_PUT_BE32(pos, data->tls_out_len);
                pos += 4;
        }

        os_memcpy(pos, &data->tls_out[data->tls_out_pos], len);
        data->tls_out_pos += len;

        if (!more_fragments) {
                data->tls_out_len = 0;
                data->tls_out_pos = 0;
                os_free(data->tls_out);
                data->tls_out = NULL;
        }

        return ret;
}


/**
 * eap_tls_process_helper - Process TLS handshake message
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * @eap_type: EAP type (EAP_TYPE_TLS, EAP_TYPE_PEAP, ...)
 * @peap_version: Version number for EAP-PEAP/TTLS
 * @id: EAP identifier for the response
 * @in_data: Message received from the server
 * @in_len: Length of in_data
 * @out_data: Buffer for returning a pointer to the response message
 * @out_len: Buffer for returning the length of the response message
 * Returns: 0 on success, 1 if more input data is needed, or -1 on failure
 *
 * This function can be used to process TLS handshake messages. It reassembles
 * the received fragments and uses a TLS library to process the messages. The
 * response data from the TLS library is fragmented to suitable output messages
 * that the caller can send out.
 *
 * out_data is used to return the response message if the return value of this
 * function is 0 or -1. In case of failure, the message is likely a TLS alarm
 * message. The caller is responsible for freeing the allocated buffer if
 * *out_data is not %NULL.
 */
int eap_tls_process_helper(struct eap_sm *sm, struct eap_ssl_data *data,
                           EapType eap_type, int peap_version,
                           u8 id, const u8 *in_data, size_t in_len,
                           u8 **out_data, size_t *out_len)
{
        int ret = 0;

        WPA_ASSERT(data->tls_out_len == 0 || in_len == 0);
        *out_len = 0;
        *out_data = NULL;

        if (data->tls_out_len == 0) {
                /* No more data to send out - expect to receive more data from
                 * the AS. */
                int res = eap_tls_process_input(sm, data, in_data, in_len,
                                                out_data, out_len);
                if (res)
                        return res;
        }

        if (data->tls_out == NULL) {
                data->tls_out_len = 0;
                return -1;
        }

        if (tls_connection_get_failed(sm->ssl_ctx, data->conn)) {
                wpa_printf(MSG_DEBUG, "SSL: Failed - tls_out available to "
                           "report error");
                ret = -1;
                /* TODO: clean pin if engine used? */
        }

        if (data->tls_out_len == 0) {
                /* TLS negotiation should now be complete since all other cases
                 * needing more data should have been caught above based on
                 * the TLS Message Length field. */
                wpa_printf(MSG_DEBUG, "SSL: No data to be sent out");
                os_free(data->tls_out);
                data->tls_out = NULL;
                return 1;
        }

        return eap_tls_process_output(data, eap_type, peap_version, id, ret,
                                      out_data, out_len);
}


/**
 * eap_tls_build_ack - Build a TLS ACK frames
 * @data: Data for TLS processing
 * @respDataLen: Buffer for returning the length of the response message
 * @id: EAP identifier for the response
 * @eap_type: EAP type (EAP_TYPE_TLS, EAP_TYPE_PEAP, ...)
 * @peap_version: Version number for EAP-PEAP/TTLS
 * Returns: Pointer to allocated ACK frames or %NULL on failure
 */
u8 * eap_tls_build_ack(struct eap_ssl_data *data, size_t *respDataLen, u8 id,
                       EapType eap_type, int peap_version)
{
        struct eap_hdr *resp;
        u8 *pos;

        resp = eap_msg_alloc(EAP_VENDOR_IETF, eap_type, respDataLen,
                             1, EAP_CODE_RESPONSE, id, &pos);
        if (resp == NULL)
                return NULL;
        wpa_printf(MSG_DEBUG, "SSL: Building ACK");
        *pos = peap_version; /* Flags */
        return (u8 *) resp;
}


/**
 * eap_tls_reauth_init - Re-initialize shared TLS for session resumption
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * Returns: 0 on success, -1 on failure
 */
int eap_tls_reauth_init(struct eap_sm *sm, struct eap_ssl_data *data)
{
        os_free(data->tls_in);
        data->tls_in = NULL;
        data->tls_in_len = data->tls_in_left = data->tls_in_total = 0;
        os_free(data->tls_out);
        data->tls_out = NULL;
        data->tls_out_len = data->tls_out_pos = 0;

        return tls_connection_shutdown(sm->ssl_ctx, data->conn);
}


/**
 * eap_tls_status - Get TLS status
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * @buf: Buffer for status information
 * @buflen: Maximum buffer length
 * @verbose: Whether to include verbose status information
 * Returns: Number of bytes written to buf.
 */
int eap_tls_status(struct eap_sm *sm, struct eap_ssl_data *data, char *buf,
                   size_t buflen, int verbose)
{
        char name[128];
        int len = 0, ret;

        if (tls_get_cipher(sm->ssl_ctx, data->conn, name, sizeof(name)) == 0) {
                ret = os_snprintf(buf + len, buflen - len,
                                  "EAP TLS cipher=%s\n", name);
                if (ret < 0 || (size_t) ret >= buflen - len)
                        return len;
                len += ret;
        }

        return len;
}


/**
 * eap_tls_process_init - Initial validation and processing of EAP requests
 * @sm: Pointer to EAP state machine allocated with eap_sm_init()
 * @data: Data for TLS processing
 * @eap_type: EAP type (EAP_TYPE_TLS, EAP_TYPE_PEAP, ...)
 * @ret: Return values from EAP request validation and processing
 * @reqData: EAP request to be processed (eapReqData)
 * @reqDataLen: Length of the EAP request
 * @len: Buffer for returning length of the remaining payload
 * @flags: Buffer for returning TLS flags
 * Returns: Buffer to payload after TLS flags and length or %NULL on failure
 */
const u8 * eap_tls_process_init(struct eap_sm *sm, struct eap_ssl_data *data,
                                EapType eap_type, struct eap_method_ret *ret,
                                const u8 *reqData, size_t reqDataLen,
                                size_t *len, u8 *flags)
{
        const u8 *pos;
        size_t left;
        unsigned int tls_msg_len;

        if (tls_get_errors(sm->ssl_ctx)) {
                wpa_printf(MSG_INFO, "SSL: TLS errors detected");
                ret->ignore = TRUE;
                return NULL;
        }

        pos = eap_hdr_validate(EAP_VENDOR_IETF, eap_type, reqData, reqDataLen,
                               &left);
        if (pos == NULL) {
                ret->ignore = TRUE;
                return NULL;
        }
        *flags = *pos++;
        left--;
        wpa_printf(MSG_DEBUG, "SSL: Received packet(len=%lu) - "
                   "Flags 0x%02x", (unsigned long) reqDataLen, *flags);
        if (*flags & EAP_TLS_FLAGS_LENGTH_INCLUDED) {
                if (left < 4) {
                        wpa_printf(MSG_INFO, "SSL: Short frame with TLS "
                                   "length");
                        ret->ignore = TRUE;
                        return NULL;
                }
                tls_msg_len = WPA_GET_BE32(pos);
                wpa_printf(MSG_DEBUG, "SSL: TLS Message Length: %d",
                           tls_msg_len);
                if (data->tls_in_left == 0) {
                        data->tls_in_total = tls_msg_len;
                        data->tls_in_left = tls_msg_len;
                        os_free(data->tls_in);
                        data->tls_in = NULL;
                        data->tls_in_len = 0;
                }
                pos += 4;
                left -= 4;
        }

        ret->ignore = FALSE;
        ret->methodState = METHOD_MAY_CONT;
        ret->decision = DECISION_FAIL;
        ret->allowNotifications = TRUE;

        *len = (size_t) left;
        return pos;
}