ssl

NAME

SYNOPSIS

DESCRIPTION

HEADER FILES

ssl.h

SSL/TLS API 를 위한 공통 헤더·파일입니다. ssl 프로그램 라이브러리를 이용할 수 있는 API 를 make 하는 프로그램에 포함하게 합니다. 사적인 SSL 헤더와 crypto 프로그램 라이브러리로부터의 헤더의 양쪽 모두를 내부적으로 포함합니다. SSL API 내부의 핵심의 상세를 알 필요가 있다면, 이 헤더 파일 내부를 봐 주세요.

ssl2.h

SSLv2 프로토콜만으로 취급하는 서브·헤더·파일입니다. 이미 ssl.h 에 의해 포함되어 있으므로, 보통은 당신이 포함해서는 안됩니다.

ssl3.h

SSLv3 프로토콜만으로 취급하는 서브·헤더·파일입니다. 이미 ssl.h 에 의해 포함되어 있으므로, 보통은 당신이 포함해서는 안됩니다.

ssl23.h

SSLv2 와 SSLv3 프로토콜의 편성으로 취급하는 서브·헤더·파일입니다. 이미 ssl.h 에 의해 포함되어 있으므로, 보통은 당신이 포함해서는 안됩니다.

tls1.h

TLSv1 프로토콜만으로 취급하는 서브·헤더·파일입니다. 이미 ssl.h 에 의해 포함되어 있으므로, 보통은 당신이 포함해서는 안됩니다.

DATA STRUCTURES

SSL_METHOD (SSL Method)

여러가지 프로토콜의 버젼 (SSLv1, SSLv2, TLSv1)을 실장한 내부적인 ssl 프로그램 라이브러리 방식·기능을 기술하고 있는 디스팟치 구성입니다. SSL_CTX 를 만들 필요가 있습니다.

SSL_CIPHER (SSL Cipher)

이 구성은 SSL/TLS 프로토콜의 핵심 부분이 되어 있는 특정의 cipher 를 위한 알고리즘 정보를 가지고 있습니다. 이용할 수 있는 cipher 는 SSL_CTX 를 기본으로 설정되어 실제로 사용되는 것은 SSL_SESSION 의 부분입니다.

SSL_CTX (SSL Context)

프로그램의 life-time 마다 한 번, 서버와 클라이언트에 의해 만들어져 접속을 위해서(때문에) 다음에 만들어지는 SSL 구성을 위한 디폴트치를 주로 가지는 전체적인 콘텍스트 구성입니다.

SSL_SESSION (SSL Session)

이것은 접속을 위한 최신의 SSL 세션의 상세를 포함한 구성입니다:SSL_CIPHER, 클라이언트와 서버의 증명서, 열쇠, 등.

SSL (SSL Connection)

확립한 접속마다 서버나 클라이언트에 의해 만들어지는 주된 SSL/TLS 구성입니다. 이것은 실제로는 SSL API 에서는 핵심이 되는 구성입니다. run-time 의 어플리케이션은 통상, 거의 다른 모든 구성에 대한 링크를 가진 구성에 대응하고 있습니다.

API FUNCTIONS

DEALING WITH PROTOCOL METHODS

SSL_METHOD *SSLv2_client_method(void);

전용 클라이언트를 위한 SSLv2 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *SSLv2_server_method(void);

전용 서버를 위한 SSLv2 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *SSLv2_method(void);

짜 합쳐진 클라이언트와 서버를 위한 SSLv2 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *SSLv3_client_method(void);

전용의 클라이언트를 위한 SSLv3 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *SSLv3_server_method(void);

전용 서버를 위한 SSLv3 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *SSLv3_method(void);

짜 합쳐진 클라이언트와 서버를 위한 SSLv3 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *TLSv1_client_method(void);

전용 클라이언트를 위한 TLSv1 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *TLSv1_server_method(void);

전용 서버를 위한 TLSv1 SSL_METHOD 구성에 대한 컨스트릭터.

SSL_METHOD *TLSv1_method(void);

짜 합쳐진 클라이언트와 서버를 위한 TLSv1 SSL_METHOD 구성에 대한 컨스트릭터.

DEALING WITH CIPHERS

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

사람이 읽을 수 있는 cipher 의 기술을 포함한 buf (len 의 최대 사이즈로)에 캐릭터 라인을 써,buf 를 돌려줍니다.

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

cipher 로 비트수를 결정합니다. 2 비트에서는 도움이 되지 않는 cipher 를 export 하기 (위해)때문에입니다: 일반적(alg_bits 에 축적되고 있다)으로 알고리즘이 서포트하고 있는 비트와 실제로 사용되는 비트(돌아가 값)

char *SSL_CIPHER_get_name(SSL_CIPHER *cipher);

캐릭터 라인으로서 내부적인 cipher 의 이름을 돌려줍니다. 이것들은 헤더·파일로 SSL2_TXT_xxx,SSL3_TXT_xxx,TLS1_TXT_xxx 에 의해 정의된 여러가지 캐릭터 라인입니다.

char *SSL_CIPHER_get_version(SSL_CIPHER *cipher);

cipher 가 속하는 (즉, 최초의 사양으로 정의된) SSL/TLS 프로토콜의 버젼을 나타내는 ``TLSv1/SSLv3''나 ``SSLv2''와 같은 캐릭터 라인을 돌려줍니다

DEALING WITH PROTOCOL CONTEXTS

int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x);

long SSL_CTX_add_extra_chain_cert(SSL_CTX *ctx, X509 *x509);

int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c);

int SSL_CTX_check_private_key(SSL_CTX *ctx);

long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, char *parg);

void SSL_CTX_flush_sessions(SSL_CTX *s, long t);

void SSL_CTX_free(SSL_CTX *a);

char *SSL_CTX_get_app_data(SSL_CTX *ctx);

X509_STORE *SSL_CTX_get_cert_store(SSL_CTX *ctx);

STACK *SSL_CTX_get_client_CA_list(SSL_CTX *ctx);

int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey);

char *SSL_CTX_get_ex_data(SSL_CTX *s, int idx);

int SSL_CTX_get_ex_new_index(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))

void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(SSL *ssl, int cb, int ret);

int SSL_CTX_get_quiet_shutdown(SSL_CTX *ctx);

int SSL_CTX_get_session_cache_mode(SSL_CTX *ctx);

long SSL_CTX_get_timeout(SSL_CTX *ctx);

int (*SSL_CTX_get_verify_callback(SSL_CTX *ctx))(int ok, X509_STORE_CTX *ctx);

int SSL_CTX_get_verify_mode(SSL_CTX *ctx);

int SSL_CTX_load_verify_locations(SSL_CTX *ctx, char *CAfile, char *CApath);

long SSL_CTX_need_tmp_RSA(SSL_CTX *ctx);

SSL_CTX *SSL_CTX_new(SSL_METHOD *meth);

int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c);

int SSL_CTX_sess_accept(SSL_CTX *ctx);

int SSL_CTX_sess_accept_good(SSL_CTX *ctx);

int SSL_CTX_sess_accept_renegotiate(SSL_CTX *ctx);

int SSL_CTX_sess_cache_full(SSL_CTX *ctx);

int SSL_CTX_sess_cb_hits(SSL_CTX *ctx);

int SSL_CTX_sess_connect(SSL_CTX *ctx);

int SSL_CTX_sess_connect_good(SSL_CTX *ctx);

int SSL_CTX_sess_connect_renegotiate(SSL_CTX *ctx);

int SSL_CTX_sess_get_cache_size(SSL_CTX *ctx);

SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(SSL *ssl, unsigned char *data, int len, int *copy);

int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)(SSL *ssl, SSL_SESSION *sess);

void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)(SSL_CTX *ctx, SSL_SESSION *sess);

int SSL_CTX_sess_hits(SSL_CTX *ctx);

int SSL_CTX_sess_misses(SSL_CTX *ctx);

int SSL_CTX_sess_number(SSL_CTX *ctx);

void SSL_CTX_sess_set_cache_size(SSL_CTX *ctx, t);

void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, SSL_SESSION *(*cb)(SSL *ssl, unsigned char *data, int len, int *copy));

void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx, int (*cb)(SSL *ssl, SSL_SESSION *sess));

void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx, void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess));

int SSL_CTX_sess_timeouts(SSL_CTX *ctx);

LHASH *SSL_CTX_sessions(SSL_CTX *ctx);

void SSL_CTX_set_app_data(SSL_CTX *ctx, void *arg);

void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *cs);

void SSL_CTX_set_cert_verify_cb(SSL_CTX *ctx, int (*cb)(SSL_CTX *), char *arg)

int SSL_CTX_set_cipher_list(SSL_CTX *ctx, char *str);

void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK *list);

void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey));

void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, int (*cb);(void))

void SSL_CTX_set_default_read_ahead(SSL_CTX *ctx, int m);

int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);

int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, char *arg);

void SSL_CTX_set_info_callback(SSL_CTX *ctx, void (*cb)(SSL *ssl, int cb, int ret));

void SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op);

void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode);

void SSL_CTX_set_session_cache_mode(SSL_CTX *ctx, int mode);

int SSL_CTX_set_ssl_version(SSL_CTX *ctx, SSL_METHOD *meth);

void SSL_CTX_set_timeout(SSL_CTX *ctx, long t);

long SSL_CTX_set_tmp_dh(SSL_CTX* ctx, DH *dh);

long SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, DH *(*cb)(void));

long SSL_CTX_set_tmp_rsa(SSL_CTX *ctx, RSA *rsa);

long SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA *(*cb)(void));

void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, int (*cb);(void))

int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);

int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx, unsigned char *d, long len);

int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, char *file, int type);

int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);

int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len);

int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, char *file, int type);

int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);

int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d);

int SSL_CTX_use_certificate_file(SSL_CTX *ctx, char *file, int type);

 

DEALING WITH SESSIONS

int SSL_SESSION_cmp(SSL_SESSION *a, SSL_SESSION *b);

void SSL_SESSION_free(SSL_SESSION *ss);

char *SSL_SESSION_get_app_data(SSL_SESSION *s);

char *SSL_SESSION_get_ex_data(SSL_SESSION *s, int idx);

int SSL_SESSION_get_ex_new_index(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))

long SSL_SESSION_get_time(SSL_SESSION *s);

long SSL_SESSION_get_timeout(SSL_SESSION *s);

unsigned long SSL_SESSION_hash(SSL_SESSION *a);

SSL_SESSION *SSL_SESSION_new(void);

int SSL_SESSION_print(BIO *bp, SSL_SESSION *x);

int SSL_SESSION_print_fp(FILE *fp, SSL_SESSION *x);

void SSL_SESSION_set_app_data(SSL_SESSION *s, char *a);

int SSL_SESSION_set_ex_data(SSL_SESSION *s, int idx, char *arg);

long SSL_SESSION_set_time(SSL_SESSION *s, long t);

long SSL_SESSION_set_timeout(SSL_SESSION *s, long t);

 

DEALING WITH CONNECTIONS

int SSL_accept(SSL *ssl);

int SSL_add_client_CA(SSL *ssl, X509 *x);

char *SSL_alert_desc_string(int value);

char *SSL_alert_desc_string_long(int value);

char *SSL_alert_type_string(int value);

char *SSL_alert_type_string_long(int value);

int SSL_check_private_key(SSL *ssl);

void SSL_clear(SSL *ssl);

long SSL_clear_num_renegotiations(SSL *ssl);

int SSL_connect(SSL *ssl);

void SSL_copy_session_id(SSL *t, SSL *f);

long SSL_ctrl(SSL *ssl, int cmd, long larg, char *parg);

int SSL_do_handshake(SSL *ssl);

SSL *SSL_dup(SSL *ssl);

STACK *SSL_dup_CA_list(STACK *sk);

void SSL_free(SSL *ssl);

SSL_CTX *SSL_get_SSL_CTX(SSL *ssl);

char *SSL_get_app_data(SSL *ssl);

X509 *SSL_get_certificate(SSL *ssl);

SSL_CIPHER *SSL_get_cipher(SSL *ssl);

int SSL_get_cipher_bits(SSL *ssl, int *alg_bits);

char *SSL_get_cipher_list(SSL *ssl, int n);

char *SSL_get_cipher_name(SSL *ssl);

char *SSL_get_cipher_version(SSL *ssl);

STACK *SSL_get_ciphers(SSL *ssl);

STACK *SSL_get_client_CA_list(SSL *ssl);

SSL_CIPHER *SSL_get_current_cipher(SSL *ssl);

long SSL_get_default_timeout(SSL *ssl);

int SSL_get_error(SSL *ssl, int i);

char *SSL_get_ex_data(SSL *ssl, int idx);

int SSL_get_ex_data_X509_STORE_CTX_idx(void);

int SSL_get_ex_new_index(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))

int SSL_get_fd(SSL *ssl);

void (*SSL_get_info_callback(SSL *ssl);)(void)

STACK *SSL_get_peer_cert_chain(SSL *ssl);

X509 *SSL_get_peer_certificate(SSL *ssl);

EVP_PKEY *SSL_get_privatekey(SSL *ssl);

int SSL_get_quiet_shutdown(SSL *ssl);

BIO *SSL_get_rbio(SSL *ssl);

int SSL_get_read_ahead(SSL *ssl);

SSL_SESSION *SSL_get_session(SSL *ssl);

char *SSL_get_shared_ciphers(SSL *ssl, char *buf, int len);

int SSL_get_shutdown(SSL *ssl);

SSL_METHOD *SSL_get_ssl_method(SSL *ssl);

int SSL_get_state(SSL *ssl);

long SSL_get_time(SSL *ssl);

long SSL_get_timeout(SSL *ssl);

int (*SSL_get_verify_callback(SSL *ssl);)(void)

int SSL_get_verify_mode(SSL *ssl);

long SSL_get_verify_result(SSL *ssl);

char *SSL_get_version(SSL *ssl);

BIO *SSL_get_wbio(SSL *ssl);

int SSL_in_accept_init(SSL *ssl);

int SSL_in_before(SSL *ssl);

int SSL_in_connect_init(SSL *ssl);

int SSL_in_init(SSL *ssl);

int SSL_is_init_finished(SSL *ssl);

STACK *SSL_load_client_CA_file(char *file);

void SSL_load_error_strings(void);

SSL *SSL_new(SSL_CTX *ctx);

long SSL_num_renegotiations(SSL *ssl);

int SSL_peek(SSL *ssl, char *buf, int num);

int SSL_pending(SSL *ssl);

int SSL_read(SSL *ssl, char *buf, int num);

int SSL_renegotiate(SSL *ssl);

char *SSL_rstate_string(SSL *ssl);

char *SSL_rstate_string_long(SSL *ssl);

long SSL_session_reused(SSL *ssl);

void SSL_set_accept_state(SSL *ssl);

void SSL_set_app_data(SSL *ssl, char *arg);

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

int SSL_set_cipher_list(SSL *ssl, char *str);

void SSL_set_client_CA_list(SSL *ssl, STACK *list);

void SSL_set_connect_state(SSL *ssl);

int SSL_set_ex_data(SSL *ssl, int idx, char *arg);

int SSL_set_fd(SSL *ssl, int fd);

void SSL_set_info_callback(SSL *ssl, void (*cb);(void))

void SSL_set_options(SSL *ssl, unsigned long op);

void SSL_set_quiet_shutdown(SSL *ssl, int mode);

void SSL_set_read_ahead(SSL *ssl, int yes);

int SSL_set_rfd(SSL *ssl, int fd);

int SSL_set_session(SSL *ssl, SSL_SESSION *session);

void SSL_set_shutdown(SSL *ssl, int mode);

int SSL_set_ssl_method(SSL *ssl, SSL_METHOD *meth);

void SSL_set_time(SSL *ssl, long t);

void SSL_set_timeout(SSL *ssl, long t);

void SSL_set_verify(SSL *ssl, int mode, int (*callback);(void))

void SSL_set_verify_result(SSL *ssl, long arg);

int SSL_set_wfd(SSL *ssl, int fd);

int SSL_shutdown(SSL *ssl);

int SSL_state(SSL *ssl);

char *SSL_state_string(SSL *ssl);

char *SSL_state_string_long(SSL *ssl);

long SSL_total_renegotiations(SSL *ssl);

int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);

int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, unsigned char *d, long len);

int SSL_use_PrivateKey_file(SSL *ssl, char *file, int type);

int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);

int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len);

int SSL_use_RSAPrivateKey_file(SSL *ssl, char *file, int type);

int SSL_use_certificate(SSL *ssl, X509 *x);

int SSL_use_certificate_ASN1(SSL *ssl, int len, unsigned char *d);

int SSL_use_certificate_file(SSL *ssl, char *file, int type);

int SSL_version(SSL *ssl);

int SSL_want(SSL *ssl);

int SSL_want_nothing(SSL *ssl);

int SSL_want_read(SSL *ssl);

int SSL_want_write(SSL *ssl);

int SSL_want_x509_lookup(s);

int SSL_write(SSL *ssl, char *buf, int num);