openssl

openssl

Synopsis

#define             GNUTLS_X509_CN_SIZE
#define             GNUTLS_X509_C_SIZE
#define             GNUTLS_X509_O_SIZE
#define             GNUTLS_X509_OU_SIZE
#define             GNUTLS_X509_L_SIZE
#define             GNUTLS_X509_S_SIZE
#define             GNUTLS_X509_EMAIL_SIZE
#define             OPENSSL_VERSION_NUMBER
#define             SSLEAY_VERSION_NUMBER
#define             OPENSSL_VERSION_TEXT
#define             SSL_ERROR_NONE
#define             SSL_ERROR_SSL
#define             SSL_ERROR_WANT_READ
#define             SSL_ERROR_WANT_WRITE
#define             SSL_ERROR_SYSCALL
#define             SSL_ERROR_ZERO_RETURN
#define             SSL_FILETYPE_PEM
#define             SSL_VERIFY_NONE
#define             SSL_ST_OK
#define             X509_V_ERR_CERT_NOT_YET_VALID
#define             X509_V_ERR_CERT_HAS_EXPIRED
#define             X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT
#define             SSL_OP_ALL
#define             SSL_OP_NO_TLSv1
#define             SSL_MODE_ENABLE_PARTIAL_WRITE
#define             SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
#define             SSL_MODE_AUTO_RETRY
typedef             X509_NAME;
typedef             X509;
                    SSL;
#define             current_cert
#define             X509_STORE_CTX_get_current_cert     (ctx)
int                 verify_callback                     (...,
                                                         X509_STORE_CTX *);
#define             rbio
                    MD_CTX;
struct              rsa_st;
typedef             RSA;
#define             MD5_CTX
#define             RIPEMD160_CTX
#define             OpenSSL_add_ssl_algorithms          ()
#define             SSLeay_add_ssl_algorithms           ()
#define             SSLeay_add_all_algorithms           ()
#define             SSL_get_cipher_name                 (ssl)
#define             SSL_get_cipher                      (ssl)
#define             SSL_get_cipher_bits                 (ssl,bp)
#define             SSL_get_cipher_version              (ssl)
int                 SSL_library_init                    (void);
void                OpenSSL_add_all_algorithms          (void);
SSL_CTX *           SSL_CTX_new                         (SSL_METHOD *method);
void                SSL_CTX_free                        (SSL_CTX *ctx);
int                 SSL_CTX_set_default_verify_paths    (SSL_CTX *ctx);
int                 SSL_CTX_use_certificate_file        (SSL_CTX *ctx,
                                                         const char *certfile,
                                                         int type);
int                 SSL_CTX_use_PrivateKey_file         (SSL_CTX *ctx,
                                                         const char *keyfile,
                                                         int type);
void                SSL_CTX_set_verify                  (SSL_CTX *ctx,
                                                         int verify_mode,
                                                         int (verify_callbackint, X509_STORE_CTX *) ());
unsigned long       SSL_CTX_set_options                 (SSL_CTX *ctx,
                                                         unsigned long  options);
long                SSL_CTX_set_mode                    (SSL_CTX *ctx,
                                                         long mode );
int                 SSL_CTX_set_cipher_list             (SSL_CTX *ctx,
                                                         const char *list);
long                SSL_CTX_sess_number                 (SSL_CTX *ctx);
long                SSL_CTX_sess_connect                (SSL_CTX *ctx);
long                SSL_CTX_sess_connect_good           (SSL_CTX *ctx);
long                SSL_CTX_sess_connect_renegotiate    (SSL_CTX *ctx);
long                SSL_CTX_sess_accept                 (SSL_CTX *ctx);
long                SSL_CTX_sess_accept_good            (SSL_CTX *ctx);
long                SSL_CTX_sess_accept_renegotiate     (SSL_CTX *ctx);
long                SSL_CTX_sess_hits                   (SSL_CTX *ctx);
long                SSL_CTX_sess_misses                 (SSL_CTX *ctx);
long                SSL_CTX_sess_timeouts               (SSL_CTX *ctx);
SSL *               SSL_new                             (SSL_CTX *ctx);
void                SSL_free                            (SSL *ssl);
void                SSL_load_error_strings              (void);
int                 SSL_get_error                       (SSL *ssl,
                                                         int ret);
int                 SSL_set_fd                          (SSL *ssl,
                                                         int fd);
int                 SSL_set_rfd                         (SSL *ssl,
                                                         int fd);
int                 SSL_set_wfd                         (SSL *ssl,
                                                         int fd);
void                SSL_set_bio                         (SSL *ssl,
                                                         BIO *rbio,
                                                         BIO *wbio);
void                SSL_set_connect_state               (SSL *ssl);
int                 SSL_pending                         (SSL *ssl);
void                SSL_set_verify                      (SSL *ssl,
                                                         int verify_mode,
                                                         int (verify_callbackint, X509_STORE_CTX *) ());
const X509 *        SSL_get_peer_certificate            (SSL *ssl);
int                 SSL_connect                         (SSL *ssl);
int                 SSL_accept                          (SSL *ssl);
int                 SSL_shutdown                        (SSL *ssl);
int                 SSL_read                            (SSL *ssl,
                                                         void *buf,
                                                         int len);
int                 SSL_write                           (SSL *ssl,
                                                         const void *buf,
                                                         int len);
int                 SSL_want                            (SSL *ssl);
#define             SSL_NOTHING
#define             SSL_WRITING
#define             SSL_READING
#define             SSL_X509_LOOKUP
#define             SSL_want_nothing                    (s)
#define             SSL_want_read                       (s)
#define             SSL_want_write                      (s)
#define             SSL_want_x509_lookup                (s)
SSL_METHOD *        SSLv23_client_method                (void);
SSL_METHOD *        SSLv23_server_method                (void);
SSL_METHOD *        SSLv3_client_method                 (void);
SSL_METHOD *        SSLv3_server_method                 (void);
SSL_METHOD *        TLSv1_client_method                 (void);
SSL_METHOD *        TLSv1_server_method                 (void);
SSL_CIPHER *        SSL_get_current_cipher              (SSL *ssl);
const char *        SSL_CIPHER_get_name                 (SSL_CIPHER *cipher);
int                 SSL_CIPHER_get_bits                 (SSL_CIPHER *cipher,
                                                         int *bits);
const char *        SSL_CIPHER_get_version              (SSL_CIPHER *cipher);
char *              SSL_CIPHER_description              (SSL_CIPHER *cipher,
                                                         char *buf,
                                                         int size);
X509_NAME *         X509_get_subject_name               (const X509 *cert);
X509_NAME *         X509_get_issuer_name                (const X509 *cert);
char *              X509_NAME_oneline                   (gnutls_x509_dn *name,
                                                         char *buf,
                                                         int len);
void                X509_free                           (const X509 *cert);
void                BIO_get_fd                          (gnutls_session_t gnutls_state,
                                                         int *fd);
BIO *               BIO_new_socket                      (int sock,
                                                         int close_flag);
unsigned long       ERR_get_error                       (void);
const char *        ERR_error_string                    (unsigned long  e,
                                                         char *buf);
int                 RAND_status                         (void);
void                RAND_seed                           (const void *buf,
                                                         int num);
int                 RAND_bytes                          (unsigned char *buf,
                                                         int num);
int                 RAND_pseudo_bytes                   (unsigned char *buf,
                                                         int num);
const char *        RAND_file_name                      (char *buf,
                                                         size_t len);
int                 RAND_load_file                      (const char *name,
                                                         long maxbytes );
int                 RAND_write_file                     (const char *name);
int                 RAND_egd_bytes                      (const char *path,
                                                         int bytes);
#define             RAND_egd                            (p)
#define             MD5_DIGEST_LENGTH
void                MD5_Init                            (MD5_CTX *ctx);
void                MD5_Update                          (MD5_CTX *ctx,
                                                         const void *buf,
                                                         int len);
void                MD5_Final                           (unsigned char *md,
                                                         MD5_CTX *ctx);
unsigned char *     MD5                                 (unsigned char *buf,
                                                         unsigned long  len,
                                                         unsigned char *md);
void                RIPEMD160_Init                      (RIPEMD160_CTX *ctx);
void                RIPEMD160_Update                    (RIPEMD160_CTX *ctx,
                                                         const void *buf,
                                                         int len);
void                RIPEMD160_Final                     (unsigned char *md,
                                                         RIPEMD160_CTX *ctx);
unsigned char *     RIPEMD160                           (unsigned char *buf,
                                                         unsigned long  len,
                                                         unsigned char *md);

Description

Details

GNUTLS_X509_CN_SIZE

#define GNUTLS_X509_CN_SIZE 256

GNUTLS_X509_C_SIZE

#define GNUTLS_X509_C_SIZE 3

GNUTLS_X509_O_SIZE

#define GNUTLS_X509_O_SIZE 256

GNUTLS_X509_OU_SIZE

#define GNUTLS_X509_OU_SIZE 256

GNUTLS_X509_L_SIZE

#define GNUTLS_X509_L_SIZE 256

GNUTLS_X509_S_SIZE

#define GNUTLS_X509_S_SIZE 256

GNUTLS_X509_EMAIL_SIZE

#define GNUTLS_X509_EMAIL_SIZE 256

OPENSSL_VERSION_NUMBER

#define OPENSSL_VERSION_NUMBER (0x0090604F)

SSLEAY_VERSION_NUMBER

#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER

OPENSSL_VERSION_TEXT

#define OPENSSL_VERSION_TEXT ("GNUTLS " LIBGNUTLS_VERSION " ")

SSL_ERROR_NONE

#define SSL_ERROR_NONE        (0)

SSL_ERROR_SSL

#define SSL_ERROR_SSL         (1)

SSL_ERROR_WANT_READ

#define SSL_ERROR_WANT_READ   (2)

SSL_ERROR_WANT_WRITE

#define SSL_ERROR_WANT_WRITE  (3)

SSL_ERROR_SYSCALL

#define SSL_ERROR_SYSCALL     (5)

SSL_ERROR_ZERO_RETURN

#define SSL_ERROR_ZERO_RETURN (6)

SSL_FILETYPE_PEM

#define SSL_FILETYPE_PEM (GNUTLS_X509_FMT_PEM)

SSL_VERIFY_NONE

#define SSL_VERIFY_NONE (0)

SSL_ST_OK

#define SSL_ST_OK (1)

X509_V_ERR_CERT_NOT_YET_VALID

#define X509_V_ERR_CERT_NOT_YET_VALID          (1)

X509_V_ERR_CERT_HAS_EXPIRED

#define X509_V_ERR_CERT_HAS_EXPIRED            (2)

X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT

#define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT (3)

SSL_OP_ALL

#define SSL_OP_ALL (0x000FFFFF)

SSL_OP_NO_TLSv1

#define SSL_OP_NO_TLSv1 (0x0400000)

SSL_MODE_ENABLE_PARTIAL_WRITE

#define SSL_MODE_ENABLE_PARTIAL_WRITE (0x1)

SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER

#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER (0x2)

SSL_MODE_AUTO_RETRY

#define SSL_MODE_AUTO_RETRY (0x4)

X509_NAME

  typedef gnutls_x509_dn X509_NAME;

X509

  typedef gnutls_datum_t X509;

SSL

typedef struct {
    gnutls_session_t gnutls_state;

    gnutls_certificate_client_credentials gnutls_cred;

    SSL_CTX *ctx;
    SSL_CIPHER ciphersuite;

    int last_error;
    int shutdown;
    int state;
    unsigned long options;

    int (*verify_callback) (int, X509_STORE_CTX *);
    int verify_mode;

    gnutls_transport_ptr_t rfd;
    gnutls_transport_ptr_t wfd;
} SSL;

current_cert

#define current_cert cert_list

X509_STORE_CTX_get_current_cert()

#define X509_STORE_CTX_get_current_cert(ctx) ((ctx)->current_cert)

verify_callback ()

int                 verify_callback                     (...,
                                                         X509_STORE_CTX *);

rbio

#define rbio gnutls_state

MD_CTX

typedef struct {
    void* handle;
} MD_CTX;

struct rsa_st

struct rsa_st;

RSA

  typedef struct rsa_st RSA;

MD5_CTX

#define MD5_CTX MD_CTX

RIPEMD160_CTX

#define RIPEMD160_CTX MD_CTX

OpenSSL_add_ssl_algorithms()

#define OpenSSL_add_ssl_algorithms()  SSL_library_init()

SSLeay_add_ssl_algorithms()

#define SSLeay_add_ssl_algorithms()   SSL_library_init()

SSLeay_add_all_algorithms()

#define SSLeay_add_all_algorithms()   OpenSSL_add_all_algorithms()

SSL_get_cipher_name()

#define SSL_get_cipher_name(ssl) SSL_CIPHER_get_name(SSL_get_current_cipher(ssl))

SSL_get_cipher()

#define SSL_get_cipher(ssl) SSL_get_cipher_name(ssl)

SSL_get_cipher_bits()

#define SSL_get_cipher_bits(ssl,bp) SSL_CIPHER_get_bits(SSL_get_current_cipher(ssl),(bp))

SSL_get_cipher_version()

#define SSL_get_cipher_version(ssl) SSL_CIPHER_get_version(SSL_get_current_cipher(ssl))

SSL_library_init ()

int                 SSL_library_init                    (void);

OpenSSL_add_all_algorithms ()

void                OpenSSL_add_all_algorithms          (void);

SSL_CTX_new ()

SSL_CTX *           SSL_CTX_new                         (SSL_METHOD *method);

SSL_CTX_free ()

void                SSL_CTX_free                        (SSL_CTX *ctx);

SSL_CTX_set_default_verify_paths ()

int                 SSL_CTX_set_default_verify_paths    (SSL_CTX *ctx);

SSL_CTX_use_certificate_file ()

int                 SSL_CTX_use_certificate_file        (SSL_CTX *ctx,
                                                         const char *certfile,
                                                         int type);

SSL_CTX_use_PrivateKey_file ()

int                 SSL_CTX_use_PrivateKey_file         (SSL_CTX *ctx,
                                                         const char *keyfile,
                                                         int type);

SSL_CTX_set_verify ()

void                SSL_CTX_set_verify                  (SSL_CTX *ctx,
                                                         int verify_mode,
                                                         int (verify_callbackint, X509_STORE_CTX *) ());

SSL_CTX_set_options ()

unsigned long       SSL_CTX_set_options                 (SSL_CTX *ctx,
                                                         unsigned long  options);

SSL_CTX_set_mode ()

long                SSL_CTX_set_mode                    (SSL_CTX *ctx,
                                                         long mode );

SSL_CTX_set_cipher_list ()

int                 SSL_CTX_set_cipher_list             (SSL_CTX *ctx,
                                                         const char *list);

SSL_CTX_sess_number ()

long                SSL_CTX_sess_number                 (SSL_CTX *ctx);

SSL_CTX_sess_connect ()

long                SSL_CTX_sess_connect                (SSL_CTX *ctx);

SSL_CTX_sess_connect_good ()

long                SSL_CTX_sess_connect_good           (SSL_CTX *ctx);

SSL_CTX_sess_connect_renegotiate ()

long                SSL_CTX_sess_connect_renegotiate    (SSL_CTX *ctx);

SSL_CTX_sess_accept ()

long                SSL_CTX_sess_accept                 (SSL_CTX *ctx);

SSL_CTX_sess_accept_good ()

long                SSL_CTX_sess_accept_good            (SSL_CTX *ctx);

SSL_CTX_sess_accept_renegotiate ()

long                SSL_CTX_sess_accept_renegotiate     (SSL_CTX *ctx);

SSL_CTX_sess_hits ()

long                SSL_CTX_sess_hits                   (SSL_CTX *ctx);

SSL_CTX_sess_misses ()

long                SSL_CTX_sess_misses                 (SSL_CTX *ctx);

SSL_CTX_sess_timeouts ()

long                SSL_CTX_sess_timeouts               (SSL_CTX *ctx);

SSL_new ()

SSL *               SSL_new                             (SSL_CTX *ctx);

SSL_free ()

void                SSL_free                            (SSL *ssl);

SSL_load_error_strings ()

void                SSL_load_error_strings              (void);

SSL_get_error ()

int                 SSL_get_error                       (SSL *ssl,
                                                         int ret);

SSL_set_fd ()

int                 SSL_set_fd                          (SSL *ssl,
                                                         int fd);

SSL_set_rfd ()

int                 SSL_set_rfd                         (SSL *ssl,
                                                         int fd);

SSL_set_wfd ()

int                 SSL_set_wfd                         (SSL *ssl,
                                                         int fd);

SSL_set_bio ()

void                SSL_set_bio                         (SSL *ssl,
                                                         BIO *rbio,
                                                         BIO *wbio);

SSL_set_connect_state ()

void                SSL_set_connect_state               (SSL *ssl);

SSL_pending ()

int                 SSL_pending                         (SSL *ssl);

SSL_set_verify ()

void                SSL_set_verify                      (SSL *ssl,
                                                         int verify_mode,
                                                         int (verify_callbackint, X509_STORE_CTX *) ());

SSL_get_peer_certificate ()

const X509 *        SSL_get_peer_certificate            (SSL *ssl);

SSL_connect ()

int                 SSL_connect                         (SSL *ssl);

SSL_accept ()

int                 SSL_accept                          (SSL *ssl);

SSL_shutdown ()

int                 SSL_shutdown                        (SSL *ssl);

SSL_read ()

int                 SSL_read                            (SSL *ssl,
                                                         void *buf,
                                                         int len);

SSL_write ()

int                 SSL_write                           (SSL *ssl,
                                                         const void *buf,
                                                         int len);

SSL_want ()

int                 SSL_want                            (SSL *ssl);

SSL_NOTHING

#define SSL_NOTHING (1)

SSL_WRITING

#define SSL_WRITING (2)

SSL_READING

#define SSL_READING (3)

SSL_X509_LOOKUP

#define SSL_X509_LOOKUP (4)

SSL_want_nothing()

#define SSL_want_nothing(s) (SSL_want(s) == SSL_NOTHING)

SSL_want_read()

#define SSL_want_read(s) (SSL_want(s) == SSL_READING)

SSL_want_write()

#define SSL_want_write(s) (SSL_want(s) == SSL_WRITING)

SSL_want_x509_lookup()

#define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP)

SSLv23_client_method ()

SSL_METHOD *        SSLv23_client_method                (void);

SSLv23_server_method ()

SSL_METHOD *        SSLv23_server_method                (void);

SSLv3_client_method ()

SSL_METHOD *        SSLv3_client_method                 (void);

SSLv3_server_method ()

SSL_METHOD *        SSLv3_server_method                 (void);

TLSv1_client_method ()

SSL_METHOD *        TLSv1_client_method                 (void);

TLSv1_server_method ()

SSL_METHOD *        TLSv1_server_method                 (void);

SSL_get_current_cipher ()

SSL_CIPHER *        SSL_get_current_cipher              (SSL *ssl);

SSL_CIPHER_get_name ()

const char *        SSL_CIPHER_get_name                 (SSL_CIPHER *cipher);

SSL_CIPHER_get_bits ()

int                 SSL_CIPHER_get_bits                 (SSL_CIPHER *cipher,
                                                         int *bits);

SSL_CIPHER_get_version ()

const char *        SSL_CIPHER_get_version              (SSL_CIPHER *cipher);

SSL_CIPHER_description ()

char *              SSL_CIPHER_description              (SSL_CIPHER *cipher,
                                                         char *buf,
                                                         int size);

X509_get_subject_name ()

X509_NAME *         X509_get_subject_name               (const X509 *cert);

X509_get_issuer_name ()

X509_NAME *         X509_get_issuer_name                (const X509 *cert);

X509_NAME_oneline ()

char *              X509_NAME_oneline                   (gnutls_x509_dn *name,
                                                         char *buf,
                                                         int len);

X509_free ()

void                X509_free                           (const X509 *cert);

BIO_get_fd ()

void                BIO_get_fd                          (gnutls_session_t gnutls_state,
                                                         int *fd);

BIO_new_socket ()

BIO *               BIO_new_socket                      (int sock,
                                                         int close_flag);

ERR_get_error ()

unsigned long       ERR_get_error                       (void);

ERR_error_string ()

const char *        ERR_error_string                    (unsigned long  e,
                                                         char *buf);

RAND_status ()

int                 RAND_status                         (void);

RAND_seed ()

void                RAND_seed                           (const void *buf,
                                                         int num);

RAND_bytes ()

int                 RAND_bytes                          (unsigned char *buf,
                                                         int num);

RAND_pseudo_bytes ()

int                 RAND_pseudo_bytes                   (unsigned char *buf,
                                                         int num);

RAND_file_name ()

const char *        RAND_file_name                      (char *buf,
                                                         size_t len);

RAND_load_file ()

int                 RAND_load_file                      (const char *name,
                                                         long maxbytes );

RAND_write_file ()

int                 RAND_write_file                     (const char *name);

RAND_egd_bytes ()

int                 RAND_egd_bytes                      (const char *path,
                                                         int bytes);

RAND_egd()

#define RAND_egd(p) RAND_egd_bytes((p), 255)

MD5_DIGEST_LENGTH

#define MD5_DIGEST_LENGTH 16

MD5_Init ()

void                MD5_Init                            (MD5_CTX *ctx);

MD5_Update ()

void                MD5_Update                          (MD5_CTX *ctx,
                                                         const void *buf,
                                                         int len);

MD5_Final ()

void                MD5_Final                           (unsigned char *md,
                                                         MD5_CTX *ctx);

MD5 ()

unsigned char *     MD5                                 (unsigned char *buf,
                                                         unsigned long  len,
                                                         unsigned char *md);

RIPEMD160_Init ()

void                RIPEMD160_Init                      (RIPEMD160_CTX *ctx);

RIPEMD160_Update ()

void                RIPEMD160_Update                    (RIPEMD160_CTX *ctx,
                                                         const void *buf,
                                                         int len);

RIPEMD160_Final ()

void                RIPEMD160_Final                     (unsigned char *md,
                                                         RIPEMD160_CTX *ctx);

RIPEMD160 ()

unsigned char *     RIPEMD160                           (unsigned char *buf,
                                                         unsigned long  len,
                                                         unsigned char *md);