/*

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

 * Copyright (C) 2017-2018 Red Hat, Inc.

 *

 * Author: Nikos Mavrogiannopoulos

 *

 * 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 the code for the Max Record Size TLS extension.

 */

#include "gnutls_int.h"

#include "errors.h"

#include "num.h"

#include "hello_ext.h"

#include "ext/supported_versions.h"

#include "handshake.h"

static int supported_versions_recv_params(gnutls_session_t session,

            const uint8_t *data,

            size_t data_size);

static int supported_versions_send_params(gnutls_session_t session,

            gnutls_buffer_st *extdata);

const hello_ext_entry_st ext_mod_supported_versions = {

  .name = "Supported Versions",

  .tls_id = 43,

  .gid = GNUTLS_EXTENSION_SUPPORTED_VERSIONS,

  .validity = GNUTLS_EXT_FLAG_CLIENT_HELLO |

        GNUTLS_EXT_FLAG_TLS12_SERVER_HELLO |

        GNUTLS_EXT_FLAG_TLS13_SERVER_HELLO | GNUTLS_EXT_FLAG_HRR |

        GNUTLS_EXT_FLAG_TLS,

  .client_parse_point =

    GNUTLS_EXT_VERSION_NEG, /* force parsing prior to EXT_TLS extensions */

  .server_parse_point = GNUTLS_EXT_VERSION_NEG,

  .recv_func = supported_versions_recv_params,

  .send_func = supported_versions_send_params,

  .pack_func = NULL,

  .unpack_func = NULL,

  .deinit_func = NULL,

  .cannot_be_overriden = 1

};

static int supported_versions_recv_params(gnutls_session_t session,

            const uint8_t *data, size_t data_size)

{

  const version_entry_st *vers;

  uint8_t major, minor;

  size_t bytes;

  int ret;

  if (session->security_parameters.entity == GNUTLS_SERVER) {

    const version_entry_st *old_vers;

    const version_entry_st *cli_vers = NULL;

    vers = _gnutls_version_max(session);

    old_vers = get_version(session);

    /* do not parse this extension when we haven't TLS1.3

     * enabled. That is because we cannot handle earlier protocol

     * negotiation (such as SSL3.0) with this */

    if (vers && !vers->tls13_sem)

      return 0;

    DECR_LEN(data_size, 1);

    bytes = data[0];

    data++;

    if (bytes % 2 == 1)

      return gnutls_assert_val(

        GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

    DECR_LEN(data_size, bytes);

    if (data_size != 0)

      return gnutls_assert_val(

        GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

    while (bytes > 0) {

      major = data[0];

      minor = data[1];

      data += 2;

      bytes -= 2;

      _gnutls_handshake_log("EXT[%p]: Found version: %d.%d\n",

                session, (int)major, (int)minor);

      if (!_gnutls_nversion_is_supported(session, major,

                 minor))

        continue;

      /* Prefer the latest possible version

       * regardless of the client's precedence.  See

       * https://gitlab.com/gnutls/gnutls/issues/837

       * for the rationale.

       */

      if (!cli_vers || major > cli_vers->major ||

          (major == cli_vers->major &&

           minor > cli_vers->minor))

        cli_vers = nversion_to_entry(major, minor);

    }

    if (!cli_vers)

      return gnutls_assert_val(

        GNUTLS_E_UNSUPPORTED_VERSION_PACKET);

    session->security_parameters.pversion = cli_vers;

    _gnutls_handshake_log("EXT[%p]: Negotiated version: %d.%d\n",

              session, (int)cli_vers->major,

              (int)cli_vers->minor);

    if (old_vers != cli_vers) {

      /* regenerate the random value to set

       * downgrade sentinel if necessary

       */

      ret = _gnutls_gen_server_random(session, cli_vers->id);

      if (ret < 0)

        return gnutls_assert_val(ret);

    }

    return 0;

  } else { /* client */

    if (!have_creds_for_tls13(session)) {

      /* if we don't have certificate or PSK (which work under TLS1.3)

       * don't try to negotiate version using the extension. We fallback

       * instead to the normal TLS negotiation which has a cap on TLS1.2.

       */

      return 0;

    }

    DECR_LEN(data_size, 2);

    if (data_size != 0)

      return gnutls_assert_val(

        GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

    major = data[0];

    minor = data[1];

    vers = nversion_to_entry(major, minor);

    if (!vers)

      return gnutls_assert_val(

        GNUTLS_E_UNSUPPORTED_VERSION_PACKET);

    set_adv_version(session, major, minor);

    _gnutls_handshake_log("EXT[%p]: Negotiated version: %d.%d\n",

              session, (int)major, (int)minor);

    if (!vers->tls13_sem)

      return gnutls_assert_val(

        GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER);

    ret = _gnutls_negotiate_version(session, major, minor, 1);

    if (ret < 0) {

      gnutls_assert();

      return ret;

    }

  }

  return 0;

}

/* returns data_size or a negative number on failure

 */

static int supported_versions_send_params(gnutls_session_t session,

            gnutls_buffer_st *extdata)

{

  uint8_t versions[32];

  size_t versions_size;

  const version_entry_st *vers;

  int ret;

  /* this function sends the client extension data (dnsname) */

  if (session->security_parameters.entity == GNUTLS_CLIENT) {

    vers = _gnutls_version_max(session);

    /* Do not advertise this extension if we are not doing certificate

     * or PSK authentication; i.e., do not try to do TLS1.3 if we have

     * credentials which do not fit it. */

    if (!have_creds_for_tls13(session)) {

      /* if we don't have certificate or PSK (which work under TLS1.3)

       * don't try to negotiate version using the extension. We fallback

       * instead to the normal TLS negotiation which has a cap on TLS1.2.

       */

      return 0;

    }

    /* do not advertise this extension when we haven't TLS1.3

     * enabled. */

    if (vers && !vers->tls13_sem)

      return 0;

    ret = _gnutls_write_supported_versions(session, versions,

                   sizeof(versions));

    if (ret <=

        0) /* if this function doesn't succeed do not send anything */

      return 0;

    versions_size = ret;

    ret = _gnutls_buffer_append_data_prefix(extdata, 8, versions,

              versions_size);

    if (ret < 0)

      return gnutls_assert_val(ret);

    return versions_size + 2;

  } else {

    vers = get_version(session);

    if (unlikely(vers == NULL))

      return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

    /* don't use this extension to negotiate versions <= 1.2,

     * pretend we don't support it, so that we use a single

     * code path to negotiate these protocols. */

    if (!vers->tls13_sem)

      return 0;

    ret = _gnutls_buffer_append_data(extdata, &vers->major, 1);

    if (ret < 0)

      return gnutls_assert_val(ret);

    ret = _gnutls_buffer_append_data(extdata, &vers->minor, 1);

    if (ret < 0)

      return gnutls_assert_val(ret);

    return 2;

  }

  return 0;

}