if (last)
printf ("- received %d bytes AVP: `%.*s'\n",
- (int)lastlen, (int) lastlen, last);
+ (int) lastlen, (int) lastlen, last);
else
printf ("- new application phase\n");
return -1;
*newlen = strlen (*new);
- printf ("- sending %d bytes AVP: `%s'\n", (int)*newlen, *new);
+ printf ("- sending %d bytes AVP: `%s'\n", (int) *newlen, *new);
gnutls_ia_permute_inner_secret (session, 3, "foo");
if (output & GNUTLS_CERT_SIGNER_NOT_CA)
fprintf (stderr, ": issuer is not a CA");
if (output & GNUTLS_CERT_NOT_ACTIVATED)
- fprintf (stderr, ": not yet activated\n");
+ fprintf (stderr, ": not yet activated\n");
if (output & GNUTLS_CERT_EXPIRED)
- fprintf (stderr, ": expired\n");
+ fprintf (stderr, ": expired\n");
fprintf (stderr, "\n");
}
if (output & GNUTLS_CERT_SIGNER_NOT_CA)
fprintf (stderr, ": Issuer is not a CA\n");
if (output & GNUTLS_CERT_NOT_ACTIVATED)
- fprintf (stderr, ": Not yet activated\n");
+ fprintf (stderr, ": Not yet activated\n");
if (output & GNUTLS_CERT_EXPIRED)
- fprintf (stderr, ": Expired\n");
+ fprintf (stderr, ": Expired\n");
fprintf (stderr, "\n");
}
else
printf ("Certificate info:\n");
/* This is the preferred way of printing short information about
- a certificate. */
+ a certificate. */
ret = gnutls_x509_crt_print (cert, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
if (ret == 0)
}
/* If you want to extract fields manually for some other reason,
- below are popular example calls. */
+ below are popular example calls. */
expiration_time = gnutls_x509_crt_get_expiration_time (cert);
activation_time = gnutls_x509_crt_get_activation_time (cert);
gnutls_assert ();
goto cleanup;
}
-
+
ret = 0;
cleanup:
_gnutls_proc_cert_server_certificate (gnutls_session_t session,
opaque * data, size_t data_size)
{
-int ret;
-gnutls_certificate_credentials_t cred;
+ int ret;
+ gnutls_certificate_credentials_t cred;
- cred = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL);
- if (cred == NULL)
- {
- gnutls_assert();
- return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
- }
+ cred =
+ (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
+ GNUTLS_CRD_CERTIFICATE,
+ NULL);
+ if (cred == NULL)
+ {
+ gnutls_assert ();
+ return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
+ }
switch (session->security_parameters.cert_type)
{
#ifdef ENABLE_OPENPGP
case GNUTLS_CRT_OPENPGP:
ret = _gnutls_proc_openpgp_server_certificate (session,
- data, data_size);
+ data, data_size);
break;
#endif
case GNUTLS_CRT_X509:
if (ret == 0 && cred->verify_callback != NULL)
{
ret = cred->verify_callback (session);
- if (ret != 0) ret = GNUTLS_E_CERTIFICATE_ERROR;
+ if (ret != 0)
+ ret = GNUTLS_E_CERTIFICATE_ERROR;
}
return ret;
}
bits =
- _gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
- params[0]);
+ _gnutls_mpi_get_nbits (session->internals.
+ selected_cert_list[0].params[0]);
if (_gnutls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)
for (i = 0; i < len; i++)
{
data[i + 1] =
- _gnutls_cert_type2num (session->internals.
- priorities.cert_type.priority[i]);
+ _gnutls_cert_type2num (session->internals.priorities.
+ cert_type.priority[i]);
}
return len + 1;
}
}
data[0] =
- (uint8_t) _gnutls_mre_record2num (session->internals.
- proposed_record_size);
+ (uint8_t) _gnutls_mre_record2num (session->
+ internals.proposed_record_size);
return len;
}
}
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
- _gnutls_write_uint16 (session->security_parameters.
- extensions.oprfi_server_len, p);
+ _gnutls_write_uint16 (session->security_parameters.extensions.
+ oprfi_server_len, p);
p += 2;
DECR_LENGTH_RET (data_size,
int
_gnutls_safe_renegotiation_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const opaque * data,
+ size_t _data_size)
{
tls_ext_st *ext = &session->security_parameters.extensions;
int len = data[0];
ssize_t data_size = _data_size;
- DECR_LEN (data_size, len+1 /* count the first byte and payload */);
+ DECR_LEN (data_size, len + 1 /* count the first byte and payload */ );
/* It is not legal to receive this extension on a renegotiation and
* not receive it on the initial negotiation.
if (session->internals.initial_negotiation_completed != 0 &&
session->internals.connection_using_safe_renegotiation == 0)
{
- gnutls_assert();
+ gnutls_assert ();
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
if (len > sizeof (ext->ri_extension_data))
{
- gnutls_assert();
+ gnutls_assert ();
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
if (session->internals.priorities.disable_safe_renegotiation != 0)
{
- gnutls_assert();
+ gnutls_assert ();
return 0;
}
DECR_LEN (data_size, ext->client_verify_data_len);
if (ext->client_verify_data_len > 0)
- memcpy(&data[1], ext->client_verify_data,
- ext->client_verify_data_len);
+ memcpy (&data[1], ext->client_verify_data,
+ ext->client_verify_data_len);
if (session->security_parameters.entity == GNUTLS_SERVER)
{
DECR_LEN (data_size, ext->server_verify_data_len);
if (ext->server_verify_data_len > 0)
- memcpy(&data[1 + ext->client_verify_data_len],
- ext->server_verify_data,
- ext->server_verify_data_len);
+ memcpy (&data[1 + ext->client_verify_data_len],
+ ext->server_verify_data, ext->server_verify_data_len);
}
}
else
return 0;
- return 1 + data[0]; /* don't forget the length byte */
+ return 1 + data[0]; /* don't forget the length byte */
}
/**
void
gnutls_safe_renegotiation_set (gnutls_session_t session, int value)
{
- session->internals.priorities.unsafe_renegotiation = 1-value;
+ session->internals.priorities.unsafe_renegotiation = 1 - value;
}
/**
case 0: /* NAME_DNS */
if (len <= MAX_SERVER_NAME_SIZE)
{
- memcpy (session->security_parameters.extensions.
- server_names[i].name, p, len);
- session->security_parameters.extensions.
- server_names[i].name_length = len;
- session->security_parameters.extensions.
- server_names[i].type = GNUTLS_NAME_DNS;
+ memcpy (session->security_parameters.
+ extensions.server_names[i].name, p, len);
+ session->security_parameters.extensions.server_names[i].
+ name_length = len;
+ session->security_parameters.extensions.server_names[i].
+ type = GNUTLS_NAME_DNS;
break;
}
}
/* count the total size
*/
len =
- session->security_parameters.extensions.server_names[i].
- name_length;
+ session->security_parameters.extensions.
+ server_names[i].name_length;
/* uint8_t + uint16_t + size
*/
i < session->security_parameters.extensions.server_names_size; i++)
{
- switch (session->security_parameters.extensions.
- server_names[i].type)
+ switch (session->security_parameters.extensions.server_names[i].
+ type)
{
case GNUTLS_NAME_DNS:
len =
- session->security_parameters.extensions.
- server_names[i].name_length;
+ session->security_parameters.extensions.server_names[i].
+ name_length;
if (len == 0)
break;
p += 2;
memcpy (p,
- session->security_parameters.extensions.
- server_names[i].name, len);
+ session->security_parameters.extensions.server_names[i].
+ name, len);
p += len;
break;
default:
session->security_parameters.extensions.server_names[indx].name_length)
{
*data_length =
- session->security_parameters.extensions.server_names[indx].
- name_length;
+ session->security_parameters.extensions.
+ server_names[indx].name_length;
memcpy (data,
session->security_parameters.extensions.server_names[indx].name,
*data_length);
else
{
*data_length =
- session->security_parameters.extensions.server_names[indx].
- name_length;
+ session->security_parameters.extensions.
+ server_names[indx].name_length;
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
session->security_parameters.extensions.server_names
[server_names - 1].type = type;
- memcpy (session->security_parameters.extensions.
- server_names[server_names - 1].name, name, name_length);
+ memcpy (session->security_parameters.
+ extensions.server_names[server_names - 1].name, name, name_length);
session->security_parameters.extensions.server_names[server_names -
1].name_length =
name_length;
int ret;
/* Check the integrity of ticket using HMAC-SHA-256. */
- mac_secret.data = (void*)
+ mac_secret.data = (void *)
session->internals.session_ticket_key->mac_secret;
mac_secret.size = MAC_SECRET_SIZE;
ret = digest_ticket (&mac_secret, ticket, final);
}
/* Decrypt encrypted_state using 128-bit AES in CBC mode. */
- key.data = (void*)session->internals.session_ticket_key->key;
+ key.data = (void *) session->internals.session_ticket_key->key;
key.size = KEY_SIZE;
IV.data = ticket->IV;
IV.size = IV_SIZE;
_gnutls_free_datum (&state);
/* Encrypt state using 128-bit AES in CBC mode. */
- key.data = (void*)session->internals.session_ticket_key->key;
+ key.data = (void *) session->internals.session_ticket_key->key;
key.size = KEY_SIZE;
IV.data = session->internals.session_ticket_IV;
IV.size = IV_SIZE;
/* Fill the ticket structure to compute MAC. */
memcpy (ticket->key_name,
- session->internals.session_ticket_key->key_name, KEY_NAME_SIZE);
+ session->internals.session_ticket_key->key_name, KEY_NAME_SIZE);
memcpy (ticket->IV, IV.data, IV.size);
ticket->encrypted_state_len = encrypted_state.size;
ticket->encrypted_state = encrypted_state.data;
mac_secret.data =
- (void*)session->internals.session_ticket_key->mac_secret;
+ (void *) session->internals.session_ticket_key->mac_secret;
mac_secret.size = MAC_SECRET_SIZE;
ret = digest_ticket (&mac_secret, ticket, ticket->mac);
if (ret < 0)
/* If the key name of the ticket does not match the one that we
hold, issue a new ticket. */
if (memcmp (ticket.key_name,
- session->internals.session_ticket_key->key_name, KEY_NAME_SIZE))
+ session->internals.session_ticket_key->key_name,
+ KEY_NAME_SIZE))
{
session->internals.session_ticket_renew = 1;
return 0;
}
else
{
- if (session->internals.resumed_security_parameters.extensions.
- session_ticket_len > 0)
+ if (session->internals.resumed_security_parameters.
+ extensions.session_ticket_len > 0)
{
DECR_LENGTH_RET (data_size,
- session->internals.resumed_security_parameters.
- extensions.session_ticket_len,
- GNUTLS_E_SHORT_MEMORY_BUFFER);
+ session->internals.
+ resumed_security_parameters.extensions.
+ session_ticket_len, GNUTLS_E_SHORT_MEMORY_BUFFER);
memcpy (data,
- session->internals.resumed_security_parameters.extensions.
- session_ticket,
- session->internals.resumed_security_parameters.extensions.
- session_ticket_len);
+ session->internals.resumed_security_parameters.
+ extensions.session_ticket,
+ session->internals.resumed_security_parameters.
+ extensions.session_ticket_len);
- return session->internals.resumed_security_parameters.
- extensions.session_ticket_len;
+ return session->internals.resumed_security_parameters.extensions.
+ session_ticket_len;
}
else
{
}
ret = _gnutls_rnd (GNUTLS_RND_RANDOM,
- session->internals.
- session_ticket_IV, IV_SIZE);
+ session->internals.session_ticket_IV, IV_SIZE);
if (ret < 0)
{
gnutls_assert ();
SAVE_WRITE_SECURITY_PARAMETERS;
ret = _gnutls_set_write_cipher (session,
_gnutls_cipher_suite_get_cipher_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (ret < 0)
return ret;
ret = _gnutls_set_write_mac (session,
_gnutls_cipher_suite_get_mac_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (ret < 0)
return ret;
ret = _gnutls_set_write_compression (session,
- session->internals.
- compression_method);
+ session->
+ internals.compression_method);
if (ret < 0)
return ret;
/* Discard the current session ID. (RFC5077 3.4) */
ret = _gnutls_generate_session_id (session->security_parameters.session_id,
- &session->security_parameters.
- session_id_size);
+ &session->
+ security_parameters.session_id_size);
if (ret < 0)
{
gnutls_assert ();
for (i = j = 0; i < len; i += 2, j++)
{
aid =
- _gnutls_sign_to_tls_aid (session->internals.priorities.sign_algo.
- priority[j]);
+ _gnutls_sign_to_tls_aid (session->internals.priorities.
+ sign_algo.priority[j]);
*p = aid.hash_algorithm;
p++;
*p = aid.sign_algorithm;
sig = _gnutls_tls_aid_to_sign (&aid);
if (sig != GNUTLS_SIGN_UNKNOWN)
{
- session->security_parameters.extensions.
- sign_algorithms[session->security_parameters.extensions.
- sign_algorithms_size++] = sig;
+ session->security_parameters.extensions.sign_algorithms[session->
+ security_parameters.
+ extensions.sign_algorithms_size++]
+ = sig;
if (session->security_parameters.extensions.sign_algorithms_size ==
MAX_SIGNATURE_ALGORITHMS)
break;
(session->security_parameters.extensions.sign_algorithms[i]) == pk)
{
*hash =
- _gnutls_sign_get_hash_algorithm (session->
- security_parameters.extensions.
- sign_algorithms[i]);
+ _gnutls_sign_get_hash_algorithm (session->security_parameters.
+ extensions.sign_algorithms[i]);
return session->security_parameters.extensions.sign_algorithms[i];
}
}
gnutls_kx_algorithm_t kx_algorithm;
gnutls_mac_algorithm_t mac_algorithm;
gnutls_protocol_t min_version; /* this cipher suite is supported
- * from 'version' and above;
- */
- gnutls_protocol_t max_version;/* this cipher suite is not supported after that */
+ * from 'version' and above;
+ */
+ gnutls_protocol_t max_version; /* this cipher suite is not supported after that */
} gnutls_cipher_suite_entry;
/* RSA with NULL cipher and MD5 MAC
GNUTLS_SSL3, GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
#ifdef ENABLE_CAMELLIA
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_CAMELLIA_128_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_128_CBC,
GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_CAMELLIA_256_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_256_CBC,
GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
#endif
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_128_CBC_SHA256,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_256_CBC_SHA256,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_ANON_DH,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
/* PSK */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_PSK_SHA_ARCFOUR_SHA1,
GNUTLS_CIPHER_ARCFOUR, GNUTLS_KX_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_PSK_SHA_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_PSK_SHA_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_PSK_SHA_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
/* DHE-PSK */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_PSK_SHA_ARCFOUR_SHA1,
GNUTLS_CIPHER_ARCFOUR, GNUTLS_KX_DHE_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_PSK_SHA_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_PSK_SHA_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_PSK_SHA_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_PSK,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
/* SRP */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_SRP,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_SRP,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_SRP,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_SRP_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_SRP_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_SRP_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_SRP_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_SRP_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_SRP_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
/* DHE_DSS */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_ARCFOUR_SHA1,
GNUTLS_CIPHER_ARCFOUR_128, GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
#ifdef ENABLE_CAMELLIA
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_CAMELLIA_128_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_128_CBC,
GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_CAMELLIA_256_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_256_CBC,
GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
#endif
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_128_CBC_SHA256,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_256_CBC_SHA256,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_DSS,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
/* DHE_RSA */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
#ifdef ENABLE_CAMELLIA
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_CAMELLIA_128_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_128_CBC,
GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_CAMELLIA_256_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_256_CBC,
GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
#endif
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_128_CBC_SHA256,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_256_CBC_SHA256,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_RSA,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
/* RSA */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_NULL_MD5,
GNUTLS_CIPHER_NULL,
- GNUTLS_KX_RSA, GNUTLS_MAC_MD5, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_KX_RSA, GNUTLS_MAC_MD5, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_EXPORT_ARCFOUR_40_MD5,
GNUTLS_CIPHER_ARCFOUR_40,
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_ARCFOUR_SHA1,
GNUTLS_CIPHER_ARCFOUR_128,
- GNUTLS_KX_RSA, GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_KX_RSA, GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_ARCFOUR_MD5,
GNUTLS_CIPHER_ARCFOUR_128,
- GNUTLS_KX_RSA, GNUTLS_MAC_MD5, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_KX_RSA, GNUTLS_MAC_MD5, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_3DES_EDE_CBC_SHA1,
GNUTLS_CIPHER_3DES_CBC,
- GNUTLS_KX_RSA, GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_KX_RSA, GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_128_CBC_SHA1,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_256_CBC_SHA1,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
#ifdef ENABLE_CAMELLIA
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_CAMELLIA_128_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_128_CBC, GNUTLS_KX_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_CAMELLIA_256_CBC_SHA1,
GNUTLS_CIPHER_CAMELLIA_256_CBC, GNUTLS_KX_RSA,
- GNUTLS_MAC_SHA1, GNUTLS_TLS1, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA1, GNUTLS_TLS1,
+ GNUTLS_VERSION_MAX),
#endif
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_128_CBC_SHA256,
GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_RSA,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_256_CBC_SHA256,
GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_RSA,
- GNUTLS_MAC_SHA256, GNUTLS_TLS1_2, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_SHA256, GNUTLS_TLS1_2,
+ GNUTLS_VERSION_MAX),
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RENEGO_PROTECTION_REQUEST,
GNUTLS_CIPHER_UNKNOWN, GNUTLS_KX_UNKNOWN,
- GNUTLS_MAC_UNKNOWN, GNUTLS_SSL3, GNUTLS_VERSION_MAX),
+ GNUTLS_MAC_UNKNOWN, GNUTLS_SSL3,
+ GNUTLS_VERSION_MAX),
{0, {{0, 0}}, 0, 0, 0, 0, 0}
};
for (i = 0; i < session->internals.priorities.protocol.algorithms; i++)
{
if (session->internals.priorities.protocol.priority[i] < min)
- min = session->internals.priorities.protocol.priority[i];
+ min = session->internals.priorities.protocol.priority[i];
}
if (min == 0xff)
for (i = 0; i < session->internals.priorities.protocol.algorithms; i++)
{
if (session->internals.priorities.protocol.priority[i] > max)
- max = session->internals.priorities.protocol.priority[i];
+ max = session->internals.priorities.protocol.priority[i];
}
if (max == 0x00)
}
gnutls_protocol_t
-_gnutls_cipher_suite_is_version_supported (const cipher_suite_st * suite, gnutls_protocol_t version)
+_gnutls_cipher_suite_is_version_supported (const cipher_suite_st * suite,
+ gnutls_protocol_t version)
{
int ret = 0;
- GNUTLS_CIPHER_SUITE_ALG_LOOP ( (version >= p->min_version && version <= p->max_version)?(ret=1):(ret=0));
+ GNUTLS_CIPHER_SUITE_ALG_LOOP ((version >= p->min_version
+ && version <= p->max_version) ? (ret =
+ 1) : (ret =
+ 0));
return ret;
}
/* remove cipher suites which do not support the
* protocol version used.
*/
- if (_gnutls_cipher_suite_is_version_supported (&tmp_ciphers[i], version) == 0)
+ if (_gnutls_cipher_suite_is_version_supported (&tmp_ciphers[i], version)
+ == 0)
continue;
if (_gnutls_kx_priority
return
_gnutls_map_kx_get_cred (_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite), server);
+ (&session->
+ security_parameters.current_cipher_suite),
+ server);
}
/**
{
return
_gnutls_map_kx_get_cred (_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite), 1);
+ (&session->
+ security_parameters.current_cipher_suite), 1);
}
/**
{
return
_gnutls_map_kx_get_cred (_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite), 0);
+ (&session->
+ security_parameters.current_cipher_suite), 0);
}
/* checking is handled above */
_gnutls_buffer_get_datum (&session->internals.handshake_send_buffer,
&bdata,
- session->internals.
- handshake_send_buffer.length);
+ session->internals.handshake_send_buffer.
+ length);
ptr = bdata.data;
n = bdata.size;
gnutls_assert ();
retval =
- _gnutls_buffer_append (&session->internals.
- handshake_send_buffer, &ptr[n - left],
- left);
+ _gnutls_buffer_append (&session->
+ internals.handshake_send_buffer,
+ &ptr[n - left], left);
if (retval < 0)
{
gnutls_assert ();
{
gnutls_assert ();
- _gnutls_buffer_append (&session->
- internals.handshake_recv_buffer, iptr,
- dsize);
+ _gnutls_buffer_append (&session->internals.
+ handshake_recv_buffer, iptr, dsize);
session->internals.handshake_recv_buffer_htype = htype;
session->internals.handshake_recv_buffer_type = type;
* Since: 2.10.0
**/
void
-gnutls_certificate_set_verify_function
-(gnutls_certificate_credentials_t cred,
- gnutls_certificate_verify_function * func)
+ gnutls_certificate_set_verify_function
+ (gnutls_certificate_credentials_t cred,
+ gnutls_certificate_verify_function * func)
{
cred->verify_callback = func;
}
case GNUTLS_CRT_OPENPGP:
return _gnutls_openpgp_raw_crt_to_gcert (gcert,
&info->raw_certificate_list[0],
- info->
- use_subkey ? info->subkey_id :
- NULL);
+ info->use_subkey ? info->
+ subkey_id : NULL);
#endif
default:
gnutls_assert ();
}
static inline void
-mac_hash (digest_hd_st * td, void * data, int data_size, int ver)
+mac_hash (digest_hd_st * td, void *data, int data_size, int ver)
{
if (ver == GNUTLS_SSL3)
{ /* SSL 3.0 */
}
#define PREAMBLE_SIZE 16
-static inline int make_preamble(opaque* uint64_data, opaque type, uint16_t c_length, opaque ver, opaque* preamble)
+static inline int
+make_preamble (opaque * uint64_data, opaque type, uint16_t c_length,
+ opaque ver, opaque * preamble)
{
opaque minor = _gnutls_version_get_minor (ver);
opaque major = _gnutls_version_get_major (ver);
opaque *p = preamble;
-
- memcpy(p, uint64_data, 8);
- p+=8;
- *p=type; p++;
+
+ memcpy (p, uint64_data, 8);
+ p += 8;
+ *p = type;
+ p++;
if (_gnutls_version_has_variable_padding (ver))
- { /* TLS 1.0 or higher */
- *p = major; p++;
- *p = minor; p++;
+ { /* TLS 1.0 or higher */
+ *p = major;
+ p++;
+ *p = minor;
+ p++;
}
- memcpy(p, &c_length, 2);
- p+=2;
- return p-preamble;
+ memcpy (p, &c_length, 2);
+ p += 2;
+ return p - preamble;
}
/* This is the actual encryption
opaque preamble[PREAMBLE_SIZE];
int preamble_size;
int hash_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
- write_mac_algorithm);
+ _gnutls_hash_get_algo_len (session->
+ security_parameters.write_mac_algorithm);
int blocksize =
- gnutls_cipher_get_block_size (session->security_parameters.
- write_bulk_cipher_algorithm);
+ gnutls_cipher_get_block_size (session->
+ security_parameters.write_bulk_cipher_algorithm);
cipher_type_t block_algo =
- _gnutls_cipher_is_block (session->security_parameters.
- write_bulk_cipher_algorithm);
+ _gnutls_cipher_is_block (session->
+ security_parameters.write_bulk_cipher_algorithm);
opaque *data_ptr;
int ver = gnutls_protocol_get_version (session);
digest_hd_st td;
ret = mac_init (&td, session->security_parameters.write_mac_algorithm,
- session->connection_state.write_mac_secret.data,
- session->connection_state.write_mac_secret.size, ver);
+ session->connection_state.write_mac_secret.data,
+ session->connection_state.write_mac_secret.size, ver);
if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
- preamble_size = make_preamble( UINT64DATA (session->connection_state.write_sequence_number), type, c_length, ver, preamble);
+ {
+ gnutls_assert ();
+ return ret;
+ }
+ preamble_size =
+ make_preamble (UINT64DATA
+ (session->connection_state.write_sequence_number),
+ type, c_length, ver, preamble);
mac_hash (&td, preamble, preamble_size, ver);
mac_hash (&td, compressed.data, compressed.size, ver);
mac_deinit (&td, MAC, ver);
int preamble_size;
int ver = gnutls_protocol_get_version (session);
int hash_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
- read_mac_algorithm);
+ _gnutls_hash_get_algo_len (session->
+ security_parameters.read_mac_algorithm);
blocksize =
- gnutls_cipher_get_block_size (session->security_parameters.
- read_bulk_cipher_algorithm);
+ gnutls_cipher_get_block_size (session->
+ security_parameters.read_bulk_cipher_algorithm);
/* actual decryption (inplace)
{
case CIPHER_STREAM:
if ((ret =
- _gnutls_cipher_decrypt (&session->connection_state.
- read_cipher_state, ciphertext.data,
- ciphertext.size)) < 0)
+ _gnutls_cipher_decrypt (&session->
+ connection_state.read_cipher_state,
+ ciphertext.data, ciphertext.size)) < 0)
{
gnutls_assert ();
return ret;
}
if ((ret =
- _gnutls_cipher_decrypt (&session->connection_state.
- read_cipher_state, ciphertext.data,
- ciphertext.size)) < 0)
+ _gnutls_cipher_decrypt (&session->
+ connection_state.read_cipher_state,
+ ciphertext.data, ciphertext.size)) < 0)
{
gnutls_assert ();
return ret;
digest_hd_st td;
ret = mac_init (&td, session->security_parameters.read_mac_algorithm,
- session->connection_state.read_mac_secret.data,
- session->connection_state.read_mac_secret.size, ver);
+ session->connection_state.read_mac_secret.data,
+ session->connection_state.read_mac_secret.size, ver);
if (ret < 0)
- {
- gnutls_assert ();
- return GNUTLS_E_INTERNAL_ERROR;
- }
+ {
+ gnutls_assert ();
+ return GNUTLS_E_INTERNAL_ERROR;
+ }
- preamble_size = make_preamble( UINT64DATA (session->connection_state.read_sequence_number), type, c_length, ver, preamble);
+ preamble_size =
+ make_preamble (UINT64DATA
+ (session->connection_state.read_sequence_number), type,
+ c_length, ver, preamble);
mac_hash (&td, preamble, preamble_size, ver);
if (length > 0)
mac_hash (&td, ciphertext.data, length, ver);
for (i = j = 0; i < SUPPORTED_COMPRESSION_METHODS; i++)
{
int tmp =
- _gnutls_compression_get_num (session->internals.priorities.
- compression.priority[i]);
+ _gnutls_compression_get_num (session->internals.
+ priorities.compression.priority[i]);
/* remove private compression algorithms, if requested.
*/
gnutls_free(dst->extensions.oprfi_client); \
gnutls_free(dst->extensions.oprfi_server); \
memcpy(&dst->extensions.server_names, &src->extensions, sizeof(src->extensions)); \
- memset(&src->extensions, 0, sizeof(src->extensions)) /* avoid duplicate free's */
+ memset(&src->extensions, 0, sizeof(src->extensions)) /* avoid duplicate free's */
#define CPY_COMMON dst->entity = src->entity; \
dst->kx_algorithm = src->kx_algorithm; \
dst, security_parameters_st * src)
{
CPY_COMMON;
- CPY_EXTENSIONS; /* only do once */
+ CPY_EXTENSIONS; /* only do once */
dst->write_bulk_cipher_algorithm = src->write_bulk_cipher_algorithm;
dst->write_mac_algorithm = src->write_mac_algorithm;
{
rc = _gnutls_set_read_cipher (session,
_gnutls_cipher_suite_get_cipher_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (rc < 0)
return rc;
rc = _gnutls_set_read_mac (session,
_gnutls_cipher_suite_get_mac_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (rc < 0)
return rc;
rc = _gnutls_set_kx (session,
_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (rc < 0)
return rc;
rc = _gnutls_set_read_compression (session,
- session->internals.
- compression_method);
+ session->
+ internals.compression_method);
if (rc < 0)
return rc;
}
else
{ /* RESUME_TRUE */
_gnutls_cpy_read_security_parameters (&session->security_parameters,
- &session->internals.
- resumed_security_parameters);
+ &session->
+ internals.resumed_security_parameters);
}
_gnutls_handshake_log ("HSK[%p]: Cipher Suite: %s\n",
session,
_gnutls_cipher_suite_get_name
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (_gnutls_compression_is_ok
(session->security_parameters.read_compression_algorithm) != 0)
mac_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
- read_mac_algorithm);
+ _gnutls_hash_get_algo_len (session->
+ security_parameters.read_mac_algorithm);
_gnutls_handshake_log
("HSK[%p]: Initializing internal [read] cipher sessions\n", session);
/* initialize cipher session
*/
rc = _gnutls_cipher_init (&session->connection_state.read_cipher_state,
- session->
- security_parameters.read_bulk_cipher_algorithm,
+ session->security_parameters.
+ read_bulk_cipher_algorithm,
&session->cipher_specs.client_write_key,
&session->cipher_specs.client_write_IV);
if (rc < 0
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.read_mac_secret,
- session->cipher_specs.
- client_write_mac_secret.data,
- session->cipher_specs.
- client_write_mac_secret.size) < 0)
+ session->
+ cipher_specs.client_write_mac_secret.data,
+ session->
+ cipher_specs.client_write_mac_secret.size) <
+ 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
case GNUTLS_CLIENT:
rc = _gnutls_cipher_init (&session->connection_state.read_cipher_state,
- session->
- security_parameters.read_bulk_cipher_algorithm,
+ session->security_parameters.
+ read_bulk_cipher_algorithm,
&session->cipher_specs.server_write_key,
&session->cipher_specs.server_write_IV);
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.read_mac_secret,
- session->cipher_specs.
- server_write_mac_secret.data,
- session->cipher_specs.
- server_write_mac_secret.size) < 0)
+ session->
+ cipher_specs.server_write_mac_secret.data,
+ session->
+ cipher_specs.server_write_mac_secret.size) <
+ 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
session->connection_state.read_compression_state =
- _gnutls_comp_init (session->security_parameters.
- read_compression_algorithm, 1);
+ _gnutls_comp_init (session->
+ security_parameters.read_compression_algorithm, 1);
if (session->connection_state.read_compression_state == GNUTLS_COMP_FAILED)
{
{
rc = _gnutls_set_write_cipher (session,
_gnutls_cipher_suite_get_cipher_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (rc < 0)
return rc;
rc = _gnutls_set_write_mac (session,
_gnutls_cipher_suite_get_mac_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (rc < 0)
return rc;
rc = _gnutls_set_kx (session,
_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (rc < 0)
return rc;
rc = _gnutls_set_write_compression (session,
- session->internals.
- compression_method);
+ session->
+ internals.compression_method);
if (rc < 0)
return rc;
}
else
{ /* RESUME_TRUE */
_gnutls_cpy_write_security_parameters (&session->security_parameters,
- &session->internals.
- resumed_security_parameters);
+ &session->
+ internals.resumed_security_parameters);
}
rc = _gnutls_set_write_keys (session);
_gnutls_handshake_log ("HSK[%p]: Cipher Suite: %s\n", session,
_gnutls_cipher_suite_get_name
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (_gnutls_compression_is_ok
(session->security_parameters.write_compression_algorithm) != 0)
0);
mac_size =
- _gnutls_hash_get_algo_len (session->security_parameters.
- write_mac_algorithm);
+ _gnutls_hash_get_algo_len (session->
+ security_parameters.write_mac_algorithm);
_gnutls_handshake_log
("HSK[%p]: Initializing internal [write] cipher sessions\n", session);
/* initialize cipher session
*/
rc = _gnutls_cipher_init (&session->connection_state.write_cipher_state,
- session->security_parameters.
- write_bulk_cipher_algorithm,
+ session->
+ security_parameters.write_bulk_cipher_algorithm,
&session->cipher_specs.server_write_key,
&session->cipher_specs.server_write_IV);
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.write_mac_secret,
- session->cipher_specs.
- server_write_mac_secret.data,
- session->cipher_specs.
- server_write_mac_secret.size) < 0)
+ session->
+ cipher_specs.server_write_mac_secret.data,
+ session->
+ cipher_specs.server_write_mac_secret.size) <
+ 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
case GNUTLS_CLIENT:
rc = _gnutls_cipher_init (&session->connection_state.write_cipher_state,
- session->security_parameters.
- write_bulk_cipher_algorithm,
+ session->
+ security_parameters.write_bulk_cipher_algorithm,
&session->cipher_specs.client_write_key,
&session->cipher_specs.client_write_IV);
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.write_mac_secret,
- session->cipher_specs.
- client_write_mac_secret.data,
- session->cipher_specs.
- client_write_mac_secret.size) < 0)
+ session->
+ cipher_specs.client_write_mac_secret.data,
+ session->
+ cipher_specs.client_write_mac_secret.size) <
+ 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
session->connection_state.write_compression_state =
- _gnutls_comp_init (session->security_parameters.
- write_compression_algorithm, 0);
+ _gnutls_comp_init (session->
+ security_parameters.write_compression_algorithm, 0);
if (session->connection_state.write_compression_state == GNUTLS_COMP_FAILED)
{
{
if (session->internals.extensions_sent_size < MAX_EXT_TYPES)
{
- session->internals.extensions_sent[session->
- internals.extensions_sent_size] =
- type;
+ session->internals.extensions_sent[session->internals.
+ extensions_sent_size] = type;
session->internals.extensions_sent_size++;
}
else
if (p->send_func == NULL)
continue;
-
+
if (parse_type != GNUTLS_EXT_ANY && p->parse_type != parse_type)
- continue;
+ continue;
size = p->send_func (session, sdata, sdata_size);
if (size > 0 || size == GNUTLS_E_INT_RET_0)
gnutls_assert ();
goto out;
}
-
- _gnutls_cryptodev_init();
+
+ _gnutls_cryptodev_init ();
out:
return result;
asn1_delete_structure (&_gnutls_gnutls_asn);
asn1_delete_structure (&_gnutls_pkix1_asn);
_gnutls_crypto_deregister ();
- _gnutls_cryptodev_deinit();
+ _gnutls_cryptodev_deinit ();
}
_gnutls_init--;
}
else if (session->security_parameters.handshake_mac_handle_type ==
HANDSHAKE_MAC_TYPE_12)
{
- _gnutls_hash_deinit (&session->internals.handshake_mac_handle.
- tls12.sha256, NULL);
- _gnutls_hash_deinit (&session->internals.handshake_mac_handle.
- tls12.sha1, NULL);
+ _gnutls_hash_deinit (&session->internals.handshake_mac_handle.tls12.
+ sha256, NULL);
+ _gnutls_hash_deinit (&session->internals.handshake_mac_handle.tls12.
+ sha1, NULL);
}
session->security_parameters.handshake_mac_handle_type = 0;
session->internals.handshake_mac_handle_init = 0;
* hello message.
*/
memcpy (session->security_parameters.current_cipher_suite.suite,
- session->internals.resumed_security_parameters.
- current_cipher_suite.suite, 2);
+ session->internals.resumed_security_parameters.current_cipher_suite.
+ suite, 2);
session->internals.compression_method =
session->internals.resumed_security_parameters.read_compression_algorithm;
session->internals.resumed_security_parameters.entity;
_gnutls_set_current_version (session,
- session->internals.
- resumed_security_parameters.version);
+ session->internals.resumed_security_parameters.
+ version);
session->security_parameters.cert_type =
session->internals.resumed_security_parameters.cert_type;
{
rc =
_gnutls_hash_copy (&td_md5,
- &session->internals.handshake_mac_handle.
- tls10.md5);
+ &session->internals.handshake_mac_handle.tls10.
+ md5);
if (rc < 0)
{
gnutls_assert ();
rc =
_gnutls_hash_copy (&td_sha,
- &session->internals.handshake_mac_handle.
- tls10.sha);
+ &session->internals.handshake_mac_handle.tls10.
+ sha);
if (rc < 0)
{
gnutls_assert ();
_gnutls_hash (&td_sha, mesg, siz);
_gnutls_mac_deinit_ssl3_handshake (&td_md5, ret,
- session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE);
+ session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE);
_gnutls_mac_deinit_ssl3_handshake (&td_sha, &ret[16],
- session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE);
+ session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE);
return 0;
}
{
rc =
_gnutls_hash_copy (&td_md5,
- &session->internals.handshake_mac_handle.
- tls10.md5);
+ &session->internals.handshake_mac_handle.tls10.
+ md5);
if (rc < 0)
{
gnutls_assert ();
rc =
_gnutls_hash_copy (&td_sha,
- &session->internals.handshake_mac_handle.
- tls10.sha);
+ &session->internals.handshake_mac_handle.tls10.
+ sha);
if (rc < 0)
{
gnutls_assert ();
{
rc =
_gnutls_hash_copy (&td_sha,
- &session->internals.handshake_mac_handle.
- tls12.sha256);
+ &session->internals.handshake_mac_handle.tls12.
+ sha256);
if (rc < 0)
{
gnutls_assert ();
pos += session_id_len;
if (ret == 0)
- { /* resumed using default TLS resumption! */
+ { /* resumed using default TLS resumption! */
/* Parse only the safe renegotiation extension
* We don't want to parse any other extensions since
* we don't want new extension values to overwrite the
* resumed ones.
*/
-
+
/* move forward to extensions */
DECR_LEN (len, 2);
suite_size = _gnutls_read_uint16 (&data[pos]);
DECR_LEN (len, suite_size);
pos += suite_size;
-
+
DECR_LEN (len, 1);
comp_size = data[pos++]; /* z is the number of compression methods */
DECR_LEN (len, comp_size);
pos += comp_size;
ret = _gnutls_parse_extensions (session, GNUTLS_EXT_MANDATORY,
- &data[pos], len);
+ &data[pos], len);
if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
+ {
+ gnutls_assert ();
+ return ret;
+ }
resume_copy_required_values (session);
session->internals.resumed = RESUME_TRUE;
-
+
return _gnutls_user_hello_func (session, adv_version);
}
else
{
_gnutls_generate_session_id (session->security_parameters.session_id,
- &session->security_parameters.
- session_id_size);
+ &session->
+ security_parameters.session_id_size);
session->internals.resumed = RESUME_FALSE;
}
return ret;
}
- ret = _gnutls_parse_extensions (session, GNUTLS_EXT_TLS,
- &data[pos], len);
+ ret = _gnutls_parse_extensions (session, GNUTLS_EXT_TLS, &data[pos], len);
if (ret < 0)
{
gnutls_assert ();
memcpy (session->internals.resumed_security_parameters.session_id,
session_id, session_id_len);
session->internals.resumed_security_parameters.session_id_size =
- session_id_len;
+ session_id_len;
- session->internals.
- resumed_security_parameters.max_record_recv_size =
+ session->internals.resumed_security_parameters.max_record_recv_size =
session->security_parameters.max_record_recv_size;
- session->internals.
- resumed_security_parameters.max_record_send_size =
+ session->internals.resumed_security_parameters.max_record_send_size =
session->security_parameters.max_record_send_size;
resume_copy_required_values (session);
data_size = 36;
}
else
- { /* TLS 1.0+ */
+ { /* TLS 1.0+ */
ret = _gnutls_finished (session,
session->security_parameters.entity, data);
data_size = 12;
/* Save data for safe renegotiation.
*/
- if (data_size > MAX_VERIFY_DATA_SIZE)
+ if (data_size > MAX_VERIFY_DATA_SIZE)
{
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
- session->security_parameters.extensions.client_verify_data_len =
- data_size;
+ session->security_parameters.extensions.client_verify_data_len =
+ data_size;
memcpy (session->security_parameters.extensions.client_verify_data,
data, data_size);
}
else
{
- session->security_parameters.extensions.server_verify_data_len =
- data_size;
+ session->security_parameters.extensions.server_verify_data_len =
+ data_size;
memcpy (session->security_parameters.extensions.server_verify_data,
data, data_size);
{
int offset;
- for(offset = 0; offset < datalen; offset += 2)
+ for (offset = 0; offset < datalen; offset += 2)
{
/* TLS_RENEGO_PROTECTION_REQUEST = { 0x00, 0xff } */
- if (data[offset] == GNUTLS_RENEGO_PROTECTION_REQUEST_MAJOR &&
- data[offset+1] == GNUTLS_RENEGO_PROTECTION_REQUEST_MINOR)
- {
- _gnutls_handshake_log ("HSK[%p]: Received safe renegotiation CS\n", session);
- session->internals.safe_renegotiation_received = 1;
- session->internals.connection_using_safe_renegotiation = 1;
+ if (data[offset] == GNUTLS_RENEGO_PROTECTION_REQUEST_MAJOR &&
+ data[offset + 1] == GNUTLS_RENEGO_PROTECTION_REQUEST_MINOR)
+ {
+ _gnutls_handshake_log
+ ("HSK[%p]: Received safe renegotiation CS\n", session);
+ session->internals.safe_renegotiation_received = 1;
+ session->internals.connection_using_safe_renegotiation = 1;
break;
- }
+ }
}
}
x = _gnutls_supported_ciphersuites (session, &ciphers);
if (x < 0)
- { /* the case x==0 is handled within the function. */
+ { /* the case x==0 is handled within the function. */
gnutls_assert ();
return x;
}
for (j = 0; j < datalen; j += 2)
{
- for (i = 0; i < x; i++)
- {
- if (memcmp (ciphers[i].suite, &data[j], 2) == 0)
- {
- memcpy (&cs.suite, &data[j], 2);
+ for (i = 0; i < x; i++)
+ {
+ if (memcmp (ciphers[i].suite, &data[j], 2) == 0)
+ {
+ memcpy (&cs.suite, &data[j], 2);
- _gnutls_handshake_log
- ("HSK[%p]: Selected cipher suite: %s\n", session,
- _gnutls_cipher_suite_get_name (&cs));
- memcpy (session->security_parameters.current_cipher_suite.suite,
- ciphers[i].suite, 2);
- retval = 0;
- goto finish;
- }
- }
+ _gnutls_handshake_log
+ ("HSK[%p]: Selected cipher suite: %s\n", session,
+ _gnutls_cipher_suite_get_name (&cs));
+ memcpy (session->security_parameters.current_cipher_suite.suite,
+ ciphers[i].suite, 2);
+ retval = 0;
+ goto finish;
+ }
+ }
}
finish:
*/
if (_gnutls_get_kx_cred
(session,
- _gnutls_cipher_suite_get_kx_algo (&session->security_parameters.
- current_cipher_suite), &err) == NULL
- && err != 0)
+ _gnutls_cipher_suite_get_kx_algo (&session->
+ security_parameters.current_cipher_suite),
+ &err) == NULL && err != 0)
{
gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
*/
session->internals.auth_struct =
_gnutls_kx_auth_struct (_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (session->internals.auth_struct == NULL)
{
_gnutls_handshake_log
("HSK[%p]: Selected Compression Method: %s\n", session,
- gnutls_compression_get_name (session->internals.
- compression_method));
+ gnutls_compression_get_name (session->
+ internals.compression_method));
return 0;
if (session->internals.handshake_header_buffer.header_size ==
handshake_header_size || (session->internals.v2_hello != 0
&& type == GNUTLS_HANDSHAKE_CLIENT_HELLO
- && session->internals.
- handshake_header_buffer.packet_length > 0))
+ && session->internals.handshake_header_buffer.
+ packet_length > 0))
{
*recv_type = session->internals.handshake_header_buffer.recv_type;
_gnutls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type,
&dataptr
- [session->internals.
- handshake_header_buffer.header_size],
+ [session->
+ internals.handshake_header_buffer.
+ header_size],
HANDSHAKE_HEADER_SIZE -
- session->internals.
- handshake_header_buffer.header_size);
+ session->
+ internals.handshake_header_buffer.
+ header_size);
if (ret <= 0)
{
gnutls_assert ();
ret = _gnutls_handshake_hash_add_recvd (session, recv_type,
- session->internals.
- handshake_header_buffer.header,
- session->internals.
- handshake_header_buffer.header_size,
- dataptr, length32);
+ session->
+ internals.handshake_header_buffer.
+ header,
+ session->
+ internals.handshake_header_buffer.
+ header_size, dataptr, length32);
if (ret < 0)
{
gnutls_assert ();
_gnutls_handshake_log ("HSK[%p]: Selected cipher suite: %s\n", session,
_gnutls_cipher_suite_get_name
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
/* check if the credentials (username, public key etc.) are ok.
*/
session->internals.auth_struct =
_gnutls_kx_auth_struct (_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (session->internals.auth_struct == NULL)
{
(session, &data[pos], session_id_len) == 0)
{
pos += session_id_len + 2 + 1;
- DECR_LEN (len, 2+1);
+ DECR_LEN (len, 2 + 1);
ret = _gnutls_parse_extensions (session, GNUTLS_EXT_MANDATORY,
- &data[pos], len);
+ &data[pos], len);
if (ret < 0)
- {
- gnutls_assert ();
- return ret;
- }
+ {
+ gnutls_assert ();
+ return ret;
+ }
return 0;
}
/* Parse extensions.
*/
- ret = _gnutls_parse_extensions (session, GNUTLS_EXT_ANY,
- &data[pos], len);
+ ret = _gnutls_parse_extensions (session, GNUTLS_EXT_ANY, &data[pos], len);
if (ret < 0)
{
gnutls_assert ();
extdatalen = MAX_EXT_DATA_LENGTH
+
- session->internals.resumed_security_parameters.extensions.
- session_ticket_len;
+ session->internals.resumed_security_parameters.
+ extensions.session_ticket_len;
extdata = gnutls_malloc (extdatalen);
if (extdata == NULL)
{
*/
if (session_id_len == 0)
{
- if (rehandshake) /* already negotiated version thus version_max == negotiated version */
- hver = session->security_parameters.version;
- else /* new handshake. just get the max */
- hver = _gnutls_version_max (session);
+ if (rehandshake) /* already negotiated version thus version_max == negotiated version */
+ hver = session->security_parameters.version;
+ else /* new handshake. just get the max */
+ hver = _gnutls_version_max (session);
}
else
{
if (session_id_len > 0)
{
- memcpy (&data[pos], session->internals.resumed_security_parameters.session_id, session_id_len);
+ memcpy (&data[pos],
+ session->internals.resumed_security_parameters.session_id,
+ session_id_len);
pos += session_id_len;
}
* prevention on initial negotiation (but not renegotiation; that's
* handled with the RI extension below).
*/
- if(!session->internals.initial_negotiation_completed &&
- session->security_parameters.entity == GNUTLS_CLIENT &&
- gnutls_protocol_get_version (session) == GNUTLS_SSL3)
- {
- ret = _gnutls_copy_ciphersuites (session, extdata, extdatalen, TRUE);
- _gnutls_extension_list_add (session, GNUTLS_EXTENSION_SAFE_RENEGOTIATION);
+ if (!session->internals.initial_negotiation_completed &&
+ session->security_parameters.entity == GNUTLS_CLIENT &&
+ gnutls_protocol_get_version (session) == GNUTLS_SSL3)
+ {
+ ret =
+ _gnutls_copy_ciphersuites (session, extdata, extdatalen, TRUE);
+ _gnutls_extension_list_add (session,
+ GNUTLS_EXTENSION_SAFE_RENEGOTIATION);
}
else
ret = _gnutls_copy_ciphersuites (session, extdata, extdatalen, FALSE);
/* Generate and copy TLS extensions.
*/
if (_gnutls_version_has_extensions (hver))
- type = GNUTLS_EXT_ANY;
+ type = GNUTLS_EXT_ANY;
else
{
- if(session->internals.initial_negotiation_completed != 0)
+ if (session->internals.initial_negotiation_completed != 0)
type = GNUTLS_EXT_MANDATORY;
else
type = GNUTLS_EXT_NONE;
{
datalen = 2 + session_id_len + 1 + GNUTLS_RANDOM_SIZE + 3;
extdatalen =
- _gnutls_gen_extensions (session, extdata, sizeof (extdata), GNUTLS_EXT_ANY);
+ _gnutls_gen_extensions (session, extdata, sizeof (extdata),
+ GNUTLS_EXT_ANY);
if (extdatalen < 0)
{
data[pos++] = session_id_len;
if (session_id_len > 0)
{
- memcpy (&data[pos], session->security_parameters.session_id, session_id_len);
+ memcpy (&data[pos], session->security_parameters.session_id,
+ session_id_len);
}
pos += session_id_len;
_gnutls_handshake_log ("HSK[%p]: SessionID: %s\n", session,
- _gnutls_bin2hex (session->security_parameters.session_id, session_id_len,
- buf, sizeof (buf)));
+ _gnutls_bin2hex (session->security_parameters.
+ session_id, session_id_len, buf,
+ sizeof (buf)));
memcpy (&data[pos],
session->security_parameters.current_cipher_suite.suite, 2);
pos += 2;
comp =
- (uint8_t) _gnutls_compression_get_num (session->
- internals.compression_method);
+ (uint8_t) _gnutls_compression_get_num (session->internals.
+ compression_method);
data[pos++] = comp;
}
}
else
- { /* Server side reading a client hello */
+ { /* Server side reading a client hello */
ret = _gnutls_read_client_hello (session, data, datalen);
if (ret < 0)
if (session->internals.priorities.disable_safe_renegotiation != 0)
{
- gnutls_assert();
+ gnutls_assert ();
return ret;
}
{
if ((ext->ri_extension_data_len < ext->client_verify_data_len) ||
(memcmp (ext->ri_extension_data,
- ext->client_verify_data,
- ext->client_verify_data_len)))
+ ext->client_verify_data, ext->client_verify_data_len)))
{
- gnutls_assert();
+ gnutls_assert ();
_gnutls_handshake_log ("Safe renegotiation failed [1]\n");
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
ext->server_verify_data,
ext->server_verify_data_len) != 0)
{
- gnutls_assert();
+ gnutls_assert ();
_gnutls_handshake_log ("Safe renegotiation failed [2]\n");
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
}
- else /* Make sure there are 0 extra bytes */
+ else /* Make sure there are 0 extra bytes */
{
if (ext->ri_extension_data_len != ext->client_verify_data_len)
{
- gnutls_assert();
+ gnutls_assert ();
_gnutls_handshake_log ("Safe renegotiation failed [3]\n");
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
_gnutls_handshake_log ("Safe renegotiation succeeded.\n");
}
- else /* safe renegotiation not received... */
+ else /* safe renegotiation not received... */
{
if (session->internals.connection_using_safe_renegotiation)
{
- gnutls_assert();
- _gnutls_handshake_log ("Peer previously asked for safe renegotiation!\n");
+ gnutls_assert ();
+ _gnutls_handshake_log
+ ("Peer previously asked for safe renegotiation!\n");
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
}
else
{
- gnutls_assert();
+ gnutls_assert ();
_gnutls_handshake_log ("Denying unsafe (re)negotiation.\n");
if (session->security_parameters.entity == GNUTLS_SERVER)
/* send no renegotiation alert */
}
else
{
- if (session->internals.priorities.initial_safe_renegotiation==0)
+ if (session->internals.priorities.initial_safe_renegotiation == 0)
{
- _gnutls_handshake_log ("Allowing unsafe initial negotiation!\n");
+ _gnutls_handshake_log
+ ("Allowing unsafe initial negotiation!\n");
}
else
{
- gnutls_assert();
+ gnutls_assert ();
_gnutls_handshake_log ("Denying unsafe initial negotiation.\n");
return GNUTLS_E_SAFE_RENEGOTIATION_FAILED;
}
HANDSHAKE_MAC_TYPE_10)
{
ret =
- _gnutls_hash_init (&session->internals.handshake_mac_handle.
- tls10.md5, GNUTLS_MAC_MD5);
+ _gnutls_hash_init (&session->internals.handshake_mac_handle.tls10.
+ md5, GNUTLS_MAC_MD5);
if (ret < 0)
{
}
ret =
- _gnutls_hash_init (&session->internals.handshake_mac_handle.
- tls10.sha, GNUTLS_MAC_SHA1);
+ _gnutls_hash_init (&session->internals.handshake_mac_handle.tls10.
+ sha, GNUTLS_MAC_SHA1);
if (ret < 0)
{
gnutls_assert ();
- _gnutls_hash_deinit (&session->internals.
- handshake_mac_handle.tls10.md5, NULL);
+ _gnutls_hash_deinit (&session->internals.handshake_mac_handle.
+ tls10.md5, NULL);
return GNUTLS_E_MEMORY_ERROR;
}
}
same as the one used as the basis for PRF. By now we use
SHA256. */
ret =
- _gnutls_hash_init (&session->internals.handshake_mac_handle.
- tls12.sha256, GNUTLS_DIG_SHA256);
+ _gnutls_hash_init (&session->internals.handshake_mac_handle.tls12.
+ sha256, GNUTLS_DIG_SHA256);
if (ret < 0)
{
gnutls_assert ();
}
ret =
- _gnutls_hash_init (&session->internals.handshake_mac_handle.
- tls12.sha1, GNUTLS_DIG_SHA1);
+ _gnutls_hash_init (&session->internals.handshake_mac_handle.tls12.
+ sha1, GNUTLS_DIG_SHA1);
if (ret < 0)
{
gnutls_assert ();
- _gnutls_hash_deinit (&session->internals.
- handshake_mac_handle.tls12.sha256, NULL);
+ _gnutls_hash_deinit (&session->internals.handshake_mac_handle.
+ tls12.sha256, NULL);
return GNUTLS_E_MEMORY_ERROR;
}
}
if (session->internals.resumed_security_parameters.session_id_size > 0)
_gnutls_handshake_log ("HSK[%p]: Ask to resume: %s\n", session,
- _gnutls_bin2hex (session->internals.
- resumed_security_parameters.
- session_id,
- session->internals.
- resumed_security_parameters.
- session_id_size, buf,
- sizeof (buf)));
+ _gnutls_bin2hex (session->
+ internals.resumed_security_parameters.session_id,
+ session->
+ internals.resumed_security_parameters.session_id_size,
+ buf, sizeof (buf)));
#endif
switch (STATE)
_gnutls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
sizeof (buf)));
_gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
- _gnutls_bin2hex (session->security_parameters.
- client_random, 32, buf, sizeof (buf)));
+ _gnutls_bin2hex (session->
+ security_parameters.client_random, 32,
+ buf, sizeof (buf)));
_gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
- _gnutls_bin2hex (session->security_parameters.
- server_random, 32, buf, sizeof (buf)));
+ _gnutls_bin2hex (session->
+ security_parameters.server_random, 32,
+ buf, sizeof (buf)));
if (gnutls_protocol_get_version (session) == GNUTLS_SSL3)
{
_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
rnd, 2 * GNUTLS_RANDOM_SIZE,
GNUTLS_MASTER_SIZE,
- session->security_parameters.
- master_secret);
+ session->
+ security_parameters.master_secret);
}
else if (session->security_parameters.extensions.oprfi_client_len > 0 &&
}
_gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
- session->security_parameters.
- extensions.oprfi_server_len,
- _gnutls_bin2hex (session->security_parameters.
- extensions.oprfi_client,
- session->security_parameters.
- extensions.oprfi_client_len, buf,
+ session->security_parameters.extensions.
+ oprfi_server_len,
+ _gnutls_bin2hex (session->
+ security_parameters.extensions.
+ oprfi_client,
+ session->
+ security_parameters.extensions.
+ oprfi_client_len, buf,
sizeof (buf)));
_gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
- session->security_parameters.
- extensions.oprfi_server_len,
- _gnutls_bin2hex (session->security_parameters.
- extensions.oprfi_server,
- session->security_parameters.
- extensions.oprfi_server_len, buf,
+ session->security_parameters.extensions.
+ oprfi_server_len,
+ _gnutls_bin2hex (session->
+ security_parameters.extensions.
+ oprfi_server,
+ session->
+ security_parameters.extensions.
+ oprfi_server_len, buf,
sizeof (buf)));
memcpy (rnd, session->security_parameters.client_random,
return ret;
_gnutls_hard_log ("INT: MASTER SECRET: %s\n",
- _gnutls_bin2hex (session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE, buf,
- sizeof (buf)));
+ _gnutls_bin2hex (session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE, buf, sizeof (buf)));
return ret;
}
int data_size = 0;
int ret = 0;
- if (session->internals.auth_struct->
- gnutls_generate_server_certificate_request == NULL)
+ if (session->internals.
+ auth_struct->gnutls_generate_server_certificate_request == NULL)
return 0;
if (session->internals.send_cert_req <= 0)
if (again == 0)
{
data_size =
- session->internals.auth_struct->
- gnutls_generate_server_certificate_request (session, &data);
+ session->internals.
+ auth_struct->gnutls_generate_server_certificate_request (session,
+ &data);
if (data_size < 0)
{
if (again == 0)
{
data_size =
- session->internals.auth_struct->
- gnutls_generate_client_cert_vrfy (session, &data);
+ session->internals.
+ auth_struct->gnutls_generate_client_cert_vrfy (session, &data);
if (data_size < 0)
{
gnutls_assert ();
int datasize;
int ret = 0;
- if (session->internals.auth_struct->
- gnutls_process_server_certificate_request != NULL)
+ if (session->internals.
+ auth_struct->gnutls_process_server_certificate_request != NULL)
{
ret =
return 0; /* ignored */
ret =
- session->internals.auth_struct->
- gnutls_process_server_certificate_request (session, data, datasize);
+ session->internals.
+ auth_struct->gnutls_process_server_certificate_request (session, data,
+ datasize);
gnutls_free (data);
if (ret < 0)
return ret;
/* TLS 1.0 or SSL 3.0 with a valid certificate
*/
data_size =
- session->internals.auth_struct->
- gnutls_generate_client_certificate (session, &data);
+ session->internals.
+ auth_struct->gnutls_generate_client_certificate (session, &data);
if (data_size < 0)
{
if (again == 0)
{
data_size =
- session->internals.auth_struct->
- gnutls_generate_server_certificate (session, &data);
+ session->internals.
+ auth_struct->gnutls_generate_server_certificate (session, &data);
if (data_size < 0)
{
return 0;
}
ret =
- session->internals.auth_struct->
- gnutls_process_client_certificate (session, data, datasize);
+ session->internals.
+ auth_struct->gnutls_process_client_certificate (session, data,
+ datasize);
gnutls_free (data);
if (ret < 0 && ret != GNUTLS_E_NO_CERTIFICATE_FOUND)
}
ret =
- session->internals.auth_struct->
- gnutls_process_server_certificate (session, data, datasize);
+ session->internals.
+ auth_struct->gnutls_process_server_certificate (session, data,
+ datasize);
gnutls_free (data);
if (ret < 0)
{
}
ret =
- session->internals.auth_struct->
- gnutls_process_client_cert_vrfy (session, data, datasize);
+ session->internals.
+ auth_struct->gnutls_process_client_cert_vrfy (session, data,
+ datasize);
gnutls_free (data);
if (ret < 0)
return ret;
*/
if (session->internals.priorities.protocol.algorithms > 0)
_gnutls_set_current_version (session,
- session->internals.priorities.
- protocol.priority[0]);
+ session->internals.priorities.protocol.
+ priority[0]);
return 0;
}
else if (strcasecmp (&broken_list[i][1],
"UNSAFE_RENEGOTIATION") == 0)
(*priority_cache)->unsafe_renegotiation = 1;
- else if (strcasecmp (&broken_list[i][1],
- "SAFE_RENEGOTIATION") == 0)
+ else if (strcasecmp (&broken_list[i][1], "SAFE_RENEGOTIATION") == 0)
(*priority_cache)->unsafe_renegotiation = 0;
else if (strcasecmp (&broken_list[i][1],
"INITIAL_SAFE_RENEGOTIATION") == 0)
- {
+ {
(*priority_cache)->unsafe_renegotiation = 0;
(*priority_cache)->initial_safe_renegotiation = 1;
- }
+ }
else if (strcasecmp (&broken_list[i][1],
"DISABLE_SAFE_RENEGOTIATION") == 0)
(*priority_cache)->disable_safe_renegotiation = 1;
_gnutls_record_log
("REC[%p]: Sending Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
- write_sequence_number),
+ (int) _gnutls_uint64touint32 (&session->
+ connection_state.write_sequence_number),
_gnutls_packet2str (type), type, (int) sizeofdata);
if (sizeofdata > MAX_RECORD_SEND_SIZE)
_gnutls_io_read_buffered (session, &headers, header_size,
-1)) != header_size)
{
- _gnutls_handshake_log ("XXX[]: ret: %d %s\n", ret, gnutls_strerror(ret));
+ _gnutls_handshake_log ("XXX[]: ret: %d %s\n", ret,
+ gnutls_strerror (ret));
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
return ret;
- _gnutls_handshake_log ("XXX2[]: ret: %d %s\n", ret, gnutls_strerror(ret));
+ _gnutls_handshake_log ("XXX2[]: ret: %d %s\n", ret,
+ gnutls_strerror (ret));
session_invalidate (session);
if (type == GNUTLS_ALERT)
_gnutls_record_log
("REC[%p]: Expected Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
- read_sequence_number),
+ (int) _gnutls_uint64touint32 (&session->
+ connection_state.read_sequence_number),
_gnutls_packet2str (type), type, (int) sizeofdata);
_gnutls_record_log ("REC[%p]: Received Packet[%d] %s(%d) with length: %d\n",
session,
- (int)
- _gnutls_uint64touint32 (&session->connection_state.
- read_sequence_number),
+ (int) _gnutls_uint64touint32 (&session->
+ connection_state.read_sequence_number),
_gnutls_packet2str (recv_type), recv_type, length);
if (length > MAX_RECV_SIZE)
_gnutls_record_log
("REC[%p]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
- (int) _gnutls_uint64touint32 (&session->connection_state.
- read_sequence_number),
+ (int) _gnutls_uint64touint32 (&session->
+ connection_state.read_sequence_number),
_gnutls_packet2str (recv_type), recv_type, decrypted_length);
/* increase sequence number
*/
packed_session->data =
gnutls_malloc (packed_session->size + MAX_SEC_PARAMS + 2 +
- session->security_parameters.
- extensions.session_ticket_len);
+ session->security_parameters.extensions.
+ session_ticket_len);
if (packed_session->data == NULL)
{
*/
packed_session->data =
gnutls_malloc (packed_session->size + MAX_SEC_PARAMS + 2 +
- session->security_parameters.
- extensions.session_ticket_len);
+ session->security_parameters.extensions.
+ session_ticket_len);
if (packed_session->data == NULL)
{
*/
packed_session->data =
gnutls_malloc (packed_session->size + MAX_SEC_PARAMS + 2 +
- session->security_parameters.
- extensions.session_ticket_len);
+ session->security_parameters.extensions.
+ session_ticket_len);
if (packed_session->data == NULL)
{
hint_size = strlen (info->hint) + 1; /* include the terminating null */
pack_size = 1 + 4 + 4 + username_size + 4 + hint_size +
- + 2 + 4 + info->dh.prime.size + 4 + info->dh.generator.size +
+ +2 + 4 + info->dh.prime.size + 4 + info->dh.generator.size +
4 + info->dh.public_key.size;
}
else
*/
packed_session->data =
gnutls_malloc (packed_session->size + MAX_SEC_PARAMS + 2 +
- session->security_parameters.
- extensions.session_ticket_len);
+ session->security_parameters.extensions.
+ session_ticket_len);
if (packed_session->data == NULL)
{
session->security_parameters.extensions.srp_username, len);
pos += len;
- _gnutls_write_uint16 (session->security_parameters.extensions.
- server_names_size, &packed_session->data[pos]);
+ _gnutls_write_uint16 (session->security_parameters.
+ extensions.server_names_size,
+ &packed_session->data[pos]);
pos += 2;
for (i = 0; i < session->security_parameters.extensions.server_names_size;
{
packed_session->data[pos++] =
session->security_parameters.extensions.server_names[i].type;
- _gnutls_write_uint16 (session->security_parameters.extensions.
- server_names[i].name_length,
+ _gnutls_write_uint16 (session->security_parameters.
+ extensions.server_names[i].name_length,
&packed_session->data[pos]);
pos += 2;
memcpy (&packed_session->data[pos],
session->security_parameters.extensions.server_names[i].name,
- session->security_parameters.extensions.server_names[i].
- name_length);
+ session->security_parameters.extensions.
+ server_names[i].name_length);
pos +=
session->security_parameters.extensions.server_names[i].name_length;
}
- _gnutls_write_uint16 (session->security_parameters.extensions.
- session_ticket_len, &packed_session->data[pos]);
+ _gnutls_write_uint16 (session->security_parameters.
+ extensions.session_ticket_len,
+ &packed_session->data[pos]);
pos += 2;
memcpy (&packed_session->data[pos],
session->security_parameters.extensions.session_ticket,
return GNUTLS_E_INVALID_REQUEST;
}
- memset(&session->internals.resumed_security_parameters, 0, sizeof(session->internals.resumed_security_parameters));
+ memset (&session->internals.resumed_security_parameters, 0,
+ sizeof (session->internals.resumed_security_parameters));
session->internals.resumed_security_parameters.entity =
packed_session->data[pos++];
session->internals.resumed_security_parameters.kx_algorithm =
packed_session->data[pos++];
session->internals.resumed_security_parameters.write_compression_algorithm =
packed_session->data[pos++];
- session->internals.resumed_security_parameters.current_cipher_suite.
- suite[0] = packed_session->data[pos++];
- session->internals.resumed_security_parameters.current_cipher_suite.
- suite[1] = packed_session->data[pos++];
+ session->internals.resumed_security_parameters.
+ current_cipher_suite.suite[0] = packed_session->data[pos++];
+ session->internals.resumed_security_parameters.
+ current_cipher_suite.suite[1] = packed_session->data[pos++];
session->internals.resumed_security_parameters.cert_type =
packed_session->data[pos++];
/* SRP */
len = packed_session->data[pos++]; /* srp username length */
- memcpy (session->internals.resumed_security_parameters.extensions.
- srp_username, &packed_session->data[pos], len);
- session->internals.resumed_security_parameters.extensions.
- srp_username[len] = 0;
+ memcpy (session->internals.resumed_security_parameters.
+ extensions.srp_username, &packed_session->data[pos], len);
+ session->internals.resumed_security_parameters.
+ extensions.srp_username[len] = 0;
pos += len;
- session->internals.resumed_security_parameters.extensions.
- server_names_size = _gnutls_read_uint16 (&packed_session->data[pos]);
+ session->internals.resumed_security_parameters.
+ extensions.server_names_size =
+ _gnutls_read_uint16 (&packed_session->data[pos]);
pos += 2;
for (i = 0;
i <
- session->internals.resumed_security_parameters.extensions.
- server_names_size; i++)
+ session->internals.resumed_security_parameters.
+ extensions.server_names_size; i++)
{
- session->internals.resumed_security_parameters.extensions.
- server_names[i].type = packed_session->data[pos++];
- session->internals.resumed_security_parameters.extensions.
- server_names[i].name_length =
+ session->internals.resumed_security_parameters.
+ extensions.server_names[i].type = packed_session->data[pos++];
+ session->internals.resumed_security_parameters.
+ extensions.server_names[i].name_length =
_gnutls_read_uint16 (&packed_session->data[pos]);
pos += 2;
- memcpy (session->internals.resumed_security_parameters.extensions.
- server_names[i].name, &packed_session->data[pos],
- session->internals.resumed_security_parameters.extensions.
- server_names[i].name_length);
+ memcpy (session->internals.resumed_security_parameters.
+ extensions.server_names[i].name, &packed_session->data[pos],
+ session->internals.resumed_security_parameters.
+ extensions.server_names[i].name_length);
pos +=
- session->internals.resumed_security_parameters.extensions.
- server_names[i].name_length;
+ session->internals.resumed_security_parameters.
+ extensions.server_names[i].name_length;
}
- session->internals.resumed_security_parameters.extensions.
- session_ticket_len = _gnutls_read_uint16 (&packed_session->data[pos]);
+ session->internals.resumed_security_parameters.
+ extensions.session_ticket_len =
+ _gnutls_read_uint16 (&packed_session->data[pos]);
pos += 2;
session->internals.resumed_security_parameters.extensions.session_ticket =
- gnutls_malloc (session->internals.resumed_security_parameters.extensions.
- session_ticket_len);
- memcpy (session->internals.resumed_security_parameters.extensions.
- session_ticket, &packed_session->data[pos],
- session->internals.resumed_security_parameters.extensions.
- session_ticket_len);
+ gnutls_malloc (session->internals.resumed_security_parameters.
+ extensions.session_ticket_len);
+ memcpy (session->internals.resumed_security_parameters.
+ extensions.session_ticket, &packed_session->data[pos],
+ session->internals.resumed_security_parameters.
+ extensions.session_ticket_len);
return 0;
}
/* If the certificate supports signing continue.
*/
if (cert->key_usage != 0)
- if (!(cert->key_usage & KEY_DIGITAL_SIGNATURE))
- {
- gnutls_assert ();
- return GNUTLS_E_KEY_USAGE_VIOLATION;
- }
+ if (!(cert->key_usage & KEY_DIGITAL_SIGNATURE))
+ {
+ gnutls_assert ();
+ return GNUTLS_E_KEY_USAGE_VIOLATION;
+ }
if (pk_algo == GNUTLS_PK_UNKNOWN)
pk_algo = cert->subject_pk_algorithm;
}
_gnutls_mac_deinit_ssl3_handshake (&td_md5, concat,
- session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE);
+ session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE);
_gnutls_mac_deinit_ssl3_handshake (&td_sha, &concat[16],
- session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE);
+ session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE);
}
else
{
_gnutls_x509_log
("Server did not allow either '%s' or '%s' for signing\n",
gnutls_mac_get_name (hash_algo),
- gnutls_mac_get_name (session->internals.
- handshake_mac_handle.tls12.sha1.algorithm));
+ gnutls_mac_get_name (session->internals.handshake_mac_handle.
+ tls12.sha1.algorithm));
return ret;
}
}
}
_gnutls_mac_deinit_ssl3_handshake (&td_sha, &concat[16],
- session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE);
+ session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE);
}
else
_gnutls_hash_deinit (&td_sha, &concat[16]);
case GNUTLS_PK_RSA:
ret =
_gnutls_hash_copy (&td_md5,
- &session->internals.handshake_mac_handle.
- tls10.md5);
+ &session->internals.handshake_mac_handle.tls10.
+ md5);
if (ret < 0)
{
gnutls_assert ();
if (ver == GNUTLS_SSL3)
_gnutls_mac_deinit_ssl3_handshake (&td_md5, concat,
- session->security_parameters.
- master_secret, GNUTLS_MASTER_SIZE);
+ session->
+ security_parameters.master_secret,
+ GNUTLS_MASTER_SIZE);
else
_gnutls_hash_deinit (&td_md5, concat);
}
gnutls_free (session->security_parameters.extensions.session_ticket);
- gnutls_free (session->internals.resumed_security_parameters.extensions.
- session_ticket);
+ gnutls_free (session->internals.resumed_security_parameters.
+ extensions.session_ticket);
memset (session, 0, sizeof (struct gnutls_session_int));
gnutls_free (session);
session->security_parameters.session_id_size ==
session->internals.resumed_security_parameters.session_id_size
&& memcmp (session->security_parameters.session_id,
- session->internals.resumed_security_parameters.
- session_id,
+ session->internals.
+ resumed_security_parameters.session_id,
session->security_parameters.session_id_size) == 0)
return 1;
}
gnutls_cipher_algorithm_t cipher;
cipher =
- _gnutls_cipher_suite_get_cipher_algo (&session->security_parameters.
- current_cipher_suite);
+ _gnutls_cipher_suite_get_cipher_algo (&session->
+ security_parameters.current_cipher_suite);
if (_gnutls_cipher_get_export_flag (cipher) != 0)
return 1;
gnutls_kx_algorithm_t kx;
kx =
- _gnutls_cipher_suite_get_kx_algo (&session->security_parameters.
- current_cipher_suite);
+ _gnutls_cipher_suite_get_kx_algo (&session->
+ security_parameters.current_cipher_suite);
if (kx == GNUTLS_KX_PSK || kx == GNUTLS_KX_DHE_PSK)
return 1;
*/
if (_gnutls_get_kx_cred
(session,
- _gnutls_cipher_suite_get_kx_algo (&session->security_parameters.
- current_cipher_suite), &err) == NULL
- && err != 0)
+ _gnutls_cipher_suite_get_kx_algo (&session->
+ security_parameters.current_cipher_suite),
+ &err) == NULL && err != 0)
{
gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
*/
session->internals.auth_struct =
_gnutls_kx_auth_struct (_gnutls_cipher_suite_get_kx_algo
- (&session->security_parameters.
- current_cipher_suite));
+ (&session->
+ security_parameters.current_cipher_suite));
if (session->internals.auth_struct == NULL)
{
else
{
_gnutls_generate_session_id (session->security_parameters.session_id,
- &session->security_parameters.
- session_id_size);
+ &session->
+ security_parameters.session_id_size);
session->internals.resumed = RESUME_FALSE;
}
peer_certificate_list_size,
cred->x509_ca_list, cred->x509_ncas,
cred->x509_crl_list, cred->x509_ncrls,
- cred->verify_flags | session->
- internals.priorities.
- additional_verify_flags, status);
+ cred->verify_flags | session->internals.
+ priorities.additional_verify_flags,
+ status);
CLEAR_CERTS;
1].params_size, &kid);
- _gnutls_x509_write_rsa_params (res->cert_list[res->ncerts - 1][0].
- params,
+ _gnutls_x509_write_rsa_params (res->
+ cert_list[res->ncerts - 1][0].params,
res->cert_list[res->ncerts -
1][0].params_size, &cid);
}
res->pkey[res->ncerts -
1].params_size, &kid);
- _gnutls_x509_write_dsa_params (res->cert_list[res->ncerts - 1][0].
- params,
+ _gnutls_x509_write_dsa_params (res->
+ cert_list[res->ncerts - 1][0].params,
res->cert_list[res->ncerts -
1][0].params_size, &cid);
}
leading = 1;
for (k = 1; k < len; k++)
{
-
+
/* X.690 mandates that the leading byte must never be 0x80
*/
- if (leading != 0 && der[len_len + k] == 0x80) return ASN1_DER_ERROR;
+ if (leading != 0 && der[len_len + k] == 0x80)
+ return ASN1_DER_ERROR;
leading = 0;
/* check for wrap around */
val = val << 7;
val |= der[len_len + k] & 0x7F;
- if (val < prev_val) return ASN1_DER_ERROR;
+ if (val < prev_val)
+ return ASN1_DER_ERROR;
prev_val = val;
}
}
*ret_len = len + len_len;
-
+
return ASN1_SUCCESS;
}
move = RIGHT;
break;
case TYPE_OBJECT_ID:
- result = _asn1_get_objectid_der (der + counter, len - counter, &len2,
- temp, sizeof (temp));
+ result =
+ _asn1_get_objectid_der (der + counter, len - counter, &len2,
+ temp, sizeof (temp));
if (result != ASN1_SUCCESS)
{
asn1_delete_structure (element);
case TYPE_OBJECT_ID:
if (state == FOUND)
{
- result = _asn1_get_objectid_der (der + counter, len - counter, &len2,
- temp, sizeof (temp));
- if (result != ASN1_SUCCESS)
- {
- return result;
- }
+ result =
+ _asn1_get_objectid_der (der + counter, len - counter,
+ &len2, temp, sizeof (temp));
+ if (result != ASN1_SUCCESS)
+ {
+ return result;
+ }
tlen = strlen (temp);
sk->protect.ivlen = 0;
else
{
- sk->protect.ivlen =
- gnutls_cipher_get_block_size (sk->protect.algo);
+ sk->protect.ivlen = gnutls_cipher_get_block_size (sk->protect.algo);
if (!sk->protect.ivlen)
return CDK_Inv_Packet;
rc = stream_read (inp, sk->protect.iv, sk->protect.ivlen, &nread);
if (is_selfsig)
*is_selfsig = 0;
if ((knode->pkt->pkttype != CDK_PKT_PUBLIC_KEY &&
- knode->pkt->pkttype != CDK_PKT_PUBLIC_SUBKEY) ||
+ knode->pkt->pkttype != CDK_PKT_PUBLIC_SUBKEY) ||
snode->pkt->pkttype != CDK_PKT_SIGNATURE)
{
gnutls_assert ();
*r_status = CDK_KEY_INVALID;
return rc;
}
- else /* For each valid self sig we increase this counter. */
+ else /* For each valid self sig we increase this counter. */
sig_ok++;
}
}
}
- /* No flags indicate a valid key. */
- *r_status = CDK_KEY_VALID;
+ /* No flags indicate a valid key. */
+ *r_status = CDK_KEY_VALID;
- return 0;
+ return 0;
}
result =
_gnutls_x509_encode_and_write_attribute (KEY_ID_OID, c2, root,
- bag->element[elem].
- local_key_id.data,
- bag->element[elem].
- local_key_id.size, 1);
+ bag->
+ element[elem].local_key_id.
+ data,
+ bag->
+ element[elem].local_key_id.
+ size, 1);
if (result < 0)
{
gnutls_assert ();
static int _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
const gnutls_x509_crt_t * trusted_cas,
int tcas_size, unsigned int flags,
- unsigned int *output, gnutls_x509_crt_t* issuer);
+ unsigned int *output,
+ gnutls_x509_crt_t * issuer);
static int is_crl_issuer (gnutls_x509_crl_t crl,
gnutls_x509_crt_t issuer_cert);
_gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
const gnutls_x509_crt_t * trusted_cas,
int tcas_size, unsigned int flags,
- unsigned int *output, gnutls_x509_crt_t *_issuer)
+ unsigned int *output,
+ gnutls_x509_crt_t * _issuer)
{
gnutls_datum_t cert_signed_data = { NULL, 0 };
gnutls_datum_t cert_signature = { NULL, 0 };
return 0;
}
- if (_issuer != NULL) *_issuer = issuer;
+ if (_issuer != NULL)
+ *_issuer = issuer;
issuer_version = gnutls_x509_crt_get_version (issuer);
if (issuer_version < 0)
return is_issuer (cert, issuer);
}
-static unsigned int check_time(gnutls_x509_crt_t crt, time_t now)
+static unsigned int
+check_time (gnutls_x509_crt_t crt, time_t now)
{
-int status = 0;
-time_t t;
+ int status = 0;
+ time_t t;
t = gnutls_x509_crt_get_activation_time (crt);
if (t == (time_t) - 1 || now < t)
status |= GNUTLS_CERT_INVALID;
return status;
}
-
+
return 0;
}
/* explicity time check for trusted CA that we remove from
* list. GNUTLS_VERIFY_DISABLE_TRUSTED_TIME_CHECKS
*/
- if (!(flags&GNUTLS_VERIFY_DISABLE_TRUSTED_TIME_CHECKS) && !(flags&GNUTLS_VERIFY_DISABLE_TIME_CHECKS))
+ if (!(flags & GNUTLS_VERIFY_DISABLE_TRUSTED_TIME_CHECKS)
+ && !(flags & GNUTLS_VERIFY_DISABLE_TIME_CHECKS))
{
- status |= check_time(trusted_cas[j], now);
+ status |= check_time (trusted_cas[j], now);
if (status != 0)
- {
- return status;
- }
+ {
+ return status;
+ }
}
clist_size = i;
break;
* in self signed etc certificates.
*/
ret = _gnutls_verify_certificate2 (certificate_list[clist_size - 1],
- trusted_cas, tcas_size, flags, &output, &issuer);
+ trusted_cas, tcas_size, flags, &output,
+ &issuer);
if (ret == 0)
{
/* if the last certificate in the certificate
if (!(flags & GNUTLS_VERIFY_DISABLE_TIME_CHECKS))
{
/* check the time of the issuer first */
- if (!(flags&GNUTLS_VERIFY_DISABLE_TRUSTED_TIME_CHECKS))
- {
- if (issuer == NULL)
- {
- gnutls_assert();
- return GNUTLS_E_INTERNAL_ERROR;
- }
-
- status |= check_time(issuer, now);
- if (status != 0)
- {
- return status;
- }
- }
+ if (!(flags & GNUTLS_VERIFY_DISABLE_TRUSTED_TIME_CHECKS))
+ {
+ if (issuer == NULL)
+ {
+ gnutls_assert ();
+ return GNUTLS_E_INTERNAL_ERROR;
+ }
+
+ status |= check_time (issuer, now);
+ if (status != 0)
+ {
+ return status;
+ }
+ }
for (i = 0; i < clist_size; i++)
{
- status |= check_time(certificate_list[i], now);
+ status |= check_time (certificate_list[i], now);
if (status != 0)
{
return status;
*/
*verify =
_gnutls_x509_verify_certificate (&cert, 1,
- CA_list, CA_list_length, NULL,
- 0, flags);
+ CA_list, CA_list_length, NULL, 0, flags);
return 0;
}
int
hmac_md5 (const void *key, size_t keylen,
- const void *in, size_t inlen, void *resbuf)
+ const void *in, size_t inlen, void *resbuf)
{
struct md5_ctx inner;
struct md5_ctx outer;
/* This array contains the bytes used to pad the buffer to the next
64-byte boundary. (RFC 1321, 3.1: Step 1) */
-static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
+static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
/* Initialize structure containing state of computation.
return md5_read_ctx (ctx, resbuf);
}
-#if 0 /* Not needed by GnuTLS, and it has a large stack frame. */
+#if 0 /* Not needed by GnuTLS, and it has a large stack frame. */
/* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
int
-md5_stream (FILE *stream, void *resblock)
+md5_stream (FILE * stream, void *resblock)
{
struct md5_ctx ctx;
size_t sum;
/* Read block. Take care for partial reads. */
while (1)
- {
- n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
-
- sum += n;
-
- if (sum == BLOCKSIZE)
- break;
-
- if (n == 0)
- {
- /* Check for the error flag IFF N == 0, so that we don't
- exit the loop after a partial read due to e.g., EAGAIN
- or EWOULDBLOCK. */
- if (ferror (stream))
- {
- free (buffer);
- return 1;
- }
- goto process_partial_block;
- }
-
- /* We've read at least one byte, so ignore errors. But always
- check for EOF, since feof may be true even though N > 0.
- Otherwise, we could end up calling fread after EOF. */
- if (feof (stream))
- goto process_partial_block;
- }
+ {
+ n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
+
+ sum += n;
+
+ if (sum == BLOCKSIZE)
+ break;
+
+ if (n == 0)
+ {
+ /* Check for the error flag IFF N == 0, so that we don't
+ exit the loop after a partial read due to e.g., EAGAIN
+ or EWOULDBLOCK. */
+ if (ferror (stream))
+ {
+ free (buffer);
+ return 1;
+ }
+ goto process_partial_block;
+ }
+
+ /* We've read at least one byte, so ignore errors. But always
+ check for EOF, since feof may be true even though N > 0.
+ Otherwise, we could end up calling fread after EOF. */
+ if (feof (stream))
+ goto process_partial_block;
+ }
/* Process buffer with BLOCKSIZE bytes. Note that
BLOCKSIZE % 64 == 0
ctx->buflen += add;
if (ctx->buflen > 64)
- {
- md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
+ {
+ md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
- ctx->buflen &= 63;
- /* The regions in the following copy operation cannot overlap. */
- memcpy (ctx->buffer,
- &((char *) ctx->buffer)[(left_over + add) & ~63],
- ctx->buflen);
- }
+ ctx->buflen &= 63;
+ /* The regions in the following copy operation cannot overlap. */
+ memcpy (ctx->buffer,
+ &((char *) ctx->buffer)[(left_over + add) & ~63],
+ ctx->buflen);
+ }
buffer = (const char *) buffer + add;
len -= add;
# define alignof(type) offsetof (struct { char c; type x; }, x)
# define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
if (UNALIGNED_P (buffer))
- while (len > 64)
- {
- md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
- buffer = (const char *) buffer + 64;
- len -= 64;
- }
+ while (len > 64)
+ {
+ md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
+ buffer = (const char *) buffer + 64;
+ len -= 64;
+ }
else
#endif
- {
- md5_process_block (buffer, len & ~63, ctx);
- buffer = (const char *) buffer + (len & ~63);
- len &= 63;
- }
+ {
+ md5_process_block (buffer, len & ~63, ctx);
+ buffer = (const char *) buffer + (len & ~63);
+ len &= 63;
+ }
}
/* Move remaining bytes in internal buffer. */
memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
left_over += len;
if (left_over >= 64)
- {
- md5_process_block (ctx->buffer, 64, ctx);
- left_over -= 64;
- memcpy (ctx->buffer, &ctx->buffer[16], left_over);
- }
+ {
+ md5_process_block (ctx->buffer, 64, ctx);
+ left_over -= 64;
+ memcpy (ctx->buffer, &ctx->buffer[16], left_over);
+ }
ctx->buflen = left_over;
}
}
#include <gnutls/gnutls.h>
#include <gnutls/crypto.h>
#include <time.h>
-#include "timespec.h" /* gnulib gettime */
+#include "timespec.h" /* gnulib gettime */
static unsigned char data[64 * 1024];
}
- ret = gnutls_openpgp_crt_verify_self(crt, 0, &verify_status);
- if (ret < 0)
+ ret = gnutls_openpgp_crt_verify_self (crt, 0, &verify_status);
+ if (ret < 0)
{
- error (EXIT_FAILURE, 0, "verify signature error: %s", gnutls_strerror (ret));
+ error (EXIT_FAILURE, 0, "verify signature error: %s",
+ gnutls_strerror (ret));
}
if (verify_status & GNUTLS_CERT_INVALID)
}
else
{
- fprintf (outfile, "Self Signature verification: ok (%x)\n\n", verify_status);
+ fprintf (outfile, "Self Signature verification: ok (%x)\n\n",
+ verify_status);
}
size = sizeof (buffer);
int ret;
size_t size;
- if (info.outcert_format == GNUTLS_X509_FMT_PEM)
+ if (info.outcert_format == GNUTLS_X509_FMT_PEM)
{
ret = gnutls_x509_crq_print (crq, GNUTLS_CRT_PRINT_FULL, &cinfo);
if (ret < 0)
- error (EXIT_FAILURE, 0, "crq_print: %s", gnutls_strerror (ret));
+ error (EXIT_FAILURE, 0, "crq_print: %s", gnutls_strerror (ret));
fprintf (out, "%s\n", cinfo.data);
if (ret < 0)
error (EXIT_FAILURE, 0, "key_kp: %s", gnutls_strerror (ret));
}
- }
+ }
ret = gnutls_x509_crq_set_key (crq, key);
if (ret < 0)
fprintf (outfile, "\tVerification output: ");
print_verification_res (x509_cert_list[i - 2],
x509_cert_list[i - 1], x509_crl_list,
- x509_ncrls, GNUTLS_VERIFY_DO_NOT_ALLOW_SAME);
+ x509_ncrls,
+ GNUTLS_VERIFY_DO_NOT_ALLOW_SAME);
fprintf (outfile, ".\n\n");
}
x509_cert_list[x509_ncerts - 1], x509_crl_list,
/* we add GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT since it is
* self signed. */
- x509_ncrls, GNUTLS_VERIFY_DO_NOT_ALLOW_SAME|GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT);
+ x509_ncrls,
+ GNUTLS_VERIFY_DO_NOT_ALLOW_SAME |
+ GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT);
fprintf (outfile, ".\n\n");
&x509_cert_list[x509_ncerts - 1], 1,
x509_crl_list,
x509_ncrls,
- GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT|GNUTLS_VERIFY_DO_NOT_ALLOW_SAME,
+ GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT |
+ GNUTLS_VERIFY_DO_NOT_ALLOW_SAME,
&verify_status);
if (ret < 0)
error (EXIT_FAILURE, 0, "gnutls_x509_crt_list_verify: %s",
static void
print_verification_res (gnutls_x509_crt_t crt,
gnutls_x509_crt_t issuer,
- gnutls_x509_crl_t * crl_list, int crl_list_size, unsigned int flags)
+ gnutls_x509_crl_t * crl_list, int crl_list_size,
+ unsigned int flags)
{
unsigned int output;
int comma = 0;
int ret;
- ret = gnutls_x509_crt_verify (crt, &issuer, 1, flags , &output);
+ ret = gnutls_x509_crt_verify (crt, &issuer, 1, flags, &output);
if (ret < 0)
error (EXIT_FAILURE, 0, "verification error: %s", gnutls_strerror (ret));
}
-static int cert_verify_callback( gnutls_session_t session)
+static int
+cert_verify_callback (gnutls_session_t session)
{
-int rc;
-unsigned int status;
+ int rc;
+ unsigned int status;
if (!x509_cafile && !pgp_keyring)
return 0;
{
printf ("*** Verifying server certificate failed...\n");
if (!insecure)
- return -1;
+ return -1;
}
return 0;
if (FD_ISSET (fileno (stdin), &rset))
{
- if ((bytes = read (fileno(stdin), buffer, MAX_BUF - 1)) < 0)
+ if ((bytes = read (fileno (stdin), buffer, MAX_BUF - 1)) < 0)
{
if (hd.secure == 0)
{
}
else
{
- gnutls_alert_send_appropriate(socket->session, ret);
+ gnutls_alert_send_appropriate (socket->session, ret);
shutdown (socket->fd, SHUT_RDWR);
}
return ret;
#define HTTP_STATE_RESPONSE 2
#define HTTP_STATE_CLOSING 3
-LIST_TYPE_DECLARE (listener_item, char *http_request;
- char *http_response; int request_length;
- int response_length; int response_written;
- int http_state; int listen_socket;
- int fd; gnutls_session_t tls_session; int handshake_ok;);
+LIST_TYPE_DECLARE (listener_item, char *http_request; char *http_response;
+ int request_length; int response_length;
+ int response_written; int http_state;
+ int listen_socket; int fd;
+ gnutls_session_t tls_session;
+ int handshake_ok;
+ );
static const char *
safe_strerror (int value)
http_buffer = malloc (len);
if (http_buffer == NULL)
{
- free(crtinfo);
+ free (crtinfo);
return NULL;
}
strcat (http_buffer, "<hr><PRE>");
strcat (http_buffer, crtinfo);
strcat (http_buffer, "\n</PRE>\n");
- free(crtinfo);
+ free (crtinfo);
}
strcat (http_buffer, "<hr><P>Your HTTP header was:<PRE>");
}
else
{
- fprintf(stderr, "received: %s\n", request);
+ fprintf (stderr, "received: %s\n", request);
if (request[0] == request[1] && request[0] == '*')
- {
- if (strncmp(request, "**REHANDSHAKE**", sizeof("**REHANDSHAKE**")-1)==0)
- {
- fprintf(stderr, "*** Sending rehandshake request\n");
- gnutls_rehandshake(session);
- }
- *response = NULL;
- *response_length = 0;
- return;
- }
+ {
+ if (strncmp
+ (request, "**REHANDSHAKE**",
+ sizeof ("**REHANDSHAKE**") - 1) == 0)
+ {
+ fprintf (stderr, "*** Sending rehandshake request\n");
+ gnutls_rehandshake (session);
+ }
+ *response = NULL;
+ *response_length = 0;
+ return;
+ }
*response = strdup (request);
*response_length = ((*response) ? strlen (*response) : 0);
}
ret =
gnutls_alert_send_appropriate (j->tls_session, r);
}
- while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+ while (ret == GNUTLS_E_AGAIN
+ || ret == GNUTLS_E_INTERRUPTED);
j->http_state = HTTP_STATE_CLOSING;
}
else if (r == 0)
{
if (r == GNUTLS_E_REHANDSHAKE)
{
- fprintf(stderr, "*** Received hello message\n");
+ fprintf (stderr, "*** Received hello message\n");
do
{
r = gnutls_handshake (j->tls_session);
}
}
}
- else
- {
+ else
+ {
j->request_length = 0;
j->http_request[0] = 0;
- j->http_state = HTTP_STATE_REQUEST;
- }
+ j->http_state = HTTP_STATE_REQUEST;
+ }
}
}
lloopend (listener_list, j);
#define ALL_KX "+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+RSA-EXPORT"
#define INIT_STR "NONE:"
-static inline void _gnutls_priority_set_direct(gnutls_session_t session, const char* str)
+static inline void
+_gnutls_priority_set_direct (gnutls_session_t session, const char *str)
{
- const char* err;
- int ret = gnutls_priority_set_direct(session, str, &err);
-
- if (ret < 0)
+ const char *err;
+ int ret = gnutls_priority_set_direct (session, str, &err);
+
+ if (ret < 0)
{
- fprintf(stderr, "Error in %s\n", err);
- exit(1);
+ fprintf (stderr, "Error in %s\n", err);
+ exit (1);
}
}
buf[sizeof (buf) - 1] = 0;
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS ":"
+ ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, "+ARCFOUR-40:+RSA-EXPORT:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ "+ARCFOUR-40:+RSA-EXPORT:" ALL_COMP ":" ALL_CERTTYPES ":%s:"
+ ALL_MACS ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
if (verbose == 0 || export_true == 0)
return TEST_IGNORE;
- sprintf(prio_str, "+ARCFOUR-40:+RSA-EXPORT:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ "+ARCFOUR-40:+RSA-EXPORT:" ALL_COMP ":" ALL_CERTTYPES ":%s:"
+ ALL_MACS ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":+DHE-RSA:+DHE-DSS:"REST, protocol_str);
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":+DHE-RSA:+DHE-DSS:" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":%%INITIAL_SAFE_RENEGOTIATION", protocol_str);
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS ":"
+ ALL_KX ":%%INITIAL_SAFE_RENEGOTIATION", protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":+VERS-SSL3.0:"ALL_MACS":"ALL_KX":%%INITIAL_SAFE_RENEGOTIATION");
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":+VERS-SSL3.0:"
+ ALL_MACS ":" ALL_KX ":%%INITIAL_SAFE_RENEGOTIATION");
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
if (verbose == 0 || pubkey.data == NULL)
return TEST_IGNORE;
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":+DHE-RSA:+DHE-DSS:"REST, protocol_str);
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":+DHE-RSA:+DHE-DSS:" REST, protocol_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
test_ssl3 (gnutls_session_t session)
{
int ret;
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":+VERS-SSL3.0:"ALL_MACS":"ALL_KX":"REST);
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":+VERS-SSL3.0:"
+ ALL_MACS ":" ALL_KX ":" REST);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
signal (SIGALRM, got_alarm);
#endif
- sprintf(prio_str, ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS ":"
+ ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR "+AES-128-CBC:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST , protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+AES-128-CBC:" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR "+CAMELLIA-128-CBC:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+CAMELLIA-128-CBC:" ALL_COMP ":" ALL_CERTTYPES ":%s:"
+ ALL_MACS ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":+CTYPE-OPENPGP:%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":+CTYPE-OPENPGP:%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
#ifdef ENABLE_CAMELLIA
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
#else
- sprintf(prio_str, INIT_STR "+AES-128-CBC:"ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+AES-128-CBC:" ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":%s:" ALL_MACS ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
#endif
{
int ret;
- sprintf(prio_str, INIT_STR "+AES-128-CBC:"ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:+MD5:"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+AES-128-CBC:" ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":%s:+MD5:" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":+COMP-ZLIB:"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":+COMP-ZLIB:" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR "+AES-128-CBC:"ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:+SHA1:"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+AES-128-CBC:" ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":%s:+SHA1:" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR "+3DES-CBC:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+3DES-CBC:" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR "+ARCFOUR-128:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+ARCFOUR-128:" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR "+ARCFOUR-40:"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":""+RSA-EXPORT"":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR "+ARCFOUR-40:" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" "+RSA-EXPORT" ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":+VERS-TLS1.0:"ALL_MACS":"ALL_KX":"REST);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":+VERS-TLS1.0:" ALL_MACS ":" ALL_KX ":" REST);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":+VERS-TLS1.2:"ALL_MACS":"ALL_KX":"REST);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":+VERS-TLS1.2:" ALL_MACS ":" ALL_KX ":" REST);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":+VERS-TLS1.1:"ALL_MACS":"ALL_KX":"REST);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":+VERS-TLS1.1:" ALL_MACS ":" ALL_KX ":" REST);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
if (tls1_1_ok)
return TEST_IGNORE;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":+VERS-TLS1.1:+VERS-TLS1.0:+VERS-SSL3.0:"ALL_MACS":"ALL_KX":"REST);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES
+ ":+VERS-TLS1.1:+VERS-TLS1.0:+VERS-SSL3.0:" ALL_MACS ":" ALL_KX ":"
+ REST);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
if (tls1_ok != 0)
return TEST_IGNORE;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
/* disable TLS 1.0 */
if (ssl3_ok != 0)
{
- strcpy(protocol_str, "+VERS-SSL3.0");
+ strcpy (protocol_str, "+VERS-SSL3.0");
}
}
return ret;
* If the server is old, buggy and only supports
* SSL 3.0 then the handshake will fail.
*/
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":+RSA:"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":+RSA:" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
test_max_record_size (gnutls_session_t session)
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
gnutls_record_set_max_size (session, 512);
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
gnutls_record_set_max_size (session, 512);
* attacks which allow a version downgrade) and this
* connection will fail.
*/
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
_gnutls_record_set_default_version (session, 3, 0);
/* here we enable both SSL 3.0 and TLS 1.0
* and we connect using a 5.5 record version.
*/
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
_gnutls_record_set_default_version (session, 5, 5);
*
* A normal server would abort this handshake.
*/
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
_gnutls_rsa_pms_set_version (session, 5, 5); /* use SSL 5.5 version */
{
int ret;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":+ANON-DH:"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":+ANON-DH:" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_ANON, anon_cred);
if (session == NULL)
return TEST_IGNORE;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
if (verbose == 0)
return TEST_IGNORE;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
if (verbose == 0)
return TEST_IGNORE;
- sprintf(prio_str, INIT_STR ALL_CIPHERS":"ALL_COMP":"ALL_CERTTYPES":%s:"ALL_MACS":"ALL_KX":"REST, protocol_str);
+ sprintf (prio_str,
+ INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS
+ ":" ALL_KX ":" REST, protocol_str);
_gnutls_priority_set_direct (session, prio_str);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred);
} TLS_TEST;
static const TLS_TEST tls_tests[] = {
- {"for Safe renegotiation support", test_safe_renegotiation, "yes", "no", "dunno"},
- {"for Safe renegotiation support (SCSV)", test_safe_renegotiation_scsv, "yes", "no", "dunno"},
+ {"for Safe renegotiation support", test_safe_renegotiation, "yes", "no",
+ "dunno"},
+ {"for Safe renegotiation support (SCSV)", test_safe_renegotiation_scsv,
+ "yes", "no", "dunno"},
{"for TLS 1.2 support", test_tls1_2, "yes", "no", "dunno"},
{"for TLS 1.1 support", test_tls1_1, "yes", "no", "dunno"},
{"fallback from TLS 1.1 to", test_tls1_1_fallback, "TLS 1.0", "failed",
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
- if (debug) success ("client: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("client: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
gnutls_record_send (session, MSG, strlen (MSG));
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
{
printf ("- Received %d bytes: ", ret);
for (ii = 0; ii < ret; ii++)
- {
- fputc (buffer[ii], stdout);
- }
+ {
+ fputc (buffer[ii], stdout);
+ }
fputs ("\n", stdout);
}
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
gnutls_anon_allocate_server_credentials (&anoncred);
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
- if (debug) success ("server: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("server: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
/* print_info(session); */
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
void
if (ret != GNUTLS_E_ASN1_DER_ERROR)
fail ("crt3_import %d\n", ret);
- if (debug) success ("done\n");
+ if (debug)
+ success ("done\n");
gnutls_x509_crt_deinit (cert);
fprintf (stderr, "|<%d>| %s", level, str);
}
-void doit (void)
+void
+doit (void)
{
int exit_val = 0;
size_t i;
if (ret != 0)
{
fail ("%d: %s\n", ret, gnutls_strerror (ret));
- exit(EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
gnutls_global_set_log_function (tls_log_func);
gnutls_datum_t tmp;
size_t j;
- if (debug) printf ("Chain '%s' (%d)...\n", chains[i].name, (int) i);
+ if (debug)
+ printf ("Chain '%s' (%d)...\n", chains[i].name, (int) i);
for (j = 0; chains[i].chain[j]; j++)
{
- if (debug) printf ("\tAdding certificate %d...", (int) j);
+ if (debug)
+ printf ("\tAdding certificate %d...", (int) j);
ret = gnutls_x509_crt_init (&certs[j]);
if (ret < 0)
tmp.size = strlen (chains[i].chain[j]);
ret = gnutls_x509_crt_import (certs[j], &tmp, GNUTLS_X509_FMT_PEM);
- if (debug) printf ("done\n");
+ if (debug)
+ printf ("done\n");
if (ret < 0)
error (EXIT_FAILURE, 0, "gnutls_x509_crt_import[%d,%d]: %s",
(int) i, (int) j, gnutls_strerror (ret));
gnutls_x509_crt_print (certs[j], GNUTLS_CRT_PRINT_ONELINE, &tmp);
- if (debug) printf ("\tCertificate %d: %.*s\n", (int) j, tmp.size, tmp.data);
+ if (debug)
+ printf ("\tCertificate %d: %.*s\n", (int) j, tmp.size, tmp.data);
gnutls_free (tmp.data);
}
- if (debug) printf ("\tAdding CA certificate...");
+ if (debug)
+ printf ("\tAdding CA certificate...");
ret = gnutls_x509_crt_init (&ca);
if (ret < 0)
error (EXIT_FAILURE, 0, "gnutls_x509_crt_import: %s",
gnutls_strerror (ret));
- if (debug) printf ("done\n");
+ if (debug)
+ printf ("done\n");
gnutls_x509_crt_print (ca, GNUTLS_CRT_PRINT_ONELINE, &tmp);
- if (debug) printf ("\tCA Certificate: %.*s\n", tmp.size, tmp.data);
+ if (debug)
+ printf ("\tCA Certificate: %.*s\n", tmp.size, tmp.data);
gnutls_free (tmp.data);
- if (debug) printf ("\tVerifying...");
+ if (debug)
+ printf ("\tVerifying...");
ret = gnutls_x509_crt_list_verify (certs, j,
&ca, 1, NULL, 0,
&verify_status);
if (ret < 0)
error (EXIT_FAILURE, 0, "gnutls_x509_crt_list_verify[%d,%d]: %s",
- (int)i, (int)j, gnutls_strerror (ret));
+ (int) i, (int) j, gnutls_strerror (ret));
if (verify_status != chains[i].expected_verify_result)
{
- fail("verify_status: %d expected: %d",
- verify_status, chains[i].expected_verify_result);
-
- if (debug) exit(1);
+ fail ("verify_status: %d expected: %d",
+ verify_status, chains[i].expected_verify_result);
+
+ if (debug)
+ exit (1);
}
else if (debug)
printf ("done\n");
- if (debug) printf ("\tCleanup...");
+ if (debug)
+ printf ("\tCleanup...");
gnutls_x509_crt_deinit (ca);
for (j = 0; chains[i].chain[j]; j++)
gnutls_x509_crt_deinit (certs[j]);
- if (debug) printf ("done\n");
+ if (debug)
+ printf ("done\n");
}
gnutls_global_deinit ();
- if (debug) printf ("Exit status...%d\n", exit_val);
+ if (debug)
+ printf ("Exit status...%d\n", exit_val);
- exit(exit_val);
+ exit (exit_val);
}
s = 0;
ret = gnutls_x509_crq_get_challenge_password (crq, NULL, &s);
if (ret != 0 || s != 3)
- fail ("gnutls_x509_crq_get_challenge_password2 %d/%d\n", ret, (int)s);
+ fail ("gnutls_x509_crq_get_challenge_password2 %d/%d\n", ret, (int) s);
s = 10;
ret = gnutls_x509_crq_get_challenge_password (crq, smallbuf, &s);
if (ret != 0 || s != 3 || strcmp (smallbuf, "foo") != 0)
fail ("gnutls_x509_crq_get_challenge_password3 %d/%d/%s\n",
- ret,(int) s, smallbuf);
+ ret, (int) s, smallbuf);
s = 0;
ret = gnutls_x509_crq_get_extension_info (crq, 0, NULL, &s, NULL);
ret = gnutls_x509_crq_print (crq, GNUTLS_CRT_PRINT_FULL, &out);
if (ret != 0)
fail ("gnutls_x509_crq_print\n");
- if (debug) printf ("crq: %.*s\n", out.size, out.data);
+ if (debug)
+ printf ("crq: %.*s\n", out.size, out.data);
gnutls_free (out.data);
ret = gnutls_x509_crt_set_version (crt, 3);
ret = gnutls_x509_crt_print (crt, GNUTLS_CRT_PRINT_FULL, &out);
if (ret != 0)
fail ("gnutls_x509_crt_print\n");
- if (debug) printf ("crt: %.*s\n", out.size, out.data);
+ if (debug)
+ printf ("crt: %.*s\n", out.size, out.data);
gnutls_free (out.data);
gnutls_x509_crq_deinit (crq);
ret = memcmp (crq_key_id, pkey_key_id, crq_key_id_len);
if (ret == 0)
{
- if (debug) success ("Key ids are identical. OK.\n");
+ if (debug)
+ success ("Key ids are identical. OK.\n");
}
else
{
else
{
fail ("Key_id lengths differ incorrectly: %d - %d\n",
- (int)crq_key_id_len, (int)pkey_key_id_len);
+ (int) crq_key_id_len, (int) pkey_key_id_len);
}
{
ret = gnutls_x509_crt_init (&certs[i]);
if (ret < 0)
- error (EXIT_FAILURE, 0, "gnutls_x509_crt_init[%d]: %s", (int)i,
+ error (EXIT_FAILURE, 0, "gnutls_x509_crt_init[%d]: %s", (int) i,
gnutls_strerror (ret));
tmp.data = (char *) pem_certs[i];
ret = gnutls_x509_crt_import (certs[i], &tmp, GNUTLS_X509_FMT_PEM);
if (ret < 0)
- error (EXIT_FAILURE, 0, "gnutls_x509_crt_import[%d]: %s", (int)i,
+ error (EXIT_FAILURE, 0, "gnutls_x509_crt_import[%d]: %s", (int) i,
gnutls_strerror (ret));
}
GNUTLS_VERIFY_DISABLE_TIME_CHECKS,
&verify_status);
if (ret < 0)
- error (EXIT_FAILURE, 0, "gnutls_x509_crt_list_verify[%d]: %s", (int)i,
+ error (EXIT_FAILURE, 0, "gnutls_x509_crt_list_verify[%d]: %s", (int) i,
gnutls_strerror (ret));
if (verify_status != (GNUTLS_CERT_SIGNER_NOT_FOUND | GNUTLS_CERT_INVALID))
GNUTLS_VERIFY_DISABLE_TIME_CHECKS,
&verify_status);
if (ret < 0)
- error (EXIT_FAILURE, 0, "gnutls_x509_crt_list_verify[%d]: %s", (int)i,
+ error (EXIT_FAILURE, 0, "gnutls_x509_crt_list_verify[%d]: %s", (int) i,
gnutls_strerror (ret));
if (verify_status != 0)
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
gnutls_record_send (session, MSG, strlen (MSG));
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
{
printf ("- Received %d bytes: ", ret);
for (ii = 0; ii < ret; ii++)
- fputc (buffer[ii], stdout);
+ fputc (buffer[ii], stdout);
fputs ("\n", stdout);
}
static int
pskfunc (gnutls_session_t session, const char *username, gnutls_datum_t * key)
{
- if (debug) printf ("psk callback to get %s's password\n", username);
+ if (debug)
+ printf ("psk callback to get %s's password\n", username);
key->data = gnutls_malloc (4);
key->data[0] = 0xDE;
key->data[1] = 0xAD;
static void
server_start (void)
{
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
/* Socket operations
*/
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
/* see the Getting peer's information example */
/* print_info(session); */
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
void
print_dn (xdn);
}
- if (debug) success ("done\n");
+ if (debug)
+ success ("done\n");
gnutls_x509_crt_deinit (cert);
gnutls_global_deinit ();
if (out.size != strlen (info) || strcmp (out.data, info) != 0)
fail ("comparison fail (%d/%d)\nexpect: %s\n got: %.*s\n",
- out.size, (int)strlen (info), info, out.size, out.data);
+ out.size, (int) strlen (info), info, out.size, out.data);
gnutls_x509_crt_deinit (cert);
gnutls_global_deinit ();
gnutls_free (out.data);
- if (debug) success ("done\n");
+ if (debug)
+ success ("done\n");
}
static ssize_t
client_pull (gnutls_transport_ptr_t tr, void *data, size_t len)
{
- if (debug) success ("client_pull len %d has %d\n", (int)len, (int)to_client_len);
+ if (debug)
+ success ("client_pull len %d has %d\n", (int) len, (int) to_client_len);
if (to_client_len < len)
{
size_t newlen = to_server_len + len;
char *tmp;
- if (debug)
+ if (debug)
{
- success ("client_push len %d has %d\n", (int)len, (int)to_server_len);
+ success ("client_push len %d has %d\n", (int) len, (int) to_server_len);
hexprint (data, len);
}
static ssize_t
server_pull (gnutls_transport_ptr_t tr, void *data, size_t len)
{
- if (debug) success ("server_pull len %d has %d\n", (int)len, (int)to_server_len);
+ if (debug)
+ success ("server_pull len %d has %d\n", (int) len, (int) to_server_len);
if (to_server_len < len)
{
size_t newlen = to_client_len + len;
char *tmp;
- if (debug)
+ if (debug)
{
- success ("server_push len %d has %d\n", (int)len, (int)to_client_len);
+ success ("server_push len %d has %d\n", (int) len, (int) to_client_len);
hexprint (data, len);
}
client_finished_callback (gnutls_session_t session,
const void *finished, size_t len)
{
- if (debug)
+ if (debug)
{
- success ("client finished (length %d)\n", (int)len);
+ success ("client finished (length %d)\n", (int) len);
hexprint (finished, len);
}
}
server_finished_callback (gnutls_session_t session,
const void *finished, size_t len)
{
- if (debug)
+ if (debug)
{
- success ("server finished (length %d)\n", (int)len);
+ success ("server finished (length %d)\n", (int) len);
hexprint (finished, len);
}
}
{
if (cret == GNUTLS_E_AGAIN)
{
- if (debug) success ("loop invoking client:\n");
+ if (debug)
+ success ("loop invoking client:\n");
cret = gnutls_handshake (client);
- if (debug) success ("client %d: %s\n", cret, gnutls_strerror (cret));
+ if (debug)
+ success ("client %d: %s\n", cret, gnutls_strerror (cret));
}
if (sret == GNUTLS_E_AGAIN)
{
- if (debug) success ("loop invoking server:\n");
+ if (debug)
+ success ("loop invoking server:\n");
sret = gnutls_handshake (server);
- if (debug) success ("server %d: %s\n", sret, gnutls_strerror (sret));
+ if (debug)
+ success ("server %d: %s\n", sret, gnutls_strerror (sret));
}
}
while (cret == GNUTLS_E_AGAIN || sret == GNUTLS_E_AGAIN);
- if (debug) success ("Handshake established\n");
+ if (debug)
+ success ("Handshake established\n");
ns = gnutls_record_send (client, MSG, strlen (MSG));
- if (debug) success ("client: sent %d\n", (int)ns);
+ if (debug)
+ success ("client: sent %d\n", (int) ns);
ret = gnutls_record_recv (server, buffer, MAX_BUF);
if (ret == 0)
}
ns = gnutls_record_send (server, MSG, strlen (MSG));
- if (debug) success ("server: sent %d\n", (int)ns);
+ if (debug)
+ success ("server: sent %d\n", (int) ns);
ret = gnutls_record_recv (client, buffer, MAX_BUF);
if (ret == 0)
{
if (memcmp (digest, "\x3c\xb0\x9d\x83\x28\x01\xef\xc0"
"\x7b\xb3\xaf\x42\x69\xe5\x93\x9a", 16) == 0)
- {
- if (debug) success ("_gnutls_hmac_fast(MD5) OK\n");
- }
+ {
+ if (debug)
+ success ("_gnutls_hmac_fast(MD5) OK\n");
+ }
else
{
hexprint (digest, 16);
if (memcmp (digest, "\x58\x93\x7a\x58\xfe\xea\x82\xf8"
"\x0e\x64\x62\x01\x40\x2b\x2c\xed\x5d\x54\xc1\xfa",
20) == 0)
- {
- if (debug) success ("_gnutls_hmac_fast(SHA1) OK\n");
- }
+ {
+ if (debug)
+ success ("_gnutls_hmac_fast(SHA1) OK\n");
+ }
else
{
hexprint (digest, 20);
if (memcmp (digest, "\x09\xb7\x85\x57\xdd\xf6\x07\x15"
"\x1c\x52\x34\xde\xba\x5c\xdc\x59", 16) == 0)
{
- if (debug) success ("_gnutls_pkcs5_pbkdf2_sha1() OK\n");
- }
+ if (debug)
+ success ("_gnutls_pkcs5_pbkdf2_sha1() OK\n");
+ }
else
{
hexprint (digest, 16);
fail ("gnutls_openpgp_crt_init: %d\n", ret);
#endif
- if (debug) success ("Testing pem1...\n");
+ if (debug)
+ success ("Testing pem1...\n");
data.data = pem1;
data.size = strlen (pem1);
if (ret)
fail ("Hostname incorrectly matches (%d)\n", ret);
- if (debug) success ("Testing pem2...\n");
+ if (debug)
+ success ("Testing pem2...\n");
data.data = pem2;
data.size = strlen (pem2);
if (ret)
fail ("Hostname incorrectly matches (%d)\n", ret);
- if (debug) success ("Testing pem3...\n");
+ if (debug)
+ success ("Testing pem3...\n");
data.data = pem3;
data.size = strlen (pem3);
if (ret)
fail ("Hostname incorrectly matches (%d)\n", ret);
- if (debug) success ("Testing pem4...\n");
+ if (debug)
+ success ("Testing pem4...\n");
data.data = pem4;
data.size = strlen (pem4);
if (ret)
fail ("Hostname incorrectly matches (%d)\n", ret);
- if (debug) success ("Testing pem5...\n");
+ if (debug)
+ success ("Testing pem5...\n");
data.data = pem5;
data.size = strlen (pem5);
if (ret)
fail ("Hostname incorrectly matches (%d)\n", ret);
- if (debug) success ("Testing pem6...\n");
+ if (debug)
+ success ("Testing pem6...\n");
data.data = pem6;
data.size = strlen (pem6);
if (!ret)
fail ("Hostname incorrectly does not match (%d)\n", ret);
- if (debug) success ("Testing pem7...\n");
+ if (debug)
+ success ("Testing pem7...\n");
data.data = pem7;
data.size = strlen (pem7);
if (!ret)
fail ("Hostname incorrectly does not match (%d)\n", ret);
- if (debug) success ("Testing pem8...\n");
+ if (debug)
+ success ("Testing pem8...\n");
data.data = pem8;
data.size = strlen (pem8);
if (ret)
fail ("Hostname incorrectly matches (%d)\n", ret);
- if (debug) success ("Testing pem9...\n");
+ if (debug)
+ success ("Testing pem9...\n");
data.data = pem9;
data.size = strlen (pem9);
if (!ret)
fail ("Hostname incorrectly does not match (%d)\n", ret);
- if (debug) success ("Testing pem10...\n");
+ if (debug)
+ success ("Testing pem10...\n");
data.data = pem10;
data.size = strlen (pem10);
fail ("Hostname incorrectly matches (%d)\n", ret);
#ifdef ENABLE_OPENPGP
- if (debug) success ("Testing pem11...\n");
+ if (debug)
+ success ("Testing pem11...\n");
data.data = pem11;
data.size = strlen (pem11);
gnutls_global_deinit ();
- if (debug) success ("init-deinit round-trip success\n");
+ if (debug)
+ success ("init-deinit round-trip success\n");
}
}
while (cret == GNUTLS_E_AGAIN || sret == GNUTLS_E_AGAIN);
handshake = 0;
- if (debug) success ("Handshake established\n");
+ if (debug)
+ success ("Handshake established\n");
ns = gnutls_record_send (client, MSG, strlen (MSG));
//success ("client: sent %d\n", ns);
else
{
transferred += ret;
- if (debug) fputs ("*", stdout);
+ if (debug)
+ fputs ("*", stdout);
}
ns = gnutls_record_send (server, MSG, strlen (MSG));
else
{
transferred += ret;
- if (debug) fputs (".", stdout);
+ if (debug)
+ fputs (".", stdout);
}
}
while (transferred < 7000);
- if (debug) fputs ("\n", stdout);
+ if (debug)
+ fputs ("\n", stdout);
gnutls_bye (client, GNUTLS_SHUT_RDWR);
gnutls_bye (server, GNUTLS_SHUT_RDWR);
client_pull (gnutls_transport_ptr_t tr, void *data, size_t len)
{
if (debug)
- success ("client_pull len %d has %d\n", (int)len, (int)to_client_len);
+ success ("client_pull len %d has %d\n", (int) len, (int) to_client_len);
if (to_client_len < len)
{
if (debug)
{
- success ("client_push len %d has %d\n", (int)len, (int)to_server_len);
+ success ("client_push len %d has %d\n", (int) len, (int) to_server_len);
hexprint (data, len);
}
server_pull (gnutls_transport_ptr_t tr, void *data, size_t len)
{
if (debug)
- success ("server_pull len %d has %d\n", (int)len, (int)to_server_len);
+ success ("server_pull len %d has %d\n", (int) len, (int) to_server_len);
if (to_server_len < len)
{
if (debug)
{
- success ("server_push len %d has %d\n", (int)len, (int)to_client_len);
+ success ("server_push len %d has %d\n", (int) len, (int) to_client_len);
hexprint (data, len);
}
if (debug)
success ("loop invoking client:\n");
cret = gnutls_handshake (client);
- if (debug) success ("client %d: %s\n", cret, gnutls_strerror (cret));
+ if (debug)
+ success ("client %d: %s\n", cret, gnutls_strerror (cret));
}
if (sret == GNUTLS_E_AGAIN)
{
- if (debug) success ("loop invoking server:\n");
+ if (debug)
+ success ("loop invoking server:\n");
sret = gnutls_handshake (server);
- if (debug) success ("server %d: %s\n", sret, gnutls_strerror (sret));
+ if (debug)
+ success ("server %d: %s\n", sret, gnutls_strerror (sret));
}
}
while (cret == GNUTLS_E_AGAIN || sret == GNUTLS_E_AGAIN);
- if (debug) success ("Handshake established\n");
+ if (debug)
+ success ("Handshake established\n");
ns = gnutls_record_send (client, MSG, strlen (MSG));
- if (debug) success ("client: sent %d\n", (int)ns);
+ if (debug)
+ success ("client: sent %d\n", (int) ns);
ret = gnutls_record_recv (server, buffer, MAX_BUF);
if (ret == 0)
}
ns = gnutls_record_send (server, MSG, strlen (MSG));
- if (debug) success ("server: sent %d\n", (int)ns);
+ if (debug)
+ success ("server: sent %d\n", (int) ns);
ret = gnutls_record_recv (client, buffer, MAX_BUF);
if (ret == 0)
else
{
if (debug)
- {
- printf ("client: received %d: ", ret);
- for (n = 0; n < ret; n++)
+ {
+ printf ("client: received %d: ", ret);
+ for (n = 0; n < ret; n++)
fputc (buffer[n], stdout);
- fputs ("\n", stdout);
- }
+ fputs ("\n", stdout);
+ }
}
gnutls_bye (client, GNUTLS_SHUT_RDWR);
if (gnutls_psk_netconf_derive_key ("password", "psk_identity",
"psk_identity_hint", &key) == 0)
{
- if (debug) success ("success: gnutls_psk_netconf_derive_key\n");
+ if (debug)
+ success ("success: gnutls_psk_netconf_derive_key\n");
}
else
fail ("gnutls_psk_netconf_derive_key failure\n");
if (key.size == 20 && memcmp (key.data, known, 20) == 0)
{
- if (debug) success ("success: match.\n");
+ if (debug)
+ success ("success: match.\n");
}
else
fail ("FAIL: key differ.\n");
#include <gnutls/gnutls.h>
#include <gnutls/x509.h>
-#include "utils.h"
+#include "utils.h"
/* Thanks to Tomas Hoger <thoger@redhat.com> for generating the two
certs that trigger this bug. */
badguy_nul_san_data, sizeof (badguy_nul_san_data)
};
-void doit(void)
+void
+doit (void)
{
gnutls_x509_crt_t crt;
int ret;
if (ret < 0)
{
fail ("gnutls_global_init");
- exit(1);
+ exit (1);
}
ret = gnutls_x509_crt_init (&crt);
if (ret != 0)
{
- fail("gnutls_x509_crt_init");
- exit(1);
+ fail ("gnutls_x509_crt_init");
+ exit (1);
}
ret = gnutls_x509_crt_import (crt, &badguy_nul_cn, GNUTLS_X509_FMT_PEM);
if (ret < 0)
{
- fail("gnutls_x509_crt_import");
- exit(1);
+ fail ("gnutls_x509_crt_import");
+ exit (1);
}
ret = gnutls_x509_crt_check_hostname (crt, "www.bank.com");
if (ret == 0)
{
- if (debug) success("gnutls_x509_crt_check_hostname OK (NUL-IN-CN)");
+ if (debug)
+ success ("gnutls_x509_crt_check_hostname OK (NUL-IN-CN)");
}
else
{
- fail("gnutls_x509_crt_check_hostname BROKEN (NUL-IN-CN)");
+ fail ("gnutls_x509_crt_check_hostname BROKEN (NUL-IN-CN)");
}
ret = gnutls_x509_crt_import (crt, &badguy_nul_san, GNUTLS_X509_FMT_PEM);
if (ret < 0)
{
fail ("gnutls_x509_crt_import");
- exit(1);
+ exit (1);
}
ret = gnutls_x509_crt_check_hostname (crt, "www.bank.com");
if (ret == 0)
{
- if (debug) success("gnutls_x509_crt_check_hostname OK (NUL-IN-SAN)");
+ if (debug)
+ success ("gnutls_x509_crt_check_hostname OK (NUL-IN-SAN)");
}
else
{
- fail("gnutls_x509_crt_check_hostname BROKEN (NUL-IN-SAN)");
+ fail ("gnutls_x509_crt_check_hostname BROKEN (NUL-IN-SAN)");
}
gnutls_x509_crt_deinit (crt);
if (ret != 0)
fail ("keyring-check-id second key %d\n", ret);
- if (debug) success ("done\n");
+ if (debug)
+ success ("done\n");
gnutls_openpgp_keyring_deinit (keyring);
gnutls_global_deinit ();
/* sets the trusted cas file
*/
- if (debug) success ("Setting key files...\n");
+ if (debug)
+ success ("Setting key files...\n");
ret = gnutls_certificate_set_openpgp_key_mem (xcred, &cert, &key,
GNUTLS_OPENPGP_FMT_BASE64);
/* connect to the peer
*/
- if (debug) success ("Connecting...\n");
+ if (debug)
+ success ("Connecting...\n");
sd = tcp_connect ();
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
gnutls_perror (ret);
goto end;
}
- else if (debug)
+ else if (debug)
{
success ("client: Handshake was completed\n");
}
- if (debug) success ("client: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("client: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
gnutls_record_send (session, MSG, strlen (MSG));
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
if (debug)
{
- printf ("- Received %d bytes: ", ret);
- for (ii = 0; ii < ret; ii++)
- {
- fputc (buffer[ii], stdout);
- }
- fputs ("\n", stdout);
+ printf ("- Received %d bytes: ", ret);
+ for (ii = 0; ii < ret; ii++)
+ {
+ fputc (buffer[ii], stdout);
+ }
+ fputs ("\n", stdout);
}
gnutls_bye (session, GNUTLS_SHUT_RDWR);
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
fail ("Could not set server key files...\n");
}
- if (debug) success ("Launched, setting DH parameters...\n");
+ if (debug)
+ success ("Launched, setting DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
- if (debug) success ("server: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("server: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
i = 0;
for (;;)
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
gnutls_global_deinit ();
- if (debug) success ("import ok\n");
+ if (debug)
+ success ("import ok\n");
}
"PfqUpIhz5Bbm7J4=\n" "-----END CERTIFICATE-----\n";
const gnutls_datum_t ca_dat = { ca_pem, sizeof (ca_pem) };
-void doit(void)
+void
+doit (void)
{
gnutls_pkcs12_t pkcs12;
gnutls_x509_crt_t client;
if (ret < 0)
error (EXIT_FAILURE, 0, "pkcs12_export: %d", ret);
- if (debug) fwrite (outbuf, size, 1, stdout);
+ if (debug)
+ fwrite (outbuf, size, 1, stdout);
/* Cleanup. */
gnutls_pkcs12_deinit (pkcs12);
if (debug)
printf ("ij: %d.%d: %s\n", i, j,
- _gnutls_bin2hex (key, sizeof (key), tmp, sizeof (tmp)));
+ _gnutls_bin2hex (key, sizeof (key), tmp, sizeof (tmp)));
x++;
}
}
- if (debug) printf ("\n");
+ if (debug)
+ printf ("\n");
for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
{
fail ("_gnutls_pkcs12_string_to_key failed[3]\n");
if (debug)
- printf ("tv[%d]: %s\n", i,
- _gnutls_bin2hex (key, tv[i].keylen, tmp, sizeof (tmp)));
+ printf ("tv[%d]: %s\n", i,
+ _gnutls_bin2hex (key, tv[i].keylen, tmp, sizeof (tmp)));
}
- if (debug) printf ("\n");
+ if (debug)
+ printf ("\n");
gnutls_global_deinit ();
- if (debug) success ("_gnutls_pkcs12_string_to_key ok\n");
+ if (debug)
+ success ("_gnutls_pkcs12_string_to_key ok\n");
}
keys[i].password, 0);
if (ret != keys[i].expected_result)
{
- printf ("fail[%d]: %d: %s\n", (int)i, ret, gnutls_strerror (ret));
+ printf ("fail[%d]: %d: %s\n", (int) i, ret, gnutls_strerror (ret));
return 1;
}
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
gnutls_record_send (session, MSG, strlen (MSG));
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
static int
pskfunc (gnutls_session_t session, const char *username, gnutls_datum_t * key)
{
- if (debug) printf ("psk: username %s\n", username);
+ if (debug)
+ printf ("psk: username %s\n", username);
key->data = gnutls_malloc (4);
key->data[0] = 0xDE;
key->data[1] = 0xAD;
static void
server_start (void)
{
- if (debug) success ("Launched...\n");
+ if (debug)
+ success ("Launched...\n");
/* Socket operations
*/
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
/* see the Getting peer's information example */
/* print_info(session); */
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
void
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
if (t == 0)
if (gnutls_session_is_resumed (session) != 0)
{
if (params->expect_resume)
- {
- if (debug) success ("- Previous session was resumed\n");
- }
+ {
+ if (debug)
+ success ("- Previous session was resumed\n");
+ }
else
fail ("- Previous session was resumed\n");
}
if (params->expect_resume)
fail ("*** Previous session was NOT resumed\n");
else
- {
- if (debug) success ("*** Previous session was NOT resumed (expected)\n");
- }
+ {
+ if (debug)
+ success
+ ("*** Previous session was NOT resumed (expected)\n");
+ }
}
}
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
global_stop (void)
{
- if (debug) success ("global stop\n");
+ if (debug)
+ success ("global stop\n");
gnutls_anon_free_server_credentials (anoncred);
gnutls_global_init ();
gnutls_anon_allocate_server_credentials (&anoncred);
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
/* see the Getting peer's information example */
/* print_info(session); */
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_free (session_ticket_key.data);
session_ticket_key.data = NULL;
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
void
for (i = 0; resume_tests[i].desc; i++)
{
- if (debug) printf ("%s\n", resume_tests[i].desc);
+ if (debug)
+ printf ("%s\n", resume_tests[i].desc);
global_start ();
if (error_count)
static int
wrap_db_store (void *dbf, gnutls_datum_t key, gnutls_datum_t data)
{
- if (debug) success ("resume db storing... (%d-%d)\n", key.size, data.size);
+ if (debug)
+ success ("resume db storing... (%d-%d)\n", key.size, data.size);
if (debug)
{
gnutls_datum_t res = { NULL, 0 };
int i;
- if (debug) success ("resume db fetch... (%d)\n", key.size);
+ if (debug)
+ success ("resume db fetch... (%d)\n", key.size);
if (debug)
{
unsigned int i;
if (key.size == cache_db[i].session_id_size &&
memcmp (key.data, cache_db[i].session_id, key.size) == 0)
{
- if (debug) success ("resume db fetch... return info\n");
+ if (debug)
+ success ("resume db fetch... return info\n");
res.size = cache_db[i].session_data_size;
if (!password)
password = "foobar";
- if (debug) success ("Reading PKCS#12 blob from `%s' using password `%s'.\n",
- file, password);
+ if (debug)
+ success ("Reading PKCS#12 blob from `%s' using password `%s'.\n",
+ file, password);
ret = gnutls_certificate_set_x509_simple_pkcs12_file (x509cred,
file,
GNUTLS_X509_FMT_DER,
if (ret < 0)
fail ("x509_pkcs12 failed %d: %s\n", ret, gnutls_strerror (ret));
- if (debug) success ("Read file OK\n");
+ if (debug)
+ success ("Read file OK\n");
gnutls_certificate_free_credentials (x509cred);
if (!password)
password = "";
- if (debug) success ("Reading PKCS#12 blob from `%s' using password `%s'.\n",
- file, password);
+ if (debug)
+ success ("Reading PKCS#12 blob from `%s' using password `%s'.\n",
+ file, password);
ret = gnutls_certificate_set_x509_simple_pkcs12_file (x509cred,
file,
GNUTLS_X509_FMT_DER,
if (ret < 0)
fail ("x509_pkcs12 failed %d: %s\n", ret, gnutls_strerror (ret));
- if (debug) success ("Read file OK\n");
+ if (debug)
+ success ("Read file OK\n");
gnutls_certificate_free_credentials (x509cred);
void
doit (void)
{
- if (debug)
+ if (debug)
{
printf ("GnuTLS header version %s.\n", GNUTLS_VERSION);
printf ("GnuTLS library version %s.\n", gnutls_check_version (NULL));
for (i = 0; algs[i]; i++)
{
- if (debug) printf ("pk_list[%d] = %d = %s = %d\n", (int)i, algs[i],
- gnutls_pk_algorithm_get_name (algs[i]),
- gnutls_pk_get_id (gnutls_pk_algorithm_get_name (algs[i])));
+ if (debug)
+ printf ("pk_list[%d] = %d = %s = %d\n", (int) i, algs[i],
+ gnutls_pk_algorithm_get_name (algs[i]),
+ gnutls_pk_get_id (gnutls_pk_algorithm_get_name (algs[i])));
if (gnutls_pk_get_id (gnutls_pk_algorithm_get_name (algs[i]))
!= algs[i])
fail ("gnutls_pk id's doesn't match\n");
if (pk != GNUTLS_PK_UNKNOWN)
fail ("gnutls_pk unknown test failed (%d)\n", pk);
- if (debug) success ("gnutls_pk_list ok\n");
+ if (debug)
+ success ("gnutls_pk_list ok\n");
}
{
for (i = 0; algs[i]; i++)
{
if (debug)
- printf ("sign_list[%d] = %d = %s = %d\n", (int)i, algs[i],
- gnutls_sign_algorithm_get_name (algs[i]),
- gnutls_sign_get_id (gnutls_sign_algorithm_get_name
- (algs[i])));
+ printf ("sign_list[%d] = %d = %s = %d\n", (int) i, algs[i],
+ gnutls_sign_algorithm_get_name (algs[i]),
+ gnutls_sign_get_id (gnutls_sign_algorithm_get_name
+ (algs[i])));
if (gnutls_sign_get_id (gnutls_sign_algorithm_get_name (algs[i])) !=
algs[i])
fail ("gnutls_sign id's doesn't match\n");
if (pk != GNUTLS_PK_UNKNOWN)
fail ("gnutls_sign unknown test failed (%d)\n", pk);
- if (debug) success ("gnutls_sign_list ok\n");
+ if (debug)
+ success ("gnutls_sign_list ok\n");
}
}
if (debug)
{
if (last)
- printf ("client: received %d bytes AVP: `%.*s'\n",
- (int)lastlen, (int) lastlen, last);
+ printf ("client: received %d bytes AVP: `%.*s'\n",
+ (int) lastlen, (int) lastlen, last);
else
- printf ("client: new application phase\n");
+ printf ("client: new application phase\n");
}
switch (iter)
return -1;
*newlen = strlen (*new);
- if (debug) printf ("client: sending %d bytes AVP: `%s'\n", (int)*newlen, *new);
+ if (debug)
+ printf ("client: sending %d bytes AVP: `%s'\n", (int) *newlen, *new);
gnutls_ia_permute_inner_secret (session, 3, "foo");
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
/*
fail ("client: No TLS/IA negotiation\n");
else
{
- if (debug) success ("client: TLS/IA handshake\n");
+ if (debug)
+ success ("client: TLS/IA handshake\n");
ret = gnutls_ia_handshake (session);
}
else
{
- if (debug) success ("client: TLS/IA Handshake was completed\n");
+ if (debug)
+ success ("client: TLS/IA Handshake was completed\n");
}
}
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
if (last && debug)
printf ("server: received %d bytes AVP: `%.*s'\n",
- (int)lastlen, (int) lastlen, last);
+ (int) lastlen, (int) lastlen, last);
gnutls_ia_permute_inner_secret (session, 3, "foo");
if (strcmp (p, "1") == 0)
{
- if (debug) success ("server: Sending IntermediatePhaseFinished...\n");
+ if (debug)
+ success ("server: Sending IntermediatePhaseFinished...\n");
return 1;
}
if (strcmp (p, "2") == 0)
{
- if (debug) success ("server: Sending FinalPhaseFinished...\n");
+ if (debug)
+ success ("server: Sending FinalPhaseFinished...\n");
return 2;
}
return -1;
*newlen = strlen (*new);
- if (debug) printf ("server: sending %d bytes AVP: `%s'\n", (int)*newlen, *new);
+ if (debug)
+ printf ("server: sending %d bytes AVP: `%s'\n", (int) *newlen, *new);
return 0;
}
return;
}
- if (debug) success ("server: ready. Listening to port '%d'\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'\n", PORT);
}
static void
gnutls_anon_allocate_server_credentials (&anoncred);
gnutls_ia_allocate_server_credentials (&iacred);
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
if (!gnutls_ia_handshake_p (session))
fail ("server: No TLS/IA negotiation\n");
else
{
- if (debug) success ("server: TLS/IA handshake\n");
+ if (debug)
+ success ("server: TLS/IA handshake\n");
ret = gnutls_ia_handshake (session);
}
else
{
- if (debug) success ("server: TLS/IA Handshake was completed\n");
+ if (debug)
+ success ("server: TLS/IA Handshake was completed\n");
}
}
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
void
{
size_t i;
- printf (" (length %d bytes):\n\t", (int)len);
+ printf (" (length %d bytes):\n\t", (int) len);
for (i = 0; i < len; i++)
{
if (((str[i] & 0xFF) >= 'A' && (str[i] & 0xFF) <= 'Z') ||
fail ("unexpected number of alt names: %i\n", alt_name_count);
}
- if (debug) success ("done\n");
+ if (debug)
+ success ("done\n");
gnutls_x509_crt_deinit (cert);
gnutls_global_deinit ();
return -1;
}
- if (debug) success ("client: invoked to provide client cert.\n");
+ if (debug)
+ success ("client: invoked to provide client cert.\n");
result = gnutls_x509_dn_init (&dn);
if (result < 0)
{
gnutls_x509_ava_st val;
- if (debug) success ("client: imported DN.\n");
+ if (debug)
+ success ("client: imported DN.\n");
if (gnutls_x509_dn_get_rdn_ava (dn, 0, 0, &val) == 0)
{
- if (debug) success ("client: got RDN 0.\n");
+ if (debug)
+ success ("client: got RDN 0.\n");
if (val.value.size == strlen (EXPECT_RDN0)
&& strncmp (val.value.data, EXPECT_RDN0, val.value.size) == 0)
{
- if (debug) success ("client: RND 0 correct.\n");
+ if (debug)
+ success ("client: RND 0 correct.\n");
}
else
{
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
- if (debug) success ("client: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("client: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
gnutls_record_send (session, MSG, strlen (MSG));
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
{
printf ("- Received %d bytes: ", ret);
for (ii = 0; ii < ret; ii++)
- {
- fputc (buffer[ii], stdout);
- }
+ {
+ fputc (buffer[ii], stdout);
+ }
fputs ("\n", stdout);
}
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key,
GNUTLS_X509_FMT_PEM);
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
- if (debug) success ("server: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("server: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
i = 0;
for (;;)
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
success ("client: Handshake was completed\n");
}
- if (debug) success ("client: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("client: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
ret = gnutls_record_send (session, MSG, strlen (MSG));
if (ret == strlen (MSG))
{
- if (debug) success ("client: sent record.\n");
+ if (debug)
+ success ("client: sent record.\n");
}
else
{
ret = gnutls_record_recv (session, buffer, MAX_BUF);
- if (debug) success ("client: recv returned %d.\n", ret);
+ if (debug)
+ success ("client: recv returned %d.\n", ret);
if (ret == GNUTLS_E_REHANDSHAKE)
{
- if (debug) success ("client: doing handshake!\n");
+ if (debug)
+ success ("client: doing handshake!\n");
ret = gnutls_handshake (session);
if (ret == 0)
{
- if (debug) success ("client: handshake complete, reading again.\n");
+ if (debug)
+ success ("client: handshake complete, reading again.\n");
ret = gnutls_record_recv (session, buffer, MAX_BUF);
}
else
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
goto end;
}
- if (debug)
+ if (debug)
{
printf ("- Received %d bytes: ", ret);
for (ii = 0; ii < ret; ii++)
- {
- fputc (buffer[ii], stdout);
- }
+ {
+ fputc (buffer[ii], stdout);
+ }
fputs ("\n", stdout);
}
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key,
GNUTLS_X509_FMT_PEM);
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
{
success ("server: Handshake was completed\n");
success ("server: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
}
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
i = 0;
for (;;)
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_certificate_server_set_request (session,
GNUTLS_CERT_REQUEST);
- if (debug) success ("server: got data, forcing rehandshake.\n");
+ if (debug)
+ success ("server: got data, forcing rehandshake.\n");
ret = gnutls_rehandshake (session);
if (ret < 0)
break;
}
- if (debug) success ("server: rehandshake complete.\n");
+ if (debug)
+ success ("server: rehandshake complete.\n");
/* echo data back to the client
*/
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
for (i = 0; i < sizeof (key_dat) / sizeof (key_dat[0]); i++)
{
- if (debug) success ("loop %d\n", (int)i);
+ if (debug)
+ success ("loop %d\n", (int) i);
ret = gnutls_x509_privkey_init (&key);
if (ret < 0)
}
else
{
- if (debug) success ("client: Handshake was completed\n");
+ if (debug)
+ success ("client: Handshake was completed\n");
}
- if (debug) success ("client: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("client: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
gnutls_record_send (session, MSG, strlen (MSG));
ret = gnutls_record_recv (session, buffer, MAX_BUF);
if (ret == 0)
{
- if (debug) success ("client: Peer has closed the TLS connection\n");
+ if (debug)
+ success ("client: Peer has closed the TLS connection\n");
goto end;
}
else if (ret < 0)
{
printf ("- Received %d bytes: ", ret);
for (ii = 0; ii < ret; ii++)
- {
- fputc (buffer[ii], stdout);
- }
+ {
+ fputc (buffer[ii], stdout);
+ }
fputs ("\n", stdout);
}
return;
}
- if (debug) success ("server: ready. Listening to port '%d'.\n", PORT);
+ if (debug)
+ success ("server: ready. Listening to port '%d'.\n", PORT);
}
static void
gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key,
GNUTLS_X509_FMT_PEM);
- if (debug) success ("Launched, generating DH parameters...\n");
+ if (debug)
+ success ("Launched, generating DH parameters...\n");
generate_dh_params ();
sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
- if (debug) success ("server: connection from %s, port %d\n",
- inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
- sizeof (topbuf)), ntohs (sa_cli.sin_port));
+ if (debug)
+ success ("server: connection from %s, port %d\n",
+ inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
+ sizeof (topbuf)), ntohs (sa_cli.sin_port));
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
ret = gnutls_handshake (session);
fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
return;
}
- if (debug) success ("server: Handshake was completed\n");
+ if (debug)
+ success ("server: Handshake was completed\n");
- if (debug) success ("server: TLS version is: %s\n",
- gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
+ if (debug)
+ success ("server: TLS version is: %s\n",
+ gnutls_protocol_get_name (gnutls_protocol_get_version
+ (session)));
/* see the Getting peer's information example */
- if (debug) print_info (session);
+ if (debug)
+ print_info (session);
i = 0;
for (;;)
if (ret == 0)
{
- if (debug) success ("server: Peer has closed the GNUTLS connection\n");
+ if (debug)
+ success ("server: Peer has closed the GNUTLS connection\n");
break;
}
else if (ret < 0)
gnutls_global_deinit ();
- if (debug) success ("server: finished\n");
+ if (debug)
+ success ("server: finished\n");
}
projects / thirdparty / gnutls.git / commitdiff
