doc/ssl/ssl.pod

   1
   2 =pod
   3
   4 =head1 NAME
   5
   6 SSL - OpenSSL SSL/TLS library
   7
   8 =head1 SYNOPSIS
   9
  10 =head1 DESCRIPTION
  11
  12 The OpenSSL B<ssl> library implements the Secure Sockets Layer (SSL v2/v3) and
  13 Transport Layer Security (TLS v1) protocols. It provides a rich API which is
  14 documented here.
  15
  16 Then an B<SSL_CTX> object is created as a framework to establish
  17 TLS/SSL enabled connections (see L<SSL_CTX_new(3)>).
  18 Various options regarding certificates, algorithms etc. can be set
  19 in this object.
  20
  21 When a network connection has been created, it can be assigned to an
  22 B<SSL> object. After the B<SSL> object has been created using
  23 L<SSL_new(3)>, L<SSL_set_fd(3)> or
  24 L<SSL_set_bio(3)> can be used to associate the network
  25 connection with the object.
  26
  27 Then the TLS/SSL handshake is performed using
  28 L<SSL_accept(3)> or L<SSL_connect(3)>
  29 respectively.
  30 L<SSL_read(3)> and L<SSL_write(3)> are used
  31 to read and write data on the TLS/SSL connection.
  32 L<SSL_shutdown(3)> can be used to shut down the
  33 TLS/SSL connection.
  34
  35 =head1 DATA STRUCTURES
  36
  37 Currently the OpenSSL B<ssl> library functions deals with the following data
  38 structures:
  39
  40 =over 4
  41
  42 =item B<SSL_METHOD> (SSL Method)
  43
  44 That's a dispatch structure describing the internal B<ssl> library
  45 methods/functions which implement the various protocol versions (SSLv3
  46 TLSv1, ...). It's needed to create an B<SSL_CTX>.
  47
  48 =item B<SSL_CIPHER> (SSL Cipher)
  49
  50 This structure holds the algorithm information for a particular cipher which
  51 are a core part of the SSL/TLS protocol. The available ciphers are configured
  52 on a B<SSL_CTX> basis and the actually used ones are then part of the
  53 B<SSL_SESSION>.
  54
  55 =item B<SSL_CTX> (SSL Context)
  56
  57 That's the global context structure which is created by a server or client
  58 once per program life-time and which holds mainly default values for the
  59 B<SSL> structures which are later created for the connections.
  60
  61 =item B<SSL_SESSION> (SSL Session)
  62
  63 This is a structure containing the current TLS/SSL session details for a
  64 connection: B<SSL_CIPHER>s, client and server certificates, keys, etc.
  65
  66 =item B<SSL> (SSL Connection)
  67
  68 That's the main SSL/TLS structure which is created by a server or client per
  69 established connection. This actually is the core structure in the SSL API.
  70 Under run-time the application usually deals with this structure which has
  71 links to mostly all other structures.
  72
  73 =back
  74
  75
  76 =head1 HEADER FILES
  77
  78 Currently the OpenSSL B<ssl> library provides the following C header files
  79 containing the prototypes for the data structures and and functions:
  80
  81 =over 4
  82
  83 =item B<ssl.h>
  84
  85 That's the common header file for the SSL/TLS API.  Include it into your
  86 program to make the API of the B<ssl> library available. It internally
  87 includes both more private SSL headers and headers from the B<crypto> library.
  88 Whenever you need hard-core details on the internals of the SSL API, look
  89 inside this header file.
  90
  91 =item B<ssl2.h>
  92
  93 Unused. Present for backwards compatibility only.
  94
  95 =item B<ssl3.h>
  96
  97 That's the sub header file dealing with the SSLv3 protocol only.
  98 I<Usually you don't have to include it explicitly because
  99 it's already included by ssl.h>.
 100
 101 =item B<tls1.h>
 102
 103 That's the sub header file dealing with the TLSv1 protocol only.
 104 I<Usually you don't have to include it explicitly because
 105 it's already included by ssl.h>.
 106
 107 =back
 108
 109 =head1 API FUNCTIONS
 110
 111 Currently the OpenSSL B<ssl> library exports 214 API functions.
 112 They are documented in the following:
 113
 114 =head2 DEALING WITH PROTOCOL METHODS
 115
 116 Here we document the various API functions which deal with the SSL/TLS
 117 protocol methods defined in B<SSL_METHOD> structures.
 118
 119 =over 4
 120
 121 =item const SSL_METHOD *B<SSLv3_client_method>(void);
 122
 123 Constructor for the SSLv3 SSL_METHOD structure for a dedicated client.
 124
 125 =item const SSL_METHOD *B<SSLv3_server_method>(void);
 126
 127 Constructor for the SSLv3 SSL_METHOD structure for a dedicated server.
 128
 129 =item const SSL_METHOD *B<SSLv3_method>(void);
 130
 131 Constructor for the SSLv3 SSL_METHOD structure for combined client and server.
 132
 133 =item const SSL_METHOD *B<TLSv1_client_method>(void);
 134
 135 Constructor for the TLSv1 SSL_METHOD structure for a dedicated client.
 136
 137 =item const SSL_METHOD *B<TLSv1_server_method>(void);
 138
 139 Constructor for the TLSv1 SSL_METHOD structure for a dedicated server.
 140
 141 =item const SSL_METHOD *B<TLSv1_method>(void);
 142
 143 Constructor for the TLSv1 SSL_METHOD structure for combined client and server.
 144
 145 =back
 146
 147 =head2 DEALING WITH CIPHERS
 148
 149 Here we document the various API functions which deal with the SSL/TLS
 150 ciphers defined in B<SSL_CIPHER> structures.
 151
 152 =over 4
 153
 154 =item char *B<SSL_CIPHER_description>(SSL_CIPHER *cipher, char *buf, int len);
 155
 156 Write a string to I<buf> (with a maximum size of I<len>) containing a human
 157 readable description of I<cipher>. Returns I<buf>.
 158
 159 =item int B<SSL_CIPHER_get_bits>(SSL_CIPHER *cipher, int *alg_bits);
 160
 161 Determine the number of bits in I<cipher>. Because of export crippled ciphers
 162 there are two bits: The bits the algorithm supports in general (stored to
 163 I<alg_bits>) and the bits which are actually used (the return value).
 164
 165 =item const char *B<SSL_CIPHER_get_name>(SSL_CIPHER *cipher);
 166
 167 Return the internal name of I<cipher> as a string. These are the various
 168 strings defined by the I<SSL3_TXT_xxx> and I<TLS1_TXT_xxx>
 169 definitions in the header files.
 170
 171 =item char *B<SSL_CIPHER_get_version>(SSL_CIPHER *cipher);
 172
 173 Returns a string like "C<SSLv3>" or "C<TLSv1.2>" which indicates the
 174 SSL/TLS protocol version to which I<cipher> belongs (i.e. where it was defined
 175 in the specification the first time).
 176
 177 =back
 178
 179 =head2 DEALING WITH PROTOCOL CONTEXTS
 180
 181 Here we document the various API functions which deal with the SSL/TLS
 182 protocol context defined in the B<SSL_CTX> structure.
 183
 184 =over 4
 185
 186 =item int B<SSL_CTX_add_client_CA>(SSL_CTX *ctx, X509 *x);
 187
 188 =item long B<SSL_CTX_add_extra_chain_cert>(SSL_CTX *ctx, X509 *x509);
 189
 190 =item int B<SSL_CTX_add_session>(SSL_CTX *ctx, SSL_SESSION *c);
 191
 192 =item int B<SSL_CTX_check_private_key>(const SSL_CTX *ctx);
 193
 194 =item long B<SSL_CTX_ctrl>(SSL_CTX *ctx, int cmd, long larg, char *parg);
 195
 196 =item void B<SSL_CTX_flush_sessions>(SSL_CTX *s, long t);
 197
 198 =item void B<SSL_CTX_free>(SSL_CTX *a);
 199
 200 =item char *B<SSL_CTX_get_app_data>(SSL_CTX *ctx);
 201
 202 =item X509_STORE *B<SSL_CTX_get_cert_store>(SSL_CTX *ctx);
 203
 204 =item STACK *B<SSL_CTX_get_client_CA_list>(const SSL_CTX *ctx);
 205
 206 =item int (*B<SSL_CTX_get_client_cert_cb>(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
 207
 208 =item void B<SSL_CTX_get_default_read_ahead>(SSL_CTX *ctx);
 209
 210 =item char *B<SSL_CTX_get_ex_data>(const SSL_CTX *s, int idx);
 211
 212 =item int B<SSL_CTX_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
 213
 214 =item void (*B<SSL_CTX_get_info_callback>(SSL_CTX *ctx))(SSL *ssl, int cb, int ret);
 215
 216 =item int B<SSL_CTX_get_quiet_shutdown>(const SSL_CTX *ctx);
 217
 218 =item void B<SSL_CTX_get_read_ahead>(SSL_CTX *ctx);
 219
 220 =item int B<SSL_CTX_get_session_cache_mode>(SSL_CTX *ctx);
 221
 222 =item long B<SSL_CTX_get_timeout>(const SSL_CTX *ctx);
 223
 224 =item int (*B<SSL_CTX_get_verify_callback>(const SSL_CTX *ctx))(int ok, X509_STORE_CTX *ctx);
 225
 226 =item int B<SSL_CTX_get_verify_mode>(SSL_CTX *ctx);
 227
 228 =item int B<SSL_CTX_load_verify_locations>(SSL_CTX *ctx, char *CAfile, char *CApath);
 229
 230 =item long B<SSL_CTX_need_tmp_RSA>(SSL_CTX *ctx);
 231
 232 =item SSL_CTX *B<SSL_CTX_new>(const SSL_METHOD *meth);
 233
 234 =item void SSL_CTX_up_ref(SSL_CTX *ctx);
 235
 236 =item int B<SSL_CTX_remove_session>(SSL_CTX *ctx, SSL_SESSION *c);
 237
 238 =item int B<SSL_CTX_sess_accept>(SSL_CTX *ctx);
 239
 240 =item int B<SSL_CTX_sess_accept_good>(SSL_CTX *ctx);
 241
 242 =item int B<SSL_CTX_sess_accept_renegotiate>(SSL_CTX *ctx);
 243
 244 =item int B<SSL_CTX_sess_cache_full>(SSL_CTX *ctx);
 245
 246 =item int B<SSL_CTX_sess_cb_hits>(SSL_CTX *ctx);
 247
 248 =item int B<SSL_CTX_sess_connect>(SSL_CTX *ctx);
 249
 250 =item int B<SSL_CTX_sess_connect_good>(SSL_CTX *ctx);
 251
 252 =item int B<SSL_CTX_sess_connect_renegotiate>(SSL_CTX *ctx);
 253
 254 =item int B<SSL_CTX_sess_get_cache_size>(SSL_CTX *ctx);
 255
 256 =item SSL_SESSION *(*B<SSL_CTX_sess_get_get_cb>(SSL_CTX *ctx))(SSL *ssl, unsigned char *data, int len, int *copy);
 257
 258 =item int (*B<SSL_CTX_sess_get_new_cb>(SSL_CTX *ctx)(SSL *ssl, SSL_SESSION *sess);
 259
 260 =item void (*B<SSL_CTX_sess_get_remove_cb>(SSL_CTX *ctx)(SSL_CTX *ctx, SSL_SESSION *sess);
 261
 262 =item int B<SSL_CTX_sess_hits>(SSL_CTX *ctx);
 263
 264 =item int B<SSL_CTX_sess_misses>(SSL_CTX *ctx);
 265
 266 =item int B<SSL_CTX_sess_number>(SSL_CTX *ctx);
 267
 268 =item void B<SSL_CTX_sess_set_cache_size>(SSL_CTX *ctx,t);
 269
 270 =item void B<SSL_CTX_sess_set_get_cb>(SSL_CTX *ctx, SSL_SESSION *(*cb)(SSL *ssl, unsigned char *data, int len, int *copy));
 271
 272 =item void B<SSL_CTX_sess_set_new_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, SSL_SESSION *sess));
 273
 274 =item void B<SSL_CTX_sess_set_remove_cb>(SSL_CTX *ctx, void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess));
 275
 276 =item int B<SSL_CTX_sess_timeouts>(SSL_CTX *ctx);
 277
 278 =item LHASH *B<SSL_CTX_sessions>(SSL_CTX *ctx);
 279
 280 =item void B<SSL_CTX_set_app_data>(SSL_CTX *ctx, void *arg);
 281
 282 =item void B<SSL_CTX_set_cert_store>(SSL_CTX *ctx, X509_STORE *cs);
 283
 284 =item void B<SSL_CTX_set_cert_verify_cb>(SSL_CTX *ctx, int (*cb)(), char *arg)
 285
 286 =item int B<SSL_CTX_set_cipher_list>(SSL_CTX *ctx, char *str);
 287
 288 =item void B<SSL_CTX_set_client_CA_list>(SSL_CTX *ctx, STACK *list);
 289
 290 =item void B<SSL_CTX_set_client_cert_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey));
 291
 292 =item void B<SSL_CTX_set_default_passwd_cb>(SSL_CTX *ctx, int (*cb);(void))
 293
 294 =item void B<SSL_CTX_set_default_read_ahead>(SSL_CTX *ctx, int m);
 295
 296 =item int B<SSL_CTX_set_default_verify_paths>(SSL_CTX *ctx);
 297
 298 Use the default paths to locate trusted CA certificates. There is one default
 299 directory path and one default file path. Both are set via this call.
 300
 301 =item int B<SSL_CTX_set_default_verify_dir>(SSL_CTX *ctx)
 302
 303 Use the default directory path to locate trusted CA certficates.
 304
 305 =item int B<SSL_CTX_set_default_verify_file>(SSL_CTX *ctx)
 306
 307 Use the file path to locate trusted CA certficates.
 308
 309 =item int B<SSL_CTX_set_ex_data>(SSL_CTX *s, int idx, char *arg);
 310
 311 =item void B<SSL_CTX_set_info_callback>(SSL_CTX *ctx, void (*cb)(SSL *ssl, int cb, int ret));
 312
 313 =item void B<SSL_CTX_set_msg_callback>(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
 314
 315 =item void B<SSL_CTX_set_msg_callback_arg>(SSL_CTX *ctx, void *arg);
 316
 317 =item unsigned long B<SSL_CTX_clear_options>(SSL_CTX *ctx, unsigned long op);
 318
 319 =item unsigned long B<SSL_CTX_get_options>(SSL_CTX *ctx);
 320
 321 =item unsigned long B<SSL_CTX_set_options>(SSL_CTX *ctx, unsigned long op);
 322
 323 =item void B<SSL_CTX_set_quiet_shutdown>(SSL_CTX *ctx, int mode);
 324
 325 =item void B<SSL_CTX_set_read_ahead>(SSL_CTX *ctx, int m);
 326
 327 =item void B<SSL_CTX_set_session_cache_mode>(SSL_CTX *ctx, int mode);
 328
 329 =item int B<SSL_CTX_set_ssl_version>(SSL_CTX *ctx, const SSL_METHOD *meth);
 330
 331 =item void B<SSL_CTX_set_timeout>(SSL_CTX *ctx, long t);
 332
 333 =item long B<SSL_CTX_set_tmp_dh>(SSL_CTX* ctx, DH *dh);
 334
 335 =item long B<SSL_CTX_set_tmp_dh_callback>(SSL_CTX *ctx, DH *(*cb)(void));
 336
 337 =item void B<SSL_CTX_set_verify>(SSL_CTX *ctx, int mode, int (*cb);(void))
 338
 339 =item int B<SSL_CTX_use_PrivateKey>(SSL_CTX *ctx, EVP_PKEY *pkey);
 340
 341 =item int B<SSL_CTX_use_PrivateKey_ASN1>(int type, SSL_CTX *ctx, unsigned char *d, long len);
 342
 343 =item int B<SSL_CTX_use_PrivateKey_file>(SSL_CTX *ctx, char *file, int type);
 344
 345 =item int B<SSL_CTX_use_RSAPrivateKey>(SSL_CTX *ctx, RSA *rsa);
 346
 347 =item int B<SSL_CTX_use_RSAPrivateKey_ASN1>(SSL_CTX *ctx, unsigned char *d, long len);
 348
 349 =item int B<SSL_CTX_use_RSAPrivateKey_file>(SSL_CTX *ctx, char *file, int type);
 350
 351 =item int B<SSL_CTX_use_certificate>(SSL_CTX *ctx, X509 *x);
 352
 353 =item int B<SSL_CTX_use_certificate_ASN1>(SSL_CTX *ctx, int len, unsigned char *d);
 354
 355 =item int B<SSL_CTX_use_certificate_file>(SSL_CTX *ctx, char *file, int type);
 356
 357 =item X509 *B<SSL_CTX_get0_certificate>(const SSL_CTX *ctx);
 358
 359 =item EVP_PKEY *B<SSL_CTX_get0_privatekey>(const SSL_CTX *ctx);
 360
 361 =item void B<SSL_CTX_set_psk_client_callback>(SSL_CTX *ctx, unsigned int (*callback)(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len));
 362
 363 =item int B<SSL_CTX_use_psk_identity_hint>(SSL_CTX *ctx, const char *hint);
 364
 365 =item void B<SSL_CTX_set_psk_server_callback>(SSL_CTX *ctx, unsigned int (*callback)(SSL *ssl, const char *identity, unsigned char *psk, int max_psk_len));
 366
 367
 368
 369
 370 =back
 371
 372 =head2 DEALING WITH SESSIONS
 373
 374 Here we document the various API functions which deal with the SSL/TLS
 375 sessions defined in the B<SSL_SESSION> structures.
 376
 377 =over 4
 378
 379 =item int B<SSL_SESSION_cmp>(const SSL_SESSION *a, const SSL_SESSION *b);
 380
 381 =item void B<SSL_SESSION_free>(SSL_SESSION *ss);
 382
 383 =item char *B<SSL_SESSION_get_app_data>(SSL_SESSION *s);
 384
 385 =item char *B<SSL_SESSION_get_ex_data>(const SSL_SESSION *s, int idx);
 386
 387 =item int B<SSL_SESSION_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
 388
 389 =item long B<SSL_SESSION_get_time>(const SSL_SESSION *s);
 390
 391 =item long B<SSL_SESSION_get_timeout>(const SSL_SESSION *s);
 392
 393 =item unsigned long B<SSL_SESSION_hash>(const SSL_SESSION *a);
 394
 395 =item SSL_SESSION *B<SSL_SESSION_new>(void);
 396
 397 =item int B<SSL_SESSION_print>(BIO *bp, const SSL_SESSION *x);
 398
 399 =item int B<SSL_SESSION_print_fp>(FILE *fp, const SSL_SESSION *x);
 400
 401 =item void B<SSL_SESSION_set_app_data>(SSL_SESSION *s, char *a);
 402
 403 =item int B<SSL_SESSION_set_ex_data>(SSL_SESSION *s, int idx, char *arg);
 404
 405 =item long B<SSL_SESSION_set_time>(SSL_SESSION *s, long t);
 406
 407 =item long B<SSL_SESSION_set_timeout>(SSL_SESSION *s, long t);
 408
 409 =back
 410
 411 =head2 DEALING WITH CONNECTIONS
 412
 413 Here we document the various API functions which deal with the SSL/TLS
 414 connection defined in the B<SSL> structure.
 415
 416 =over 4
 417
 418 =item int B<SSL_accept>(SSL *ssl);
 419
 420 =item int B<SSL_add_dir_cert_subjects_to_stack>(STACK *stack, const char *dir);
 421
 422 =item int B<SSL_add_file_cert_subjects_to_stack>(STACK *stack, const char *file);
 423
 424 =item int B<SSL_add_client_CA>(SSL *ssl, X509 *x);
 425
 426 =item char *B<SSL_alert_desc_string>(int value);
 427
 428 =item char *B<SSL_alert_desc_string_long>(int value);
 429
 430 =item char *B<SSL_alert_type_string>(int value);
 431
 432 =item char *B<SSL_alert_type_string_long>(int value);
 433
 434 =item int B<SSL_check_private_key>(const SSL *ssl);
 435
 436 =item void B<SSL_clear>(SSL *ssl);
 437
 438 =item long B<SSL_clear_num_renegotiations>(SSL *ssl);
 439
 440 =item int B<SSL_connect>(SSL *ssl);
 441
 442 =item int B<SSL_copy_session_id>(SSL *t, const SSL *f);
 443
 444 Sets the session details for B<t> to be the same as in B<f>. Returns 1 on
 445 success or 0 on failure.
 446
 447 =item long B<SSL_ctrl>(SSL *ssl, int cmd, long larg, char *parg);
 448
 449 =item int B<SSL_do_handshake>(SSL *ssl);
 450
 451 =item SSL *B<SSL_dup>(SSL *ssl);
 452
 453 SSL_dup() allows applications to configure an SSL handle for use
 454 in multiple SSL connections, and then duplicate it prior to initiating
 455 each connection with the duplicated handle.
 456 Use of SSL_dup() avoids the need to repeat the configuration of the
 457 handles for each connection.
 458 This is used internally by L<BIO_s_accept(3)> to construct
 459 per-connection SSL handles after L<accept(2)>.
 460
 461 For SSL_dup() to work, the connection MUST be in its initial state
 462 and MUST NOT have not yet have started the SSL handshake.
 463 For connections that are not in their initial state SSL_dup() just
 464 increments an internal reference count and returns the I<same>
 465 handle.
 466 It may be possible to use L<SSL_clear(3)> to recycle an SSL handle
 467 that is not in its initial state for re-use, but this is best
 468 avoided.
 469 Instead, save and restore the session, if desired, and construct a
 470 fresh handle for each connection.
 471
 472 =item STACK *B<SSL_dup_CA_list>(STACK *sk);
 473
 474 =item void B<SSL_free>(SSL *ssl);
 475
 476 =item SSL_CTX *B<SSL_get_SSL_CTX>(const SSL *ssl);
 477
 478 =item char *B<SSL_get_app_data>(SSL *ssl);
 479
 480 =item X509 *B<SSL_get_certificate>(const SSL *ssl);
 481
 482 =item const char *B<SSL_get_cipher>(const SSL *ssl);
 483
 484 =item int B<SSL_get_cipher_bits>(const SSL *ssl, int *alg_bits);
 485
 486 =item char *B<SSL_get_cipher_list>(const SSL *ssl, int n);
 487
 488 =item char *B<SSL_get_cipher_name>(const SSL *ssl);
 489
 490 =item char *B<SSL_get_cipher_version>(const SSL *ssl);
 491
 492 =item STACK *B<SSL_get_ciphers>(const SSL *ssl);
 493
 494 =item STACK *B<SSL_get_client_CA_list>(const SSL *ssl);
 495
 496 =item SSL_CIPHER *B<SSL_get_current_cipher>(SSL *ssl);
 497
 498 =item long B<SSL_get_default_timeout>(const SSL *ssl);
 499
 500 =item int B<SSL_get_error>(const SSL *ssl, int i);
 501
 502 =item char *B<SSL_get_ex_data>(const SSL *ssl, int idx);
 503
 504 =item int B<SSL_get_ex_data_X509_STORE_CTX_idx>(void);
 505
 506 =item int B<SSL_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
 507
 508 =item int B<SSL_get_fd>(const SSL *ssl);
 509
 510 =item void (*B<SSL_get_info_callback>(const SSL *ssl);)()
 511
 512 =item STACK *B<SSL_get_peer_cert_chain>(const SSL *ssl);
 513
 514 =item X509 *B<SSL_get_peer_certificate>(const SSL *ssl);
 515
 516 =item EVP_PKEY *B<SSL_get_privatekey>(const SSL *ssl);
 517
 518 =item int B<SSL_get_quiet_shutdown>(const SSL *ssl);
 519
 520 =item BIO *B<SSL_get_rbio>(const SSL *ssl);
 521
 522 =item int B<SSL_get_read_ahead>(const SSL *ssl);
 523
 524 =item SSL_SESSION *B<SSL_get_session>(const SSL *ssl);
 525
 526 =item char *B<SSL_get_shared_ciphers>(const SSL *ssl, char *buf, int len);
 527
 528 =item int B<SSL_get_shutdown>(const SSL *ssl);
 529
 530 =item const SSL_METHOD *B<SSL_get_ssl_method>(SSL *ssl);
 531
 532 =item int B<SSL_get_state>(const SSL *ssl);
 533
 534 =item long B<SSL_get_time>(const SSL *ssl);
 535
 536 =item long B<SSL_get_timeout>(const SSL *ssl);
 537
 538 =item int (*B<SSL_get_verify_callback>(const SSL *ssl))(int,X509_STORE_CTX *)
 539
 540 =item int B<SSL_get_verify_mode>(const SSL *ssl);
 541
 542 =item long B<SSL_get_verify_result>(const SSL *ssl);
 543
 544 =item char *B<SSL_get_version>(const SSL *ssl);
 545
 546 =item BIO *B<SSL_get_wbio>(const SSL *ssl);
 547
 548 =item int B<SSL_in_accept_init>(SSL *ssl);
 549
 550 =item int B<SSL_in_before>(SSL *ssl);
 551
 552 =item int B<SSL_in_connect_init>(SSL *ssl);
 553
 554 =item int B<SSL_in_init>(SSL *ssl);
 555
 556 =item int B<SSL_is_init_finished>(SSL *ssl);
 557
 558 =item STACK *B<SSL_load_client_CA_file>(char *file);
 559
 560 =item SSL *B<SSL_new>(SSL_CTX *ctx);
 561
 562 =item void SSL_up_ref(SSL *s);
 563
 564 =item long B<SSL_num_renegotiations>(SSL *ssl);
 565
 566 =item int B<SSL_peek>(SSL *ssl, void *buf, int num);
 567
 568 =item int B<SSL_pending>(const SSL *ssl);
 569
 570 =item int B<SSL_read>(SSL *ssl, void *buf, int num);
 571
 572 =item int B<SSL_renegotiate>(SSL *ssl);
 573
 574 =item char *B<SSL_rstate_string>(SSL *ssl);
 575
 576 =item char *B<SSL_rstate_string_long>(SSL *ssl);
 577
 578 =item long B<SSL_session_reused>(SSL *ssl);
 579
 580 =item void B<SSL_set_accept_state>(SSL *ssl);
 581
 582 =item void B<SSL_set_app_data>(SSL *ssl, char *arg);
 583
 584 =item void B<SSL_set_bio>(SSL *ssl, BIO *rbio, BIO *wbio);
 585
 586 =item int B<SSL_set_cipher_list>(SSL *ssl, char *str);
 587
 588 =item void B<SSL_set_client_CA_list>(SSL *ssl, STACK *list);
 589
 590 =item void B<SSL_set_connect_state>(SSL *ssl);
 591
 592 =item int B<SSL_set_ex_data>(SSL *ssl, int idx, char *arg);
 593
 594 =item int B<SSL_set_fd>(SSL *ssl, int fd);
 595
 596 =item void B<SSL_set_info_callback>(SSL *ssl, void (*cb);(void))
 597
 598 =item void B<SSL_set_msg_callback>(SSL *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
 599
 600 =item void B<SSL_set_msg_callback_arg>(SSL *ctx, void *arg);
 601
 602 =item unsigned long B<SSL_clear_options>(SSL *ssl, unsigned long op);
 603
 604 =item unsigned long B<SSL_get_options>(SSL *ssl);
 605
 606 =item unsigned long B<SSL_set_options>(SSL *ssl, unsigned long op);
 607
 608 =item void B<SSL_set_quiet_shutdown>(SSL *ssl, int mode);
 609
 610 =item void B<SSL_set_read_ahead>(SSL *ssl, int yes);
 611
 612 =item int B<SSL_set_rfd>(SSL *ssl, int fd);
 613
 614 =item int B<SSL_set_session>(SSL *ssl, SSL_SESSION *session);
 615
 616 =item void B<SSL_set_shutdown>(SSL *ssl, int mode);
 617
 618 =item int B<SSL_set_ssl_method>(SSL *ssl, const SSL_METHOD *meth);
 619
 620 =item void B<SSL_set_time>(SSL *ssl, long t);
 621
 622 =item void B<SSL_set_timeout>(SSL *ssl, long t);
 623
 624 =item void B<SSL_set_verify>(SSL *ssl, int mode, int (*callback);(void))
 625
 626 =item void B<SSL_set_verify_result>(SSL *ssl, long arg);
 627
 628 =item int B<SSL_set_wfd>(SSL *ssl, int fd);
 629
 630 =item int B<SSL_shutdown>(SSL *ssl);
 631
 632 =item OSSL_HANDSHAKE_STATE B<SSL_get_state>(const SSL *ssl);
 633
 634 Returns the current handshake state.
 635
 636 =item char *B<SSL_state_string>(const SSL *ssl);
 637
 638 =item char *B<SSL_state_string_long>(const SSL *ssl);
 639
 640 =item long B<SSL_total_renegotiations>(SSL *ssl);
 641
 642 =item int B<SSL_use_PrivateKey>(SSL *ssl, EVP_PKEY *pkey);
 643
 644 =item int B<SSL_use_PrivateKey_ASN1>(int type, SSL *ssl, unsigned char *d, long len);
 645
 646 =item int B<SSL_use_PrivateKey_file>(SSL *ssl, char *file, int type);
 647
 648 =item int B<SSL_use_RSAPrivateKey>(SSL *ssl, RSA *rsa);
 649
 650 =item int B<SSL_use_RSAPrivateKey_ASN1>(SSL *ssl, unsigned char *d, long len);
 651
 652 =item int B<SSL_use_RSAPrivateKey_file>(SSL *ssl, char *file, int type);
 653
 654 =item int B<SSL_use_certificate>(SSL *ssl, X509 *x);
 655
 656 =item int B<SSL_use_certificate_ASN1>(SSL *ssl, int len, unsigned char *d);
 657
 658 =item int B<SSL_use_certificate_file>(SSL *ssl, char *file, int type);
 659
 660 =item int B<SSL_version>(const SSL *ssl);
 661
 662 =item int B<SSL_want>(const SSL *ssl);
 663
 664 =item int B<SSL_want_nothing>(const SSL *ssl);
 665
 666 =item int B<SSL_want_read>(const SSL *ssl);
 667
 668 =item int B<SSL_want_write>(const SSL *ssl);
 669
 670 =item int B<SSL_want_x509_lookup>(const SSL *ssl);
 671
 672 =item int B<SSL_write>(SSL *ssl, const void *buf, int num);
 673
 674 =item void B<SSL_set_psk_client_callback>(SSL *ssl, unsigned int (*callback)(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len));
 675
 676 =item int B<SSL_use_psk_identity_hint>(SSL *ssl, const char *hint);
 677
 678 =item void B<SSL_set_psk_server_callback>(SSL *ssl, unsigned int (*callback)(SSL *ssl, const char *identity, unsigned char *psk, int max_psk_len));
 679
 680 =item const char *B<SSL_get_psk_identity_hint>(SSL *ssl);
 681
 682 =item const char *B<SSL_get_psk_identity>(SSL *ssl);
 683
 684 =back
 685
 686 =head1 SEE ALSO
 687
 688 L<openssl(1)>, L<crypto(3)>,
 689 L<CRYPTO_get_ex_new_index(3)>,
 690 L<SSL_accept(3)>, L<SSL_clear(3)>,
 691 L<SSL_connect(3)>,
 692 L<SSL_CIPHER_get_name(3)>,
 693 L<SSL_COMP_add_compression_method(3)>,
 694 L<SSL_CTX_add_extra_chain_cert(3)>,
 695 L<SSL_CTX_add_session(3)>,
 696 L<SSL_CTX_ctrl(3)>,
 697 L<SSL_CTX_flush_sessions(3)>,
 698 L<SSL_CTX_get_verify_mode(3)>,
 699 L<SSL_CTX_load_verify_locations(3)>
 700 L<SSL_CTX_new(3)>,
 701 L<SSL_CTX_sess_number(3)>,
 702 L<SSL_CTX_sess_set_cache_size(3)>,
 703 L<SSL_CTX_sess_set_get_cb(3)>,
 704 L<SSL_CTX_sessions(3)>,
 705 L<SSL_CTX_set_cert_store(3)>,
 706 L<SSL_CTX_set_cert_verify_callback(3)>,
 707 L<SSL_CTX_set_cipher_list(3)>,
 708 L<SSL_CTX_set_client_CA_list(3)>,
 709 L<SSL_CTX_set_client_cert_cb(3)>,
 710 L<SSL_CTX_set_default_passwd_cb(3)>,
 711 L<SSL_CTX_set_generate_session_id(3)>,
 712 L<SSL_CTX_set_info_callback(3)>,
 713 L<SSL_CTX_set_max_cert_list(3)>,
 714 L<SSL_CTX_set_mode(3)>,
 715 L<SSL_CTX_set_msg_callback(3)>,
 716 L<SSL_CTX_set_options(3)>,
 717 L<SSL_CTX_set_quiet_shutdown(3)>,
 718 L<SSL_CTX_set_read_ahead(3)>,
 719 L<SSL_CTX_set_session_cache_mode(3)>,
 720 L<SSL_CTX_set_session_id_context(3)>,
 721 L<SSL_CTX_set_ssl_version(3)>,
 722 L<SSL_CTX_set_timeout(3)>,
 723 L<SSL_CTX_set_tmp_dh_callback(3)>,
 724 L<SSL_CTX_set_verify(3)>,
 725 L<SSL_CTX_use_certificate(3)>,
 726 L<SSL_alert_type_string(3)>,
 727 L<SSL_do_handshake(3)>,
 728 L<SSL_get_SSL_CTX(3)>,
 729 L<SSL_get_ciphers(3)>,
 730 L<SSL_get_client_CA_list(3)>,
 731 L<SSL_get_default_timeout(3)>,
 732 L<SSL_get_error(3)>,
 733 L<SSL_get_ex_data_X509_STORE_CTX_idx(3)>,
 734 L<SSL_get_fd(3)>,
 735 L<SSL_get_peer_cert_chain(3)>,
 736 L<SSL_get_rbio(3)>,
 737 L<SSL_get_session(3)>,
 738 L<SSL_get_verify_result(3)>,
 739 L<SSL_get_version(3)>,
 740 L<SSL_load_client_CA_file(3)>,
 741 L<SSL_new(3)>,
 742 L<SSL_pending(3)>,
 743 L<SSL_read(3)>,
 744 L<SSL_rstate_string(3)>,
 745 L<SSL_session_reused(3)>,
 746 L<SSL_set_bio(3)>,
 747 L<SSL_set_connect_state(3)>,
 748 L<SSL_set_fd(3)>,
 749 L<SSL_set_session(3)>,
 750 L<SSL_set_shutdown(3)>,
 751 L<SSL_shutdown(3)>,
 752 L<SSL_state_string(3)>,
 753 L<SSL_want(3)>,
 754 L<SSL_write(3)>,
 755 L<SSL_SESSION_free(3)>,
 756 L<SSL_SESSION_get_time(3)>,
 757 L<d2i_SSL_SESSION(3)>,
 758 L<SSL_CTX_set_psk_client_callback(3)>,
 759 L<SSL_CTX_use_psk_identity_hint(3)>,
 760 L<SSL_get_psk_identity(3)>,
 761 L<DTLSv1_listen(3)>
 762
 763 =head1 HISTORY
 764
 765 B<SSLv2_client_method>, B<SSLv2_server_method> and B<SSLv2_method> where removed
 766 in OpenSSL 1.1.0.
 767
 768 The return type of B<SSL_copy_session_id> was changed from void to int in
 769 OpenSSL 1.1.0.
 770
 771 =cut
 772