/*

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

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

#include "global.h"

#include <libtasn1.h>

#include "datum.h"

#include "common.h"

#include "x509_int.h"

#include "num.h"

#include <limits.h>

/* Reads an Integer from the DER encoded data

 */

int _gnutls_x509_read_der_int(uint8_t *der, int dersize, bigint_t *out)

{

  int result;

  asn1_node spk = NULL;

  /* == INTEGER */

  if ((result = asn1_create_element(_gnutls_get_gnutls_asn(),

            "GNUTLS.DSAPublicKey", &spk)) !=

      ASN1_SUCCESS) {

    gnutls_assert();

    return _gnutls_asn2err(result);

  }

  result = _asn1_strict_der_decode(&spk, der, dersize, NULL);

  if (result != ASN1_SUCCESS) {

    gnutls_assert();

    asn1_delete_structure(&spk);

    return _gnutls_asn2err(result);

  }

  /* Read Y */

  if ((result = _gnutls_x509_read_int(spk, "", out)) < 0) {

    gnutls_assert();

    asn1_delete_structure(&spk);

    return _gnutls_asn2err(result);

  }

  asn1_delete_structure(&spk);

  return 0;

}

int _gnutls_x509_read_der_uint(uint8_t *der, int dersize, unsigned int *out)

{

  int result;

  asn1_node spk = NULL;

  /* == INTEGER */

  if ((result = asn1_create_element(_gnutls_get_gnutls_asn(),

            "GNUTLS.DSAPublicKey", &spk)) !=

      ASN1_SUCCESS) {

    gnutls_assert();

    return _gnutls_asn2err(result);

  }

  result = _asn1_strict_der_decode(&spk, der, dersize, NULL);

  if (result != ASN1_SUCCESS) {

    gnutls_assert();

    asn1_delete_structure(&spk);

    return _gnutls_asn2err(result);

  }

  /* Read Y */

  if ((result = _gnutls_x509_read_uint(spk, "", out)) < 0) {

    gnutls_assert();

    asn1_delete_structure(&spk);

    return _gnutls_asn2err(result);

  }

  asn1_delete_structure(&spk);

  return 0;

}

/* Extracts DSA and RSA parameters from a certificate.

 */

int _gnutls_get_asn_mpis(asn1_node asn, const char *root,

       gnutls_pk_params_st *params)

{

  int result;

  char name[256];

  gnutls_datum_t tmp = { NULL, 0 };

  gnutls_pk_algorithm_t pk_algorithm;

  gnutls_ecc_curve_t curve;

  gnutls_pk_params_init(params);

  result = _gnutls_x509_get_pk_algorithm(asn, root, &curve, NULL);

  if (result < 0) {

    gnutls_assert();

    return result;

  }

  pk_algorithm = result;

  params->curve = curve;

  params->algo = pk_algorithm;

  /* Read the algorithm's parameters

   */

  _asnstr_append_name(name, sizeof(name), root, ".algorithm.parameters");

  if (pk_algorithm != GNUTLS_PK_RSA &&

      pk_algorithm != GNUTLS_PK_EDDSA_ED25519 &&

      pk_algorithm != GNUTLS_PK_ECDH_X25519 &&

      pk_algorithm != GNUTLS_PK_EDDSA_ED448 &&

      pk_algorithm != GNUTLS_PK_ECDH_X448) {

    /* RSA and EdDSA do not use parameters */

    result = _gnutls_x509_read_value(asn, name, &tmp);

    if (pk_algorithm == GNUTLS_PK_RSA_PSS &&

        (result == GNUTLS_E_ASN1_VALUE_NOT_FOUND ||

         result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)) {

      goto skip_params;

    }

    if (result < 0) {

      gnutls_assert();

      goto error;

    }

    result = _gnutls_x509_read_pubkey_params(pk_algorithm, tmp.data,

               tmp.size, params);

    if (result < 0) {

      gnutls_assert();

      goto error;

    }

    _gnutls_free_datum(&tmp);

  }

skip_params:

  /* Now read the public key */

  _asnstr_append_name(name, sizeof(name), root, ".subjectPublicKey");

  result = _gnutls_x509_read_value(asn, name, &tmp);

  if (result < 0) {

    gnutls_assert();

    goto error;

  }

  if ((result = _gnutls_x509_read_pubkey(pk_algorithm, tmp.data, tmp.size,

                 params)) < 0) {

    gnutls_assert();

    goto error;

  }

  result = _gnutls_x509_check_pubkey_params(params);

  if (result < 0) {

    gnutls_assert();

    goto error;

  }

  result = 0;

error:

  if (result < 0)

    gnutls_pk_params_release(params);

  _gnutls_free_datum(&tmp);

  return result;

}

/* Extracts DSA and RSA parameters from a certificate.

 */

int _gnutls_x509_crt_get_mpis(gnutls_x509_crt_t cert,

            gnutls_pk_params_st *params)

{

  /* Read the algorithm's OID

   */

  return _gnutls_get_asn_mpis(

    cert->cert, "tbsCertificate.subjectPublicKeyInfo", params);

}

/* Extracts DSA and RSA parameters from a certificate.

 */

int _gnutls_x509_crq_get_mpis(gnutls_x509_crq_t cert,

            gnutls_pk_params_st *params)

{

  /* Read the algorithm's OID

   */

  return _gnutls_get_asn_mpis(

    cert->crq, "certificationRequestInfo.subjectPKInfo", params);

}

/*

 * This function reads and decodes the parameters for DSS or RSA keys.

 * This is the "signatureAlgorithm" fields.

 */

int _gnutls_x509_read_pkalgo_params(asn1_node src, const char *src_name,

            gnutls_x509_spki_st *spki, unsigned is_sig)

{

  int result;

  char name[128];

  char oid[MAX_OID_SIZE];

  int oid_size;

  memset(spki, 0, sizeof(*spki));

  _gnutls_str_cpy(name, sizeof(name), src_name);

  _gnutls_str_cat(name, sizeof(name), ".algorithm");

  oid_size = sizeof(oid);

  result = asn1_read_value(src, name, oid, &oid_size);

  if (result != ASN1_SUCCESS) {

    gnutls_assert();

    return _gnutls_asn2err(result);

  }

  if (strcmp(oid, PK_PKIX1_RSA_PSS_OID) == 0) {

    gnutls_datum_t tmp = { NULL, 0 };

    _gnutls_str_cpy(name, sizeof(name), src_name);

    _gnutls_str_cat(name, sizeof(name), ".parameters");

    result = _gnutls_x509_read_value(src, name, &tmp);

    if (result < 0) {

      if (!is_sig) {

        if (result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND ||

            result != GNUTLS_E_ASN1_VALUE_NOT_FOUND) {

          /* it is ok to not have parameters in SPKI, but

           * not in signatures */

          return 0;

        }

      }

      return gnutls_assert_val(result);

    }

    result = _gnutls_x509_read_rsa_pss_params(tmp.data, tmp.size,

                spki);

    _gnutls_free_datum(&tmp);

    if (result < 0)

      gnutls_assert();

    return result;

  }

  return 0;

}

static int write_oid_and_params(asn1_node dst, const char *dst_name,

        const char *oid, gnutls_x509_spki_st *params)

{

  int result;

  char name[128];

  if (params == NULL) {

    gnutls_assert();

    return GNUTLS_E_INVALID_REQUEST;

  }

  _gnutls_str_cpy(name, sizeof(name), dst_name);

  _gnutls_str_cat(name, sizeof(name), ".algorithm");

  /* write the OID.

   */

  result = asn1_write_value(dst, name, oid, 1);

  if (result != ASN1_SUCCESS) {

    gnutls_assert();

    return _gnutls_asn2err(result);

  }

  _gnutls_str_cpy(name, sizeof(name), dst_name);

  _gnutls_str_cat(name, sizeof(name), ".parameters");

  if (params->pk == GNUTLS_PK_RSA)

    result = asn1_write_value(dst, name, ASN1_NULL, ASN1_NULL_SIZE);

  else if (params->pk == GNUTLS_PK_RSA_PSS) {

    gnutls_datum_t tmp = { NULL, 0 };

    result = _gnutls_x509_write_rsa_pss_params(params, &tmp);

    if (result < 0)

      return gnutls_assert_val(result);

    result = asn1_write_value(dst, name, tmp.data, tmp.size);

    _gnutls_free_datum(&tmp);

  } else

    result = asn1_write_value(dst, name, NULL, 0);

  if (result != ASN1_SUCCESS && result != ASN1_ELEMENT_NOT_FOUND) {

    /* Here we ignore the element not found error, since this

     * may have been disabled before.

     */

    gnutls_assert();

    return _gnutls_asn2err(result);

  }

  return 0;

}

int _gnutls_x509_write_spki_params(asn1_node dst, const char *dst_name,

           gnutls_x509_spki_st *params)

{

  const char *oid;

  if (params->legacy && params->pk == GNUTLS_PK_RSA)

    oid = PK_PKIX1_RSA_OID;

  else if (params->pk == GNUTLS_PK_RSA_PSS)

    oid = PK_PKIX1_RSA_PSS_OID;

  else

    oid = gnutls_pk_get_oid(params->pk);

  if (oid == NULL) {

    gnutls_assert();

    _gnutls_debug_log(

      "Cannot find OID for public key algorithm %s\n",

      gnutls_pk_get_name(params->pk));

    return GNUTLS_E_INVALID_REQUEST;

  }

  return write_oid_and_params(dst, dst_name, oid, params);

}

int _gnutls_x509_write_sign_params(asn1_node dst, const char *dst_name,

           const gnutls_sign_entry_st *se,

           gnutls_x509_spki_st *params)

{

  const char *oid;

  if (params->legacy && params->pk == GNUTLS_PK_RSA)

    oid = PK_PKIX1_RSA_OID;

  else if (params->pk == GNUTLS_PK_RSA_PSS)

    oid = PK_PKIX1_RSA_PSS_OID;

  else

    oid = se->oid;

  if (oid == NULL) {

    gnutls_assert();

    _gnutls_debug_log("Cannot find OID for sign algorithm %s\n",

          se->name);

    return GNUTLS_E_INVALID_REQUEST;

  }

  return write_oid_and_params(dst, dst_name, oid, params);

}

/* this function reads a (small) unsigned integer

 * from asn1 structs. Combines the read and the conversion

 * steps.

 */

int _gnutls_x509_read_uint(asn1_node node, const char *value, unsigned int *ret)

{

  int len, result;

  uint8_t *tmpstr;

  len = 0;

  result = asn1_read_value(node, value, NULL, &len);

  if (result != ASN1_MEM_ERROR) {

    return _gnutls_asn2err(result);

  }

  tmpstr = gnutls_malloc(len);

  if (tmpstr == NULL) {

    gnutls_assert();

    return GNUTLS_E_MEMORY_ERROR;

  }

  result = asn1_read_value(node, value, tmpstr, &len);

  if (result != ASN1_SUCCESS) {

    gnutls_assert();

    gnutls_free(tmpstr);

    return _gnutls_asn2err(result);

  }

  if (len == 1)

    *ret = tmpstr[0];

  else if (len == 2)

    *ret = _gnutls_read_uint16(tmpstr);

  else if (len == 3)

    *ret = _gnutls_read_uint24(tmpstr);

  else if (len == 4)

    *ret = _gnutls_read_uint32(tmpstr);

  else {

    gnutls_assert();

    gnutls_free(tmpstr);

    return GNUTLS_E_INTERNAL_ERROR;

  }

  gnutls_free(tmpstr);

  return 0;

}

/* Writes the specified integer into the specified node.

 */

int _gnutls_x509_write_uint32(asn1_node node, const char *value, uint32_t num)

{

  uint8_t tmpstr[5];

  int result;

  tmpstr[0] = 0;

  _gnutls_write_uint32(num, tmpstr + 1);

  if (tmpstr[1] > SCHAR_MAX) {

    result = asn1_write_value(node, value, tmpstr, 5);

  } else {

    result = asn1_write_value(node, value, tmpstr + 1, 4);

  }

  if (result != ASN1_SUCCESS) {

    gnutls_assert();

    return _gnutls_asn2err(result);

  }

  return 0;

}