/*

 * Copyright (C) 2000-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 "errors.h"

#include <record.h>

#include <debug.h>

#include "str.h"

#include <system/ktls.h>

typedef struct {

  gnutls_alert_description_t alert;

  const char *name;

  const char *desc;

} gnutls_alert_entry;

#define ALERT_ENTRY(x,y) \

  {x, #x, y}

static const gnutls_alert_entry sup_alerts[] = {

  ALERT_ENTRY(GNUTLS_A_CLOSE_NOTIFY, N_("Close notify")),

  ALERT_ENTRY(GNUTLS_A_UNEXPECTED_MESSAGE, N_("Unexpected message")),

  ALERT_ENTRY(GNUTLS_A_BAD_RECORD_MAC, N_("Bad record MAC")),

  ALERT_ENTRY(GNUTLS_A_DECRYPTION_FAILED, N_("Decryption failed")),

  ALERT_ENTRY(GNUTLS_A_RECORD_OVERFLOW, N_("Record overflow")),

  ALERT_ENTRY(GNUTLS_A_DECOMPRESSION_FAILURE,

        N_("Decompression failed")),

  ALERT_ENTRY(GNUTLS_A_HANDSHAKE_FAILURE, N_("Handshake failed")),

  ALERT_ENTRY(GNUTLS_A_BAD_CERTIFICATE, N_("Certificate is bad")),

  ALERT_ENTRY(GNUTLS_A_UNSUPPORTED_CERTIFICATE,

        N_("Certificate is not supported")),

  ALERT_ENTRY(GNUTLS_A_CERTIFICATE_REVOKED,

        N_("Certificate was revoked")),

  ALERT_ENTRY(GNUTLS_A_CERTIFICATE_EXPIRED,

        N_("Certificate is expired")),

  ALERT_ENTRY(GNUTLS_A_CERTIFICATE_UNKNOWN,

        N_("Unknown certificate")),

  ALERT_ENTRY(GNUTLS_A_ILLEGAL_PARAMETER, N_("Illegal parameter")),

  ALERT_ENTRY(GNUTLS_A_UNKNOWN_CA, N_("CA is unknown")),

  ALERT_ENTRY(GNUTLS_A_ACCESS_DENIED, N_("Access was denied")),

  ALERT_ENTRY(GNUTLS_A_DECODE_ERROR, N_("Decode error")),

  ALERT_ENTRY(GNUTLS_A_DECRYPT_ERROR, N_("Decrypt error")),

  ALERT_ENTRY(GNUTLS_A_EXPORT_RESTRICTION, N_("Export restriction")),

  ALERT_ENTRY(GNUTLS_A_PROTOCOL_VERSION,

        N_("Error in protocol version")),

  ALERT_ENTRY(GNUTLS_A_INSUFFICIENT_SECURITY,

        N_("Insufficient security")),

  ALERT_ENTRY(GNUTLS_A_USER_CANCELED, N_("User canceled")),

  ALERT_ENTRY(GNUTLS_A_SSL3_NO_CERTIFICATE,

        N_("No certificate (SSL 3.0)")),

  ALERT_ENTRY(GNUTLS_A_INTERNAL_ERROR, N_("Internal error")),

  ALERT_ENTRY(GNUTLS_A_INAPPROPRIATE_FALLBACK,

        N_("Inappropriate fallback")),

  ALERT_ENTRY(GNUTLS_A_NO_RENEGOTIATION,

        N_("No renegotiation is allowed")),

  ALERT_ENTRY(GNUTLS_A_CERTIFICATE_UNOBTAINABLE,

        N_("Could not retrieve the specified certificate")),

  ALERT_ENTRY(GNUTLS_A_UNSUPPORTED_EXTENSION,

        N_("An unsupported extension was sent")),

  ALERT_ENTRY(GNUTLS_A_UNRECOGNIZED_NAME,

        N_("The server name sent was not recognized")),

  ALERT_ENTRY(GNUTLS_A_UNKNOWN_PSK_IDENTITY,

        N_("The SRP/PSK username is missing or not known")),

  ALERT_ENTRY(GNUTLS_A_MISSING_EXTENSION,

        N_("An extension was expected but was not seen")),

  ALERT_ENTRY(GNUTLS_A_NO_APPLICATION_PROTOCOL,

        N_

        ("No supported application protocol could be negotiated")),

  ALERT_ENTRY(GNUTLS_A_CERTIFICATE_REQUIRED,

        N_("Certificate is required")),

  {0, NULL, NULL}

};

/**

 * gnutls_alert_get_name:

 * @alert: is an alert number.

 *

 * This function will return a string that describes the given alert

 * number, or %NULL.  See gnutls_alert_get().

 *

 * Returns: string corresponding to #gnutls_alert_description_t value.

 **/

const char *gnutls_alert_get_name(gnutls_alert_description_t alert)

{

  const gnutls_alert_entry *p;

  for (p = sup_alerts; p->desc != NULL; p++)

    if (p->alert == alert)

      return _(p->desc);

  return NULL;

}

/**

 * gnutls_alert_get_strname:

 * @alert: is an alert number.

 *

 * This function will return a string of the name of the alert.

 *

 * Returns: string corresponding to #gnutls_alert_description_t value.

 *

 * Since: 3.0

 **/

const char *gnutls_alert_get_strname(gnutls_alert_description_t alert)

{

  const gnutls_alert_entry *p;

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

    if (p->alert == alert)

      return p->name;

  return NULL;

}

/**

 * gnutls_alert_send:

 * @session: is a #gnutls_session_t type.

 * @level: is the level of the alert

 * @desc: is the alert description

 *

 * This function will send an alert to the peer in order to inform

 * him of something important (eg. his Certificate could not be verified).

 * If the alert level is Fatal then the peer is expected to close the

 * connection, otherwise he may ignore the alert and continue.

 *

 * The error code of the underlying record send function will be

 * returned, so you may also receive %GNUTLS_E_INTERRUPTED or

 * %GNUTLS_E_AGAIN as well.

 *

 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise

 *   an error code is returned.

 **/

int

gnutls_alert_send(gnutls_session_t session, gnutls_alert_level_t level,

      gnutls_alert_description_t desc)

{

  uint8_t data[2];

  int ret;

  const char *name;

  data[0] = (uint8_t) level;

  data[1] = (uint8_t) desc;

  name = gnutls_alert_get_name((gnutls_alert_description_t) data[1]);

  if (name == NULL)

    name = "(unknown)";

  _gnutls_record_log("REC: Sending Alert[%d|%d] - %s\n", data[0],

         data[1], name);

  if (session->internals.alert_read_func) {

    record_parameters_st *params;

    ret = _gnutls_epoch_get(session, EPOCH_WRITE_CURRENT, &params);

    if (ret < 0)

      return gnutls_assert_val(ret);

    ret = session->internals.alert_read_func(session,

               params->write.level,

               level, desc);

    if (ret < 0)

      return gnutls_assert_val(ret);

    return ret;

  }

  ret = _gnutls_send_int(session, GNUTLS_ALERT, -1,

             EPOCH_WRITE_CURRENT, data, 2, MBUFFER_FLUSH);

  return (ret < 0) ? ret : 0;

}

/**

 * gnutls_error_to_alert:

 * @err: is a negative integer

 * @level: the alert level will be stored there

 *

 * Get an alert depending on the error code returned by a gnutls

 * function.  All alerts sent by this function should be considered

 * fatal.  The only exception is when @err is %GNUTLS_E_REHANDSHAKE,

 * where a warning alert should be sent to the peer indicating that no

 * renegotiation will be performed.

 *

 * If there is no mapping to a valid alert the alert to indicate

 * internal error (%GNUTLS_A_INTERNAL_ERROR) is returned.

 *

 * Returns: the alert code to use for a particular error code.

 **/

int gnutls_error_to_alert(int err, int *level)

{

  int ret, _level = -1;

  switch (err) {    /* send appropriate alert */

  case GNUTLS_E_PK_SIG_VERIFY_FAILED:

  case GNUTLS_E_ERROR_IN_FINISHED_PACKET:

    ret = GNUTLS_A_DECRYPT_ERROR;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_DECRYPTION_FAILED:

    /* GNUTLS_A_DECRYPTION_FAILED is not sent, because

     * it is not defined in SSL3. Note that we must

     * not distinguish Decryption failures from mac

     * check failures, due to the possibility of some

     * attacks.

     */

    ret = GNUTLS_A_BAD_RECORD_MAC;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_UNEXPECTED_PACKET_LENGTH:

  case GNUTLS_E_UNEXPECTED_EXTENSIONS_LENGTH:

  case GNUTLS_E_NO_CERTIFICATE_FOUND:

  case GNUTLS_E_HANDSHAKE_TOO_LARGE:

    ret = GNUTLS_A_DECODE_ERROR;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_DECOMPRESSION_FAILED:

    ret = GNUTLS_A_DECOMPRESSION_FAILURE;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_ILLEGAL_PARAMETER:

  case GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER:

  case GNUTLS_E_ILLEGAL_SRP_USERNAME:

  case GNUTLS_E_PK_INVALID_PUBKEY:

  case GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM:

  case GNUTLS_E_RECEIVED_DISALLOWED_NAME:

  case GNUTLS_E_INCOMPATIBLE_SIG_WITH_KEY:

    ret = GNUTLS_A_ILLEGAL_PARAMETER;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_UNKNOWN_SRP_USERNAME:

    ret = GNUTLS_A_UNKNOWN_PSK_IDENTITY;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_ASN1_ELEMENT_NOT_FOUND:

  case GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND:

  case GNUTLS_E_ASN1_DER_ERROR:

  case GNUTLS_E_ASN1_VALUE_NOT_FOUND:

  case GNUTLS_E_ASN1_GENERIC_ERROR:

  case GNUTLS_E_ASN1_VALUE_NOT_VALID:

  case GNUTLS_E_ASN1_TAG_ERROR:

  case GNUTLS_E_ASN1_TAG_IMPLICIT:

  case GNUTLS_E_ASN1_TYPE_ANY_ERROR:

  case GNUTLS_E_ASN1_SYNTAX_ERROR:

  case GNUTLS_E_ASN1_DER_OVERFLOW:

  case GNUTLS_E_CERTIFICATE_ERROR:

  case GNUTLS_E_CERTIFICATE_VERIFICATION_ERROR:

    ret = GNUTLS_A_BAD_CERTIFICATE;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_UNKNOWN_CIPHER_SUITE:

  case GNUTLS_E_INSUFFICIENT_CREDENTIALS:

  case GNUTLS_E_NO_CIPHER_SUITES:

  case GNUTLS_E_NO_COMPRESSION_ALGORITHMS:

  case GNUTLS_E_UNSUPPORTED_SIGNATURE_ALGORITHM:

  case GNUTLS_E_SAFE_RENEGOTIATION_FAILED:

  case GNUTLS_E_INCOMPAT_DSA_KEY_WITH_TLS_PROTOCOL:

  case GNUTLS_E_UNKNOWN_PK_ALGORITHM:

  case GNUTLS_E_UNWANTED_ALGORITHM:

  case GNUTLS_E_NO_COMMON_KEY_SHARE:

  case GNUTLS_E_ECC_NO_SUPPORTED_CURVES:

  case GNUTLS_E_ECC_UNSUPPORTED_CURVE:

    ret = GNUTLS_A_HANDSHAKE_FAILURE;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION:

    ret = GNUTLS_A_UNSUPPORTED_EXTENSION;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_MISSING_EXTENSION:

    ret = GNUTLS_A_MISSING_EXTENSION;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_USER_ERROR:

    ret = GNUTLS_A_USER_CANCELED;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_UNEXPECTED_PACKET:

  case GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET:

  case GNUTLS_E_PREMATURE_TERMINATION:

    ret = GNUTLS_A_UNEXPECTED_MESSAGE;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_REHANDSHAKE:

  case GNUTLS_E_UNSAFE_RENEGOTIATION_DENIED:

    ret = GNUTLS_A_NO_RENEGOTIATION;

    _level = GNUTLS_AL_WARNING;

    break;

  case GNUTLS_E_UNSUPPORTED_VERSION_PACKET:

    ret = GNUTLS_A_PROTOCOL_VERSION;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE:

    ret = GNUTLS_A_UNSUPPORTED_CERTIFICATE;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_RECORD_OVERFLOW:

    ret = GNUTLS_A_RECORD_OVERFLOW;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_INTERNAL_ERROR:

  case GNUTLS_E_NO_TEMPORARY_DH_PARAMS:

  case GNUTLS_E_NO_TEMPORARY_RSA_PARAMS:

    ret = GNUTLS_A_INTERNAL_ERROR;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_INAPPROPRIATE_FALLBACK:

    ret = GNUTLS_A_INAPPROPRIATE_FALLBACK;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_OPENPGP_GETKEY_FAILED:

    ret = GNUTLS_A_CERTIFICATE_UNOBTAINABLE;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_DH_PRIME_UNACCEPTABLE:

  case GNUTLS_E_SESSION_USER_ID_CHANGED:

  case GNUTLS_E_INSUFFICIENT_SECURITY:

    ret = GNUTLS_A_INSUFFICIENT_SECURITY;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_NO_APPLICATION_PROTOCOL:

    ret = GNUTLS_A_NO_APPLICATION_PROTOCOL;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_UNRECOGNIZED_NAME:

    ret = GNUTLS_A_UNRECOGNIZED_NAME;

    _level = GNUTLS_AL_FATAL;

    break;

  case GNUTLS_E_CERTIFICATE_REQUIRED:

    ret = GNUTLS_A_CERTIFICATE_REQUIRED;

    _level = GNUTLS_AL_FATAL;

    break;

  default:

    ret = GNUTLS_A_INTERNAL_ERROR;

    _level = GNUTLS_AL_FATAL;

    break;

  }

  if (level != NULL)

    *level = _level;

  return ret;

}

/**

 * gnutls_alert_send_appropriate:

 * @session: is a #gnutls_session_t type.

 * @err: is an error code returned by another GnuTLS function

 *

 * Sends an alert to the peer depending on the error code returned by

 * a gnutls function. This function will call gnutls_error_to_alert()

 * to determine the appropriate alert to send.

 *

 * This function may also return %GNUTLS_E_AGAIN, or

 * %GNUTLS_E_INTERRUPTED.

 *

 * This function historically was always sending an alert to the

 * peer, even if @err was inappropriate to respond with an alert

 * (e.g., %GNUTLS_E_SUCCESS). Since 3.6.6 this function returns

 * success without transmitting any data on error codes that

 * should not result to an alert.

 *

 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise

 *   an error code is returned.

 */

int gnutls_alert_send_appropriate(gnutls_session_t session, int err)

{

  int alert;

  int level;

  if (err != GNUTLS_E_REHANDSHAKE && (!gnutls_error_is_fatal(err) ||

              err ==

              GNUTLS_E_FATAL_ALERT_RECEIVED))

    return gnutls_assert_val(0);

  alert = gnutls_error_to_alert(err, &level);

  return gnutls_alert_send(session, (gnutls_alert_level_t) level, alert);

}

/**

 * gnutls_alert_get:

 * @session: is a #gnutls_session_t type.

 *

 * This function will return the last alert number received.  This

 * function should be called when %GNUTLS_E_WARNING_ALERT_RECEIVED or

 * %GNUTLS_E_FATAL_ALERT_RECEIVED errors are returned by a gnutls

 * function.  The peer may send alerts if he encounters an error.

 * If no alert has been received the returned value is undefined.

 *

 * Returns: the last alert received, a

 *   #gnutls_alert_description_t value.

 **/

gnutls_alert_description_t gnutls_alert_get(gnutls_session_t session)

{

  return (gnutls_alert_description_t) session->internals.last_alert;

}