/*

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

 *

 */

/* The certificate authentication functions which are needed in the handshake,

 * and are common to RSA and DHE key exchange, are in this file.

 */

#include "gnutls_int.h"

#include "auth.h"

#include "errors.h"

#include <auth/cert.h>

#include "dh.h"

#include "num.h"

#include "libtasn1.h"

#include "datum.h"

#include "ext/signature.h"

#include <pk.h>

#include <algorithms.h>

#include <global.h>

#include <record.h>

#include <tls-sig.h>

#include <state.h>

#include <pk.h>

#include <x509.h>

#include <x509/verify-high.h>

#include <gnutls/abstract.h>

#include "abstract_int.h"

#include "debug.h"

static void

selected_certs_set(gnutls_session_t session,

		   gnutls_pcert_st * certs, int ncerts,

		   gnutls_ocsp_data_st *ocsp, unsigned nocsp,

		   gnutls_privkey_t key, int need_free,

		   gnutls_status_request_ocsp_func ocsp_func,

		   void *ocsp_func_ptr);

#define MAX_CLIENT_SIGN_ALGOS 5

#define CERTTYPE_SIZE (MAX_CLIENT_SIGN_ALGOS+1)

typedef enum CertificateSigType { RSA_SIGN = 1, DSA_SIGN = 2, ECDSA_SIGN = 64,

#ifdef ENABLE_GOST

	GOSTR34102012_256_SIGN = 67,

	GOSTR34102012_512_SIGN = 68

#endif

} CertificateSigType;

/* Moves data from an internal certificate struct (gnutls_pcert_st) to

 * another internal certificate struct (cert_auth_info_t), and deinitializes

 * the former.

 */

int _gnutls_pcert_to_auth_info(cert_auth_info_t info, gnutls_pcert_st * certs, size_t ncerts)

{

	size_t i, j;

	if (info->raw_certificate_list != NULL) {

		for (j = 0; j < info->ncerts; j++)

			_gnutls_free_datum(&info->raw_certificate_list[j]);

		gnutls_free(info->raw_certificate_list);

	}

	if (ncerts == 0) {

		info->raw_certificate_list = NULL;

		info->ncerts = 0;

		return 0;

	}

	info->raw_certificate_list =

	    gnutls_calloc(ncerts, sizeof(gnutls_datum_t));

	if (info->raw_certificate_list == NULL) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	info->cert_type = certs[0].type;

	info->ncerts = ncerts;

	for (i = 0; i < ncerts; i++) {

		info->raw_certificate_list[i].data = certs[i].cert.data;

		info->raw_certificate_list[i].size = certs[i].cert.size;

		certs[i].cert.data = NULL;

		gnutls_pcert_deinit(&certs[i]);

	}

	gnutls_free(certs);

	return 0;

}

/* returns 0 if the algo_to-check exists in the pk_algos list,

 * -1 otherwise.

 */

inline static int

check_pk_algo_in_list(const gnutls_pk_algorithm_t *

		      pk_algos, int pk_algos_length,

		      gnutls_pk_algorithm_t algo_to_check)

{

	int i;

	for (i = 0; i < pk_algos_length; i++) {

		if (algo_to_check == pk_algos[i]) {

			return 0;

		}

	}

	return -1;

}

/* Returns the issuer's Distinguished name in odn, of the certificate

 * specified in cert.

 */

static int cert_get_issuer_dn(gnutls_pcert_st * cert, gnutls_datum_t * odn)

{

	ASN1_TYPE dn;

	int len, result;

	int start, end;

	if ((result = asn1_create_element

	     (_gnutls_get_pkix(), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS) {

		gnutls_assert();

		return _gnutls_asn2err(result);

	}

	result = asn1_der_decoding(&dn, cert->cert.data, cert->cert.size, NULL);

	if (result != ASN1_SUCCESS) {

		/* couldn't decode DER */

		gnutls_assert();

		asn1_delete_structure(&dn;;

		return _gnutls_asn2err(result);

	}

	result =

	    asn1_der_decoding_startEnd(dn, cert->cert.data,

				       cert->cert.size,

				       "tbsCertificate.issuer", &start, &end;;

	if (result != ASN1_SUCCESS) {

		/* couldn't decode DER */

		gnutls_assert();

		asn1_delete_structure(&dn;;

		return _gnutls_asn2err(result);

	}

	asn1_delete_structure(&dn;;

	len = end - start + 1;

	odn->size = len;

	odn->data = &cert->cert.data[start];

	return 0;

}

/* Locates the most appropriate x509 certificate using the

 * given DN. If indx == -1 then no certificate was found.

 *

 * That is to guess which certificate to use, based on the

 * CAs and sign algorithms supported by the peer server.

 */

static int

find_x509_client_cert(gnutls_session_t session,

	       const gnutls_certificate_credentials_t cred,

	       const uint8_t * _data, size_t _data_size,

	       const gnutls_pk_algorithm_t * pk_algos,

	       int pk_algos_length, int *indx)

{

	unsigned size;

	gnutls_datum_t odn = { NULL, 0 }, asked_dn;

	const uint8_t *data = _data;

	ssize_t data_size = _data_size;

	unsigned i, j;

	int result, cert_pk;

	unsigned key_usage;

	*indx = -1;

	/* If peer doesn't send any issuers and we have a single certificate

	 * then send that one.

	 */

	if (cred->ncerts == 1 &&

	    (data_size == 0

	     || (session->internals.flags & GNUTLS_FORCE_CLIENT_CERT))) {

		if (cred->certs[0].cert_list[0].type == GNUTLS_CRT_X509) {

			key_usage = get_key_usage(session, cred->certs[0].cert_list[0].pubkey);

			/* For client certificates we require signatures */

			result = _gnutls_check_key_usage_for_sig(session, key_usage, 1);

			if (result < 0) {

				_gnutls_debug_log("Client certificate is not suitable for signing\n");

				return gnutls_assert_val(result);

			}

			*indx = 0;

			return 0;

		}

	}

	do {

		DECR_LENGTH_RET(data_size, 2, 0);

		size = _gnutls_read_uint16(data);

		DECR_LENGTH_RET(data_size, size, 0);

		data += 2;

		asked_dn.data = (void*)data;

		asked_dn.size = size;

		_gnutls_dn_log("Peer requested CA", &asked_dn);

		for (i = 0; i < cred->ncerts; i++) {

			for (j = 0; j < cred->certs[i].cert_list_length; j++) {

				if ((result =

				     cert_get_issuer_dn(&cred->certs

							[i].cert_list

							[j], &odn)) < 0) {

					gnutls_assert();

					return result;

				}

				if (odn.size == 0 || odn.size != asked_dn.size)

					continue;

				key_usage = get_key_usage(session, cred->certs[i].cert_list[0].pubkey);

				/* For client certificates we require signatures */

				if (_gnutls_check_key_usage_for_sig(session, key_usage, 1) < 0) {

					_gnutls_debug_log("Client certificate is not suitable for signing\n");

					continue;

				}

				/* If the DN matches and

				 * the *_SIGN algorithm matches

				 * the cert is our cert!

				 */

				cert_pk =

				    gnutls_pubkey_get_pk_algorithm(cred->certs

								   [i].cert_list

								   [0].pubkey,

								   NULL);

				if ((memcmp(odn.data, asked_dn.data, asked_dn.size) == 0) &&

				    (check_pk_algo_in_list

				     (pk_algos, pk_algos_length,

				      cert_pk) == 0)) {

					*indx = i;

					break;

				}

			}

			if (*indx != -1)

				break;

		}

		if (*indx != -1)

			break;

		/* move to next record */

		data += size;

	}

	while (1);

	return 0;

}

/* Locates the first raw public-key.

 * Currently it only makes sense to associate one raw pubkey per session.

 * Associating more raw pubkeys with a session has no use because we

 * don't know how to select the correct one.

 */

static int

find_rawpk_client_cert(gnutls_session_t session,

			const gnutls_certificate_credentials_t cred,

			const gnutls_pk_algorithm_t* pk_algos,

			int pk_algos_length, int* indx)

{

	unsigned i;

	int ret;

	gnutls_pk_algorithm_t pk;

	*indx = -1;

	for (i = 0; i < cred->ncerts; i++) {

		/* We know that our list length will be 1, therefore we can

		 * ignore the rest.

		 */

		if (cred->certs[i].cert_list_length == 1 && cred->certs[i].cert_list[0].type == GNUTLS_CRT_RAWPK) {

			pk = gnutls_pubkey_get_pk_algorithm(cred->certs[i].cert_list[0].pubkey, NULL);

			/* For client certificates we require signatures */

			ret = _gnutls_check_key_usage_for_sig(session, get_key_usage(session, cred->certs[i].cert_list[0].pubkey), 1);

			if (ret < 0) {

				/* we return an error instead of skipping so that the user is notified about

				 * the key incompatibility */

				_gnutls_debug_log("Client certificate is not suitable for signing\n");

				return gnutls_assert_val(ret);

			}

			/* Check whether the public-key algorithm of our credential is in

			 * the list with supported public-key algorithms and whether the

			 * cert type matches. */

			if ((check_pk_algo_in_list(pk_algos, pk_algos_length, pk) == 0)) {

				// We found a compatible credential

				*indx = i;

				break;

			}

		}

	}

	return 0;

}

/* Returns the number of issuers in the server's

 * certificate request packet.

 */

static int

get_issuers_num(gnutls_session_t session, const uint8_t * data, ssize_t data_size)

{

	int issuers_dn_len = 0;

	unsigned size;

	/* Count the number of the given issuers;

	 * This is used to allocate the issuers_dn without

	 * using realloc().

	 */

	if (data_size == 0 || data == NULL)

		return 0;

	while (data_size > 0) {

		/* This works like DECR_LEN()

		 */

		DECR_LENGTH_RET(data_size, 2, GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

		size = _gnutls_read_uint16(data);

		DECR_LENGTH_RET(data_size, size, GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

		data += 2;

		if (size > 0) {

			issuers_dn_len++;

			data += size;

		}

	}

	return issuers_dn_len;

}

/* Returns the issuers in the server's certificate request

 * packet.

 */

static int

get_issuers(gnutls_session_t session,

	    gnutls_datum_t * issuers_dn, int issuers_len,

	    const uint8_t * data, size_t data_size)

{

	int i;

	unsigned size;

	if (get_certificate_type(session, GNUTLS_CTYPE_CLIENT) != GNUTLS_CRT_X509)

		return 0;

	/* put the requested DNs to req_dn, only in case

	 * of X509 certificates.

	 */

	if (issuers_len > 0) {

		for (i = 0; i < issuers_len; i++) {

			/* The checks here for the buffer boundaries

			 * are not needed since the buffer has been

			 * parsed above.

			 */

			data_size -= 2;

			size = _gnutls_read_uint16(data);

			data += 2;

			issuers_dn[i].data = (void*)data;

			issuers_dn[i].size = size;

			_gnutls_dn_log("Peer requested CA", &issuers_dn[i]);

			data += size;

		}

	}

	return 0;

}

/* Calls the client or server certificate get callback.

 */

static int

call_get_cert_callback(gnutls_session_t session,

		       const gnutls_datum_t * issuers_dn,

		       int issuers_dn_length,

		       gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)

{

	gnutls_privkey_t local_key = NULL;

	int ret = GNUTLS_E_INTERNAL_ERROR;

	gnutls_certificate_type_t type;

	gnutls_certificate_credentials_t cred;

	gnutls_pcert_st *pcert = NULL;

	gnutls_ocsp_data_st *ocsp = NULL;

	unsigned int ocsp_length = 0;

	unsigned int pcert_length = 0;

	cred = (gnutls_certificate_credentials_t)

	    _gnutls_get_cred(session, GNUTLS_CRD_CERTIFICATE);

	if (cred == NULL) {

		gnutls_assert();

		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;

	}

	/* Correctly set the certificate type for ourselves */

	type = get_certificate_type(session, GNUTLS_CTYPE_OURS);

	/* Check whether a callback is set and call it */

	if (cred->get_cert_callback3) {

		struct gnutls_cert_retr_st info;

		unsigned int flags = 0;

		memset(&info, 0, sizeof(info));

		info.req_ca_rdn = issuers_dn;

		info.nreqs = issuers_dn_length;

		info.pk_algos = pk_algos;

		info.pk_algos_length = pk_algos_length;

		info.cred = cred;

		/* we avoid all allocations and transformations */

		ret =

		    cred->get_cert_callback3(session, &info,

					     &pcert, &pcert_length,

					     &ocsp, &ocsp_length,

					     &local_key, &flags);

		if (ret < 0)

			return gnutls_assert_val(GNUTLS_E_USER_ERROR);

		if (pcert_length > 0 && type != pcert[0].type)

			return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

		if (pcert_length == 0) {

			pcert = NULL;

			local_key = NULL;

		}

		selected_certs_set(session, pcert, pcert_length,

				   ocsp, ocsp_length,

				   local_key, (flags&GNUTLS_CERT_RETR_DEINIT_ALL)?1:0,

				   cred->glob_ocsp_func, cred->glob_ocsp_func_ptr);

		return 0;

	} else {

		return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

	}

}

/* Finds the appropriate certificate depending on the cA Distinguished name

 * advertized by the server. If none matches then returns 0 and -1 as index.

 * In case of an error a negative error code, is returned.

 *

 * 20020128: added ability to select a certificate depending on the SIGN

 * algorithm (only in automatic mode).

 */

int

_gnutls_select_client_cert(gnutls_session_t session,

			   const uint8_t * _data, size_t _data_size,

			   gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)

{

	int result;

	int indx = -1;

	gnutls_certificate_credentials_t cred;

	const uint8_t *data = _data;

	ssize_t data_size = _data_size;

	int issuers_dn_length;

	gnutls_datum_t *issuers_dn = NULL;

	gnutls_certificate_type_t cert_type;

	cred = (gnutls_certificate_credentials_t)

	    _gnutls_get_cred(session, GNUTLS_CRD_CERTIFICATE);

	if (cred == NULL) {

		gnutls_assert();

		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;

	}

	cert_type = get_certificate_type(session, GNUTLS_CTYPE_CLIENT);

	if (cred->get_cert_callback3 != NULL) {

		/* use a callback to get certificate

		 */

		if (cert_type == GNUTLS_CRT_X509) {

			issuers_dn_length =

			    get_issuers_num(session, data, data_size);

			if (issuers_dn_length < 0) {

				gnutls_assert();

				return issuers_dn_length;

			}

			if (issuers_dn_length > 0) {

				issuers_dn =

				    gnutls_malloc(sizeof(gnutls_datum_t) *

						  issuers_dn_length);

				if (issuers_dn == NULL) {

					gnutls_assert();

					return GNUTLS_E_MEMORY_ERROR;

				}

				result =

				    get_issuers(session, issuers_dn,

						issuers_dn_length, data,

						data_size);

				if (result < 0) {

					gnutls_assert();

					goto cleanup;

				}

			}

		} else {

			issuers_dn_length = 0;

		}

		result =

		    call_get_cert_callback(session, issuers_dn,

					   issuers_dn_length, pk_algos,

					   pk_algos_length);

		goto cleanup;

	} else {

		/* If we have no callbacks, try to guess.

		 */

		switch (cert_type) {

			case GNUTLS_CRT_X509:

				result = find_x509_client_cert(session, cred, _data,

										_data_size, pk_algos,

										pk_algos_length, &indx);

				break;

			case GNUTLS_CRT_RAWPK:

				result = find_rawpk_client_cert(session, cred,

							pk_algos, pk_algos_length, &indx);

				break;

			default:

				result = GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE;

				break;

		}

		if (result < 0) {

			return gnutls_assert_val(result);

		}

		if (indx >= 0) {

			selected_certs_set(session,

					   &cred->certs[indx].

					   cert_list[0],

					   cred->certs[indx].

					   cert_list_length,

					   cred->certs[indx].ocsp_data,

					   cred->certs[indx].ocsp_data_length,

					   cred->certs[indx].pkey, 0,

					   NULL, NULL);

		} else {

			selected_certs_set(session, NULL, 0, NULL, 0,

					   NULL, 0, NULL, NULL);

		}

		result = 0;

	}

 cleanup:

	gnutls_free(issuers_dn);

	return result;

}

/* Generate certificate message

 */

static int gen_x509_crt(gnutls_session_t session, gnutls_buffer_st * data)

{

	int ret, i;

	gnutls_pcert_st *apr_cert_list;

	gnutls_privkey_t apr_pkey;

	int apr_cert_list_length;

	unsigned init_pos = data->length;

	/* find the appropriate certificate

	 */

	if ((ret =

	     _gnutls_get_selected_cert(session, &apr_cert_list,

				       &apr_cert_list_length, &apr_pkey)) < 0) {

		gnutls_assert();

		return ret;

	}

	ret = 3;

	for (i = 0; i < apr_cert_list_length; i++) {

		ret += apr_cert_list[i].cert.size + 3;

		/* hold size

		 * for uint24 */

	}

	/* if no certificates were found then send:

	 * 0B 00 00 03 00 00 00    // Certificate with no certs

	 * instead of:

	 * 0B 00 00 00	  // empty certificate handshake

	 *

	 * ( the above is the whole handshake message, not

	 * the one produced here )

	 */

	ret = _gnutls_buffer_append_prefix(data, 24, ret - 3);

	if (ret < 0)

		return gnutls_assert_val(ret);

	for (i = 0; i < apr_cert_list_length; i++) {

		ret =

		    _gnutls_buffer_append_data_prefix(data, 24,

						      apr_cert_list[i].

						      cert.data,

						      apr_cert_list[i].

						      cert.size);

		if (ret < 0)

			return gnutls_assert_val(ret);

	}

	return data->length - init_pos;

}

/* Generates a Raw Public Key certificate message that holds only the

 * SubjectPublicKeyInfo part of a regular certificate message.

 *

 * Returns the number of bytes sent or a negative error code.

 */

int

_gnutls_gen_rawpk_crt(gnutls_session_t session, gnutls_buffer_st* data)

{

	int ret;

	gnutls_pcert_st *apr_cert_list;

	gnutls_privkey_t apr_pkey;

	int apr_cert_list_length;

	if((ret = _gnutls_get_selected_cert(session, &apr_cert_list,

				       &apr_cert_list_length, &apr_pkey)) < 0)	{

			return gnutls_assert_val(ret);

	}

	/* Since we are transmitting a raw public key with no additional

	 * certificate credentials attached to it, it doesn't make sense to

	 * have more than one certificate set (i.e. to have a certificate chain).

	 */

	assert(apr_cert_list_length <= 1);

	/* Write our certificate containing only the SubjectPublicKeyInfo to

	 * the output buffer. We always have exactly one certificate that

	 * contains our raw public key. Our message looks like:

	 * <length++certificate> where

	 * length = 3 bytes (or 24 bits) and

	 * certificate = length bytes.

	 */

	if (apr_cert_list_length == 0) {

		ret = _gnutls_buffer_append_prefix(data, 24, 0);

	} else {

		ret = _gnutls_buffer_append_data_prefix(data, 24,

							apr_cert_list[0].cert.data,

							apr_cert_list[0].cert.size);

	}

	if (ret < 0) return gnutls_assert_val(ret);

	return data->length;

}

int

_gnutls_gen_cert_client_crt(gnutls_session_t session, gnutls_buffer_st * data)

{

	gnutls_certificate_type_t cert_type;

	// Retrieve the (negotiated) certificate type for the client

	cert_type = get_certificate_type(session, GNUTLS_CTYPE_CLIENT);

	switch (cert_type) {

		case GNUTLS_CRT_X509:

			return gen_x509_crt(session, data);

		case GNUTLS_CRT_RAWPK:

			return _gnutls_gen_rawpk_crt(session, data);

		default:

			return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

	}

}

int

_gnutls_gen_cert_server_crt(gnutls_session_t session, gnutls_buffer_st * data)

{

	gnutls_certificate_type_t cert_type;

	// Retrieve the (negotiated) certificate type for the server

	cert_type = get_certificate_type(session, GNUTLS_CTYPE_SERVER);

	switch (cert_type) {

		case GNUTLS_CRT_X509:

			return gen_x509_crt(session, data);

		case GNUTLS_CRT_RAWPK:

			return _gnutls_gen_rawpk_crt(session, data);

		default:

			return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

	}

}

static

int check_pk_compat(gnutls_session_t session, gnutls_pubkey_t pubkey)

{

	unsigned cert_pk;

	unsigned kx;

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

		return 0;

	cert_pk = gnutls_pubkey_get_pk_algorithm(pubkey, NULL);

	if (cert_pk == GNUTLS_PK_UNKNOWN) {

		gnutls_assert();

		return GNUTLS_E_CERTIFICATE_ERROR;

	}

	kx = session->security_parameters.cs->kx_algorithm;

	if (_gnutls_map_kx_get_cred(kx, 1) == GNUTLS_CRD_CERTIFICATE &&

	    !_gnutls_kx_supports_pk(kx, cert_pk)) {

		gnutls_assert();

		return GNUTLS_E_CERTIFICATE_ERROR;

	}

	return 0;

}

/* Process server certificate

 */

#define CLEAR_CERTS for(x=0;x

static int

_gnutls_proc_x509_crt(gnutls_session_t session,

			     uint8_t * data, size_t data_size)

{

	int size, len, ret;

	uint8_t *p = data;

	cert_auth_info_t info;

	gnutls_certificate_credentials_t cred;

	ssize_t dsize = data_size;

	int i;

	gnutls_pcert_st *peer_certificate_list;

	size_t peer_certificate_list_size = 0, j, x;

	gnutls_datum_t tmp;

	cred = (gnutls_certificate_credentials_t)

	    _gnutls_get_cred(session, GNUTLS_CRD_CERTIFICATE);

	if (cred == NULL) {

		gnutls_assert();

		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;

	}

	if ((ret =

	     _gnutls_auth_info_init(session, GNUTLS_CRD_CERTIFICATE,

				   sizeof(cert_auth_info_st), 1)) < 0) {

		gnutls_assert();

		return ret;

	}

	info = _gnutls_get_auth_info(session, GNUTLS_CRD_CERTIFICATE);

	if (data == NULL || data_size == 0) {

		gnutls_assert();

		/* no certificate was sent */

		return GNUTLS_E_NO_CERTIFICATE_FOUND;

	}

	DECR_LEN(dsize, 3);

	size = _gnutls_read_uint24(p);

	p += 3;

	/* ensure no discrepancy in data */

	if (size != dsize)

		return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

	/* some implementations send 0B 00 00 06 00 00 03 00 00 00

	 * instead of just 0B 00 00 03 00 00 00 as an empty certificate message.

	 */

	if (size == 0 || (size == 3 && memcmp(p, "\x00\x00\x00", 3) == 0)) {

		gnutls_assert();

		/* no certificate was sent */

		return GNUTLS_E_NO_CERTIFICATE_FOUND;

	}

	i = dsize;

	while (i > 0) {

		DECR_LEN(dsize, 3);

		len = _gnutls_read_uint24(p);

		p += 3;

		DECR_LEN(dsize, len);

		peer_certificate_list_size++;

		p += len;

		i -= len + 3;

	}

	if (dsize != 0)

		return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);

	if (peer_certificate_list_size == 0) {

		gnutls_assert();

		return GNUTLS_E_NO_CERTIFICATE_FOUND;

	}

	/* Ok we now allocate the memory to hold the

	 * certificate list

	 */

	peer_certificate_list =

	    gnutls_calloc(1,

			  sizeof(gnutls_pcert_st) *

			  (peer_certificate_list_size));

	if (peer_certificate_list == NULL) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	p = data + 3;

	/* Now we start parsing the list (again).

	 * We don't use DECR_LEN since the list has

	 * been parsed before.

	 */

	for (j = 0; j < peer_certificate_list_size; j++) {

		len = _gnutls_read_uint24(p);

		p += 3;

		tmp.size = len;

		tmp.data = p;

		ret =

		    gnutls_pcert_import_x509_raw(&peer_certificate_list

						 [j], &tmp,

						 GNUTLS_X509_FMT_DER, 0);

		if (ret < 0) {

			gnutls_assert();

			peer_certificate_list_size = j;

			ret = GNUTLS_E_CERTIFICATE_ERROR;

			goto cleanup;

		}

		p += len;

	}

	ret = check_pk_compat(session, peer_certificate_list[0].pubkey);

	if (ret < 0) {

		gnutls_assert();

		goto cleanup;

	}

	ret =

	     _gnutls_pcert_to_auth_info(info,

					peer_certificate_list,

					peer_certificate_list_size);

	if (ret < 0) {

		gnutls_assert();

		goto cleanup;

	}