/*

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

 * Copyright (C) 2017 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/>

 *

 */

#include "gnutls_int.h"

#include <algorithms.h>

#include "errors.h"

#include <x509/common.h>

#include "c-strcase.h"

#define MAC_OID_SHA1 "1.2.840.113549.2.7"

#define MAC_OID_SHA224 "1.2.840.113549.2.8"

#define MAC_OID_SHA256 "1.2.840.113549.2.9"

#define MAC_OID_SHA384 "1.2.840.113549.2.10"

#define MAC_OID_SHA512 "1.2.840.113549.2.11"

#define MAC_OID_GOST_R_3411_94 "1.2.643.2.2.10"

#define MAC_OID_STREEBOG_256 "1.2.643.7.1.1.4.1"

#define MAC_OID_STREEBOG_512 "1.2.643.7.1.1.4.2"

static SYSTEM_CONFIG_OR_CONST mac_entry_st hash_algorithms[] = {

  {.name = "SHA1",

   .oid = HASH_OID_SHA1,

   .mac_oid = MAC_OID_SHA1,

   .id = GNUTLS_MAC_SHA1,

   .output_size = 20,

   .key_size = 20,

   .block_size = 64},

  {.name = "MD5+SHA1",

   .id = GNUTLS_MAC_MD5_SHA1,

   .output_size = 36,

   .key_size = 36,

   .flags = GNUTLS_MAC_FLAG_PREIMAGE_INSECURE,

   .block_size = 64},

  {.name = "SHA256",

   .oid = HASH_OID_SHA256,

   .mac_oid = MAC_OID_SHA256,

   .id = GNUTLS_MAC_SHA256,

   .output_size = 32,

   .key_size = 32,

   .block_size = 64},

  {.name = "SHA384",

   .oid = HASH_OID_SHA384,

   .mac_oid = MAC_OID_SHA384,

   .id = GNUTLS_MAC_SHA384,

   .output_size = 48,

   .key_size = 48,

   .block_size = 128},

  {.name = "SHA512",

   .oid = HASH_OID_SHA512,

   .mac_oid = MAC_OID_SHA512,

   .id = GNUTLS_MAC_SHA512,

   .output_size = 64,

   .key_size = 64,

   .block_size = 128},

  {.name = "SHA224",

   .oid = HASH_OID_SHA224,

   .mac_oid = MAC_OID_SHA224,

   .id = GNUTLS_MAC_SHA224,

   .output_size = 28,

   .key_size = 28,

   .block_size = 64},

  {.name = "SHA3-256",

   .oid = HASH_OID_SHA3_256,

   .id = GNUTLS_MAC_SHA3_256,

   .output_size = 32,

   .key_size = 32,

   .block_size = 136},

  {.name = "SHA3-384",

   .oid = HASH_OID_SHA3_384,

   .id = GNUTLS_MAC_SHA3_384,

   .output_size = 48,

   .key_size = 48,

   .block_size = 104},

  {.name = "SHA3-512",

   .oid = HASH_OID_SHA3_512,

   .id = GNUTLS_MAC_SHA3_512,

   .output_size = 64,

   .key_size = 64,

   .block_size = 72},

  {.name = "SHA3-224",

   .oid = HASH_OID_SHA3_224,

   .id = GNUTLS_MAC_SHA3_224,

   .output_size = 28,

   .key_size = 28,

   .block_size = 144},

  {.name = "UMAC-96",

   .id = GNUTLS_MAC_UMAC_96,

   .output_size = 12,

   .key_size = 16,

   .nonce_size = 8},

  {.name = "UMAC-128",

   .id = GNUTLS_MAC_UMAC_128,

   .output_size = 16,

   .key_size = 16,

   .nonce_size = 8},

  {.name = "AEAD",

   .id = GNUTLS_MAC_AEAD,

   .placeholder = 1},

  {.name = "MD5",

   .oid = HASH_OID_MD5,

   .id = GNUTLS_MAC_MD5,

   .output_size = 16,

   .key_size = 16,

   .flags = GNUTLS_MAC_FLAG_PREIMAGE_INSECURE,

   .block_size = 64},

  {.name = "MD2",

   .oid = HASH_OID_MD2,

   .flags = GNUTLS_MAC_FLAG_PREIMAGE_INSECURE,

   .id = GNUTLS_MAC_MD2},

  {.name = "RIPEMD160",

   .oid = HASH_OID_RMD160,

   .id = GNUTLS_MAC_RMD160,

   .output_size = 20,

   .key_size = 20,

   .block_size = 64},

  {.name = "GOSTR341194",

   .oid = HASH_OID_GOST_R_3411_94,

   .mac_oid = MAC_OID_GOST_R_3411_94,

   .id = GNUTLS_MAC_GOSTR_94,

   .output_size = 32,

   .key_size = 32,

   .block_size = 32,

   .flags = GNUTLS_MAC_FLAG_PREIMAGE_INSECURE},

  {.name = "STREEBOG-256",

   .oid = HASH_OID_STREEBOG_256,

   .mac_oid = MAC_OID_STREEBOG_256,

   .id = GNUTLS_MAC_STREEBOG_256,

   .output_size = 32,

   .key_size = 32,

   .block_size = 64},

  {.name = "STREEBOG-512",

   .oid = HASH_OID_STREEBOG_512,

   .mac_oid = MAC_OID_STREEBOG_512,

   .id = GNUTLS_MAC_STREEBOG_512,

   .output_size = 64,

   .key_size = 64,

   .block_size = 64},

  {.name = "AES-CMAC-128",

   .id = GNUTLS_MAC_AES_CMAC_128,

   .output_size = 16,

   .key_size = 16,},

  {.name = "AES-CMAC-256",

   .id = GNUTLS_MAC_AES_CMAC_256,

   .output_size = 16,

   .key_size = 32},

  {.name = "AES-GMAC-128",

   .id = GNUTLS_MAC_AES_GMAC_128,

   .output_size = 16,

   .key_size = 16,

   .nonce_size = 12},

  {.name = "AES-GMAC-192",

   .id = GNUTLS_MAC_AES_GMAC_192,

   .output_size = 16,

   .key_size = 24,

   .nonce_size = 12},

  {.name = "AES-GMAC-256",

   .id = GNUTLS_MAC_AES_GMAC_256,

   .output_size = 16,

   .key_size = 32,

   .nonce_size = 12},

  {.name = "GOST28147-TC26Z-IMIT",

   .id = GNUTLS_MAC_GOST28147_TC26Z_IMIT,

   .output_size = 4,

   .key_size = 32,

   .block_size = 8,

   .flags = GNUTLS_MAC_FLAG_CONTINUOUS_MAC},

  {.name = "SHAKE-128",

   .oid = HASH_OID_SHAKE_128,

   .id = GNUTLS_MAC_SHAKE_128,

   .block_size = 168},

  {.name = "SHAKE-256",

   .oid = HASH_OID_SHAKE_256,

   .id = GNUTLS_MAC_SHAKE_256,

   .block_size = 136},

  {.name = "OMAC-MAGMA",

   .id = GNUTLS_MAC_MAGMA_OMAC,

   .output_size = 8,

   .key_size = 32,

   .block_size = 8},

  {.name = "OMAC-KUZNYECHIK",

   .id = GNUTLS_MAC_KUZNYECHIK_OMAC,

   .output_size = 16,

   .key_size = 32,

   .block_size = 16},

  {.name = "MAC-NULL",

   .id = GNUTLS_MAC_NULL},

  {0, 0, 0, 0, 0, 0, 0, 0, 0}

};

#define GNUTLS_HASH_LOOP(b) \

  const mac_entry_st *p; \

    for(p = hash_algorithms; p->name != NULL; p++) { b ; }

#define GNUTLS_HASH_ALG_LOOP(a) \

      GNUTLS_HASH_LOOP( if(p->id == algorithm) { a; break; } )

const mac_entry_st *_gnutls_mac_to_entry(gnutls_mac_algorithm_t c)

{

  GNUTLS_HASH_LOOP(if (c == p->id) return p) ;

  return NULL;

}

/**

 * gnutls_mac_get_name:

 * @algorithm: is a MAC algorithm

 *

 * Convert a #gnutls_mac_algorithm_t value to a string.

 *

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

 *   algorithm, or %NULL.

 **/

const char *gnutls_mac_get_name(gnutls_mac_algorithm_t algorithm)

{

  const char *ret = NULL;

  /* avoid prefix */

  GNUTLS_HASH_ALG_LOOP(ret = p->name);

  return ret;

}

/**

 * gnutls_digest_get_name:

 * @algorithm: is a digest algorithm

 *

 * Convert a #gnutls_digest_algorithm_t value to a string.

 *

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

 *   algorithm, or %NULL.

 **/

const char *gnutls_digest_get_name(gnutls_digest_algorithm_t algorithm)

{

  const char *ret = NULL;

  GNUTLS_HASH_LOOP(if (algorithm == (unsigned)p->id && p->oid != NULL) {

       ret = p->name; break;}

  ) ;

  return ret;

}

/**

 * gnutls_digest_get_id:

 * @name: is a digest algorithm name

 *

 * Convert a string to a #gnutls_digest_algorithm_t value.  The names are

 * compared in a case insensitive way.

 *

 * Returns: a #gnutls_digest_algorithm_t id of the specified MAC

 *   algorithm string, or %GNUTLS_DIG_UNKNOWN on failure.

 **/

gnutls_digest_algorithm_t gnutls_digest_get_id(const char *name)

{

  gnutls_digest_algorithm_t ret = GNUTLS_DIG_UNKNOWN;

  GNUTLS_HASH_LOOP(if (p->oid != NULL && c_strcasecmp(p->name, name) == 0) {

       if (_gnutls_digest_exists

           ((gnutls_digest_algorithm_t) p->id))

       ret = (gnutls_digest_algorithm_t) p->id; break;}

  ) ;

  return ret;

}

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

int _gnutls_digest_mark_insecure(gnutls_digest_algorithm_t dig)

{

#ifndef DISABLE_SYSTEM_CONFIG

  mac_entry_st *p;

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

    if (p->oid != NULL && p->id == (gnutls_mac_algorithm_t) dig) {

      p->flags |= GNUTLS_MAC_FLAG_PREIMAGE_INSECURE;

      return 0;

    }

  }

#endif

  return GNUTLS_E_INVALID_REQUEST;

}

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

void _gnutls_digest_mark_insecure_all(void)

{

#ifndef DISABLE_SYSTEM_CONFIG

  mac_entry_st *p;

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

    p->flags |= GNUTLS_MAC_FLAG_PREIMAGE_INSECURE_REVERTIBLE |

        GNUTLS_MAC_FLAG_PREIMAGE_INSECURE;

  }

#endif

}

int

_gnutls_digest_set_secure(gnutls_digest_algorithm_t dig, unsigned int secure)

{

#ifndef DISABLE_SYSTEM_CONFIG

  mac_entry_st *p;

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

    if (p->oid != NULL && p->id == (gnutls_mac_algorithm_t) dig) {

      if (!

          (p->flags &

           GNUTLS_MAC_FLAG_PREIMAGE_INSECURE_REVERTIBLE)) {

        return

            gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

      }

      if (secure) {

        p->flags &= ~GNUTLS_MAC_FLAG_PREIMAGE_INSECURE;

      } else {

        p->flags |= GNUTLS_MAC_FLAG_PREIMAGE_INSECURE;

      }

      return 0;

    }

  }

#endif

  return GNUTLS_E_INVALID_REQUEST;

}

unsigned _gnutls_digest_is_insecure(gnutls_digest_algorithm_t dig)

{

  const mac_entry_st *p;

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

    if (p->oid != NULL && p->id == (gnutls_mac_algorithm_t) dig) {

      return p->flags & GNUTLS_MAC_FLAG_PREIMAGE_INSECURE;

    }

  }

  return 1;

}

bool _gnutls_digest_is_insecure2(gnutls_digest_algorithm_t dig, unsigned flags)

{

  const mac_entry_st *p;

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

    if (p->oid != NULL && p->id == (gnutls_mac_algorithm_t) dig) {

      return (p->flags & GNUTLS_MAC_FLAG_PREIMAGE_INSECURE &&

        !(flags &

          GNUTLS_MAC_FLAG_ALLOW_INSECURE_REVERTIBLE

          && p->flags &

          GNUTLS_MAC_FLAG_PREIMAGE_INSECURE_REVERTIBLE));

    }

  }

  return true;

}

/**

 * gnutls_mac_get_id:

 * @name: is a MAC algorithm name

 *

 * Convert a string to a #gnutls_mac_algorithm_t value.  The names are

 * compared in a case insensitive way.

 *

 * Returns: a #gnutls_mac_algorithm_t id of the specified MAC

 *   algorithm string, or %GNUTLS_MAC_UNKNOWN on failure.

 **/

gnutls_mac_algorithm_t gnutls_mac_get_id(const char *name)

{

  gnutls_mac_algorithm_t ret = GNUTLS_MAC_UNKNOWN;

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

       if (p->placeholder != 0 || _gnutls_mac_exists(p->id))

       ret = p->id; break;}

  ) ;

  return ret;

}

/**

 * gnutls_mac_get_key_size:

 * @algorithm: is an encryption algorithm

 *

 * Returns the size of the MAC key used in TLS.

 *

 * Returns: length (in bytes) of the given MAC key size, or 0 if the

 *   given MAC algorithm is invalid.

 **/

size_t gnutls_mac_get_key_size(gnutls_mac_algorithm_t algorithm)

{

  size_t ret = 0;

  /* avoid prefix */

  GNUTLS_HASH_ALG_LOOP(ret = p->key_size);

  return ret;

}

/**

 * gnutls_mac_get_nonce_size:

 * @algorithm: is an encryption algorithm

 *

 * Returns the size of the nonce used by the MAC in TLS.

 *

 * Returns: length (in bytes) of the given MAC nonce size, or 0.

 *

 * Since: 3.2.0

 **/

size_t gnutls_mac_get_nonce_size(gnutls_mac_algorithm_t algorithm)

{

  size_t ret = 0;

  /* avoid prefix */

  GNUTLS_HASH_ALG_LOOP(ret = p->nonce_size);

  return ret;

}

/**

 * gnutls_mac_list:

 *

 * Get a list of hash algorithms for use as MACs.  Note that not

 * necessarily all MACs are supported in TLS cipher suites.

 * This function is not thread safe.

 *

 * Returns: Return a (0)-terminated list of #gnutls_mac_algorithm_t

 *   integers indicating the available MACs.

 **/

const gnutls_mac_algorithm_t *gnutls_mac_list(void)

{

  static gnutls_mac_algorithm_t supported_macs[MAX_ALGOS] = { 0 };

  if (supported_macs[0] == 0) {

    int i = 0;

    GNUTLS_HASH_LOOP(if

         (p->placeholder != 0

          || _gnutls_mac_exists(p->id))

         supported_macs[i++] = p->id;) ;

    supported_macs[i++] = 0;

  }

  return supported_macs;

}

/**

 * gnutls_digest_list:

 *

 * Get a list of hash (digest) algorithms supported by GnuTLS.

 *

 * This function is not thread safe.

 *

 * Returns: Return a (0)-terminated list of #gnutls_digest_algorithm_t

 *   integers indicating the available digests.

 **/

const gnutls_digest_algorithm_t *gnutls_digest_list(void)

{

  static gnutls_digest_algorithm_t supported_digests[MAX_ALGOS] = { 0 };

  if (supported_digests[0] == 0) {

    int i = 0;

    GNUTLS_HASH_LOOP(if (p->oid != NULL && (p->placeholder != 0 ||

              _gnutls_mac_exists

              (p->id))) {

         supported_digests[i++] =

         (gnutls_digest_algorithm_t) p->id;}

    ) ;

    supported_digests[i++] = 0;

  }

  return supported_digests;

}

/**

 * gnutls_oid_to_digest:

 * @oid: is an object identifier

 *

 * Converts a textual object identifier to a #gnutls_digest_algorithm_t value.

 *

 * Returns: a #gnutls_digest_algorithm_t id of the specified digest

 *   algorithm, or %GNUTLS_DIG_UNKNOWN on failure.

 *

 * Since: 3.4.3

 **/

gnutls_digest_algorithm_t gnutls_oid_to_digest(const char *oid)

{

  GNUTLS_HASH_LOOP(if (p->oid && strcmp(oid, p->oid) == 0) {

       if (_gnutls_digest_exists

           ((gnutls_digest_algorithm_t) p->id)) {

       return (gnutls_digest_algorithm_t) p->id;}

       break;}

  ) ;

  return GNUTLS_DIG_UNKNOWN;

}

/**

 * gnutls_oid_to_mac:

 * @oid: is an object identifier

 *

 * Converts a textual object identifier typically from PKCS#5 values to a #gnutls_mac_algorithm_t value.

 *

 * Returns: a #gnutls_mac_algorithm_t id of the specified digest

 *   algorithm, or %GNUTLS_MAC_UNKNOWN on failure.

 *

 * Since: 3.5.4

 **/

gnutls_mac_algorithm_t gnutls_oid_to_mac(const char *oid)

{

  GNUTLS_HASH_LOOP(if (p->mac_oid && strcmp(oid, p->mac_oid) == 0) {

       if (_gnutls_mac_exists(p->id)) {

       return p->id;}

       break;}

  ) ;

  return GNUTLS_MAC_UNKNOWN;

}

/**

 * gnutls_digest_get_oid:

 * @algorithm: is a digest algorithm

 *

 * Convert a #gnutls_digest_algorithm_t value to its object identifier.

 *

 * Returns: a string that contains the object identifier of the specified digest

 *   algorithm, or %NULL.

 *

 * Since: 3.4.3

 **/

const char *gnutls_digest_get_oid(gnutls_digest_algorithm_t algorithm)

{

  GNUTLS_HASH_LOOP(if (algorithm == (unsigned)p->id && p->oid != NULL) {

       return p->oid;}

  ) ;

  return NULL;

}

gnutls_digest_algorithm_t _gnutls_hash_size_to_sha_hash(unsigned int size)

{

  if (size == 20)

    return GNUTLS_DIG_SHA1;

  else if (size == 28)

    return GNUTLS_DIG_SHA224;

  else if (size == 32)

    return GNUTLS_DIG_SHA256;

  else if (size == 48)

    return GNUTLS_DIG_SHA384;

  else if (size == 64)

    return GNUTLS_DIG_SHA512;

  return GNUTLS_DIG_UNKNOWN;

}