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 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<TLS_method>(void);
 122
 123 Constructor for the I<version-flexible> SSL_METHOD structure for clients,
 124 servers or both.
 125 See L<SSL_CTX_new(3)> for details.
 126
 127 =item const SSL_METHOD *B<TLS_client_method>(void);
 128
 129 Constructor for the I<version-flexible> SSL_METHOD structure for clients.
 130
 131 =item const SSL_METHOD *B<TLS_server_method>(void);
 132
 133 Constructor for the I<version-flexible> SSL_METHOD structure for servers.
 134
 135 =item const SSL_METHOD *B<TLSv1_2_method>(void);
 136
 137 Constructor for the TLSv1.2 SSL_METHOD structure for clients, servers or both.
 138
 139 =item const SSL_METHOD *B<TLSv1_2_client_method>(void);
 140
 141 Constructor for the TLSv1.2 SSL_METHOD structure for clients.
 142
 143 =item const SSL_METHOD *B<TLSv1_2_server_method>(void);
 144
 145 Constructor for the TLSv1.2 SSL_METHOD structure for servers.
 146
 147 =item const SSL_METHOD *B<TLSv1_1_method>(void);
 148
 149 Constructor for the TLSv1.1 SSL_METHOD structure for clients, servers or both.
 150
 151 =item const SSL_METHOD *B<TLSv1_1_client_method>(void);
 152
 153 Constructor for the TLSv1.1 SSL_METHOD structure for clients.
 154
 155 =item const SSL_METHOD *B<TLSv1_1_server_method>(void);
 156
 157 Constructor for the TLSv1.1 SSL_METHOD structure for servers.
 158
 159 =item const SSL_METHOD *B<TLSv1_method>(void);
 160
 161 Constructor for the TLSv1 SSL_METHOD structure for clients, servers or both.
 162
 163 =item const SSL_METHOD *B<TLSv1_client_method>(void);
 164
 165 Constructor for the TLSv1 SSL_METHOD structure for clients.
 166
 167 =item const SSL_METHOD *B<TLSv1_server_method>(void);
 168
 169 Constructor for the TLSv1 SSL_METHOD structure for servers.
 170
 171 =item const SSL_METHOD *B<SSLv3_method>(void);
 172
 173 Constructor for the SSLv3 SSL_METHOD structure for clients, servers or both.
 174
 175 =item const SSL_METHOD *B<SSLv3_client_method>(void);
 176
 177 Constructor for the SSLv3 SSL_METHOD structure for clients.
 178
 179 =item const SSL_METHOD *B<SSLv3_server_method>(void);
 180
 181 Constructor for the SSLv3 SSL_METHOD structure for servers.
 182
 183 =back
 184
 185 =head2 DEALING WITH CIPHERS
 186
 187 Here we document the various API functions which deal with the SSL/TLS
 188 ciphers defined in B<SSL_CIPHER> structures.
 189
 190 =over 4
 191
 192 =item char *B<SSL_CIPHER_description>(SSL_CIPHER *cipher, char *buf, int len);
 193
 194 Write a string to I<buf> (with a maximum size of I<len>) containing a human
 195 readable description of I<cipher>. Returns I<buf>.
 196
 197 =item int B<SSL_CIPHER_get_bits>(SSL_CIPHER *cipher, int *alg_bits);
 198
 199 Determine the number of bits in I<cipher>. Because of export crippled ciphers
 200 there are two bits: The bits the algorithm supports in general (stored to
 201 I<alg_bits>) and the bits which are actually used (the return value).
 202
 203 =item const char *B<SSL_CIPHER_get_name>(SSL_CIPHER *cipher);
 204
 205 Return the internal name of I<cipher> as a string. These are the various
 206 strings defined by the I<SSL3_TXT_xxx> and I<TLS1_TXT_xxx>
 207 definitions in the header files.
 208
 209 =item const char *B<SSL_CIPHER_get_version>(SSL_CIPHER *cipher);
 210
 211 Returns a string like "C<SSLv3>" or "C<TLSv1.2>" which indicates the
 212 SSL/TLS protocol version to which I<cipher> belongs (i.e. where it was defined
 213 in the specification the first time).
 214
 215 =back
 216
 217 =head2 DEALING WITH PROTOCOL CONTEXTS
 218
 219 Here we document the various API functions which deal with the SSL/TLS
 220 protocol context defined in the B<SSL_CTX> structure.
 221
 222 =over 4
 223
 224 =item int B<SSL_CTX_add_client_CA>(SSL_CTX *ctx, X509 *x);
 225
 226 =item long B<SSL_CTX_add_extra_chain_cert>(SSL_CTX *ctx, X509 *x509);
 227
 228 =item int B<SSL_CTX_add_session>(SSL_CTX *ctx, SSL_SESSION *c);
 229
 230 =item int B<SSL_CTX_check_private_key>(const SSL_CTX *ctx);
 231
 232 =item long B<SSL_CTX_ctrl>(SSL_CTX *ctx, int cmd, long larg, char *parg);
 233
 234 =item void B<SSL_CTX_flush_sessions>(SSL_CTX *s, long t);
 235
 236 =item void B<SSL_CTX_free>(SSL_CTX *a);
 237
 238 =item char *B<SSL_CTX_get_app_data>(SSL_CTX *ctx);
 239
 240 =item X509_STORE *B<SSL_CTX_get_cert_store>(SSL_CTX *ctx);
 241
 242 =item STACK *B<SSL_CTX_get_client_CA_list>(const SSL_CTX *ctx);
 243
 244 =item int (*B<SSL_CTX_get_client_cert_cb>(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
 245
 246 =item void B<SSL_CTX_get_default_read_ahead>(SSL_CTX *ctx);
 247
 248 =item char *B<SSL_CTX_get_ex_data>(const SSL_CTX *s, int idx);
 249
 250 =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))
 251
 252 =item void (*B<SSL_CTX_get_info_callback>(SSL_CTX *ctx))(SSL *ssl, int cb, int ret);
 253
 254 =item int B<SSL_CTX_get_quiet_shutdown>(const SSL_CTX *ctx);
 255
 256 =item void B<SSL_CTX_get_read_ahead>(SSL_CTX *ctx);
 257
 258 =item int B<SSL_CTX_get_session_cache_mode>(SSL_CTX *ctx);
 259
 260 =item long B<SSL_CTX_get_timeout>(const SSL_CTX *ctx);
 261
 262 =item int (*B<SSL_CTX_get_verify_callback>(const SSL_CTX *ctx))(int ok, X509_STORE_CTX *ctx);
 263
 264 =item int B<SSL_CTX_get_verify_mode>(SSL_CTX *ctx);
 265
 266 =item int B<SSL_CTX_load_verify_locations>(SSL_CTX *ctx, char *CAfile, char *CApath);
 267
 268 =item long B<SSL_CTX_need_tmp_RSA>(SSL_CTX *ctx);
 269
 270 =item SSL_CTX *B<SSL_CTX_new>(const SSL_METHOD *meth);
 271
 272 =item void SSL_CTX_up_ref(SSL_CTX *ctx);
 273
 274 =item int B<SSL_CTX_remove_session>(SSL_CTX *ctx, SSL_SESSION *c);
 275
 276 =item int B<SSL_CTX_sess_accept>(SSL_CTX *ctx);
 277
 278 =item int B<SSL_CTX_sess_accept_good>(SSL_CTX *ctx);
 279
 280 =item int B<SSL_CTX_sess_accept_renegotiate>(SSL_CTX *ctx);
 281
 282 =item int B<SSL_CTX_sess_cache_full>(SSL_CTX *ctx);
 283
 284 =item int B<SSL_CTX_sess_cb_hits>(SSL_CTX *ctx);
 285
 286 =item int B<SSL_CTX_sess_connect>(SSL_CTX *ctx);
 287
 288 =item int B<SSL_CTX_sess_connect_good>(SSL_CTX *ctx);
 289
 290 =item int B<SSL_CTX_sess_connect_renegotiate>(SSL_CTX *ctx);
 291
 292 =item int B<SSL_CTX_sess_get_cache_size>(SSL_CTX *ctx);
 293
 294 =item SSL_SESSION *(*B<SSL_CTX_sess_get_get_cb>(SSL_CTX *ctx))(SSL *ssl, unsigned char *data, int len, int *copy);
 295
 296 =item int (*B<SSL_CTX_sess_get_new_cb>(SSL_CTX *ctx)(SSL *ssl, SSL_SESSION *sess);
 297
 298 =item void (*B<SSL_CTX_sess_get_remove_cb>(SSL_CTX *ctx)(SSL_CTX *ctx, SSL_SESSION *sess);
 299
 300 =item int B<SSL_CTX_sess_hits>(SSL_CTX *ctx);
 301
 302 =item int B<SSL_CTX_sess_misses>(SSL_CTX *ctx);
 303
 304 =item int B<SSL_CTX_sess_number>(SSL_CTX *ctx);
 305
 306 =item void B<SSL_CTX_sess_set_cache_size>(SSL_CTX *ctx,t);
 307
 308 =item void B<SSL_CTX_sess_set_get_cb>(SSL_CTX *ctx, SSL_SESSION *(*cb)(SSL *ssl, unsigned char *data, int len, int *copy));
 309
 310 =item void B<SSL_CTX_sess_set_new_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, SSL_SESSION *sess));
 311
 312 =item void B<SSL_CTX_sess_set_remove_cb>(SSL_CTX *ctx, void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess));
 313
 314 =item int B<SSL_CTX_sess_timeouts>(SSL_CTX *ctx);
 315
 316 =item LHASH *B<SSL_CTX_sessions>(SSL_CTX *ctx);
 317
 318 =item void B<SSL_CTX_set_app_data>(SSL_CTX *ctx, void *arg);
 319
 320 =item void B<SSL_CTX_set_cert_store>(SSL_CTX *ctx, X509_STORE *cs);
 321
 322 =item void B<SSL_CTX_set_cert_verify_cb>(SSL_CTX *ctx, int (*cb)(), char *arg)
 323
 324 =item int B<SSL_CTX_set_cipher_list>(SSL_CTX *ctx, char *str);
 325
 326 =item void B<SSL_CTX_set_client_CA_list>(SSL_CTX *ctx, STACK *list);
 327
 328 =item void B<SSL_CTX_set_client_cert_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey));
 329
 330 =item void B<SSL_CTX_set_default_passwd_cb>(SSL_CTX *ctx, int (*cb);(void))
 331
 332 =item void B<SSL_CTX_set_default_read_ahead>(SSL_CTX *ctx, int m);
 333
 334 =item int B<SSL_CTX_set_default_verify_paths>(SSL_CTX *ctx);
 335
 336 Use the default paths to locate trusted CA certificates. There is one default
 337 directory path and one default file path. Both are set via this call.
 338
 339 =item int B<SSL_CTX_set_default_verify_dir>(SSL_CTX *ctx)
 340
 341 Use the default directory path to locate trusted CA certificates.
 342
 343 =item int B<SSL_CTX_set_default_verify_file>(SSL_CTX *ctx)
 344
 345 Use the file path to locate trusted CA certificates.
 346
 347 =item int B<SSL_CTX_set_ex_data>(SSL_CTX *s, int idx, char *arg);
 348
 349 =item void B<SSL_CTX_set_info_callback>(SSL_CTX *ctx, void (*cb)(SSL *ssl, int cb, int ret));
 350
 351 =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));
 352
 353 =item void B<SSL_CTX_set_msg_callback_arg>(SSL_CTX *ctx, void *arg);
 354
 355 =item unsigned long B<SSL_CTX_clear_options>(SSL_CTX *ctx, unsigned long op);
 356
 357 =item unsigned long B<SSL_CTX_get_options>(SSL_CTX *ctx);
 358
 359 =item unsigned long B<SSL_CTX_set_options>(SSL_CTX *ctx, unsigned long op);
 360
 361 =item void B<SSL_CTX_set_quiet_shutdown>(SSL_CTX *ctx, int mode);
 362
 363 =item void B<SSL_CTX_set_read_ahead>(SSL_CTX *ctx, int m);
 364
 365 =item void B<SSL_CTX_set_session_cache_mode>(SSL_CTX *ctx, int mode);
 366
 367 =item int B<SSL_CTX_set_ssl_version>(SSL_CTX *ctx, const SSL_METHOD *meth);
 368
 369 =item void B<SSL_CTX_set_timeout>(SSL_CTX *ctx, long t);
 370
 371 =item long B<SSL_CTX_set_tmp_dh>(SSL_CTX* ctx, DH *dh);
 372
 373 =item long B<SSL_CTX_set_tmp_dh_callback>(SSL_CTX *ctx, DH *(*cb)(void));
 374
 375 =item void B<SSL_CTX_set_verify>(SSL_CTX *ctx, int mode, int (*cb);(void))
 376
 377 =item int B<SSL_CTX_use_PrivateKey>(SSL_CTX *ctx, EVP_PKEY *pkey);
 378
 379 =item int B<SSL_CTX_use_PrivateKey_ASN1>(int type, SSL_CTX *ctx, unsigned char *d, long len);
 380
 381 =item int B<SSL_CTX_use_PrivateKey_file>(SSL_CTX *ctx, char *file, int type);
 382
 383 =item int B<SSL_CTX_use_RSAPrivateKey>(SSL_CTX *ctx, RSA *rsa);
 384
 385 =item int B<SSL_CTX_use_RSAPrivateKey_ASN1>(SSL_CTX *ctx, unsigned char *d, long len);
 386
 387 =item int B<SSL_CTX_use_RSAPrivateKey_file>(SSL_CTX *ctx, char *file, int type);
 388
 389 =item int B<SSL_CTX_use_certificate>(SSL_CTX *ctx, X509 *x);
 390
 391 =item int B<SSL_CTX_use_certificate_ASN1>(SSL_CTX *ctx, int len, unsigned char *d);
 392
 393 =item int B<SSL_CTX_use_certificate_file>(SSL_CTX *ctx, char *file, int type);
 394
 395 =item X509 *B<SSL_CTX_get0_certificate>(const SSL_CTX *ctx);
 396
 397 =item EVP_PKEY *B<SSL_CTX_get0_privatekey>(const SSL_CTX *ctx);
 398
 399 =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));
 400
 401 =item int B<SSL_CTX_use_psk_identity_hint>(SSL_CTX *ctx, const char *hint);
 402
 403 =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));
 404
 405
 406
 407
 408 =back
 409
 410 =head2 DEALING WITH SESSIONS
 411
 412 Here we document the various API functions which deal with the SSL/TLS
 413 sessions defined in the B<SSL_SESSION> structures.
 414
 415 =over 4
 416
 417 =item int B<SSL_SESSION_cmp>(const SSL_SESSION *a, const SSL_SESSION *b);
 418
 419 =item void B<SSL_SESSION_free>(SSL_SESSION *ss);
 420
 421 =item char *B<SSL_SESSION_get_app_data>(SSL_SESSION *s);
 422
 423 =item char *B<SSL_SESSION_get_ex_data>(const SSL_SESSION *s, int idx);
 424
 425 =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))
 426
 427 =item long B<SSL_SESSION_get_time>(const SSL_SESSION *s);
 428
 429 =item long B<SSL_SESSION_get_timeout>(const SSL_SESSION *s);
 430
 431 =item unsigned long B<SSL_SESSION_hash>(const SSL_SESSION *a);
 432
 433 =item SSL_SESSION *B<SSL_SESSION_new>(void);
 434
 435 =item int B<SSL_SESSION_print>(BIO *bp, const SSL_SESSION *x);
 436
 437 =item int B<SSL_SESSION_print_fp>(FILE *fp, const SSL_SESSION *x);
 438
 439 =item void B<SSL_SESSION_set_app_data>(SSL_SESSION *s, char *a);
 440
 441 =item int B<SSL_SESSION_set_ex_data>(SSL_SESSION *s, int idx, char *arg);
 442
 443 =item long B<SSL_SESSION_set_time>(SSL_SESSION *s, long t);
 444
 445 =item long B<SSL_SESSION_set_timeout>(SSL_SESSION *s, long t);
 446
 447 =back
 448
 449 =head2 DEALING WITH CONNECTIONS
 450
 451 Here we document the various API functions which deal with the SSL/TLS
 452 connection defined in the B<SSL> structure.
 453
 454 =over 4
 455
 456 =item int B<SSL_accept>(SSL *ssl);
 457
 458 =item int B<SSL_add_dir_cert_subjects_to_stack>(STACK *stack, const char *dir);
 459
 460 =item int B<SSL_add_file_cert_subjects_to_stack>(STACK *stack, const char *file);
 461
 462 =item int B<SSL_add_client_CA>(SSL *ssl, X509 *x);
 463
 464 =item char *B<SSL_alert_desc_string>(int value);
 465
 466 =item char *B<SSL_alert_desc_string_long>(int value);
 467
 468 =item char *B<SSL_alert_type_string>(int value);
 469
 470 =item char *B<SSL_alert_type_string_long>(int value);
 471
 472 =item int B<SSL_check_private_key>(const SSL *ssl);
 473
 474 =item void B<SSL_clear>(SSL *ssl);
 475
 476 =item long B<SSL_clear_num_renegotiations>(SSL *ssl);
 477
 478 =item int B<SSL_connect>(SSL *ssl);
 479
 480 =item int B<SSL_copy_session_id>(SSL *t, const SSL *f);
 481
 482 Sets the session details for B<t> to be the same as in B<f>. Returns 1 on
 483 success or 0 on failure.
 484
 485 =item long B<SSL_ctrl>(SSL *ssl, int cmd, long larg, char *parg);
 486
 487 =item int B<SSL_do_handshake>(SSL *ssl);
 488
 489 =item SSL *B<SSL_dup>(SSL *ssl);
 490
 491 SSL_dup() allows applications to configure an SSL handle for use
 492 in multiple SSL connections, and then duplicate it prior to initiating
 493 each connection with the duplicated handle.
 494 Use of SSL_dup() avoids the need to repeat the configuration of the
 495 handles for each connection.
 496 This is used internally by L<BIO_s_accept(3)> to construct
 497 per-connection SSL handles after L<accept(2)>.
 498
 499 For SSL_dup() to work, the connection MUST be in its initial state
 500 and MUST NOT have not yet have started the SSL handshake.
 501 For connections that are not in their initial state SSL_dup() just
 502 increments an internal reference count and returns the I<same>
 503 handle.
 504 It may be possible to use L<SSL_clear(3)> to recycle an SSL handle
 505 that is not in its initial state for re-use, but this is best
 506 avoided.
 507 Instead, save and restore the session, if desired, and construct a
 508 fresh handle for each connection.
 509
 510 =item STACK *B<SSL_dup_CA_list>(STACK *sk);
 511
 512 =item void B<SSL_free>(SSL *ssl);
 513
 514 =item SSL_CTX *B<SSL_get_SSL_CTX>(const SSL *ssl);
 515
 516 =item char *B<SSL_get_app_data>(SSL *ssl);
 517
 518 =item X509 *B<SSL_get_certificate>(const SSL *ssl);
 519
 520 =item const char *B<SSL_get_cipher>(const SSL *ssl);
 521
 522 =item int B<SSL_get_cipher_bits>(const SSL *ssl, int *alg_bits);
 523
 524 =item char *B<SSL_get_cipher_list>(const SSL *ssl, int n);
 525
 526 =item char *B<SSL_get_cipher_name>(const SSL *ssl);
 527
 528 =item char *B<SSL_get_cipher_version>(const SSL *ssl);
 529
 530 =item STACK *B<SSL_get_ciphers>(const SSL *ssl);
 531
 532 =item STACK *B<SSL_get_client_CA_list>(const SSL *ssl);
 533
 534 =item SSL_CIPHER *B<SSL_get_current_cipher>(SSL *ssl);
 535
 536 =item long B<SSL_get_default_timeout>(const SSL *ssl);
 537
 538 =item int B<SSL_get_error>(const SSL *ssl, int i);
 539
 540 =item char *B<SSL_get_ex_data>(const SSL *ssl, int idx);
 541
 542 =item int B<SSL_get_ex_data_X509_STORE_CTX_idx>(void);
 543
 544 =item int B<SSL_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
 545
 546 =item int B<SSL_get_fd>(const SSL *ssl);
 547
 548 =item void (*B<SSL_get_info_callback>(const SSL *ssl);)()
 549
 550 =item STACK *B<SSL_get_peer_cert_chain>(const SSL *ssl);
 551
 552 =item X509 *B<SSL_get_peer_certificate>(const SSL *ssl);
 553
 554 =item EVP_PKEY *B<SSL_get_privatekey>(const SSL *ssl);
 555
 556 =item int B<SSL_get_quiet_shutdown>(const SSL *ssl);
 557
 558 =item BIO *B<SSL_get_rbio>(const SSL *ssl);
 559
 560 =item int B<SSL_get_read_ahead>(const SSL *ssl);
 561
 562 =item SSL_SESSION *B<SSL_get_session>(const SSL *ssl);
 563
 564 =item char *B<SSL_get_shared_ciphers>(const SSL *ssl, char *buf, int len);
 565
 566 =item int B<SSL_get_shutdown>(const SSL *ssl);
 567
 568 =item const SSL_METHOD *B<SSL_get_ssl_method>(SSL *ssl);
 569
 570 =item int B<SSL_get_state>(const SSL *ssl);
 571
 572 =item long B<SSL_get_time>(const SSL *ssl);
 573
 574 =item long B<SSL_get_timeout>(const SSL *ssl);
 575
 576 =item int (*B<SSL_get_verify_callback>(const SSL *ssl))(int,X509_STORE_CTX *)
 577
 578 =item int B<SSL_get_verify_mode>(const SSL *ssl);
 579
 580 =item long B<SSL_get_verify_result>(const SSL *ssl);
 581
 582 =item char *B<SSL_get_version>(const SSL *ssl);
 583
 584 =item BIO *B<SSL_get_wbio>(const SSL *ssl);
 585
 586 =item int B<SSL_in_accept_init>(SSL *ssl);
 587
 588 =item int B<SSL_in_before>(SSL *ssl);
 589
 590 =item int B<SSL_in_connect_init>(SSL *ssl);
 591
 592 =item int B<SSL_in_init>(SSL *ssl);
 593
 594 =item int B<SSL_is_init_finished>(SSL *ssl);
 595
 596 =item STACK *B<SSL_load_client_CA_file>(char *file);
 597
 598 =item SSL *B<SSL_new>(SSL_CTX *ctx);
 599
 600 =item void SSL_up_ref(SSL *s);
 601
 602 =item long B<SSL_num_renegotiations>(SSL *ssl);
 603
 604 =item int B<SSL_peek>(SSL *ssl, void *buf, int num);
 605
 606 =item int B<SSL_pending>(const SSL *ssl);
 607
 608 =item int B<SSL_read>(SSL *ssl, void *buf, int num);
 609
 610 =item int B<SSL_renegotiate>(SSL *ssl);
 611
 612 =item char *B<SSL_rstate_string>(SSL *ssl);
 613
 614 =item char *B<SSL_rstate_string_long>(SSL *ssl);
 615
 616 =item long B<SSL_session_reused>(SSL *ssl);
 617
 618 =item void B<SSL_set_accept_state>(SSL *ssl);
 619
 620 =item void B<SSL_set_app_data>(SSL *ssl, char *arg);
 621
 622 =item void B<SSL_set_bio>(SSL *ssl, BIO *rbio, BIO *wbio);
 623
 624 =item int B<SSL_set_cipher_list>(SSL *ssl, char *str);
 625
 626 =item void B<SSL_set_client_CA_list>(SSL *ssl, STACK *list);
 627
 628 =item void B<SSL_set_connect_state>(SSL *ssl);
 629
 630 =item int B<SSL_set_ex_data>(SSL *ssl, int idx, char *arg);
 631
 632 =item int B<SSL_set_fd>(SSL *ssl, int fd);
 633
 634 =item void B<SSL_set_info_callback>(SSL *ssl, void (*cb);(void))
 635
 636 =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));
 637
 638 =item void B<SSL_set_msg_callback_arg>(SSL *ctx, void *arg);
 639
 640 =item unsigned long B<SSL_clear_options>(SSL *ssl, unsigned long op);
 641
 642 =item unsigned long B<SSL_get_options>(SSL *ssl);
 643
 644 =item unsigned long B<SSL_set_options>(SSL *ssl, unsigned long op);
 645
 646 =item void B<SSL_set_quiet_shutdown>(SSL *ssl, int mode);
 647
 648 =item void B<SSL_set_read_ahead>(SSL *ssl, int yes);
 649
 650 =item int B<SSL_set_rfd>(SSL *ssl, int fd);
 651
 652 =item int B<SSL_set_session>(SSL *ssl, SSL_SESSION *session);
 653
 654 =item void B<SSL_set_shutdown>(SSL *ssl, int mode);
 655
 656 =item int B<SSL_set_ssl_method>(SSL *ssl, const SSL_METHOD *meth);
 657
 658 =item void B<SSL_set_time>(SSL *ssl, long t);
 659
 660 =item void B<SSL_set_timeout>(SSL *ssl, long t);
 661
 662 =item void B<SSL_set_verify>(SSL *ssl, int mode, int (*callback);(void))
 663
 664 =item void B<SSL_set_verify_result>(SSL *ssl, long arg);
 665
 666 =item int B<SSL_set_wfd>(SSL *ssl, int fd);
 667
 668 =item int B<SSL_shutdown>(SSL *ssl);
 669
 670 =item OSSL_HANDSHAKE_STATE B<SSL_get_state>(const SSL *ssl);
 671
 672 Returns the current handshake state.
 673
 674 =item char *B<SSL_state_string>(const SSL *ssl);
 675
 676 =item char *B<SSL_state_string_long>(const SSL *ssl);
 677
 678 =item long B<SSL_total_renegotiations>(SSL *ssl);
 679
 680 =item int B<SSL_use_PrivateKey>(SSL *ssl, EVP_PKEY *pkey);
 681
 682 =item int B<SSL_use_PrivateKey_ASN1>(int type, SSL *ssl, unsigned char *d, long len);
 683
 684 =item int B<SSL_use_PrivateKey_file>(SSL *ssl, char *file, int type);
 685
 686 =item int B<SSL_use_RSAPrivateKey>(SSL *ssl, RSA *rsa);
 687
 688 =item int B<SSL_use_RSAPrivateKey_ASN1>(SSL *ssl, unsigned char *d, long len);
 689
 690 =item int B<SSL_use_RSAPrivateKey_file>(SSL *ssl, char *file, int type);
 691
 692 =item int B<SSL_use_certificate>(SSL *ssl, X509 *x);
 693
 694 =item int B<SSL_use_certificate_ASN1>(SSL *ssl, int len, unsigned char *d);
 695
 696 =item int B<SSL_use_certificate_file>(SSL *ssl, char *file, int type);
 697
 698 =item int B<SSL_version>(const SSL *ssl);
 699
 700 =item int B<SSL_want>(const SSL *ssl);
 701
 702 =item int B<SSL_want_nothing>(const SSL *ssl);
 703
 704 =item int B<SSL_want_read>(const SSL *ssl);
 705
 706 =item int B<SSL_want_write>(const SSL *ssl);
 707
 708 =item int B<SSL_want_x509_lookup>(const SSL *ssl);
 709
 710 =item int B<SSL_write>(SSL *ssl, const void *buf, int num);
 711
 712 =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));
 713
 714 =item int B<SSL_use_psk_identity_hint>(SSL *ssl, const char *hint);
 715
 716 =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));
 717
 718 =item const char *B<SSL_get_psk_identity_hint>(SSL *ssl);
 719
 720 =item const char *B<SSL_get_psk_identity>(SSL *ssl);
 721
 722 =back
 723
 724 =head1 SEE ALSO
 725
 726 L<openssl(1)>, L<crypto(3)>,
 727 L<CRYPTO_get_ex_new_index(3)>,
 728 L<SSL_accept(3)>, L<SSL_clear(3)>,
 729 L<SSL_connect(3)>,
 730 L<SSL_CIPHER_get_name(3)>,
 731 L<SSL_COMP_add_compression_method(3)>,
 732 L<SSL_CTX_add_extra_chain_cert(3)>,
 733 L<SSL_CTX_add_session(3)>,
 734 L<SSL_CTX_ctrl(3)>,
 735 L<SSL_CTX_flush_sessions(3)>,
 736 L<SSL_CTX_get_verify_mode(3)>,
 737 L<SSL_CTX_load_verify_locations(3)>
 738 L<SSL_CTX_new(3)>,
 739 L<SSL_CTX_sess_number(3)>,
 740 L<SSL_CTX_sess_set_cache_size(3)>,
 741 L<SSL_CTX_sess_set_get_cb(3)>,
 742 L<SSL_CTX_sessions(3)>,
 743 L<SSL_CTX_set_cert_store(3)>,
 744 L<SSL_CTX_set_cert_verify_callback(3)>,
 745 L<SSL_CTX_set_cipher_list(3)>,
 746 L<SSL_CTX_set_client_CA_list(3)>,
 747 L<SSL_CTX_set_client_cert_cb(3)>,
 748 L<SSL_CTX_set_default_passwd_cb(3)>,
 749 L<SSL_CTX_set_generate_session_id(3)>,
 750 L<SSL_CTX_set_info_callback(3)>,
 751 L<SSL_CTX_set_max_cert_list(3)>,
 752 L<SSL_CTX_set_mode(3)>,
 753 L<SSL_CTX_set_msg_callback(3)>,
 754 L<SSL_CTX_set_options(3)>,
 755 L<SSL_CTX_set_quiet_shutdown(3)>,
 756 L<SSL_CTX_set_read_ahead(3)>,
 757 L<SSL_CTX_set_session_cache_mode(3)>,
 758 L<SSL_CTX_set_session_id_context(3)>,
 759 L<SSL_CTX_set_ssl_version(3)>,
 760 L<SSL_CTX_set_timeout(3)>,
 761 L<SSL_CTX_set_tmp_dh_callback(3)>,
 762 L<SSL_CTX_set_verify(3)>,
 763 L<SSL_CTX_use_certificate(3)>,
 764 L<SSL_alert_type_string(3)>,
 765 L<SSL_do_handshake(3)>,
 766 L<SSL_get_SSL_CTX(3)>,
 767 L<SSL_get_ciphers(3)>,
 768 L<SSL_get_client_CA_list(3)>,
 769 L<SSL_get_default_timeout(3)>,
 770 L<SSL_get_error(3)>,
 771 L<SSL_get_ex_data_X509_STORE_CTX_idx(3)>,
 772 L<SSL_get_fd(3)>,
 773 L<SSL_get_peer_cert_chain(3)>,
 774 L<SSL_get_rbio(3)>,
 775 L<SSL_get_session(3)>,
 776 L<SSL_get_verify_result(3)>,
 777 L<SSL_get_version(3)>,
 778 L<SSL_load_client_CA_file(3)>,
 779 L<SSL_new(3)>,
 780 L<SSL_pending(3)>,
 781 L<SSL_read(3)>,
 782 L<SSL_rstate_string(3)>,
 783 L<SSL_session_reused(3)>,
 784 L<SSL_set_bio(3)>,
 785 L<SSL_set_connect_state(3)>,
 786 L<SSL_set_fd(3)>,
 787 L<SSL_set_session(3)>,
 788 L<SSL_set_shutdown(3)>,
 789 L<SSL_shutdown(3)>,
 790 L<SSL_state_string(3)>,
 791 L<SSL_want(3)>,
 792 L<SSL_write(3)>,
 793 L<SSL_SESSION_free(3)>,
 794 L<SSL_SESSION_get_time(3)>,
 795 L<d2i_SSL_SESSION(3)>,
 796 L<SSL_CTX_set_psk_client_callback(3)>,
 797 L<SSL_CTX_use_psk_identity_hint(3)>,
 798 L<SSL_get_psk_identity(3)>,
 799 L<DTLSv1_listen(3)>
 800
 801 =head1 HISTORY
 802
 803 B<SSLv2_client_method>, B<SSLv2_server_method> and B<SSLv2_method> where removed
 804 in OpenSSL 1.1.0.
 805
 806 The return type of B<SSL_copy_session_id> was changed from void to int in
 807 OpenSSL 1.1.0.
 808
 809 =cut
 810