/*

 * Copyright (C) 2011-2012 Free Software Foundation, 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/>

 *

 */

#include "gnutls_int.h"

#include <algorithms.h>

#include "errors.h"

#include <x509/common.h>

#include "c-strcase.h"

/* TLS Versions */

static SYSTEM_CONFIG_OR_CONST version_entry_st sup_versions[] = {

  {.name = "SSL3.0",

   .id = GNUTLS_SSL3,

   .age = 0,

   .major = 3,

   .minor = 0,

   .transport = GNUTLS_STREAM,

#ifdef ENABLE_SSL3

   .supported = 1,

#endif

   .explicit_iv = 0,

   .extensions = 0,

   .selectable_sighash = 0,

   .selectable_prf = 0,

   .obsolete = 1,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 0},

  {.name = "TLS1.0",

   .id = GNUTLS_TLS1,

   .age = 1,

   .major = 3,

   .minor = 1,

   .transport = GNUTLS_STREAM,

   .supported = 1,

   .explicit_iv = 0,

   .extensions = 1,

   .selectable_sighash = 0,

   .selectable_prf = 0,

   .obsolete = 0,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 0},

  {.name = "TLS1.1",

   .id = GNUTLS_TLS1_1,

   .age = 2,

   .major = 3,

   .minor = 2,

   .transport = GNUTLS_STREAM,

   .supported = 1,

   .explicit_iv = 1,

   .extensions = 1,

   .selectable_sighash = 0,

   .selectable_prf = 0,

   .obsolete = 0,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 0},

  {.name = "TLS1.2",

   .id = GNUTLS_TLS1_2,

   .age = 3,

   .major = 3,

   .minor = 3,

   .transport = GNUTLS_STREAM,

   .supported = 1,

   .explicit_iv = 1,

   .extensions = 1,

   .selectable_sighash = 1,

   .selectable_prf = 1,

   .obsolete = 0,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 1},

  {.name = "TLS1.3",

   .id = GNUTLS_TLS1_3,

   .age = 5,

   .major = 3,

   .minor = 4,

   .transport = GNUTLS_STREAM,

   .supported = 1,

   .explicit_iv = 0,

   .extensions = 1,

   .selectable_sighash = 1,

   .selectable_prf = 1,

   .tls13_sem = 1,

   .obsolete = 0,

   .only_extension = 1,

   .post_handshake_auth = 1,

   .multi_ocsp = 1,

   .key_shares = 1,

   .false_start = 0,  /* doesn't make sense */

   .tls_sig_sem = SIG_SEM_TLS13},

  {.name = "DTLS0.9", /* Cisco AnyConnect (based on about OpenSSL 0.9.8e) */

   .id = GNUTLS_DTLS0_9,

   .age = 200,

   .major = 1,

   .minor = 0,

   .transport = GNUTLS_DGRAM,

   .supported = 1,

   .explicit_iv = 1,

   .extensions = 1,

   .selectable_sighash = 0,

   .selectable_prf = 0,

   .obsolete = 0,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 0},

  {.name = "DTLS1.0",

   .id = GNUTLS_DTLS1_0,

   .age = 201,

   .major = 254,

   .minor = 255,

   .transport = GNUTLS_DGRAM,

   .supported = 1,

   .explicit_iv = 1,

   .extensions = 1,

   .selectable_sighash = 0,

   .selectable_prf = 0,

   .obsolete = 0,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 0},

  {.name = "DTLS1.2",

   .id = GNUTLS_DTLS1_2,

   .age = 202,

   .major = 254,

   .minor = 253,

   .transport = GNUTLS_DGRAM,

   .supported = 1,

   .explicit_iv = 1,

   .extensions = 1,

   .selectable_sighash = 1,

   .selectable_prf = 1,

   .obsolete = 0,

   .only_extension = 0,

   .tls_sig_sem = SIG_SEM_PRE_TLS12,

   .false_start = 1},

  {0, 0, 0, 0, 0}

};

const version_entry_st *version_to_entry(gnutls_protocol_t version)

{

  const version_entry_st *p;

  for (p = sup_versions; p->name != NULL; p++)

    if (p->id == version)

      return p;

  return NULL;

}

const version_entry_st *nversion_to_entry(uint8_t major, uint8_t minor)

{

  const version_entry_st *p;

  for (p = sup_versions; p->name != NULL; p++) {

    if ((p->major == major) && (p->minor == minor))

      return p;

  }

  return NULL;

}

static int

version_is_valid_for_session(gnutls_session_t session,

           const version_entry_st * v)

{

  if (!v->supported

      && !(v->supported_revertible && _gnutls_allowlisting_mode()))

    return 0;

  if (v->transport != session->internals.transport)

    return 0;

  return 1;

}

/* This is only called by cfg_apply in priority.c, in blocklisting mode. */

int _gnutls_version_mark_disabled(gnutls_protocol_t version)

{

#ifndef DISABLE_SYSTEM_CONFIG

  version_entry_st *p;

  for (p = sup_versions; p->name != NULL; p++)

    if (p->id == version) {

      p->supported = false;

      return 0;

    }

#endif

  return GNUTLS_E_INVALID_REQUEST;

}

/* This is only called by cfg_apply in priority.c, in allowlisting mode. */

void _gnutls_version_mark_disabled_all(void)

{

#ifndef DISABLE_SYSTEM_CONFIG

  version_entry_st *p;

  for (p = sup_versions; p->name != NULL; p++) {

    p->supported = false;

    p->supported_revertible = true;

  }

#endif

}

int

_gnutls_protocol_set_enabled(gnutls_protocol_t version, unsigned int enabled)

{

#ifndef DISABLE_SYSTEM_CONFIG

  version_entry_st *p;

  for (p = sup_versions; p->name != NULL; p++)

    if (p->id == version) {

      if (!p->supported_revertible) {

        return

            gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

      }

      p->supported = enabled;

      return 0;

    }

#endif

  return GNUTLS_E_INVALID_REQUEST;

}

/* Return the priority of the provided version number */

int

_gnutls_version_priority(gnutls_session_t session, gnutls_protocol_t version)

{

  unsigned int i;

  for (i = 0; i < session->internals.priorities->protocol.num_priorities;

       i++) {

    if (session->internals.priorities->protocol.priorities[i] ==

        version)

      return i;

  }

  return -1;

}

/* Returns the lowest TLS version number in the priorities.

 */

const version_entry_st *_gnutls_version_lowest(gnutls_session_t session)

{

  unsigned int i;

  gnutls_protocol_t cur_prot;

  const version_entry_st *v, *min_v = NULL;

  const version_entry_st *backup = NULL;

  for (i = 0; i < session->internals.priorities->protocol.num_priorities;

       i++) {

    cur_prot =

        session->internals.priorities->protocol.priorities[i];

    v = version_to_entry(cur_prot);

    if (v != NULL && version_is_valid_for_session(session, v)) {

      if (min_v == NULL) {

        if (v->obsolete != 0)

          backup = v;

        else

          min_v = v;

      } else if (v->obsolete == 0 && v->age < min_v->age) {

        min_v = v;

      }

    }

  }

  if (min_v == NULL)

    return backup;

  return min_v;

}

/* Returns the maximum version in the priorities

 */

const version_entry_st *_gnutls_version_max(gnutls_session_t session)

{

  unsigned int i;

  gnutls_protocol_t cur_prot;

  const version_entry_st *p, *max = NULL;

  if (!session->internals.priorities) {

    gnutls_assert();

    return NULL;

  }

  for (i = 0; i < session->internals.priorities->protocol.num_priorities;

       i++) {

    cur_prot =

        session->internals.priorities->protocol.priorities[i];

    for (p = sup_versions; p->name != NULL; p++) {

      if (p->id == cur_prot) {

#ifndef ENABLE_SSL3

        if (p->obsolete != 0)

          break;

#endif

        if (!p->supported

            && !(p->supported_revertible

           && _gnutls_allowlisting_mode()))

          break;

        if (p->transport !=

            session->internals.transport)

          break;

        if (p->tls13_sem

            && (session->

          internals.flags & INT_FLAG_NO_TLS13))

          break;

        if (max == NULL || cur_prot > max->id) {

          max = p;

        }

        break;

      }

    }

  }

  return max;

}

const version_entry_st *_gnutls_legacy_version_max(gnutls_session_t session)

{

  const version_entry_st *max = _gnutls_version_max(session);

  if (max && max->only_extension != 0) {

    /* TLS 1.3 or later found */

    if (max->transport == GNUTLS_STREAM) {

      return version_to_entry(GNUTLS_TLS1_2);

    } else {

      return version_to_entry(GNUTLS_DTLS1_2);

    }

  }

  return max;

}

/* Returns the number of bytes written to buffer or a negative

 * error code. It will return GNUTLS_E_UNSUPPORTED_VERSION_PACKET

 * if there is no version >= TLS 1.3.

 */

int _gnutls_write_supported_versions(gnutls_session_t session, uint8_t * buffer,

             ssize_t buffer_size)

{

  gnutls_protocol_t cur_prot;

  size_t written_bytes = 0;

  unsigned at_least_one_new = 0;

  unsigned i;

  const version_entry_st *p;

  for (i = 0; i < session->internals.priorities->protocol.num_priorities;

       i++) {

    cur_prot =

        session->internals.priorities->protocol.priorities[i];

    for (p = sup_versions; p->name != NULL; p++) {

      if (p->id == cur_prot) {

        if (p->obsolete != 0)

          break;

        if (!p->supported

            && !(p->supported_revertible

           && _gnutls_allowlisting_mode()))

          break;

        if (p->transport !=

            session->internals.transport)

          break;

        if (p->only_extension)

          at_least_one_new = 1;

        if (buffer_size > 2) {

          _gnutls_debug_log

              ("Advertizing version %d.%d\n",

               (int)p->major, (int)p->minor);

          buffer[0] = p->major;

          buffer[1] = p->minor;

          written_bytes += 2;

          buffer += 2;

        }

        buffer_size -= 2;

        if (buffer_size <= 0)

          goto finish;

        break;

      }

    }

  }

 finish:

  if (written_bytes == 0)

    return gnutls_assert_val(GNUTLS_E_NO_PRIORITIES_WERE_SET);

  if (at_least_one_new == 0)

    return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;

  return written_bytes;

}

/* Returns true (1) if the given version is higher than the highest supported

 * and (0) otherwise */

unsigned _gnutls_version_is_too_high(gnutls_session_t session, uint8_t major,

             uint8_t minor)

{

  const version_entry_st *e;

  e = _gnutls_legacy_version_max(session);

  if (e == NULL)   /* we don't know; but that means something is unconfigured */

    return 1;

  if (e->transport == GNUTLS_DGRAM) {

    if (major < e->major)

      return 1;

    if (e->major == major && minor < e->minor)

      return 1;

  } else {

    if (major > e->major)

      return 1;

    if (e->major == major && minor > e->minor)

      return 1;

  }

  return 0;

}

/**

 * gnutls_protocol_get_name:

 * @version: is a (gnutls) version number

 *

 * Convert a #gnutls_protocol_t value to a string.

 *

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

 *   version (e.g., "TLS1.0"), or %NULL.

 **/

const char *gnutls_protocol_get_name(gnutls_protocol_t version)

{

  const version_entry_st *p;

  /* avoid prefix */

  for (p = sup_versions; p->name != NULL; p++)

    if (p->id == version)

      return p->name;

  return NULL;

}

/**

 * gnutls_protocol_get_id:

 * @name: is a protocol name

 *

 * The names are compared in a case insensitive way.

 *

 * Returns: an id of the specified protocol, or

 * %GNUTLS_VERSION_UNKNOWN on error.

 **/

gnutls_protocol_t gnutls_protocol_get_id(const char *name)

{

  const version_entry_st *p;

  gnutls_protocol_t ret = GNUTLS_VERSION_UNKNOWN;

  for (p = sup_versions; p->name != NULL; p++) {

    if (c_strcasecmp(p->name, name) == 0) {

      ret = p->id;

      break;

    }

  }

  return ret;

}

/**

 * gnutls_protocol_list:

 *

 * Get a list of supported protocols, e.g. SSL 3.0, TLS 1.0 etc.

 *

 * This function is not thread safe.

 *

 * Returns: a (0)-terminated list of #gnutls_protocol_t integers

 * indicating the available protocols.

 *

 **/

const gnutls_protocol_t *gnutls_protocol_list(void)

{

  const version_entry_st *p;

  static gnutls_protocol_t supported_protocols[MAX_ALGOS] = { 0 };

  if (supported_protocols[0] == 0) {

    int i = 0;

    for (p = sup_versions; p->name != NULL; p++) {

      if (!p->supported)

        continue;

      supported_protocols[i++] = p->id;

    }

    supported_protocols[i++] = 0;

  }

  return supported_protocols;

}

/* Return all versions, including non-supported ones.

 */

const gnutls_protocol_t *_gnutls_protocol_list(void)

{

  const version_entry_st *p;

  static gnutls_protocol_t protocols[MAX_ALGOS] = { 0 };

  if (protocols[0] == 0) {

    int i = 0;

    for (p = sup_versions; p->name != NULL; p++) {

      protocols[i++] = p->id;

    }

    protocols[i++] = 0;

  }

  return protocols;

}

/* Returns a version number given the major and minor numbers.

 */

gnutls_protocol_t _gnutls_version_get(uint8_t major, uint8_t minor)

{

  const version_entry_st *p;

  int ret = GNUTLS_VERSION_UNKNOWN;

  for (p = sup_versions; p->name != NULL; p++)

    if ((p->major == major) && (p->minor == minor))

      ret = p->id;

  return ret;

}

/* Version Functions */

int

_gnutls_nversion_is_supported(gnutls_session_t session,

            unsigned char major, unsigned char minor)

{

  const version_entry_st *p;

  int version = 0;

  for (p = sup_versions; p->name != NULL; p++) {

    if (p->major == major && p->minor == minor) {

#ifndef ENABLE_SSL3

      if (p->obsolete != 0)

        return 0;

#endif

      if (p->tls13_sem

          && (session->internals.flags & INT_FLAG_NO_TLS13))

        return 0;

      if (!p->supported

          && !(p->supported_revertible

         && _gnutls_allowlisting_mode()))

        return 0;

      if (p->transport != session->internals.transport)

        return 0;

      version = p->id;

      break;

    }

  }

  if (version == 0)

    return 0;

  if (_gnutls_version_priority(session, version) < 0)

    return 0; /* disabled by the user */

  else

    return 1;

}