lib/gnutls_ui.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 /* This file contains certificate authentication functions to be exported in the
  24  * API which did not fit elsewhere.
  25  */
  26
  27 #include <gnutls_int.h>
  28 #include <auth/srp.h>
  29 #include <auth/anon.h>
  30 #include <auth/cert.h>
  31 #include <auth/psk.h>
  32 #include <gnutls_errors.h>
  33 #include <gnutls_auth.h>
  34 #include <gnutls_state.h>
  35 #include <gnutls_datum.h>
  36 #include <extras/randomart.h>
  37
  38 /**
  39  * gnutls_random_art:
  40  * @type: The type of the random art
  41  * @key_type: The type of the key (RSA, DSA etc.)
  42  * @key_size: The size of the key in bits
  43  * @fpr: The fingerprint of the key
  44  * @fpr_size: The size of the fingerprint
  45  * @art: The returned random art
  46  *
  47  * This function will convert a given fingerprint to an "artistic"
  48  * image. The returned image is allocated using gnutls_malloc()
  49  *
  50  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
  51  *   an error code is returned.
  52  *
  53  **/
  54 int gnutls_random_art (gnutls_random_art_t type,
  55                        const char* key_type, unsigned int key_size,
  56                        void * fpr, size_t fpr_size,
  57                        gnutls_datum_t* art)
  58 {
  59   if (type != GNUTLS_RANDOM_ART_OPENSSH)
  60     return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
  61
  62   art->data = (void*)_gnutls_key_fingerprint_randomart(fpr, fpr_size, key_type, key_size, NULL);
  63   if (art->data == NULL)
  64     return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
  65
  66   art->size = strlen((char*)art->data);
  67
  68   return 0;
  69 }
  70
  71 /* ANON & DHE */
  72
  73 /**
  74  * gnutls_dh_set_prime_bits:
  75  * @session: is a #gnutls_session_t structure.
  76  * @bits: is the number of bits
  77  *
  78  * This function sets the number of bits, for use in a Diffie-Hellman
  79  * key exchange.  This is used both in DH ephemeral and DH anonymous
  80  * cipher suites.  This will set the minimum size of the prime that
  81  * will be used for the handshake.
  82  *
  83  * In the client side it sets the minimum accepted number of bits.  If
  84  * a server sends a prime with less bits than that
  85  * %GNUTLS_E_DH_PRIME_UNACCEPTABLE will be returned by the handshake.
  86  *
  87  * Note that values lower than 512 bits may allow decryption of the
  88  * exchanged data.
  89  *
  90  * This function has no effect in server side.
  91  *
  92  **/
  93 void
  94 gnutls_dh_set_prime_bits (gnutls_session_t session, unsigned int bits)
  95 {
  96   if (bits < 512) _gnutls_audit_log(session, "Note that the security level of the Diffie-Hellman key exchange has been lowered to %u bits and this may allow decryption of the session data\n", bits);
  97   session->internals.dh_prime_bits = bits;
  98 }
  99
 100
 101 /**
 102  * gnutls_dh_get_group:
 103  * @session: is a gnutls session
 104  * @raw_gen: will hold the generator.
 105  * @raw_prime: will hold the prime.
 106  *
 107  * This function will return the group parameters used in the last
 108  * Diffie-Hellman key exchange with the peer.  These are the prime and
 109  * the generator used.  This function should be used for both
 110  * anonymous and ephemeral Diffie-Hellman.  The output parameters must
 111  * be freed with gnutls_free().
 112  *
 113  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 114  *   an error code is returned.
 115  **/
 116 int
 117 gnutls_dh_get_group (gnutls_session_t session,
 118                      gnutls_datum_t * raw_gen, gnutls_datum_t * raw_prime)
 119 {
 120   dh_info_st *dh;
 121   int ret;
 122   anon_auth_info_t anon_info;
 123   cert_auth_info_t cert_info;
 124   psk_auth_info_t psk_info;
 125
 126   switch (gnutls_auth_get_type (session))
 127     {
 128     case GNUTLS_CRD_ANON:
 129       anon_info = _gnutls_get_auth_info (session);
 130       if (anon_info == NULL)
 131         return GNUTLS_E_INTERNAL_ERROR;
 132       dh = &anon_info->dh;
 133       break;
 134     case GNUTLS_CRD_PSK:
 135       psk_info = _gnutls_get_auth_info (session);
 136       if (psk_info == NULL)
 137         return GNUTLS_E_INTERNAL_ERROR;
 138       dh = &psk_info->dh;
 139       break;
 140     case GNUTLS_CRD_CERTIFICATE:
 141       cert_info = _gnutls_get_auth_info (session);
 142       if (cert_info == NULL)
 143         return GNUTLS_E_INTERNAL_ERROR;
 144       dh = &cert_info->dh;
 145       break;
 146     default:
 147       gnutls_assert ();
 148       return GNUTLS_E_INVALID_REQUEST;
 149     }
 150
 151   ret = _gnutls_set_datum (raw_prime, dh->prime.data, dh->prime.size);
 152   if (ret < 0)
 153     {
 154       gnutls_assert ();
 155       return ret;
 156     }
 157
 158   ret = _gnutls_set_datum (raw_gen, dh->generator.data, dh->generator.size);
 159   if (ret < 0)
 160     {
 161       gnutls_assert ();
 162       _gnutls_free_datum (raw_prime);
 163       return ret;
 164     }
 165
 166   return 0;
 167 }
 168
 169 /**
 170  * gnutls_dh_get_pubkey:
 171  * @session: is a gnutls session
 172  * @raw_key: will hold the public key.
 173  *
 174  * This function will return the peer's public key used in the last
 175  * Diffie-Hellman key exchange.  This function should be used for both
 176  * anonymous and ephemeral Diffie-Hellman.  The output parameters must
 177  * be freed with gnutls_free().
 178  *
 179  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 180  *   an error code is returned.
 181  **/
 182 int
 183 gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
 184 {
 185   dh_info_st *dh;
 186   anon_auth_info_t anon_info;
 187   cert_auth_info_t cert_info;
 188   cert_auth_info_t psk_info;
 189
 190   switch (gnutls_auth_get_type (session))
 191     {
 192     case GNUTLS_CRD_ANON:
 193       {
 194         anon_info = _gnutls_get_auth_info (session);
 195         if (anon_info == NULL)
 196           return GNUTLS_E_INTERNAL_ERROR;
 197         dh = &anon_info->dh;
 198         break;
 199       }
 200     case GNUTLS_CRD_PSK:
 201       {
 202         psk_info = _gnutls_get_auth_info (session);
 203         if (psk_info == NULL)
 204           return GNUTLS_E_INTERNAL_ERROR;
 205         dh = &psk_info->dh;
 206         break;
 207       }
 208     case GNUTLS_CRD_CERTIFICATE:
 209       {
 210
 211         cert_info = _gnutls_get_auth_info (session);
 212         if (cert_info == NULL)
 213           return GNUTLS_E_INTERNAL_ERROR;
 214         dh = &cert_info->dh;
 215         break;
 216       }
 217     default:
 218       gnutls_assert ();
 219       return GNUTLS_E_INVALID_REQUEST;
 220     }
 221
 222   return _gnutls_set_datum (raw_key, dh->public_key.data,
 223                             dh->public_key.size);
 224 }
 225
 226 /**
 227  * gnutls_rsa_export_get_pubkey:
 228  * @session: is a gnutls session
 229  * @exponent: will hold the exponent.
 230  * @modulus: will hold the modulus.
 231  *
 232  * This function will return the peer's public key exponent and
 233  * modulus used in the last RSA-EXPORT authentication.  The output
 234  * parameters must be freed with gnutls_free().
 235  *
 236  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 237  *   an error code is returned.
 238  **/
 239 int
 240 gnutls_rsa_export_get_pubkey (gnutls_session_t session,
 241                               gnutls_datum_t * exponent,
 242                               gnutls_datum_t * modulus)
 243 {
 244   cert_auth_info_t info;
 245   int ret;
 246
 247   if (gnutls_auth_get_type (session) == GNUTLS_CRD_CERTIFICATE)
 248     {
 249       info = _gnutls_get_auth_info (session);
 250       if (info == NULL)
 251         return GNUTLS_E_INTERNAL_ERROR;
 252
 253       ret = _gnutls_set_datum (modulus, info->rsa_export.modulus.data,
 254                                info->rsa_export.modulus.size);
 255       if (ret < 0)
 256         {
 257           gnutls_assert ();
 258           return ret;
 259         }
 260
 261       ret = _gnutls_set_datum (exponent, info->rsa_export.exponent.data,
 262                                info->rsa_export.exponent.size);
 263       if (ret < 0)
 264         {
 265           gnutls_assert ();
 266           _gnutls_free_datum (modulus);
 267           return ret;
 268         }
 269
 270       return 0;
 271     }
 272
 273   return GNUTLS_E_INVALID_REQUEST;
 274 }
 275
 276
 277 /**
 278  * gnutls_dh_get_secret_bits:
 279  * @session: is a gnutls session
 280  *
 281  * This function will return the bits used in the last Diffie-Hellman
 282  * key exchange with the peer.  Should be used for both anonymous and
 283  * ephemeral Diffie-Hellman.
 284  *
 285  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 286  *   an error code is returned.
 287  **/
 288 int
 289 gnutls_dh_get_secret_bits (gnutls_session_t session)
 290 {
 291   switch (gnutls_auth_get_type (session))
 292     {
 293     case GNUTLS_CRD_ANON:
 294       {
 295         anon_auth_info_t info;
 296
 297         info = _gnutls_get_auth_info (session);
 298         if (info == NULL)
 299           return GNUTLS_E_INTERNAL_ERROR;
 300         return info->dh.secret_bits;
 301       }
 302     case GNUTLS_CRD_PSK:
 303       {
 304         psk_auth_info_t info;
 305
 306         info = _gnutls_get_auth_info (session);
 307         if (info == NULL)
 308           return GNUTLS_E_INTERNAL_ERROR;
 309         return info->dh.secret_bits;
 310       }
 311     case GNUTLS_CRD_CERTIFICATE:
 312       {
 313         cert_auth_info_t info;
 314
 315         info = _gnutls_get_auth_info (session);
 316         if (info == NULL)
 317           return GNUTLS_E_INTERNAL_ERROR;
 318
 319         return info->dh.secret_bits;
 320       }
 321     default:
 322       gnutls_assert ();
 323       return GNUTLS_E_INVALID_REQUEST;
 324     }
 325 }
 326
 327 static int
 328 mpi_buf2bits (gnutls_datum_t * mpi_buf)
 329 {
 330   bigint_t mpi;
 331   int rc;
 332
 333   rc = _gnutls_mpi_scan_nz (&mpi, mpi_buf->data, mpi_buf->size);
 334   if (rc)
 335     {
 336       gnutls_assert ();
 337       return rc;
 338     }
 339
 340   rc = _gnutls_mpi_get_nbits (mpi);
 341   _gnutls_mpi_release (&mpi);
 342
 343   return rc;
 344 }
 345
 346 /**
 347  * gnutls_dh_get_prime_bits:
 348  * @session: is a gnutls session
 349  *
 350  * This function will return the bits of the prime used in the last
 351  * Diffie-Hellman key exchange with the peer.  Should be used for both
 352  * anonymous and ephemeral Diffie-Hellman.  Note that some ciphers,
 353  * like RSA and DSA without DHE, do not use a Diffie-Hellman key
 354  * exchange, and then this function will return 0.
 355  *
 356  * Returns: The Diffie-Hellman bit strength is returned, or 0 if no
 357  *   Diffie-Hellman key exchange was done, or a negative error code on
 358  *   failure.
 359  **/
 360 int
 361 gnutls_dh_get_prime_bits (gnutls_session_t session)
 362 {
 363   dh_info_st *dh;
 364
 365   switch (gnutls_auth_get_type (session))
 366     {
 367     case GNUTLS_CRD_ANON:
 368       {
 369         anon_auth_info_t info;
 370
 371         info = _gnutls_get_auth_info (session);
 372         if (info == NULL)
 373           return GNUTLS_E_INTERNAL_ERROR;
 374         dh = &info->dh;
 375         break;
 376       }
 377     case GNUTLS_CRD_PSK:
 378       {
 379         psk_auth_info_t info;
 380
 381         info = _gnutls_get_auth_info (session);
 382         if (info == NULL)
 383           return GNUTLS_E_INTERNAL_ERROR;
 384         dh = &info->dh;
 385         break;
 386       }
 387     case GNUTLS_CRD_CERTIFICATE:
 388       {
 389         cert_auth_info_t info;
 390
 391         info = _gnutls_get_auth_info (session);
 392         if (info == NULL)
 393           return GNUTLS_E_INTERNAL_ERROR;
 394
 395         dh = &info->dh;
 396         break;
 397       }
 398     default:
 399       gnutls_assert ();
 400       return GNUTLS_E_INVALID_REQUEST;
 401     }
 402
 403   return mpi_buf2bits (&dh->prime);
 404 }
 405
 406 /**
 407  * gnutls_rsa_export_get_modulus_bits:
 408  * @session: is a gnutls session
 409  *
 410  * Get the export RSA parameter's modulus size.
 411  *
 412  * Returns: The bits used in the last RSA-EXPORT key exchange with the
 413  *   peer, or a negative error code in case of error.
 414  **/
 415 int
 416 gnutls_rsa_export_get_modulus_bits (gnutls_session_t session)
 417 {
 418   cert_auth_info_t info;
 419
 420   info = _gnutls_get_auth_info (session);
 421   if (info == NULL)
 422     return GNUTLS_E_INTERNAL_ERROR;
 423
 424   return mpi_buf2bits (&info->rsa_export.modulus);
 425 }
 426
 427 /**
 428  * gnutls_dh_get_peers_public_bits:
 429  * @session: is a gnutls session
 430  *
 431  * Get the Diffie-Hellman public key bit size.  Can be used for both
 432  * anonymous and ephemeral Diffie-Hellman.
 433  *
 434  * Returns: The public key bit size used in the last Diffie-Hellman
 435  *   key exchange with the peer, or a negative error code in case of error.
 436  **/
 437 int
 438 gnutls_dh_get_peers_public_bits (gnutls_session_t session)
 439 {
 440   dh_info_st *dh;
 441
 442   switch (gnutls_auth_get_type (session))
 443     {
 444     case GNUTLS_CRD_ANON:
 445       {
 446         anon_auth_info_t info;
 447
 448         info = _gnutls_get_auth_info (session);
 449         if (info == NULL)
 450           return GNUTLS_E_INTERNAL_ERROR;
 451
 452         dh = &info->dh;
 453         break;
 454       }
 455     case GNUTLS_CRD_PSK:
 456       {
 457         psk_auth_info_t info;
 458
 459         info = _gnutls_get_auth_info (session);
 460         if (info == NULL)
 461           return GNUTLS_E_INTERNAL_ERROR;
 462
 463         dh = &info->dh;
 464         break;
 465       }
 466     case GNUTLS_CRD_CERTIFICATE:
 467       {
 468         cert_auth_info_t info;
 469
 470         info = _gnutls_get_auth_info (session);
 471         if (info == NULL)
 472           return GNUTLS_E_INTERNAL_ERROR;
 473
 474         dh = &info->dh;
 475         break;
 476       }
 477     default:
 478       gnutls_assert ();
 479       return GNUTLS_E_INVALID_REQUEST;
 480     }
 481
 482   return mpi_buf2bits (&dh->public_key);
 483 }
 484
 485 /* CERTIFICATE STUFF */
 486
 487 /**
 488  * gnutls_certificate_get_ours:
 489  * @session: is a gnutls session
 490  *
 491  * Gets the certificate as sent to the peer in the last handshake.
 492  * The certificate is in raw (DER) format.  No certificate
 493  * list is being returned. Only the first certificate.
 494  *
 495  * Returns: a pointer to a #gnutls_datum_t containing our
 496  *   certificate, or %NULL in case of an error or if no certificate
 497  *   was used.
 498  **/
 499 const gnutls_datum_t *
 500 gnutls_certificate_get_ours (gnutls_session_t session)
 501 {
 502   gnutls_certificate_credentials_t cred;
 503
 504   CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, NULL);
 505
 506   cred = (gnutls_certificate_credentials_t)
 507     _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
 508   if (cred == NULL || cred->certs == NULL)
 509     {
 510       gnutls_assert ();
 511       return NULL;
 512     }
 513
 514   if (session->internals.selected_cert_list == NULL)
 515     return NULL;
 516
 517   return &session->internals.selected_cert_list[0].cert;
 518 }
 519
 520 /**
 521  * gnutls_certificate_get_peers:
 522  * @session: is a gnutls session
 523  * @list_size: is the length of the certificate list
 524  *
 525  * Get the peer's raw certificate (chain) as sent by the peer.  These
 526  * certificates are in raw format (DER encoded for X.509).  In case of
 527  * a X.509 then a certificate list may be present.  The first
 528  * certificate in the list is the peer's certificate, following the
 529  * issuer's certificate, then the issuer's issuer etc.
 530  *
 531  * In case of OpenPGP keys a single key will be returned in raw
 532  * format.
 533  *
 534  * Returns: a pointer to a #gnutls_datum_t containing our
 535  *   certificates, or %NULL in case of an error or if no certificate
 536  *   was used.
 537  **/
 538 const gnutls_datum_t *
 539 gnutls_certificate_get_peers (gnutls_session_t
 540                               session, unsigned int *list_size)
 541 {
 542   cert_auth_info_t info;
 543
 544   CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, NULL);
 545
 546   info = _gnutls_get_auth_info (session);
 547   if (info == NULL)
 548     return NULL;
 549
 550   *list_size = info->ncerts;
 551   return info->raw_certificate_list;
 552 }
 553
 554
 555 /**
 556  * gnutls_certificate_client_get_request_status:
 557  * @session: is a gnutls session
 558  *
 559  * Get whether client certificate is requested or not.
 560  *
 561  * Returns: 0 if the peer (server) did not request client
 562  *   authentication or 1 otherwise, or a negative error code in case of
 563  *   error.
 564  **/
 565 int
 566 gnutls_certificate_client_get_request_status (gnutls_session_t session)
 567 {
 568   return session->key->crt_requested;
 569 }
 570
 571 /**
 572  * gnutls_fingerprint:
 573  * @algo: is a digest algorithm
 574  * @data: is the data
 575  * @result: is the place where the result will be copied (may be null).
 576  * @result_size: should hold the size of the result. The actual size
 577  * of the returned result will also be copied there.
 578  *
 579  * This function will calculate a fingerprint (actually a hash), of
 580  * the given data.  The result is not printable data.  You should
 581  * convert it to hex, or to something else printable.
 582  *
 583  * This is the usual way to calculate a fingerprint of an X.509 DER
 584  * encoded certificate.  Note however that the fingerprint of an
 585  * OpenPGP is not just a hash and cannot be calculated with this
 586  * function.
 587  *
 588  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 589  *   an error code is returned.
 590  **/
 591 int
 592 gnutls_fingerprint (gnutls_digest_algorithm_t algo,
 593                     const gnutls_datum_t * data, void *result,
 594                     size_t * result_size)
 595 {
 596   int ret;
 597   int hash_len = _gnutls_hash_get_algo_len (algo);
 598
 599   if (hash_len < 0 || (unsigned) hash_len > *result_size || result == NULL)
 600     {
 601       *result_size = hash_len;
 602       return GNUTLS_E_SHORT_MEMORY_BUFFER;
 603     }
 604   *result_size = hash_len;
 605
 606   if (result)
 607     {
 608       ret = _gnutls_hash_fast( algo, data->data, data->size, result);
 609       if (ret < 0)
 610         return gnutls_assert_val(ret);
 611     }
 612
 613   return 0;
 614 }
 615
 616
 617 /**
 618  * gnutls_certificate_set_dh_params:
 619  * @res: is a gnutls_certificate_credentials_t structure
 620  * @dh_params: is a structure that holds Diffie-Hellman parameters.
 621  *
 622  * This function will set the Diffie-Hellman parameters for a
 623  * certificate server to use. These parameters will be used in
 624  * Ephemeral Diffie-Hellman cipher suites.  Note that only a pointer
 625  * to the parameters are stored in the certificate handle, so if you
 626  * deallocate the parameters before the certificate is deallocated,
 627  * you must change the parameters stored in the certificate first.
 628  *
 629  **/
 630 void
 631 gnutls_certificate_set_dh_params (gnutls_certificate_credentials_t res,
 632                                   gnutls_dh_params_t dh_params)
 633 {
 634   res->dh_params = dh_params;
 635 }
 636
 637 /**
 638  * gnutls_certificate_set_params_function:
 639  * @res: is a gnutls_certificate_credentials_t structure
 640  * @func: is the function to be called
 641  *
 642  * This function will set a callback in order for the server to get
 643  * the Diffie-Hellman or RSA parameters for certificate
 644  * authentication.  The callback should return %GNUTLS_E_SUCCESS (0) on success.
 645  **/
 646 void
 647 gnutls_certificate_set_params_function (gnutls_certificate_credentials_t res,
 648                                         gnutls_params_function * func)
 649 {
 650   res->params_func = func;
 651 }
 652
 653
 654 /**
 655  * gnutls_certificate_set_verify_flags:
 656  * @res: is a gnutls_certificate_credentials_t structure
 657  * @flags: are the flags
 658  *
 659  * This function will set the flags to be used at verification of the
 660  * certificates.  Flags must be OR of the
 661  * #gnutls_certificate_verify_flags enumerations.
 662  *
 663  **/
 664 void
 665 gnutls_certificate_set_verify_flags (gnutls_certificate_credentials_t
 666                                      res, unsigned int flags)
 667 {
 668   res->verify_flags = flags;
 669 }
 670
 671 /**
 672  * gnutls_certificate_set_verify_limits:
 673  * @res: is a gnutls_certificate_credentials structure
 674  * @max_bits: is the number of bits of an acceptable certificate (default 8200)
 675  * @max_depth: is maximum depth of the verification of a certificate chain (default 5)
 676  *
 677  * This function will set some upper limits for the default
 678  * verification function, gnutls_certificate_verify_peers2(), to avoid
 679  * denial of service attacks.  You can set them to zero to disable
 680  * limits.
 681  **/
 682 void
 683 gnutls_certificate_set_verify_limits (gnutls_certificate_credentials_t res,
 684                                       unsigned int max_bits,
 685                                       unsigned int max_depth)
 686 {
 687   res->verify_depth = max_depth;
 688   res->verify_bits = max_bits;
 689 }
 690
 691 /**
 692  * gnutls_certificate_set_rsa_export_params:
 693  * @res: is a gnutls_certificate_credentials_t structure
 694  * @rsa_params: is a structure that holds temporary RSA parameters.
 695  *
 696  * This function will set the temporary RSA parameters for a
 697  * certificate server to use.  These parameters will be used in
 698  * RSA-EXPORT cipher suites.
 699  **/
 700 void
 701 gnutls_certificate_set_rsa_export_params (gnutls_certificate_credentials_t
 702                                           res, gnutls_rsa_params_t rsa_params)
 703 {
 704   res->rsa_params = rsa_params;
 705 }
 706
 707 /**
 708  * gnutls_psk_set_params_function:
 709  * @res: is a gnutls_psk_server_credentials_t structure
 710  * @func: is the function to be called
 711  *
 712  * This function will set a callback in order for the server to get
 713  * the Diffie-Hellman or RSA parameters for PSK authentication.  The
 714  * callback should return %GNUTLS_E_SUCCESS (0) on success.
 715  **/
 716 void
 717 gnutls_psk_set_params_function (gnutls_psk_server_credentials_t res,
 718                                 gnutls_params_function * func)
 719 {
 720   res->params_func = func;
 721 }
 722
 723 /**
 724  * gnutls_anon_set_params_function:
 725  * @res: is a gnutls_anon_server_credentials_t structure
 726  * @func: is the function to be called
 727  *
 728  * This function will set a callback in order for the server to get
 729  * the Diffie-Hellman or RSA parameters for anonymous authentication.
 730  * The callback should return %GNUTLS_E_SUCCESS (0) on success.
 731  **/
 732 void
 733 gnutls_anon_set_params_function (gnutls_anon_server_credentials_t res,
 734                                  gnutls_params_function * func)
 735 {
 736   res->params_func = func;
 737 }