/*

 * Copyright (C) 2007-2012 Free Software Foundation, Inc.

 *

 * Author: Simon Josefsson

 *

 * This file is part of GnuTLS.

 *

 * The GnuTLS is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public License

 * as published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>

 *

 */

/* This file contains support functions for 'TLS Handshake Message for

 * Supplemental Data' (RFC 4680).

 *

 * The idea here is simple.  gnutls_handshake() in gnuts_handshake.c

 * will call _gnutls_gen_supplemental and _gnutls_parse_supplemental

 * when some extension requested that supplemental data be sent or

 * received.  Extension request this by setting the flags

 * do_recv_supplemental or do_send_supplemental in the session.

 *

 * The functions in this file iterate through the _gnutls_supplemental

 * array, and calls the send/recv functions for each respective data

 * type.

 *

 * The receive function of each data type is responsible for decoding

 * its own data.  If the extension did not expect to receive

 * supplemental data, it should return GNUTLS_E_UNEXPECTED_PACKET.

 * Otherwise, it just parse the data as normal.

 *

 * The send function needs to append the 2-byte data format type, and

 * append the 2-byte length of its data, and the data.  If it doesn't

 * want to send any data, it is fine to return without doing anything.

 */

#include "gnutls_int.h"

#include <gnutls/gnutls.h>

#include "supplemental.h"

#include "errors.h"

#include "num.h"

#include "intprops.h"

typedef struct gnutls_supplemental_entry_st {

  char *name;

  gnutls_supplemental_data_format_type_t type;

  gnutls_supp_recv_func supp_recv_func;

  gnutls_supp_send_func supp_send_func;

} gnutls_supplemental_entry_st;

static size_t suppfunc_size = 0;

static gnutls_supplemental_entry_st *suppfunc = NULL;

/**

 * gnutls_supplemental_get_name:

 * @type: is a supplemental data format type

 *

 * Convert a #gnutls_supplemental_data_format_type_t value to a

 * string.

 *

 * Returns: a string that contains the name of the specified

 *   supplemental data format type, or %NULL for unknown types.

 **/

const char

*gnutls_supplemental_get_name(gnutls_supplemental_data_format_type_t type)

{

  size_t i;

  for (i = 0; i < suppfunc_size; i++) {

    if (suppfunc[i].type == type)

      return suppfunc[i].name;

  }

  return NULL;

}

void _gnutls_supplemental_deinit(void)

{

  unsigned i;

  for (i = 0; i < suppfunc_size; i++) {

    gnutls_free(suppfunc[i].name);

  }

  gnutls_free(suppfunc);

  suppfunc = NULL;

  suppfunc_size = 0;

}

static gnutls_supp_recv_func

get_supp_func_recv(gnutls_session_t session,

       gnutls_supplemental_data_format_type_t type)

{

  size_t i;

  for (i = 0; i < session->internals.rsup_size; i++) {

    if (session->internals.rsup[i].type == type)

      return session->internals.rsup[i].supp_recv_func;

  }

  for (i = 0; i < suppfunc_size; i++) {

    if (suppfunc[i].type == type)

      return suppfunc[i].supp_recv_func;

  }

  return NULL;

}

static int gen_supplemental(gnutls_session_t session,

          const gnutls_supplemental_entry_st * supp,

          gnutls_buffer_st * buf)

{

  int ret;

  gnutls_supp_send_func supp_send = supp->supp_send_func;

  size_t sizepos = buf->length;

  /* Make room for supplement type and length byte length field. */

  ret = _gnutls_buffer_append_data(buf, "\0\0\0\0", 4);

  if (ret < 0) {

    gnutls_assert();

    return ret;

  }

  ret = supp_send(session, buf);

  if (ret < 0) {

    gnutls_assert();

    return ret;

  }

  /* If data were added, store type+length, otherwise reset. */

  if (buf->length > sizepos + 4) {

    buf->data[sizepos] = (supp->type >> 8) & 0xFF;

    buf->data[sizepos + 1] = supp->type & 0xFF;

    buf->data[sizepos + 2] =

        ((buf->length - sizepos - 4) >> 8) & 0xFF;

    buf->data[sizepos + 3] = (buf->length - sizepos - 4) & 0xFF;

  } else

    buf->length -= 4;

  return 0;

}

int _gnutls_gen_supplemental(gnutls_session_t session, gnutls_buffer_st * buf)

{

  size_t i;

  int ret;

  unsigned init_pos = buf->length;

  /* Make room for 3 byte length field. */

  ret = _gnutls_buffer_append_data(buf, "\0\0\0", 3);

  if (ret < 0) {

    gnutls_assert();

    return ret;

  }

  for (i = 0; i < session->internals.rsup_size; i++) {

    ret =

        gen_supplemental(session, &session->internals.rsup[i], buf);

    if (ret < 0)

      return gnutls_assert_val(ret);

  }

  for (i = 0; i < suppfunc_size; i++) {

    ret = gen_supplemental(session, &suppfunc[i], buf);

    if (ret < 0)

      return gnutls_assert_val(ret);

  }

  i = buf->length - init_pos - 3;

  buf->data[init_pos] = (i >> 16) & 0xFF;

  buf->data[init_pos + 1] = (i >> 8) & 0xFF;

  buf->data[init_pos + 2] = i & 0xFF;

  _gnutls_debug_log

      ("EXT[%p]: Sending %d bytes of supplemental data\n", session,

       (int)buf->length);

  return buf->length - init_pos;

}

int

_gnutls_parse_supplemental(gnutls_session_t session,

         const uint8_t * data, int datalen)

{

  const uint8_t *p = data;

  size_t dsize = datalen;

  size_t total_size;

  DECR_LEN(dsize, 3);

  total_size = _gnutls_read_uint24(p);

  p += 3;

  if (dsize != total_size) {

    gnutls_assert();

    return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;

  }

  do {

    uint16_t supp_data_type;

    uint16_t supp_data_length;

    gnutls_supp_recv_func recv_func;

    DECR_LEN(dsize, 2);

    supp_data_type = _gnutls_read_uint16(p);

    p += 2;

    DECR_LEN(dsize, 2);

    supp_data_length = _gnutls_read_uint16(p);

    p += 2;

    _gnutls_debug_log

        ("EXT[%p]: Got supplemental type=%02x length=%d\n",

         session, supp_data_type, supp_data_length);

    recv_func = get_supp_func_recv(session, supp_data_type);

    if (recv_func) {

      int ret = recv_func(session, p, supp_data_length);

      if (ret < 0) {

        gnutls_assert();

        return ret;

      }

    } else {

      gnutls_assert();

      return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;

    }

    DECR_LEN(dsize, supp_data_length);

    p += supp_data_length;

  }

  while (dsize > 0);

  return 0;

}

static int _gnutls_supplemental_register(gnutls_supplemental_entry_st * entry)

{

  gnutls_supplemental_entry_st *p;

  unsigned i;

  for (i = 0; i < suppfunc_size; i++) {

    if (entry->type == suppfunc[i].type)

      return gnutls_assert_val(GNUTLS_E_ALREADY_REGISTERED);

  }

  if (unlikely(INT_ADD_OVERFLOW(suppfunc_size, 1))) {

    return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);

  }

  p = _gnutls_reallocarray_fast(suppfunc, suppfunc_size + 1,

              sizeof(*suppfunc));

  if (!p) {

    gnutls_assert();

    return GNUTLS_E_MEMORY_ERROR;

  }

  suppfunc = p;

  memcpy(&suppfunc[suppfunc_size], entry, sizeof(*entry));

  suppfunc_size++;

  return GNUTLS_E_SUCCESS;

}

/**

 * gnutls_supplemental_register:

 * @name: the name of the supplemental data to register

 * @type: the type of the supplemental data format

 * @recv_func: the function to receive the data

 * @send_func: the function to send the data

 *

 * This function will register a new supplemental data type (rfc4680).

 * The registered data will remain until gnutls_global_deinit()

 * is called. The provided @type must be an unassigned type in

 * %gnutls_supplemental_data_format_type_t. If the type is already

 * registered or handled by GnuTLS internally %GNUTLS_E_ALREADY_REGISTERED

 * will be returned.

 *

 * This function is not thread safe. As supplemental data are not defined under

 * TLS 1.3, this function will disable TLS 1.3 support globally.

 *

 * Returns: %GNUTLS_E_SUCCESS on success, otherwise a negative error code.

 *

 * Since: 3.4.0

 **/

int

gnutls_supplemental_register(const char *name,

           gnutls_supplemental_data_format_type_t type,

           gnutls_supp_recv_func recv_func,

           gnutls_supp_send_func send_func)

{

  gnutls_supplemental_entry_st tmp_entry;

  int ret;

  tmp_entry.name = gnutls_strdup(name);

  tmp_entry.type = type;

  tmp_entry.supp_recv_func = recv_func;

  tmp_entry.supp_send_func = send_func;

  ret = _gnutls_supplemental_register(&tmp_entry);

  if (ret < 0) {

    gnutls_free(tmp_entry.name);

  }

  _gnutls_disable_tls13 = 1;

  return ret;

}

/**

 * gnutls_session_supplemental_register:

 * @session: the session for which this will be registered

 * @name: the name of the supplemental data to register

 * @type: the type of the supplemental data format

 * @recv_func: the function to receive the data

 * @send_func: the function to send the data

 * @flags: must be zero

 *

 * This function will register a new supplemental data type (rfc4680).

 * The registered supplemental functions will be used for that specific

 * session. The provided @type must be an unassigned type in

 * %gnutls_supplemental_data_format_type_t.

 *

 * If the type is already registered or handled by GnuTLS internally

 * %GNUTLS_E_ALREADY_REGISTERED will be returned.

 *

 * As supplemental data are not defined under TLS 1.3, this function will

 * disable TLS 1.3 support for the given session.

 *

 * Returns: %GNUTLS_E_SUCCESS on success, otherwise a negative error code.

 *

 * Since: 3.5.5

 **/

int

gnutls_session_supplemental_register(gnutls_session_t session, const char *name,

             gnutls_supplemental_data_format_type_t

             type, gnutls_supp_recv_func recv_func,

             gnutls_supp_send_func send_func,

             unsigned flags)

{

  gnutls_supplemental_entry_st tmp_entry;

  gnutls_supplemental_entry_st *p;

  unsigned i;

  tmp_entry.name = NULL;

  tmp_entry.type = type;

  tmp_entry.supp_recv_func = recv_func;

  tmp_entry.supp_send_func = send_func;

  for (i = 0; i < suppfunc_size; i++) {

    if (type == suppfunc[i].type)

      return gnutls_assert_val(GNUTLS_E_ALREADY_REGISTERED);

  }

  p = gnutls_realloc(session->internals.rsup,

         sizeof(gnutls_supplemental_entry_st) *

         (session->internals.rsup_size + 1));

  if (!p)

    return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);

  session->internals.rsup = p;

  memcpy(&session->internals.rsup[session->internals.rsup_size],

         &tmp_entry, sizeof(tmp_entry));

  session->internals.rsup_size++;

  session->internals.flags |= INT_FLAG_NO_TLS13;

  return GNUTLS_E_SUCCESS;

}

/**

 * gnutls_supplemental_recv:

 * @session: is a #gnutls_session_t type.

 * @do_recv_supplemental: non-zero in order to expect supplemental data

 *

 * This function is to be called by an extension handler to

 * instruct gnutls to attempt to receive supplemental data

 * during the handshake process.

 *

 * Since: 3.4.0

 **/

void

gnutls_supplemental_recv(gnutls_session_t session,

       unsigned do_recv_supplemental)

{

  session->security_parameters.do_recv_supplemental =

      do_recv_supplemental;

}

/**

 * gnutls_supplemental_send:

 * @session: is a #gnutls_session_t type.

 * @do_send_supplemental: non-zero in order to send supplemental data

 *

 * This function is to be called by an extension handler to

 * instruct gnutls to send supplemental data during the handshake process.

 *

 * Since: 3.4.0

 **/

void

gnutls_supplemental_send(gnutls_session_t session,

       unsigned do_send_supplemental)

{

  session->security_parameters.do_send_supplemental =

      do_send_supplemental;

}