path: root/lib/auth_cert.c

/*
 *  Copyright (C) 2001,2002,2003 Nikos Mavroyanopoulos
 *  Copyright (C) 2004 Free Software Foundation
 *
 *  This file is part of GNUTLS.
 *
 *  The GNUTLS library 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 library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 * 
 */

/* 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 "gnutls_auth_int.h"
#include "gnutls_errors.h"
#include <gnutls_cert.h>
#include <auth_cert.h>
#include "gnutls_dh.h"
#include "gnutls_num.h"
#include "libtasn1.h"
#include "gnutls_datum.h"
#include <gnutls_random.h>
#include <gnutls_pk.h>
#include <gnutls_algorithms.h>
#include <gnutls_global.h>
#include <gnutls_record.h>
#include <gnutls_sig.h>
#include <gnutls_state.h>
#include <gnutls_pk.h>
#include <gnutls_x509.h>
#include <gnutls_extra.h>
#include "debug.h"

static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt * certs, uint);
static gnutls_privkey *alloc_and_load_x509_key(gnutls_x509_privkey key);
static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key cert);
static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey key);


/* Copies data from a internal certificate struct (gnutls_cert) to 
 * exported certificate struct (CERTIFICATE_AUTH_INFO)
 */
static
int _gnutls_copy_certificate_auth_info(CERTIFICATE_AUTH_INFO info,
				       gnutls_cert * cert, int ncerts)
{
	/* Copy peer's information to AUTH_INFO
	 */
	int ret, i, j;

	if (ncerts == 0) {
		info->raw_certificate_list = NULL;
		info->ncerts = 0;
		return 0;
	}

	info->raw_certificate_list =
	    gnutls_calloc(1, sizeof(gnutls_datum) * ncerts);
	if (info->raw_certificate_list == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	for (i = 0; i < ncerts; i++) {
		if (cert->raw.size > 0) {
			ret =
			    _gnutls_set_datum(&info->
					      raw_certificate_list[i],
					      cert[i].raw.data,
					      cert[i].raw.size);
			if (ret < 0) {
				gnutls_assert();
				goto clear;
			}
		}
	}
	info->ncerts = ncerts;

	return 0;

      clear:

	for (j = 0; j < i; j++)
		_gnutls_free_datum(&info->raw_certificate_list[j]);

	gnutls_free(info->raw_certificate_list);
	info->raw_certificate_list = NULL;

	return ret;
}




/* returns 0 if the algo_to-check exists in the pk_algos list,
 * -1 otherwise.
 */
inline
static int _gnutls_check_pk_algo_in_list(const gnutls_pk_algorithm *pk_algos, 
	int pk_algos_length, gnutls_pk_algorithm algo_to_check)
{
	int i;
	for (i = 0; i < pk_algos_length; i++) {
		if (algo_to_check == pk_algos[i]) {
			return 0;
		}
	}
	return -1;
}



/* Locates the most appropriate x509 certificate using the
 * given DN. If indx == -1 then no certificate was found.
 */
static int _find_x509_cert(const gnutls_certificate_credentials cred,
			   opaque * _data, size_t _data_size,
			   const gnutls_pk_algorithm * pk_algos,
			   int pk_algos_length, int *indx)
{
	uint size;
	gnutls_datum odn;
	opaque *data = _data;
	ssize_t data_size = _data_size;
	uint i, j;
	int result, cert_pk;

	*indx = -1;

	do {

		DECR_LENGTH_RET(data_size, 2, 0);
		size = _gnutls_read_uint16(data);
		DECR_LENGTH_RET(data_size, size, 0);
		data += 2;

		for (i = 0; i < cred->ncerts; i++) {
			for (j = 0; j < cred->cert_list_length[i]; j++) {
				if ((result =
				     _gnutls_cert_get_dn(&cred->
							 cert_list[i][j],
							 &odn)) < 0) {
					gnutls_assert();
					return result;
				}

				if (odn.size != size)
					continue;

				/* If the DN matches and
				 * the *_SIGN algorithm matches
				 * the cert is our cert!
				 */
				cert_pk =
				    cred->cert_list[i][0].
				    subject_pk_algorithm;

				if ((memcmp(odn.data, data, size) == 0) &&
				    (_gnutls_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 most appropriate openpgp cert
 */
static int _find_openpgp_cert(const gnutls_certificate_credentials cred,
			      gnutls_pk_algorithm * pk_algos,
			      int pk_algos_length, int *indx)
{
	uint i, j;

	*indx = -1;

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

			/* If the *_SIGN algorithm matches
			 * the cert is our cert!
			 */
			if ((_gnutls_check_pk_algo_in_list
			     (pk_algos, pk_algos_length,
			      cred->cert_list[i][0].
			      subject_pk_algorithm) == 0)
			    && (cred->cert_list[i][0].cert_type ==
				GNUTLS_CRT_OPENPGP)) {
				*indx = i;
				break;
			}
		}
		if (*indx != -1)
			break;
	}

	return 0;
}

/* Returns the number of issuers in the server's
 * certificate request packet.
 */
static int get_issuers_num( gnutls_session session, opaque * data, ssize_t data_size)
{
int issuers_dn_len = 0, result;
uint size;

	/* Count the number of the given issuers;
	 * This is used to allocate the issuers_dn without
	 * using realloc().
	 */

	if (gnutls_certificate_type_get(session) != GNUTLS_CRT_X509)
		return 0;

	if (data_size > 0) do {
		/* This works like DECR_LEN() 
		 */
		result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
		DECR_LENGTH_COM(data_size, 2, goto error);
		size = _gnutls_read_uint16(data);

		result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
		DECR_LENGTH_COM(data_size, size, goto error);

		data += 2;

		if (size > 0) {
			issuers_dn_len++;
			data += size;
		}

		if (data_size == 0)
			break;

	} while (1);

	return issuers_dn_len;
	
	error:
		return result;
}

/* Returns the issuers in the server's certificate request
 * packet.
 */
static int get_issuers( gnutls_session session,
	gnutls_datum* issuers_dn, int issuers_len, 
	opaque * data, size_t data_size)
{
int i;
uint size;

	if (gnutls_certificate_type_get(session) != 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 = data;
			issuers_dn[i].size = size;

			data += size;
		}
	}

	return 0;
}


/* Calls the client_cert_callback() to select an index for the
 * certificate to use.
 */
static int call_client_cert_callback(gnutls_session session,
       const gnutls_certificate_credentials cred, gnutls_pk_algorithm * pk_algos,
       int pk_algos_length, gnutls_datum * issuers_dn, uint issuers_dn_len)
{
	uint i, j;
	int indx, result;
	int *ij_map = NULL;
	gnutls_datum *my_certs = NULL;

	if (cred->ncerts != 0) {
		my_certs =
		    gnutls_alloca(cred->ncerts *
				  sizeof(gnutls_datum));
		if (my_certs == NULL) {
			result = GNUTLS_E_MEMORY_ERROR;
			gnutls_assert();
			goto error;
		}


		/* maps j -> i 
		 */
		ij_map = gnutls_alloca(sizeof(int) * cred->ncerts);
		if (ij_map == NULL) {
			result = GNUTLS_E_MEMORY_ERROR;
			gnutls_assert();
			goto error;
		}
	}

	/* put our certificate's issuer and dn into cdn, idn
	 * Note that the certificates we provide to the callback
	 * are not all the certificates we have. Only the certificates
	 * that are requested by the server (certificate type - and sign
	 * algorithm matches), are provided.
	 */
	for (j = i = 0; i < cred->ncerts; i++) {
		if ((cred->cert_list[i][0].cert_type ==
		     gnutls_certificate_type_get(session)) &&
		    (_gnutls_check_pk_algo_in_list(pk_algos,
						   pk_algos_length,
						   cred->
						   cert_list[i][0].
						   subject_pk_algorithm)
		     == 0)) {
			/* Add a certificate ONLY if it is allowed
			 * by the peer.
			 */
			ij_map[j] = i;
			my_certs[j++] = cred->cert_list[i][0].raw;
		}
	}

	indx =
	    session->internals.client_cert_callback(session,
						    my_certs,
						    j,
						    issuers_dn,
						    issuers_dn_len);

	/* the indx returned by the user is relative
	 * to the certificates we provided him.
	 * This will make it relative to the certificates
	 * we've got.
	 */
	if (indx != -1 && cred->ncerts != 0)
		indx = ij_map[indx];
	else
		indx = -1;

	
	result = indx;

      error:
	if (my_certs != NULL) {
		gnutls_afree(my_certs);
	}
	if (ij_map != NULL) {
		gnutls_afree(ij_map);
	}
	return result;

}

OPENPGP_KEY_DEINIT _E_gnutls_openpgp_key_deinit;
OPENPGP_PRIVKEY_DEINIT _E_gnutls_openpgp_privkey_deinit;

/* Calls the client get callback.
 */
static int call_get_cert_callback( gnutls_session session,
	gnutls_datum* issuers_dn, int issuers_dn_length, 
	gnutls_pk_algorithm* pk_algos, int pk_algos_length)
{
uint i;
gnutls_cert *local_certs = NULL;
gnutls_privkey *local_key = NULL;
gnutls_retr_st st;
int ret;
gnutls_certificate_type type =
    gnutls_certificate_type_get(session);
const gnutls_certificate_credentials cred;

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}

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

	if (session->security_parameters.entity == GNUTLS_SERVER) {
		ret =
		    cred->server_get_cert_callback(session, &st);
	} else { /* CLIENT */
		ret =
		    cred->client_get_cert_callback(session,
		    		issuers_dn, issuers_dn_length,
				pk_algos, pk_algos_length,
				&st);
	}

	if (ret < 0) {
		gnutls_assert();
		return GNUTLS_E_INTERNAL_ERROR;
	}
	
	if (type != st.type) {
		gnutls_assert();
		ret = GNUTLS_E_INVALID_REQUEST;
		goto cleanup;
	}

	if (type == GNUTLS_CRT_X509) {
		local_certs = alloc_and_load_x509_certs(st.cert.x509, st.ncerts);
		if (local_certs != NULL)
			local_key = alloc_and_load_x509_key(st.key.x509);

	} else { /* PGP */
		if (st.ncerts != 1) {
			gnutls_assert();
			ret = GNUTLS_E_INVALID_REQUEST;
			goto cleanup;
		}

		local_certs = alloc_and_load_pgp_certs(st.cert.pgp);
		if (local_certs != NULL)
			local_key = alloc_and_load_pgp_key(st.key.pgp);

	}

	_gnutls_selected_certs_set(session, local_certs, (local_certs!=NULL)?st.ncerts:0,
				   local_key, 1);

	ret = 0;

cleanup:

	if (st.type == GNUTLS_CRT_X509) {
		if (st.deinit_all) {
			for (i = 0; i < st.ncerts; i++) {
				gnutls_x509_crt_deinit(st.cert.x509[i]);
			}
			gnutls_free( st.cert.x509);
			gnutls_x509_privkey_deinit(st.key.x509);
		}
	} else {
		if (st.deinit_all) {
			if (_E_gnutls_openpgp_key_deinit == NULL ||
				_E_gnutls_openpgp_privkey_deinit == NULL) {
				gnutls_assert();
				return GNUTLS_E_INIT_LIBEXTRA;
			}

			_E_gnutls_openpgp_key_deinit(st.cert.pgp);
			_E_gnutls_openpgp_privkey_deinit(st.key.pgp);
		}
	}

	return ret;
}

/* 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 value, is returned.
 *
 * 20020128: added ability to select a certificate depending on the SIGN
 * algorithm (only in automatic mode).
 */
static int _select_client_cert(gnutls_session session,
			       opaque * _data, size_t _data_size,
			       gnutls_pk_algorithm * pk_algos,
			       int pk_algos_length)
{
	int result;
	int indx = -1;
	const gnutls_certificate_credentials cred;
	opaque *data = _data;
	ssize_t data_size = _data_size;
	int issuers_dn_length;
	gnutls_datum * issuers_dn = NULL;

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}

	if (cred->client_get_cert_callback != NULL ||
		session->internals.client_cert_callback != NULL) {

		/* use a callback to get certificate 
		 */
		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)*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;
			}
		}

		if (cred->client_get_cert_callback) {
			result = call_get_cert_callback( session, issuers_dn, issuers_dn_length,
				pk_algos, pk_algos_length);
			goto cleanup;
		}

		/* in case of the callback that returns an index:
		 */
		indx = call_client_cert_callback(session, cred, pk_algos, 
			pk_algos_length, issuers_dn, issuers_dn_length);

	} else {
		/* If we have no callbacks, try to guess.
		 */
		result = 0;

		if (session->security_parameters.cert_type ==
		    GNUTLS_CRT_X509)
			result =
			    _find_x509_cert(cred, _data, _data_size,
					    pk_algos, pk_algos_length,
					    &indx);

		if (session->security_parameters.cert_type ==
		    GNUTLS_CRT_OPENPGP)
			result =
			    _find_openpgp_cert(cred, pk_algos,
					       pk_algos_length, &indx);


		if (result < 0) {
			gnutls_assert();
			return result;
		}
	}

	if (indx >= 0) {
		_gnutls_selected_certs_set(session,
					   &cred->cert_list[indx][0],
					   cred->cert_list_length[indx],
					   &cred->pkey[indx], 0);
	} else {
		_gnutls_selected_certs_set(session, NULL, 0, NULL, 0);
	}

	result = 0;

cleanup:
	gnutls_free( issuers_dn);
	return result;

}

/* Generate client certificate
 */

int _gnutls_gen_x509_crt(gnutls_session session, opaque ** data)
{
	int ret, i;
	opaque *pdata;
	gnutls_cert *apr_cert_list;
	gnutls_privkey *apr_pkey;
	int apr_cert_list_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].raw.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 )
	 */

	(*data) = gnutls_malloc(ret);
	pdata = (*data);

	if (pdata == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}
	_gnutls_write_uint24(ret - 3, pdata);
	pdata += 3;
	for (i = 0; i < apr_cert_list_length; i++) {
		_gnutls_write_datum24(pdata, apr_cert_list[i].raw);
		pdata += (3 + apr_cert_list[i].raw.size);
	}

	return ret;
}

enum PGPKeyDescriptorType { PGP_KEY_FINGERPRINT, PGP_KEY };

int _gnutls_gen_openpgp_certificate(gnutls_session session, opaque ** data)
{
	int ret;
	opaque *pdata;
	gnutls_cert *apr_cert_list;
	gnutls_privkey *apr_pkey;
	int apr_cert_list_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 + 1 + 3;

	if (apr_cert_list_length > 0)
		ret += apr_cert_list[0].raw.size;

	(*data) = gnutls_malloc(ret);
	pdata = (*data);

	if (pdata == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	_gnutls_write_uint24(ret - 3, pdata);
	pdata += 3;

	*pdata = PGP_KEY;	/* whole key */
	pdata++;

	if (apr_cert_list_length > 0) {
		_gnutls_write_datum24(pdata, apr_cert_list[0].raw);
		pdata += (3 + apr_cert_list[0].raw.size);
	} else			/* empty - no certificate */
		_gnutls_write_uint24(0, pdata);

	return ret;
}

OPENPGP_FINGERPRINT _E_gnutls_openpgp_fingerprint = NULL;
OPENPGP_KEY_REQUEST _E_gnutls_openpgp_request_key = NULL;
extern OPENPGP_RAW_KEY_TO_GCERT _E_gnutls_openpgp_raw_key_to_gcert;

int _gnutls_gen_openpgp_certificate_fpr(gnutls_session session,
					opaque ** data)
{
	int ret, packet_size;
	size_t fpr_size;
	opaque *pdata;
	gnutls_cert *apr_cert_list;
	gnutls_privkey *apr_pkey;
	int apr_cert_list_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;
	}

	packet_size = 3 + 1;

	/* Only v4 fingerprints are sent 
	 */
	if (apr_cert_list_length > 0 && apr_cert_list[0].version == 4)
		packet_size += 20 + 1;
	else			/* empty certificate case */
		return _gnutls_gen_openpgp_certificate(session, data);

	(*data) = gnutls_malloc(packet_size);
	pdata = (*data);

	if (pdata == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	_gnutls_write_uint24(packet_size - 3, pdata);
	pdata += 3;

	*pdata = PGP_KEY_FINGERPRINT;	/* key fingerprint */
	pdata++;

	*pdata = 20;
	pdata++;

	fpr_size = 20;

	if (_E_gnutls_openpgp_fingerprint == NULL) {
		gnutls_assert();
		return GNUTLS_E_INIT_LIBEXTRA;
	}

	if ((ret =
	     _E_gnutls_openpgp_fingerprint(&apr_cert_list[0].raw, pdata,
					   &fpr_size)) < 0) {
		gnutls_assert();
		return ret;
	}

	return packet_size;
}



int _gnutls_gen_cert_client_certificate(gnutls_session session,
					opaque ** data)
{
	switch (session->security_parameters.cert_type) {
	case GNUTLS_CRT_OPENPGP:
		if (_gnutls_openpgp_send_fingerprint(session) == 0)
			return
			    _gnutls_gen_openpgp_certificate(session, data);
		else
			return
			    _gnutls_gen_openpgp_certificate_fpr
			    (session, data);

	case GNUTLS_CRT_X509:
		return _gnutls_gen_x509_crt(session, data);

	default:
		gnutls_assert();
		return GNUTLS_E_INTERNAL_ERROR;
	}
}

int _gnutls_gen_cert_server_certificate(gnutls_session session,
					opaque ** data)
{
	switch (session->security_parameters.cert_type) {
	case GNUTLS_CRT_OPENPGP:
		return _gnutls_gen_openpgp_certificate(session, data);
	case GNUTLS_CRT_X509:
		return _gnutls_gen_x509_crt(session, data);
	default:
		gnutls_assert();
		return GNUTLS_E_INTERNAL_ERROR;
	}
}

/* Process server certificate
 */

#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_gcert_deinit(&peer_certificate_list[x])
int _gnutls_proc_x509_server_certificate(gnutls_session session,
					 opaque * data, size_t data_size)
{
	int size, len, ret;
	opaque *p = data;
	CERTIFICATE_AUTH_INFO info;
	const gnutls_certificate_credentials cred;
	ssize_t dsize = data_size;
	int i, j, x;
	gnutls_cert *peer_certificate_list;
	int peer_certificate_list_size = 0;
	gnutls_datum tmp;

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}


	if ((ret =
	     _gnutls_auth_info_set(session, GNUTLS_CRD_CERTIFICATE,
				   sizeof(CERTIFICATE_AUTH_INFO_INT), 1)) <
	    0) {
		gnutls_assert();
		return ret;
	}

	info = _gnutls_get_auth_info(session);

	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;

	if (size == 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 (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_malloc(sizeof(gnutls_cert) *
			  (peer_certificate_list_size));

	if (peer_certificate_list == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}
	memset(peer_certificate_list, 0, sizeof(gnutls_cert) *
	       peer_certificate_list_size);

	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;

		if ((ret =
		     _gnutls_x509_raw_cert_to_gcert(&peer_certificate_list
						   [j], &tmp,
						   CERT_ONLY_EXTENSIONS)) <
		    0) {
			gnutls_assert();
			goto cleanup;
		}

		p += len;
	}


	if ((ret =
	     _gnutls_copy_certificate_auth_info(info,
						peer_certificate_list,
						peer_certificate_list_size))
	    < 0) {
		gnutls_assert();
		goto cleanup;
	}

	if ((ret =
	     _gnutls_check_key_usage(&peer_certificate_list[0],
				     gnutls_kx_get(session))) < 0) {
		gnutls_assert();
		goto cleanup;
	}

	ret = 0;

      cleanup:
	CLEAR_CERTS;
	gnutls_free(peer_certificate_list);
	return ret;

}

#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_gcert_deinit(&peer_certificate_list[x])
int _gnutls_proc_openpgp_server_certificate(gnutls_session session,
					    opaque * data,
					    size_t data_size)
{
	int size, ret, len;
	opaque *p = data;
	CERTIFICATE_AUTH_INFO info;
	const gnutls_certificate_credentials cred;
	ssize_t dsize = data_size;
	int i, x;
	gnutls_cert *peer_certificate_list = NULL;
	int peer_certificate_list_size = 0;
	gnutls_datum tmp, akey = { NULL, 0 };

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}

	if ((ret =
	     _gnutls_auth_info_set(session, GNUTLS_CRD_CERTIFICATE,
				   sizeof(CERTIFICATE_AUTH_INFO_INT), 1)) <
	    0) {
		gnutls_assert();
		return ret;
	}

	info = _gnutls_get_auth_info(session);

	if (data == NULL || data_size == 0) {
		gnutls_assert();
		return GNUTLS_E_NO_CERTIFICATE_FOUND;
	}

	DECR_LEN(dsize, 3);
	size = _gnutls_read_uint24(p);
	p += 3;

	if (size == 0) {
		gnutls_assert();
		/* no certificate was sent */
		return GNUTLS_E_NO_CERTIFICATE_FOUND;
	}
	i = dsize;

	/* Read PGPKeyDescriptor */
	DECR_LEN(dsize, 1);
	if (*p == PGP_KEY_FINGERPRINT) {	/* the fingerprint */
		p++;

		DECR_LEN(dsize, 1);
		len = (uint8) * p;
		p++;

		if (len != 20) {
			gnutls_assert();
			return GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED;
		}

		DECR_LEN(dsize, 20);

		/* request the actual key from our database, or
		 * a key server or anything.
		 */
		if (_E_gnutls_openpgp_request_key == NULL) {
			gnutls_assert();
			return GNUTLS_E_INIT_LIBEXTRA;
		}
		if ((ret =
		     _E_gnutls_openpgp_request_key(session, &akey, cred, p,
						   20)) < 0) {
			gnutls_assert();
			return ret;
		}
		tmp = akey;
		peer_certificate_list_size++;

	} else if (*p == PGP_KEY) {	/* the whole key */

		p++;

		/* Read the actual certificate */
		DECR_LEN(dsize, 3);
		len = _gnutls_read_uint24(p);
		p += 3;

		if (len == 0) {
			gnutls_assert();
			/* no certificate was sent */
			return GNUTLS_E_NO_CERTIFICATE_FOUND;
		}

		DECR_LEN(dsize, len);
		peer_certificate_list_size++;

		tmp.size = len;
		tmp.data = p;

	} else {
		gnutls_assert();
		return GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE;
	}

	/* ok we now have the peer's key in tmp datum
	 */

	if (peer_certificate_list_size == 0) {
		gnutls_assert();
		return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
	}

	peer_certificate_list =
	    gnutls_alloca(sizeof(gnutls_cert) *
			  (peer_certificate_list_size));
	if (peer_certificate_list == NULL) {
		gnutls_assert();
		ret = GNUTLS_E_MEMORY_ERROR;
		goto cleanup;
	}
	memset(peer_certificate_list, 0, sizeof(gnutls_cert) *
	       peer_certificate_list_size);

	if (_E_gnutls_openpgp_raw_key_to_gcert == NULL) {
		gnutls_assert();
		ret = GNUTLS_E_INIT_LIBEXTRA;
		goto cleanup;
	}

	if ((ret =
	     _E_gnutls_openpgp_raw_key_to_gcert(&peer_certificate_list[0],
						&tmp)) < 0) {
		gnutls_assert();
		goto cleanup;
	}

	if ((ret =
	     _gnutls_copy_certificate_auth_info(info,
						peer_certificate_list,
						peer_certificate_list_size))
	    < 0) {
		gnutls_assert();
		goto cleanup;
	}

	if ((ret =
	     _gnutls_check_key_usage(&peer_certificate_list[0],
				     gnutls_kx_get(session))) < 0) {
		gnutls_assert();
		goto cleanup;
	}

	ret = 0;

      cleanup:

	_gnutls_free_datum(&akey);
	CLEAR_CERTS;
	gnutls_afree(peer_certificate_list);
	return ret;

}

int _gnutls_proc_cert_server_certificate(gnutls_session session,
					 opaque * data, size_t data_size)
{
	switch (session->security_parameters.cert_type) {
	case GNUTLS_CRT_OPENPGP:
		return _gnutls_proc_openpgp_server_certificate(session,
							       data,
							       data_size);
	case GNUTLS_CRT_X509:
		return _gnutls_proc_x509_server_certificate(session, data,
							    data_size);
	default:
		gnutls_assert();
		return GNUTLS_E_INTERNAL_ERROR;
	}
}

#define MAX_SIGN_ALGOS 2
typedef enum CertificateSigType { RSA_SIGN = 1, DSA_SIGN
} CertificateSigType;

/* Checks if we support the given signature algorithm 
 * (RSA or DSA). Returns the corresponding gnutls_pk_algorithm
 * if true;
 */
inline static
int _gnutls_check_supported_sign_algo(CertificateSigType algo)
{
	switch (algo) {
	case RSA_SIGN:
		return GNUTLS_PK_RSA;
	case DSA_SIGN:
		return GNUTLS_PK_DSA;
	}

	return -1;
}

int _gnutls_proc_cert_cert_req(gnutls_session session, opaque * data,
			       size_t data_size)
{
	int size, ret;
	opaque *p = data;
	const gnutls_certificate_credentials cred;
	CERTIFICATE_AUTH_INFO info;
	ssize_t dsize = data_size;
	int i, j;
	gnutls_pk_algorithm pk_algos[MAX_SIGN_ALGOS];
	int pk_algos_length;

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}

	if ((ret =
	     _gnutls_auth_info_set(session, GNUTLS_CRD_CERTIFICATE,
				   sizeof(CERTIFICATE_AUTH_INFO_INT), 0)) <
	    0) {
		gnutls_assert();
		return ret;
	}

	info = _gnutls_get_auth_info(session);

	DECR_LEN(dsize, 1);
	size = p[0];
	p++;
	/* check if the sign algorithm is supported.
	 */
	pk_algos_length = j = 0;
	for (i = 0; i < size; i++, p++) {
		DECR_LEN(dsize, 1);
		if ((ret = _gnutls_check_supported_sign_algo(*p)) > 0) {
			if (j < MAX_SIGN_ALGOS) {
				pk_algos[j++] = ret;
				pk_algos_length++;
			}
		}
	}

	if (pk_algos_length == 0) {
		gnutls_assert();
		return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
	}

	if (session->security_parameters.cert_type == GNUTLS_CRT_X509) {
		DECR_LEN(dsize, 2);
		size = _gnutls_read_uint16(p);
		p += 2;
	} else {
		p = NULL;
		size = 0;
	}

	DECR_LEN(dsize, size);

	/* now we ask the user to tell which one
	 * he wants to use.
	 */
	if ((ret =
	     _select_client_cert(session, p, size,
				 pk_algos, pk_algos_length)) < 0) {
		gnutls_assert();
		return ret;
	}

	/* We should reply with a certificate message, 
	 * even if we have no certificate to send.
	 */
	session->key->certificate_requested = 1;

	return 0;
}

int _gnutls_gen_cert_client_cert_vrfy(gnutls_session session,
				      opaque ** data)
{
	int ret;
	gnutls_cert *apr_cert_list;
	gnutls_privkey *apr_pkey;
	int apr_cert_list_length, size;
	gnutls_datum signature;

	*data = NULL;

	/* 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;
	}

	if (apr_pkey != NULL) {
		if ((ret =
		     _gnutls_tls_sign_hdata(session,
					    &apr_cert_list[0],
					    apr_pkey, &signature)) < 0) {
			gnutls_assert();
			return ret;
		}
	} else {
		gnutls_assert();
		return 0;
	}

	*data = gnutls_malloc(signature.size + 2);
	if (*data == NULL) {
		_gnutls_free_datum(&signature);
		return GNUTLS_E_MEMORY_ERROR;
	}
	size = signature.size;
	_gnutls_write_uint16(size, *data);

	memcpy(&(*data)[2], signature.data, size);

	_gnutls_free_datum(&signature);

	return size + 2;
}

int _gnutls_proc_cert_client_cert_vrfy(gnutls_session session,
				       opaque * data, size_t data_size)
{
	int size, ret;
	ssize_t dsize = data_size;
	opaque *pdata = data;
	gnutls_datum sig;
	CERTIFICATE_AUTH_INFO info = _gnutls_get_auth_info(session);
	gnutls_cert peer_cert;

	if (info == NULL || info->ncerts == 0) {
		gnutls_assert();
		/* we need this in order to get peer's certificate */
		return GNUTLS_E_INTERNAL_ERROR;
	}

	DECR_LEN(dsize, 2);
	size = _gnutls_read_uint16(pdata);
	pdata += 2;

	DECR_LEN(dsize, size);

	sig.data = pdata;
	sig.size = size;

	ret = _gnutls_raw_cert_to_gcert( &peer_cert,
		session->security_parameters.cert_type,
		&info->raw_certificate_list[0], CERT_NO_COPY);

	if (ret < 0) {
		gnutls_assert();
		return ret;
	}

	if ((ret =
	     _gnutls_verify_sig_hdata(session, &peer_cert, &sig)) < 0) {
		gnutls_assert();
		_gnutls_gcert_deinit(&peer_cert);
		return ret;
	}
	_gnutls_gcert_deinit(&peer_cert);

	return 0;
}

#define CERTTYPE_SIZE 3
int _gnutls_gen_cert_server_cert_req(gnutls_session session,
				     opaque ** data)
{
	const gnutls_certificate_credentials cred;
	int size;
	opaque *pdata;

	/* Now we need to generate the RDN sequence. This is
	 * already in the CERTIFICATE_CRED structure, to improve
	 * performance.
	 */

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}

	size = CERTTYPE_SIZE + 2;	/* 2 for gnutls_certificate_type + 2 for size of rdn_seq 
					 */

	if (session->security_parameters.cert_type == GNUTLS_CRT_X509 &&
	    session->internals.ignore_rdn_sequence == 0)
		size += cred->x509_rdn_sequence.size;

	(*data) = gnutls_malloc(size);
	pdata = (*data);

	if (pdata == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	pdata[0] = CERTTYPE_SIZE - 1;

	pdata[1] = RSA_SIGN;
	pdata[2] = DSA_SIGN;	/* only these for now */
	pdata += CERTTYPE_SIZE;

	if (session->security_parameters.cert_type == GNUTLS_CRT_X509 &&
	    session->internals.ignore_rdn_sequence == 0) {
		_gnutls_write_datum16(pdata, cred->x509_rdn_sequence);
		/* pdata += cred->x509_rdn_sequence.size + 2; */
	}

	return size;
}


/* This function will return the appropriate certificate to use. 
 * Fills in the apr_cert_list, apr_cert_list_length and apr_pkey.
 * The return value is a negative value on error.
 *
 * It is normal to return 0 with no certificates in client side.
 *
 */
int _gnutls_get_selected_cert(gnutls_session session,
			      gnutls_cert ** apr_cert_list,
			      int *apr_cert_list_length,
			      gnutls_privkey ** apr_pkey)
{
	if (session->security_parameters.entity == GNUTLS_SERVER) {

		/* select_client_cert() has been called before.
		 */

		*apr_cert_list = session->internals.selected_cert_list;
		*apr_pkey = session->internals.selected_key;
		*apr_cert_list_length =
		    session->internals.selected_cert_list_length;

		if (apr_cert_list_length == 0 || apr_pkey == NULL ||
		    apr_cert_list == NULL) {
			gnutls_assert();
			return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
		}

	} else {		/* CLIENT SIDE 
				 */

		/* we have already decided which certificate
		 * to send.
		 */
		*apr_cert_list = session->internals.selected_cert_list;
		*apr_cert_list_length =
		    session->internals.selected_cert_list_length;
		*apr_pkey = session->internals.selected_key;

	}

	return 0;
}

/* converts the given x509 certificate to gnutls_cert* and allocates
 * space for them.
 */
static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt * certs,
					 uint ncerts)
{
	gnutls_cert *local_certs;
	int ret = 0;
	uint i, j;

	local_certs = gnutls_malloc(sizeof(gnutls_cert) * ncerts);
	if (local_certs == NULL) {
		gnutls_assert();
		return NULL;
	}

	for (i = 0; i < ncerts; i++) {
		ret = _gnutls_x509_crt_to_gcert(&local_certs[i], 
			certs[i], 0);
		if (ret < 0)
			break;
	}

	if (ret < 0) {
		gnutls_assert();
		for (j = 0; j < i; j++) {
			_gnutls_gcert_deinit(&local_certs[j]);
		}
		gnutls_free(local_certs);
		return NULL;
	}

	return local_certs;
}

/* converts the given x509 key to gnutls_privkey* and allocates
 * space for it.
 */
static gnutls_privkey *alloc_and_load_x509_key(gnutls_x509_privkey key)
{
	gnutls_privkey *local_key;
	int ret = 0;

	local_key = gnutls_malloc(sizeof(gnutls_privkey));
	if (local_key == NULL) {
		gnutls_assert();
		return NULL;
	}

	ret =
	    _gnutls_x509_privkey_to_gkey(local_key, key);
	if (ret < 0) {
		gnutls_assert();
		return NULL;
	}

	return local_key;
}


OPENPGP_KEY_TO_GCERT _E_gnutls_openpgp_key_to_gcert;
OPENPGP_PRIVKEY_TO_GKEY _E_gnutls_openpgp_privkey_to_gkey;

/* converts the given pgp certificate to gnutls_cert* and allocates
 * space for them.
 */
static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key cert)
{
	gnutls_cert *local_certs;
	int ret = 0;
	uint i, j;

	local_certs = gnutls_malloc(sizeof(gnutls_cert));
	if (local_certs == NULL) {
		gnutls_assert();
		return NULL;
	}

	if (_E_gnutls_openpgp_key_to_gcert==NULL) {
		gnutls_assert();
		return NULL;
	}

	ret = _E_gnutls_openpgp_key_to_gcert(&local_certs[i], cert);
	if (ret < 0) {
		gnutls_assert();
		return NULL;
	}

	if (ret < 0) {
		gnutls_assert();
		for (j = 0; j < i; j++) {
			_gnutls_gcert_deinit(&local_certs[j]);
		}
		gnutls_free(local_certs);
		return NULL;
	}

	return local_certs;
}

/* converts the given raw key to gnutls_privkey* and allocates
 * space for it.
 */
static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey key)
{
	gnutls_privkey *local_key;
	int ret = 0;

	local_key = gnutls_malloc(sizeof(gnutls_privkey));
	if (local_key == NULL) {
		gnutls_assert();
		return NULL;
	}

	if (_E_gnutls_openpgp_privkey_to_gkey==NULL) {
		gnutls_assert();
		return NULL;
	}

	ret =
	    _E_gnutls_openpgp_privkey_to_gkey(local_key, key);
	if (ret < 0) {
		gnutls_assert();
		return NULL;
	}

	return local_key;
}


void _gnutls_selected_certs_deinit(gnutls_session session)
{
	if (session->internals.selected_need_free != 0) {
		int i;

		for (i = 0;
		     i < session->internals.selected_cert_list_length;
		     i++) {
			_gnutls_gcert_deinit(&session->internals.
					    selected_cert_list[i]);
		}
		session->internals.selected_cert_list = NULL;
		session->internals.selected_cert_list_length = 0;

		_gnutls_gkey_deinit(session->internals.selected_key);
	}

	return;
}

void _gnutls_selected_certs_set(gnutls_session session,
				gnutls_cert * certs, int ncerts,
				gnutls_privkey * key, int need_free)
{
	_gnutls_selected_certs_deinit(session);

	session->internals.selected_cert_list = certs;
	session->internals.selected_cert_list_length = ncerts;
	session->internals.selected_key = key;
	session->internals.selected_need_free = need_free;

}


/* finds the most appropriate certificate in the cert list.
 * The 'appropriate' is defined by the user.
 *
 * requested_algo holds the parameters required by the peer (RSA, DSA
 * or -1 for any).
 *
 * Returns 0 on success and a negative value on error. The
 * selected certificate will be in session->internals.selected_*.
 *
 */
int _gnutls_server_select_cert(gnutls_session session,
			       gnutls_pk_algorithm requested_algo)
{
	uint i, j;
	int index, ret;
	const gnutls_certificate_credentials cred;
	int my_certs_length;

	cred =
	    _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
	if (cred == NULL) {
		gnutls_assert();
		return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
	}

	ret = 0;
	index = -1;		/* default is use no certificate */

	for (i = 0; i < cred->ncerts; i++) {
		/* find one compatible certificate 
		 */
		if (requested_algo == (gnutls_pk_algorithm) - 1 ||
		    requested_algo ==
		    cred->cert_list[i][0].subject_pk_algorithm) {
			/* if cert type matches */
			if (session->security_parameters.cert_type ==
			    cred->cert_list[i][0].cert_type) {
				index = i;
				break;
			}
		}

	}

	/* If the callback which retrieves certificate has been
	 * set use it.
	 */
	if (cred->server_get_cert_callback != NULL) {

		return call_get_cert_callback( session, NULL, 0, NULL, 0);

	} else if (session->internals.server_cert_callback != NULL
		   && cred->ncerts > 0) {
		/* use the callback to get certificate 
		 */
		gnutls_datum *my_certs;
		int *ij_map;

		my_certs_length = cred->ncerts;
		my_certs =
		    gnutls_malloc(my_certs_length * sizeof(gnutls_datum));
		if (my_certs == NULL) {
			ret = GNUTLS_E_MEMORY_ERROR;
			goto out;
		}

		/* put our certificate's issuer and dn into cdn, idn
		 */
		ij_map = gnutls_malloc(my_certs_length * sizeof(int));
		if (ij_map == NULL) {
			ret = GNUTLS_E_MEMORY_ERROR;
			goto cleanup_certs;
		}

		j = 0;
		for (i = 0; i < cred->ncerts; i++) {
			/* Add compatible certificates */
			if (requested_algo == (gnutls_pk_algorithm) - 1 ||
			    requested_algo ==
			    cred->cert_list[i][0].subject_pk_algorithm) {

				/* if cert type matches */
				if (session->security_parameters.
				    cert_type ==
				    cred->cert_list[i][0].cert_type) {

					ij_map[j] = i;
					my_certs[j++] =
					    cred->cert_list[i][0].raw;
				}
			}
		}
		my_certs_length = j;

		index =
		    session->internals.server_cert_callback(session,
							    my_certs,
							    my_certs_length);

		if (index != -1)
			index = ij_map[index];
		ret = 0;

		gnutls_free(ij_map);
	      cleanup_certs:
		gnutls_free(my_certs);

	}

      out:
	/* store the index for future use, in the handshake.
	 * (This will allow not calling this callback again.)
	 */
	if (index >= 0 && ret == 0) {
		_gnutls_selected_certs_set(session,
					   &cred->cert_list[index][0],
					   cred->cert_list_length[index],
					   &cred->pkey[index], 0);
	}

	return ret;
}