lib/auth/cert.c

   1 /*
   2  * Copyright (C) 2001-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * The GnuTLS is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 /* The certificate authentication functions which are needed in the handshake,
  24  * and are common to RSA and DHE key exchange, are in this file.
  25  */
  26
  27 #include <gnutls_int.h>
  28 #include "gnutls_auth.h"
  29 #include "gnutls_errors.h"
  30 #include <auth/cert.h>
  31 #include "gnutls_dh.h"
  32 #include "gnutls_num.h"
  33 #include "libtasn1.h"
  34 #include "gnutls_datum.h"
  35 #include "ext/signature.h"
  36 #include <gnutls_pk.h>
  37 #include <algorithms.h>
  38 #include <gnutls_global.h>
  39 #include <gnutls_record.h>
  40 #include <gnutls_sig.h>
  41 #include <gnutls_state.h>
  42 #include <gnutls_pk.h>
  43 #include <gnutls_x509.h>
  44 #include <gnutls/abstract.h>
  45 #include "debug.h"
  46
  47 #ifdef ENABLE_OPENPGP
  48 #include "openpgp/gnutls_openpgp.h"
  49
  50 static gnutls_privkey_t alloc_and_load_pgp_key (const gnutls_openpgp_privkey_t
  51                                                 key, int deinit);
  52 static gnutls_pcert_st *alloc_and_load_pgp_certs (gnutls_openpgp_crt_t cert);
  53
  54 #endif
  55
  56 static gnutls_pcert_st *alloc_and_load_x509_certs (gnutls_x509_crt_t * certs,
  57                                                    unsigned);
  58 static gnutls_privkey_t alloc_and_load_x509_key (gnutls_x509_privkey_t key,
  59                                                  int deinit);
  60
  61 #ifdef ENABLE_PKCS11
  62 static gnutls_privkey_t alloc_and_load_pkcs11_key (gnutls_pkcs11_privkey_t
  63                                                    key, int deinit);
  64 #endif
  65
  66 #define MAX_CLIENT_SIGN_ALGOS 3
  67 #define CERTTYPE_SIZE (MAX_CLIENT_SIGN_ALGOS+1)
  68 typedef enum CertificateSigType
  69 { RSA_SIGN = 1, DSA_SIGN = 2, ECDSA_SIGN = 64
  70 } CertificateSigType;
  71
  72 /* Copies data from a internal certificate struct (gnutls_pcert_st) to
  73  * exported certificate struct (cert_auth_info_t)
  74  */
  75 static int
  76 _gnutls_copy_certificate_auth_info (cert_auth_info_t info, gnutls_pcert_st * certs, size_t ncerts, int subkey_used,     /* openpgp only */
  77                                     void *keyid)
  78 {
  79   /* Copy peer's information to auth_info_t
  80    */
  81   int ret;
  82   size_t i, j;
  83
  84   if (info->raw_certificate_list != NULL)
  85     {
  86       for (j = 0; j < info->ncerts; j++)
  87         _gnutls_free_datum (&info->raw_certificate_list[j]);
  88       gnutls_free (info->raw_certificate_list);
  89     }
  90
  91   if (ncerts == 0)
  92     {
  93       info->raw_certificate_list = NULL;
  94       info->ncerts = 0;
  95       return 0;
  96     }
  97
  98   info->raw_certificate_list =
  99     gnutls_calloc (ncerts, sizeof (gnutls_datum_t));
 100   if (info->raw_certificate_list == NULL)
 101     {
 102       gnutls_assert ();
 103       return GNUTLS_E_MEMORY_ERROR;
 104     }
 105
 106   for (i = 0; i < ncerts; i++)
 107     {
 108       if (certs[i].cert.size > 0)
 109         {
 110           ret =
 111             _gnutls_set_datum (&info->raw_certificate_list[i],
 112                                certs[i].cert.data, certs[i].cert.size);
 113           if (ret < 0)
 114             {
 115               gnutls_assert ();
 116               goto clear;
 117             }
 118         }
 119     }
 120   info->ncerts = ncerts;
 121   info->cert_type = certs[0].type;
 122
 123 #ifdef ENABLE_OPENPGP
 124   if (certs[0].type == GNUTLS_CRT_OPENPGP)
 125     {
 126       info->use_subkey = subkey_used;
 127       if (keyid)
 128         memcpy (info->subkey_id, keyid, GNUTLS_OPENPGP_KEYID_SIZE);
 129     }
 130 #endif
 131
 132   return 0;
 133
 134 clear:
 135
 136   for (j = 0; j < i; j++)
 137     _gnutls_free_datum (&info->raw_certificate_list[j]);
 138
 139   gnutls_free (info->raw_certificate_list);
 140   info->raw_certificate_list = NULL;
 141
 142   return ret;
 143 }
 144
 145
 146
 147
 148 /* returns 0 if the algo_to-check exists in the pk_algos list,
 149  * -1 otherwise.
 150  */
 151 inline static int
 152 _gnutls_check_pk_algo_in_list (const gnutls_pk_algorithm_t *
 153                                pk_algos, int pk_algos_length,
 154                                gnutls_pk_algorithm_t algo_to_check)
 155 {
 156   int i;
 157   for (i = 0; i < pk_algos_length; i++)
 158     {
 159       if (algo_to_check == pk_algos[i])
 160         {
 161           return 0;
 162         }
 163     }
 164   return -1;
 165 }
 166
 167
 168 /* Returns the issuer's Distinguished name in odn, of the certificate
 169  * specified in cert.
 170  */
 171 static int
 172 _gnutls_cert_get_issuer_dn (gnutls_pcert_st * cert, gnutls_datum_t * odn)
 173 {
 174   ASN1_TYPE dn;
 175   int len, result;
 176   int start, end;
 177
 178   if ((result = asn1_create_element
 179        (_gnutls_get_pkix (), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS)
 180     {
 181       gnutls_assert ();
 182       return _gnutls_asn2err (result);
 183     }
 184
 185   result = asn1_der_decoding (&dn, cert->cert.data, cert->cert.size, NULL);
 186   if (result != ASN1_SUCCESS)
 187     {
 188       /* couldn't decode DER */
 189       gnutls_assert ();
 190       asn1_delete_structure (&dn);
 191       return _gnutls_asn2err (result);
 192     }
 193
 194   result = asn1_der_decoding_startEnd (dn, cert->cert.data, cert->cert.size,
 195                                        "tbsCertificate.issuer", &start, &end);
 196
 197   if (result != ASN1_SUCCESS)
 198     {
 199       /* couldn't decode DER */
 200       gnutls_assert ();
 201       asn1_delete_structure (&dn);
 202       return _gnutls_asn2err (result);
 203     }
 204   asn1_delete_structure (&dn);
 205
 206   len = end - start + 1;
 207
 208   odn->size = len;
 209   odn->data = &cert->cert.data[start];
 210
 211   return 0;
 212 }
 213
 214
 215 /* Locates the most appropriate x509 certificate using the
 216  * given DN. If indx == -1 then no certificate was found.
 217  *
 218  * That is to guess which certificate to use, based on the
 219  * CAs and sign algorithms supported by the peer server.
 220  */
 221 static int
 222 _find_x509_cert (const gnutls_certificate_credentials_t cred,
 223                  uint8_t * _data, size_t _data_size,
 224                  const gnutls_pk_algorithm_t * pk_algos,
 225                  int pk_algos_length, int *indx)
 226 {
 227   unsigned size;
 228   gnutls_datum_t odn = { NULL, 0 };
 229   uint8_t *data = _data;
 230   ssize_t data_size = _data_size;
 231   unsigned i, j;
 232   int result, cert_pk;
 233
 234   *indx = -1;
 235
 236   /* If peer doesn't send any issuers and we have a single certificate
 237    * then send that one.
 238    */
 239   if (data_size == 0 && cred->ncerts == 1)
 240     {
 241       *indx = 0;
 242       return 0;
 243     }
 244
 245   do
 246     {
 247       DECR_LENGTH_RET (data_size, 2, 0);
 248       size = _gnutls_read_uint16 (data);
 249       DECR_LENGTH_RET (data_size, size, 0);
 250       data += 2;
 251
 252       for (i = 0; i < cred->ncerts; i++)
 253         {
 254           for (j = 0; j < cred->certs[i].cert_list_length; j++)
 255             {
 256               if ((result =
 257                    _gnutls_cert_get_issuer_dn (&cred->certs[i].cert_list[j],
 258                                                &odn)) < 0)
 259                 {
 260                   gnutls_assert ();
 261                   return result;
 262                 }
 263
 264               if (odn.size != size)
 265                 continue;
 266
 267               /* If the DN matches and
 268                * the *_SIGN algorithm matches
 269                * the cert is our cert!
 270                */
 271               cert_pk =
 272                 gnutls_pubkey_get_pk_algorithm (cred->certs[i].cert_list[0].pubkey,
 273                                                 NULL);
 274
 275               if ((memcmp (odn.data, data, size) == 0) &&
 276                   (_gnutls_check_pk_algo_in_list
 277                    (pk_algos, pk_algos_length, cert_pk) == 0))
 278                 {
 279                   *indx = i;
 280                   break;
 281                 }
 282             }
 283           if (*indx != -1)
 284             break;
 285         }
 286
 287       if (*indx != -1)
 288         break;
 289
 290       /* move to next record */
 291       data += size;
 292     }
 293   while (1);
 294
 295   return 0;
 296
 297 }
 298
 299 #ifdef ENABLE_OPENPGP
 300 /* Locates the most appropriate openpgp cert
 301  */
 302 static int
 303 _find_openpgp_cert (const gnutls_certificate_credentials_t cred,
 304                     gnutls_pk_algorithm_t * pk_algos,
 305                     int pk_algos_length, int *indx)
 306 {
 307   unsigned i, j;
 308
 309   *indx = -1;
 310
 311   for (i = 0; i < cred->ncerts; i++)
 312     {
 313       for (j = 0; j < cred->certs[i].cert_list_length; j++)
 314         {
 315
 316           /* If the *_SIGN algorithm matches
 317            * the cert is our cert!
 318            */
 319           if ((_gnutls_check_pk_algo_in_list
 320                (pk_algos, pk_algos_length,
 321                 gnutls_pubkey_get_pk_algorithm (cred->certs[i].cert_list[0].pubkey,
 322                                                 NULL)) == 0)
 323               && (cred->certs[i].cert_list[0].type == GNUTLS_CRT_OPENPGP))
 324             {
 325               *indx = i;
 326               break;
 327             }
 328         }
 329       if (*indx != -1)
 330         break;
 331     }
 332
 333   return 0;
 334 }
 335 #endif
 336
 337 /* Returns the number of issuers in the server's
 338  * certificate request packet.
 339  */
 340 static int
 341 get_issuers_num (gnutls_session_t session, uint8_t * data, ssize_t data_size)
 342 {
 343   int issuers_dn_len = 0, result;
 344   unsigned size;
 345
 346   /* Count the number of the given issuers;
 347    * This is used to allocate the issuers_dn without
 348    * using realloc().
 349    */
 350
 351   if (data_size == 0 || data == NULL)
 352     return 0;
 353
 354   if (data_size > 0)
 355     do
 356       {
 357         /* This works like DECR_LEN()
 358          */
 359         result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
 360         DECR_LENGTH_COM (data_size, 2, goto error);
 361         size = _gnutls_read_uint16 (data);
 362
 363         result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
 364         DECR_LENGTH_COM (data_size, size, goto error);
 365
 366         data += 2;
 367
 368         if (size > 0)
 369           {
 370             issuers_dn_len++;
 371             data += size;
 372           }
 373
 374         if (data_size == 0)
 375           break;
 376
 377       }
 378     while (1);
 379
 380   return issuers_dn_len;
 381
 382 error:
 383   return result;
 384 }
 385
 386 /* Returns the issuers in the server's certificate request
 387  * packet.
 388  */
 389 static int
 390 get_issuers (gnutls_session_t session,
 391              gnutls_datum_t * issuers_dn, int issuers_len,
 392              uint8_t * data, size_t data_size)
 393 {
 394   int i;
 395   unsigned size;
 396
 397   if (gnutls_certificate_type_get (session) != GNUTLS_CRT_X509)
 398     return 0;
 399
 400   /* put the requested DNs to req_dn, only in case
 401    * of X509 certificates.
 402    */
 403   if (issuers_len > 0)
 404     {
 405
 406       for (i = 0; i < issuers_len; i++)
 407         {
 408           /* The checks here for the buffer boundaries
 409            * are not needed since the buffer has been
 410            * parsed above.
 411            */
 412           data_size -= 2;
 413
 414           size = _gnutls_read_uint16 (data);
 415
 416           data += 2;
 417
 418           issuers_dn[i].data = data;
 419           issuers_dn[i].size = size;
 420
 421           data += size;
 422         }
 423     }
 424
 425   return 0;
 426 }
 427
 428 static void
 429 st_to_st2 (gnutls_retr2_st * st2, gnutls_retr_st * st)
 430 {
 431   st2->cert_type = st->type;
 432   if (st->type == GNUTLS_CRT_OPENPGP)
 433     {
 434       st2->key_type = GNUTLS_PRIVKEY_OPENPGP;
 435     }
 436   else
 437     {
 438       st2->key_type = GNUTLS_PRIVKEY_X509;
 439     }
 440   st2->ncerts = st->ncerts;
 441   st2->deinit_all = st->deinit_all;
 442
 443   switch (st2->cert_type)
 444     {
 445     case GNUTLS_CRT_OPENPGP:
 446       st2->cert.pgp = st->cert.pgp;
 447       st2->key.pgp = st->key.pgp;
 448       break;
 449     case GNUTLS_CRT_X509:
 450       st2->cert.x509 = st->cert.x509;
 451       st2->key.x509 = st->key.x509;
 452       break;
 453     default:
 454       return;
 455     }
 456
 457 }
 458
 459 /* Calls the client get callback.
 460  */
 461 static int
 462 call_get_cert_callback (gnutls_session_t session,
 463                         const gnutls_datum_t * issuers_dn,
 464                         int issuers_dn_length,
 465                         gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)
 466 {
 467   unsigned i;
 468   gnutls_pcert_st *local_certs = NULL;
 469   gnutls_privkey_t local_key = NULL;
 470   int ret = GNUTLS_E_INTERNAL_ERROR;
 471   gnutls_certificate_type_t type = gnutls_certificate_type_get (session);
 472   gnutls_certificate_credentials_t cred;
 473   gnutls_retr2_st st2;
 474   gnutls_pcert_st *pcert = NULL;
 475   unsigned int pcert_length = 0;
 476
 477   cred = (gnutls_certificate_credentials_t)
 478     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
 479   if (cred == NULL)
 480     {
 481       gnutls_assert ();
 482       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
 483     }
 484
 485   memset (&st2, 0, sizeof (st2));
 486
 487   if (cred->get_cert_callback2)
 488     {
 489       /* we avoid all allocations and transformations */
 490       ret = cred->get_cert_callback2 (session, issuers_dn, issuers_dn_length,
 491                                       pk_algos, pk_algos_length,
 492                                       &pcert, &pcert_length, &local_key);
 493       if (ret < 0)
 494         return gnutls_assert_val (GNUTLS_E_USER_ERROR);
 495
 496       if (pcert_length > 0 && type != pcert[0].type)
 497         return gnutls_assert_val (GNUTLS_E_INVALID_REQUEST);
 498
 499       if (pcert_length == 0)
 500         {
 501           pcert = NULL;
 502           local_key = NULL;
 503         }
 504       _gnutls_selected_certs_set (session, pcert, pcert_length, local_key, 0);
 505
 506       return 0;
 507
 508     }
 509   else if (cred->get_cert_callback)
 510     {
 511       ret = cred->get_cert_callback (session, issuers_dn, issuers_dn_length,
 512                                      pk_algos, pk_algos_length, &st2);
 513
 514     }
 515   else
 516     {                           /* compatibility mode */
 517       gnutls_retr_st st;
 518       memset (&st, 0, sizeof (st));
 519       if (session->security_parameters.entity == GNUTLS_SERVER)
 520         {
 521           if (cred->server_get_cert_callback == NULL)
 522             {
 523               gnutls_assert ();
 524               return GNUTLS_E_INTERNAL_ERROR;
 525             }
 526           ret = cred->server_get_cert_callback (session, &st);
 527           if (ret >= 0)
 528             st_to_st2 (&st2, &st);
 529         }
 530       else
 531         {                       /* CLIENT */
 532
 533           if (cred->client_get_cert_callback == NULL)
 534             {
 535               gnutls_assert ();
 536               return GNUTLS_E_INTERNAL_ERROR;
 537             }
 538           ret = cred->client_get_cert_callback (session,
 539                                                 issuers_dn, issuers_dn_length,
 540                                                 pk_algos, pk_algos_length,
 541                                                 &st);
 542           if (ret >= 0)
 543             st_to_st2 (&st2, &st);
 544         }
 545     }
 546
 547   if (ret < 0)
 548     {
 549       gnutls_assert ();
 550       return GNUTLS_E_USER_ERROR;
 551     }
 552
 553   if (st2.ncerts == 0)
 554     return 0;                   /* no certificate was selected */
 555
 556   if (type != st2.cert_type)
 557     {
 558       gnutls_assert ();
 559       ret = GNUTLS_E_INVALID_REQUEST;
 560       goto cleanup;
 561     }
 562
 563
 564   if (type == GNUTLS_CRT_X509)
 565     {
 566       local_certs = alloc_and_load_x509_certs (st2.cert.x509, st2.ncerts);
 567     }
 568   else
 569     {                           /* PGP */
 570       if (st2.ncerts > 1)
 571         {
 572           gnutls_assert ();
 573           ret = GNUTLS_E_INVALID_REQUEST;
 574           goto cleanup;
 575         }
 576 #ifdef ENABLE_OPENPGP
 577       {
 578         local_certs = alloc_and_load_pgp_certs (st2.cert.pgp);
 579       }
 580 #else
 581       ret = GNUTLS_E_UNIMPLEMENTED_FEATURE;
 582       goto cleanup;
 583 #endif
 584     }
 585
 586   if (local_certs == NULL)
 587     {
 588       gnutls_assert ();
 589       ret = GNUTLS_E_MEMORY_ERROR;
 590       goto cleanup;
 591     }
 592
 593   switch (st2.key_type)
 594     {
 595     case GNUTLS_PRIVKEY_OPENPGP:
 596 #ifdef ENABLE_OPENPGP
 597       if (st2.key.pgp != NULL)
 598         {
 599           local_key = alloc_and_load_pgp_key (st2.key.pgp, st2.deinit_all);
 600           if (local_key == NULL)
 601             {
 602               gnutls_assert ();
 603               ret = GNUTLS_E_INTERNAL_ERROR;
 604               goto cleanup;
 605             }
 606         }
 607 #endif
 608       break;
 609     case GNUTLS_PRIVKEY_PKCS11:
 610 #ifdef ENABLE_PKCS11
 611       if (st2.key.pkcs11 != NULL)
 612         {
 613           local_key =
 614             alloc_and_load_pkcs11_key (st2.key.pkcs11, st2.deinit_all);
 615           if (local_key == NULL)
 616             {
 617               gnutls_assert ();
 618               ret = GNUTLS_E_INTERNAL_ERROR;
 619               goto cleanup;
 620             }
 621         }
 622 #endif
 623       break;
 624     case GNUTLS_PRIVKEY_X509:
 625       if (st2.key.x509 != NULL)
 626         {
 627           local_key = alloc_and_load_x509_key (st2.key.x509, st2.deinit_all);
 628           if (local_key == NULL)
 629             {
 630               gnutls_assert ();
 631               ret = GNUTLS_E_INTERNAL_ERROR;
 632               goto cleanup;
 633             }
 634         }
 635       break;
 636     default:
 637       gnutls_assert();
 638       ret = GNUTLS_E_INVALID_REQUEST;
 639       goto cleanup;
 640     }
 641
 642   _gnutls_selected_certs_set (session, local_certs,
 643                               (local_certs != NULL) ? st2.ncerts : 0,
 644                               local_key, 1);
 645
 646   ret = 0;
 647
 648 cleanup:
 649
 650   if (st2.cert_type == GNUTLS_CRT_X509)
 651     {
 652       if (st2.deinit_all)
 653         {
 654           for (i = 0; i < st2.ncerts; i++)
 655             {
 656               gnutls_x509_crt_deinit (st2.cert.x509[i]);
 657             }
 658           gnutls_free(st2.cert.x509);
 659         }
 660     }
 661   else
 662     {
 663 #ifdef ENABLE_OPENPGP
 664       if (st2.deinit_all)
 665         {
 666           gnutls_openpgp_crt_deinit (st2.cert.pgp);
 667         }
 668 #endif
 669     }
 670
 671   if (ret < 0)
 672     {
 673       if (local_key != NULL)
 674         gnutls_privkey_deinit (local_key);
 675     }
 676
 677   return ret;
 678 }
 679
 680 /* Finds the appropriate certificate depending on the cA Distinguished name
 681  * advertized by the server. If none matches then returns 0 and -1 as index.
 682  * In case of an error a negative error code, is returned.
 683  *
 684  * 20020128: added ability to select a certificate depending on the SIGN
 685  * algorithm (only in automatic mode).
 686  */
 687 static int
 688 _select_client_cert (gnutls_session_t session,
 689                      uint8_t * _data, size_t _data_size,
 690                      gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)
 691 {
 692   int result;
 693   int indx = -1;
 694   gnutls_certificate_credentials_t cred;
 695   uint8_t *data = _data;
 696   ssize_t data_size = _data_size;
 697   int issuers_dn_length;
 698   gnutls_datum_t *issuers_dn = NULL;
 699
 700   cred = (gnutls_certificate_credentials_t)
 701     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
 702   if (cred == NULL)
 703     {
 704       gnutls_assert ();
 705       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
 706     }
 707
 708   if (cred->client_get_cert_callback != NULL
 709       || cred->get_cert_callback != NULL || cred->get_cert_callback2 != NULL)
 710     {
 711
 712       /* use a callback to get certificate
 713        */
 714       if (session->security_parameters.cert_type != GNUTLS_CRT_X509)
 715         issuers_dn_length = 0;
 716       else
 717         {
 718           issuers_dn_length = get_issuers_num (session, data, data_size);
 719           if (issuers_dn_length < 0)
 720             {
 721               gnutls_assert ();
 722               return issuers_dn_length;
 723             }
 724
 725           if (issuers_dn_length > 0)
 726             {
 727               issuers_dn =
 728                 gnutls_malloc (sizeof (gnutls_datum_t) * issuers_dn_length);
 729               if (issuers_dn == NULL)
 730                 {
 731                   gnutls_assert ();
 732                   return GNUTLS_E_MEMORY_ERROR;
 733                 }
 734
 735               result =
 736                 get_issuers (session, issuers_dn, issuers_dn_length,
 737                              data, data_size);
 738               if (result < 0)
 739                 {
 740                   gnutls_assert ();
 741                   goto cleanup;
 742                 }
 743             }
 744         }
 745
 746       result =
 747         call_get_cert_callback (session, issuers_dn, issuers_dn_length,
 748                                 pk_algos, pk_algos_length);
 749       goto cleanup;
 750
 751     }
 752   else
 753     {
 754       /* If we have no callbacks, try to guess.
 755        */
 756       result = 0;
 757
 758       if (session->security_parameters.cert_type == GNUTLS_CRT_X509)
 759         result =
 760           _find_x509_cert (cred, _data, _data_size,
 761                            pk_algos, pk_algos_length, &indx);
 762 #ifdef ENABLE_OPENPGP
 763       else if (session->security_parameters.cert_type == GNUTLS_CRT_OPENPGP)
 764         result = _find_openpgp_cert (cred, pk_algos, pk_algos_length, &indx);
 765 #endif
 766
 767       if (result < 0)
 768         {
 769           gnutls_assert ();
 770           return result;
 771         }
 772
 773       if (indx >= 0)
 774         {
 775           _gnutls_selected_certs_set (session,
 776                                       &cred->certs[indx].cert_list[0],
 777                                       cred->certs[indx].cert_list_length,
 778                                       cred->pkey[indx], 0);
 779         }
 780       else
 781         {
 782           _gnutls_selected_certs_set (session, NULL, 0, NULL, 0);
 783         }
 784
 785       result = 0;
 786     }
 787
 788 cleanup:
 789   gnutls_free (issuers_dn);
 790   return result;
 791
 792 }
 793
 794 /* Generate client certificate
 795  */
 796
 797 static int
 798 _gnutls_gen_x509_crt (gnutls_session_t session, gnutls_buffer_st * data)
 799 {
 800   int ret, i;
 801   gnutls_pcert_st *apr_cert_list;
 802   gnutls_privkey_t apr_pkey;
 803   int apr_cert_list_length;
 804
 805   /* find the appropriate certificate
 806    */
 807   if ((ret =
 808        _gnutls_get_selected_cert (session, &apr_cert_list,
 809                                   &apr_cert_list_length, &apr_pkey)) < 0)
 810     {
 811       gnutls_assert ();
 812       return ret;
 813     }
 814
 815   ret = 3;
 816   for (i = 0; i < apr_cert_list_length; i++)
 817     {
 818       ret += apr_cert_list[i].cert.size + 3;
 819       /* hold size
 820        * for uint24 */
 821     }
 822
 823   /* if no certificates were found then send:
 824    * 0B 00 00 03 00 00 00    // Certificate with no certs
 825    * instead of:
 826    * 0B 00 00 00          // empty certificate handshake
 827    *
 828    * ( the above is the whole handshake message, not
 829    * the one produced here )
 830    */
 831
 832   ret = _gnutls_buffer_append_prefix (data, 24, ret - 3);
 833   if (ret < 0)
 834     return gnutls_assert_val (ret);
 835
 836   for (i = 0; i < apr_cert_list_length; i++)
 837     {
 838       ret =
 839         _gnutls_buffer_append_data_prefix (data, 24,
 840                                            apr_cert_list[i].cert.data,
 841                                            apr_cert_list[i].cert.size);
 842       if (ret < 0)
 843         return gnutls_assert_val (ret);
 844     }
 845
 846   return data->length;
 847 }
 848
 849 enum PGPKeyDescriptorType
 850 { PGP_KEY_FINGERPRINT, PGP_KEY, PGP_KEY_SUBKEY, PGP_KEY_FINGERPRINT_SUBKEY };
 851
 852 #ifdef ENABLE_OPENPGP
 853 static int
 854 _gnutls_gen_openpgp_certificate (gnutls_session_t session,
 855                                  gnutls_buffer_st * data)
 856 {
 857   int ret;
 858   gnutls_pcert_st *apr_cert_list;
 859   gnutls_privkey_t apr_pkey;
 860   int apr_cert_list_length;
 861   uint8_t type;
 862   uint8_t fpr[20];
 863   size_t fpr_size;
 864   unsigned int use_subkey = 0;
 865
 866   /* find the appropriate certificate */
 867   if ((ret =
 868        _gnutls_get_selected_cert (session, &apr_cert_list,
 869                                   &apr_cert_list_length, &apr_pkey)) < 0)
 870     {
 871       gnutls_assert ();
 872       return ret;
 873     }
 874
 875   ret = 3 + 1 + 3;
 876
 877
 878
 879   if (apr_cert_list_length > 0)
 880     {
 881       fpr_size = sizeof (fpr);
 882       ret =
 883         gnutls_pubkey_get_openpgp_key_id (apr_cert_list[0].pubkey, 0, fpr,
 884                                           &fpr_size, &use_subkey);
 885       if (ret < 0)
 886         return gnutls_assert_val (ret);
 887
 888       if (use_subkey != 0)
 889         ret += 1 + fpr_size;    /* for the keyid */
 890
 891       ret += apr_cert_list[0].cert.size;
 892     }
 893
 894   ret = _gnutls_buffer_append_prefix (data, 24, ret - 3);
 895   if (ret < 0)
 896     return gnutls_assert_val (ret);
 897
 898
 899   if (apr_cert_list_length > 0)
 900     {
 901       if (use_subkey != 0)
 902         {
 903           type = PGP_KEY_SUBKEY;
 904
 905           ret = _gnutls_buffer_append_data (data, &type, 1);
 906           if (ret < 0)
 907             return gnutls_assert_val (ret);
 908
 909           ret = _gnutls_buffer_append_data_prefix (data, 8, fpr, fpr_size);
 910           if (ret < 0)
 911             return gnutls_assert_val (ret);
 912         }
 913       else
 914         {
 915           type = PGP_KEY;
 916           ret = _gnutls_buffer_append_data (data, &type, 1);
 917           if (ret < 0)
 918             return gnutls_assert_val (ret);
 919         }
 920
 921       ret =
 922         _gnutls_buffer_append_data_prefix (data, 24,
 923                                            apr_cert_list[0].cert.data,
 924                                            apr_cert_list[0].cert.size);
 925       if (ret < 0)
 926         return gnutls_assert_val (ret);
 927     }
 928   else                          /* empty - no certificate */
 929     {
 930       type = PGP_KEY;
 931
 932       ret = _gnutls_buffer_append_data (data, &type, 1);
 933       if (ret < 0)
 934         return gnutls_assert_val (ret);
 935
 936       ret = _gnutls_buffer_append_prefix (data, 24, 0);
 937       if (ret < 0)
 938         return gnutls_assert_val (ret);
 939     }
 940
 941   return data->length;
 942 }
 943
 944 static int
 945 _gnutls_gen_openpgp_certificate_fpr (gnutls_session_t session,
 946                                      gnutls_buffer_st * data)
 947 {
 948   int ret, packet_size;
 949   uint8_t type, fpr[20];
 950   size_t fpr_size;
 951   gnutls_pcert_st *apr_cert_list;
 952   gnutls_privkey_t apr_pkey;
 953   int apr_cert_list_length;
 954   unsigned int use_subkey = 0;
 955
 956   /* find the appropriate certificate */
 957   if ((ret =
 958        _gnutls_get_selected_cert (session, &apr_cert_list,
 959                                   &apr_cert_list_length, &apr_pkey)) < 0)
 960     {
 961       gnutls_assert ();
 962       return ret;
 963     }
 964
 965   fpr_size = sizeof (fpr);
 966   ret =
 967     gnutls_pubkey_get_openpgp_key_id (apr_cert_list[0].pubkey, 0, fpr,
 968                                       &fpr_size, &use_subkey);
 969   if (ret < 0)
 970     return gnutls_assert_val (ret);
 971
 972   packet_size = 3 + 1;
 973
 974   if (use_subkey)
 975     packet_size += 1 + fpr_size;        /* for the keyid */
 976
 977   /* Only v4 fingerprints are sent
 978    */
 979   if (apr_cert_list_length > 0)
 980     packet_size += 20 + 1;
 981   else                          /* empty certificate case */
 982     return _gnutls_gen_openpgp_certificate (session, data);
 983
 984   ret = _gnutls_buffer_append_prefix (data, 24, packet_size - 3);
 985   if (ret < 0)
 986     return gnutls_assert_val (ret);
 987
 988   if (use_subkey)
 989     {
 990       type = PGP_KEY_FINGERPRINT_SUBKEY;
 991       ret = _gnutls_buffer_append_data (data, &type, 1);
 992       if (ret < 0)
 993         return gnutls_assert_val (ret);
 994
 995       ret = _gnutls_buffer_append_data_prefix (data, 8, fpr, fpr_size);
 996       if (ret < 0)
 997         return gnutls_assert_val (ret);
 998     }
 999   else
1000     {
1001       type = PGP_KEY_FINGERPRINT;       /* key fingerprint */
1002       ret = _gnutls_buffer_append_data (data, &type, 1);
1003       if (ret < 0)
1004         return gnutls_assert_val (ret);
1005     }
1006
1007   fpr_size = sizeof (fpr);
1008   if ((ret =
1009        _gnutls_openpgp_fingerprint (&apr_cert_list[0].cert, fpr,
1010                                     &fpr_size)) < 0)
1011     {
1012       gnutls_assert ();
1013       return ret;
1014     }
1015
1016   ret = _gnutls_buffer_append_data_prefix (data, 8, fpr, fpr_size);
1017   if (ret < 0)
1018     return gnutls_assert_val (ret);
1019
1020   return data->length;
1021 }
1022 #endif
1023
1024
1025 int
1026 _gnutls_gen_cert_client_certificate (gnutls_session_t session,
1027                                      gnutls_buffer_st * data)
1028 {
1029   switch (session->security_parameters.cert_type)
1030     {
1031 #ifdef ENABLE_OPENPGP
1032     case GNUTLS_CRT_OPENPGP:
1033       if (_gnutls_openpgp_send_fingerprint (session) == 0)
1034         return _gnutls_gen_openpgp_certificate (session, data);
1035       else
1036         return _gnutls_gen_openpgp_certificate_fpr (session, data);
1037 #endif
1038     case GNUTLS_CRT_X509:
1039       return _gnutls_gen_x509_crt (session, data);
1040
1041     default:
1042       gnutls_assert ();
1043       return GNUTLS_E_INTERNAL_ERROR;
1044     }
1045 }
1046
1047 int
1048 _gnutls_gen_cert_server_certificate (gnutls_session_t session,
1049                                      gnutls_buffer_st * data)
1050 {
1051   switch (session->security_parameters.cert_type)
1052     {
1053 #ifdef ENABLE_OPENPGP
1054     case GNUTLS_CRT_OPENPGP:
1055       return _gnutls_gen_openpgp_certificate (session, data);
1056 #endif
1057     case GNUTLS_CRT_X509:
1058       return _gnutls_gen_x509_crt (session, data);
1059     default:
1060       gnutls_assert ();
1061       return GNUTLS_E_INTERNAL_ERROR;
1062     }
1063 }
1064
1065 /* Process server certificate
1066  */
1067
1068 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) gnutls_pcert_deinit(&peer_certificate_list[x])
1069 static int
1070 _gnutls_proc_x509_server_certificate (gnutls_session_t session,
1071                                       uint8_t * data, size_t data_size)
1072 {
1073   int size, len, ret;
1074   uint8_t *p = data;
1075   cert_auth_info_t info;
1076   gnutls_certificate_credentials_t cred;
1077   ssize_t dsize = data_size;
1078   int i;
1079   gnutls_pcert_st *peer_certificate_list;
1080   size_t peer_certificate_list_size = 0, j, x;
1081   gnutls_datum_t tmp;
1082
1083   cred = (gnutls_certificate_credentials_t)
1084     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
1085   if (cred == NULL)
1086     {
1087       gnutls_assert ();
1088       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
1089     }
1090
1091
1092   if ((ret =
1093        _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE,
1094                               sizeof (cert_auth_info_st), 1)) < 0)
1095     {
1096       gnutls_assert ();
1097       return ret;
1098     }
1099
1100   info = _gnutls_get_auth_info (session);
1101
1102   if (data == NULL || data_size == 0)
1103     {
1104       gnutls_assert ();
1105       /* no certificate was sent */
1106       return GNUTLS_E_NO_CERTIFICATE_FOUND;
1107     }
1108
1109   DECR_LEN (dsize, 3);
1110   size = _gnutls_read_uint24 (p);
1111   p += 3;
1112
1113   /* some implementations send 0B 00 00 06 00 00 03 00 00 00
1114    * instead of just 0B 00 00 03 00 00 00 as an empty certificate message.
1115    */
1116   if (size == 0 || size == 3)
1117     {
1118       gnutls_assert ();
1119       /* no certificate was sent */
1120       return GNUTLS_E_NO_CERTIFICATE_FOUND;
1121     }
1122
1123   i = dsize;
1124   while (i > 0)
1125     {
1126       DECR_LEN (dsize, 3);
1127       len = _gnutls_read_uint24 (p);
1128       p += 3;
1129       DECR_LEN (dsize, len);
1130       peer_certificate_list_size++;
1131       p += len;
1132       i -= len + 3;
1133     }
1134
1135   if (peer_certificate_list_size == 0)
1136     {
1137       gnutls_assert ();
1138       return GNUTLS_E_NO_CERTIFICATE_FOUND;
1139     }
1140
1141   /* Ok we now allocate the memory to hold the
1142    * certificate list
1143    */
1144
1145   peer_certificate_list =
1146     gnutls_calloc (1,
1147                    sizeof (gnutls_pcert_st) * (peer_certificate_list_size));
1148   if (peer_certificate_list == NULL)
1149     {
1150       gnutls_assert ();
1151       return GNUTLS_E_MEMORY_ERROR;
1152     }
1153
1154   p = data + 3;
1155
1156   /* Now we start parsing the list (again).
1157    * We don't use DECR_LEN since the list has
1158    * been parsed before.
1159    */
1160
1161   for (j = 0; j < peer_certificate_list_size; j++)
1162     {
1163       len = _gnutls_read_uint24 (p);
1164       p += 3;
1165
1166       tmp.size = len;
1167       tmp.data = p;
1168
1169       ret =
1170         gnutls_pcert_import_x509_raw (&peer_certificate_list
1171                                       [j], &tmp, GNUTLS_X509_FMT_DER, 0);
1172       if (ret < 0)
1173         {
1174           gnutls_assert ();
1175           peer_certificate_list_size = j;
1176           goto cleanup;
1177         }
1178
1179       p += len;
1180     }
1181
1182
1183   if ((ret =
1184        _gnutls_copy_certificate_auth_info (info,
1185                                            peer_certificate_list,
1186                                            peer_certificate_list_size, 0,
1187                                            NULL)) < 0)
1188     {
1189       gnutls_assert ();
1190       goto cleanup;
1191     }
1192
1193   if ((ret =
1194        _gnutls_check_key_usage (&peer_certificate_list[0],
1195                                 gnutls_kx_get (session))) < 0)
1196     {
1197       gnutls_assert ();
1198       goto cleanup;
1199     }
1200
1201   ret = 0;
1202
1203 cleanup:
1204   CLEAR_CERTS;
1205   gnutls_free (peer_certificate_list);
1206   return ret;
1207
1208 }
1209
1210 #ifdef ENABLE_OPENPGP
1211 static int
1212 _gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
1213                                          uint8_t * data, size_t data_size)
1214 {
1215   int size, ret, len;
1216   uint8_t *p = data;
1217   cert_auth_info_t info;
1218   gnutls_certificate_credentials_t cred;
1219   ssize_t dsize = data_size;
1220   int x, key_type;
1221   gnutls_pcert_st *peer_certificate_list = NULL;
1222   int peer_certificate_list_size = 0;
1223   gnutls_datum_t tmp, akey = { NULL, 0 };
1224   uint8_t subkey_id[GNUTLS_OPENPGP_KEYID_SIZE];
1225   unsigned int subkey_id_set = 0;
1226
1227   cred = (gnutls_certificate_credentials_t)
1228     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
1229   if (cred == NULL)
1230     {
1231       gnutls_assert ();
1232       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
1233     }
1234
1235   if ((ret =
1236        _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE,
1237                               sizeof (cert_auth_info_st), 1)) < 0)
1238     {
1239       gnutls_assert ();
1240       return ret;
1241     }
1242
1243   info = _gnutls_get_auth_info (session);
1244
1245   if (data == NULL || data_size == 0)
1246     {
1247       gnutls_assert ();
1248       return GNUTLS_E_NO_CERTIFICATE_FOUND;
1249     }
1250
1251   DECR_LEN (dsize, 3);
1252   size = _gnutls_read_uint24 (p);
1253   p += 3;
1254
1255   if (size == 0)
1256     {
1257       gnutls_assert ();
1258       /* no certificate was sent */
1259       return GNUTLS_E_NO_CERTIFICATE_FOUND;
1260     }
1261
1262   /* Read PGPKeyDescriptor */
1263   DECR_LEN (dsize, 1);
1264   key_type = *p;
1265   p++;
1266
1267   /* Try to read the keyid if present */
1268   if (key_type == PGP_KEY_FINGERPRINT_SUBKEY || key_type == PGP_KEY_SUBKEY)
1269     {
1270       /* check size */
1271       if (*p != GNUTLS_OPENPGP_KEYID_SIZE)
1272         {
1273           gnutls_assert ();
1274           return GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE;
1275         }
1276
1277       DECR_LEN (dsize, 1);
1278       p++;
1279
1280       DECR_LEN (dsize, GNUTLS_OPENPGP_KEYID_SIZE);
1281       memcpy (subkey_id, p, GNUTLS_OPENPGP_KEYID_SIZE);
1282       p += GNUTLS_OPENPGP_KEYID_SIZE;
1283
1284       subkey_id_set = 1;
1285
1286     }
1287
1288   /* read the actual key or fingerprint */
1289   if (key_type == PGP_KEY_FINGERPRINT
1290       || key_type == PGP_KEY_FINGERPRINT_SUBKEY)
1291     {                           /* the fingerprint */
1292
1293       DECR_LEN (dsize, 1);
1294       len = (uint8_t) * p;
1295       p++;
1296
1297       if (len != 20)
1298         {
1299           gnutls_assert ();
1300           return GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED;
1301         }
1302
1303       DECR_LEN (dsize, 20);
1304
1305       /* request the actual key from our database, or
1306        * a key server or anything.
1307        */
1308       if ((ret =
1309            _gnutls_openpgp_request_key (session, &akey, cred, p, 20)) < 0)
1310         {
1311           gnutls_assert ();
1312           return ret;
1313         }
1314       tmp = akey;
1315       peer_certificate_list_size++;
1316
1317     }
1318   else if (key_type == PGP_KEY || key_type == PGP_KEY_SUBKEY)
1319     {                           /* the whole key */
1320
1321       /* Read the actual certificate */
1322       DECR_LEN (dsize, 3);
1323       len = _gnutls_read_uint24 (p);
1324       p += 3;
1325
1326       if (len == 0)
1327         {
1328           gnutls_assert ();
1329           /* no certificate was sent */
1330           return GNUTLS_E_NO_CERTIFICATE_FOUND;
1331         }
1332
1333       DECR_LEN (dsize, len);
1334       peer_certificate_list_size++;
1335
1336       tmp.size = len;
1337       tmp.data = p;
1338
1339     }
1340   else
1341     {
1342       gnutls_assert ();
1343       return GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE;
1344     }
1345
1346   /* ok we now have the peer's key in tmp datum
1347    */
1348
1349   if (peer_certificate_list_size == 0)
1350     {
1351       gnutls_assert ();
1352       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
1353     }
1354
1355   peer_certificate_list =
1356     gnutls_calloc (1,
1357                    sizeof (gnutls_pcert_st) * (peer_certificate_list_size));
1358   if (peer_certificate_list == NULL)
1359     {
1360       gnutls_assert ();
1361       ret = GNUTLS_E_MEMORY_ERROR;
1362       goto cleanup;
1363     }
1364
1365   ret =
1366     gnutls_pcert_import_openpgp_raw (&peer_certificate_list[0],
1367                                      &tmp,
1368                                      GNUTLS_OPENPGP_FMT_RAW,
1369                                      (subkey_id_set != 0) ? subkey_id : NULL,
1370                                      0);
1371   if (ret < 0)
1372     {
1373       gnutls_assert ();
1374       goto cleanup;
1375     }
1376
1377   ret =
1378     _gnutls_copy_certificate_auth_info (info,
1379                                         peer_certificate_list,
1380                                         peer_certificate_list_size,
1381                                         subkey_id_set,
1382                                         (subkey_id_set !=
1383                                          0) ? subkey_id : NULL);
1384   if (ret < 0)
1385     {
1386       gnutls_assert ();
1387       goto cleanup;
1388     }
1389
1390   if ((ret =
1391        _gnutls_check_key_usage (&peer_certificate_list[0],
1392                                 gnutls_kx_get (session))) < 0)
1393     {
1394       gnutls_assert ();
1395       goto cleanup;
1396     }
1397
1398   ret = 0;
1399
1400 cleanup:
1401
1402   _gnutls_free_datum (&akey);
1403   CLEAR_CERTS;
1404   gnutls_free (peer_certificate_list);
1405   return ret;
1406
1407 }
1408 #endif
1409
1410 int
1411 _gnutls_proc_certificate (gnutls_session_t session,
1412                                       uint8_t * data, size_t data_size)
1413 {
1414   int ret;
1415   gnutls_certificate_credentials_t cred;
1416
1417   cred =
1418     (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
1419                                                          GNUTLS_CRD_CERTIFICATE,
1420                                                          NULL);
1421   if (cred == NULL)
1422     {
1423       gnutls_assert ();
1424       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
1425     }
1426
1427   switch (session->security_parameters.cert_type)
1428     {
1429 #ifdef ENABLE_OPENPGP
1430     case GNUTLS_CRT_OPENPGP:
1431       ret = _gnutls_proc_openpgp_server_certificate (session,
1432                                                      data, data_size);
1433       break;
1434 #endif
1435     case GNUTLS_CRT_X509:
1436       ret = _gnutls_proc_x509_server_certificate (session, data, data_size);
1437       break;
1438     default:
1439       gnutls_assert ();
1440       return GNUTLS_E_INTERNAL_ERROR;
1441     }
1442
1443   if (ret == 0 && cred->verify_callback != NULL)
1444     {
1445       ret = cred->verify_callback (session);
1446       if (ret != 0)
1447         ret = GNUTLS_E_CERTIFICATE_ERROR;
1448     }
1449
1450   return ret;
1451 }
1452
1453
1454 /* Checks if we support the given signature algorithm
1455  * (RSA or DSA). Returns the corresponding gnutls_pk_algorithm_t
1456  * if true;
1457  */
1458 inline static int
1459 _gnutls_check_supported_sign_algo (CertificateSigType algo)
1460 {
1461   switch (algo)
1462     {
1463     case RSA_SIGN:
1464       return GNUTLS_PK_RSA;
1465     case DSA_SIGN:
1466       return GNUTLS_PK_DSA;
1467     case ECDSA_SIGN:
1468       return GNUTLS_PK_EC;
1469     }
1470
1471   return -1;
1472 }
1473
1474 int
1475 _gnutls_proc_cert_cert_req (gnutls_session_t session, uint8_t * data,
1476                             size_t data_size)
1477 {
1478   int size, ret;
1479   uint8_t *p;
1480   gnutls_certificate_credentials_t cred;
1481   ssize_t dsize;
1482   int i;
1483   gnutls_pk_algorithm_t pk_algos[MAX_CLIENT_SIGN_ALGOS];
1484   int pk_algos_length;
1485   gnutls_protocol_t ver = gnutls_protocol_get_version (session);
1486
1487   cred = (gnutls_certificate_credentials_t)
1488     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
1489   if (cred == NULL)
1490     {
1491       gnutls_assert ();
1492       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
1493     }
1494
1495   if ((ret =
1496        _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE,
1497                               sizeof (cert_auth_info_st), 0)) < 0)
1498     {
1499       gnutls_assert ();
1500       return ret;
1501     }
1502
1503   p = data;
1504   dsize = data_size;
1505
1506   DECR_LEN (dsize, 1);
1507   size = p[0];
1508   p++;
1509   /* check if the sign algorithm is supported.
1510    */
1511   pk_algos_length = 0;
1512   for (i = 0; i < size; i++, p++)
1513     {
1514       DECR_LEN (dsize, 1);
1515       if ((ret = _gnutls_check_supported_sign_algo (*p)) > 0)
1516         {
1517           if (pk_algos_length < MAX_CLIENT_SIGN_ALGOS)
1518             {
1519               pk_algos[pk_algos_length++] = ret;
1520             }
1521         }
1522     }
1523
1524   if (pk_algos_length == 0)
1525     {
1526       gnutls_assert ();
1527       return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
1528     }
1529
1530   if (_gnutls_version_has_selectable_sighash (ver))
1531     {
1532       /* read supported hashes */
1533       int hash_num;
1534       DECR_LEN (dsize, 2);
1535       hash_num = _gnutls_read_uint16 (p);
1536       p += 2;
1537       DECR_LEN (dsize, hash_num);
1538
1539       ret = _gnutls_sign_algorithm_parse_data (session, p, hash_num);
1540       if (ret < 0)
1541         {
1542           gnutls_assert ();
1543           return ret;
1544         }
1545
1546       p += hash_num;
1547     }
1548
1549   /* read the certificate authorities */
1550   DECR_LEN (dsize, 2);
1551   size = _gnutls_read_uint16 (p);
1552   p += 2;
1553
1554   if (session->security_parameters.cert_type == GNUTLS_CRT_OPENPGP
1555       && size != 0)
1556     {
1557       gnutls_assert ();
1558       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
1559     }
1560
1561   DECR_LEN (dsize, size);
1562
1563   /* now we ask the user to tell which one
1564    * he wants to use.
1565    */
1566   if ((ret =
1567        _select_client_cert (session, p, size, pk_algos, pk_algos_length)) < 0)
1568     {
1569       gnutls_assert ();
1570       return ret;
1571     }
1572
1573   /* We should reply with a certificate message,
1574    * even if we have no certificate to send.
1575    */
1576   session->key->certificate_requested = 1;
1577
1578   return 0;
1579 }
1580
1581 int
1582 _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t session,
1583                                    gnutls_buffer_st * data)
1584 {
1585   int ret;
1586   gnutls_pcert_st *apr_cert_list;
1587   gnutls_privkey_t apr_pkey;
1588   int apr_cert_list_length;
1589   gnutls_datum_t signature = { NULL, 0 };
1590   int total_data;
1591   gnutls_sign_algorithm_t sign_algo;
1592   gnutls_protocol_t ver = gnutls_protocol_get_version (session);
1593
1594   /* find the appropriate certificate */
1595   if ((ret =
1596        _gnutls_get_selected_cert (session, &apr_cert_list,
1597                                   &apr_cert_list_length, &apr_pkey)) < 0)
1598     {
1599       gnutls_assert ();
1600       return ret;
1601     }
1602
1603   if (apr_cert_list_length > 0)
1604     {
1605       if ((ret =
1606            _gnutls_handshake_sign_cert_vrfy (session,
1607                                              &apr_cert_list[0],
1608                                              apr_pkey, &signature)) < 0)
1609         {
1610           gnutls_assert ();
1611           return ret;
1612         }
1613       sign_algo = ret;
1614     }
1615   else
1616     {
1617       return 0;
1618     }
1619
1620   total_data = signature.size + 2;
1621
1622   /* add hash and signature algorithms */
1623   if (_gnutls_version_has_selectable_sighash (ver))
1624     {
1625       total_data += 2;
1626     }
1627
1628   if (_gnutls_version_has_selectable_sighash (ver))
1629     {
1630       const sign_algorithm_st *aid;
1631       uint8_t p[2];
1632       /* error checking is not needed here since we have used those algorithms */
1633       aid = _gnutls_sign_to_tls_aid (sign_algo);
1634       if (aid == NULL)
1635         return gnutls_assert_val (GNUTLS_E_UNKNOWN_ALGORITHM);
1636
1637       p[0] = aid->hash_algorithm;
1638       p[1] = aid->sign_algorithm;
1639       ret = _gnutls_buffer_append_data (data, p, 2);
1640       if (ret < 0)
1641         {
1642           gnutls_assert ();
1643           goto cleanup;
1644         }
1645     }
1646
1647   ret =
1648     _gnutls_buffer_append_data_prefix (data, 16, signature.data,
1649                                        signature.size);
1650   if (ret < 0)
1651     {
1652       gnutls_assert ();
1653       goto cleanup;
1654     }
1655
1656   ret = data->length;
1657
1658 cleanup:
1659   _gnutls_free_datum (&signature);
1660   return ret;
1661 }
1662
1663 int
1664 _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t session,
1665                                     uint8_t * data, size_t data_size)
1666 {
1667   int size, ret;
1668   ssize_t dsize = data_size;
1669   uint8_t *pdata = data;
1670   gnutls_datum_t sig;
1671   cert_auth_info_t info = _gnutls_get_auth_info (session);
1672   gnutls_pcert_st peer_cert;
1673   gnutls_sign_algorithm_t sign_algo = GNUTLS_SIGN_UNKNOWN;
1674   gnutls_protocol_t ver = gnutls_protocol_get_version (session);
1675
1676   if (info == NULL || info->ncerts == 0)
1677     {
1678       gnutls_assert ();
1679       /* we need this in order to get peer's certificate */
1680       return GNUTLS_E_INTERNAL_ERROR;
1681     }
1682
1683   if (_gnutls_version_has_selectable_sighash (ver))
1684     {
1685       sign_algorithm_st aid;
1686
1687       DECR_LEN (dsize, 2);
1688       aid.hash_algorithm = pdata[0];
1689       aid.sign_algorithm = pdata[1];
1690
1691       sign_algo = _gnutls_tls_aid_to_sign (&aid);
1692       if (sign_algo == GNUTLS_SIGN_UNKNOWN)
1693         {
1694           gnutls_assert ();
1695           return GNUTLS_E_UNSUPPORTED_SIGNATURE_ALGORITHM;
1696         }
1697       pdata += 2;
1698     }
1699
1700   ret = _gnutls_session_sign_algo_enabled (session, sign_algo);
1701   if (ret < 0)
1702     {
1703       gnutls_assert ();
1704       return GNUTLS_E_UNSUPPORTED_SIGNATURE_ALGORITHM;
1705     }
1706
1707   DECR_LEN (dsize, 2);
1708   size = _gnutls_read_uint16 (pdata);
1709   pdata += 2;
1710
1711   DECR_LEN (dsize, size);
1712
1713   sig.data = pdata;
1714   sig.size = size;
1715
1716   ret = _gnutls_get_auth_info_pcert (&peer_cert,
1717                                      session->security_parameters.cert_type,
1718                                      info);
1719
1720   if (ret < 0)
1721     {
1722       gnutls_assert ();
1723       return ret;
1724     }
1725
1726   if ((ret =
1727        _gnutls_handshake_verify_cert_vrfy (session, &peer_cert, &sig,
1728                                            sign_algo)) < 0)
1729     {
1730       gnutls_assert ();
1731       gnutls_pcert_deinit (&peer_cert);
1732       return ret;
1733     }
1734   gnutls_pcert_deinit (&peer_cert);
1735
1736   return 0;
1737 }
1738
1739 int
1740 _gnutls_gen_cert_server_cert_req (gnutls_session_t session,
1741                                   gnutls_buffer_st * data)
1742 {
1743   gnutls_certificate_credentials_t cred;
1744   int size, ret;
1745   uint8_t tmp_data[CERTTYPE_SIZE];
1746   gnutls_protocol_t ver = gnutls_protocol_get_version (session);
1747
1748   /* Now we need to generate the RDN sequence. This is
1749    * already in the CERTIFICATE_CRED structure, to improve
1750    * performance.
1751    */
1752
1753   cred = (gnutls_certificate_credentials_t)
1754     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
1755   if (cred == NULL)
1756     {
1757       gnutls_assert ();
1758       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
1759     }
1760
1761   size = CERTTYPE_SIZE + 2;     /* 2 for gnutls_certificate_type_t + 2 for size of rdn_seq
1762                                  */
1763
1764   if (session->security_parameters.cert_type == GNUTLS_CRT_X509 &&
1765       session->internals.ignore_rdn_sequence == 0)
1766     size += cred->x509_rdn_sequence.size;
1767
1768   if (_gnutls_version_has_selectable_sighash (ver))
1769     /* Need two bytes to announce the number of supported hash
1770        functions (see below).  */
1771     size += MAX_SIGN_ALGO_SIZE;
1772
1773   tmp_data[0] = CERTTYPE_SIZE - 1;
1774   tmp_data[1] = RSA_SIGN;
1775   tmp_data[2] = DSA_SIGN;
1776   tmp_data[3] = ECDSA_SIGN;     /* only these for now */
1777
1778   ret = _gnutls_buffer_append_data (data, tmp_data, CERTTYPE_SIZE);
1779   if (ret < 0)
1780     return gnutls_assert_val (ret);
1781
1782   if (_gnutls_version_has_selectable_sighash (ver))
1783     {
1784       uint8_t p[MAX_SIGN_ALGO_SIZE];
1785
1786       ret =
1787         _gnutls_sign_algorithm_write_params (session, p, MAX_SIGN_ALGO_SIZE);
1788       if (ret < 0)
1789         {
1790           gnutls_assert ();
1791           return ret;
1792         }
1793
1794       /* recalculate size */
1795       size -= MAX_SIGN_ALGO_SIZE + ret;
1796
1797       ret = _gnutls_buffer_append_data (data, p, ret);
1798       if (ret < 0)
1799         return gnutls_assert_val (ret);
1800     }
1801
1802   if (session->security_parameters.cert_type == GNUTLS_CRT_X509 &&
1803       session->internals.ignore_rdn_sequence == 0)
1804     {
1805       ret =
1806         _gnutls_buffer_append_data_prefix (data, 16,
1807                                            cred->x509_rdn_sequence.data,
1808                                            cred->x509_rdn_sequence.size);
1809       if (ret < 0)
1810         return gnutls_assert_val (ret);
1811     }
1812   else
1813     {
1814       ret = _gnutls_buffer_append_prefix (data, 16, 0);
1815       if (ret < 0)
1816         return gnutls_assert_val (ret);
1817     }
1818
1819   return data->length;
1820 }
1821
1822
1823 /* This function will return the appropriate certificate to use.
1824  * Fills in the apr_cert_list, apr_cert_list_length and apr_pkey.
1825  * The return value is a negative error code on error.
1826  *
1827  * It is normal to return 0 with no certificates in client side.
1828  *
1829  */
1830 int
1831 _gnutls_get_selected_cert (gnutls_session_t session,
1832                            gnutls_pcert_st ** apr_cert_list,
1833                            int *apr_cert_list_length,
1834                            gnutls_privkey_t * apr_pkey)
1835 {
1836   if (session->security_parameters.entity == GNUTLS_SERVER)
1837     {
1838
1839       /* select_client_cert() has been called before.
1840        */
1841
1842       *apr_cert_list = session->internals.selected_cert_list;
1843       *apr_pkey = session->internals.selected_key;
1844       *apr_cert_list_length = session->internals.selected_cert_list_length;
1845
1846       if (*apr_cert_list_length == 0 || *apr_cert_list == NULL)
1847         {
1848           gnutls_assert ();
1849           return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
1850         }
1851
1852     }
1853   else
1854     {                           /* CLIENT SIDE
1855                                  */
1856
1857       /* we have already decided which certificate
1858        * to send.
1859        */
1860       *apr_cert_list = session->internals.selected_cert_list;
1861       *apr_cert_list_length = session->internals.selected_cert_list_length;
1862       *apr_pkey = session->internals.selected_key;
1863
1864     }
1865
1866   return 0;
1867 }
1868
1869 /* converts the given x509 certificate list to gnutls_pcert_st* and allocates
1870  * space for them.
1871  */
1872 static gnutls_pcert_st *
1873 alloc_and_load_x509_certs (gnutls_x509_crt_t * certs, unsigned ncerts)
1874 {
1875   gnutls_pcert_st *local_certs;
1876   int ret = 0;
1877   unsigned i, j;
1878
1879   if (certs == NULL)
1880     return NULL;
1881
1882   local_certs = gnutls_malloc (sizeof (gnutls_pcert_st) * ncerts);
1883   if (local_certs == NULL)
1884     {
1885       gnutls_assert ();
1886       return NULL;
1887     }
1888
1889   for (i = 0; i < ncerts; i++)
1890     {
1891       ret = gnutls_pcert_import_x509 (&local_certs[i], certs[i], 0);
1892       if (ret < 0)
1893         break;
1894     }
1895
1896   if (ret < 0)
1897     {
1898       gnutls_assert ();
1899       for (j = 0; j < i; j++)
1900         {
1901           gnutls_pcert_deinit (&local_certs[j]);
1902         }
1903       gnutls_free (local_certs);
1904       return NULL;
1905     }
1906
1907   return local_certs;
1908 }
1909
1910 /* converts the given x509 key to gnutls_privkey* and allocates
1911  * space for it.
1912  */
1913 static gnutls_privkey_t
1914 alloc_and_load_x509_key (gnutls_x509_privkey_t key, int deinit)
1915 {
1916   gnutls_privkey_t local_key;
1917   int ret = 0;
1918
1919   if (key == NULL)
1920     return NULL;
1921
1922   ret = gnutls_privkey_init (&local_key);
1923   if (ret < 0)
1924     {
1925       gnutls_assert ();
1926       return NULL;
1927     }
1928
1929   ret =
1930     gnutls_privkey_import_x509 (local_key, key,
1931                                 deinit ? GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE :
1932                                 0);
1933   if (ret < 0)
1934     {
1935       gnutls_assert ();
1936       gnutls_privkey_deinit (local_key);
1937       return NULL;
1938     }
1939
1940   return local_key;
1941 }
1942
1943 /* converts the given pgp certificate to gnutls_cert* and allocates
1944  * space for them.
1945  */
1946 #ifdef ENABLE_OPENPGP
1947 static gnutls_pcert_st *
1948 alloc_and_load_pgp_certs (gnutls_openpgp_crt_t cert)
1949 {
1950   gnutls_pcert_st *local_certs;
1951   int ret = 0;
1952
1953   if (cert == NULL)
1954     return NULL;
1955
1956   local_certs = gnutls_malloc (sizeof (gnutls_pcert_st));
1957   if (local_certs == NULL)
1958     {
1959       gnutls_assert ();
1960       return NULL;
1961     }
1962
1963   ret = gnutls_pcert_import_openpgp (local_certs, cert, 0);
1964   if (ret < 0)
1965     {
1966       gnutls_assert ();
1967       return NULL;
1968     }
1969
1970   if (ret < 0)
1971     {
1972       gnutls_assert ();
1973       gnutls_pcert_deinit (local_certs);
1974       gnutls_free (local_certs);
1975       return NULL;
1976     }
1977
1978   return local_certs;
1979 }
1980
1981 /* converts the given raw key to gnutls_privkey* and allocates
1982  * space for it.
1983  */
1984 static gnutls_privkey_t
1985 alloc_and_load_pgp_key (gnutls_openpgp_privkey_t key, int deinit)
1986 {
1987   gnutls_privkey_t local_key;
1988   int ret = 0;
1989
1990   if (key == NULL)
1991     return NULL;
1992
1993   ret = gnutls_privkey_init (&local_key);
1994   if (ret < 0)
1995     {
1996       gnutls_assert ();
1997       return NULL;
1998     }
1999
2000   ret =
2001     gnutls_privkey_import_openpgp (local_key, key,
2002                                    deinit ? GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE
2003                                    : 0);
2004   if (ret < 0)
2005     {
2006       gnutls_assert ();
2007       gnutls_privkey_deinit (local_key);
2008       return NULL;
2009     }
2010
2011   return local_key;
2012 }
2013 #endif
2014
2015 #ifdef ENABLE_PKCS11
2016
2017 /* converts the given raw key to gnutls_privkey* and allocates
2018  * space for it.
2019  */
2020 static gnutls_privkey_t
2021 alloc_and_load_pkcs11_key (gnutls_pkcs11_privkey_t key, int deinit)
2022 {
2023   gnutls_privkey_t local_key;
2024   int ret = 0;
2025
2026   if (key == NULL)
2027     return NULL;
2028
2029   ret = gnutls_privkey_init (&local_key);
2030   if (ret < 0)
2031     {
2032       gnutls_assert ();
2033       return NULL;
2034     }
2035
2036   ret =
2037     gnutls_privkey_import_pkcs11 (local_key, key,
2038                                   deinit ? GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE
2039                                   : 0);
2040   if (ret < 0)
2041     {
2042       gnutls_assert ();
2043       gnutls_privkey_deinit (local_key);
2044       return NULL;
2045     }
2046
2047   return local_key;
2048 }
2049
2050 #endif
2051
2052 void
2053 _gnutls_selected_certs_deinit (gnutls_session_t session)
2054 {
2055   if (session->internals.selected_need_free != 0)
2056     {
2057       int i;
2058
2059       for (i = 0; i < session->internals.selected_cert_list_length; i++)
2060         {
2061           gnutls_pcert_deinit (&session->internals.selected_cert_list[i]);
2062         }
2063       gnutls_free (session->internals.selected_cert_list);
2064       session->internals.selected_cert_list = NULL;
2065       session->internals.selected_cert_list_length = 0;
2066
2067       gnutls_privkey_deinit(session->internals.selected_key);
2068       session->internals.selected_key = NULL;
2069     }
2070
2071   return;
2072 }
2073
2074 void
2075 _gnutls_selected_certs_set (gnutls_session_t session,
2076                             gnutls_pcert_st * certs, int ncerts,
2077                             gnutls_privkey_t key, int need_free)
2078 {
2079   _gnutls_selected_certs_deinit (session);
2080
2081   session->internals.selected_cert_list = certs;
2082   session->internals.selected_cert_list_length = ncerts;
2083   session->internals.selected_key = key;
2084   session->internals.selected_need_free = need_free;
2085
2086 }
2087
2088 static void get_server_name(gnutls_session_t session, uint8_t* name, size_t max_name_size)
2089 {
2090 int ret, i;
2091 size_t max_name;
2092 unsigned int type;
2093
2094   ret = 0;
2095   for (i=0; !(ret<0);i++)
2096     {
2097       max_name = max_name_size;
2098       ret = gnutls_server_name_get (session, name, &max_name, &type, i);
2099       if (ret >= 0 && type == GNUTLS_NAME_DNS)
2100         return;
2101     }
2102
2103   name[0] = 0;
2104
2105   return;
2106 }
2107
2108 /* finds the most appropriate certificate in the cert list.
2109  * The 'appropriate' is defined by the user.
2110  *
2111  * requested_algo holds the parameters required by the peer (RSA, DSA
2112  * or -1 for any).
2113  *
2114  * Returns 0 on success and a negative error code on error. The
2115  * selected certificate will be in session->internals.selected_*.
2116  *
2117  */
2118 int
2119 _gnutls_server_select_cert (gnutls_session_t session,
2120                             gnutls_pk_algorithm_t * pk_algos,
2121                             size_t pk_algos_size)
2122 {
2123   unsigned i, j;
2124   int idx, ret;
2125   gnutls_certificate_credentials_t cred;
2126   char server_name[MAX_CN];
2127
2128   cred = (gnutls_certificate_credentials_t)
2129     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
2130   if (cred == NULL)
2131     {
2132       gnutls_assert ();
2133       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
2134     }
2135
2136   /* If the callback which retrieves certificate has been set,
2137    * use it and leave.
2138    */
2139   if (cred->server_get_cert_callback || cred->get_cert_callback
2140       || cred->get_cert_callback2)
2141     {
2142       ret = call_get_cert_callback (session, NULL, 0, NULL, 0);
2143       if (ret < 0)
2144         return gnutls_assert_val (ret);
2145       return ret;
2146     }
2147
2148   /* Otherwise... */
2149
2150   get_server_name(session, (unsigned char*)server_name, sizeof(server_name));
2151
2152   idx = -1;                     /* default is use no certificate */
2153
2154   /* find certificates that match the requested server_name
2155    */
2156
2157   if (server_name[0] != 0)
2158     {
2159       for (i = 0; i < cred->ncerts; i++)
2160         {
2161           if (cred->certs[i].names != NULL && _gnutls_str_array_match(cred->certs[i].names, server_name) != 0)
2162             {
2163               /* if requested algorithms are also compatible select it */
2164               gnutls_pk_algorithm pk =
2165                 gnutls_pubkey_get_pk_algorithm (cred->certs[i].cert_list[0].pubkey,
2166                                             NULL);
2167
2168               _gnutls_handshake_log("HSK[%p]: Requested server name: '%s', ctype: %s (%d)", session, server_name,
2169                     gnutls_certificate_type_get_name (session->security_parameters.cert_type),
2170                     session->security_parameters.cert_type);
2171
2172               if (session->security_parameters.cert_type == cred->certs[i].cert_list[0].type)
2173                 {
2174                   for (j = 0; j < pk_algos_size; j++)
2175                   if (pk_algos[j] == pk)
2176                     {
2177                       idx = i;
2178                       goto finished;
2179                     }
2180                 }
2181             }
2182         }
2183     }
2184
2185   for (j = 0; j < pk_algos_size; j++)
2186     {
2187       _gnutls_handshake_log
2188         ("HSK[%p]: Requested PK algorithm: %s (%d) -- ctype: %s (%d)\n",
2189          session, gnutls_pk_get_name (pk_algos[j]), pk_algos[j],
2190          gnutls_certificate_type_get_name (session->security_parameters.
2191                                            cert_type),
2192          session->security_parameters.cert_type);
2193
2194       for (i = 0; i < cred->ncerts; i++)
2195         {
2196           gnutls_pk_algorithm pk =
2197             gnutls_pubkey_get_pk_algorithm (cred->certs[i].cert_list[0].pubkey,
2198                                             NULL);
2199           /* find one compatible certificate
2200            */
2201           _gnutls_handshake_log
2202             ("HSK[%p]: certificate[%d] PK algorithm: %s (%d) - ctype: %s (%d)\n",
2203              session, i, gnutls_pk_get_name (pk), pk,
2204              gnutls_certificate_type_get_name (cred->certs[i].cert_list[0].type),
2205              cred->certs[i].cert_list[0].type);
2206
2207           if (pk_algos[j] == pk)
2208             {
2209               /* if cert type matches
2210                */
2211           /* *INDENT-OFF* */
2212           if (session->security_parameters.cert_type == cred->certs[i].cert_list[0].type)
2213             {
2214               idx = i;
2215               goto finished;
2216             }
2217           /* *INDENT-ON* */
2218             }
2219         }
2220     }
2221
2222   /* store the certificate pointer for future use, in the handshake.
2223    * (This will allow not calling this callback again.)
2224    */
2225 finished:
2226   if (idx >= 0)
2227     {
2228       _gnutls_selected_certs_set (session,
2229                                   &cred->certs[idx].cert_list[0],
2230                                   cred->certs[idx].cert_list_length,
2231                                   cred->pkey[idx], 0);
2232     }
2233   else
2234     {
2235       gnutls_assert ();
2236       /* Certificate does not support REQUESTED_ALGO.  */
2237       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
2238     }
2239
2240   return 0;
2241 }
2242
2243 /* Frees the rsa_info_st structure.
2244  */
2245 void
2246 _gnutls_free_rsa_info (rsa_info_st * rsa)
2247 {
2248   _gnutls_free_datum (&rsa->modulus);
2249   _gnutls_free_datum (&rsa->exponent);
2250 }