X-Git-Url: https://ruderich.org/simon/gitweb/?a=blobdiff_plain;f=src%2Fconnection.c;h=184ee5a4231a302ee520dfecb05b845cdde0e4bb;hb=7eba49d24d56288d83746f3f0ce383d7c0c36552;hp=08a72809a2f30c308f6e9e3fc4b7acd3575e48ad;hpb=34d5e8a98501f972dbfeb990cf0b96fdd77f0bac;p=tlsproxy%2Ftlsproxy.git diff --git a/src/connection.c b/src/connection.c index 08a7280..184ee5a 100644 --- a/src/connection.c +++ b/src/connection.c @@ -1,7 +1,7 @@ /* * Handle connections. * - * Copyright (C) 2011-2013 Simon Ruderich + * Copyright (C) 2011-2014 Simon Ruderich * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,10 +23,14 @@ #include #include +#include #include #include +#include #include +#include + /* Maximum length of a HTTP request line. Longer request lines are aborted * with an error. The standard doesn't specify a maximum line length but this @@ -37,7 +41,8 @@ /* Format string used to send HTTP/1.0 error responses to the client. * * %s is used 5 times, first is the error code, then additional headers, next - * two are the error code (no %n$s!), the last is the message. */ + * two are the error code (no %n$s which is not in C98!), the last is the + * message. */ #define HTTP_RESPONSE_FORMAT "HTTP/1.0 %s\r\n\ Content-Type: text/html; charset=US-ASCII\r\n\ %s\r\n\ @@ -58,10 +63,15 @@ static int initialize_tls_session_client(int peer_socket, static int initialize_tls_session_server(int peer_socket, gnutls_session_t *session, gnutls_certificate_credentials_t *x509_cred); +static int initialize_tls_session_both(unsigned int flags, + int peer_socket, + gnutls_session_t *session, + gnutls_certificate_credentials_t *x509_cred); static int fdopen_read_write(int socket, FILE **read_fd, FILE **write_fd); static int read_http_request(FILE *client_fd, char *request, size_t length); static void send_bad_request(FILE *client_fd); +static void send_authentication_required(FILE *client_fd); static void send_forwarding_failure(FILE *client_fd); static void tls_send_invalid_cert_message(gnutls_session_t session); @@ -78,6 +88,8 @@ static int connect_to_host(const char *hostname, const char *port); static int parse_request(const char *buffer, char *host, char *port, int *version_minor); +static void log_session_information(gnutls_session_t session); + void handle_connection(int client_socket) { int server_socket; @@ -104,7 +116,7 @@ void handle_connection(int client_socket) { * certificate. */ int validation_failed; - LOG(DEBUG, "new connection"); + LOG(DEBUG1, "new connection"); server_socket = -1; client_fd_read = NULL; @@ -131,27 +143,31 @@ void handle_connection(int client_socket) { LOG(WARNING, "read_http_request(): client EOF"); send_bad_request(client_fd_write); goto out; + } else if (result == -3) { + LOG(WARNING, "read_http_request(): proxy authentication failed"); + send_authentication_required(client_fd_write); + goto out; } if (parse_request(buffer, host, port, &version_minor) != 0) { - LOG(WARNING, "bad request: %s", buffer); + LOG(WARNING, "bad request: >%s<", buffer); send_bad_request(client_fd_write); goto out; } - LOG(DEBUG, "target: %s:%s (HTTP 1.%d)", host, port, version_minor); + LOG(DEBUG2, "target: %s:%s (HTTP 1.%d)", host, port, version_minor); /* Connect to proxy server or directly to server. */ if (global_proxy_host != NULL && global_proxy_port != NULL) { - LOG(DEBUG, "connecting to %s:%s", global_proxy_host, - global_proxy_port); + LOG(DEBUG1, "connecting to %s:%s", global_proxy_host, + global_proxy_port); server_socket = connect_to_host(global_proxy_host, global_proxy_port); } else { - LOG(DEBUG, "connecting to %s:%s", host, port); + LOG(DEBUG1, "connecting to %s:%s", host, port); server_socket = connect_to_host(host, port); } - if (server_socket == -1) { + if (server_socket < 0) { LOG(WARNING, "failed to connect to server"); send_forwarding_failure(client_fd_write); goto out; @@ -182,16 +198,16 @@ void handle_connection(int client_socket) { /* Check response of proxy server. */ if (strncmp(buffer, "HTTP/1.0 200", 12)) { - LOG(WARNING, "bad proxy response: %s", buffer); + LOG(WARNING, "bad proxy response: >%s<", buffer); send_forwarding_failure(client_fd_write); goto out; } } - LOG(DEBUG, "connection to server established"); + LOG(DEBUG1, "connection to server established"); /* If the -u option is used and we don't know this hostname's server - * certificate then just pass through the connection and let the client + * certificate, then just pass through the connection and let the client * verify the server certificate. */ if (global_passthrough_unknown) { char path[TLSPROXY_MAX_PATH_LENGTH]; @@ -203,13 +219,13 @@ void handle_connection(int client_socket) { fprintf(client_fd_write, "\r\n"); fflush(client_fd_write); - LOG(DEBUG, "transferring data"); + LOG(DEBUG1, "transferring data"); /* Proxy data between client and server until one side is done * (EOF or error). */ transfer_data(client_socket, server_socket); - LOG(DEBUG, "finished transferring data"); + LOG(DEBUG1, "finished transferring data"); goto out; } @@ -229,19 +245,23 @@ void handle_connection(int client_socket) { } server_session_init = 1; - LOG(DEBUG, "starting server TLS handshake"); + LOG(DEBUG1, "starting server TLS handshake"); /* Try to establish TLS handshake between us and server. */ result = gnutls_handshake(server_session); if (result != GNUTLS_E_SUCCESS) { LOG(WARNING, "server TLS handshake failed: %s", - gnutls_strerror(result)); + gnutls_strerror(result)); send_forwarding_failure(client_fd_write); goto out; } server_session_started = 1; - LOG(DEBUG, "server TLS handshake finished"); + LOG(DEBUG1, "server TLS handshake finished"); + + if (global_log_level >= LOG_DEBUG2_LEVEL) { + log_session_information(server_session); + } /* Make sure the server certificate is valid and known. */ if (verify_tls_connection(server_session, host) != 0) { @@ -272,19 +292,23 @@ void handle_connection(int client_socket) { fprintf(client_fd_write, "\r\n"); fflush(client_fd_write); - LOG(DEBUG, "starting client TLS handshake"); + LOG(DEBUG1, "starting client TLS handshake"); /* Try to establish TLS handshake between client and us. */ result = gnutls_handshake(client_session); if (result != GNUTLS_E_SUCCESS) { LOG(WARNING, "client TLS handshake failed: %s", - gnutls_strerror(result)); + gnutls_strerror(result)); send_forwarding_failure(client_fd_write); goto out; } client_session_started = 1; - LOG(DEBUG, "client TLS handshake finished"); + LOG(DEBUG1, "client TLS handshake finished"); + + if (global_log_level >= LOG_DEBUG2_LEVEL) { + log_session_information(client_session); + } /* Tell the client that the verification failed. Shouldn't be necessary as * the client should terminate the connection because he received the @@ -294,20 +318,29 @@ void handle_connection(int client_socket) { goto out; } - LOG(DEBUG, "transferring TLS data"); + LOG(DEBUG1, "transferring TLS data"); /* Proxy data between client and server until one side is done (EOF or * error). */ transfer_data_tls(client_socket, server_socket, client_session, server_session); - LOG(DEBUG, "finished transferring TLS data"); + LOG(DEBUG1, "finished transferring TLS data"); out: /* Close TLS sessions if necessary. Use GNUTLS_SHUT_RDWR so the data is * reliable transmitted. */ if (server_session_started) { - gnutls_bye(server_session, GNUTLS_SHUT_RDWR); + /* Recent gnutls-serv (used in the test-suite) won't terminate the + * connection when gnutls_bye(session, GNUTLS_SHUT_RDWR) is used + * before any other data was received. If the validation failed just + * close the connection without waiting for data, we won't read it + * anyway. + * + * For verified connections GNUTLS_SHUT_RDWR is important or we might + * lose data. */ + gnutls_bye(server_session, validation_failed ? GNUTLS_SHUT_WR + : GNUTLS_SHUT_RDWR); } if (client_session_started) { gnutls_bye(client_session, GNUTLS_SHUT_RDWR); @@ -318,8 +351,6 @@ out: } if (client_session_init) { gnutls_deinit(client_session); - gnutls_certificate_free_cas(client_x509_cred); - gnutls_certificate_free_keys(client_x509_cred); gnutls_certificate_free_credentials(client_x509_cred); } @@ -332,7 +363,7 @@ out: } else if (server_socket != -1) { close(server_socket); } - LOG(DEBUG, "connection to server closed"); + LOG(DEBUG1, "connection to server closed"); /* Close connection to client. */ if (client_fd_read != NULL) { if (client_fd_write != NULL) { @@ -342,9 +373,9 @@ out: } else { close(client_socket); } - LOG(DEBUG, "connection to client closed"); + LOG(DEBUG1, "connection to client closed"); - LOG(DEBUG, "connection finished"); + LOG(DEBUG1, "connection finished"); } @@ -362,16 +393,16 @@ static int initialize_tls_session_client(int peer_socket, if (proxy_certificate_path(hostname, path, sizeof(path)) != 0) { LOG(ERROR, - "initialize_tls_session_client(): \ -failed to get proxy certificate path"); + "initialize_tls_session_client(): " + "failed to get proxy certificate path"); return -1; } result = gnutls_certificate_allocate_credentials(x509_cred); if (result != GNUTLS_E_SUCCESS) { LOG(ERROR, - "initialize_tls_session_client(): \ -gnutls_certificate_allocate_credentials(): %s", + "initialize_tls_session_client(): " + "gnutls_certificate_allocate_credentials(): %s", gnutls_strerror(result)); return -1; } @@ -379,12 +410,17 @@ gnutls_certificate_allocate_credentials(): %s", /* Load proxy CA file, this CA "list" is send to the client. */ if (!use_invalid_cert) { result = gnutls_certificate_set_x509_trust_file(*x509_cred, - PROXY_CA_FILE, + PROXY_CA_PATH, GNUTLS_X509_FMT_PEM); if (result <= 0) { LOG(ERROR, "initialize_tls_session_client(): can't read CA file: '%s'", - PROXY_CA_FILE); + PROXY_CA_PATH); + gnutls_certificate_free_credentials(*x509_cred); + return -1; + } else if (result != 1) { + /* Must contain only one CA, our proxy CA. */ + LOG(ERROR, "initialize_tls_session_client(): multiple CAs found"); gnutls_certificate_free_credentials(*x509_cred); return -1; } @@ -395,21 +431,22 @@ gnutls_certificate_allocate_credentials(): %s", /* And certificate for this website and proxy's private key. */ if (!use_invalid_cert) { result = gnutls_certificate_set_x509_key_file(*x509_cred, - path, PROXY_KEY_FILE, + path, + PROXY_KEY_PATH, GNUTLS_X509_FMT_PEM); /* If the invalid hostname was specified load our special "invalid" * certificate. */ } else { result = gnutls_certificate_set_x509_key_file(*x509_cred, - PROXY_INVALID_CERT_FILE, - PROXY_KEY_FILE, + PROXY_INVALID_CERT_PATH, + PROXY_KEY_PATH, GNUTLS_X509_FMT_PEM); } if (result != GNUTLS_E_SUCCESS) { LOG(ERROR, - "initialize_tls_session_client(): \ -can't read server certificate ('%s') or key file ('%s'): %s", - path, PROXY_KEY_FILE, gnutls_strerror(result)); + "initialize_tls_session_client(): " + "can't read server certificate ('%s') or key file ('%s'): %s", + path, PROXY_KEY_PATH, gnutls_strerror(result)); gnutls_certificate_free_credentials(*x509_cred); /* Could be a missing certificate. */ return -2; @@ -417,37 +454,8 @@ can't read server certificate ('%s') or key file ('%s'): %s", gnutls_certificate_set_dh_params(*x509_cred, global_tls_dh_params); - result = gnutls_init(session, GNUTLS_SERVER); - if (result != GNUTLS_E_SUCCESS) { - LOG(ERROR, - "initialize_tls_session_client(): gnutls_init(): %s", - gnutls_strerror(result)); - gnutls_certificate_free_credentials(*x509_cred); - return -1; - } - result = gnutls_priority_set(*session, global_tls_priority_cache); - if (result != GNUTLS_E_SUCCESS) { - LOG(ERROR, - "initialize_tls_session_client(): gnutls_priority_set(): %s", - gnutls_strerror(result)); - gnutls_deinit(*session); - gnutls_certificate_free_credentials(*x509_cred); - return -1; - } - result = gnutls_credentials_set(*session, - GNUTLS_CRD_CERTIFICATE, *x509_cred); - if (result != GNUTLS_E_SUCCESS) { - LOG(ERROR, - "initialize_tls_session_client(): gnutls_credentials_set(): %s", - gnutls_strerror(result)); - gnutls_deinit(*session); - gnutls_certificate_free_credentials(*x509_cred); - return -1; - } - - gnutls_transport_set_ptr(*session, (gnutls_transport_ptr_t)peer_socket); - - return 0; + return initialize_tls_session_both(GNUTLS_SERVER, + peer_socket, session, x509_cred); } static int initialize_tls_session_server(int peer_socket, gnutls_session_t *session, @@ -457,43 +465,61 @@ static int initialize_tls_session_server(int peer_socket, result = gnutls_certificate_allocate_credentials(x509_cred); if (result != GNUTLS_E_SUCCESS) { LOG(ERROR, - "initialize_tls_session_server(): \ -gnutls_certificate_allocate_credentials(): %s", + "initialize_tls_session_server(): " + "gnutls_certificate_allocate_credentials(): %s", gnutls_strerror(result)); return -1; } - result = gnutls_init(session, GNUTLS_CLIENT); + return initialize_tls_session_both(GNUTLS_CLIENT, + peer_socket, session, x509_cred); +} +static int initialize_tls_session_both(unsigned int flags, + int peer_socket, + gnutls_session_t *session, + gnutls_certificate_credentials_t *x509_cred) { + int result; + + *session = NULL; + + result = gnutls_init(session, flags); if (result != GNUTLS_E_SUCCESS) { LOG(ERROR, - "initialize_tls_session_server(): gnutls_init(): %s", + "initialize_tls_session_both(): gnutls_init(): %s", gnutls_strerror(result)); - gnutls_certificate_free_credentials(*x509_cred); - return -1; + goto err; } result = gnutls_priority_set(*session, global_tls_priority_cache); if (result != GNUTLS_E_SUCCESS) { LOG(ERROR, - "initialize_tls_session_server(): gnutls_priority_set(): %s", + "initialize_tls_session_both(): gnutls_priority_set(): %s", gnutls_strerror(result)); - gnutls_deinit(*session); - gnutls_certificate_free_credentials(*x509_cred); - return -1; + goto err; } result = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE, *x509_cred); if (result != GNUTLS_E_SUCCESS) { LOG(ERROR, - "initialize_tls_session_server(): gnutls_credentials_set(): %s", + "initialize_tls_session_both(): gnutls_credentials_set(): %s", gnutls_strerror(result)); - gnutls_deinit(*session); - gnutls_certificate_free_credentials(*x509_cred); - return -1; + goto err; } +#ifdef HAVE_GNUTLS_TRANSPORT_SET_INT2 + /* gnutls_transport_set_int() is a macro. */ + gnutls_transport_set_int(*session, peer_socket); +#else gnutls_transport_set_ptr(*session, (gnutls_transport_ptr_t)peer_socket); +#endif return 0; + +err: + if (*session) { + gnutls_deinit(*session); + } + gnutls_certificate_free_credentials(*x509_cred); + return -1; } @@ -521,7 +547,9 @@ static int fdopen_read_write(int socket, FILE **read_fd, FILE **write_fd) { */ static int read_http_request(FILE *client_fd, char *request, size_t length) { char buffer[MAX_REQUEST_LINE]; + int found_proxy_authorization; + assert(length <= INT_MAX); if (fgets(request, (int)length, client_fd) == NULL) { if (ferror(client_fd)) { LOG_PERROR(WARNING, "read_http_request(): fgets()"); @@ -531,7 +559,22 @@ static int read_http_request(FILE *client_fd, char *request, size_t length) { return -2; } + found_proxy_authorization = 0; while (fgets(buffer, sizeof(buffer), client_fd) != NULL) { + const char *authentication = "Proxy-Authorization: Basic "; + + if (global_http_digest_authorization != NULL + && !strncmp(buffer, authentication, strlen(authentication))) { + found_proxy_authorization = 1; + + /* Check if the passphrase matches. */ + strtok(buffer, "\r\n"); + if (strcmp(buffer + strlen(authentication), + global_http_digest_authorization)) { + return -3; + } + } + /* End of header. */ if (!strcmp(buffer, "\n") || !strcmp(buffer, "\r\n")) { break; @@ -540,6 +583,12 @@ static int read_http_request(FILE *client_fd, char *request, size_t length) { if (ferror(client_fd)) { LOG_PERROR(WARNING, "read_http_request(): fgets()"); return -1; + } else if (feof(client_fd)) { + return -2; + } + + if (global_http_digest_authorization != NULL && !found_proxy_authorization) { + return -3; } return 0; @@ -551,6 +600,13 @@ static void send_bad_request(FILE *client_fd) { fprintf(client_fd, HTTP_RESPONSE_FORMAT, error, "", error, error, msg); fflush(client_fd); } +static void send_authentication_required(FILE *client_fd) { + const char error[] = "407 Proxy Authentication Required"; + const char auth[] = "Proxy-Authenticate: Basic realm=\"tlsproxy\"\r\n"; + const char msg[] = "TODO"; + fprintf(client_fd, HTTP_RESPONSE_FORMAT, error, auth, error, error, msg); + fflush(client_fd); +} static void send_forwarding_failure(FILE *client_fd) { const char error[] = "503 Forwarding failure"; const char msg[] = "Failed to connect to server, check logs."; @@ -562,6 +618,7 @@ static void tls_send_invalid_cert_message(gnutls_session_t session) { const char msg[] = "Server certificate validation failed, check logs."; int result; + ssize_t size_written; char buffer[sizeof(HTTP_RESPONSE_FORMAT) + 3 * sizeof(error) + sizeof(msg)]; @@ -569,7 +626,13 @@ static void tls_send_invalid_cert_message(gnutls_session_t session) { error, "", error, error, msg); assert(result > 0 && (size_t)result < sizeof(buffer)); - gnutls_record_send(session, buffer, strlen(buffer)); + size_written = gnutls_record_send(session, buffer, strlen(buffer)); + if (size_written < 0) { + LOG(WARNING, "tls_send_invalid_cert_message(): " + "gnutls_record_send(): %s", + gnutls_strerror((int)size_written)); + } + /* Just an error message, no need to check if everything was written. */ } @@ -584,6 +647,8 @@ static void transfer_data(int client, int server) { fds[1].events = POLLIN | POLLPRI | POLLHUP | POLLERR; fds[1].revents = 0; + LOG(DEBUG2, "transfer_data(): %d -> %d", client, server); + for (;;) { int result = poll(fds, 2 /* fd count */, -1 /* no timeout */); if (result < 0) { @@ -624,8 +689,6 @@ static int read_from_write_to(int from, int to) { ssize_t size_written; char buffer[4096]; - LOG(DEBUG, "read_from_write_to(): %d -> %d", from, to); - size_read = read(from, buffer, sizeof(buffer)); if (size_read < 0) { LOG_PERROR(WARNING, "read_from_write_to(): read()"); @@ -641,8 +704,8 @@ static int read_from_write_to(int from, int to) { return -1; } if (size_read != size_written) { - LOG(ERROR, "read_from_write_to(): only written %ld of %ld bytes!", - (long int)size_written, (long int)size_read); + LOG(ERROR, "read_from_write_to(): only written %zu of %zu bytes!", + size_written, size_read); return -1; } @@ -669,8 +732,8 @@ static void transfer_data_tls(int client, int server, if (gnutls_record_get_max_size(server_session) < buffer_size) { buffer_size = gnutls_record_get_max_size(server_session); } - LOG(DEBUG, "transfer_data_tls(): suggested buffer size: %ld", - (long int)buffer_size); + LOG(DEBUG2, "transfer_data_tls(): suggested buffer size: %zu", + buffer_size); for (;;) { int result = poll(fds, 2 /* fd count */, -1 /* no timeout */); @@ -713,18 +776,34 @@ static int read_from_write_to_tls(gnutls_session_t from, size_t buffer_size) { ssize_t size_read; ssize_t size_written; - char buffer[16384]; + char buffer[16384]; /* GnuTLS default maximum */ if (buffer_size > sizeof(buffer)) { + LOG(WARNING, "read_from_write_to_tls(): reduced buffer size to %zu", + sizeof(buffer)); buffer_size = sizeof(buffer); } - LOG(DEBUG, "read_from_write_to_tls(): used buffer size: %ld", - (long int)buffer_size); size_read = gnutls_record_recv(from, buffer, buffer_size); if (size_read < 0) { + /* Allow rehandshakes. As handshakes might be insecure make sure that + * %SAFE_RENEGOTIATION is used in GnuTLS's priority string. */ + if (size_read == GNUTLS_E_REHANDSHAKE) { + int result; + + LOG(DEBUG1, "server requested TLS rehandshake"); + + result = gnutls_handshake(from); + if (result != GNUTLS_E_SUCCESS) { + LOG(WARNING, "server TLS rehandshake failed: %s", + gnutls_strerror(result)); + return -1; + } + return 0; + } + LOG(WARNING, "read_from_write_to_tls(): gnutls_record_recv(): %s", - gnutls_strerror((int)size_read)); + gnutls_strerror((int)size_read)); return -1; /* EOF */ } else if (size_read == 0) { @@ -734,12 +813,12 @@ static int read_from_write_to_tls(gnutls_session_t from, size_written = gnutls_record_send(to, buffer, (size_t)size_read); if (size_written < 0) { LOG(WARNING, "read_from_write_to_tls(): gnutls_record_send(): %s", - gnutls_strerror((int)size_written)); + gnutls_strerror((int)size_written)); return -1; } if (size_read != size_written) { - LOG(ERROR, "read_from_write_to_tls(): only written %ld of %ld bytes!", - (long int)size_written, (long int)size_read); + LOG(ERROR, "read_from_write_to_tls(): only written %zu of %zu bytes!", + size_written, size_read); return -1; } @@ -765,15 +844,17 @@ static int connect_to_host(const char *hostname, const char *port) { gai_hints.ai_socktype = SOCK_STREAM; gai_hints.ai_protocol = 0; gai_hints.ai_flags = AI_NUMERICSERV /* given port is numeric */ +#ifdef AI_ADDRCONFIG | AI_ADDRCONFIG /* supported by this computer */ - | AI_V4MAPPED; /* support IPv4 through IPv6 */ +#endif + ; gai_return = getaddrinfo(hostname, port, &gai_hints, &gai_result); if (gai_return != 0) { if (gai_return == EAI_SYSTEM) { LOG_PERROR(WARNING, "connect_to_host(): getaddrinfo()"); } else { LOG(WARNING, "connect_to_host(): getaddrinfo(): %s", - gai_strerror(gai_return)); + gai_strerror(gai_return)); } return -1; } @@ -784,15 +865,15 @@ static int connect_to_host(const char *hostname, const char *port) { server_socket = socket(server->ai_family, server->ai_socktype, server->ai_protocol); - if (server_socket == -1) { - LOG_PERROR(DEBUG, "connect_to_host(): socket(), trying next"); + if (server_socket < 0) { + LOG_PERROR(DEBUG1, "connect_to_host(): socket(), trying next"); continue; } - if (connect(server_socket, server->ai_addr, server->ai_addrlen) != -1) { + if (connect(server_socket, server->ai_addr, server->ai_addrlen) == 0) { break; } - LOG_PERROR(DEBUG, "connect_to_host(): connect(), trying next"); + LOG_PERROR(DEBUG1, "connect_to_host(): connect(), trying next"); close(server_socket); } @@ -844,3 +925,72 @@ static int parse_request(const char *request, char *host, char *port, return 0; } + + +static void log_session_information(gnutls_session_t session) { + /* From doc/examples/ex-session-info.c of GnuTLS 3.2.3's tarball and + * modified, thanks. */ + + const char *tmp; + gnutls_credentials_type_t cred; + gnutls_kx_algorithm_t kx; + int dhe, ecdh; + + dhe = 0; + ecdh = 0; + + /* Key exchange algorithm. */ + kx = gnutls_kx_get(session); + LOG(DEBUG2, "- key exchange: %s", gnutls_kx_get_name(kx)); + + /* Authentication type. */ + cred = gnutls_auth_get_type(session); + switch (cred) { + case GNUTLS_CRD_CERTIFICATE: + if (kx == GNUTLS_KX_DHE_RSA + || kx == GNUTLS_KX_DHE_DSS) { + dhe = 1; +#ifdef GNUTLS_KX_ECDHE_RSA + } else if (kx == GNUTLS_KX_ECDHE_RSA + || kx == GNUTLS_KX_ECDHE_ECDSA) { + ecdh = 1; +#endif + } + break; + + case GNUTLS_CRD_IA: + case GNUTLS_CRD_SRP: + case GNUTLS_CRD_PSK: + case GNUTLS_CRD_ANON: + default: + /* This shouldn't occur. */ + LOG(WARNING, "unexpected authentication method: %d", cred); + break; + } + + /* Information about key exchange. */ + if (dhe) { + LOG(DEBUG2, "- ephemeral DH using prime of %d bits", + gnutls_dh_get_prime_bits(session)); + } else if (ecdh) { +#ifdef GNUTLS_KX_ECDHE_RSA + LOG(DEBUG2, "- ephemeral ECDH using curve %s", + gnutls_ecc_curve_get_name(gnutls_ecc_curve_get(session))); +#endif + } + + tmp = gnutls_protocol_get_name(gnutls_protocol_get_version(session)); + LOG(DEBUG2, "- protocol: %s", tmp); /* e.g. TLS 1.0 */ + + tmp = gnutls_certificate_type_get_name(gnutls_certificate_type_get(session)); + LOG(DEBUG2, "- certificate type: %s", tmp); + + tmp = gnutls_compression_get_name(gnutls_compression_get(session)); + LOG(DEBUG2, "- compression: %s", tmp); + + tmp = gnutls_cipher_get_name(gnutls_cipher_get(session)); + LOG(DEBUG2, "- cipher: %s", tmp); + + tmp = gnutls_mac_get_name(gnutls_mac_get(session)); + LOG(DEBUG2, "- MAC: %s", tmp); +}