idx
int64 | func_before
string | Vulnerability Classification
string | vul
int64 | func_after
string | patch
string | CWE ID
string | lines_before
string | lines_after
string |
|---|---|---|---|---|---|---|---|---|
2,800
|
irc_server_set_index_current_address (struct t_irc_server *server, int index)
{
if (server->current_address)
{
free (server->current_address);
server->current_address = NULL;
}
server->current_port = 0;
if (index < server->addresses_count)
{
server->index_current_address = index;
if (server->current_address)
free (server->current_address);
server->current_address = strdup (server->addresses_array[index]);
server->current_port = server->ports_array[index];
}
}
| null | 0
|
irc_server_set_index_current_address (struct t_irc_server *server, int index)
{
if (server->current_address)
{
free (server->current_address);
server->current_address = NULL;
}
server->current_port = 0;
if (index < server->addresses_count)
{
server->index_current_address = index;
if (server->current_address)
free (server->current_address);
server->current_address = strdup (server->addresses_array[index]);
server->current_port = server->ports_array[index];
}
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,801
|
irc_server_set_nick (struct t_irc_server *server, const char *nick)
{
struct t_irc_channel *ptr_channel;
if (server->nick)
free (server->nick);
server->nick = (nick) ? strdup (nick) : NULL;
/* set local variable "nick" for server and all channels/pv */
weechat_buffer_set (server->buffer, "localvar_set_nick", nick);
for (ptr_channel = server->channels; ptr_channel;
ptr_channel = ptr_channel->next_channel)
{
weechat_buffer_set (ptr_channel->buffer, "localvar_set_nick", nick);
}
weechat_bar_item_update ("input_prompt");
}
| null | 0
|
irc_server_set_nick (struct t_irc_server *server, const char *nick)
{
struct t_irc_channel *ptr_channel;
if (server->nick)
free (server->nick);
server->nick = (nick) ? strdup (nick) : NULL;
/* set local variable "nick" for server and all channels/pv */
weechat_buffer_set (server->buffer, "localvar_set_nick", nick);
for (ptr_channel = server->channels; ptr_channel;
ptr_channel = ptr_channel->next_channel)
{
weechat_buffer_set (ptr_channel->buffer, "localvar_set_nick", nick);
}
weechat_bar_item_update ("input_prompt");
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,802
|
irc_server_set_nicks (struct t_irc_server *server, const char *nicks)
{
/* free data */
server->nicks_count = 0;
if (server->nicks_array)
{
weechat_string_free_split (server->nicks_array);
server->nicks_array = NULL;
}
/* set new nicks */
server->nicks_array = weechat_string_split ((nicks) ? nicks : IRC_SERVER_DEFAULT_NICKS,
",", 0, 0,
&server->nicks_count);
}
| null | 0
|
irc_server_set_nicks (struct t_irc_server *server, const char *nicks)
{
/* free data */
server->nicks_count = 0;
if (server->nicks_array)
{
weechat_string_free_split (server->nicks_array);
server->nicks_array = NULL;
}
/* set new nicks */
server->nicks_array = weechat_string_split ((nicks) ? nicks : IRC_SERVER_DEFAULT_NICKS,
",", 0, 0,
&server->nicks_count);
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,803
|
irc_server_set_prefix_modes_chars (struct t_irc_server *server,
const char *prefix)
{
char *pos;
int i, length_modes, length_chars;
if (!server || !prefix)
return;
/* free previous values */
if (server->prefix_modes)
{
free (server->prefix_modes);
server->prefix_modes = NULL;
}
if (server->prefix_chars)
{
free (server->prefix_chars);
server->prefix_chars = NULL;
}
/* assign new values */
pos = strchr (prefix, ')');
if (pos)
{
server->prefix_modes = weechat_strndup (prefix + 1,
pos - prefix - 1);
if (server->prefix_modes)
{
pos++;
length_modes = strlen (server->prefix_modes);
length_chars = strlen (pos);
server->prefix_chars = malloc (length_modes + 1);
if (server->prefix_chars)
{
for (i = 0; i < length_modes; i++)
{
server->prefix_chars[i] = (i < length_chars) ? pos[i] : ' ';
}
server->prefix_chars[length_modes] = '\0';
}
else
{
free (server->prefix_modes);
server->prefix_modes = NULL;
}
}
}
}
| null | 0
|
irc_server_set_prefix_modes_chars (struct t_irc_server *server,
const char *prefix)
{
char *pos;
int i, length_modes, length_chars;
if (!server || !prefix)
return;
/* free previous values */
if (server->prefix_modes)
{
free (server->prefix_modes);
server->prefix_modes = NULL;
}
if (server->prefix_chars)
{
free (server->prefix_chars);
server->prefix_chars = NULL;
}
/* assign new values */
pos = strchr (prefix, ')');
if (pos)
{
server->prefix_modes = weechat_strndup (prefix + 1,
pos - prefix - 1);
if (server->prefix_modes)
{
pos++;
length_modes = strlen (server->prefix_modes);
length_chars = strlen (pos);
server->prefix_chars = malloc (length_modes + 1);
if (server->prefix_chars)
{
for (i = 0; i < length_modes; i++)
{
server->prefix_chars[i] = (i < length_chars) ? pos[i] : ' ';
}
server->prefix_chars[length_modes] = '\0';
}
else
{
free (server->prefix_modes);
server->prefix_modes = NULL;
}
}
}
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,804
|
irc_server_set_send_default_tags (const char *tags)
{
irc_server_send_default_tags = tags;
}
| null | 0
|
irc_server_set_send_default_tags (const char *tags)
{
irc_server_send_default_tags = tags;
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,805
|
irc_server_switch_address (struct t_irc_server *server, int connection)
{
if (server->addresses_count > 1)
{
irc_server_set_index_current_address (server,
(server->index_current_address + 1) % server->addresses_count);
weechat_printf (server->buffer,
_("%s: switching address to %s/%d"),
IRC_PLUGIN_NAME,
server->current_address,
server->current_port);
if (connection)
{
if (server->index_current_address == 0)
irc_server_reconnect_schedule (server);
else
irc_server_connect (server);
}
}
else
{
if (connection)
irc_server_reconnect_schedule (server);
}
}
| null | 0
|
irc_server_switch_address (struct t_irc_server *server, int connection)
{
if (server->addresses_count > 1)
{
irc_server_set_index_current_address (server,
(server->index_current_address + 1) % server->addresses_count);
weechat_printf (server->buffer,
_("%s: switching address to %s/%d"),
IRC_PLUGIN_NAME,
server->current_address,
server->current_port);
if (connection)
{
if (server->index_current_address == 0)
irc_server_reconnect_schedule (server);
else
irc_server_connect (server);
}
}
else
{
if (connection)
irc_server_reconnect_schedule (server);
}
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,806
|
irc_server_timer_cb (void *data, int remaining_calls)
{
struct t_irc_server *ptr_server;
struct t_irc_redirect *ptr_redirect, *ptr_next_redirect;
time_t current_time;
static struct timeval tv;
int away_check;
/* make C compiler happy */
(void) data;
(void) remaining_calls;
current_time = time (NULL);
for (ptr_server = irc_servers; ptr_server;
ptr_server = ptr_server->next_server)
{
/* check if reconnection is pending */
if ((!ptr_server->is_connected)
&& (ptr_server->reconnect_start > 0)
&& (current_time >= (ptr_server->reconnect_start + ptr_server->reconnect_delay)))
{
irc_server_reconnect (ptr_server);
}
else
{
if (ptr_server->is_connected)
{
/* send queued messages */
irc_server_outqueue_send (ptr_server);
/* check for lag */
if ((weechat_config_integer (irc_config_network_lag_check) > 0)
&& (ptr_server->lag_check_time.tv_sec == 0)
&& (current_time >= ptr_server->lag_next_check))
{
irc_server_sendf (ptr_server, 0, NULL, "PING %s",
(ptr_server->current_address) ?
ptr_server->current_address : "weechat");
gettimeofday (&(ptr_server->lag_check_time), NULL);
ptr_server->lag = 0;
ptr_server->lag_last_refresh = 0;
}
else
{
/* check away (only if lag check was not done) */
away_check = IRC_SERVER_OPTION_INTEGER(ptr_server, IRC_SERVER_OPTION_AWAY_CHECK);
if (away_check > 0)
{
if ((ptr_server->last_away_check == 0)
|| (current_time >= ptr_server->last_away_check + (away_check * 60)))
{
irc_server_check_away (ptr_server);
}
}
}
/* check if it's time to autojoin channels (after command delay) */
if ((ptr_server->command_time != 0)
&& (current_time >= ptr_server->command_time +
IRC_SERVER_OPTION_INTEGER(ptr_server, IRC_SERVER_OPTION_COMMAND_DELAY)))
{
irc_server_autojoin_channels (ptr_server);
ptr_server->command_time = 0;
}
/* compute lag */
if (ptr_server->lag_check_time.tv_sec != 0)
{
gettimeofday (&tv, NULL);
ptr_server->lag = (int) weechat_util_timeval_diff (&(ptr_server->lag_check_time),
&tv);
/* refresh lag item if needed */
if (((ptr_server->lag_last_refresh == 0)
|| (current_time >= ptr_server->lag_last_refresh + weechat_config_integer (irc_config_network_lag_refresh_interval)))
&& (ptr_server->lag >= weechat_config_integer (irc_config_network_lag_min_show)))
{
ptr_server->lag_last_refresh = current_time;
weechat_bar_item_update ("lag");
}
/* lag timeout? => disconnect */
if ((weechat_config_integer (irc_config_network_lag_disconnect) > 0)
&& (ptr_server->lag / 1000 > weechat_config_integer (irc_config_network_lag_disconnect) * 60))
{
weechat_printf (ptr_server->buffer,
_("%s: lag is high, disconnecting "
"from server..."),
IRC_PLUGIN_NAME);
irc_server_disconnect (ptr_server, 0, 1);
}
}
/* remove redirects if timeout occurs */
ptr_redirect = ptr_server->redirects;
while (ptr_redirect)
{
ptr_next_redirect = ptr_redirect->next_redirect;
if ((ptr_redirect->start_time > 0)
&& (ptr_redirect->start_time + ptr_redirect->timeout < current_time))
{
irc_redirect_stop (ptr_redirect, "timeout");
}
ptr_redirect = ptr_next_redirect;
}
}
}
}
return WEECHAT_RC_OK;
}
| null | 0
|
irc_server_timer_cb (void *data, int remaining_calls)
{
struct t_irc_server *ptr_server;
struct t_irc_redirect *ptr_redirect, *ptr_next_redirect;
time_t current_time;
static struct timeval tv;
int away_check;
/* make C compiler happy */
(void) data;
(void) remaining_calls;
current_time = time (NULL);
for (ptr_server = irc_servers; ptr_server;
ptr_server = ptr_server->next_server)
{
/* check if reconnection is pending */
if ((!ptr_server->is_connected)
&& (ptr_server->reconnect_start > 0)
&& (current_time >= (ptr_server->reconnect_start + ptr_server->reconnect_delay)))
{
irc_server_reconnect (ptr_server);
}
else
{
if (ptr_server->is_connected)
{
/* send queued messages */
irc_server_outqueue_send (ptr_server);
/* check for lag */
if ((weechat_config_integer (irc_config_network_lag_check) > 0)
&& (ptr_server->lag_check_time.tv_sec == 0)
&& (current_time >= ptr_server->lag_next_check))
{
irc_server_sendf (ptr_server, 0, NULL, "PING %s",
(ptr_server->current_address) ?
ptr_server->current_address : "weechat");
gettimeofday (&(ptr_server->lag_check_time), NULL);
ptr_server->lag = 0;
ptr_server->lag_last_refresh = 0;
}
else
{
/* check away (only if lag check was not done) */
away_check = IRC_SERVER_OPTION_INTEGER(ptr_server, IRC_SERVER_OPTION_AWAY_CHECK);
if (away_check > 0)
{
if ((ptr_server->last_away_check == 0)
|| (current_time >= ptr_server->last_away_check + (away_check * 60)))
{
irc_server_check_away (ptr_server);
}
}
}
/* check if it's time to autojoin channels (after command delay) */
if ((ptr_server->command_time != 0)
&& (current_time >= ptr_server->command_time +
IRC_SERVER_OPTION_INTEGER(ptr_server, IRC_SERVER_OPTION_COMMAND_DELAY)))
{
irc_server_autojoin_channels (ptr_server);
ptr_server->command_time = 0;
}
/* compute lag */
if (ptr_server->lag_check_time.tv_sec != 0)
{
gettimeofday (&tv, NULL);
ptr_server->lag = (int) weechat_util_timeval_diff (&(ptr_server->lag_check_time),
&tv);
/* refresh lag item if needed */
if (((ptr_server->lag_last_refresh == 0)
|| (current_time >= ptr_server->lag_last_refresh + weechat_config_integer (irc_config_network_lag_refresh_interval)))
&& (ptr_server->lag >= weechat_config_integer (irc_config_network_lag_min_show)))
{
ptr_server->lag_last_refresh = current_time;
weechat_bar_item_update ("lag");
}
/* lag timeout? => disconnect */
if ((weechat_config_integer (irc_config_network_lag_disconnect) > 0)
&& (ptr_server->lag / 1000 > weechat_config_integer (irc_config_network_lag_disconnect) * 60))
{
weechat_printf (ptr_server->buffer,
_("%s: lag is high, disconnecting "
"from server..."),
IRC_PLUGIN_NAME);
irc_server_disconnect (ptr_server, 0, 1);
}
}
/* remove redirects if timeout occurs */
ptr_redirect = ptr_server->redirects;
while (ptr_redirect)
{
ptr_next_redirect = ptr_redirect->next_redirect;
if ((ptr_redirect->start_time > 0)
&& (ptr_redirect->start_time + ptr_redirect->timeout < current_time))
{
irc_redirect_stop (ptr_redirect, "timeout");
}
ptr_redirect = ptr_next_redirect;
}
}
}
}
return WEECHAT_RC_OK;
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,807
|
irc_server_timer_connection_cb (void *data, int remaining_calls)
{
struct t_irc_server *server;
/* make C compiler happy */
(void) remaining_calls;
server = (struct t_irc_server *)data;
if (!server)
return WEECHAT_RC_ERROR;
server->hook_timer_connection = NULL;
if (!server->is_connected)
{
weechat_printf (server->buffer,
_("%s%s: connection timeout (message 001 not received)"),
weechat_prefix ("error"), IRC_PLUGIN_NAME);
irc_server_disconnect (server, !server->is_connected, 1);
}
return WEECHAT_RC_OK;
}
| null | 0
|
irc_server_timer_connection_cb (void *data, int remaining_calls)
{
struct t_irc_server *server;
/* make C compiler happy */
(void) remaining_calls;
server = (struct t_irc_server *)data;
if (!server)
return WEECHAT_RC_ERROR;
server->hook_timer_connection = NULL;
if (!server->is_connected)
{
weechat_printf (server->buffer,
_("%s%s: connection timeout (message 001 not received)"),
weechat_prefix ("error"), IRC_PLUGIN_NAME);
irc_server_disconnect (server, !server->is_connected, 1);
}
return WEECHAT_RC_OK;
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,808
|
irc_server_valid (struct t_irc_server *server)
{
struct t_irc_server *ptr_server;
if (!server)
return 0;
for (ptr_server = irc_servers; ptr_server;
ptr_server = ptr_server->next_server)
{
if (ptr_server == server)
return 1;
}
/* server not found */
return 0;
}
| null | 0
|
irc_server_valid (struct t_irc_server *server)
{
struct t_irc_server *ptr_server;
if (!server)
return 0;
for (ptr_server = irc_servers; ptr_server;
ptr_server = ptr_server->next_server)
{
if (ptr_server == server)
return 1;
}
/* server not found */
return 0;
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,809
|
irc_server_xfer_resume_ready_cb (void *data, const char *signal,
const char *type_data, void *signal_data)
{
struct t_infolist *infolist;
struct t_irc_server *ptr_server;
const char *plugin_name, *plugin_id, *filename;
int spaces_in_name;
/* make C compiler happy */
(void) data;
(void) signal;
(void) type_data;
infolist = (struct t_infolist *)signal_data;
if (weechat_infolist_next (infolist))
{
plugin_name = weechat_infolist_string (infolist, "plugin_name");
plugin_id = weechat_infolist_string (infolist, "plugin_id");
if (plugin_name && (strcmp (plugin_name, IRC_PLUGIN_NAME) == 0) && plugin_id)
{
ptr_server = irc_server_search (plugin_id);
if (ptr_server)
{
filename = weechat_infolist_string (infolist, "filename");
spaces_in_name = (strchr (filename, ' ') != NULL);
irc_server_sendf (ptr_server,
IRC_SERVER_SEND_OUTQ_PRIO_HIGH, NULL,
"PRIVMSG %s :\01DCC RESUME %s%s%s %d %s\01",
weechat_infolist_string (infolist, "remote_nick"),
(spaces_in_name) ? "\"" : "",
filename,
(spaces_in_name) ? "\"" : "",
weechat_infolist_integer (infolist, "port"),
weechat_infolist_string (infolist, "start_resume"));
}
}
}
weechat_infolist_reset_item_cursor (infolist);
return WEECHAT_RC_OK;
}
| null | 0
|
irc_server_xfer_resume_ready_cb (void *data, const char *signal,
const char *type_data, void *signal_data)
{
struct t_infolist *infolist;
struct t_irc_server *ptr_server;
const char *plugin_name, *plugin_id, *filename;
int spaces_in_name;
/* make C compiler happy */
(void) data;
(void) signal;
(void) type_data;
infolist = (struct t_infolist *)signal_data;
if (weechat_infolist_next (infolist))
{
plugin_name = weechat_infolist_string (infolist, "plugin_name");
plugin_id = weechat_infolist_string (infolist, "plugin_id");
if (plugin_name && (strcmp (plugin_name, IRC_PLUGIN_NAME) == 0) && plugin_id)
{
ptr_server = irc_server_search (plugin_id);
if (ptr_server)
{
filename = weechat_infolist_string (infolist, "filename");
spaces_in_name = (strchr (filename, ' ') != NULL);
irc_server_sendf (ptr_server,
IRC_SERVER_SEND_OUTQ_PRIO_HIGH, NULL,
"PRIVMSG %s :\01DCC RESUME %s%s%s %d %s\01",
weechat_infolist_string (infolist, "remote_nick"),
(spaces_in_name) ? "\"" : "",
filename,
(spaces_in_name) ? "\"" : "",
weechat_infolist_integer (infolist, "port"),
weechat_infolist_string (infolist, "start_resume"));
}
}
}
weechat_infolist_reset_item_cursor (infolist);
return WEECHAT_RC_OK;
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,810
|
irc_server_xfer_send_ready_cb (void *data, const char *signal,
const char *type_data, void *signal_data)
{
struct t_infolist *infolist;
struct t_irc_server *ptr_server;
const char *plugin_name, *plugin_id, *type, *filename;
int spaces_in_name;
/* make C compiler happy */
(void) data;
(void) signal;
(void) type_data;
infolist = (struct t_infolist *)signal_data;
if (weechat_infolist_next (infolist))
{
plugin_name = weechat_infolist_string (infolist, "plugin_name");
plugin_id = weechat_infolist_string (infolist, "plugin_id");
if (plugin_name && (strcmp (plugin_name, IRC_PLUGIN_NAME) == 0) && plugin_id)
{
ptr_server = irc_server_search (plugin_id);
if (ptr_server)
{
type = weechat_infolist_string (infolist, "type");
if (type)
{
if (strcmp (type, "file_send") == 0)
{
filename = weechat_infolist_string (infolist, "filename");
spaces_in_name = (strchr (filename, ' ') != NULL);
irc_server_sendf (ptr_server,
IRC_SERVER_SEND_OUTQ_PRIO_HIGH, NULL,
"PRIVMSG %s :\01DCC SEND %s%s%s "
"%s %d %s\01",
weechat_infolist_string (infolist, "remote_nick"),
(spaces_in_name) ? "\"" : "",
filename,
(spaces_in_name) ? "\"" : "",
weechat_infolist_string (infolist, "address"),
weechat_infolist_integer (infolist, "port"),
weechat_infolist_string (infolist, "size"));
}
else if (strcmp (type, "chat_send") == 0)
{
irc_server_sendf (ptr_server,
IRC_SERVER_SEND_OUTQ_PRIO_HIGH, NULL,
"PRIVMSG %s :\01DCC CHAT chat %s %d\01",
weechat_infolist_string (infolist, "remote_nick"),
weechat_infolist_string (infolist, "address"),
weechat_infolist_integer (infolist, "port"));
}
}
}
}
}
weechat_infolist_reset_item_cursor (infolist);
return WEECHAT_RC_OK;
}
| null | 0
|
irc_server_xfer_send_ready_cb (void *data, const char *signal,
const char *type_data, void *signal_data)
{
struct t_infolist *infolist;
struct t_irc_server *ptr_server;
const char *plugin_name, *plugin_id, *type, *filename;
int spaces_in_name;
/* make C compiler happy */
(void) data;
(void) signal;
(void) type_data;
infolist = (struct t_infolist *)signal_data;
if (weechat_infolist_next (infolist))
{
plugin_name = weechat_infolist_string (infolist, "plugin_name");
plugin_id = weechat_infolist_string (infolist, "plugin_id");
if (plugin_name && (strcmp (plugin_name, IRC_PLUGIN_NAME) == 0) && plugin_id)
{
ptr_server = irc_server_search (plugin_id);
if (ptr_server)
{
type = weechat_infolist_string (infolist, "type");
if (type)
{
if (strcmp (type, "file_send") == 0)
{
filename = weechat_infolist_string (infolist, "filename");
spaces_in_name = (strchr (filename, ' ') != NULL);
irc_server_sendf (ptr_server,
IRC_SERVER_SEND_OUTQ_PRIO_HIGH, NULL,
"PRIVMSG %s :\01DCC SEND %s%s%s "
"%s %d %s\01",
weechat_infolist_string (infolist, "remote_nick"),
(spaces_in_name) ? "\"" : "",
filename,
(spaces_in_name) ? "\"" : "",
weechat_infolist_string (infolist, "address"),
weechat_infolist_integer (infolist, "port"),
weechat_infolist_string (infolist, "size"));
}
else if (strcmp (type, "chat_send") == 0)
{
irc_server_sendf (ptr_server,
IRC_SERVER_SEND_OUTQ_PRIO_HIGH, NULL,
"PRIVMSG %s :\01DCC CHAT chat %s %d\01",
weechat_infolist_string (infolist, "remote_nick"),
weechat_infolist_string (infolist, "address"),
weechat_infolist_integer (infolist, "port"));
}
}
}
}
}
weechat_infolist_reset_item_cursor (infolist);
return WEECHAT_RC_OK;
}
|
@@ -2805,7 +2805,8 @@ int
irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
const gnutls_datum_t *req_ca, int nreq,
const gnutls_pk_algorithm_t *pk_algos,
- int pk_algos_len, gnutls_retr_st *answer)
+ int pk_algos_len, gnutls_retr_st *answer,
+ int action)
{
struct t_irc_server *server;
gnutls_retr_st tls_struct;
@@ -2837,207 +2838,212 @@ irc_server_gnutls_callback (void *data, gnutls_session_t tls_session,
hostname = server->current_address;
hostname_match = 0;
- weechat_printf (server->buffer,
- _("gnutls: connected using %d-bit Diffie-Hellman shared "
- "secret exchange"),
- IRC_SERVER_OPTION_INTEGER (server,
- IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
- if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
+ if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_VERIFY_CERT)
{
weechat_printf (server->buffer,
- _("%sgnutls: error while checking peer's certificate"),
- weechat_prefix ("error"));
- rc = -1;
- }
- else
- {
- /* some checks */
- if (status & GNUTLS_CERT_INVALID)
+ _("gnutls: connected using %d-bit Diffie-Hellman shared "
+ "secret exchange"),
+ IRC_SERVER_OPTION_INTEGER (server,
+ IRC_SERVER_OPTION_SSL_DHKEY_SIZE));
+ if (gnutls_certificate_verify_peers2 (tls_session, &status) < 0)
{
weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate is NOT trusted"),
+ _("%sgnutls: error while checking peer's certificate"),
weechat_prefix ("error"));
rc = -1;
}
else
{
- weechat_printf (server->buffer,
- _("gnutls: peer's certificate is trusted"));
- }
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: peer's certificate issuer is unknown"),
- weechat_prefix ("error"));
- rc = -1;
- }
- if (status & GNUTLS_CERT_REVOKED)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the certificate has been revoked"),
- weechat_prefix ("error"));
- rc = -1;
- }
-
- /* check certificates */
- if (gnutls_x509_crt_init (&cert_temp) >= 0)
- {
- cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
- if (cert_list)
+ /* some checks */
+ if (status & GNUTLS_CERT_INVALID)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: peer's certificate is NOT trusted"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("gnutls: peer's certificate is trusted"));
+ }
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
weechat_printf (server->buffer,
- NG_("gnutls: receiving %d certificate",
- "gnutls: receiving %d certificates",
- cert_list_len),
- cert_list_len);
- for (i = 0, j = (int) cert_list_len; i < j; i++)
+ _("%sgnutls: peer's certificate issuer is unknown"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ if (status & GNUTLS_CERT_REVOKED)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the certificate has been revoked"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+
+ /* check certificates */
+ if (gnutls_x509_crt_init (&cert_temp) >= 0)
+ {
+ cert_list = gnutls_certificate_get_peers (tls_session, &cert_list_len);
+ if (cert_list)
{
- if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
+ weechat_printf (server->buffer,
+ NG_("gnutls: receiving %d certificate",
+ "gnutls: receiving %d certificates",
+ cert_list_len),
+ cert_list_len);
+ for (i = 0, j = (int) cert_list_len; i < j; i++)
{
- /* checking if hostname matches in the first certificate */
- if (i == 0 && gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0)
+ if (gnutls_x509_crt_import (cert_temp, &cert_list[i], GNUTLS_X509_FMT_DER) >= 0)
{
- hostname_match = 1;
- }
+ /* checking if hostname matches in the first certificate */
+ if ((i == 0) && (gnutls_x509_crt_check_hostname (cert_temp, hostname) != 0))
+ {
+ hostname_match = 1;
+ }
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* displaying infos about certificate */
+ /* displaying infos about certificate */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_X509_CRT_ONELINE, &cinfo);
#else
- rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
+ rinfo = gnutls_x509_crt_print (cert_temp, GNUTLS_CRT_PRINT_ONELINE, &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - certificate[%d] info:"), i + 1);
- weechat_printf (server->buffer,
- " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - certificate[%d] info:"), i + 1);
+ weechat_printf (server->buffer,
+ " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
- if (cert_time < time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate has expired"),
- weechat_prefix ("error"));
- rc = -1;
- }
- /* check expiration date */
- cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
- if (cert_time > time(NULL))
- {
- weechat_printf (server->buffer,
- _("%sgnutls: certificate is not yet activated"),
- weechat_prefix ("error"));
- rc = -1;
+ /* check expiration date */
+ cert_time = gnutls_x509_crt_get_expiration_time (cert_temp);
+ if (cert_time < time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate has expired"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
+ /* check activation date */
+ cert_time = gnutls_x509_crt_get_activation_time (cert_temp);
+ if (cert_time > time (NULL))
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: certificate is not yet activated"),
+ weechat_prefix ("error"));
+ rc = -1;
+ }
}
}
- }
- if (hostname_match == 0)
- {
- weechat_printf (server->buffer,
- _("%sgnutls: the hostname in the "
- "certificate does NOT match \"%s\""),
- weechat_prefix ("error"), hostname);
- rc = -1;
+ if (hostname_match == 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: the hostname in the "
+ "certificate does NOT match \"%s\""),
+ weechat_prefix ("error"), hostname);
+ rc = -1;
+ }
}
}
}
}
-
- /* using client certificate if it exists */
- cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
- IRC_SERVER_OPTION_SSL_CERT);
- if (cert_path0 && cert_path0[0])
+ else if (action == WEECHAT_HOOK_CONNECT_GNUTLS_CB_SET_CERT)
{
- weechat_dir = weechat_info_get ("weechat_dir", "");
- cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
- cert_path2 = (cert_path1) ?
- weechat_string_expand_home (cert_path1) : NULL;
-
- if (cert_path2)
+ /* using client certificate if it exists */
+ cert_path0 = (char *) IRC_SERVER_OPTION_STRING(server,
+ IRC_SERVER_OPTION_SSL_CERT);
+ if (cert_path0 && cert_path0[0])
{
- cert_str = weechat_file_get_content (cert_path2);
- if (cert_str)
+ weechat_dir = weechat_info_get ("weechat_dir", "");
+ cert_path1 = weechat_string_replace (cert_path0, "%h", weechat_dir);
+ cert_path2 = (cert_path1) ?
+ weechat_string_expand_home (cert_path1) : NULL;
+
+ if (cert_path2)
{
- weechat_printf (server->buffer,
- _("gnutls: sending one certificate"));
-
- filedatum.data = (unsigned char *) cert_str;
- filedatum.size = strlen (cert_str);
-
- /* certificate */
- gnutls_x509_crt_init (&server->tls_cert);
- gnutls_x509_crt_import (server->tls_cert, &filedatum,
- GNUTLS_X509_FMT_PEM);
-
- /* key */
- gnutls_x509_privkey_init (&server->tls_cert_key);
- ret = gnutls_x509_privkey_import (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM);
- if (ret < 0)
- {
- ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
- &filedatum,
- GNUTLS_X509_FMT_PEM,
- NULL,
- GNUTLS_PKCS_PLAIN);
- }
- if (ret < 0)
+ cert_str = weechat_file_get_content (cert_path2);
+ if (cert_str)
{
weechat_printf (server->buffer,
- _("%sgnutls: invalid certificate \"%s\", "
- "error: %s"),
- weechat_prefix ("error"), cert_path2,
- gnutls_strerror (ret));
- rc = -1;
- }
- else
- {
- tls_struct.type = GNUTLS_CRT_X509;
- tls_struct.ncerts = 1;
- tls_struct.deinit_all = 0;
- tls_struct.cert.x509 = &server->tls_cert;
- tls_struct.key.x509 = server->tls_cert_key;
+ _("gnutls: sending one certificate"));
+
+ filedatum.data = (unsigned char *) cert_str;
+ filedatum.size = strlen (cert_str);
+
+ /* certificate */
+ gnutls_x509_crt_init (&server->tls_cert);
+ gnutls_x509_crt_import (server->tls_cert, &filedatum,
+ GNUTLS_X509_FMT_PEM);
+
+ /* key */
+ gnutls_x509_privkey_init (&server->tls_cert_key);
+ ret = gnutls_x509_privkey_import (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM);
+ if (ret < 0)
+ {
+ ret = gnutls_x509_privkey_import_pkcs8 (server->tls_cert_key,
+ &filedatum,
+ GNUTLS_X509_FMT_PEM,
+ NULL,
+ GNUTLS_PKCS_PLAIN);
+ }
+ if (ret < 0)
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: invalid certificate \"%s\", "
+ "error: %s"),
+ weechat_prefix ("error"), cert_path2,
+ gnutls_strerror (ret));
+ rc = -1;
+ }
+ else
+ {
+ tls_struct.type = GNUTLS_CRT_X509;
+ tls_struct.ncerts = 1;
+ tls_struct.deinit_all = 0;
+ tls_struct.cert.x509 = &server->tls_cert;
+ tls_struct.key.x509 = server->tls_cert_key;
#if LIBGNUTLS_VERSION_NUMBER >= 0x010706
- /* client certificate info */
+ /* client certificate info */
#if LIBGNUTLS_VERSION_NUMBER < 0x020400
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_X509_CRT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_X509_CRT_ONELINE,
+ &cinfo);
#else
- rinfo = gnutls_x509_crt_print (server->tls_cert,
- GNUTLS_CRT_PRINT_ONELINE,
- &cinfo);
+ rinfo = gnutls_x509_crt_print (server->tls_cert,
+ GNUTLS_CRT_PRINT_ONELINE,
+ &cinfo);
#endif
- if (rinfo == 0)
- {
- weechat_printf (server->buffer,
- _(" - client certificate info (%s):"),
- cert_path2);
- weechat_printf (server->buffer, " - %s", cinfo.data);
- gnutls_free (cinfo.data);
- }
+ if (rinfo == 0)
+ {
+ weechat_printf (server->buffer,
+ _(" - client certificate info (%s):"),
+ cert_path2);
+ weechat_printf (server->buffer, " - %s", cinfo.data);
+ gnutls_free (cinfo.data);
+ }
#endif
- memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
- free (cert_str);
+ memcpy (answer, &tls_struct, sizeof (gnutls_retr_st));
+ free (cert_str);
+ }
+ }
+ else
+ {
+ weechat_printf (server->buffer,
+ _("%sgnutls: unable to read certifcate \"%s\""),
+ weechat_prefix ("error"), cert_path2);
}
}
- else
- {
- weechat_printf (server->buffer,
- _("%sgnutls: unable to read certifcate \"%s\""),
- weechat_prefix ("error"), cert_path2);
- }
+
+ if (cert_path1)
+ free (cert_path1);
+ if (cert_path2)
+ free (cert_path2);
}
-
- if (cert_path1)
- free (cert_path1);
- if (cert_path2)
- free (cert_path2);
}
/* an error should stop the handshake unless the user doesn't care */
|
CWE-20
| null | null |
2,811
|
void buffer_dump(FILE *o, struct buffer *b, int from, int to)
{
fprintf(o, "Dumping buffer %p\n", b);
fprintf(o, " data=%p o=%d i=%d p=%p\n"
" relative: p=0x%04x\n",
b->data, b->o, b->i, b->p, (unsigned int)(b->p - b->data));
fprintf(o, "Dumping contents from byte %d to byte %d\n", from, to);
fprintf(o, " 0 1 2 3 4 5 6 7 8 9 a b c d e f\n");
/* dump hexa */
while (from < to) {
int i;
fprintf(o, " %04x: ", from);
for (i = 0; ((from + i) < to) && (i < 16) ; i++) {
fprintf(o, "%02x ", (unsigned char)b->data[from + i]);
if (((from + i) & 15) == 7)
fprintf(o, "- ");
}
if (to - from < 16) {
int j = 0;
for (j = 0; j < from + 16 - to; j++)
fprintf(o, " ");
if (j > 8)
fprintf(o, " ");
}
fprintf(o, " ");
for (i = 0; (from + i < to) && (i < 16) ; i++) {
fprintf(o, "%c", isprint((int)b->data[from + i]) ? b->data[from + i] : '.') ;
if ((((from + i) & 15) == 15) && ((from + i) != to-1))
fprintf(o, "\n");
}
from += i;
}
fprintf(o, "\n--\n");
fflush(o);
}
|
Overflow +Info
| 0
|
void buffer_dump(FILE *o, struct buffer *b, int from, int to)
{
fprintf(o, "Dumping buffer %p\n", b);
fprintf(o, " data=%p o=%d i=%d p=%p\n"
" relative: p=0x%04x\n",
b->data, b->o, b->i, b->p, (unsigned int)(b->p - b->data));
fprintf(o, "Dumping contents from byte %d to byte %d\n", from, to);
fprintf(o, " 0 1 2 3 4 5 6 7 8 9 a b c d e f\n");
/* dump hexa */
while (from < to) {
int i;
fprintf(o, " %04x: ", from);
for (i = 0; ((from + i) < to) && (i < 16) ; i++) {
fprintf(o, "%02x ", (unsigned char)b->data[from + i]);
if (((from + i) & 15) == 7)
fprintf(o, "- ");
}
if (to - from < 16) {
int j = 0;
for (j = 0; j < from + 16 - to; j++)
fprintf(o, " ");
if (j > 8)
fprintf(o, " ");
}
fprintf(o, " ");
for (i = 0; (from + i < to) && (i < 16) ; i++) {
fprintf(o, "%c", isprint((int)b->data[from + i]) ? b->data[from + i] : '.') ;
if ((((from + i) & 15) == 15) && ((from + i) != to-1))
fprintf(o, "\n");
}
from += i;
}
fprintf(o, "\n--\n");
fflush(o);
}
|
@@ -107,30 +107,39 @@ int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
return delta;
}
-/* This function realigns input data in a possibly wrapping buffer so that it
- * becomes contiguous and starts at the beginning of the buffer area. The
- * function may only be used when the buffer's output is empty.
+/* This function realigns a possibly wrapping buffer so that the input part is
+ * contiguous and starts at the beginning of the buffer and the output part
+ * ends at the end of the buffer. This provides the best conditions since it
+ * allows the largest inputs to be processed at once and ensures that once the
+ * output data leaves, the whole buffer is available at once.
*/
void buffer_slow_realign(struct buffer *buf)
{
- /* two possible cases :
- * - the buffer is in one contiguous block, we move it in-place
- * - the buffer is in two blocks, we move it via the swap_buffer
- */
- if (buf->i) {
- int block1 = buf->i;
- int block2 = 0;
- if (buf->p + buf->i > buf->data + buf->size) {
- /* non-contiguous block */
- block1 = buf->data + buf->size - buf->p;
- block2 = buf->p + buf->i - (buf->data + buf->size);
- }
- if (block2)
- memcpy(swap_buffer, buf->data, block2);
- memmove(buf->data, buf->p, block1);
- if (block2)
- memcpy(buf->data + block1, swap_buffer, block2);
+ int block1 = buf->o;
+ int block2 = 0;
+
+ /* process output data in two steps to cover wrapping */
+ if (block1 > buf->p - buf->data) {
+ block2 = buf->p - buf->data;
+ block1 -= block2;
+ }
+ memcpy(swap_buffer + buf->size - buf->o, bo_ptr(buf), block1);
+ memcpy(swap_buffer + buf->size - block2, buf->data, block2);
+
+ /* process input data in two steps to cover wrapping */
+ block1 = buf->i;
+ block2 = 0;
+
+ if (block1 > buf->data + buf->size - buf->p) {
+ block1 = buf->data + buf->size - buf->p;
+ block2 = buf->i - block1;
}
+ memcpy(swap_buffer, bi_ptr(buf), block1);
+ memcpy(swap_buffer + block1, buf->data, block2);
+
+ /* reinject changes into the buffer */
+ memcpy(buf->data, swap_buffer, buf->i);
+ memcpy(buf->data + buf->size - buf->o, swap_buffer + buf->size - buf->o, buf->o);
buf->p = buf->data;
}
|
CWE-119
| null | null |
2,812
|
int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
{
int delta;
delta = len + 2;
if (bi_end(b) + delta >= b->data + b->size)
return 0; /* no space left */
if (buffer_not_empty(b) &&
bi_end(b) + delta > bo_ptr(b) &&
bo_ptr(b) >= bi_end(b))
return 0; /* no space left before wrapping data */
/* first, protect the end of the buffer */
memmove(pos + delta, pos, bi_end(b) - pos);
/* now, copy str over pos */
if (len && str) {
memcpy(pos, str, len);
pos[len] = '\r';
pos[len + 1] = '\n';
}
b->i += delta;
return delta;
}
|
Overflow +Info
| 0
|
int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
{
int delta;
delta = len + 2;
if (bi_end(b) + delta >= b->data + b->size)
return 0; /* no space left */
if (buffer_not_empty(b) &&
bi_end(b) + delta > bo_ptr(b) &&
bo_ptr(b) >= bi_end(b))
return 0; /* no space left before wrapping data */
/* first, protect the end of the buffer */
memmove(pos + delta, pos, bi_end(b) - pos);
/* now, copy str over pos */
if (len && str) {
memcpy(pos, str, len);
pos[len] = '\r';
pos[len + 1] = '\n';
}
b->i += delta;
return delta;
}
|
@@ -107,30 +107,39 @@ int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
return delta;
}
-/* This function realigns input data in a possibly wrapping buffer so that it
- * becomes contiguous and starts at the beginning of the buffer area. The
- * function may only be used when the buffer's output is empty.
+/* This function realigns a possibly wrapping buffer so that the input part is
+ * contiguous and starts at the beginning of the buffer and the output part
+ * ends at the end of the buffer. This provides the best conditions since it
+ * allows the largest inputs to be processed at once and ensures that once the
+ * output data leaves, the whole buffer is available at once.
*/
void buffer_slow_realign(struct buffer *buf)
{
- /* two possible cases :
- * - the buffer is in one contiguous block, we move it in-place
- * - the buffer is in two blocks, we move it via the swap_buffer
- */
- if (buf->i) {
- int block1 = buf->i;
- int block2 = 0;
- if (buf->p + buf->i > buf->data + buf->size) {
- /* non-contiguous block */
- block1 = buf->data + buf->size - buf->p;
- block2 = buf->p + buf->i - (buf->data + buf->size);
- }
- if (block2)
- memcpy(swap_buffer, buf->data, block2);
- memmove(buf->data, buf->p, block1);
- if (block2)
- memcpy(buf->data + block1, swap_buffer, block2);
+ int block1 = buf->o;
+ int block2 = 0;
+
+ /* process output data in two steps to cover wrapping */
+ if (block1 > buf->p - buf->data) {
+ block2 = buf->p - buf->data;
+ block1 -= block2;
+ }
+ memcpy(swap_buffer + buf->size - buf->o, bo_ptr(buf), block1);
+ memcpy(swap_buffer + buf->size - block2, buf->data, block2);
+
+ /* process input data in two steps to cover wrapping */
+ block1 = buf->i;
+ block2 = 0;
+
+ if (block1 > buf->data + buf->size - buf->p) {
+ block1 = buf->data + buf->size - buf->p;
+ block2 = buf->i - block1;
}
+ memcpy(swap_buffer, bi_ptr(buf), block1);
+ memcpy(swap_buffer + block1, buf->data, block2);
+
+ /* reinject changes into the buffer */
+ memcpy(buf->data, swap_buffer, buf->i);
+ memcpy(buf->data + buf->size - buf->o, swap_buffer + buf->size - buf->o, buf->o);
buf->p = buf->data;
}
|
CWE-119
| null | null |
2,813
|
int init_buffer()
{
pool2_buffer = create_pool("buffer", sizeof (struct buffer) + global.tune.bufsize, MEM_F_SHARED);
return pool2_buffer != NULL;
}
|
Overflow +Info
| 0
|
int init_buffer()
{
pool2_buffer = create_pool("buffer", sizeof (struct buffer) + global.tune.bufsize, MEM_F_SHARED);
return pool2_buffer != NULL;
}
|
@@ -107,30 +107,39 @@ int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
return delta;
}
-/* This function realigns input data in a possibly wrapping buffer so that it
- * becomes contiguous and starts at the beginning of the buffer area. The
- * function may only be used when the buffer's output is empty.
+/* This function realigns a possibly wrapping buffer so that the input part is
+ * contiguous and starts at the beginning of the buffer and the output part
+ * ends at the end of the buffer. This provides the best conditions since it
+ * allows the largest inputs to be processed at once and ensures that once the
+ * output data leaves, the whole buffer is available at once.
*/
void buffer_slow_realign(struct buffer *buf)
{
- /* two possible cases :
- * - the buffer is in one contiguous block, we move it in-place
- * - the buffer is in two blocks, we move it via the swap_buffer
- */
- if (buf->i) {
- int block1 = buf->i;
- int block2 = 0;
- if (buf->p + buf->i > buf->data + buf->size) {
- /* non-contiguous block */
- block1 = buf->data + buf->size - buf->p;
- block2 = buf->p + buf->i - (buf->data + buf->size);
- }
- if (block2)
- memcpy(swap_buffer, buf->data, block2);
- memmove(buf->data, buf->p, block1);
- if (block2)
- memcpy(buf->data + block1, swap_buffer, block2);
+ int block1 = buf->o;
+ int block2 = 0;
+
+ /* process output data in two steps to cover wrapping */
+ if (block1 > buf->p - buf->data) {
+ block2 = buf->p - buf->data;
+ block1 -= block2;
+ }
+ memcpy(swap_buffer + buf->size - buf->o, bo_ptr(buf), block1);
+ memcpy(swap_buffer + buf->size - block2, buf->data, block2);
+
+ /* process input data in two steps to cover wrapping */
+ block1 = buf->i;
+ block2 = 0;
+
+ if (block1 > buf->data + buf->size - buf->p) {
+ block1 = buf->data + buf->size - buf->p;
+ block2 = buf->i - block1;
}
+ memcpy(swap_buffer, bi_ptr(buf), block1);
+ memcpy(swap_buffer + block1, buf->data, block2);
+
+ /* reinject changes into the buffer */
+ memcpy(buf->data, swap_buffer, buf->i);
+ memcpy(buf->data + buf->size - buf->o, swap_buffer + buf->size - buf->o, buf->o);
buf->p = buf->data;
}
|
CWE-119
| null | null |
2,814
|
gs_heap_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size,
client_name_t cname)
{
ulong lsize = (ulong) num_elements * elt_size;
if (lsize != (uint) lsize)
return 0;
return gs_heap_alloc_bytes(mem, (uint) lsize, cname);
}
|
DoS Overflow
| 0
|
gs_heap_alloc_byte_array(gs_memory_t * mem, uint num_elements, uint elt_size,
client_name_t cname)
{
ulong lsize = (ulong) num_elements * elt_size;
if (lsize != (uint) lsize)
return 0;
return gs_heap_alloc_bytes(mem, (uint) lsize, cname);
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,815
|
gs_heap_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
{
return gs_heap_alloc_bytes(mem, nbytes, cname);
}
|
DoS Overflow
| 0
|
gs_heap_alloc_string(gs_memory_t * mem, uint nbytes, client_name_t cname)
{
return gs_heap_alloc_bytes(mem, nbytes, cname);
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,816
|
gs_heap_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
client_name_t cname)
{
void *ptr =
gs_heap_alloc_bytes(mem, gs_struct_type_size(pstype), cname);
if (ptr == 0)
return 0;
((gs_malloc_block_t *) ptr)[-1].type = pstype;
return ptr;
}
|
DoS Overflow
| 0
|
gs_heap_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
client_name_t cname)
{
void *ptr =
gs_heap_alloc_bytes(mem, gs_struct_type_size(pstype), cname);
if (ptr == 0)
return 0;
((gs_malloc_block_t *) ptr)[-1].type = pstype;
return ptr;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,817
|
gs_heap_alloc_struct_array(gs_memory_t * mem, uint num_elements,
gs_memory_type_ptr_t pstype, client_name_t cname)
{
void *ptr =
gs_heap_alloc_byte_array(mem, num_elements,
gs_struct_type_size(pstype), cname);
if (ptr == 0)
return 0;
((gs_malloc_block_t *) ptr)[-1].type = pstype;
return ptr;
}
|
DoS Overflow
| 0
|
gs_heap_alloc_struct_array(gs_memory_t * mem, uint num_elements,
gs_memory_type_ptr_t pstype, client_name_t cname)
{
void *ptr =
gs_heap_alloc_byte_array(mem, num_elements,
gs_struct_type_size(pstype), cname);
if (ptr == 0)
return 0;
((gs_malloc_block_t *) ptr)[-1].type = pstype;
return ptr;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,818
|
gs_heap_enable_free(gs_memory_t * mem, bool enable)
{
if (enable)
mem->procs.free_object = gs_heap_free_object,
mem->procs.free_string = gs_heap_free_string;
else
mem->procs.free_object = gs_ignore_free_object,
mem->procs.free_string = gs_ignore_free_string;
}
|
DoS Overflow
| 0
|
gs_heap_enable_free(gs_memory_t * mem, bool enable)
{
if (enable)
mem->procs.free_object = gs_heap_free_object,
mem->procs.free_string = gs_heap_free_string;
else
mem->procs.free_object = gs_ignore_free_object,
mem->procs.free_string = gs_ignore_free_string;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,819
|
gs_heap_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
{
gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
gs_malloc_block_t *bp;
gs_memory_type_ptr_t pstype;
struct_proc_finalize((*finalize));
if_debug3m('a', mem, "[a-]gs_free(%s) 0x%lx(%u)\n",
client_name_string(cname), (ulong) ptr,
(ptr == 0 ? 0 : ((gs_malloc_block_t *) ptr)[-1].size));
if (ptr == 0)
return;
pstype = ((gs_malloc_block_t *) ptr)[-1].type;
finalize = pstype->finalize;
if (finalize != 0) {
if_debug3m('u', mem, "[u]finalizing %s 0x%lx (%s)\n",
struct_type_name_string(pstype),
(ulong) ptr, client_name_string(cname));
(*finalize) (mem, ptr);
}
if (mmem->monitor)
gx_monitor_enter(mmem->monitor); /* Exclusive access */
/* Previously, we used to search through every allocated block to find
* the block we are freeing. This gives us safety in that an attempt to
* free an unallocated block will not go wrong. This does radically
* slow down frees though, so we replace it with this simpler code; we
* now assume that the block is valid, and hence avoid the search.
*/
#if 1
bp = &((gs_malloc_block_t *)ptr)[-1];
if (bp->prev)
bp->prev->next = bp->next;
if (bp->next)
bp->next->prev = bp->prev;
if (bp == mmem->allocated) {
mmem->allocated = bp->next;
mmem->allocated->prev = NULL;
}
mmem->used -= bp->size + sizeof(gs_malloc_block_t);
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
gs_alloc_fill(bp, gs_alloc_fill_free,
bp->size + sizeof(gs_malloc_block_t));
free(bp);
#else
bp = mmem->allocated; /* If 'finalize' releases a memory,
this function could be called recursively and
change mmem->allocated. */
if (ptr == bp + 1) {
mmem->allocated = bp->next;
mmem->used -= bp->size + sizeof(gs_malloc_block_t);
if (mmem->allocated)
mmem->allocated->prev = 0;
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
gs_alloc_fill(bp, gs_alloc_fill_free,
bp->size + sizeof(gs_malloc_block_t));
free(bp);
} else {
gs_malloc_block_t *np;
/*
* bp == 0 at this point is an error, but we'd rather have an
* error message than an invalid access.
*/
if (bp) {
for (; (np = bp->next) != 0; bp = np) {
if (ptr == np + 1) {
bp->next = np->next;
if (np->next)
np->next->prev = bp;
mmem->used -= np->size + sizeof(gs_malloc_block_t);
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
gs_alloc_fill(np, gs_alloc_fill_free,
np->size + sizeof(gs_malloc_block_t));
free(np);
return;
}
}
}
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
lprintf2("%s: free 0x%lx not found!\n",
client_name_string(cname), (ulong) ptr);
free((char *)((gs_malloc_block_t *) ptr - 1));
}
#endif
}
|
DoS Overflow
| 0
|
gs_heap_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
{
gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
gs_malloc_block_t *bp;
gs_memory_type_ptr_t pstype;
struct_proc_finalize((*finalize));
if_debug3m('a', mem, "[a-]gs_free(%s) 0x%lx(%u)\n",
client_name_string(cname), (ulong) ptr,
(ptr == 0 ? 0 : ((gs_malloc_block_t *) ptr)[-1].size));
if (ptr == 0)
return;
pstype = ((gs_malloc_block_t *) ptr)[-1].type;
finalize = pstype->finalize;
if (finalize != 0) {
if_debug3m('u', mem, "[u]finalizing %s 0x%lx (%s)\n",
struct_type_name_string(pstype),
(ulong) ptr, client_name_string(cname));
(*finalize) (mem, ptr);
}
if (mmem->monitor)
gx_monitor_enter(mmem->monitor); /* Exclusive access */
/* Previously, we used to search through every allocated block to find
* the block we are freeing. This gives us safety in that an attempt to
* free an unallocated block will not go wrong. This does radically
* slow down frees though, so we replace it with this simpler code; we
* now assume that the block is valid, and hence avoid the search.
*/
#if 1
bp = &((gs_malloc_block_t *)ptr)[-1];
if (bp->prev)
bp->prev->next = bp->next;
if (bp->next)
bp->next->prev = bp->prev;
if (bp == mmem->allocated) {
mmem->allocated = bp->next;
mmem->allocated->prev = NULL;
}
mmem->used -= bp->size + sizeof(gs_malloc_block_t);
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
gs_alloc_fill(bp, gs_alloc_fill_free,
bp->size + sizeof(gs_malloc_block_t));
free(bp);
#else
bp = mmem->allocated; /* If 'finalize' releases a memory,
this function could be called recursively and
change mmem->allocated. */
if (ptr == bp + 1) {
mmem->allocated = bp->next;
mmem->used -= bp->size + sizeof(gs_malloc_block_t);
if (mmem->allocated)
mmem->allocated->prev = 0;
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
gs_alloc_fill(bp, gs_alloc_fill_free,
bp->size + sizeof(gs_malloc_block_t));
free(bp);
} else {
gs_malloc_block_t *np;
/*
* bp == 0 at this point is an error, but we'd rather have an
* error message than an invalid access.
*/
if (bp) {
for (; (np = bp->next) != 0; bp = np) {
if (ptr == np + 1) {
bp->next = np->next;
if (np->next)
np->next->prev = bp;
mmem->used -= np->size + sizeof(gs_malloc_block_t);
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
gs_alloc_fill(np, gs_alloc_fill_free,
np->size + sizeof(gs_malloc_block_t));
free(np);
return;
}
}
}
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
lprintf2("%s: free 0x%lx not found!\n",
client_name_string(cname), (ulong) ptr);
free((char *)((gs_malloc_block_t *) ptr - 1));
}
#endif
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,820
|
gs_heap_object_type(const gs_memory_t * mem, const void *ptr)
{
return ((const gs_malloc_block_t *)ptr)[-1].type;
}
|
DoS Overflow
| 0
|
gs_heap_object_type(const gs_memory_t * mem, const void *ptr)
{
return ((const gs_malloc_block_t *)ptr)[-1].type;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,821
|
gs_heap_register_root(gs_memory_t * mem, gs_gc_root_t * rp,
gs_ptr_type_t ptype, void **up, client_name_t cname)
{
return 0;
}
|
DoS Overflow
| 0
|
gs_heap_register_root(gs_memory_t * mem, gs_gc_root_t * rp,
gs_ptr_type_t ptype, void **up, client_name_t cname)
{
return 0;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,822
|
gs_heap_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
client_name_t cname)
{
gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
gs_malloc_block_t *ptr = (gs_malloc_block_t *) obj - 1;
gs_memory_type_ptr_t pstype = ptr->type;
uint old_size = gs_object_size(mem, obj) + sizeof(gs_malloc_block_t);
uint new_size =
gs_struct_type_size(pstype) * new_num_elements +
sizeof(gs_malloc_block_t);
gs_malloc_block_t *new_ptr;
if (new_size == old_size)
return obj;
if (mmem->monitor)
gx_monitor_enter(mmem->monitor); /* Exclusive access */
new_ptr = (gs_malloc_block_t *) gs_realloc(ptr, old_size, new_size);
if (new_ptr == 0)
return 0;
if (new_ptr->prev)
new_ptr->prev->next = new_ptr;
else
mmem->allocated = new_ptr;
if (new_ptr->next)
new_ptr->next->prev = new_ptr;
new_ptr->size = new_size - sizeof(gs_malloc_block_t);
mmem->used -= old_size;
mmem->used += new_size;
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
if (new_size > old_size)
gs_alloc_fill((byte *) new_ptr + old_size,
gs_alloc_fill_alloc, new_size - old_size);
return new_ptr + 1;
}
|
DoS Overflow
| 0
|
gs_heap_resize_object(gs_memory_t * mem, void *obj, uint new_num_elements,
client_name_t cname)
{
gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
gs_malloc_block_t *ptr = (gs_malloc_block_t *) obj - 1;
gs_memory_type_ptr_t pstype = ptr->type;
uint old_size = gs_object_size(mem, obj) + sizeof(gs_malloc_block_t);
uint new_size =
gs_struct_type_size(pstype) * new_num_elements +
sizeof(gs_malloc_block_t);
gs_malloc_block_t *new_ptr;
if (new_size == old_size)
return obj;
if (mmem->monitor)
gx_monitor_enter(mmem->monitor); /* Exclusive access */
new_ptr = (gs_malloc_block_t *) gs_realloc(ptr, old_size, new_size);
if (new_ptr == 0)
return 0;
if (new_ptr->prev)
new_ptr->prev->next = new_ptr;
else
mmem->allocated = new_ptr;
if (new_ptr->next)
new_ptr->next->prev = new_ptr;
new_ptr->size = new_size - sizeof(gs_malloc_block_t);
mmem->used -= old_size;
mmem->used += new_size;
if (mmem->monitor)
gx_monitor_leave(mmem->monitor); /* Done with exclusive access */
if (new_size > old_size)
gs_alloc_fill((byte *) new_ptr + old_size,
gs_alloc_fill_alloc, new_size - old_size);
return new_ptr + 1;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,823
|
gs_heap_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
client_name_t cname)
{
if (gs_heap_object_type(mem, data) != &st_bytes)
lprintf2("%s: resizing non-string 0x%lx!\n",
client_name_string(cname), (ulong) data);
return gs_heap_resize_object(mem, data, new_num, cname);
}
|
DoS Overflow
| 0
|
gs_heap_resize_string(gs_memory_t * mem, byte * data, uint old_num, uint new_num,
client_name_t cname)
{
if (gs_heap_object_type(mem, data) != &st_bytes)
lprintf2("%s: resizing non-string 0x%lx!\n",
client_name_string(cname), (ulong) data);
return gs_heap_resize_object(mem, data, new_num, cname);
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,824
|
gs_heap_status(gs_memory_t * mem, gs_memory_status_t * pstat)
{
gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
pstat->allocated = mmem->used + heap_available();
pstat->used = mmem->used;
pstat->is_thread_safe = true; /* this allocator has a mutex (monitor) and IS thread safe */
}
|
DoS Overflow
| 0
|
gs_heap_status(gs_memory_t * mem, gs_memory_status_t * pstat)
{
gs_malloc_memory_t *mmem = (gs_malloc_memory_t *) mem;
pstat->allocated = mmem->used + heap_available();
pstat->used = mmem->used;
pstat->is_thread_safe = true; /* this allocator has a mutex (monitor) and IS thread safe */
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,825
|
gs_heap_unregister_root(gs_memory_t * mem, gs_gc_root_t * rp,
client_name_t cname)
{
}
|
DoS Overflow
| 0
|
gs_heap_unregister_root(gs_memory_t * mem, gs_gc_root_t * rp,
client_name_t cname)
{
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,826
|
gs_malloc_init(void)
{
gs_malloc_memory_t *malloc_memory_default = gs_malloc_memory_init();
gs_memory_t *memory_t_default;
if (malloc_memory_default == NULL)
return NULL;
if (gs_lib_ctx_init((gs_memory_t *)malloc_memory_default) != 0)
return NULL;
#if defined(USE_RETRY_MEMORY_WRAPPER)
gs_malloc_wrap(&memory_t_default, malloc_memory_default);
#else
memory_t_default = (gs_memory_t *)malloc_memory_default;
#endif
memory_t_default->stable_memory = memory_t_default;
return memory_t_default;
}
|
DoS Overflow
| 0
|
gs_malloc_init(void)
{
gs_malloc_memory_t *malloc_memory_default = gs_malloc_memory_init();
gs_memory_t *memory_t_default;
if (malloc_memory_default == NULL)
return NULL;
if (gs_lib_ctx_init((gs_memory_t *)malloc_memory_default) != 0)
return NULL;
#if defined(USE_RETRY_MEMORY_WRAPPER)
gs_malloc_wrap(&memory_t_default, malloc_memory_default);
#else
memory_t_default = (gs_memory_t *)malloc_memory_default;
#endif
memory_t_default->stable_memory = memory_t_default;
return memory_t_default;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,827
|
gs_malloc_memory_init(void)
{
gs_malloc_memory_t *mem =
(gs_malloc_memory_t *)Memento_label(malloc(sizeof(gs_malloc_memory_t)), "gs_malloc_memory_t");
if (mem == NULL)
return NULL;
mem->stable_memory = 0; /* just for tidyness, never referenced */
mem->procs = gs_malloc_memory_procs;
mem->allocated = 0;
mem->limit = max_long;
mem->used = 0;
mem->max_used = 0;
mem->gs_lib_ctx = 0;
mem->non_gc_memory = (gs_memory_t *)mem;
mem->thread_safe_memory = (gs_memory_t *)mem; /* this allocator is thread safe */
/* Allocate a monitor to serialize access to structures within */
mem->monitor = NULL; /* prevent use during initial allocation */
mem->monitor = gx_monitor_alloc((gs_memory_t *)mem);
return mem;
}
|
DoS Overflow
| 0
|
gs_malloc_memory_init(void)
{
gs_malloc_memory_t *mem =
(gs_malloc_memory_t *)Memento_label(malloc(sizeof(gs_malloc_memory_t)), "gs_malloc_memory_t");
if (mem == NULL)
return NULL;
mem->stable_memory = 0; /* just for tidyness, never referenced */
mem->procs = gs_malloc_memory_procs;
mem->allocated = 0;
mem->limit = max_long;
mem->used = 0;
mem->max_used = 0;
mem->gs_lib_ctx = 0;
mem->non_gc_memory = (gs_memory_t *)mem;
mem->thread_safe_memory = (gs_memory_t *)mem; /* this allocator is thread safe */
/* Allocate a monitor to serialize access to structures within */
mem->monitor = NULL; /* prevent use during initial allocation */
mem->monitor = gx_monitor_alloc((gs_memory_t *)mem);
return mem;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,828
|
gs_malloc_release(gs_memory_t *mem)
{
gs_malloc_memory_t * malloc_memory_default;
if (mem == NULL)
return;
/* Use gs_debug['a'] if gs_debug[':'] is set to dump the heap stats */
if (gs_debug[':']) {
void *temp;
char save_debug_a = gs_debug['a'];
gs_debug['a'] = 1;
temp = (char *)gs_alloc_bytes_immovable(mem, 8, "gs_malloc_release");
gs_debug['a'] = save_debug_a;
gs_free_object(mem, temp, "gs_malloc_release");
}
#ifdef USE_RETRY_MEMORY_WRAPPER
malloc_memory_default = gs_malloc_unwrap(mem);
#else
malloc_memory_default = (gs_malloc_memory_t *)mem;
#endif
gs_lib_ctx_fin((gs_memory_t *)malloc_memory_default);
gs_malloc_memory_release(malloc_memory_default);
}
|
DoS Overflow
| 0
|
gs_malloc_release(gs_memory_t *mem)
{
gs_malloc_memory_t * malloc_memory_default;
if (mem == NULL)
return;
/* Use gs_debug['a'] if gs_debug[':'] is set to dump the heap stats */
if (gs_debug[':']) {
void *temp;
char save_debug_a = gs_debug['a'];
gs_debug['a'] = 1;
temp = (char *)gs_alloc_bytes_immovable(mem, 8, "gs_malloc_release");
gs_debug['a'] = save_debug_a;
gs_free_object(mem, temp, "gs_malloc_release");
}
#ifdef USE_RETRY_MEMORY_WRAPPER
malloc_memory_default = gs_malloc_unwrap(mem);
#else
malloc_memory_default = (gs_malloc_memory_t *)mem;
#endif
gs_lib_ctx_fin((gs_memory_t *)malloc_memory_default);
gs_malloc_memory_release(malloc_memory_default);
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,829
|
gs_malloc_unwrap(gs_memory_t *wrapped)
{
#ifdef USE_RETRY_MEMORY_WRAPPER
gs_memory_retrying_t *rmem = (gs_memory_retrying_t *)wrapped;
gs_memory_t *contents = gs_memory_retrying_target(rmem);
gs_free_object(wrapped rmem, "gs_malloc_unwrap(retrying)");
return (gs_malloc_memory_t *)contents;
#else
return (gs_malloc_memory_t *)wrapped;
#endif
}
|
DoS Overflow
| 0
|
gs_malloc_unwrap(gs_memory_t *wrapped)
{
#ifdef USE_RETRY_MEMORY_WRAPPER
gs_memory_retrying_t *rmem = (gs_memory_retrying_t *)wrapped;
gs_memory_t *contents = gs_memory_retrying_target(rmem);
gs_free_object(wrapped rmem, "gs_malloc_unwrap(retrying)");
return (gs_malloc_memory_t *)contents;
#else
return (gs_malloc_memory_t *)wrapped;
#endif
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,830
|
gs_malloc_wrap(gs_memory_t **wrapped, gs_malloc_memory_t *contents)
{
# ifdef USE_RETRY_MEMORY_WRAPPER
/*
* This is deprecated since 'retry' for clist reversion/cycling
* will ONLY work for monochrome, simple PS or PCL, not for a
* color device and not for PDF or XPS with transparency
*/
{
gs_memory_retrying_t *rmem;
rmem = (gs_memory_retrying_t *)
gs_alloc_bytes_immovable((gs_memory_t *)lmem,
sizeof(gs_memory_retrying_t),
"gs_malloc_wrap(retrying)");
if (rmem == 0) {
gs_memory_locked_release(lmem);
gs_free_object(cmem, lmem, "gs_malloc_wrap(locked)");
return_error(gs_error_VMerror);
}
code = gs_memory_retrying_init(rmem, (gs_memory_t *)lmem);
if (code < 0) {
gs_free_object((gs_memory_t *)lmem, rmem, "gs_malloc_wrap(retrying)");
gs_memory_locked_release(lmem);
gs_free_object(cmem, lmem, "gs_malloc_wrap(locked)");
return code;
}
*wrapped = (gs_memory_t *)rmem;
}
# endif /* retrying */
return 0;
}
|
DoS Overflow
| 0
|
gs_malloc_wrap(gs_memory_t **wrapped, gs_malloc_memory_t *contents)
{
# ifdef USE_RETRY_MEMORY_WRAPPER
/*
* This is deprecated since 'retry' for clist reversion/cycling
* will ONLY work for monochrome, simple PS or PCL, not for a
* color device and not for PDF or XPS with transparency
*/
{
gs_memory_retrying_t *rmem;
rmem = (gs_memory_retrying_t *)
gs_alloc_bytes_immovable((gs_memory_t *)lmem,
sizeof(gs_memory_retrying_t),
"gs_malloc_wrap(retrying)");
if (rmem == 0) {
gs_memory_locked_release(lmem);
gs_free_object(cmem, lmem, "gs_malloc_wrap(locked)");
return_error(gs_error_VMerror);
}
code = gs_memory_retrying_init(rmem, (gs_memory_t *)lmem);
if (code < 0) {
gs_free_object((gs_memory_t *)lmem, rmem, "gs_malloc_wrap(retrying)");
gs_memory_locked_release(lmem);
gs_free_object(cmem, lmem, "gs_malloc_wrap(locked)");
return code;
}
*wrapped = (gs_memory_t *)rmem;
}
# endif /* retrying */
return 0;
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,831
|
gs_malloc_wrapped_contents(gs_memory_t *wrapped)
{
#ifdef USE_RETRY_MEMORY_WRAPPER
gs_memory_retrying_t *rmem = (gs_memory_retrying_t *)wrapped;
return (gs_malloc_memory_t *)gs_memory_retrying_target(rmem);
#else /* retrying */
return (gs_malloc_memory_t *)wrapped;
#endif /* retrying */
}
|
DoS Overflow
| 0
|
gs_malloc_wrapped_contents(gs_memory_t *wrapped)
{
#ifdef USE_RETRY_MEMORY_WRAPPER
gs_memory_retrying_t *rmem = (gs_memory_retrying_t *)wrapped;
return (gs_malloc_memory_t *)gs_memory_retrying_target(rmem);
#else /* retrying */
return (gs_malloc_memory_t *)wrapped;
#endif /* retrying */
}
|
@@ -178,7 +178,7 @@ gs_heap_alloc_bytes(gs_memory_t * mem, uint size, client_name_t cname)
} else {
uint added = size + sizeof(gs_malloc_block_t);
- if (mmem->limit - added < mmem->used)
+ if (added <= size || mmem->limit - added < mmem->used)
set_msg("exceeded limit");
else if ((ptr = (byte *) Memento_label(malloc(added), cname)) == 0)
set_msg("failed");
|
CWE-189
| null | null |
2,832
|
static int ldb_match_comparison(struct ldb_context *ldb,
const struct ldb_message *msg,
const struct ldb_parse_tree *tree,
enum ldb_scope scope,
enum ldb_parse_op comp_op, bool *matched)
{
unsigned int i;
struct ldb_message_element *el;
const struct ldb_schema_attribute *a;
/* FIXME: APPROX comparison not handled yet */
if (comp_op == LDB_OP_APPROX) {
return LDB_ERR_INAPPROPRIATE_MATCHING;
}
el = ldb_msg_find_element(msg, tree->u.comparison.attr);
if (el == NULL) {
*matched = false;
return LDB_SUCCESS;
}
a = ldb_schema_attribute_by_name(ldb, el->name);
if (!a) {
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
for (i = 0; i < el->num_values; i++) {
if (a->syntax->operator_fn) {
int ret;
ret = a->syntax->operator_fn(ldb, comp_op, a, &el->values[i], &tree->u.comparison.value, matched);
if (ret != LDB_SUCCESS) return ret;
if (*matched) return LDB_SUCCESS;
} else {
int ret = a->syntax->comparison_fn(ldb, ldb, &el->values[i], &tree->u.comparison.value);
if (ret == 0) {
*matched = true;
return LDB_SUCCESS;
}
if (ret > 0 && comp_op == LDB_OP_GREATER) {
*matched = true;
return LDB_SUCCESS;
}
if (ret < 0 && comp_op == LDB_OP_LESS) {
*matched = true;
return LDB_SUCCESS;
}
}
}
*matched = false;
return LDB_SUCCESS;
}
|
DoS
| 0
|
static int ldb_match_comparison(struct ldb_context *ldb,
const struct ldb_message *msg,
const struct ldb_parse_tree *tree,
enum ldb_scope scope,
enum ldb_parse_op comp_op, bool *matched)
{
unsigned int i;
struct ldb_message_element *el;
const struct ldb_schema_attribute *a;
/* FIXME: APPROX comparison not handled yet */
if (comp_op == LDB_OP_APPROX) {
return LDB_ERR_INAPPROPRIATE_MATCHING;
}
el = ldb_msg_find_element(msg, tree->u.comparison.attr);
if (el == NULL) {
*matched = false;
return LDB_SUCCESS;
}
a = ldb_schema_attribute_by_name(ldb, el->name);
if (!a) {
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
for (i = 0; i < el->num_values; i++) {
if (a->syntax->operator_fn) {
int ret;
ret = a->syntax->operator_fn(ldb, comp_op, a, &el->values[i], &tree->u.comparison.value, matched);
if (ret != LDB_SUCCESS) return ret;
if (*matched) return LDB_SUCCESS;
} else {
int ret = a->syntax->comparison_fn(ldb, ldb, &el->values[i], &tree->u.comparison.value);
if (ret == 0) {
*matched = true;
return LDB_SUCCESS;
}
if (ret > 0 && comp_op == LDB_OP_GREATER) {
*matched = true;
return LDB_SUCCESS;
}
if (ret < 0 && comp_op == LDB_OP_LESS) {
*matched = true;
return LDB_SUCCESS;
}
}
}
*matched = false;
return LDB_SUCCESS;
}
|
@@ -271,6 +271,14 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
if (cnk.length > val.length) {
goto mismatch;
}
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
+
if (memcmp((char *)val.data, (char *)cnk.data, cnk.length) != 0) goto mismatch;
val.length -= cnk.length;
val.data += cnk.length;
@@ -284,7 +292,13 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
chunk = tree->u.substring.chunks[c];
if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto mismatch;
- /* FIXME: case of embedded nulls */
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
p = strstr((char *)val.data, (char *)cnk.data);
if (p == NULL) goto mismatch;
if ( (! tree->u.substring.chunks[c + 1]) && (! tree->u.substring.end_with_wildcard) ) {
|
CWE-189
| null | null |
2,833
|
static int ldb_match_equality(struct ldb_context *ldb,
const struct ldb_message *msg,
const struct ldb_parse_tree *tree,
enum ldb_scope scope,
bool *matched)
{
unsigned int i;
struct ldb_message_element *el;
const struct ldb_schema_attribute *a;
struct ldb_dn *valuedn;
int ret;
if (ldb_attr_dn(tree->u.equality.attr) == 0) {
valuedn = ldb_dn_from_ldb_val(ldb, ldb, &tree->u.equality.value);
if (valuedn == NULL) {
return LDB_ERR_INVALID_DN_SYNTAX;
}
ret = ldb_dn_compare(msg->dn, valuedn);
talloc_free(valuedn);
*matched = (ret == 0);
return LDB_SUCCESS;
}
/* TODO: handle the "*" case derived from an extended search
operation without the attibute type defined */
el = ldb_msg_find_element(msg, tree->u.equality.attr);
if (el == NULL) {
*matched = false;
return LDB_SUCCESS;
}
a = ldb_schema_attribute_by_name(ldb, el->name);
if (a == NULL) {
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
for (i=0;i<el->num_values;i++) {
if (a->syntax->operator_fn) {
ret = a->syntax->operator_fn(ldb, LDB_OP_EQUALITY, a,
&tree->u.equality.value, &el->values[i], matched);
if (ret != LDB_SUCCESS) return ret;
if (*matched) return LDB_SUCCESS;
} else {
if (a->syntax->comparison_fn(ldb, ldb, &tree->u.equality.value,
&el->values[i]) == 0) {
*matched = true;
return LDB_SUCCESS;
}
}
}
*matched = false;
return LDB_SUCCESS;
}
|
DoS
| 0
|
static int ldb_match_equality(struct ldb_context *ldb,
const struct ldb_message *msg,
const struct ldb_parse_tree *tree,
enum ldb_scope scope,
bool *matched)
{
unsigned int i;
struct ldb_message_element *el;
const struct ldb_schema_attribute *a;
struct ldb_dn *valuedn;
int ret;
if (ldb_attr_dn(tree->u.equality.attr) == 0) {
valuedn = ldb_dn_from_ldb_val(ldb, ldb, &tree->u.equality.value);
if (valuedn == NULL) {
return LDB_ERR_INVALID_DN_SYNTAX;
}
ret = ldb_dn_compare(msg->dn, valuedn);
talloc_free(valuedn);
*matched = (ret == 0);
return LDB_SUCCESS;
}
/* TODO: handle the "*" case derived from an extended search
operation without the attibute type defined */
el = ldb_msg_find_element(msg, tree->u.equality.attr);
if (el == NULL) {
*matched = false;
return LDB_SUCCESS;
}
a = ldb_schema_attribute_by_name(ldb, el->name);
if (a == NULL) {
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
for (i=0;i<el->num_values;i++) {
if (a->syntax->operator_fn) {
ret = a->syntax->operator_fn(ldb, LDB_OP_EQUALITY, a,
&tree->u.equality.value, &el->values[i], matched);
if (ret != LDB_SUCCESS) return ret;
if (*matched) return LDB_SUCCESS;
} else {
if (a->syntax->comparison_fn(ldb, ldb, &tree->u.equality.value,
&el->values[i]) == 0) {
*matched = true;
return LDB_SUCCESS;
}
}
}
*matched = false;
return LDB_SUCCESS;
}
|
@@ -271,6 +271,14 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
if (cnk.length > val.length) {
goto mismatch;
}
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
+
if (memcmp((char *)val.data, (char *)cnk.data, cnk.length) != 0) goto mismatch;
val.length -= cnk.length;
val.data += cnk.length;
@@ -284,7 +292,13 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
chunk = tree->u.substring.chunks[c];
if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto mismatch;
- /* FIXME: case of embedded nulls */
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
p = strstr((char *)val.data, (char *)cnk.data);
if (p == NULL) goto mismatch;
if ( (! tree->u.substring.chunks[c + 1]) && (! tree->u.substring.end_with_wildcard) ) {
|
CWE-189
| null | null |
2,834
|
static int ldb_match_present(struct ldb_context *ldb,
const struct ldb_message *msg,
const struct ldb_parse_tree *tree,
enum ldb_scope scope, bool *matched)
{
const struct ldb_schema_attribute *a;
struct ldb_message_element *el;
if (ldb_attr_dn(tree->u.present.attr) == 0) {
*matched = true;
return LDB_SUCCESS;
}
el = ldb_msg_find_element(msg, tree->u.present.attr);
if (el == NULL) {
*matched = false;
return LDB_SUCCESS;
}
a = ldb_schema_attribute_by_name(ldb, el->name);
if (!a) {
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
if (a->syntax->operator_fn) {
unsigned int i;
for (i = 0; i < el->num_values; i++) {
int ret = a->syntax->operator_fn(ldb, LDB_OP_PRESENT, a, &el->values[i], NULL, matched);
if (ret != LDB_SUCCESS) return ret;
if (*matched) return LDB_SUCCESS;
}
*matched = false;
return LDB_SUCCESS;
}
*matched = true;
return LDB_SUCCESS;
}
|
DoS
| 0
|
static int ldb_match_present(struct ldb_context *ldb,
const struct ldb_message *msg,
const struct ldb_parse_tree *tree,
enum ldb_scope scope, bool *matched)
{
const struct ldb_schema_attribute *a;
struct ldb_message_element *el;
if (ldb_attr_dn(tree->u.present.attr) == 0) {
*matched = true;
return LDB_SUCCESS;
}
el = ldb_msg_find_element(msg, tree->u.present.attr);
if (el == NULL) {
*matched = false;
return LDB_SUCCESS;
}
a = ldb_schema_attribute_by_name(ldb, el->name);
if (!a) {
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
if (a->syntax->operator_fn) {
unsigned int i;
for (i = 0; i < el->num_values; i++) {
int ret = a->syntax->operator_fn(ldb, LDB_OP_PRESENT, a, &el->values[i], NULL, matched);
if (ret != LDB_SUCCESS) return ret;
if (*matched) return LDB_SUCCESS;
}
*matched = false;
return LDB_SUCCESS;
}
*matched = true;
return LDB_SUCCESS;
}
|
@@ -271,6 +271,14 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
if (cnk.length > val.length) {
goto mismatch;
}
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
+
if (memcmp((char *)val.data, (char *)cnk.data, cnk.length) != 0) goto mismatch;
val.length -= cnk.length;
val.data += cnk.length;
@@ -284,7 +292,13 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
chunk = tree->u.substring.chunks[c];
if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto mismatch;
- /* FIXME: case of embedded nulls */
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
p = strstr((char *)val.data, (char *)cnk.data);
if (p == NULL) goto mismatch;
if ( (! tree->u.substring.chunks[c + 1]) && (! tree->u.substring.end_with_wildcard) ) {
|
CWE-189
| null | null |
2,835
|
static int ldb_match_scope(struct ldb_context *ldb,
struct ldb_dn *base,
struct ldb_dn *dn,
enum ldb_scope scope)
{
int ret = 0;
if (base == NULL || dn == NULL) {
return 1;
}
switch (scope) {
case LDB_SCOPE_BASE:
if (ldb_dn_compare(base, dn) == 0) {
ret = 1;
}
break;
case LDB_SCOPE_ONELEVEL:
if (ldb_dn_get_comp_num(dn) == (ldb_dn_get_comp_num(base) + 1)) {
if (ldb_dn_compare_base(base, dn) == 0) {
ret = 1;
}
}
break;
case LDB_SCOPE_SUBTREE:
default:
if (ldb_dn_compare_base(base, dn) == 0) {
ret = 1;
}
break;
}
return ret;
}
|
DoS
| 0
|
static int ldb_match_scope(struct ldb_context *ldb,
struct ldb_dn *base,
struct ldb_dn *dn,
enum ldb_scope scope)
{
int ret = 0;
if (base == NULL || dn == NULL) {
return 1;
}
switch (scope) {
case LDB_SCOPE_BASE:
if (ldb_dn_compare(base, dn) == 0) {
ret = 1;
}
break;
case LDB_SCOPE_ONELEVEL:
if (ldb_dn_get_comp_num(dn) == (ldb_dn_get_comp_num(base) + 1)) {
if (ldb_dn_compare_base(base, dn) == 0) {
ret = 1;
}
}
break;
case LDB_SCOPE_SUBTREE:
default:
if (ldb_dn_compare_base(base, dn) == 0) {
ret = 1;
}
break;
}
return ret;
}
|
@@ -271,6 +271,14 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
if (cnk.length > val.length) {
goto mismatch;
}
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
+
if (memcmp((char *)val.data, (char *)cnk.data, cnk.length) != 0) goto mismatch;
val.length -= cnk.length;
val.data += cnk.length;
@@ -284,7 +292,13 @@ static int ldb_wildcard_compare(struct ldb_context *ldb,
chunk = tree->u.substring.chunks[c];
if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto mismatch;
- /* FIXME: case of embedded nulls */
+ /*
+ * Empty strings are returned as length 0. Ensure
+ * we can cope with this.
+ */
+ if (cnk.length == 0) {
+ goto mismatch;
+ }
p = strstr((char *)val.data, (char *)cnk.data);
if (p == NULL) goto mismatch;
if ( (! tree->u.substring.chunks[c + 1]) && (! tree->u.substring.end_with_wildcard) ) {
|
CWE-189
| null | null |
2,836
|
api_opaque_lsa_print (struct lsa_header *data)
{
struct opaque_lsa
{
struct lsa_header header;
u_char mydata[];
};
struct opaque_lsa *olsa;
int opaquelen;
int i;
ospf_lsa_header_dump (data);
olsa = (struct opaque_lsa *) data;
opaquelen = ntohs (data->length) - OSPF_LSA_HEADER_SIZE;
zlog_debug ("apiserver_lsa_print: opaquelen=%d\n", opaquelen);
for (i = 0; i < opaquelen; i++)
{
zlog_debug ("0x%x ", olsa->mydata[i]);
}
zlog_debug ("\n");
}
|
DoS Overflow
| 0
|
api_opaque_lsa_print (struct lsa_header *data)
{
struct opaque_lsa
{
struct lsa_header header;
u_char mydata[];
};
struct opaque_lsa *olsa;
int opaquelen;
int i;
ospf_lsa_header_dump (data);
olsa = (struct opaque_lsa *) data;
opaquelen = ntohs (data->length) - OSPF_LSA_HEADER_SIZE;
zlog_debug ("apiserver_lsa_print: opaquelen=%d\n", opaquelen);
for (i = 0; i < opaquelen; i++)
{
zlog_debug ("0x%x ", olsa->mydata[i]);
}
zlog_debug ("\n");
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,837
|
msg_dup (struct msg *msg)
{
struct msg *new;
assert (msg);
new = msg_new (msg->hdr.msgtype, STREAM_DATA (msg->s),
ntohl (msg->hdr.msgseq), ntohs (msg->hdr.msglen));
return new;
}
|
DoS Overflow
| 0
|
msg_dup (struct msg *msg)
{
struct msg *new;
assert (msg);
new = msg_new (msg->hdr.msgtype, STREAM_DATA (msg->s),
ntohl (msg->hdr.msgseq), ntohs (msg->hdr.msglen));
return new;
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,838
|
msg_fifo_flush (struct msg_fifo *fifo)
{
struct msg *op;
struct msg *next;
for (op = fifo->head; op; op = next)
{
next = op->next;
msg_free (op);
}
fifo->head = fifo->tail = NULL;
fifo->count = 0;
}
|
DoS Overflow
| 0
|
msg_fifo_flush (struct msg_fifo *fifo)
{
struct msg *op;
struct msg *next;
for (op = fifo->head; op; op = next)
{
next = op->next;
msg_free (op);
}
fifo->head = fifo->tail = NULL;
fifo->count = 0;
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,839
|
msg_fifo_free (struct msg_fifo *fifo)
{
msg_fifo_flush (fifo);
XFREE (MTYPE_OSPF_API_FIFO, fifo);
}
|
DoS Overflow
| 0
|
msg_fifo_free (struct msg_fifo *fifo)
{
msg_fifo_flush (fifo);
XFREE (MTYPE_OSPF_API_FIFO, fifo);
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,840
|
msg_fifo_head (struct msg_fifo *fifo)
{
return fifo->head;
}
|
DoS Overflow
| 0
|
msg_fifo_head (struct msg_fifo *fifo)
{
return fifo->head;
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,841
|
msg_fifo_new ()
{
return XCALLOC (MTYPE_OSPF_API_FIFO, sizeof (struct msg_fifo));
}
|
DoS Overflow
| 0
|
msg_fifo_new ()
{
return XCALLOC (MTYPE_OSPF_API_FIFO, sizeof (struct msg_fifo));
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,842
|
msg_fifo_push (struct msg_fifo *fifo, struct msg *msg)
{
if (fifo->tail)
fifo->tail->next = msg;
else
fifo->head = msg;
fifo->tail = msg;
fifo->count++;
}
|
DoS Overflow
| 0
|
msg_fifo_push (struct msg_fifo *fifo, struct msg *msg)
{
if (fifo->tail)
fifo->tail->next = msg;
else
fifo->head = msg;
fifo->tail = msg;
fifo->count++;
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,843
|
msg_free (struct msg *msg)
{
if (msg->s)
stream_free (msg->s);
XFREE (MTYPE_OSPF_API_MSG, msg);
}
|
DoS Overflow
| 0
|
msg_free (struct msg *msg)
{
if (msg->s)
stream_free (msg->s);
XFREE (MTYPE_OSPF_API_MSG, msg);
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,844
|
msg_get_seq (struct msg *msg)
{
assert (msg);
return ntohl (msg->hdr.msgseq);
}
|
DoS Overflow
| 0
|
msg_get_seq (struct msg *msg)
{
assert (msg);
return ntohl (msg->hdr.msgseq);
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,845
|
msg_new (u_char msgtype, void *msgbody, u_int32_t seqnum, u_int16_t msglen)
{
struct msg *new;
new = XCALLOC (MTYPE_OSPF_API_MSG, sizeof (struct msg));
new->hdr.version = OSPF_API_VERSION;
new->hdr.msgtype = msgtype;
new->hdr.msglen = htons (msglen);
new->hdr.msgseq = htonl (seqnum);
new->s = stream_new (msglen);
assert (new->s);
stream_put (new->s, msgbody, msglen);
return new;
}
|
DoS Overflow
| 0
|
msg_new (u_char msgtype, void *msgbody, u_int32_t seqnum, u_int16_t msglen)
{
struct msg *new;
new = XCALLOC (MTYPE_OSPF_API_MSG, sizeof (struct msg));
new->hdr.version = OSPF_API_VERSION;
new->hdr.msgtype = msgtype;
new->hdr.msglen = htons (msglen);
new->hdr.msgseq = htonl (seqnum);
new->s = stream_new (msglen);
assert (new->s);
stream_put (new->s, msgbody, msglen);
return new;
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,846
|
msg_print (struct msg *msg)
{
if (!msg)
{
zlog_debug ("msg_print msg=NULL!\n");
return;
}
#ifdef ORIGINAL_CODING
zlog_debug
("msg=%p msgtype=%d msglen=%d msgseq=%d streamdata=%p streamsize=%lu\n",
msg, msg->hdr.msgtype, ntohs (msg->hdr.msglen), ntohl (msg->hdr.msgseq),
STREAM_DATA (msg->s), STREAM_SIZE (msg->s));
#else /* ORIGINAL_CODING */
/* API message common header part. */
zlog_debug
("API-msg [%s]: type(%d),len(%d),seq(%lu),data(%p),size(%zd)",
ospf_api_typename (msg->hdr.msgtype), msg->hdr.msgtype,
ntohs (msg->hdr.msglen), (unsigned long) ntohl (msg->hdr.msgseq),
STREAM_DATA (msg->s), STREAM_SIZE (msg->s));
/* API message body part. */
#ifdef ndef
/* Generic Hex/Ascii dump */
DumpBuf (STREAM_DATA (msg->s), STREAM_SIZE (msg->s)); /* Sorry, deleted! */
#else /* ndef */
/* Message-type dependent dump function. */
#endif /* ndef */
return;
#endif /* ORIGINAL_CODING */
}
|
DoS Overflow
| 0
|
msg_print (struct msg *msg)
{
if (!msg)
{
zlog_debug ("msg_print msg=NULL!\n");
return;
}
#ifdef ORIGINAL_CODING
zlog_debug
("msg=%p msgtype=%d msglen=%d msgseq=%d streamdata=%p streamsize=%lu\n",
msg, msg->hdr.msgtype, ntohs (msg->hdr.msglen), ntohl (msg->hdr.msgseq),
STREAM_DATA (msg->s), STREAM_SIZE (msg->s));
#else /* ORIGINAL_CODING */
/* API message common header part. */
zlog_debug
("API-msg [%s]: type(%d),len(%d),seq(%lu),data(%p),size(%zd)",
ospf_api_typename (msg->hdr.msgtype), msg->hdr.msgtype,
ntohs (msg->hdr.msglen), (unsigned long) ntohl (msg->hdr.msgseq),
STREAM_DATA (msg->s), STREAM_SIZE (msg->s));
/* API message body part. */
#ifdef ndef
/* Generic Hex/Ascii dump */
DumpBuf (STREAM_DATA (msg->s), STREAM_SIZE (msg->s)); /* Sorry, deleted! */
#else /* ndef */
/* Message-type dependent dump function. */
#endif /* ndef */
return;
#endif /* ORIGINAL_CODING */
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,847
|
msg_read (int fd)
{
struct msg *msg;
struct apimsghdr hdr;
u_char buf[OSPF_API_MAX_MSG_SIZE];
int bodylen;
int rlen;
/* Read message header */
rlen = readn (fd, (u_char *) &hdr, sizeof (struct apimsghdr));
if (rlen < 0)
{
zlog_warn ("msg_read: readn %s", safe_strerror (errno));
return NULL;
}
else if (rlen == 0)
{
zlog_warn ("msg_read: Connection closed by peer");
return NULL;
}
else if (rlen != sizeof (struct apimsghdr))
{
zlog_warn ("msg_read: Cannot read message header!");
return NULL;
}
/* Check version of API protocol */
if (hdr.version != OSPF_API_VERSION)
{
zlog_warn ("msg_read: OSPF API protocol version mismatch");
return NULL;
}
/* Determine body length. */
bodylen = ntohs (hdr.msglen);
if (bodylen > 0)
{
/* Read message body */
rlen = readn (fd, buf, bodylen);
if (rlen < 0)
{
zlog_warn ("msg_read: readn %s", safe_strerror (errno));
return NULL;
}
else if (rlen == 0)
{
zlog_warn ("msg_read: Connection closed by peer");
return NULL;
}
else if (rlen != bodylen)
{
zlog_warn ("msg_read: Cannot read message body!");
return NULL;
}
}
/* Allocate new message */
msg = msg_new (hdr.msgtype, buf, ntohl (hdr.msgseq), ntohs (hdr.msglen));
return msg;
}
|
DoS Overflow
| 0
|
msg_read (int fd)
{
struct msg *msg;
struct apimsghdr hdr;
u_char buf[OSPF_API_MAX_MSG_SIZE];
int bodylen;
int rlen;
/* Read message header */
rlen = readn (fd, (u_char *) &hdr, sizeof (struct apimsghdr));
if (rlen < 0)
{
zlog_warn ("msg_read: readn %s", safe_strerror (errno));
return NULL;
}
else if (rlen == 0)
{
zlog_warn ("msg_read: Connection closed by peer");
return NULL;
}
else if (rlen != sizeof (struct apimsghdr))
{
zlog_warn ("msg_read: Cannot read message header!");
return NULL;
}
/* Check version of API protocol */
if (hdr.version != OSPF_API_VERSION)
{
zlog_warn ("msg_read: OSPF API protocol version mismatch");
return NULL;
}
/* Determine body length. */
bodylen = ntohs (hdr.msglen);
if (bodylen > 0)
{
/* Read message body */
rlen = readn (fd, buf, bodylen);
if (rlen < 0)
{
zlog_warn ("msg_read: readn %s", safe_strerror (errno));
return NULL;
}
else if (rlen == 0)
{
zlog_warn ("msg_read: Connection closed by peer");
return NULL;
}
else if (rlen != bodylen)
{
zlog_warn ("msg_read: Cannot read message body!");
return NULL;
}
}
/* Allocate new message */
msg = msg_new (hdr.msgtype, buf, ntohl (hdr.msgseq), ntohs (hdr.msglen));
return msg;
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,848
|
msg_set_seq (struct msg *msg, u_int32_t seqnr)
{
assert (msg);
msg->hdr.msgseq = htonl (seqnr);
}
|
DoS Overflow
| 0
|
msg_set_seq (struct msg *msg, u_int32_t seqnr)
{
assert (msg);
msg->hdr.msgseq = htonl (seqnr);
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,849
|
new_msg_register_opaque_type (u_int32_t seqnum, u_char ltype, u_char otype)
{
struct msg_register_opaque_type rmsg;
rmsg.lsatype = ltype;
rmsg.opaquetype = otype;
memset (&rmsg.pad, 0, sizeof (rmsg.pad));
return msg_new (MSG_REGISTER_OPAQUETYPE, &rmsg, seqnum,
sizeof (struct msg_register_opaque_type));
}
|
DoS Overflow
| 0
|
new_msg_register_opaque_type (u_int32_t seqnum, u_char ltype, u_char otype)
{
struct msg_register_opaque_type rmsg;
rmsg.lsatype = ltype;
rmsg.opaquetype = otype;
memset (&rmsg.pad, 0, sizeof (rmsg.pad));
return msg_new (MSG_REGISTER_OPAQUETYPE, &rmsg, seqnum,
sizeof (struct msg_register_opaque_type));
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,850
|
ospf_api_errname (int errcode)
{
struct nametab NameTab[] = {
{ OSPF_API_OK, "OK", },
{ OSPF_API_NOSUCHINTERFACE, "No such interface", },
{ OSPF_API_NOSUCHAREA, "No such area", },
{ OSPF_API_NOSUCHLSA, "No such LSA", },
{ OSPF_API_ILLEGALLSATYPE, "Illegal LSA type", },
{ OSPF_API_OPAQUETYPEINUSE, "Opaque type in use", },
{ OSPF_API_OPAQUETYPENOTREGISTERED, "Opaque type not registered", },
{ OSPF_API_NOTREADY, "Not ready", },
{ OSPF_API_NOMEMORY, "No memory", },
{ OSPF_API_ERROR, "Other error", },
{ OSPF_API_UNDEF, "Undefined", },
};
int i, n = array_size(NameTab);
const char *name = NULL;
for (i = 0; i < n; i++)
{
if (NameTab[i].value == errcode)
{
name = NameTab[i].name;
break;
}
}
return name ? name : "?";
}
|
DoS Overflow
| 0
|
ospf_api_errname (int errcode)
{
struct nametab NameTab[] = {
{ OSPF_API_OK, "OK", },
{ OSPF_API_NOSUCHINTERFACE, "No such interface", },
{ OSPF_API_NOSUCHAREA, "No such area", },
{ OSPF_API_NOSUCHLSA, "No such LSA", },
{ OSPF_API_ILLEGALLSATYPE, "Illegal LSA type", },
{ OSPF_API_OPAQUETYPEINUSE, "Opaque type in use", },
{ OSPF_API_OPAQUETYPENOTREGISTERED, "Opaque type not registered", },
{ OSPF_API_NOTREADY, "Not ready", },
{ OSPF_API_NOMEMORY, "No memory", },
{ OSPF_API_ERROR, "Other error", },
{ OSPF_API_UNDEF, "Undefined", },
};
int i, n = array_size(NameTab);
const char *name = NULL;
for (i = 0; i < n; i++)
{
if (NameTab[i].value == errcode)
{
name = NameTab[i].name;
break;
}
}
return name ? name : "?";
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,851
|
ospf_api_typename (int msgtype)
{
struct nametab NameTab[] = {
{ MSG_REGISTER_OPAQUETYPE, "Register opaque-type", },
{ MSG_UNREGISTER_OPAQUETYPE, "Unregister opaque-type", },
{ MSG_REGISTER_EVENT, "Register event", },
{ MSG_SYNC_LSDB, "Sync LSDB", },
{ MSG_ORIGINATE_REQUEST, "Originate request", },
{ MSG_DELETE_REQUEST, "Delete request", },
{ MSG_REPLY, "Reply", },
{ MSG_READY_NOTIFY, "Ready notify", },
{ MSG_LSA_UPDATE_NOTIFY, "LSA update notify", },
{ MSG_LSA_DELETE_NOTIFY, "LSA delete notify", },
{ MSG_NEW_IF, "New interface", },
{ MSG_DEL_IF, "Del interface", },
{ MSG_ISM_CHANGE, "ISM change", },
{ MSG_NSM_CHANGE, "NSM change", },
};
int i, n = array_size(NameTab);
const char *name = NULL;
for (i = 0; i < n; i++)
{
if (NameTab[i].value == msgtype)
{
name = NameTab[i].name;
break;
}
}
return name ? name : "?";
}
|
DoS Overflow
| 0
|
ospf_api_typename (int msgtype)
{
struct nametab NameTab[] = {
{ MSG_REGISTER_OPAQUETYPE, "Register opaque-type", },
{ MSG_UNREGISTER_OPAQUETYPE, "Unregister opaque-type", },
{ MSG_REGISTER_EVENT, "Register event", },
{ MSG_SYNC_LSDB, "Sync LSDB", },
{ MSG_ORIGINATE_REQUEST, "Originate request", },
{ MSG_DELETE_REQUEST, "Delete request", },
{ MSG_REPLY, "Reply", },
{ MSG_READY_NOTIFY, "Ready notify", },
{ MSG_LSA_UPDATE_NOTIFY, "LSA update notify", },
{ MSG_LSA_DELETE_NOTIFY, "LSA delete notify", },
{ MSG_NEW_IF, "New interface", },
{ MSG_DEL_IF, "Del interface", },
{ MSG_ISM_CHANGE, "ISM change", },
{ MSG_NSM_CHANGE, "NSM change", },
};
int i, n = array_size(NameTab);
const char *name = NULL;
for (i = 0; i < n; i++)
{
if (NameTab[i].value == msgtype)
{
name = NameTab[i].name;
break;
}
}
return name ? name : "?";
}
|
@@ -472,6 +472,9 @@ new_msg_register_event (u_int32_t seqnum, struct lsa_filter_type *filter)
emsg->filter.typemask = htons (filter->typemask);
emsg->filter.origin = filter->origin;
emsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_REGISTER_EVENT, emsg, seqnum, len);
}
@@ -488,6 +491,9 @@ new_msg_sync_lsdb (u_int32_t seqnum, struct lsa_filter_type *filter)
smsg->filter.typemask = htons (filter->typemask);
smsg->filter.origin = filter->origin;
smsg->filter.num_areas = filter->num_areas;
+ if (len > sizeof (buf))
+ len = sizeof(buf);
+ /* API broken - missing memcpy to fill data */
return msg_new (MSG_SYNC_LSDB, smsg, seqnum, len);
}
@@ -501,13 +507,15 @@ new_msg_originate_request (u_int32_t seqnum,
int omsglen;
char buf[OSPF_API_MAX_MSG_SIZE];
- omsglen = sizeof (struct msg_originate_request) - sizeof (struct lsa_header)
- + ntohs (data->length);
-
omsg = (struct msg_originate_request *) buf;
omsg->ifaddr = ifaddr;
omsg->area_id = area_id;
- memcpy (&omsg->data, data, ntohs (data->length));
+
+ omsglen = ntohs (data->length);
+ if (omsglen > sizeof (buf) - offsetof (struct msg_originate_request, data))
+ omsglen = sizeof (buf) - offsetof (struct msg_originate_request, data);
+ memcpy (&omsg->data, data, omsglen);
+ omsglen += sizeof (struct msg_originate_request) - sizeof (struct lsa_header);
return msg_new (MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
@@ -627,13 +635,16 @@ new_msg_lsa_change_notify (u_char msgtype,
assert (data);
nmsg = (struct msg_lsa_change_notify *) buf;
- len = ntohs (data->length) + sizeof (struct msg_lsa_change_notify)
- - sizeof (struct lsa_header);
nmsg->ifaddr = ifaddr;
nmsg->area_id = area_id;
nmsg->is_self_originated = is_self_originated;
memset (&nmsg->pad, 0, sizeof (nmsg->pad));
- memcpy (&nmsg->data, data, ntohs (data->length));
+
+ len = ntohs (data->length);
+ if (len > sizeof (buf) - offsetof (struct msg_lsa_change_notify, data))
+ len = sizeof (buf) - offsetof (struct msg_lsa_change_notify, data);
+ memcpy (&nmsg->data, data, len);
+ len += sizeof (struct msg_lsa_change_notify) - sizeof (struct lsa_header);
return msg_new (msgtype, nmsg, seqnum, len);
}
|
CWE-119
| null | null |
2,852
|
static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
{
return (X509_NAME_cmp(*a, *b));
}
|
DoS
| 0
|
static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
{
return (X509_NAME_cmp(*a, *b));
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,853
|
static DH *get_server_static_dh_key(SESS_CERT *scert)
{
DH *dh_srvr = NULL;
EVP_PKEY *spkey = NULL;
int idx = scert->peer_cert_type;
if (idx >= 0)
spkey = X509_get_pubkey(scert->peer_pkeys[idx].x509);
if (spkey) {
dh_srvr = EVP_PKEY_get1_DH(spkey);
EVP_PKEY_free(spkey);
}
if (dh_srvr == NULL)
SSLerr(SSL_F_GET_SERVER_STATIC_DH_KEY, ERR_R_INTERNAL_ERROR);
return dh_srvr;
}
|
DoS
| 0
|
static DH *get_server_static_dh_key(SESS_CERT *scert)
{
DH *dh_srvr = NULL;
EVP_PKEY *spkey = NULL;
int idx = scert->peer_cert_type;
if (idx >= 0)
spkey = X509_get_pubkey(scert->peer_pkeys[idx].x509);
if (spkey) {
dh_srvr = EVP_PKEY_get1_DH(spkey);
EVP_PKEY_free(spkey);
}
if (dh_srvr == NULL)
SSLerr(SSL_F_GET_SERVER_STATIC_DH_KEY, ERR_R_INTERNAL_ERROR);
return dh_srvr;
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,854
|
int ssl3_check_cert_and_algorithm(SSL *s)
{
int i, idx;
long alg_k, alg_a;
EVP_PKEY *pkey = NULL;
int pkey_bits;
SESS_CERT *sc;
#ifndef OPENSSL_NO_RSA
RSA *rsa;
#endif
#ifndef OPENSSL_NO_DH
DH *dh;
#endif
int al = SSL_AD_HANDSHAKE_FAILURE;
alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
alg_a = s->s3->tmp.new_cipher->algorithm_auth;
/* we don't have a certificate */
if ((alg_a & (SSL_aNULL | SSL_aKRB5)) || (alg_k & SSL_kPSK))
return (1);
sc = s->session->sess_cert;
if (sc == NULL) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
goto err;
}
#ifndef OPENSSL_NO_RSA
rsa = s->session->sess_cert->peer_rsa_tmp;
#endif
#ifndef OPENSSL_NO_DH
dh = s->session->sess_cert->peer_dh_tmp;
#endif
/* This is the passed certificate */
idx = sc->peer_cert_type;
#ifndef OPENSSL_NO_ECDH
if (idx == SSL_PKEY_ECC) {
if (ssl_check_srvr_ecc_cert_and_alg(sc->peer_pkeys[idx].x509, s) == 0) {
/* check failed */
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_BAD_ECC_CERT);
goto f_err;
} else {
return 1;
}
} else if (alg_a & SSL_aECDSA) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_ECDSA_SIGNING_CERT);
goto f_err;
} else if (alg_k & (SSL_kECDHr | SSL_kECDHe)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_MISSING_ECDH_CERT);
goto f_err;
}
#endif
pkey = X509_get_pubkey(sc->peer_pkeys[idx].x509);
pkey_bits = EVP_PKEY_bits(pkey);
i = X509_certificate_type(sc->peer_pkeys[idx].x509, pkey);
EVP_PKEY_free(pkey);
/* Check that we have a certificate if we require one */
if ((alg_a & SSL_aRSA) && !has_bits(i, EVP_PK_RSA | EVP_PKT_SIGN)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_RSA_SIGNING_CERT);
goto f_err;
}
#ifndef OPENSSL_NO_DSA
else if ((alg_a & SSL_aDSS) && !has_bits(i, EVP_PK_DSA | EVP_PKT_SIGN)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_DSA_SIGNING_CERT);
goto f_err;
}
#endif
#ifndef OPENSSL_NO_RSA
if (alg_k & SSL_kRSA) {
if (!SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
!has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_RSA_ENCRYPTING_CERT);
goto f_err;
} else if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)) {
if (pkey_bits <= SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
if (!has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_RSA_ENCRYPTING_CERT);
goto f_err;
}
if (rsa != NULL) {
/* server key exchange is not allowed. */
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
goto f_err;
}
}
}
}
#endif
#ifndef OPENSSL_NO_DH
if ((alg_k & SSL_kEDH) && dh == NULL) {
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
goto f_err;
}
if ((alg_k & SSL_kDHr) && !SSL_USE_SIGALGS(s) &&
!has_bits(i, EVP_PK_DH | EVP_PKS_RSA)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_DH_RSA_CERT);
goto f_err;
}
# ifndef OPENSSL_NO_DSA
if ((alg_k & SSL_kDHd) && !SSL_USE_SIGALGS(s) &&
!has_bits(i, EVP_PK_DH | EVP_PKS_DSA)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_DH_DSA_CERT);
goto f_err;
}
# endif
if (alg_k & (SSL_kDHE | SSL_kDHr | SSL_kDHd)) {
int dh_size;
if (alg_k & SSL_kDHE) {
dh_size = BN_num_bits(dh->p);
} else {
DH *dh_srvr = get_server_static_dh_key(sc);
if (dh_srvr == NULL)
goto f_err;
dh_size = BN_num_bits(dh_srvr->p);
DH_free(dh_srvr);
}
if ((!SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && dh_size < 768)
|| (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && dh_size < 512)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_DH_KEY_TOO_SMALL);
goto f_err;
}
}
#endif /* !OPENSSL_NO_DH */
if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
pkey_bits > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
#ifndef OPENSSL_NO_RSA
if (alg_k & SSL_kRSA) {
if (rsa == NULL) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
goto f_err;
} else if (BN_num_bits(rsa->n) >
SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
/* We have a temporary RSA key but it's too large. */
al = SSL_AD_EXPORT_RESTRICTION;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
goto f_err;
}
} else
#endif
#ifndef OPENSSL_NO_DH
if (alg_k & SSL_kDHE) {
if (BN_num_bits(dh->p) >
SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
/* We have a temporary DH key but it's too large. */
al = SSL_AD_EXPORT_RESTRICTION;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_DH_KEY);
goto f_err;
}
} else if (alg_k & (SSL_kDHr | SSL_kDHd)) {
/* The cert should have had an export DH key. */
al = SSL_AD_EXPORT_RESTRICTION;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_DH_KEY);
goto f_err;
} else
#endif
{
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
goto f_err;
}
}
return (1);
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
return (0);
}
|
DoS
| 0
|
int ssl3_check_cert_and_algorithm(SSL *s)
{
int i, idx;
long alg_k, alg_a;
EVP_PKEY *pkey = NULL;
int pkey_bits;
SESS_CERT *sc;
#ifndef OPENSSL_NO_RSA
RSA *rsa;
#endif
#ifndef OPENSSL_NO_DH
DH *dh;
#endif
int al = SSL_AD_HANDSHAKE_FAILURE;
alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
alg_a = s->s3->tmp.new_cipher->algorithm_auth;
/* we don't have a certificate */
if ((alg_a & (SSL_aNULL | SSL_aKRB5)) || (alg_k & SSL_kPSK))
return (1);
sc = s->session->sess_cert;
if (sc == NULL) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
goto err;
}
#ifndef OPENSSL_NO_RSA
rsa = s->session->sess_cert->peer_rsa_tmp;
#endif
#ifndef OPENSSL_NO_DH
dh = s->session->sess_cert->peer_dh_tmp;
#endif
/* This is the passed certificate */
idx = sc->peer_cert_type;
#ifndef OPENSSL_NO_ECDH
if (idx == SSL_PKEY_ECC) {
if (ssl_check_srvr_ecc_cert_and_alg(sc->peer_pkeys[idx].x509, s) == 0) {
/* check failed */
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_BAD_ECC_CERT);
goto f_err;
} else {
return 1;
}
} else if (alg_a & SSL_aECDSA) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_ECDSA_SIGNING_CERT);
goto f_err;
} else if (alg_k & (SSL_kECDHr | SSL_kECDHe)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_MISSING_ECDH_CERT);
goto f_err;
}
#endif
pkey = X509_get_pubkey(sc->peer_pkeys[idx].x509);
pkey_bits = EVP_PKEY_bits(pkey);
i = X509_certificate_type(sc->peer_pkeys[idx].x509, pkey);
EVP_PKEY_free(pkey);
/* Check that we have a certificate if we require one */
if ((alg_a & SSL_aRSA) && !has_bits(i, EVP_PK_RSA | EVP_PKT_SIGN)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_RSA_SIGNING_CERT);
goto f_err;
}
#ifndef OPENSSL_NO_DSA
else if ((alg_a & SSL_aDSS) && !has_bits(i, EVP_PK_DSA | EVP_PKT_SIGN)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_DSA_SIGNING_CERT);
goto f_err;
}
#endif
#ifndef OPENSSL_NO_RSA
if (alg_k & SSL_kRSA) {
if (!SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
!has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_RSA_ENCRYPTING_CERT);
goto f_err;
} else if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)) {
if (pkey_bits <= SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
if (!has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_RSA_ENCRYPTING_CERT);
goto f_err;
}
if (rsa != NULL) {
/* server key exchange is not allowed. */
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
goto f_err;
}
}
}
}
#endif
#ifndef OPENSSL_NO_DH
if ((alg_k & SSL_kEDH) && dh == NULL) {
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
goto f_err;
}
if ((alg_k & SSL_kDHr) && !SSL_USE_SIGALGS(s) &&
!has_bits(i, EVP_PK_DH | EVP_PKS_RSA)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_DH_RSA_CERT);
goto f_err;
}
# ifndef OPENSSL_NO_DSA
if ((alg_k & SSL_kDHd) && !SSL_USE_SIGALGS(s) &&
!has_bits(i, EVP_PK_DH | EVP_PKS_DSA)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_DH_DSA_CERT);
goto f_err;
}
# endif
if (alg_k & (SSL_kDHE | SSL_kDHr | SSL_kDHd)) {
int dh_size;
if (alg_k & SSL_kDHE) {
dh_size = BN_num_bits(dh->p);
} else {
DH *dh_srvr = get_server_static_dh_key(sc);
if (dh_srvr == NULL)
goto f_err;
dh_size = BN_num_bits(dh_srvr->p);
DH_free(dh_srvr);
}
if ((!SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && dh_size < 768)
|| (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && dh_size < 512)) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_DH_KEY_TOO_SMALL);
goto f_err;
}
}
#endif /* !OPENSSL_NO_DH */
if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
pkey_bits > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
#ifndef OPENSSL_NO_RSA
if (alg_k & SSL_kRSA) {
if (rsa == NULL) {
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
goto f_err;
} else if (BN_num_bits(rsa->n) >
SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
/* We have a temporary RSA key but it's too large. */
al = SSL_AD_EXPORT_RESTRICTION;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
goto f_err;
}
} else
#endif
#ifndef OPENSSL_NO_DH
if (alg_k & SSL_kDHE) {
if (BN_num_bits(dh->p) >
SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
/* We have a temporary DH key but it's too large. */
al = SSL_AD_EXPORT_RESTRICTION;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_DH_KEY);
goto f_err;
}
} else if (alg_k & (SSL_kDHr | SSL_kDHd)) {
/* The cert should have had an export DH key. */
al = SSL_AD_EXPORT_RESTRICTION;
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_MISSING_EXPORT_TMP_DH_KEY);
goto f_err;
} else
#endif
{
SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
goto f_err;
}
}
return (1);
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
return (0);
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,855
|
static int ssl3_check_client_certificate(SSL *s)
{
unsigned long alg_k;
if (!s->cert || !s->cert->key->x509 || !s->cert->key->privatekey)
return 0;
/* If no suitable signature algorithm can't use certificate */
if (SSL_USE_SIGALGS(s) && !s->cert->key->digest)
return 0;
/*
* If strict mode check suitability of chain before using it. This also
* adjusts suite B digest if necessary.
*/
if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
!tls1_check_chain(s, NULL, NULL, NULL, -2))
return 0;
alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
/* See if we can use client certificate for fixed DH */
if (alg_k & (SSL_kDHr | SSL_kDHd)) {
SESS_CERT *scert = s->session->sess_cert;
int i = scert->peer_cert_type;
EVP_PKEY *clkey = NULL, *spkey = NULL;
clkey = s->cert->key->privatekey;
/* If client key not DH assume it can be used */
if (EVP_PKEY_id(clkey) != EVP_PKEY_DH)
return 1;
if (i >= 0)
spkey = X509_get_pubkey(scert->peer_pkeys[i].x509);
if (spkey) {
/* Compare server and client parameters */
i = EVP_PKEY_cmp_parameters(clkey, spkey);
EVP_PKEY_free(spkey);
if (i != 1)
return 0;
}
s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
}
return 1;
}
|
DoS
| 0
|
static int ssl3_check_client_certificate(SSL *s)
{
unsigned long alg_k;
if (!s->cert || !s->cert->key->x509 || !s->cert->key->privatekey)
return 0;
/* If no suitable signature algorithm can't use certificate */
if (SSL_USE_SIGALGS(s) && !s->cert->key->digest)
return 0;
/*
* If strict mode check suitability of chain before using it. This also
* adjusts suite B digest if necessary.
*/
if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
!tls1_check_chain(s, NULL, NULL, NULL, -2))
return 0;
alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
/* See if we can use client certificate for fixed DH */
if (alg_k & (SSL_kDHr | SSL_kDHd)) {
SESS_CERT *scert = s->session->sess_cert;
int i = scert->peer_cert_type;
EVP_PKEY *clkey = NULL, *spkey = NULL;
clkey = s->cert->key->privatekey;
/* If client key not DH assume it can be used */
if (EVP_PKEY_id(clkey) != EVP_PKEY_DH)
return 1;
if (i >= 0)
spkey = X509_get_pubkey(scert->peer_pkeys[i].x509);
if (spkey) {
/* Compare server and client parameters */
i = EVP_PKEY_cmp_parameters(clkey, spkey);
EVP_PKEY_free(spkey);
if (i != 1)
return 0;
}
s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
}
return 1;
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,856
|
int ssl3_client_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p, *d;
int i;
unsigned long l;
int al = 0;
#ifndef OPENSSL_NO_COMP
int j;
SSL_COMP *comp;
#endif
buf = (unsigned char *)s->init_buf->data;
if (s->state == SSL3_ST_CW_CLNT_HELLO_A) {
SSL_SESSION *sess = s->session;
if ((sess == NULL) || (sess->ssl_version != s->version) ||
#ifdef OPENSSL_NO_TLSEXT
!sess->session_id_length ||
#else
/*
* In the case of EAP-FAST, we can have a pre-shared
* "ticket" without a session ID.
*/
(!sess->session_id_length && !sess->tlsext_tick) ||
#endif
(sess->not_resumable)) {
if (!ssl_get_new_session(s, 0))
goto err;
}
if (s->method->version == DTLS_ANY_VERSION) {
/* Determine which DTLS version to use */
int options = s->options;
/* If DTLS 1.2 disabled correct the version number */
if (options & SSL_OP_NO_DTLSv1_2) {
if (tls1_suiteb(s)) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO,
SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
goto err;
}
/*
* Disabling all versions is silly: return an error.
*/
if (options & SSL_OP_NO_DTLSv1) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_WRONG_SSL_VERSION);
goto err;
}
/*
* Update method so we don't use any DTLS 1.2 features.
*/
s->method = DTLSv1_client_method();
s->version = DTLS1_VERSION;
} else {
/*
* We only support one version: update method
*/
if (options & SSL_OP_NO_DTLSv1)
s->method = DTLSv1_2_client_method();
s->version = DTLS1_2_VERSION;
}
s->client_version = s->version;
}
/* else use the pre-loaded session */
p = s->s3->client_random;
/*
* for DTLS if client_random is initialized, reuse it, we are
* required to use same upon reply to HelloVerify
*/
if (SSL_IS_DTLS(s)) {
size_t idx;
i = 1;
for (idx = 0; idx < sizeof(s->s3->client_random); idx++) {
if (p[idx]) {
i = 0;
break;
}
}
} else
i = 1;
if (i && ssl_fill_hello_random(s, 0, p,
sizeof(s->s3->client_random)) <= 0)
goto err;
/* Do the message type and length last */
d = p = ssl_handshake_start(s);
/*-
* version indicates the negotiated version: for example from
* an SSLv2/v3 compatible client hello). The client_version
* field is the maximum version we permit and it is also
* used in RSA encrypted premaster secrets. Some servers can
* choke if we initially report a higher version then
* renegotiate to a lower one in the premaster secret. This
* didn't happen with TLS 1.0 as most servers supported it
* but it can with TLS 1.1 or later if the server only supports
* 1.0.
*
* Possible scenario with previous logic:
* 1. Client hello indicates TLS 1.2
* 2. Server hello says TLS 1.0
* 3. RSA encrypted premaster secret uses 1.2.
* 4. Handhaked proceeds using TLS 1.0.
* 5. Server sends hello request to renegotiate.
* 6. Client hello indicates TLS v1.0 as we now
* know that is maximum server supports.
* 7. Server chokes on RSA encrypted premaster secret
* containing version 1.0.
*
* For interoperability it should be OK to always use the
* maximum version we support in client hello and then rely
* on the checking of version to ensure the servers isn't
* being inconsistent: for example initially negotiating with
* TLS 1.0 and renegotiating with TLS 1.2. We do this by using
* client_version in client hello and not resetting it to
* the negotiated version.
*/
#if 0
*(p++) = s->version >> 8;
*(p++) = s->version & 0xff;
s->client_version = s->version;
#else
*(p++) = s->client_version >> 8;
*(p++) = s->client_version & 0xff;
#endif
/* Random stuff */
memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
/* Session ID */
if (s->new_session)
i = 0;
else
i = s->session->session_id_length;
*(p++) = i;
if (i != 0) {
if (i > (int)sizeof(s->session->session_id)) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto err;
}
memcpy(p, s->session->session_id, i);
p += i;
}
/* cookie stuff for DTLS */
if (SSL_IS_DTLS(s)) {
if (s->d1->cookie_len > sizeof(s->d1->cookie)) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto err;
}
*(p++) = s->d1->cookie_len;
memcpy(p, s->d1->cookie, s->d1->cookie_len);
p += s->d1->cookie_len;
}
/* Ciphers supported */
i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]), 0);
if (i == 0) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
goto err;
}
#ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
/*
* Some servers hang if client hello > 256 bytes as hack workaround
* chop number of supported ciphers to keep it well below this if we
* use TLS v1.2
*/
if (TLS1_get_version(s) >= TLS1_2_VERSION
&& i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
#endif
s2n(i, p);
p += i;
/* COMPRESSION */
#ifdef OPENSSL_NO_COMP
*(p++) = 1;
#else
if ((s->options & SSL_OP_NO_COMPRESSION)
|| !s->ctx->comp_methods)
j = 0;
else
j = sk_SSL_COMP_num(s->ctx->comp_methods);
*(p++) = 1 + j;
for (i = 0; i < j; i++) {
comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
*(p++) = comp->id;
}
#endif
*(p++) = 0; /* Add the NULL method */
#ifndef OPENSSL_NO_TLSEXT
/* TLS extensions */
if (ssl_prepare_clienthello_tlsext(s) <= 0) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
goto err;
}
if ((p =
ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH,
&al)) == NULL) {
ssl3_send_alert(s, SSL3_AL_FATAL, al);
SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto err;
}
#endif
l = p - d;
ssl_set_handshake_header(s, SSL3_MT_CLIENT_HELLO, l);
s->state = SSL3_ST_CW_CLNT_HELLO_B;
}
/* SSL3_ST_CW_CLNT_HELLO_B */
return ssl_do_write(s);
err:
s->state = SSL_ST_ERR;
return (-1);
}
|
DoS
| 0
|
int ssl3_client_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p, *d;
int i;
unsigned long l;
int al = 0;
#ifndef OPENSSL_NO_COMP
int j;
SSL_COMP *comp;
#endif
buf = (unsigned char *)s->init_buf->data;
if (s->state == SSL3_ST_CW_CLNT_HELLO_A) {
SSL_SESSION *sess = s->session;
if ((sess == NULL) || (sess->ssl_version != s->version) ||
#ifdef OPENSSL_NO_TLSEXT
!sess->session_id_length ||
#else
/*
* In the case of EAP-FAST, we can have a pre-shared
* "ticket" without a session ID.
*/
(!sess->session_id_length && !sess->tlsext_tick) ||
#endif
(sess->not_resumable)) {
if (!ssl_get_new_session(s, 0))
goto err;
}
if (s->method->version == DTLS_ANY_VERSION) {
/* Determine which DTLS version to use */
int options = s->options;
/* If DTLS 1.2 disabled correct the version number */
if (options & SSL_OP_NO_DTLSv1_2) {
if (tls1_suiteb(s)) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO,
SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
goto err;
}
/*
* Disabling all versions is silly: return an error.
*/
if (options & SSL_OP_NO_DTLSv1) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_WRONG_SSL_VERSION);
goto err;
}
/*
* Update method so we don't use any DTLS 1.2 features.
*/
s->method = DTLSv1_client_method();
s->version = DTLS1_VERSION;
} else {
/*
* We only support one version: update method
*/
if (options & SSL_OP_NO_DTLSv1)
s->method = DTLSv1_2_client_method();
s->version = DTLS1_2_VERSION;
}
s->client_version = s->version;
}
/* else use the pre-loaded session */
p = s->s3->client_random;
/*
* for DTLS if client_random is initialized, reuse it, we are
* required to use same upon reply to HelloVerify
*/
if (SSL_IS_DTLS(s)) {
size_t idx;
i = 1;
for (idx = 0; idx < sizeof(s->s3->client_random); idx++) {
if (p[idx]) {
i = 0;
break;
}
}
} else
i = 1;
if (i && ssl_fill_hello_random(s, 0, p,
sizeof(s->s3->client_random)) <= 0)
goto err;
/* Do the message type and length last */
d = p = ssl_handshake_start(s);
/*-
* version indicates the negotiated version: for example from
* an SSLv2/v3 compatible client hello). The client_version
* field is the maximum version we permit and it is also
* used in RSA encrypted premaster secrets. Some servers can
* choke if we initially report a higher version then
* renegotiate to a lower one in the premaster secret. This
* didn't happen with TLS 1.0 as most servers supported it
* but it can with TLS 1.1 or later if the server only supports
* 1.0.
*
* Possible scenario with previous logic:
* 1. Client hello indicates TLS 1.2
* 2. Server hello says TLS 1.0
* 3. RSA encrypted premaster secret uses 1.2.
* 4. Handhaked proceeds using TLS 1.0.
* 5. Server sends hello request to renegotiate.
* 6. Client hello indicates TLS v1.0 as we now
* know that is maximum server supports.
* 7. Server chokes on RSA encrypted premaster secret
* containing version 1.0.
*
* For interoperability it should be OK to always use the
* maximum version we support in client hello and then rely
* on the checking of version to ensure the servers isn't
* being inconsistent: for example initially negotiating with
* TLS 1.0 and renegotiating with TLS 1.2. We do this by using
* client_version in client hello and not resetting it to
* the negotiated version.
*/
#if 0
*(p++) = s->version >> 8;
*(p++) = s->version & 0xff;
s->client_version = s->version;
#else
*(p++) = s->client_version >> 8;
*(p++) = s->client_version & 0xff;
#endif
/* Random stuff */
memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
/* Session ID */
if (s->new_session)
i = 0;
else
i = s->session->session_id_length;
*(p++) = i;
if (i != 0) {
if (i > (int)sizeof(s->session->session_id)) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto err;
}
memcpy(p, s->session->session_id, i);
p += i;
}
/* cookie stuff for DTLS */
if (SSL_IS_DTLS(s)) {
if (s->d1->cookie_len > sizeof(s->d1->cookie)) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto err;
}
*(p++) = s->d1->cookie_len;
memcpy(p, s->d1->cookie, s->d1->cookie_len);
p += s->d1->cookie_len;
}
/* Ciphers supported */
i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]), 0);
if (i == 0) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
goto err;
}
#ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
/*
* Some servers hang if client hello > 256 bytes as hack workaround
* chop number of supported ciphers to keep it well below this if we
* use TLS v1.2
*/
if (TLS1_get_version(s) >= TLS1_2_VERSION
&& i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
#endif
s2n(i, p);
p += i;
/* COMPRESSION */
#ifdef OPENSSL_NO_COMP
*(p++) = 1;
#else
if ((s->options & SSL_OP_NO_COMPRESSION)
|| !s->ctx->comp_methods)
j = 0;
else
j = sk_SSL_COMP_num(s->ctx->comp_methods);
*(p++) = 1 + j;
for (i = 0; i < j; i++) {
comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
*(p++) = comp->id;
}
#endif
*(p++) = 0; /* Add the NULL method */
#ifndef OPENSSL_NO_TLSEXT
/* TLS extensions */
if (ssl_prepare_clienthello_tlsext(s) <= 0) {
SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
goto err;
}
if ((p =
ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH,
&al)) == NULL) {
ssl3_send_alert(s, SSL3_AL_FATAL, al);
SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto err;
}
#endif
l = p - d;
ssl_set_handshake_header(s, SSL3_MT_CLIENT_HELLO, l);
s->state = SSL3_ST_CW_CLNT_HELLO_B;
}
/* SSL3_ST_CW_CLNT_HELLO_B */
return ssl_do_write(s);
err:
s->state = SSL_ST_ERR;
return (-1);
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,857
|
int ssl3_connect(SSL *s)
{
BUF_MEM *buf = NULL;
unsigned long Time = (unsigned long)time(NULL);
void (*cb) (const SSL *ssl, int type, int val) = NULL;
int ret = -1;
int new_state, state, skip = 0;
RAND_add(&Time, sizeof(Time), 0);
ERR_clear_error();
clear_sys_error();
if (s->info_callback != NULL)
cb = s->info_callback;
else if (s->ctx->info_callback != NULL)
cb = s->ctx->info_callback;
s->in_handshake++;
if (!SSL_in_init(s) || SSL_in_before(s))
SSL_clear(s);
#ifndef OPENSSL_NO_HEARTBEATS
/*
* If we're awaiting a HeartbeatResponse, pretend we already got and
* don't await it anymore, because Heartbeats don't make sense during
* handshakes anyway.
*/
if (s->tlsext_hb_pending) {
s->tlsext_hb_pending = 0;
s->tlsext_hb_seq++;
}
#endif
for (;;) {
state = s->state;
switch (s->state) {
case SSL_ST_RENEGOTIATE:
s->renegotiate = 1;
s->state = SSL_ST_CONNECT;
s->ctx->stats.sess_connect_renegotiate++;
/* break */
case SSL_ST_BEFORE:
case SSL_ST_CONNECT:
case SSL_ST_BEFORE | SSL_ST_CONNECT:
case SSL_ST_OK | SSL_ST_CONNECT:
s->server = 0;
if (cb != NULL)
cb(s, SSL_CB_HANDSHAKE_START, 1);
if ((s->version & 0xff00) != 0x0300) {
SSLerr(SSL_F_SSL3_CONNECT, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
ret = -1;
goto end;
}
/* s->version=SSL3_VERSION; */
s->type = SSL_ST_CONNECT;
if (s->init_buf == NULL) {
if ((buf = BUF_MEM_new()) == NULL) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
s->init_buf = buf;
buf = NULL;
}
if (!ssl3_setup_buffers(s)) {
ret = -1;
goto end;
}
/* setup buffing BIO */
if (!ssl_init_wbio_buffer(s, 0)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
/* don't push the buffering BIO quite yet */
ssl3_init_finished_mac(s);
s->state = SSL3_ST_CW_CLNT_HELLO_A;
s->ctx->stats.sess_connect++;
s->init_num = 0;
s->s3->flags &= ~SSL3_FLAGS_CCS_OK;
/*
* Should have been reset by ssl3_get_finished, too.
*/
s->s3->change_cipher_spec = 0;
break;
case SSL3_ST_CW_CLNT_HELLO_A:
case SSL3_ST_CW_CLNT_HELLO_B:
s->shutdown = 0;
ret = ssl3_client_hello(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_SRVR_HELLO_A;
s->init_num = 0;
/* turn on buffering for the next lot of output */
if (s->bbio != s->wbio)
s->wbio = BIO_push(s->bbio, s->wbio);
break;
case SSL3_ST_CR_SRVR_HELLO_A:
case SSL3_ST_CR_SRVR_HELLO_B:
ret = ssl3_get_server_hello(s);
if (ret <= 0)
goto end;
if (s->hit) {
s->state = SSL3_ST_CR_FINISHED_A;
#ifndef OPENSSL_NO_TLSEXT
if (s->tlsext_ticket_expected) {
/* receive renewed session ticket */
s->state = SSL3_ST_CR_SESSION_TICKET_A;
}
#endif
} else {
s->state = SSL3_ST_CR_CERT_A;
}
s->init_num = 0;
break;
case SSL3_ST_CR_CERT_A:
case SSL3_ST_CR_CERT_B:
#ifndef OPENSSL_NO_TLSEXT
/* Noop (ret = 0) for everything but EAP-FAST. */
ret = ssl3_check_finished(s);
if (ret < 0)
goto end;
if (ret == 1) {
s->hit = 1;
s->state = SSL3_ST_CR_FINISHED_A;
s->init_num = 0;
break;
}
#endif
/* Check if it is anon DH/ECDH, SRP auth */
/* or PSK */
if (!
(s->s3->tmp.
new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
&& !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
ret = ssl3_get_server_certificate(s);
if (ret <= 0)
goto end;
#ifndef OPENSSL_NO_TLSEXT
if (s->tlsext_status_expected)
s->state = SSL3_ST_CR_CERT_STATUS_A;
else
s->state = SSL3_ST_CR_KEY_EXCH_A;
} else {
skip = 1;
s->state = SSL3_ST_CR_KEY_EXCH_A;
}
#else
} else
skip = 1;
s->state = SSL3_ST_CR_KEY_EXCH_A;
#endif
s->init_num = 0;
break;
case SSL3_ST_CR_KEY_EXCH_A:
case SSL3_ST_CR_KEY_EXCH_B:
ret = ssl3_get_key_exchange(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_CERT_REQ_A;
s->init_num = 0;
/*
* at this point we check that we have the required stuff from
* the server
*/
if (!ssl3_check_cert_and_algorithm(s)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
break;
case SSL3_ST_CR_CERT_REQ_A:
case SSL3_ST_CR_CERT_REQ_B:
ret = ssl3_get_certificate_request(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_SRVR_DONE_A;
s->init_num = 0;
break;
case SSL3_ST_CR_SRVR_DONE_A:
case SSL3_ST_CR_SRVR_DONE_B:
ret = ssl3_get_server_done(s);
if (ret <= 0)
goto end;
#ifndef OPENSSL_NO_SRP
if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
if ((ret = SRP_Calc_A_param(s)) <= 0) {
SSLerr(SSL_F_SSL3_CONNECT, SSL_R_SRP_A_CALC);
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
goto end;
}
}
#endif
if (s->s3->tmp.cert_req)
s->state = SSL3_ST_CW_CERT_A;
else
s->state = SSL3_ST_CW_KEY_EXCH_A;
s->init_num = 0;
break;
case SSL3_ST_CW_CERT_A:
case SSL3_ST_CW_CERT_B:
case SSL3_ST_CW_CERT_C:
case SSL3_ST_CW_CERT_D:
ret = ssl3_send_client_certificate(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_KEY_EXCH_A;
s->init_num = 0;
break;
case SSL3_ST_CW_KEY_EXCH_A:
case SSL3_ST_CW_KEY_EXCH_B:
ret = ssl3_send_client_key_exchange(s);
if (ret <= 0)
goto end;
/*
* EAY EAY EAY need to check for DH fix cert sent back
*/
/*
* For TLS, cert_req is set to 2, so a cert chain of nothing is
* sent, but no verify packet is sent
*/
/*
* XXX: For now, we do not support client authentication in ECDH
* cipher suites with ECDH (rather than ECDSA) certificates. We
* need to skip the certificate verify message when client's
* ECDH public key is sent inside the client certificate.
*/
if (s->s3->tmp.cert_req == 1) {
s->state = SSL3_ST_CW_CERT_VRFY_A;
} else {
s->state = SSL3_ST_CW_CHANGE_A;
}
if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
s->state = SSL3_ST_CW_CHANGE_A;
}
s->init_num = 0;
break;
case SSL3_ST_CW_CERT_VRFY_A:
case SSL3_ST_CW_CERT_VRFY_B:
ret = ssl3_send_client_verify(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_CHANGE_A;
s->init_num = 0;
break;
case SSL3_ST_CW_CHANGE_A:
case SSL3_ST_CW_CHANGE_B:
ret = ssl3_send_change_cipher_spec(s,
SSL3_ST_CW_CHANGE_A,
SSL3_ST_CW_CHANGE_B);
if (ret <= 0)
goto end;
#if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
s->state = SSL3_ST_CW_FINISHED_A;
#else
if (s->s3->next_proto_neg_seen)
s->state = SSL3_ST_CW_NEXT_PROTO_A;
else
s->state = SSL3_ST_CW_FINISHED_A;
#endif
s->init_num = 0;
s->session->cipher = s->s3->tmp.new_cipher;
#ifdef OPENSSL_NO_COMP
s->session->compress_meth = 0;
#else
if (s->s3->tmp.new_compression == NULL)
s->session->compress_meth = 0;
else
s->session->compress_meth = s->s3->tmp.new_compression->id;
#endif
if (!s->method->ssl3_enc->setup_key_block(s)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
if (!s->method->ssl3_enc->change_cipher_state(s,
SSL3_CHANGE_CIPHER_CLIENT_WRITE))
{
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
break;
#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
case SSL3_ST_CW_NEXT_PROTO_A:
case SSL3_ST_CW_NEXT_PROTO_B:
ret = ssl3_send_next_proto(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_FINISHED_A;
break;
#endif
case SSL3_ST_CW_FINISHED_A:
case SSL3_ST_CW_FINISHED_B:
ret = ssl3_send_finished(s,
SSL3_ST_CW_FINISHED_A,
SSL3_ST_CW_FINISHED_B,
s->method->
ssl3_enc->client_finished_label,
s->method->
ssl3_enc->client_finished_label_len);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_FLUSH;
/* clear flags */
s->s3->flags &= ~SSL3_FLAGS_POP_BUFFER;
if (s->hit) {
s->s3->tmp.next_state = SSL_ST_OK;
if (s->s3->flags & SSL3_FLAGS_DELAY_CLIENT_FINISHED) {
s->state = SSL_ST_OK;
s->s3->flags |= SSL3_FLAGS_POP_BUFFER;
s->s3->delay_buf_pop_ret = 0;
}
} else {
#ifndef OPENSSL_NO_TLSEXT
/*
* Allow NewSessionTicket if ticket expected
*/
if (s->tlsext_ticket_expected)
s->s3->tmp.next_state = SSL3_ST_CR_SESSION_TICKET_A;
else
#endif
s->s3->tmp.next_state = SSL3_ST_CR_FINISHED_A;
}
s->init_num = 0;
break;
#ifndef OPENSSL_NO_TLSEXT
case SSL3_ST_CR_SESSION_TICKET_A:
case SSL3_ST_CR_SESSION_TICKET_B:
ret = ssl3_get_new_session_ticket(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_FINISHED_A;
s->init_num = 0;
break;
case SSL3_ST_CR_CERT_STATUS_A:
case SSL3_ST_CR_CERT_STATUS_B:
ret = ssl3_get_cert_status(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_KEY_EXCH_A;
s->init_num = 0;
break;
#endif
case SSL3_ST_CR_FINISHED_A:
case SSL3_ST_CR_FINISHED_B:
if (!s->s3->change_cipher_spec)
s->s3->flags |= SSL3_FLAGS_CCS_OK;
ret = ssl3_get_finished(s, SSL3_ST_CR_FINISHED_A,
SSL3_ST_CR_FINISHED_B);
if (ret <= 0)
goto end;
if (s->hit)
s->state = SSL3_ST_CW_CHANGE_A;
else
s->state = SSL_ST_OK;
s->init_num = 0;
break;
case SSL3_ST_CW_FLUSH:
s->rwstate = SSL_WRITING;
if (BIO_flush(s->wbio) <= 0) {
ret = -1;
goto end;
}
s->rwstate = SSL_NOTHING;
s->state = s->s3->tmp.next_state;
break;
case SSL_ST_OK:
/* clean a few things up */
ssl3_cleanup_key_block(s);
if (s->init_buf != NULL) {
BUF_MEM_free(s->init_buf);
s->init_buf = NULL;
}
/*
* If we are not 'joining' the last two packets, remove the
* buffering now
*/
if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))
ssl_free_wbio_buffer(s);
/* else do it later in ssl3_write */
s->init_num = 0;
s->renegotiate = 0;
s->new_session = 0;
ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
if (s->hit)
s->ctx->stats.sess_hit++;
ret = 1;
/* s->server=0; */
s->handshake_func = ssl3_connect;
s->ctx->stats.sess_connect_good++;
if (cb != NULL)
cb(s, SSL_CB_HANDSHAKE_DONE, 1);
goto end;
/* break; */
case SSL_ST_ERR:
default:
SSLerr(SSL_F_SSL3_CONNECT, SSL_R_UNKNOWN_STATE);
ret = -1;
goto end;
/* break; */
}
/* did we do anything */
if (!s->s3->tmp.reuse_message && !skip) {
if (s->debug) {
if ((ret = BIO_flush(s->wbio)) <= 0)
goto end;
}
if ((cb != NULL) && (s->state != state)) {
new_state = s->state;
s->state = state;
cb(s, SSL_CB_CONNECT_LOOP, 1);
s->state = new_state;
}
}
skip = 0;
}
|
DoS
| 0
|
int ssl3_connect(SSL *s)
{
BUF_MEM *buf = NULL;
unsigned long Time = (unsigned long)time(NULL);
void (*cb) (const SSL *ssl, int type, int val) = NULL;
int ret = -1;
int new_state, state, skip = 0;
RAND_add(&Time, sizeof(Time), 0);
ERR_clear_error();
clear_sys_error();
if (s->info_callback != NULL)
cb = s->info_callback;
else if (s->ctx->info_callback != NULL)
cb = s->ctx->info_callback;
s->in_handshake++;
if (!SSL_in_init(s) || SSL_in_before(s))
SSL_clear(s);
#ifndef OPENSSL_NO_HEARTBEATS
/*
* If we're awaiting a HeartbeatResponse, pretend we already got and
* don't await it anymore, because Heartbeats don't make sense during
* handshakes anyway.
*/
if (s->tlsext_hb_pending) {
s->tlsext_hb_pending = 0;
s->tlsext_hb_seq++;
}
#endif
for (;;) {
state = s->state;
switch (s->state) {
case SSL_ST_RENEGOTIATE:
s->renegotiate = 1;
s->state = SSL_ST_CONNECT;
s->ctx->stats.sess_connect_renegotiate++;
/* break */
case SSL_ST_BEFORE:
case SSL_ST_CONNECT:
case SSL_ST_BEFORE | SSL_ST_CONNECT:
case SSL_ST_OK | SSL_ST_CONNECT:
s->server = 0;
if (cb != NULL)
cb(s, SSL_CB_HANDSHAKE_START, 1);
if ((s->version & 0xff00) != 0x0300) {
SSLerr(SSL_F_SSL3_CONNECT, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
ret = -1;
goto end;
}
/* s->version=SSL3_VERSION; */
s->type = SSL_ST_CONNECT;
if (s->init_buf == NULL) {
if ((buf = BUF_MEM_new()) == NULL) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
s->init_buf = buf;
buf = NULL;
}
if (!ssl3_setup_buffers(s)) {
ret = -1;
goto end;
}
/* setup buffing BIO */
if (!ssl_init_wbio_buffer(s, 0)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
/* don't push the buffering BIO quite yet */
ssl3_init_finished_mac(s);
s->state = SSL3_ST_CW_CLNT_HELLO_A;
s->ctx->stats.sess_connect++;
s->init_num = 0;
s->s3->flags &= ~SSL3_FLAGS_CCS_OK;
/*
* Should have been reset by ssl3_get_finished, too.
*/
s->s3->change_cipher_spec = 0;
break;
case SSL3_ST_CW_CLNT_HELLO_A:
case SSL3_ST_CW_CLNT_HELLO_B:
s->shutdown = 0;
ret = ssl3_client_hello(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_SRVR_HELLO_A;
s->init_num = 0;
/* turn on buffering for the next lot of output */
if (s->bbio != s->wbio)
s->wbio = BIO_push(s->bbio, s->wbio);
break;
case SSL3_ST_CR_SRVR_HELLO_A:
case SSL3_ST_CR_SRVR_HELLO_B:
ret = ssl3_get_server_hello(s);
if (ret <= 0)
goto end;
if (s->hit) {
s->state = SSL3_ST_CR_FINISHED_A;
#ifndef OPENSSL_NO_TLSEXT
if (s->tlsext_ticket_expected) {
/* receive renewed session ticket */
s->state = SSL3_ST_CR_SESSION_TICKET_A;
}
#endif
} else {
s->state = SSL3_ST_CR_CERT_A;
}
s->init_num = 0;
break;
case SSL3_ST_CR_CERT_A:
case SSL3_ST_CR_CERT_B:
#ifndef OPENSSL_NO_TLSEXT
/* Noop (ret = 0) for everything but EAP-FAST. */
ret = ssl3_check_finished(s);
if (ret < 0)
goto end;
if (ret == 1) {
s->hit = 1;
s->state = SSL3_ST_CR_FINISHED_A;
s->init_num = 0;
break;
}
#endif
/* Check if it is anon DH/ECDH, SRP auth */
/* or PSK */
if (!
(s->s3->tmp.
new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
&& !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
ret = ssl3_get_server_certificate(s);
if (ret <= 0)
goto end;
#ifndef OPENSSL_NO_TLSEXT
if (s->tlsext_status_expected)
s->state = SSL3_ST_CR_CERT_STATUS_A;
else
s->state = SSL3_ST_CR_KEY_EXCH_A;
} else {
skip = 1;
s->state = SSL3_ST_CR_KEY_EXCH_A;
}
#else
} else
skip = 1;
s->state = SSL3_ST_CR_KEY_EXCH_A;
#endif
s->init_num = 0;
break;
case SSL3_ST_CR_KEY_EXCH_A:
case SSL3_ST_CR_KEY_EXCH_B:
ret = ssl3_get_key_exchange(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_CERT_REQ_A;
s->init_num = 0;
/*
* at this point we check that we have the required stuff from
* the server
*/
if (!ssl3_check_cert_and_algorithm(s)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
break;
case SSL3_ST_CR_CERT_REQ_A:
case SSL3_ST_CR_CERT_REQ_B:
ret = ssl3_get_certificate_request(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_SRVR_DONE_A;
s->init_num = 0;
break;
case SSL3_ST_CR_SRVR_DONE_A:
case SSL3_ST_CR_SRVR_DONE_B:
ret = ssl3_get_server_done(s);
if (ret <= 0)
goto end;
#ifndef OPENSSL_NO_SRP
if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
if ((ret = SRP_Calc_A_param(s)) <= 0) {
SSLerr(SSL_F_SSL3_CONNECT, SSL_R_SRP_A_CALC);
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
goto end;
}
}
#endif
if (s->s3->tmp.cert_req)
s->state = SSL3_ST_CW_CERT_A;
else
s->state = SSL3_ST_CW_KEY_EXCH_A;
s->init_num = 0;
break;
case SSL3_ST_CW_CERT_A:
case SSL3_ST_CW_CERT_B:
case SSL3_ST_CW_CERT_C:
case SSL3_ST_CW_CERT_D:
ret = ssl3_send_client_certificate(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_KEY_EXCH_A;
s->init_num = 0;
break;
case SSL3_ST_CW_KEY_EXCH_A:
case SSL3_ST_CW_KEY_EXCH_B:
ret = ssl3_send_client_key_exchange(s);
if (ret <= 0)
goto end;
/*
* EAY EAY EAY need to check for DH fix cert sent back
*/
/*
* For TLS, cert_req is set to 2, so a cert chain of nothing is
* sent, but no verify packet is sent
*/
/*
* XXX: For now, we do not support client authentication in ECDH
* cipher suites with ECDH (rather than ECDSA) certificates. We
* need to skip the certificate verify message when client's
* ECDH public key is sent inside the client certificate.
*/
if (s->s3->tmp.cert_req == 1) {
s->state = SSL3_ST_CW_CERT_VRFY_A;
} else {
s->state = SSL3_ST_CW_CHANGE_A;
}
if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
s->state = SSL3_ST_CW_CHANGE_A;
}
s->init_num = 0;
break;
case SSL3_ST_CW_CERT_VRFY_A:
case SSL3_ST_CW_CERT_VRFY_B:
ret = ssl3_send_client_verify(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_CHANGE_A;
s->init_num = 0;
break;
case SSL3_ST_CW_CHANGE_A:
case SSL3_ST_CW_CHANGE_B:
ret = ssl3_send_change_cipher_spec(s,
SSL3_ST_CW_CHANGE_A,
SSL3_ST_CW_CHANGE_B);
if (ret <= 0)
goto end;
#if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
s->state = SSL3_ST_CW_FINISHED_A;
#else
if (s->s3->next_proto_neg_seen)
s->state = SSL3_ST_CW_NEXT_PROTO_A;
else
s->state = SSL3_ST_CW_FINISHED_A;
#endif
s->init_num = 0;
s->session->cipher = s->s3->tmp.new_cipher;
#ifdef OPENSSL_NO_COMP
s->session->compress_meth = 0;
#else
if (s->s3->tmp.new_compression == NULL)
s->session->compress_meth = 0;
else
s->session->compress_meth = s->s3->tmp.new_compression->id;
#endif
if (!s->method->ssl3_enc->setup_key_block(s)) {
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
if (!s->method->ssl3_enc->change_cipher_state(s,
SSL3_CHANGE_CIPHER_CLIENT_WRITE))
{
ret = -1;
s->state = SSL_ST_ERR;
goto end;
}
break;
#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
case SSL3_ST_CW_NEXT_PROTO_A:
case SSL3_ST_CW_NEXT_PROTO_B:
ret = ssl3_send_next_proto(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_FINISHED_A;
break;
#endif
case SSL3_ST_CW_FINISHED_A:
case SSL3_ST_CW_FINISHED_B:
ret = ssl3_send_finished(s,
SSL3_ST_CW_FINISHED_A,
SSL3_ST_CW_FINISHED_B,
s->method->
ssl3_enc->client_finished_label,
s->method->
ssl3_enc->client_finished_label_len);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CW_FLUSH;
/* clear flags */
s->s3->flags &= ~SSL3_FLAGS_POP_BUFFER;
if (s->hit) {
s->s3->tmp.next_state = SSL_ST_OK;
if (s->s3->flags & SSL3_FLAGS_DELAY_CLIENT_FINISHED) {
s->state = SSL_ST_OK;
s->s3->flags |= SSL3_FLAGS_POP_BUFFER;
s->s3->delay_buf_pop_ret = 0;
}
} else {
#ifndef OPENSSL_NO_TLSEXT
/*
* Allow NewSessionTicket if ticket expected
*/
if (s->tlsext_ticket_expected)
s->s3->tmp.next_state = SSL3_ST_CR_SESSION_TICKET_A;
else
#endif
s->s3->tmp.next_state = SSL3_ST_CR_FINISHED_A;
}
s->init_num = 0;
break;
#ifndef OPENSSL_NO_TLSEXT
case SSL3_ST_CR_SESSION_TICKET_A:
case SSL3_ST_CR_SESSION_TICKET_B:
ret = ssl3_get_new_session_ticket(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_FINISHED_A;
s->init_num = 0;
break;
case SSL3_ST_CR_CERT_STATUS_A:
case SSL3_ST_CR_CERT_STATUS_B:
ret = ssl3_get_cert_status(s);
if (ret <= 0)
goto end;
s->state = SSL3_ST_CR_KEY_EXCH_A;
s->init_num = 0;
break;
#endif
case SSL3_ST_CR_FINISHED_A:
case SSL3_ST_CR_FINISHED_B:
if (!s->s3->change_cipher_spec)
s->s3->flags |= SSL3_FLAGS_CCS_OK;
ret = ssl3_get_finished(s, SSL3_ST_CR_FINISHED_A,
SSL3_ST_CR_FINISHED_B);
if (ret <= 0)
goto end;
if (s->hit)
s->state = SSL3_ST_CW_CHANGE_A;
else
s->state = SSL_ST_OK;
s->init_num = 0;
break;
case SSL3_ST_CW_FLUSH:
s->rwstate = SSL_WRITING;
if (BIO_flush(s->wbio) <= 0) {
ret = -1;
goto end;
}
s->rwstate = SSL_NOTHING;
s->state = s->s3->tmp.next_state;
break;
case SSL_ST_OK:
/* clean a few things up */
ssl3_cleanup_key_block(s);
if (s->init_buf != NULL) {
BUF_MEM_free(s->init_buf);
s->init_buf = NULL;
}
/*
* If we are not 'joining' the last two packets, remove the
* buffering now
*/
if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))
ssl_free_wbio_buffer(s);
/* else do it later in ssl3_write */
s->init_num = 0;
s->renegotiate = 0;
s->new_session = 0;
ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
if (s->hit)
s->ctx->stats.sess_hit++;
ret = 1;
/* s->server=0; */
s->handshake_func = ssl3_connect;
s->ctx->stats.sess_connect_good++;
if (cb != NULL)
cb(s, SSL_CB_HANDSHAKE_DONE, 1);
goto end;
/* break; */
case SSL_ST_ERR:
default:
SSLerr(SSL_F_SSL3_CONNECT, SSL_R_UNKNOWN_STATE);
ret = -1;
goto end;
/* break; */
}
/* did we do anything */
if (!s->s3->tmp.reuse_message && !skip) {
if (s->debug) {
if ((ret = BIO_flush(s->wbio)) <= 0)
goto end;
}
if ((cb != NULL) && (s->state != state)) {
new_state = s->state;
s->state = state;
cb(s, SSL_CB_CONNECT_LOOP, 1);
s->state = new_state;
}
}
skip = 0;
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,858
|
int ssl3_get_certificate_request(SSL *s)
{
int ok, ret = 0;
unsigned long n, nc, l;
unsigned int llen, ctype_num, i;
X509_NAME *xn = NULL;
const unsigned char *p, *q;
unsigned char *d;
STACK_OF(X509_NAME) *ca_sk = NULL;
n = s->method->ssl_get_message(s,
SSL3_ST_CR_CERT_REQ_A,
SSL3_ST_CR_CERT_REQ_B,
-1, s->max_cert_list, &ok);
if (!ok)
return ((int)n);
s->s3->tmp.cert_req = 0;
if (s->s3->tmp.message_type == SSL3_MT_SERVER_DONE) {
s->s3->tmp.reuse_message = 1;
/*
* If we get here we don't need any cached handshake records as we
* wont be doing client auth.
*/
if (s->s3->handshake_buffer) {
if (!ssl3_digest_cached_records(s))
goto err;
}
return (1);
}
if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE_REQUEST) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_WRONG_MESSAGE_TYPE);
goto err;
}
/* TLS does not like anon-DH with client cert */
if (s->version > SSL3_VERSION) {
if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER);
goto err;
}
}
p = d = (unsigned char *)s->init_msg;
if ((ca_sk = sk_X509_NAME_new(ca_dn_cmp)) == NULL) {
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
goto err;
}
/* get the certificate types */
ctype_num = *(p++);
if (s->cert->ctypes) {
OPENSSL_free(s->cert->ctypes);
s->cert->ctypes = NULL;
}
if (ctype_num > SSL3_CT_NUMBER) {
/* If we exceed static buffer copy all to cert structure */
s->cert->ctypes = OPENSSL_malloc(ctype_num);
memcpy(s->cert->ctypes, p, ctype_num);
s->cert->ctype_num = (size_t)ctype_num;
ctype_num = SSL3_CT_NUMBER;
}
for (i = 0; i < ctype_num; i++)
s->s3->tmp.ctype[i] = p[i];
p += p[-1];
if (SSL_USE_SIGALGS(s)) {
n2s(p, llen);
/*
* Check we have enough room for signature algorithms and following
* length value.
*/
if ((unsigned long)(p - d + llen + 2) > n) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_DATA_LENGTH_TOO_LONG);
goto err;
}
/* Clear certificate digests and validity flags */
for (i = 0; i < SSL_PKEY_NUM; i++) {
s->cert->pkeys[i].digest = NULL;
s->cert->pkeys[i].valid_flags = 0;
}
if ((llen & 1) || !tls1_save_sigalgs(s, p, llen)) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_SIGNATURE_ALGORITHMS_ERROR);
goto err;
}
if (!tls1_process_sigalgs(s)) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
goto err;
}
p += llen;
}
/* get the CA RDNs */
n2s(p, llen);
#if 0
{
FILE *out;
out = fopen("/tmp/vsign.der", "w");
fwrite(p, 1, llen, out);
fclose(out);
}
#endif
if ((unsigned long)(p - d + llen) != n) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_LENGTH_MISMATCH);
goto err;
}
for (nc = 0; nc < llen;) {
n2s(p, l);
if ((l + nc + 2) > llen) {
if ((s->options & SSL_OP_NETSCAPE_CA_DN_BUG))
goto cont; /* netscape bugs */
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_CA_DN_TOO_LONG);
goto err;
}
q = p;
if ((xn = d2i_X509_NAME(NULL, &q, l)) == NULL) {
/* If netscape tolerance is on, ignore errors */
if (s->options & SSL_OP_NETSCAPE_CA_DN_BUG)
goto cont;
else {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_ASN1_LIB);
goto err;
}
}
if (q != (p + l)) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_CA_DN_LENGTH_MISMATCH);
goto err;
}
if (!sk_X509_NAME_push(ca_sk, xn)) {
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
goto err;
}
p += l;
nc += l + 2;
}
if (0) {
cont:
ERR_clear_error();
}
/* we should setup a certificate to return.... */
s->s3->tmp.cert_req = 1;
s->s3->tmp.ctype_num = ctype_num;
if (s->s3->tmp.ca_names != NULL)
sk_X509_NAME_pop_free(s->s3->tmp.ca_names, X509_NAME_free);
s->s3->tmp.ca_names = ca_sk;
ca_sk = NULL;
ret = 1;
goto done;
err:
s->state = SSL_ST_ERR;
done:
if (ca_sk != NULL)
sk_X509_NAME_pop_free(ca_sk, X509_NAME_free);
return (ret);
}
|
DoS
| 0
|
int ssl3_get_certificate_request(SSL *s)
{
int ok, ret = 0;
unsigned long n, nc, l;
unsigned int llen, ctype_num, i;
X509_NAME *xn = NULL;
const unsigned char *p, *q;
unsigned char *d;
STACK_OF(X509_NAME) *ca_sk = NULL;
n = s->method->ssl_get_message(s,
SSL3_ST_CR_CERT_REQ_A,
SSL3_ST_CR_CERT_REQ_B,
-1, s->max_cert_list, &ok);
if (!ok)
return ((int)n);
s->s3->tmp.cert_req = 0;
if (s->s3->tmp.message_type == SSL3_MT_SERVER_DONE) {
s->s3->tmp.reuse_message = 1;
/*
* If we get here we don't need any cached handshake records as we
* wont be doing client auth.
*/
if (s->s3->handshake_buffer) {
if (!ssl3_digest_cached_records(s))
goto err;
}
return (1);
}
if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE_REQUEST) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_WRONG_MESSAGE_TYPE);
goto err;
}
/* TLS does not like anon-DH with client cert */
if (s->version > SSL3_VERSION) {
if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER);
goto err;
}
}
p = d = (unsigned char *)s->init_msg;
if ((ca_sk = sk_X509_NAME_new(ca_dn_cmp)) == NULL) {
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
goto err;
}
/* get the certificate types */
ctype_num = *(p++);
if (s->cert->ctypes) {
OPENSSL_free(s->cert->ctypes);
s->cert->ctypes = NULL;
}
if (ctype_num > SSL3_CT_NUMBER) {
/* If we exceed static buffer copy all to cert structure */
s->cert->ctypes = OPENSSL_malloc(ctype_num);
memcpy(s->cert->ctypes, p, ctype_num);
s->cert->ctype_num = (size_t)ctype_num;
ctype_num = SSL3_CT_NUMBER;
}
for (i = 0; i < ctype_num; i++)
s->s3->tmp.ctype[i] = p[i];
p += p[-1];
if (SSL_USE_SIGALGS(s)) {
n2s(p, llen);
/*
* Check we have enough room for signature algorithms and following
* length value.
*/
if ((unsigned long)(p - d + llen + 2) > n) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_DATA_LENGTH_TOO_LONG);
goto err;
}
/* Clear certificate digests and validity flags */
for (i = 0; i < SSL_PKEY_NUM; i++) {
s->cert->pkeys[i].digest = NULL;
s->cert->pkeys[i].valid_flags = 0;
}
if ((llen & 1) || !tls1_save_sigalgs(s, p, llen)) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_SIGNATURE_ALGORITHMS_ERROR);
goto err;
}
if (!tls1_process_sigalgs(s)) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
goto err;
}
p += llen;
}
/* get the CA RDNs */
n2s(p, llen);
#if 0
{
FILE *out;
out = fopen("/tmp/vsign.der", "w");
fwrite(p, 1, llen, out);
fclose(out);
}
#endif
if ((unsigned long)(p - d + llen) != n) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_LENGTH_MISMATCH);
goto err;
}
for (nc = 0; nc < llen;) {
n2s(p, l);
if ((l + nc + 2) > llen) {
if ((s->options & SSL_OP_NETSCAPE_CA_DN_BUG))
goto cont; /* netscape bugs */
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_CA_DN_TOO_LONG);
goto err;
}
q = p;
if ((xn = d2i_X509_NAME(NULL, &q, l)) == NULL) {
/* If netscape tolerance is on, ignore errors */
if (s->options & SSL_OP_NETSCAPE_CA_DN_BUG)
goto cont;
else {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_ASN1_LIB);
goto err;
}
}
if (q != (p + l)) {
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
SSL_R_CA_DN_LENGTH_MISMATCH);
goto err;
}
if (!sk_X509_NAME_push(ca_sk, xn)) {
SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
goto err;
}
p += l;
nc += l + 2;
}
if (0) {
cont:
ERR_clear_error();
}
/* we should setup a certificate to return.... */
s->s3->tmp.cert_req = 1;
s->s3->tmp.ctype_num = ctype_num;
if (s->s3->tmp.ca_names != NULL)
sk_X509_NAME_pop_free(s->s3->tmp.ca_names, X509_NAME_free);
s->s3->tmp.ca_names = ca_sk;
ca_sk = NULL;
ret = 1;
goto done;
err:
s->state = SSL_ST_ERR;
done:
if (ca_sk != NULL)
sk_X509_NAME_pop_free(ca_sk, X509_NAME_free);
return (ret);
}
|
@@ -1456,8 +1456,6 @@ int ssl3_get_key_exchange(SSL *s)
#ifndef OPENSSL_NO_PSK
if (alg_k & SSL_kPSK) {
- char tmp_id_hint[PSK_MAX_IDENTITY_LEN + 1];
-
param_len = 2;
if (param_len > n) {
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
@@ -1483,17 +1481,8 @@ int ssl3_get_key_exchange(SSL *s)
}
param_len += i;
- /*
- * If received PSK identity hint contains NULL characters, the hint
- * is truncated from the first NULL. p may not be ending with NULL,
- * so create a NULL-terminated string.
- */
- memcpy(tmp_id_hint, p, i);
- memset(tmp_id_hint + i, 0, PSK_MAX_IDENTITY_LEN + 1 - i);
- if (s->ctx->psk_identity_hint != NULL)
- OPENSSL_free(s->ctx->psk_identity_hint);
- s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
- if (s->ctx->psk_identity_hint == NULL) {
+ s->session->psk_identity_hint = BUF_strndup((char *)p, i);
+ if (s->session->psk_identity_hint == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto f_err;
@@ -3077,7 +3066,7 @@ int ssl3_send_client_key_exchange(SSL *s)
}
memset(identity, 0, sizeof(identity));
- psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
+ psk_len = s->psk_client_callback(s, s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk_or_pre_ms,
sizeof(psk_or_pre_ms));
|
CWE-362
| null | null |
2,859
|
int ssl3_get_cert_verify(SSL *s)
{
EVP_PKEY *pkey = NULL;
unsigned char *p;
int al, ok, ret = 0;
long n;
int type = 0, i, j;
X509 *peer;
const EVP_MD *md = NULL;
EVP_MD_CTX mctx;
EVP_MD_CTX_init(&mctx);
/*
* We should only process a CertificateVerify message if we have received
* a Certificate from the client. If so then |s->session->peer| will be non
* NULL. In some instances a CertificateVerify message is not required even
* if the peer has sent a Certificate (e.g. such as in the case of static
* DH). In that case the ClientKeyExchange processing will skip the
* CertificateVerify state so we should not arrive here.
*/
if (s->session->peer == NULL) {
ret = 1;
goto end;
}
n = s->method->ssl_get_message(s,
SSL3_ST_SR_CERT_VRFY_A,
SSL3_ST_SR_CERT_VRFY_B,
SSL3_MT_CERTIFICATE_VERIFY,
SSL3_RT_MAX_PLAIN_LENGTH, &ok);
if (!ok)
return ((int)n);
peer = s->session->peer;
pkey = X509_get_pubkey(peer);
type = X509_certificate_type(peer, pkey);
if (!(type & EVP_PKT_SIGN)) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,
SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
al = SSL_AD_ILLEGAL_PARAMETER;
goto f_err;
}
/* we now have a signature that we need to verify */
p = (unsigned char *)s->init_msg;
/* Check for broken implementations of GOST ciphersuites */
/*
* If key is GOST and n is exactly 64, it is bare signature without
* length field
*/
if (n == 64 && (pkey->type == NID_id_GostR3410_94 ||
pkey->type == NID_id_GostR3410_2001)) {
i = 64;
} else {
if (SSL_USE_SIGALGS(s)) {
int rv = tls12_check_peer_sigalg(&md, s, p, pkey);
if (rv == -1) {
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
} else if (rv == 0) {
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
#ifdef SSL_DEBUG
fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
#endif
p += 2;
n -= 2;
}
n2s(p, i);
n -= 2;
if (i > n) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
}
j = EVP_PKEY_size(pkey);
if ((i > j) || (n > j) || (n <= 0)) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
if (SSL_USE_SIGALGS(s)) {
long hdatalen = 0;
void *hdata;
hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
if (hdatalen <= 0) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
}
#ifdef SSL_DEBUG
fprintf(stderr, "Using TLS 1.2 with client verify alg %s\n",
EVP_MD_name(md));
#endif
if (!EVP_VerifyInit_ex(&mctx, md, NULL)
|| !EVP_VerifyUpdate(&mctx, hdata, hdatalen)) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_EVP_LIB);
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
}
if (EVP_VerifyFinal(&mctx, p, i, pkey) <= 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
goto f_err;
}
} else
#ifndef OPENSSL_NO_RSA
if (pkey->type == EVP_PKEY_RSA) {
i = RSA_verify(NID_md5_sha1, s->s3->tmp.cert_verify_md,
MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH, p, i,
pkey->pkey.rsa);
if (i < 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_RSA_DECRYPT);
goto f_err;
}
if (i == 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_RSA_SIGNATURE);
goto f_err;
}
} else
#endif
#ifndef OPENSSL_NO_DSA
if (pkey->type == EVP_PKEY_DSA) {
j = DSA_verify(pkey->save_type,
&(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
SHA_DIGEST_LENGTH, p, i, pkey->pkey.dsa);
if (j <= 0) {
/* bad signature */
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_DSA_SIGNATURE);
goto f_err;
}
} else
#endif
#ifndef OPENSSL_NO_ECDSA
if (pkey->type == EVP_PKEY_EC) {
j = ECDSA_verify(pkey->save_type,
&(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
SHA_DIGEST_LENGTH, p, i, pkey->pkey.ec);
if (j <= 0) {
/* bad signature */
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_ECDSA_SIGNATURE);
goto f_err;
}
} else
#endif
if (pkey->type == NID_id_GostR3410_94
|| pkey->type == NID_id_GostR3410_2001) {
unsigned char signature[64];
int idx;
EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new(pkey, NULL);
EVP_PKEY_verify_init(pctx);
if (i != 64) {
fprintf(stderr, "GOST signature length is %d", i);
}
for (idx = 0; idx < 64; idx++) {
signature[63 - idx] = p[idx];
}
j = EVP_PKEY_verify(pctx, signature, 64, s->s3->tmp.cert_verify_md,
32);
EVP_PKEY_CTX_free(pctx);
if (j <= 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_ECDSA_SIGNATURE);
goto f_err;
}
} else {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
al = SSL_AD_UNSUPPORTED_CERTIFICATE;
goto f_err;
}
ret = 1;
if (0) {
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
s->state = SSL_ST_ERR;
}
end:
if (s->s3->handshake_buffer) {
BIO_free(s->s3->handshake_buffer);
s->s3->handshake_buffer = NULL;
s->s3->flags &= ~TLS1_FLAGS_KEEP_HANDSHAKE;
}
EVP_MD_CTX_cleanup(&mctx);
EVP_PKEY_free(pkey);
return (ret);
}
|
DoS
| 0
|
int ssl3_get_cert_verify(SSL *s)
{
EVP_PKEY *pkey = NULL;
unsigned char *p;
int al, ok, ret = 0;
long n;
int type = 0, i, j;
X509 *peer;
const EVP_MD *md = NULL;
EVP_MD_CTX mctx;
EVP_MD_CTX_init(&mctx);
/*
* We should only process a CertificateVerify message if we have received
* a Certificate from the client. If so then |s->session->peer| will be non
* NULL. In some instances a CertificateVerify message is not required even
* if the peer has sent a Certificate (e.g. such as in the case of static
* DH). In that case the ClientKeyExchange processing will skip the
* CertificateVerify state so we should not arrive here.
*/
if (s->session->peer == NULL) {
ret = 1;
goto end;
}
n = s->method->ssl_get_message(s,
SSL3_ST_SR_CERT_VRFY_A,
SSL3_ST_SR_CERT_VRFY_B,
SSL3_MT_CERTIFICATE_VERIFY,
SSL3_RT_MAX_PLAIN_LENGTH, &ok);
if (!ok)
return ((int)n);
peer = s->session->peer;
pkey = X509_get_pubkey(peer);
type = X509_certificate_type(peer, pkey);
if (!(type & EVP_PKT_SIGN)) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,
SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
al = SSL_AD_ILLEGAL_PARAMETER;
goto f_err;
}
/* we now have a signature that we need to verify */
p = (unsigned char *)s->init_msg;
/* Check for broken implementations of GOST ciphersuites */
/*
* If key is GOST and n is exactly 64, it is bare signature without
* length field
*/
if (n == 64 && (pkey->type == NID_id_GostR3410_94 ||
pkey->type == NID_id_GostR3410_2001)) {
i = 64;
} else {
if (SSL_USE_SIGALGS(s)) {
int rv = tls12_check_peer_sigalg(&md, s, p, pkey);
if (rv == -1) {
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
} else if (rv == 0) {
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
#ifdef SSL_DEBUG
fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
#endif
p += 2;
n -= 2;
}
n2s(p, i);
n -= 2;
if (i > n) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
}
j = EVP_PKEY_size(pkey);
if ((i > j) || (n > j) || (n <= 0)) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
if (SSL_USE_SIGALGS(s)) {
long hdatalen = 0;
void *hdata;
hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
if (hdatalen <= 0) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
}
#ifdef SSL_DEBUG
fprintf(stderr, "Using TLS 1.2 with client verify alg %s\n",
EVP_MD_name(md));
#endif
if (!EVP_VerifyInit_ex(&mctx, md, NULL)
|| !EVP_VerifyUpdate(&mctx, hdata, hdatalen)) {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_EVP_LIB);
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
}
if (EVP_VerifyFinal(&mctx, p, i, pkey) <= 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
goto f_err;
}
} else
#ifndef OPENSSL_NO_RSA
if (pkey->type == EVP_PKEY_RSA) {
i = RSA_verify(NID_md5_sha1, s->s3->tmp.cert_verify_md,
MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH, p, i,
pkey->pkey.rsa);
if (i < 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_RSA_DECRYPT);
goto f_err;
}
if (i == 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_RSA_SIGNATURE);
goto f_err;
}
} else
#endif
#ifndef OPENSSL_NO_DSA
if (pkey->type == EVP_PKEY_DSA) {
j = DSA_verify(pkey->save_type,
&(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
SHA_DIGEST_LENGTH, p, i, pkey->pkey.dsa);
if (j <= 0) {
/* bad signature */
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_DSA_SIGNATURE);
goto f_err;
}
} else
#endif
#ifndef OPENSSL_NO_ECDSA
if (pkey->type == EVP_PKEY_EC) {
j = ECDSA_verify(pkey->save_type,
&(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
SHA_DIGEST_LENGTH, p, i, pkey->pkey.ec);
if (j <= 0) {
/* bad signature */
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_ECDSA_SIGNATURE);
goto f_err;
}
} else
#endif
if (pkey->type == NID_id_GostR3410_94
|| pkey->type == NID_id_GostR3410_2001) {
unsigned char signature[64];
int idx;
EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new(pkey, NULL);
EVP_PKEY_verify_init(pctx);
if (i != 64) {
fprintf(stderr, "GOST signature length is %d", i);
}
for (idx = 0; idx < 64; idx++) {
signature[63 - idx] = p[idx];
}
j = EVP_PKEY_verify(pctx, signature, 64, s->s3->tmp.cert_verify_md,
32);
EVP_PKEY_CTX_free(pctx);
if (j <= 0) {
al = SSL_AD_DECRYPT_ERROR;
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, SSL_R_BAD_ECDSA_SIGNATURE);
goto f_err;
}
} else {
SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
al = SSL_AD_UNSUPPORTED_CERTIFICATE;
goto f_err;
}
ret = 1;
if (0) {
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
s->state = SSL_ST_ERR;
}
end:
if (s->s3->handshake_buffer) {
BIO_free(s->s3->handshake_buffer);
s->s3->handshake_buffer = NULL;
s->s3->flags &= ~TLS1_FLAGS_KEEP_HANDSHAKE;
}
EVP_MD_CTX_cleanup(&mctx);
EVP_PKEY_free(pkey);
return (ret);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,860
|
int ssl3_get_client_certificate(SSL *s)
{
int i, ok, al, ret = -1;
X509 *x = NULL;
unsigned long l, nc, llen, n;
const unsigned char *p, *q;
unsigned char *d;
STACK_OF(X509) *sk = NULL;
n = s->method->ssl_get_message(s,
SSL3_ST_SR_CERT_A,
SSL3_ST_SR_CERT_B,
-1, s->max_cert_list, &ok);
if (!ok)
return ((int)n);
if (s->s3->tmp.message_type == SSL3_MT_CLIENT_KEY_EXCHANGE) {
if ((s->verify_mode & SSL_VERIFY_PEER) &&
(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
al = SSL_AD_HANDSHAKE_FAILURE;
goto f_err;
}
/*
* If tls asked for a client cert, the client must return a 0 list
*/
if ((s->version > SSL3_VERSION) && s->s3->tmp.cert_request) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST);
al = SSL_AD_UNEXPECTED_MESSAGE;
goto f_err;
}
s->s3->tmp.reuse_message = 1;
return (1);
}
if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE) {
al = SSL_AD_UNEXPECTED_MESSAGE;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, SSL_R_WRONG_MESSAGE_TYPE);
goto f_err;
}
p = d = (unsigned char *)s->init_msg;
if ((sk = sk_X509_new_null()) == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
goto err;
}
n2l3(p, llen);
if (llen + 3 != n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
goto f_err;
}
for (nc = 0; nc < llen;) {
n2l3(p, l);
if ((l + nc + 3) > llen) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_CERT_LENGTH_MISMATCH);
goto f_err;
}
q = p;
x = d2i_X509(NULL, &p, l);
if (x == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
goto err;
}
if (p != (q + l)) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_CERT_LENGTH_MISMATCH);
goto f_err;
}
if (!sk_X509_push(sk, x)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
goto err;
}
x = NULL;
nc += l + 3;
}
if (sk_X509_num(sk) <= 0) {
/* TLS does not mind 0 certs returned */
if (s->version == SSL3_VERSION) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_NO_CERTIFICATES_RETURNED);
goto f_err;
}
/* Fail for TLS only if we required a certificate */
else if ((s->verify_mode & SSL_VERIFY_PEER) &&
(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
al = SSL_AD_HANDSHAKE_FAILURE;
goto f_err;
}
/* No client certificate so digest cached records */
if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s)) {
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
}
} else {
i = ssl_verify_cert_chain(s, sk);
if (i <= 0) {
al = ssl_verify_alarm_type(s->verify_result);
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_CERTIFICATE_VERIFY_FAILED);
goto f_err;
}
}
if (s->session->peer != NULL) /* This should not be needed */
X509_free(s->session->peer);
s->session->peer = sk_X509_shift(sk);
s->session->verify_result = s->verify_result;
/*
* With the current implementation, sess_cert will always be NULL when we
* arrive here.
*/
if (s->session->sess_cert == NULL) {
s->session->sess_cert = ssl_sess_cert_new();
if (s->session->sess_cert == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
goto err;
}
}
if (s->session->sess_cert->cert_chain != NULL)
sk_X509_pop_free(s->session->sess_cert->cert_chain, X509_free);
s->session->sess_cert->cert_chain = sk;
/*
* Inconsistency alert: cert_chain does *not* include the peer's own
* certificate, while we do include it in s3_clnt.c
*/
sk = NULL;
ret = 1;
if (0) {
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
s->state = SSL_ST_ERR;
}
if (x != NULL)
X509_free(x);
if (sk != NULL)
sk_X509_pop_free(sk, X509_free);
return (ret);
}
|
DoS
| 0
|
int ssl3_get_client_certificate(SSL *s)
{
int i, ok, al, ret = -1;
X509 *x = NULL;
unsigned long l, nc, llen, n;
const unsigned char *p, *q;
unsigned char *d;
STACK_OF(X509) *sk = NULL;
n = s->method->ssl_get_message(s,
SSL3_ST_SR_CERT_A,
SSL3_ST_SR_CERT_B,
-1, s->max_cert_list, &ok);
if (!ok)
return ((int)n);
if (s->s3->tmp.message_type == SSL3_MT_CLIENT_KEY_EXCHANGE) {
if ((s->verify_mode & SSL_VERIFY_PEER) &&
(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
al = SSL_AD_HANDSHAKE_FAILURE;
goto f_err;
}
/*
* If tls asked for a client cert, the client must return a 0 list
*/
if ((s->version > SSL3_VERSION) && s->s3->tmp.cert_request) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST);
al = SSL_AD_UNEXPECTED_MESSAGE;
goto f_err;
}
s->s3->tmp.reuse_message = 1;
return (1);
}
if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE) {
al = SSL_AD_UNEXPECTED_MESSAGE;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, SSL_R_WRONG_MESSAGE_TYPE);
goto f_err;
}
p = d = (unsigned char *)s->init_msg;
if ((sk = sk_X509_new_null()) == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
goto err;
}
n2l3(p, llen);
if (llen + 3 != n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
goto f_err;
}
for (nc = 0; nc < llen;) {
n2l3(p, l);
if ((l + nc + 3) > llen) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_CERT_LENGTH_MISMATCH);
goto f_err;
}
q = p;
x = d2i_X509(NULL, &p, l);
if (x == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
goto err;
}
if (p != (q + l)) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_CERT_LENGTH_MISMATCH);
goto f_err;
}
if (!sk_X509_push(sk, x)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
goto err;
}
x = NULL;
nc += l + 3;
}
if (sk_X509_num(sk) <= 0) {
/* TLS does not mind 0 certs returned */
if (s->version == SSL3_VERSION) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_NO_CERTIFICATES_RETURNED);
goto f_err;
}
/* Fail for TLS only if we required a certificate */
else if ((s->verify_mode & SSL_VERIFY_PEER) &&
(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
al = SSL_AD_HANDSHAKE_FAILURE;
goto f_err;
}
/* No client certificate so digest cached records */
if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s)) {
al = SSL_AD_INTERNAL_ERROR;
goto f_err;
}
} else {
i = ssl_verify_cert_chain(s, sk);
if (i <= 0) {
al = ssl_verify_alarm_type(s->verify_result);
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
SSL_R_CERTIFICATE_VERIFY_FAILED);
goto f_err;
}
}
if (s->session->peer != NULL) /* This should not be needed */
X509_free(s->session->peer);
s->session->peer = sk_X509_shift(sk);
s->session->verify_result = s->verify_result;
/*
* With the current implementation, sess_cert will always be NULL when we
* arrive here.
*/
if (s->session->sess_cert == NULL) {
s->session->sess_cert = ssl_sess_cert_new();
if (s->session->sess_cert == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
goto err;
}
}
if (s->session->sess_cert->cert_chain != NULL)
sk_X509_pop_free(s->session->sess_cert->cert_chain, X509_free);
s->session->sess_cert->cert_chain = sk;
/*
* Inconsistency alert: cert_chain does *not* include the peer's own
* certificate, while we do include it in s3_clnt.c
*/
sk = NULL;
ret = 1;
if (0) {
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
s->state = SSL_ST_ERR;
}
if (x != NULL)
X509_free(x);
if (sk != NULL)
sk_X509_pop_free(sk, X509_free);
return (ret);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,861
|
int ssl3_get_client_hello(SSL *s)
{
int i, j, ok, al = SSL_AD_INTERNAL_ERROR, ret = -1;
unsigned int cookie_len;
long n;
unsigned long id;
unsigned char *p, *d;
SSL_CIPHER *c;
#ifndef OPENSSL_NO_COMP
unsigned char *q;
SSL_COMP *comp = NULL;
#endif
STACK_OF(SSL_CIPHER) *ciphers = NULL;
if (s->state == SSL3_ST_SR_CLNT_HELLO_C && !s->first_packet)
goto retry_cert;
/*
* We do this so that we will respond with our native type. If we are
* TLSv1 and we get SSLv3, we will respond with TLSv1, This down
* switching should be handled by a different method. If we are SSLv3, we
* will respond with SSLv3, even if prompted with TLSv1.
*/
if (s->state == SSL3_ST_SR_CLNT_HELLO_A) {
s->state = SSL3_ST_SR_CLNT_HELLO_B;
}
s->first_packet = 1;
n = s->method->ssl_get_message(s,
SSL3_ST_SR_CLNT_HELLO_B,
SSL3_ST_SR_CLNT_HELLO_C,
SSL3_MT_CLIENT_HELLO,
SSL3_RT_MAX_PLAIN_LENGTH, &ok);
if (!ok)
return ((int)n);
s->first_packet = 0;
d = p = (unsigned char *)s->init_msg;
/*
* 2 bytes for client version, SSL3_RANDOM_SIZE bytes for random, 1 byte
* for session id length
*/
if (n < 2 + SSL3_RANDOM_SIZE + 1) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
/*
* use version from inside client hello, not from record header (may
* differ: see RFC 2246, Appendix E, second paragraph)
*/
s->client_version = (((int)p[0]) << 8) | (int)p[1];
p += 2;
if (SSL_IS_DTLS(s) ? (s->client_version > s->version &&
s->method->version != DTLS_ANY_VERSION)
: (s->client_version < s->version)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
if ((s->client_version >> 8) == SSL3_VERSION_MAJOR &&
!s->enc_write_ctx && !s->write_hash) {
/*
* similar to ssl3_get_record, send alert using remote version
* number
*/
s->version = s->client_version;
}
al = SSL_AD_PROTOCOL_VERSION;
goto f_err;
}
/*
* If we require cookies and this ClientHello doesn't contain one, just
* return since we do not want to allocate any memory yet. So check
* cookie length...
*/
if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
unsigned int session_length, cookie_length;
session_length = *(p + SSL3_RANDOM_SIZE);
if (p + SSL3_RANDOM_SIZE + session_length + 1 >= d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
cookie_length = *(p + SSL3_RANDOM_SIZE + session_length + 1);
if (cookie_length == 0)
return 1;
}
/* load the client random */
memcpy(s->s3->client_random, p, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
/* get the session-id */
j = *(p++);
if (p + j > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
s->hit = 0;
/*
* Versions before 0.9.7 always allow clients to resume sessions in
* renegotiation. 0.9.7 and later allow this by default, but optionally
* ignore resumption requests with flag
* SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
* than a change to default behavior so that applications relying on this
* for security won't even compile against older library versions).
* 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to
* request renegotiation but not a new session (s->new_session remains
* unset): for servers, this essentially just means that the
* SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be ignored.
*/
if ((s->new_session
&& (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
if (!ssl_get_new_session(s, 1))
goto err;
} else {
i = ssl_get_prev_session(s, p, j, d + n);
/*
* Only resume if the session's version matches the negotiated
* version.
* RFC 5246 does not provide much useful advice on resumption
* with a different protocol version. It doesn't forbid it but
* the sanity of such behaviour would be questionable.
* In practice, clients do not accept a version mismatch and
* will abort the handshake with an error.
*/
if (i == 1 && s->version == s->session->ssl_version) { /* previous
* session */
s->hit = 1;
} else if (i == -1)
goto err;
else { /* i == 0 */
if (!ssl_get_new_session(s, 1))
goto err;
}
}
p += j;
if (SSL_IS_DTLS(s)) {
/* cookie stuff */
if (p + 1 > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
cookie_len = *(p++);
if (p + cookie_len > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
/*
* The ClientHello may contain a cookie even if the
* HelloVerify message has not been sent--make sure that it
* does not cause an overflow.
*/
if (cookie_len > sizeof(s->d1->rcvd_cookie)) {
/* too much data */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
goto f_err;
}
/* verify the cookie if appropriate option is set. */
if ((SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) && cookie_len > 0) {
memcpy(s->d1->rcvd_cookie, p, cookie_len);
if (s->ctx->app_verify_cookie_cb != NULL) {
if (s->ctx->app_verify_cookie_cb(s, s->d1->rcvd_cookie,
cookie_len) == 0) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_COOKIE_MISMATCH);
goto f_err;
}
/* else cookie verification succeeded */
}
/* default verification */
else if (memcmp(s->d1->rcvd_cookie, s->d1->cookie,
s->d1->cookie_len) != 0) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
goto f_err;
}
/* Set to -2 so if successful we return 2 */
ret = -2;
}
p += cookie_len;
if (s->method->version == DTLS_ANY_VERSION) {
/* Select version to use */
if (s->client_version <= DTLS1_2_VERSION &&
!(s->options & SSL_OP_NO_DTLSv1_2)) {
s->version = DTLS1_2_VERSION;
s->method = DTLSv1_2_server_method();
} else if (tls1_suiteb(s)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
s->version = s->client_version;
al = SSL_AD_PROTOCOL_VERSION;
goto f_err;
} else if (s->client_version <= DTLS1_VERSION &&
!(s->options & SSL_OP_NO_DTLSv1)) {
s->version = DTLS1_VERSION;
s->method = DTLSv1_server_method();
} else {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_WRONG_VERSION_NUMBER);
s->version = s->client_version;
al = SSL_AD_PROTOCOL_VERSION;
goto f_err;
}
s->session->ssl_version = s->version;
}
}
if (p + 2 > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
n2s(p, i);
if (i == 0) {
al = SSL_AD_ILLEGAL_PARAMETER;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_CIPHERS_SPECIFIED);
goto f_err;
}
/* i bytes of cipher data + 1 byte for compression length later */
if ((p + i + 1) > (d + n)) {
/* not enough data */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
goto f_err;
}
if (ssl_bytes_to_cipher_list(s, p, i, &(ciphers)) == NULL) {
goto err;
}
p += i;
/* If it is a hit, check that the cipher is in the list */
if (s->hit) {
j = 0;
id = s->session->cipher->id;
#ifdef CIPHER_DEBUG
fprintf(stderr, "client sent %d ciphers\n",
sk_SSL_CIPHER_num(ciphers));
#endif
for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
c = sk_SSL_CIPHER_value(ciphers, i);
#ifdef CIPHER_DEBUG
fprintf(stderr, "client [%2d of %2d]:%s\n",
i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
#endif
if (c->id == id) {
j = 1;
break;
}
}
/*
* Disabled because it can be used in a ciphersuite downgrade attack:
* CVE-2010-4180.
*/
#if 0
if (j == 0 && (s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG)
&& (sk_SSL_CIPHER_num(ciphers) == 1)) {
/*
* Special case as client bug workaround: the previously used
* cipher may not be in the current list, the client instead
* might be trying to continue using a cipher that before wasn't
* chosen due to server preferences. We'll have to reject the
* connection if the cipher is not enabled, though.
*/
c = sk_SSL_CIPHER_value(ciphers, 0);
if (sk_SSL_CIPHER_find(SSL_get_ciphers(s), c) >= 0) {
s->session->cipher = c;
j = 1;
}
}
#endif
if (j == 0) {
/*
* we need to have the cipher in the cipher list if we are asked
* to reuse it
*/
al = SSL_AD_ILLEGAL_PARAMETER;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_REQUIRED_CIPHER_MISSING);
goto f_err;
}
}
/* compression */
i = *(p++);
if ((p + i) > (d + n)) {
/* not enough data */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
goto f_err;
}
#ifndef OPENSSL_NO_COMP
q = p;
#endif
for (j = 0; j < i; j++) {
if (p[j] == 0)
break;
}
p += i;
if (j >= i) {
/* no compress */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_COMPRESSION_SPECIFIED);
goto f_err;
}
#ifndef OPENSSL_NO_TLSEXT
/* TLS extensions */
if (s->version >= SSL3_VERSION) {
if (!ssl_parse_clienthello_tlsext(s, &p, d, n)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_PARSE_TLSEXT);
goto err;
}
}
/*
* Check if we want to use external pre-shared secret for this handshake
* for not reused session only. We need to generate server_random before
* calling tls_session_secret_cb in order to allow SessionTicket
* processing to use it in key derivation.
*/
{
unsigned char *pos;
pos = s->s3->server_random;
if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0) {
goto f_err;
}
}
if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb) {
SSL_CIPHER *pref_cipher = NULL;
s->session->master_key_length = sizeof(s->session->master_key);
if (s->tls_session_secret_cb(s, s->session->master_key,
&s->session->master_key_length, ciphers,
&pref_cipher,
s->tls_session_secret_cb_arg)) {
s->hit = 1;
s->session->ciphers = ciphers;
s->session->verify_result = X509_V_OK;
ciphers = NULL;
/* check if some cipher was preferred by call back */
pref_cipher =
pref_cipher ? pref_cipher : ssl3_choose_cipher(s,
s->
session->ciphers,
SSL_get_ciphers
(s));
if (pref_cipher == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
goto f_err;
}
s->session->cipher = pref_cipher;
if (s->cipher_list)
sk_SSL_CIPHER_free(s->cipher_list);
if (s->cipher_list_by_id)
sk_SSL_CIPHER_free(s->cipher_list_by_id);
s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
}
}
#endif
/*
* Worst case, we will use the NULL compression, but if we have other
* options, we will now look for them. We have i-1 compression
* algorithms from the client, starting at q.
*/
s->s3->tmp.new_compression = NULL;
#ifndef OPENSSL_NO_COMP
/* This only happens if we have a cache hit */
if (s->session->compress_meth != 0) {
int m, comp_id = s->session->compress_meth;
/* Perform sanity checks on resumed compression algorithm */
/* Can't disable compression */
if (s->options & SSL_OP_NO_COMPRESSION) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_INCONSISTENT_COMPRESSION);
goto f_err;
}
/* Look for resumed compression method */
for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
if (comp_id == comp->id) {
s->s3->tmp.new_compression = comp;
break;
}
}
if (s->s3->tmp.new_compression == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_INVALID_COMPRESSION_ALGORITHM);
goto f_err;
}
/* Look for resumed method in compression list */
for (m = 0; m < i; m++) {
if (q[m] == comp_id)
break;
}
if (m >= i) {
al = SSL_AD_ILLEGAL_PARAMETER;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING);
goto f_err;
}
} else if (s->hit)
comp = NULL;
else if (!(s->options & SSL_OP_NO_COMPRESSION) && s->ctx->comp_methods) {
/* See if we have a match */
int m, nn, o, v, done = 0;
nn = sk_SSL_COMP_num(s->ctx->comp_methods);
for (m = 0; m < nn; m++) {
comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
v = comp->id;
for (o = 0; o < i; o++) {
if (v == q[o]) {
done = 1;
break;
}
}
if (done)
break;
}
if (done)
s->s3->tmp.new_compression = comp;
else
comp = NULL;
}
#else
/*
* If compression is disabled we'd better not try to resume a session
* using compression.
*/
if (s->session->compress_meth != 0) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
goto f_err;
}
#endif
/*
* Given s->session->ciphers and SSL_get_ciphers, we must pick a cipher
*/
if (!s->hit) {
#ifdef OPENSSL_NO_COMP
s->session->compress_meth = 0;
#else
s->session->compress_meth = (comp == NULL) ? 0 : comp->id;
#endif
if (s->session->ciphers != NULL)
sk_SSL_CIPHER_free(s->session->ciphers);
s->session->ciphers = ciphers;
if (ciphers == NULL) {
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto f_err;
}
ciphers = NULL;
if (!tls1_set_server_sigalgs(s)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
goto err;
}
/* Let cert callback update server certificates if required */
retry_cert:
if (s->cert->cert_cb) {
int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
if (rv == 0) {
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CERT_CB_ERROR);
goto f_err;
}
if (rv < 0) {
s->rwstate = SSL_X509_LOOKUP;
return -1;
}
s->rwstate = SSL_NOTHING;
}
c = ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
if (c == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
goto f_err;
}
s->s3->tmp.new_cipher = c;
} else {
/* Session-id reuse */
#ifdef REUSE_CIPHER_BUG
STACK_OF(SSL_CIPHER) *sk;
SSL_CIPHER *nc = NULL;
SSL_CIPHER *ec = NULL;
if (s->options & SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG) {
sk = s->session->ciphers;
for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
c = sk_SSL_CIPHER_value(sk, i);
if (c->algorithm_enc & SSL_eNULL)
nc = c;
if (SSL_C_IS_EXPORT(c))
ec = c;
}
if (nc != NULL)
s->s3->tmp.new_cipher = nc;
else if (ec != NULL)
s->s3->tmp.new_cipher = ec;
else
s->s3->tmp.new_cipher = s->session->cipher;
} else
#endif
s->s3->tmp.new_cipher = s->session->cipher;
}
if (!SSL_USE_SIGALGS(s) || !(s->verify_mode & SSL_VERIFY_PEER)) {
if (!ssl3_digest_cached_records(s))
goto f_err;
}
/*-
* we now have the following setup.
* client_random
* cipher_list - our prefered list of ciphers
* ciphers - the clients prefered list of ciphers
* compression - basically ignored right now
* ssl version is set - sslv3
* s->session - The ssl session has been setup.
* s->hit - session reuse flag
* s->tmp.new_cipher - the new cipher to use.
*/
/* Handles TLS extensions that we couldn't check earlier */
if (s->version >= SSL3_VERSION) {
if (ssl_check_clienthello_tlsext_late(s) <= 0) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
goto err;
}
}
if (ret < 0)
ret = -ret;
if (0) {
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
s->state = SSL_ST_ERR;
}
if (ciphers != NULL)
sk_SSL_CIPHER_free(ciphers);
return ret < 0 ? -1 : ret;
}
|
DoS
| 0
|
int ssl3_get_client_hello(SSL *s)
{
int i, j, ok, al = SSL_AD_INTERNAL_ERROR, ret = -1;
unsigned int cookie_len;
long n;
unsigned long id;
unsigned char *p, *d;
SSL_CIPHER *c;
#ifndef OPENSSL_NO_COMP
unsigned char *q;
SSL_COMP *comp = NULL;
#endif
STACK_OF(SSL_CIPHER) *ciphers = NULL;
if (s->state == SSL3_ST_SR_CLNT_HELLO_C && !s->first_packet)
goto retry_cert;
/*
* We do this so that we will respond with our native type. If we are
* TLSv1 and we get SSLv3, we will respond with TLSv1, This down
* switching should be handled by a different method. If we are SSLv3, we
* will respond with SSLv3, even if prompted with TLSv1.
*/
if (s->state == SSL3_ST_SR_CLNT_HELLO_A) {
s->state = SSL3_ST_SR_CLNT_HELLO_B;
}
s->first_packet = 1;
n = s->method->ssl_get_message(s,
SSL3_ST_SR_CLNT_HELLO_B,
SSL3_ST_SR_CLNT_HELLO_C,
SSL3_MT_CLIENT_HELLO,
SSL3_RT_MAX_PLAIN_LENGTH, &ok);
if (!ok)
return ((int)n);
s->first_packet = 0;
d = p = (unsigned char *)s->init_msg;
/*
* 2 bytes for client version, SSL3_RANDOM_SIZE bytes for random, 1 byte
* for session id length
*/
if (n < 2 + SSL3_RANDOM_SIZE + 1) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
/*
* use version from inside client hello, not from record header (may
* differ: see RFC 2246, Appendix E, second paragraph)
*/
s->client_version = (((int)p[0]) << 8) | (int)p[1];
p += 2;
if (SSL_IS_DTLS(s) ? (s->client_version > s->version &&
s->method->version != DTLS_ANY_VERSION)
: (s->client_version < s->version)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
if ((s->client_version >> 8) == SSL3_VERSION_MAJOR &&
!s->enc_write_ctx && !s->write_hash) {
/*
* similar to ssl3_get_record, send alert using remote version
* number
*/
s->version = s->client_version;
}
al = SSL_AD_PROTOCOL_VERSION;
goto f_err;
}
/*
* If we require cookies and this ClientHello doesn't contain one, just
* return since we do not want to allocate any memory yet. So check
* cookie length...
*/
if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
unsigned int session_length, cookie_length;
session_length = *(p + SSL3_RANDOM_SIZE);
if (p + SSL3_RANDOM_SIZE + session_length + 1 >= d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
cookie_length = *(p + SSL3_RANDOM_SIZE + session_length + 1);
if (cookie_length == 0)
return 1;
}
/* load the client random */
memcpy(s->s3->client_random, p, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
/* get the session-id */
j = *(p++);
if (p + j > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
s->hit = 0;
/*
* Versions before 0.9.7 always allow clients to resume sessions in
* renegotiation. 0.9.7 and later allow this by default, but optionally
* ignore resumption requests with flag
* SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
* than a change to default behavior so that applications relying on this
* for security won't even compile against older library versions).
* 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to
* request renegotiation but not a new session (s->new_session remains
* unset): for servers, this essentially just means that the
* SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be ignored.
*/
if ((s->new_session
&& (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
if (!ssl_get_new_session(s, 1))
goto err;
} else {
i = ssl_get_prev_session(s, p, j, d + n);
/*
* Only resume if the session's version matches the negotiated
* version.
* RFC 5246 does not provide much useful advice on resumption
* with a different protocol version. It doesn't forbid it but
* the sanity of such behaviour would be questionable.
* In practice, clients do not accept a version mismatch and
* will abort the handshake with an error.
*/
if (i == 1 && s->version == s->session->ssl_version) { /* previous
* session */
s->hit = 1;
} else if (i == -1)
goto err;
else { /* i == 0 */
if (!ssl_get_new_session(s, 1))
goto err;
}
}
p += j;
if (SSL_IS_DTLS(s)) {
/* cookie stuff */
if (p + 1 > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
cookie_len = *(p++);
if (p + cookie_len > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
/*
* The ClientHello may contain a cookie even if the
* HelloVerify message has not been sent--make sure that it
* does not cause an overflow.
*/
if (cookie_len > sizeof(s->d1->rcvd_cookie)) {
/* too much data */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
goto f_err;
}
/* verify the cookie if appropriate option is set. */
if ((SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) && cookie_len > 0) {
memcpy(s->d1->rcvd_cookie, p, cookie_len);
if (s->ctx->app_verify_cookie_cb != NULL) {
if (s->ctx->app_verify_cookie_cb(s, s->d1->rcvd_cookie,
cookie_len) == 0) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_COOKIE_MISMATCH);
goto f_err;
}
/* else cookie verification succeeded */
}
/* default verification */
else if (memcmp(s->d1->rcvd_cookie, s->d1->cookie,
s->d1->cookie_len) != 0) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
goto f_err;
}
/* Set to -2 so if successful we return 2 */
ret = -2;
}
p += cookie_len;
if (s->method->version == DTLS_ANY_VERSION) {
/* Select version to use */
if (s->client_version <= DTLS1_2_VERSION &&
!(s->options & SSL_OP_NO_DTLSv1_2)) {
s->version = DTLS1_2_VERSION;
s->method = DTLSv1_2_server_method();
} else if (tls1_suiteb(s)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
s->version = s->client_version;
al = SSL_AD_PROTOCOL_VERSION;
goto f_err;
} else if (s->client_version <= DTLS1_VERSION &&
!(s->options & SSL_OP_NO_DTLSv1)) {
s->version = DTLS1_VERSION;
s->method = DTLSv1_server_method();
} else {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_WRONG_VERSION_NUMBER);
s->version = s->client_version;
al = SSL_AD_PROTOCOL_VERSION;
goto f_err;
}
s->session->ssl_version = s->version;
}
}
if (p + 2 > d + n) {
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
goto f_err;
}
n2s(p, i);
if (i == 0) {
al = SSL_AD_ILLEGAL_PARAMETER;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_CIPHERS_SPECIFIED);
goto f_err;
}
/* i bytes of cipher data + 1 byte for compression length later */
if ((p + i + 1) > (d + n)) {
/* not enough data */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
goto f_err;
}
if (ssl_bytes_to_cipher_list(s, p, i, &(ciphers)) == NULL) {
goto err;
}
p += i;
/* If it is a hit, check that the cipher is in the list */
if (s->hit) {
j = 0;
id = s->session->cipher->id;
#ifdef CIPHER_DEBUG
fprintf(stderr, "client sent %d ciphers\n",
sk_SSL_CIPHER_num(ciphers));
#endif
for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
c = sk_SSL_CIPHER_value(ciphers, i);
#ifdef CIPHER_DEBUG
fprintf(stderr, "client [%2d of %2d]:%s\n",
i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
#endif
if (c->id == id) {
j = 1;
break;
}
}
/*
* Disabled because it can be used in a ciphersuite downgrade attack:
* CVE-2010-4180.
*/
#if 0
if (j == 0 && (s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG)
&& (sk_SSL_CIPHER_num(ciphers) == 1)) {
/*
* Special case as client bug workaround: the previously used
* cipher may not be in the current list, the client instead
* might be trying to continue using a cipher that before wasn't
* chosen due to server preferences. We'll have to reject the
* connection if the cipher is not enabled, though.
*/
c = sk_SSL_CIPHER_value(ciphers, 0);
if (sk_SSL_CIPHER_find(SSL_get_ciphers(s), c) >= 0) {
s->session->cipher = c;
j = 1;
}
}
#endif
if (j == 0) {
/*
* we need to have the cipher in the cipher list if we are asked
* to reuse it
*/
al = SSL_AD_ILLEGAL_PARAMETER;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_REQUIRED_CIPHER_MISSING);
goto f_err;
}
}
/* compression */
i = *(p++);
if ((p + i) > (d + n)) {
/* not enough data */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
goto f_err;
}
#ifndef OPENSSL_NO_COMP
q = p;
#endif
for (j = 0; j < i; j++) {
if (p[j] == 0)
break;
}
p += i;
if (j >= i) {
/* no compress */
al = SSL_AD_DECODE_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_COMPRESSION_SPECIFIED);
goto f_err;
}
#ifndef OPENSSL_NO_TLSEXT
/* TLS extensions */
if (s->version >= SSL3_VERSION) {
if (!ssl_parse_clienthello_tlsext(s, &p, d, n)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_PARSE_TLSEXT);
goto err;
}
}
/*
* Check if we want to use external pre-shared secret for this handshake
* for not reused session only. We need to generate server_random before
* calling tls_session_secret_cb in order to allow SessionTicket
* processing to use it in key derivation.
*/
{
unsigned char *pos;
pos = s->s3->server_random;
if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0) {
goto f_err;
}
}
if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb) {
SSL_CIPHER *pref_cipher = NULL;
s->session->master_key_length = sizeof(s->session->master_key);
if (s->tls_session_secret_cb(s, s->session->master_key,
&s->session->master_key_length, ciphers,
&pref_cipher,
s->tls_session_secret_cb_arg)) {
s->hit = 1;
s->session->ciphers = ciphers;
s->session->verify_result = X509_V_OK;
ciphers = NULL;
/* check if some cipher was preferred by call back */
pref_cipher =
pref_cipher ? pref_cipher : ssl3_choose_cipher(s,
s->
session->ciphers,
SSL_get_ciphers
(s));
if (pref_cipher == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
goto f_err;
}
s->session->cipher = pref_cipher;
if (s->cipher_list)
sk_SSL_CIPHER_free(s->cipher_list);
if (s->cipher_list_by_id)
sk_SSL_CIPHER_free(s->cipher_list_by_id);
s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
}
}
#endif
/*
* Worst case, we will use the NULL compression, but if we have other
* options, we will now look for them. We have i-1 compression
* algorithms from the client, starting at q.
*/
s->s3->tmp.new_compression = NULL;
#ifndef OPENSSL_NO_COMP
/* This only happens if we have a cache hit */
if (s->session->compress_meth != 0) {
int m, comp_id = s->session->compress_meth;
/* Perform sanity checks on resumed compression algorithm */
/* Can't disable compression */
if (s->options & SSL_OP_NO_COMPRESSION) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_INCONSISTENT_COMPRESSION);
goto f_err;
}
/* Look for resumed compression method */
for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
if (comp_id == comp->id) {
s->s3->tmp.new_compression = comp;
break;
}
}
if (s->s3->tmp.new_compression == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_INVALID_COMPRESSION_ALGORITHM);
goto f_err;
}
/* Look for resumed method in compression list */
for (m = 0; m < i; m++) {
if (q[m] == comp_id)
break;
}
if (m >= i) {
al = SSL_AD_ILLEGAL_PARAMETER;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING);
goto f_err;
}
} else if (s->hit)
comp = NULL;
else if (!(s->options & SSL_OP_NO_COMPRESSION) && s->ctx->comp_methods) {
/* See if we have a match */
int m, nn, o, v, done = 0;
nn = sk_SSL_COMP_num(s->ctx->comp_methods);
for (m = 0; m < nn; m++) {
comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
v = comp->id;
for (o = 0; o < i; o++) {
if (v == q[o]) {
done = 1;
break;
}
}
if (done)
break;
}
if (done)
s->s3->tmp.new_compression = comp;
else
comp = NULL;
}
#else
/*
* If compression is disabled we'd better not try to resume a session
* using compression.
*/
if (s->session->compress_meth != 0) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
goto f_err;
}
#endif
/*
* Given s->session->ciphers and SSL_get_ciphers, we must pick a cipher
*/
if (!s->hit) {
#ifdef OPENSSL_NO_COMP
s->session->compress_meth = 0;
#else
s->session->compress_meth = (comp == NULL) ? 0 : comp->id;
#endif
if (s->session->ciphers != NULL)
sk_SSL_CIPHER_free(s->session->ciphers);
s->session->ciphers = ciphers;
if (ciphers == NULL) {
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
goto f_err;
}
ciphers = NULL;
if (!tls1_set_server_sigalgs(s)) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
goto err;
}
/* Let cert callback update server certificates if required */
retry_cert:
if (s->cert->cert_cb) {
int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
if (rv == 0) {
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CERT_CB_ERROR);
goto f_err;
}
if (rv < 0) {
s->rwstate = SSL_X509_LOOKUP;
return -1;
}
s->rwstate = SSL_NOTHING;
}
c = ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
if (c == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
goto f_err;
}
s->s3->tmp.new_cipher = c;
} else {
/* Session-id reuse */
#ifdef REUSE_CIPHER_BUG
STACK_OF(SSL_CIPHER) *sk;
SSL_CIPHER *nc = NULL;
SSL_CIPHER *ec = NULL;
if (s->options & SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG) {
sk = s->session->ciphers;
for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
c = sk_SSL_CIPHER_value(sk, i);
if (c->algorithm_enc & SSL_eNULL)
nc = c;
if (SSL_C_IS_EXPORT(c))
ec = c;
}
if (nc != NULL)
s->s3->tmp.new_cipher = nc;
else if (ec != NULL)
s->s3->tmp.new_cipher = ec;
else
s->s3->tmp.new_cipher = s->session->cipher;
} else
#endif
s->s3->tmp.new_cipher = s->session->cipher;
}
if (!SSL_USE_SIGALGS(s) || !(s->verify_mode & SSL_VERIFY_PEER)) {
if (!ssl3_digest_cached_records(s))
goto f_err;
}
/*-
* we now have the following setup.
* client_random
* cipher_list - our prefered list of ciphers
* ciphers - the clients prefered list of ciphers
* compression - basically ignored right now
* ssl version is set - sslv3
* s->session - The ssl session has been setup.
* s->hit - session reuse flag
* s->tmp.new_cipher - the new cipher to use.
*/
/* Handles TLS extensions that we couldn't check earlier */
if (s->version >= SSL3_VERSION) {
if (ssl_check_clienthello_tlsext_late(s) <= 0) {
SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
goto err;
}
}
if (ret < 0)
ret = -ret;
if (0) {
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
s->state = SSL_ST_ERR;
}
if (ciphers != NULL)
sk_SSL_CIPHER_free(ciphers);
return ret < 0 ? -1 : ret;
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,862
|
static const SSL_METHOD *ssl3_get_server_method(int ver)
{
if (ver == SSL3_VERSION)
return (SSLv3_server_method());
else
return (NULL);
}
|
DoS
| 0
|
static const SSL_METHOD *ssl3_get_server_method(int ver)
{
if (ver == SSL3_VERSION)
return (SSLv3_server_method());
else
return (NULL);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,863
|
int ssl3_send_cert_status(SSL *s)
{
if (s->state == SSL3_ST_SW_CERT_STATUS_A) {
unsigned char *p;
/*-
* Grow buffer if need be: the length calculation is as
* follows 1 (message type) + 3 (message length) +
* 1 (ocsp response type) + 3 (ocsp response length)
* + (ocsp response)
*/
if (!BUF_MEM_grow(s->init_buf, 8 + s->tlsext_ocsp_resplen)) {
s->state = SSL_ST_ERR;
return -1;
}
p = (unsigned char *)s->init_buf->data;
/* do the header */
*(p++) = SSL3_MT_CERTIFICATE_STATUS;
/* message length */
l2n3(s->tlsext_ocsp_resplen + 4, p);
/* status type */
*(p++) = s->tlsext_status_type;
/* length of OCSP response */
l2n3(s->tlsext_ocsp_resplen, p);
/* actual response */
memcpy(p, s->tlsext_ocsp_resp, s->tlsext_ocsp_resplen);
/* number of bytes to write */
s->init_num = 8 + s->tlsext_ocsp_resplen;
s->state = SSL3_ST_SW_CERT_STATUS_B;
s->init_off = 0;
}
/* SSL3_ST_SW_CERT_STATUS_B */
return (ssl3_do_write(s, SSL3_RT_HANDSHAKE));
}
|
DoS
| 0
|
int ssl3_send_cert_status(SSL *s)
{
if (s->state == SSL3_ST_SW_CERT_STATUS_A) {
unsigned char *p;
/*-
* Grow buffer if need be: the length calculation is as
* follows 1 (message type) + 3 (message length) +
* 1 (ocsp response type) + 3 (ocsp response length)
* + (ocsp response)
*/
if (!BUF_MEM_grow(s->init_buf, 8 + s->tlsext_ocsp_resplen)) {
s->state = SSL_ST_ERR;
return -1;
}
p = (unsigned char *)s->init_buf->data;
/* do the header */
*(p++) = SSL3_MT_CERTIFICATE_STATUS;
/* message length */
l2n3(s->tlsext_ocsp_resplen + 4, p);
/* status type */
*(p++) = s->tlsext_status_type;
/* length of OCSP response */
l2n3(s->tlsext_ocsp_resplen, p);
/* actual response */
memcpy(p, s->tlsext_ocsp_resp, s->tlsext_ocsp_resplen);
/* number of bytes to write */
s->init_num = 8 + s->tlsext_ocsp_resplen;
s->state = SSL3_ST_SW_CERT_STATUS_B;
s->init_off = 0;
}
/* SSL3_ST_SW_CERT_STATUS_B */
return (ssl3_do_write(s, SSL3_RT_HANDSHAKE));
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,864
|
int ssl3_send_certificate_request(SSL *s)
{
unsigned char *p, *d;
int i, j, nl, off, n;
STACK_OF(X509_NAME) *sk = NULL;
X509_NAME *name;
BUF_MEM *buf;
if (s->state == SSL3_ST_SW_CERT_REQ_A) {
buf = s->init_buf;
d = p = ssl_handshake_start(s);
/* get the list of acceptable cert types */
p++;
n = ssl3_get_req_cert_type(s, p);
d[0] = n;
p += n;
n++;
if (SSL_USE_SIGALGS(s)) {
const unsigned char *psigs;
nl = tls12_get_psigalgs(s, &psigs);
s2n(nl, p);
memcpy(p, psigs, nl);
p += nl;
n += nl + 2;
}
off = n;
p += 2;
n += 2;
sk = SSL_get_client_CA_list(s);
nl = 0;
if (sk != NULL) {
for (i = 0; i < sk_X509_NAME_num(sk); i++) {
name = sk_X509_NAME_value(sk, i);
j = i2d_X509_NAME(name, NULL);
if (!BUF_MEM_grow_clean
(buf, SSL_HM_HEADER_LENGTH(s) + n + j + 2)) {
SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,
ERR_R_BUF_LIB);
goto err;
}
p = ssl_handshake_start(s) + n;
if (!(s->options & SSL_OP_NETSCAPE_CA_DN_BUG)) {
s2n(j, p);
i2d_X509_NAME(name, &p);
n += 2 + j;
nl += 2 + j;
} else {
d = p;
i2d_X509_NAME(name, &p);
j -= 2;
s2n(j, d);
j += 2;
n += j;
nl += j;
}
}
}
/* else no CA names */
p = ssl_handshake_start(s) + off;
s2n(nl, p);
ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_REQUEST, n);
#ifdef NETSCAPE_HANG_BUG
if (!SSL_IS_DTLS(s)) {
if (!BUF_MEM_grow_clean(buf, s->init_num + 4)) {
SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST, ERR_R_BUF_LIB);
goto err;
}
p = (unsigned char *)s->init_buf->data + s->init_num;
/* do the header */
*(p++) = SSL3_MT_SERVER_DONE;
*(p++) = 0;
*(p++) = 0;
*(p++) = 0;
s->init_num += 4;
}
#endif
s->state = SSL3_ST_SW_CERT_REQ_B;
}
/* SSL3_ST_SW_CERT_REQ_B */
return ssl_do_write(s);
err:
s->state = SSL_ST_ERR;
return (-1);
}
|
DoS
| 0
|
int ssl3_send_certificate_request(SSL *s)
{
unsigned char *p, *d;
int i, j, nl, off, n;
STACK_OF(X509_NAME) *sk = NULL;
X509_NAME *name;
BUF_MEM *buf;
if (s->state == SSL3_ST_SW_CERT_REQ_A) {
buf = s->init_buf;
d = p = ssl_handshake_start(s);
/* get the list of acceptable cert types */
p++;
n = ssl3_get_req_cert_type(s, p);
d[0] = n;
p += n;
n++;
if (SSL_USE_SIGALGS(s)) {
const unsigned char *psigs;
nl = tls12_get_psigalgs(s, &psigs);
s2n(nl, p);
memcpy(p, psigs, nl);
p += nl;
n += nl + 2;
}
off = n;
p += 2;
n += 2;
sk = SSL_get_client_CA_list(s);
nl = 0;
if (sk != NULL) {
for (i = 0; i < sk_X509_NAME_num(sk); i++) {
name = sk_X509_NAME_value(sk, i);
j = i2d_X509_NAME(name, NULL);
if (!BUF_MEM_grow_clean
(buf, SSL_HM_HEADER_LENGTH(s) + n + j + 2)) {
SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,
ERR_R_BUF_LIB);
goto err;
}
p = ssl_handshake_start(s) + n;
if (!(s->options & SSL_OP_NETSCAPE_CA_DN_BUG)) {
s2n(j, p);
i2d_X509_NAME(name, &p);
n += 2 + j;
nl += 2 + j;
} else {
d = p;
i2d_X509_NAME(name, &p);
j -= 2;
s2n(j, d);
j += 2;
n += j;
nl += j;
}
}
}
/* else no CA names */
p = ssl_handshake_start(s) + off;
s2n(nl, p);
ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_REQUEST, n);
#ifdef NETSCAPE_HANG_BUG
if (!SSL_IS_DTLS(s)) {
if (!BUF_MEM_grow_clean(buf, s->init_num + 4)) {
SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST, ERR_R_BUF_LIB);
goto err;
}
p = (unsigned char *)s->init_buf->data + s->init_num;
/* do the header */
*(p++) = SSL3_MT_SERVER_DONE;
*(p++) = 0;
*(p++) = 0;
*(p++) = 0;
s->init_num += 4;
}
#endif
s->state = SSL3_ST_SW_CERT_REQ_B;
}
/* SSL3_ST_SW_CERT_REQ_B */
return ssl_do_write(s);
err:
s->state = SSL_ST_ERR;
return (-1);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,865
|
int ssl3_send_hello_request(SSL *s)
{
if (s->state == SSL3_ST_SW_HELLO_REQ_A) {
ssl_set_handshake_header(s, SSL3_MT_HELLO_REQUEST, 0);
s->state = SSL3_ST_SW_HELLO_REQ_B;
}
/* SSL3_ST_SW_HELLO_REQ_B */
return ssl_do_write(s);
}
|
DoS
| 0
|
int ssl3_send_hello_request(SSL *s)
{
if (s->state == SSL3_ST_SW_HELLO_REQ_A) {
ssl_set_handshake_header(s, SSL3_MT_HELLO_REQUEST, 0);
s->state = SSL3_ST_SW_HELLO_REQ_B;
}
/* SSL3_ST_SW_HELLO_REQ_B */
return ssl_do_write(s);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,866
|
int ssl3_send_server_certificate(SSL *s)
{
CERT_PKEY *cpk;
if (s->state == SSL3_ST_SW_CERT_A) {
cpk = ssl_get_server_send_pkey(s);
if (cpk == NULL) {
/* VRS: allow null cert if auth == KRB5 */
if ((s->s3->tmp.new_cipher->algorithm_auth != SSL_aKRB5) ||
(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kKRB5)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,
ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return (0);
}
}
if (!ssl3_output_cert_chain(s, cpk)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return (0);
}
s->state = SSL3_ST_SW_CERT_B;
}
/* SSL3_ST_SW_CERT_B */
return ssl_do_write(s);
}
|
DoS
| 0
|
int ssl3_send_server_certificate(SSL *s)
{
CERT_PKEY *cpk;
if (s->state == SSL3_ST_SW_CERT_A) {
cpk = ssl_get_server_send_pkey(s);
if (cpk == NULL) {
/* VRS: allow null cert if auth == KRB5 */
if ((s->s3->tmp.new_cipher->algorithm_auth != SSL_aKRB5) ||
(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kKRB5)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,
ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return (0);
}
}
if (!ssl3_output_cert_chain(s, cpk)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return (0);
}
s->state = SSL3_ST_SW_CERT_B;
}
/* SSL3_ST_SW_CERT_B */
return ssl_do_write(s);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,867
|
int ssl3_send_server_done(SSL *s)
{
if (s->state == SSL3_ST_SW_SRVR_DONE_A) {
ssl_set_handshake_header(s, SSL3_MT_SERVER_DONE, 0);
s->state = SSL3_ST_SW_SRVR_DONE_B;
}
/* SSL3_ST_SW_SRVR_DONE_B */
return ssl_do_write(s);
}
|
DoS
| 0
|
int ssl3_send_server_done(SSL *s)
{
if (s->state == SSL3_ST_SW_SRVR_DONE_A) {
ssl_set_handshake_header(s, SSL3_MT_SERVER_DONE, 0);
s->state = SSL3_ST_SW_SRVR_DONE_B;
}
/* SSL3_ST_SW_SRVR_DONE_B */
return ssl_do_write(s);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,868
|
int ssl3_send_server_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p, *d;
int i, sl;
int al = 0;
unsigned long l;
if (s->state == SSL3_ST_SW_SRVR_HELLO_A) {
buf = (unsigned char *)s->init_buf->data;
#ifdef OPENSSL_NO_TLSEXT
p = s->s3->server_random;
if (ssl_fill_hello_random(s, 1, p, SSL3_RANDOM_SIZE) <= 0) {
s->state = SSL_ST_ERR;
return -1;
}
#endif
/* Do the message type and length last */
d = p = ssl_handshake_start(s);
*(p++) = s->version >> 8;
*(p++) = s->version & 0xff;
/* Random stuff */
memcpy(p, s->s3->server_random, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
/*-
* There are several cases for the session ID to send
* back in the server hello:
* - For session reuse from the session cache,
* we send back the old session ID.
* - If stateless session reuse (using a session ticket)
* is successful, we send back the client's "session ID"
* (which doesn't actually identify the session).
* - If it is a new session, we send back the new
* session ID.
* - However, if we want the new session to be single-use,
* we send back a 0-length session ID.
* s->hit is non-zero in either case of session reuse,
* so the following won't overwrite an ID that we're supposed
* to send back.
*/
if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
&& !s->hit)
s->session->session_id_length = 0;
sl = s->session->session_id_length;
if (sl > (int)sizeof(s->session->session_id)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return -1;
}
*(p++) = sl;
memcpy(p, s->session->session_id, sl);
p += sl;
/* put the cipher */
i = ssl3_put_cipher_by_char(s->s3->tmp.new_cipher, p);
p += i;
/* put the compression method */
#ifdef OPENSSL_NO_COMP
*(p++) = 0;
#else
if (s->s3->tmp.new_compression == NULL)
*(p++) = 0;
else
*(p++) = s->s3->tmp.new_compression->id;
#endif
#ifndef OPENSSL_NO_TLSEXT
if (ssl_prepare_serverhello_tlsext(s) <= 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, SSL_R_SERVERHELLO_TLSEXT);
s->state = SSL_ST_ERR;
return -1;
}
if ((p =
ssl_add_serverhello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH,
&al)) == NULL) {
ssl3_send_alert(s, SSL3_AL_FATAL, al);
SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return -1;
}
#endif
/* do the header */
l = (p - d);
ssl_set_handshake_header(s, SSL3_MT_SERVER_HELLO, l);
s->state = SSL3_ST_SW_SRVR_HELLO_B;
}
/* SSL3_ST_SW_SRVR_HELLO_B */
return ssl_do_write(s);
}
|
DoS
| 0
|
int ssl3_send_server_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p, *d;
int i, sl;
int al = 0;
unsigned long l;
if (s->state == SSL3_ST_SW_SRVR_HELLO_A) {
buf = (unsigned char *)s->init_buf->data;
#ifdef OPENSSL_NO_TLSEXT
p = s->s3->server_random;
if (ssl_fill_hello_random(s, 1, p, SSL3_RANDOM_SIZE) <= 0) {
s->state = SSL_ST_ERR;
return -1;
}
#endif
/* Do the message type and length last */
d = p = ssl_handshake_start(s);
*(p++) = s->version >> 8;
*(p++) = s->version & 0xff;
/* Random stuff */
memcpy(p, s->s3->server_random, SSL3_RANDOM_SIZE);
p += SSL3_RANDOM_SIZE;
/*-
* There are several cases for the session ID to send
* back in the server hello:
* - For session reuse from the session cache,
* we send back the old session ID.
* - If stateless session reuse (using a session ticket)
* is successful, we send back the client's "session ID"
* (which doesn't actually identify the session).
* - If it is a new session, we send back the new
* session ID.
* - However, if we want the new session to be single-use,
* we send back a 0-length session ID.
* s->hit is non-zero in either case of session reuse,
* so the following won't overwrite an ID that we're supposed
* to send back.
*/
if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
&& !s->hit)
s->session->session_id_length = 0;
sl = s->session->session_id_length;
if (sl > (int)sizeof(s->session->session_id)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return -1;
}
*(p++) = sl;
memcpy(p, s->session->session_id, sl);
p += sl;
/* put the cipher */
i = ssl3_put_cipher_by_char(s->s3->tmp.new_cipher, p);
p += i;
/* put the compression method */
#ifdef OPENSSL_NO_COMP
*(p++) = 0;
#else
if (s->s3->tmp.new_compression == NULL)
*(p++) = 0;
else
*(p++) = s->s3->tmp.new_compression->id;
#endif
#ifndef OPENSSL_NO_TLSEXT
if (ssl_prepare_serverhello_tlsext(s) <= 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, SSL_R_SERVERHELLO_TLSEXT);
s->state = SSL_ST_ERR;
return -1;
}
if ((p =
ssl_add_serverhello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH,
&al)) == NULL) {
ssl3_send_alert(s, SSL3_AL_FATAL, al);
SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
s->state = SSL_ST_ERR;
return -1;
}
#endif
/* do the header */
l = (p - d);
ssl_set_handshake_header(s, SSL3_MT_SERVER_HELLO, l);
s->state = SSL3_ST_SW_SRVR_HELLO_B;
}
/* SSL3_ST_SW_SRVR_HELLO_B */
return ssl_do_write(s);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,869
|
int ssl3_send_server_key_exchange(SSL *s)
{
#ifndef OPENSSL_NO_RSA
unsigned char *q;
int j, num;
RSA *rsa;
unsigned char md_buf[MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH];
unsigned int u;
#endif
#ifndef OPENSSL_NO_DH
DH *dh = NULL, *dhp;
#endif
#ifndef OPENSSL_NO_ECDH
EC_KEY *ecdh = NULL, *ecdhp;
unsigned char *encodedPoint = NULL;
int encodedlen = 0;
int curve_id = 0;
BN_CTX *bn_ctx = NULL;
#endif
EVP_PKEY *pkey;
const EVP_MD *md = NULL;
unsigned char *p, *d;
int al, i;
unsigned long type;
int n;
CERT *cert;
BIGNUM *r[4];
int nr[4], kn;
BUF_MEM *buf;
EVP_MD_CTX md_ctx;
EVP_MD_CTX_init(&md_ctx);
if (s->state == SSL3_ST_SW_KEY_EXCH_A) {
type = s->s3->tmp.new_cipher->algorithm_mkey;
cert = s->cert;
buf = s->init_buf;
r[0] = r[1] = r[2] = r[3] = NULL;
n = 0;
#ifndef OPENSSL_NO_RSA
if (type & SSL_kRSA) {
rsa = cert->rsa_tmp;
if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL)) {
rsa = s->cert->rsa_tmp_cb(s,
SSL_C_IS_EXPORT(s->s3->
tmp.new_cipher),
SSL_C_EXPORT_PKEYLENGTH(s->s3->
tmp.new_cipher));
if (rsa == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_ERROR_GENERATING_TMP_RSA_KEY);
goto f_err;
}
RSA_up_ref(rsa);
cert->rsa_tmp = rsa;
}
if (rsa == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_TMP_RSA_KEY);
goto f_err;
}
r[0] = rsa->n;
r[1] = rsa->e;
s->s3->tmp.use_rsa_tmp = 1;
} else
#endif
#ifndef OPENSSL_NO_DH
if (type & SSL_kEDH) {
dhp = cert->dh_tmp;
if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL))
dhp = s->cert->dh_tmp_cb(s,
SSL_C_IS_EXPORT(s->s3->
tmp.new_cipher),
SSL_C_EXPORT_PKEYLENGTH(s->s3->
tmp.new_cipher));
if (dhp == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_TMP_DH_KEY);
goto f_err;
}
if (s->s3->tmp.dh != NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_INTERNAL_ERROR);
goto err;
}
if ((dh = DHparams_dup(dhp)) == NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
goto err;
}
s->s3->tmp.dh = dh;
if ((dhp->pub_key == NULL ||
dhp->priv_key == NULL ||
(s->options & SSL_OP_SINGLE_DH_USE))) {
if (!DH_generate_key(dh)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
goto err;
}
} else {
dh->pub_key = BN_dup(dhp->pub_key);
dh->priv_key = BN_dup(dhp->priv_key);
if ((dh->pub_key == NULL) || (dh->priv_key == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
goto err;
}
}
r[0] = dh->p;
r[1] = dh->g;
r[2] = dh->pub_key;
} else
#endif
#ifndef OPENSSL_NO_ECDH
if (type & SSL_kEECDH) {
const EC_GROUP *group;
ecdhp = cert->ecdh_tmp;
if (s->cert->ecdh_tmp_auto) {
/* Get NID of appropriate shared curve */
int nid = tls1_shared_curve(s, -2);
if (nid != NID_undef)
ecdhp = EC_KEY_new_by_curve_name(nid);
} else if ((ecdhp == NULL) && s->cert->ecdh_tmp_cb) {
ecdhp = s->cert->ecdh_tmp_cb(s,
SSL_C_IS_EXPORT(s->s3->
tmp.new_cipher),
SSL_C_EXPORT_PKEYLENGTH(s->
s3->tmp.new_cipher));
}
if (ecdhp == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_TMP_ECDH_KEY);
goto f_err;
}
if (s->s3->tmp.ecdh != NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_INTERNAL_ERROR);
goto err;
}
/* Duplicate the ECDH structure. */
if (ecdhp == NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
if (s->cert->ecdh_tmp_auto)
ecdh = ecdhp;
else if ((ecdh = EC_KEY_dup(ecdhp)) == NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
s->s3->tmp.ecdh = ecdh;
if ((EC_KEY_get0_public_key(ecdh) == NULL) ||
(EC_KEY_get0_private_key(ecdh) == NULL) ||
(s->options & SSL_OP_SINGLE_ECDH_USE)) {
if (!EC_KEY_generate_key(ecdh)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_ECDH_LIB);
goto err;
}
}
if (((group = EC_KEY_get0_group(ecdh)) == NULL) ||
(EC_KEY_get0_public_key(ecdh) == NULL) ||
(EC_KEY_get0_private_key(ecdh) == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
(EC_GROUP_get_degree(group) > 163)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
goto err;
}
/*
* XXX: For now, we only support ephemeral ECDH keys over named
* (not generic) curves. For supported named curves, curve_id is
* non-zero.
*/
if ((curve_id =
tls1_ec_nid2curve_id(EC_GROUP_get_curve_name(group)))
== 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
goto err;
}
/*
* Encode the public key. First check the size of encoding and
* allocate memory accordingly.
*/
encodedlen = EC_POINT_point2oct(group,
EC_KEY_get0_public_key(ecdh),
POINT_CONVERSION_UNCOMPRESSED,
NULL, 0, NULL);
encodedPoint = (unsigned char *)
OPENSSL_malloc(encodedlen * sizeof(unsigned char));
bn_ctx = BN_CTX_new();
if ((encodedPoint == NULL) || (bn_ctx == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_MALLOC_FAILURE);
goto err;
}
encodedlen = EC_POINT_point2oct(group,
EC_KEY_get0_public_key(ecdh),
POINT_CONVERSION_UNCOMPRESSED,
encodedPoint, encodedlen, bn_ctx);
if (encodedlen == 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
BN_CTX_free(bn_ctx);
bn_ctx = NULL;
/*
* XXX: For now, we only support named (not generic) curves in
* ECDH ephemeral key exchanges. In this situation, we need four
* additional bytes to encode the entire ServerECDHParams
* structure.
*/
n = 4 + encodedlen;
/*
* We'll generate the serverKeyExchange message explicitly so we
* can set these to NULLs
*/
r[0] = NULL;
r[1] = NULL;
r[2] = NULL;
r[3] = NULL;
} else
#endif /* !OPENSSL_NO_ECDH */
#ifndef OPENSSL_NO_PSK
if (type & SSL_kPSK) {
/*
* reserve size for record length and PSK identity hint
*/
n += 2 + strlen(s->ctx->psk_identity_hint);
} else
#endif /* !OPENSSL_NO_PSK */
#ifndef OPENSSL_NO_SRP
if (type & SSL_kSRP) {
if ((s->srp_ctx.N == NULL) ||
(s->srp_ctx.g == NULL) ||
(s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_SRP_PARAM);
goto err;
}
r[0] = s->srp_ctx.N;
r[1] = s->srp_ctx.g;
r[2] = s->srp_ctx.s;
r[3] = s->srp_ctx.B;
} else
#endif
{
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
goto f_err;
}
for (i = 0; i < 4 && r[i] != NULL; i++) {
nr[i] = BN_num_bytes(r[i]);
#ifndef OPENSSL_NO_SRP
if ((i == 2) && (type & SSL_kSRP))
n += 1 + nr[i];
else
#endif
n += 2 + nr[i];
}
if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
&& !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
if ((pkey = ssl_get_sign_pkey(s, s->s3->tmp.new_cipher, &md))
== NULL) {
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
kn = EVP_PKEY_size(pkey);
} else {
pkey = NULL;
kn = 0;
}
if (!BUF_MEM_grow_clean(buf, n + SSL_HM_HEADER_LENGTH(s) + kn)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_LIB_BUF);
goto err;
}
d = p = ssl_handshake_start(s);
for (i = 0; i < 4 && r[i] != NULL; i++) {
#ifndef OPENSSL_NO_SRP
if ((i == 2) && (type & SSL_kSRP)) {
*p = nr[i];
p++;
} else
#endif
s2n(nr[i], p);
BN_bn2bin(r[i], p);
p += nr[i];
}
#ifndef OPENSSL_NO_ECDH
if (type & SSL_kEECDH) {
/*
* XXX: For now, we only support named (not generic) curves. In
* this situation, the serverKeyExchange message has: [1 byte
* CurveType], [2 byte CurveName] [1 byte length of encoded
* point], followed by the actual encoded point itself
*/
*p = NAMED_CURVE_TYPE;
p += 1;
*p = 0;
p += 1;
*p = curve_id;
p += 1;
*p = encodedlen;
p += 1;
memcpy((unsigned char *)p,
(unsigned char *)encodedPoint, encodedlen);
OPENSSL_free(encodedPoint);
encodedPoint = NULL;
p += encodedlen;
}
#endif
#ifndef OPENSSL_NO_PSK
if (type & SSL_kPSK) {
/* copy PSK identity hint */
s2n(strlen(s->ctx->psk_identity_hint), p);
strncpy((char *)p, s->ctx->psk_identity_hint,
strlen(s->ctx->psk_identity_hint));
p += strlen(s->ctx->psk_identity_hint);
}
#endif
/* not anonymous */
if (pkey != NULL) {
/*
* n is the length of the params, they start at &(d[4]) and p
* points to the space at the end.
*/
#ifndef OPENSSL_NO_RSA
if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s)) {
q = md_buf;
j = 0;
for (num = 2; num > 0; num--) {
EVP_MD_CTX_set_flags(&md_ctx,
EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
EVP_DigestInit_ex(&md_ctx, (num == 2)
? s->ctx->md5 : s->ctx->sha1, NULL);
EVP_DigestUpdate(&md_ctx, &(s->s3->client_random[0]),
SSL3_RANDOM_SIZE);
EVP_DigestUpdate(&md_ctx, &(s->s3->server_random[0]),
SSL3_RANDOM_SIZE);
EVP_DigestUpdate(&md_ctx, d, n);
EVP_DigestFinal_ex(&md_ctx, q, (unsigned int *)&i);
q += i;
j += i;
}
if (RSA_sign(NID_md5_sha1, md_buf, j,
&(p[2]), &u, pkey->pkey.rsa) <= 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_LIB_RSA);
goto err;
}
s2n(u, p);
n += u + 2;
} else
#endif
if (md) {
/* send signature algorithm */
if (SSL_USE_SIGALGS(s)) {
if (!tls12_get_sigandhash(p, pkey, md)) {
/* Should never happen */
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_INTERNAL_ERROR);
goto f_err;
}
p += 2;
}
#ifdef SSL_DEBUG
fprintf(stderr, "Using hash %s\n", EVP_MD_name(md));
#endif
EVP_SignInit_ex(&md_ctx, md, NULL);
EVP_SignUpdate(&md_ctx, &(s->s3->client_random[0]),
SSL3_RANDOM_SIZE);
EVP_SignUpdate(&md_ctx, &(s->s3->server_random[0]),
SSL3_RANDOM_SIZE);
EVP_SignUpdate(&md_ctx, d, n);
if (!EVP_SignFinal(&md_ctx, &(p[2]),
(unsigned int *)&i, pkey)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_LIB_EVP);
goto err;
}
s2n(i, p);
n += i + 2;
if (SSL_USE_SIGALGS(s))
n += 2;
} else {
/* Is this error check actually needed? */
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_UNKNOWN_PKEY_TYPE);
goto f_err;
}
}
ssl_set_handshake_header(s, SSL3_MT_SERVER_KEY_EXCHANGE, n);
}
s->state = SSL3_ST_SW_KEY_EXCH_B;
EVP_MD_CTX_cleanup(&md_ctx);
return ssl_do_write(s);
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
#ifndef OPENSSL_NO_ECDH
if (encodedPoint != NULL)
OPENSSL_free(encodedPoint);
BN_CTX_free(bn_ctx);
#endif
EVP_MD_CTX_cleanup(&md_ctx);
s->state = SSL_ST_ERR;
return (-1);
}
|
DoS
| 0
|
int ssl3_send_server_key_exchange(SSL *s)
{
#ifndef OPENSSL_NO_RSA
unsigned char *q;
int j, num;
RSA *rsa;
unsigned char md_buf[MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH];
unsigned int u;
#endif
#ifndef OPENSSL_NO_DH
DH *dh = NULL, *dhp;
#endif
#ifndef OPENSSL_NO_ECDH
EC_KEY *ecdh = NULL, *ecdhp;
unsigned char *encodedPoint = NULL;
int encodedlen = 0;
int curve_id = 0;
BN_CTX *bn_ctx = NULL;
#endif
EVP_PKEY *pkey;
const EVP_MD *md = NULL;
unsigned char *p, *d;
int al, i;
unsigned long type;
int n;
CERT *cert;
BIGNUM *r[4];
int nr[4], kn;
BUF_MEM *buf;
EVP_MD_CTX md_ctx;
EVP_MD_CTX_init(&md_ctx);
if (s->state == SSL3_ST_SW_KEY_EXCH_A) {
type = s->s3->tmp.new_cipher->algorithm_mkey;
cert = s->cert;
buf = s->init_buf;
r[0] = r[1] = r[2] = r[3] = NULL;
n = 0;
#ifndef OPENSSL_NO_RSA
if (type & SSL_kRSA) {
rsa = cert->rsa_tmp;
if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL)) {
rsa = s->cert->rsa_tmp_cb(s,
SSL_C_IS_EXPORT(s->s3->
tmp.new_cipher),
SSL_C_EXPORT_PKEYLENGTH(s->s3->
tmp.new_cipher));
if (rsa == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_ERROR_GENERATING_TMP_RSA_KEY);
goto f_err;
}
RSA_up_ref(rsa);
cert->rsa_tmp = rsa;
}
if (rsa == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_TMP_RSA_KEY);
goto f_err;
}
r[0] = rsa->n;
r[1] = rsa->e;
s->s3->tmp.use_rsa_tmp = 1;
} else
#endif
#ifndef OPENSSL_NO_DH
if (type & SSL_kEDH) {
dhp = cert->dh_tmp;
if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL))
dhp = s->cert->dh_tmp_cb(s,
SSL_C_IS_EXPORT(s->s3->
tmp.new_cipher),
SSL_C_EXPORT_PKEYLENGTH(s->s3->
tmp.new_cipher));
if (dhp == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_TMP_DH_KEY);
goto f_err;
}
if (s->s3->tmp.dh != NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_INTERNAL_ERROR);
goto err;
}
if ((dh = DHparams_dup(dhp)) == NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
goto err;
}
s->s3->tmp.dh = dh;
if ((dhp->pub_key == NULL ||
dhp->priv_key == NULL ||
(s->options & SSL_OP_SINGLE_DH_USE))) {
if (!DH_generate_key(dh)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
goto err;
}
} else {
dh->pub_key = BN_dup(dhp->pub_key);
dh->priv_key = BN_dup(dhp->priv_key);
if ((dh->pub_key == NULL) || (dh->priv_key == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
goto err;
}
}
r[0] = dh->p;
r[1] = dh->g;
r[2] = dh->pub_key;
} else
#endif
#ifndef OPENSSL_NO_ECDH
if (type & SSL_kEECDH) {
const EC_GROUP *group;
ecdhp = cert->ecdh_tmp;
if (s->cert->ecdh_tmp_auto) {
/* Get NID of appropriate shared curve */
int nid = tls1_shared_curve(s, -2);
if (nid != NID_undef)
ecdhp = EC_KEY_new_by_curve_name(nid);
} else if ((ecdhp == NULL) && s->cert->ecdh_tmp_cb) {
ecdhp = s->cert->ecdh_tmp_cb(s,
SSL_C_IS_EXPORT(s->s3->
tmp.new_cipher),
SSL_C_EXPORT_PKEYLENGTH(s->
s3->tmp.new_cipher));
}
if (ecdhp == NULL) {
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_TMP_ECDH_KEY);
goto f_err;
}
if (s->s3->tmp.ecdh != NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_INTERNAL_ERROR);
goto err;
}
/* Duplicate the ECDH structure. */
if (ecdhp == NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
if (s->cert->ecdh_tmp_auto)
ecdh = ecdhp;
else if ((ecdh = EC_KEY_dup(ecdhp)) == NULL) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
s->s3->tmp.ecdh = ecdh;
if ((EC_KEY_get0_public_key(ecdh) == NULL) ||
(EC_KEY_get0_private_key(ecdh) == NULL) ||
(s->options & SSL_OP_SINGLE_ECDH_USE)) {
if (!EC_KEY_generate_key(ecdh)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_ECDH_LIB);
goto err;
}
}
if (((group = EC_KEY_get0_group(ecdh)) == NULL) ||
(EC_KEY_get0_public_key(ecdh) == NULL) ||
(EC_KEY_get0_private_key(ecdh) == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
(EC_GROUP_get_degree(group) > 163)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
goto err;
}
/*
* XXX: For now, we only support ephemeral ECDH keys over named
* (not generic) curves. For supported named curves, curve_id is
* non-zero.
*/
if ((curve_id =
tls1_ec_nid2curve_id(EC_GROUP_get_curve_name(group)))
== 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
goto err;
}
/*
* Encode the public key. First check the size of encoding and
* allocate memory accordingly.
*/
encodedlen = EC_POINT_point2oct(group,
EC_KEY_get0_public_key(ecdh),
POINT_CONVERSION_UNCOMPRESSED,
NULL, 0, NULL);
encodedPoint = (unsigned char *)
OPENSSL_malloc(encodedlen * sizeof(unsigned char));
bn_ctx = BN_CTX_new();
if ((encodedPoint == NULL) || (bn_ctx == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_MALLOC_FAILURE);
goto err;
}
encodedlen = EC_POINT_point2oct(group,
EC_KEY_get0_public_key(ecdh),
POINT_CONVERSION_UNCOMPRESSED,
encodedPoint, encodedlen, bn_ctx);
if (encodedlen == 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
goto err;
}
BN_CTX_free(bn_ctx);
bn_ctx = NULL;
/*
* XXX: For now, we only support named (not generic) curves in
* ECDH ephemeral key exchanges. In this situation, we need four
* additional bytes to encode the entire ServerECDHParams
* structure.
*/
n = 4 + encodedlen;
/*
* We'll generate the serverKeyExchange message explicitly so we
* can set these to NULLs
*/
r[0] = NULL;
r[1] = NULL;
r[2] = NULL;
r[3] = NULL;
} else
#endif /* !OPENSSL_NO_ECDH */
#ifndef OPENSSL_NO_PSK
if (type & SSL_kPSK) {
/*
* reserve size for record length and PSK identity hint
*/
n += 2 + strlen(s->ctx->psk_identity_hint);
} else
#endif /* !OPENSSL_NO_PSK */
#ifndef OPENSSL_NO_SRP
if (type & SSL_kSRP) {
if ((s->srp_ctx.N == NULL) ||
(s->srp_ctx.g == NULL) ||
(s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_MISSING_SRP_PARAM);
goto err;
}
r[0] = s->srp_ctx.N;
r[1] = s->srp_ctx.g;
r[2] = s->srp_ctx.s;
r[3] = s->srp_ctx.B;
} else
#endif
{
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
goto f_err;
}
for (i = 0; i < 4 && r[i] != NULL; i++) {
nr[i] = BN_num_bytes(r[i]);
#ifndef OPENSSL_NO_SRP
if ((i == 2) && (type & SSL_kSRP))
n += 1 + nr[i];
else
#endif
n += 2 + nr[i];
}
if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
&& !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
if ((pkey = ssl_get_sign_pkey(s, s->s3->tmp.new_cipher, &md))
== NULL) {
al = SSL_AD_DECODE_ERROR;
goto f_err;
}
kn = EVP_PKEY_size(pkey);
} else {
pkey = NULL;
kn = 0;
}
if (!BUF_MEM_grow_clean(buf, n + SSL_HM_HEADER_LENGTH(s) + kn)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_LIB_BUF);
goto err;
}
d = p = ssl_handshake_start(s);
for (i = 0; i < 4 && r[i] != NULL; i++) {
#ifndef OPENSSL_NO_SRP
if ((i == 2) && (type & SSL_kSRP)) {
*p = nr[i];
p++;
} else
#endif
s2n(nr[i], p);
BN_bn2bin(r[i], p);
p += nr[i];
}
#ifndef OPENSSL_NO_ECDH
if (type & SSL_kEECDH) {
/*
* XXX: For now, we only support named (not generic) curves. In
* this situation, the serverKeyExchange message has: [1 byte
* CurveType], [2 byte CurveName] [1 byte length of encoded
* point], followed by the actual encoded point itself
*/
*p = NAMED_CURVE_TYPE;
p += 1;
*p = 0;
p += 1;
*p = curve_id;
p += 1;
*p = encodedlen;
p += 1;
memcpy((unsigned char *)p,
(unsigned char *)encodedPoint, encodedlen);
OPENSSL_free(encodedPoint);
encodedPoint = NULL;
p += encodedlen;
}
#endif
#ifndef OPENSSL_NO_PSK
if (type & SSL_kPSK) {
/* copy PSK identity hint */
s2n(strlen(s->ctx->psk_identity_hint), p);
strncpy((char *)p, s->ctx->psk_identity_hint,
strlen(s->ctx->psk_identity_hint));
p += strlen(s->ctx->psk_identity_hint);
}
#endif
/* not anonymous */
if (pkey != NULL) {
/*
* n is the length of the params, they start at &(d[4]) and p
* points to the space at the end.
*/
#ifndef OPENSSL_NO_RSA
if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s)) {
q = md_buf;
j = 0;
for (num = 2; num > 0; num--) {
EVP_MD_CTX_set_flags(&md_ctx,
EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
EVP_DigestInit_ex(&md_ctx, (num == 2)
? s->ctx->md5 : s->ctx->sha1, NULL);
EVP_DigestUpdate(&md_ctx, &(s->s3->client_random[0]),
SSL3_RANDOM_SIZE);
EVP_DigestUpdate(&md_ctx, &(s->s3->server_random[0]),
SSL3_RANDOM_SIZE);
EVP_DigestUpdate(&md_ctx, d, n);
EVP_DigestFinal_ex(&md_ctx, q, (unsigned int *)&i);
q += i;
j += i;
}
if (RSA_sign(NID_md5_sha1, md_buf, j,
&(p[2]), &u, pkey->pkey.rsa) <= 0) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_LIB_RSA);
goto err;
}
s2n(u, p);
n += u + 2;
} else
#endif
if (md) {
/* send signature algorithm */
if (SSL_USE_SIGALGS(s)) {
if (!tls12_get_sigandhash(p, pkey, md)) {
/* Should never happen */
al = SSL_AD_INTERNAL_ERROR;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
ERR_R_INTERNAL_ERROR);
goto f_err;
}
p += 2;
}
#ifdef SSL_DEBUG
fprintf(stderr, "Using hash %s\n", EVP_MD_name(md));
#endif
EVP_SignInit_ex(&md_ctx, md, NULL);
EVP_SignUpdate(&md_ctx, &(s->s3->client_random[0]),
SSL3_RANDOM_SIZE);
EVP_SignUpdate(&md_ctx, &(s->s3->server_random[0]),
SSL3_RANDOM_SIZE);
EVP_SignUpdate(&md_ctx, d, n);
if (!EVP_SignFinal(&md_ctx, &(p[2]),
(unsigned int *)&i, pkey)) {
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_LIB_EVP);
goto err;
}
s2n(i, p);
n += i + 2;
if (SSL_USE_SIGALGS(s))
n += 2;
} else {
/* Is this error check actually needed? */
al = SSL_AD_HANDSHAKE_FAILURE;
SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
SSL_R_UNKNOWN_PKEY_TYPE);
goto f_err;
}
}
ssl_set_handshake_header(s, SSL3_MT_SERVER_KEY_EXCHANGE, n);
}
s->state = SSL3_ST_SW_KEY_EXCH_B;
EVP_MD_CTX_cleanup(&md_ctx);
return ssl_do_write(s);
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
err:
#ifndef OPENSSL_NO_ECDH
if (encodedPoint != NULL)
OPENSSL_free(encodedPoint);
BN_CTX_free(bn_ctx);
#endif
EVP_MD_CTX_cleanup(&md_ctx);
s->state = SSL_ST_ERR;
return (-1);
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,870
|
static int ssl_check_srp_ext_ClientHello(SSL *s, int *al)
{
int ret = SSL_ERROR_NONE;
*al = SSL_AD_UNRECOGNIZED_NAME;
if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
(s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
if (s->srp_ctx.login == NULL) {
/*
* RFC 5054 says SHOULD reject, we do so if There is no srp
* login name
*/
ret = SSL3_AL_FATAL;
*al = SSL_AD_UNKNOWN_PSK_IDENTITY;
} else {
ret = SSL_srp_server_param_with_username(s, al);
}
}
return ret;
}
|
DoS
| 0
|
static int ssl_check_srp_ext_ClientHello(SSL *s, int *al)
{
int ret = SSL_ERROR_NONE;
*al = SSL_AD_UNRECOGNIZED_NAME;
if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
(s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
if (s->srp_ctx.login == NULL) {
/*
* RFC 5054 says SHOULD reject, we do so if There is no srp
* login name
*/
ret = SSL3_AL_FATAL;
*al = SSL_AD_UNKNOWN_PSK_IDENTITY;
} else {
ret = SSL_srp_server_param_with_username(s, al);
}
}
return ret;
}
|
@@ -2780,7 +2780,7 @@ int ssl3_get_client_key_exchange(SSL *s)
if (s->session->psk_identity != NULL)
OPENSSL_free(s->session->psk_identity);
- s->session->psk_identity = BUF_strdup((char *)p);
+ s->session->psk_identity = BUF_strndup((char *)p, i);
if (s->session->psk_identity == NULL) {
SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
goto psk_err;
|
CWE-362
| null | null |
2,871
|
unsigned long ASN1_tag2bit(int tag)
{
if ((tag < 0) || (tag > 30))
return 0;
return tag2bit[tag];
}
|
+Info
| 0
|
unsigned long ASN1_tag2bit(int tag)
{
if ((tag < 0) || (tag > 30))
return 0;
return tag2bit[tag];
}
|
@@ -180,6 +180,8 @@ int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
int otag;
int ret = 0;
ASN1_VALUE **pchptr, *ptmpval;
+ int combine = aclass & ASN1_TFLG_COMBINE;
+ aclass &= ~ASN1_TFLG_COMBINE;
if (!pval)
return 0;
if (aux && aux->asn1_cb)
@@ -500,7 +502,8 @@ int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
auxerr:
ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_AUX_ERROR);
err:
- ASN1_item_ex_free(pval, it);
+ if (combine == 0)
+ ASN1_item_ex_free(pval, it);
if (errtt)
ERR_add_error_data(4, "Field=", errtt->field_name,
", Type=", it->sname);
@@ -689,7 +692,7 @@ static int asn1_template_noexp_d2i(ASN1_VALUE **val,
} else {
/* Nothing special */
ret = ASN1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item),
- -1, 0, opt, ctx);
+ -1, tt->flags & ASN1_TFLG_COMBINE, opt, ctx);
if (!ret) {
ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
goto err;
|
CWE-200
| null | null |
2,872
|
int ASN1_template_d2i(ASN1_VALUE **pval,
const unsigned char **in, long len,
const ASN1_TEMPLATE *tt)
{
ASN1_TLC c;
asn1_tlc_clear_nc(&c);
return asn1_template_ex_d2i(pval, in, len, tt, 0, &c);
}
|
+Info
| 0
|
int ASN1_template_d2i(ASN1_VALUE **pval,
const unsigned char **in, long len,
const ASN1_TEMPLATE *tt)
{
ASN1_TLC c;
asn1_tlc_clear_nc(&c);
return asn1_template_ex_d2i(pval, in, len, tt, 0, &c);
}
|
@@ -180,6 +180,8 @@ int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
int otag;
int ret = 0;
ASN1_VALUE **pchptr, *ptmpval;
+ int combine = aclass & ASN1_TFLG_COMBINE;
+ aclass &= ~ASN1_TFLG_COMBINE;
if (!pval)
return 0;
if (aux && aux->asn1_cb)
@@ -500,7 +502,8 @@ int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
auxerr:
ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_AUX_ERROR);
err:
- ASN1_item_ex_free(pval, it);
+ if (combine == 0)
+ ASN1_item_ex_free(pval, it);
if (errtt)
ERR_add_error_data(4, "Field=", errtt->field_name,
", Type=", it->sname);
@@ -689,7 +692,7 @@ static int asn1_template_noexp_d2i(ASN1_VALUE **val,
} else {
/* Nothing special */
ret = ASN1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item),
- -1, 0, opt, ctx);
+ -1, tt->flags & ASN1_TFLG_COMBINE, opt, ctx);
if (!ret) {
ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, ERR_R_NESTED_ASN1_ERROR);
goto err;
|
CWE-200
| null | null |
2,873
|
static int do_rsa_print(BIO *bp, const RSA *x, int off, int priv)
{
char *str;
const char *s;
unsigned char *m = NULL;
int ret = 0, mod_len = 0;
size_t buf_len = 0;
update_buflen(x->n, &buf_len);
update_buflen(x->e, &buf_len);
if (priv) {
update_buflen(x->d, &buf_len);
update_buflen(x->p, &buf_len);
update_buflen(x->q, &buf_len);
update_buflen(x->dmp1, &buf_len);
update_buflen(x->dmq1, &buf_len);
update_buflen(x->iqmp, &buf_len);
}
m = (unsigned char *)OPENSSL_malloc(buf_len + 10);
if (m == NULL) {
RSAerr(RSA_F_DO_RSA_PRINT, ERR_R_MALLOC_FAILURE);
goto err;
}
if (x->n != NULL)
mod_len = BN_num_bits(x->n);
if (!BIO_indent(bp, off, 128))
goto err;
if (priv && x->d) {
if (BIO_printf(bp, "Private-Key: (%d bit)\n", mod_len)
<= 0)
goto err;
str = "modulus:";
s = "publicExponent:";
} else {
if (BIO_printf(bp, "Public-Key: (%d bit)\n", mod_len)
<= 0)
goto err;
str = "Modulus:";
s = "Exponent:";
}
if (!ASN1_bn_print(bp, str, x->n, m, off))
goto err;
if (!ASN1_bn_print(bp, s, x->e, m, off))
goto err;
if (priv) {
if (!ASN1_bn_print(bp, "privateExponent:", x->d, m, off))
goto err;
if (!ASN1_bn_print(bp, "prime1:", x->p, m, off))
goto err;
if (!ASN1_bn_print(bp, "prime2:", x->q, m, off))
goto err;
if (!ASN1_bn_print(bp, "exponent1:", x->dmp1, m, off))
goto err;
if (!ASN1_bn_print(bp, "exponent2:", x->dmq1, m, off))
goto err;
if (!ASN1_bn_print(bp, "coefficient:", x->iqmp, m, off))
goto err;
}
ret = 1;
err:
if (m != NULL)
OPENSSL_free(m);
return (ret);
}
|
DoS
| 0
|
static int do_rsa_print(BIO *bp, const RSA *x, int off, int priv)
{
char *str;
const char *s;
unsigned char *m = NULL;
int ret = 0, mod_len = 0;
size_t buf_len = 0;
update_buflen(x->n, &buf_len);
update_buflen(x->e, &buf_len);
if (priv) {
update_buflen(x->d, &buf_len);
update_buflen(x->p, &buf_len);
update_buflen(x->q, &buf_len);
update_buflen(x->dmp1, &buf_len);
update_buflen(x->dmq1, &buf_len);
update_buflen(x->iqmp, &buf_len);
}
m = (unsigned char *)OPENSSL_malloc(buf_len + 10);
if (m == NULL) {
RSAerr(RSA_F_DO_RSA_PRINT, ERR_R_MALLOC_FAILURE);
goto err;
}
if (x->n != NULL)
mod_len = BN_num_bits(x->n);
if (!BIO_indent(bp, off, 128))
goto err;
if (priv && x->d) {
if (BIO_printf(bp, "Private-Key: (%d bit)\n", mod_len)
<= 0)
goto err;
str = "modulus:";
s = "publicExponent:";
} else {
if (BIO_printf(bp, "Public-Key: (%d bit)\n", mod_len)
<= 0)
goto err;
str = "Modulus:";
s = "Exponent:";
}
if (!ASN1_bn_print(bp, str, x->n, m, off))
goto err;
if (!ASN1_bn_print(bp, s, x->e, m, off))
goto err;
if (priv) {
if (!ASN1_bn_print(bp, "privateExponent:", x->d, m, off))
goto err;
if (!ASN1_bn_print(bp, "prime1:", x->p, m, off))
goto err;
if (!ASN1_bn_print(bp, "prime2:", x->q, m, off))
goto err;
if (!ASN1_bn_print(bp, "exponent1:", x->dmp1, m, off))
goto err;
if (!ASN1_bn_print(bp, "exponent2:", x->dmq1, m, off))
goto err;
if (!ASN1_bn_print(bp, "coefficient:", x->iqmp, m, off))
goto err;
}
ret = 1;
err:
if (m != NULL)
OPENSSL_free(m);
return (ret);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,874
|
static void int_rsa_free(EVP_PKEY *pkey)
{
RSA_free(pkey->pkey.rsa);
}
|
DoS
| 0
|
static void int_rsa_free(EVP_PKEY *pkey)
{
RSA_free(pkey->pkey.rsa);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,875
|
static int int_rsa_size(const EVP_PKEY *pkey)
{
return RSA_size(pkey->pkey.rsa);
}
|
DoS
| 0
|
static int int_rsa_size(const EVP_PKEY *pkey)
{
return RSA_size(pkey->pkey.rsa);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,876
|
static int old_rsa_priv_decode(EVP_PKEY *pkey,
const unsigned char **pder, int derlen)
{
RSA *rsa;
if (!(rsa = d2i_RSAPrivateKey(NULL, pder, derlen))) {
RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
return 0;
}
EVP_PKEY_assign_RSA(pkey, rsa);
return 1;
}
|
DoS
| 0
|
static int old_rsa_priv_decode(EVP_PKEY *pkey,
const unsigned char **pder, int derlen)
{
RSA *rsa;
if (!(rsa = d2i_RSAPrivateKey(NULL, pder, derlen))) {
RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
return 0;
}
EVP_PKEY_assign_RSA(pkey, rsa);
return 1;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,877
|
static int old_rsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
{
return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
}
|
DoS
| 0
|
static int old_rsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
{
return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,878
|
static int rsa_bits(const EVP_PKEY *pkey)
{
return BN_num_bits(pkey->pkey.rsa->n);
}
|
DoS
| 0
|
static int rsa_bits(const EVP_PKEY *pkey)
{
return BN_num_bits(pkey->pkey.rsa->n);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,879
|
static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
X509_ALGOR *alg1, X509_ALGOR *alg2,
ASN1_BIT_STRING *sig)
{
int pad_mode;
EVP_PKEY_CTX *pkctx = ctx->pctx;
if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
return 0;
if (pad_mode == RSA_PKCS1_PADDING)
return 2;
if (pad_mode == RSA_PKCS1_PSS_PADDING) {
const EVP_MD *sigmd, *mgf1md;
RSA_PSS_PARAMS *pss = NULL;
X509_ALGOR *mgf1alg = NULL;
ASN1_STRING *os1 = NULL, *os2 = NULL;
EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
int saltlen, rv = 0;
sigmd = EVP_MD_CTX_md(ctx);
if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
goto err;
if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
goto err;
if (saltlen == -1)
saltlen = EVP_MD_size(sigmd);
else if (saltlen == -2) {
saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0)
saltlen--;
}
pss = RSA_PSS_PARAMS_new();
if (!pss)
goto err;
if (saltlen != 20) {
pss->saltLength = ASN1_INTEGER_new();
if (!pss->saltLength)
goto err;
if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
goto err;
}
if (EVP_MD_type(sigmd) != NID_sha1) {
pss->hashAlgorithm = X509_ALGOR_new();
if (!pss->hashAlgorithm)
goto err;
X509_ALGOR_set_md(pss->hashAlgorithm, sigmd);
}
if (EVP_MD_type(mgf1md) != NID_sha1) {
ASN1_STRING *stmp = NULL;
/* need to embed algorithm ID inside another */
mgf1alg = X509_ALGOR_new();
X509_ALGOR_set_md(mgf1alg, mgf1md);
if (!ASN1_item_pack(mgf1alg, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
goto err;
pss->maskGenAlgorithm = X509_ALGOR_new();
if (!pss->maskGenAlgorithm)
goto err;
X509_ALGOR_set0(pss->maskGenAlgorithm,
OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
}
/* Finally create string with pss parameter encoding. */
if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os1))
goto err;
if (alg2) {
os2 = ASN1_STRING_dup(os1);
if (!os2)
goto err;
X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_rsassaPss),
V_ASN1_SEQUENCE, os2);
}
X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_rsassaPss),
V_ASN1_SEQUENCE, os1);
os1 = os2 = NULL;
rv = 3;
err:
if (mgf1alg)
X509_ALGOR_free(mgf1alg);
if (pss)
RSA_PSS_PARAMS_free(pss);
if (os1)
ASN1_STRING_free(os1);
return rv;
}
return 2;
}
|
DoS
| 0
|
static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
X509_ALGOR *alg1, X509_ALGOR *alg2,
ASN1_BIT_STRING *sig)
{
int pad_mode;
EVP_PKEY_CTX *pkctx = ctx->pctx;
if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
return 0;
if (pad_mode == RSA_PKCS1_PADDING)
return 2;
if (pad_mode == RSA_PKCS1_PSS_PADDING) {
const EVP_MD *sigmd, *mgf1md;
RSA_PSS_PARAMS *pss = NULL;
X509_ALGOR *mgf1alg = NULL;
ASN1_STRING *os1 = NULL, *os2 = NULL;
EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
int saltlen, rv = 0;
sigmd = EVP_MD_CTX_md(ctx);
if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
goto err;
if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
goto err;
if (saltlen == -1)
saltlen = EVP_MD_size(sigmd);
else if (saltlen == -2) {
saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0)
saltlen--;
}
pss = RSA_PSS_PARAMS_new();
if (!pss)
goto err;
if (saltlen != 20) {
pss->saltLength = ASN1_INTEGER_new();
if (!pss->saltLength)
goto err;
if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
goto err;
}
if (EVP_MD_type(sigmd) != NID_sha1) {
pss->hashAlgorithm = X509_ALGOR_new();
if (!pss->hashAlgorithm)
goto err;
X509_ALGOR_set_md(pss->hashAlgorithm, sigmd);
}
if (EVP_MD_type(mgf1md) != NID_sha1) {
ASN1_STRING *stmp = NULL;
/* need to embed algorithm ID inside another */
mgf1alg = X509_ALGOR_new();
X509_ALGOR_set_md(mgf1alg, mgf1md);
if (!ASN1_item_pack(mgf1alg, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
goto err;
pss->maskGenAlgorithm = X509_ALGOR_new();
if (!pss->maskGenAlgorithm)
goto err;
X509_ALGOR_set0(pss->maskGenAlgorithm,
OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
}
/* Finally create string with pss parameter encoding. */
if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os1))
goto err;
if (alg2) {
os2 = ASN1_STRING_dup(os1);
if (!os2)
goto err;
X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_rsassaPss),
V_ASN1_SEQUENCE, os2);
}
X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_rsassaPss),
V_ASN1_SEQUENCE, os1);
os1 = os2 = NULL;
rv = 3;
err:
if (mgf1alg)
X509_ALGOR_free(mgf1alg);
if (pss)
RSA_PSS_PARAMS_free(pss);
if (os1)
ASN1_STRING_free(os1);
return rv;
}
return 2;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,880
|
static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
{
X509_ALGOR *alg = NULL;
switch (op) {
case ASN1_PKEY_CTRL_PKCS7_SIGN:
if (arg1 == 0)
PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
break;
case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
if (arg1 == 0)
PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
break;
#ifndef OPENSSL_NO_CMS
case ASN1_PKEY_CTRL_CMS_SIGN:
if (arg1 == 0)
CMS_SignerInfo_get0_algs(arg2, NULL, NULL, NULL, &alg);
break;
case ASN1_PKEY_CTRL_CMS_ENVELOPE:
if (arg1 == 0)
CMS_RecipientInfo_ktri_get0_algs(arg2, NULL, NULL, &alg);
break;
#endif
case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
*(int *)arg2 = NID_sha1;
return 1;
default:
return -2;
}
if (alg)
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
|
DoS
| 0
|
static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
{
X509_ALGOR *alg = NULL;
switch (op) {
case ASN1_PKEY_CTRL_PKCS7_SIGN:
if (arg1 == 0)
PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
break;
case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
if (arg1 == 0)
PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
break;
#ifndef OPENSSL_NO_CMS
case ASN1_PKEY_CTRL_CMS_SIGN:
if (arg1 == 0)
CMS_SignerInfo_get0_algs(arg2, NULL, NULL, NULL, &alg);
break;
case ASN1_PKEY_CTRL_CMS_ENVELOPE:
if (arg1 == 0)
CMS_RecipientInfo_ktri_get0_algs(arg2, NULL, NULL, &alg);
break;
#endif
case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
*(int *)arg2 = NID_sha1;
return 1;
default:
return -2;
}
if (alg)
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,881
|
static int rsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
{
const unsigned char *p;
int pklen;
if (!PKCS8_pkey_get0(NULL, &p, &pklen, NULL, p8))
return 0;
return old_rsa_priv_decode(pkey, &p, pklen);
}
|
DoS
| 0
|
static int rsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
{
const unsigned char *p;
int pklen;
if (!PKCS8_pkey_get0(NULL, &p, &pklen, NULL, p8))
return 0;
return old_rsa_priv_decode(pkey, &p, pklen);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,882
|
static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
{
unsigned char *rk = NULL;
int rklen;
rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
if (rklen <= 0) {
RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
return 0;
}
if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_rsaEncryption), 0,
V_ASN1_NULL, NULL, rk, rklen)) {
RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
return 0;
}
return 1;
}
|
DoS
| 0
|
static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
{
unsigned char *rk = NULL;
int rklen;
rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
if (rklen <= 0) {
RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
return 0;
}
if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_rsaEncryption), 0,
V_ASN1_NULL, NULL, rk, rklen)) {
RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
return 0;
}
return 1;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,883
|
static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
}
|
DoS
| 0
|
static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,884
|
static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
{
if (BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) != 0
|| BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) != 0)
return 0;
return 1;
}
|
DoS
| 0
|
static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
{
if (BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) != 0
|| BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) != 0)
return 0;
return 1;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,885
|
static int rsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
{
const unsigned char *p;
int pklen;
RSA *rsa = NULL;
if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, NULL, pubkey))
return 0;
if (!(rsa = d2i_RSAPublicKey(NULL, &p, pklen))) {
RSAerr(RSA_F_RSA_PUB_DECODE, ERR_R_RSA_LIB);
return 0;
}
EVP_PKEY_assign_RSA(pkey, rsa);
return 1;
}
|
DoS
| 0
|
static int rsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
{
const unsigned char *p;
int pklen;
RSA *rsa = NULL;
if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, NULL, pubkey))
return 0;
if (!(rsa = d2i_RSAPublicKey(NULL, &p, pklen))) {
RSAerr(RSA_F_RSA_PUB_DECODE, ERR_R_RSA_LIB);
return 0;
}
EVP_PKEY_assign_RSA(pkey, rsa);
return 1;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,886
|
static int rsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
{
unsigned char *penc = NULL;
int penclen;
penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
if (penclen <= 0)
return 0;
if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_RSA),
V_ASN1_NULL, NULL, penc, penclen))
return 1;
OPENSSL_free(penc);
return 0;
}
|
DoS
| 0
|
static int rsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
{
unsigned char *penc = NULL;
int penclen;
penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
if (penclen <= 0)
return 0;
if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_RSA),
V_ASN1_NULL, NULL, penc, penclen))
return 1;
OPENSSL_free(penc);
return 0;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,887
|
static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
}
|
DoS
| 0
|
static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,888
|
static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
{
if (OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss) {
int rv;
RSA_PSS_PARAMS *pss;
X509_ALGOR *maskHash;
pss = rsa_pss_decode(sigalg, &maskHash);
rv = rsa_pss_param_print(bp, pss, maskHash, indent);
if (pss)
RSA_PSS_PARAMS_free(pss);
if (maskHash)
X509_ALGOR_free(maskHash);
if (!rv)
return 0;
} else if (!sig && BIO_puts(bp, "\n") <= 0)
return 0;
if (sig)
return X509_signature_dump(bp, sig, indent);
return 1;
}
|
DoS
| 0
|
static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
{
if (OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss) {
int rv;
RSA_PSS_PARAMS *pss;
X509_ALGOR *maskHash;
pss = rsa_pss_decode(sigalg, &maskHash);
rv = rsa_pss_param_print(bp, pss, maskHash, indent);
if (pss)
RSA_PSS_PARAMS_free(pss);
if (maskHash)
X509_ALGOR_free(maskHash);
if (!rv)
return 0;
} else if (!sig && BIO_puts(bp, "\n") <= 0)
return 0;
if (sig)
return X509_signature_dump(bp, sig, indent);
return 1;
}
|
@@ -279,7 +279,7 @@ static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
if (pss->maskGenAlgorithm) {
ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
- && param->type == V_ASN1_SEQUENCE) {
+ && param && param->type == V_ASN1_SEQUENCE) {
p = param->value.sequence->data;
plen = param->value.sequence->length;
*pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
| null | null | null |
2,889
|
static int rsa_cms_decrypt(CMS_RecipientInfo *ri)
{
EVP_PKEY_CTX *pkctx;
X509_ALGOR *cmsalg;
int nid;
int rv = -1;
unsigned char *label = NULL;
int labellen = 0;
const EVP_MD *mgf1md = NULL, *md = NULL;
RSA_OAEP_PARAMS *oaep;
X509_ALGOR *maskHash;
pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
if (!pkctx)
return 0;
if (!CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &cmsalg))
return -1;
nid = OBJ_obj2nid(cmsalg->algorithm);
if (nid == NID_rsaEncryption)
return 1;
if (nid != NID_rsaesOaep) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE);
return -1;
}
/* Decode OAEP parameters */
oaep = rsa_oaep_decode(cmsalg, &maskHash);
if (oaep == NULL) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_OAEP_PARAMETERS);
goto err;
}
mgf1md = rsa_mgf1_to_md(oaep->maskGenFunc, maskHash);
if (!mgf1md)
goto err;
md = rsa_algor_to_md(oaep->hashFunc);
if (!md)
goto err;
if (oaep->pSourceFunc) {
X509_ALGOR *plab = oaep->pSourceFunc;
if (OBJ_obj2nid(plab->algorithm) != NID_pSpecified) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_LABEL_SOURCE);
goto err;
}
if (plab->parameter->type != V_ASN1_OCTET_STRING) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_LABEL);
goto err;
}
label = plab->parameter->value.octet_string->data;
/* Stop label being freed when OAEP parameters are freed */
plab->parameter->value.octet_string->data = NULL;
labellen = plab->parameter->value.octet_string->length;
}
if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_OAEP_PADDING) <= 0)
goto err;
if (EVP_PKEY_CTX_set_rsa_oaep_md(pkctx, md) <= 0)
goto err;
if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
goto err;
if (EVP_PKEY_CTX_set0_rsa_oaep_label(pkctx, label, labellen) <= 0)
goto err;
/* Carry on */
rv = 1;
err:
RSA_OAEP_PARAMS_free(oaep);
if (maskHash)
X509_ALGOR_free(maskHash);
return rv;
}
|
DoS
| 0
|
static int rsa_cms_decrypt(CMS_RecipientInfo *ri)
{
EVP_PKEY_CTX *pkctx;
X509_ALGOR *cmsalg;
int nid;
int rv = -1;
unsigned char *label = NULL;
int labellen = 0;
const EVP_MD *mgf1md = NULL, *md = NULL;
RSA_OAEP_PARAMS *oaep;
X509_ALGOR *maskHash;
pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
if (!pkctx)
return 0;
if (!CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &cmsalg))
return -1;
nid = OBJ_obj2nid(cmsalg->algorithm);
if (nid == NID_rsaEncryption)
return 1;
if (nid != NID_rsaesOaep) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE);
return -1;
}
/* Decode OAEP parameters */
oaep = rsa_oaep_decode(cmsalg, &maskHash);
if (oaep == NULL) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_OAEP_PARAMETERS);
goto err;
}
mgf1md = rsa_mgf1_to_md(oaep->maskGenFunc, maskHash);
if (!mgf1md)
goto err;
md = rsa_algor_to_md(oaep->hashFunc);
if (!md)
goto err;
if (oaep->pSourceFunc) {
X509_ALGOR *plab = oaep->pSourceFunc;
if (OBJ_obj2nid(plab->algorithm) != NID_pSpecified) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_LABEL_SOURCE);
goto err;
}
if (plab->parameter->type != V_ASN1_OCTET_STRING) {
RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_LABEL);
goto err;
}
label = plab->parameter->value.octet_string->data;
/* Stop label being freed when OAEP parameters are freed */
plab->parameter->value.octet_string->data = NULL;
labellen = plab->parameter->value.octet_string->length;
}
if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_OAEP_PADDING) <= 0)
goto err;
if (EVP_PKEY_CTX_set_rsa_oaep_md(pkctx, md) <= 0)
goto err;
if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
goto err;
if (EVP_PKEY_CTX_set0_rsa_oaep_label(pkctx, label, labellen) <= 0)
goto err;
/* Carry on */
rv = 1;
err:
RSA_OAEP_PARAMS_free(oaep);
if (maskHash)
X509_ALGOR_free(maskHash);
return rv;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,890
|
static int rsa_cms_encrypt(CMS_RecipientInfo *ri)
{
const EVP_MD *md, *mgf1md;
RSA_OAEP_PARAMS *oaep = NULL;
ASN1_STRING *os = NULL;
X509_ALGOR *alg;
EVP_PKEY_CTX *pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
int pad_mode = RSA_PKCS1_PADDING, rv = 0, labellen;
unsigned char *label;
CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg);
if (pkctx) {
if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
return 0;
}
if (pad_mode == RSA_PKCS1_PADDING) {
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
/* Not supported */
if (pad_mode != RSA_PKCS1_OAEP_PADDING)
return 0;
if (EVP_PKEY_CTX_get_rsa_oaep_md(pkctx, &md) <= 0)
goto err;
if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
goto err;
labellen = EVP_PKEY_CTX_get0_rsa_oaep_label(pkctx, &label);
if (labellen < 0)
goto err;
oaep = RSA_OAEP_PARAMS_new();
if (!oaep)
goto err;
if (!rsa_md_to_algor(&oaep->hashFunc, md))
goto err;
if (!rsa_md_to_mgf1(&oaep->maskGenFunc, mgf1md))
goto err;
if (labellen > 0) {
ASN1_OCTET_STRING *los = ASN1_OCTET_STRING_new();
oaep->pSourceFunc = X509_ALGOR_new();
if (!oaep->pSourceFunc)
goto err;
if (!los)
goto err;
if (!ASN1_OCTET_STRING_set(los, label, labellen)) {
ASN1_OCTET_STRING_free(los);
goto err;
}
X509_ALGOR_set0(oaep->pSourceFunc, OBJ_nid2obj(NID_pSpecified),
V_ASN1_OCTET_STRING, los);
}
/* create string with pss parameter encoding. */
if (!ASN1_item_pack(oaep, ASN1_ITEM_rptr(RSA_OAEP_PARAMS), &os))
goto err;
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaesOaep), V_ASN1_SEQUENCE, os);
os = NULL;
rv = 1;
err:
if (oaep)
RSA_OAEP_PARAMS_free(oaep);
if (os)
ASN1_STRING_free(os);
return rv;
}
|
DoS
| 0
|
static int rsa_cms_encrypt(CMS_RecipientInfo *ri)
{
const EVP_MD *md, *mgf1md;
RSA_OAEP_PARAMS *oaep = NULL;
ASN1_STRING *os = NULL;
X509_ALGOR *alg;
EVP_PKEY_CTX *pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
int pad_mode = RSA_PKCS1_PADDING, rv = 0, labellen;
unsigned char *label;
CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg);
if (pkctx) {
if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
return 0;
}
if (pad_mode == RSA_PKCS1_PADDING) {
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
/* Not supported */
if (pad_mode != RSA_PKCS1_OAEP_PADDING)
return 0;
if (EVP_PKEY_CTX_get_rsa_oaep_md(pkctx, &md) <= 0)
goto err;
if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
goto err;
labellen = EVP_PKEY_CTX_get0_rsa_oaep_label(pkctx, &label);
if (labellen < 0)
goto err;
oaep = RSA_OAEP_PARAMS_new();
if (!oaep)
goto err;
if (!rsa_md_to_algor(&oaep->hashFunc, md))
goto err;
if (!rsa_md_to_mgf1(&oaep->maskGenFunc, mgf1md))
goto err;
if (labellen > 0) {
ASN1_OCTET_STRING *los = ASN1_OCTET_STRING_new();
oaep->pSourceFunc = X509_ALGOR_new();
if (!oaep->pSourceFunc)
goto err;
if (!los)
goto err;
if (!ASN1_OCTET_STRING_set(los, label, labellen)) {
ASN1_OCTET_STRING_free(los);
goto err;
}
X509_ALGOR_set0(oaep->pSourceFunc, OBJ_nid2obj(NID_pSpecified),
V_ASN1_OCTET_STRING, los);
}
/* create string with pss parameter encoding. */
if (!ASN1_item_pack(oaep, ASN1_ITEM_rptr(RSA_OAEP_PARAMS), &os))
goto err;
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaesOaep), V_ASN1_SEQUENCE, os);
os = NULL;
rv = 1;
err:
if (oaep)
RSA_OAEP_PARAMS_free(oaep);
if (os)
ASN1_STRING_free(os);
return rv;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,891
|
static int rsa_cms_sign(CMS_SignerInfo *si)
{
int pad_mode = RSA_PKCS1_PADDING;
X509_ALGOR *alg;
EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
ASN1_STRING *os = NULL;
CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
if (pkctx) {
if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
return 0;
}
if (pad_mode == RSA_PKCS1_PADDING) {
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
/* We don't support it */
if (pad_mode != RSA_PKCS1_PSS_PADDING)
return 0;
os = rsa_ctx_to_pss(pkctx);
if (!os)
return 0;
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsassaPss), V_ASN1_SEQUENCE, os);
return 1;
}
|
DoS
| 0
|
static int rsa_cms_sign(CMS_SignerInfo *si)
{
int pad_mode = RSA_PKCS1_PADDING;
X509_ALGOR *alg;
EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
ASN1_STRING *os = NULL;
CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
if (pkctx) {
if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
return 0;
}
if (pad_mode == RSA_PKCS1_PADDING) {
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
/* We don't support it */
if (pad_mode != RSA_PKCS1_PSS_PADDING)
return 0;
os = rsa_ctx_to_pss(pkctx);
if (!os)
return 0;
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsassaPss), V_ASN1_SEQUENCE, os);
return 1;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,892
|
static int rsa_cms_verify(CMS_SignerInfo *si)
{
int nid, nid2;
X509_ALGOR *alg;
EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
nid = OBJ_obj2nid(alg->algorithm);
if (nid == NID_rsaEncryption)
return 1;
if (nid == NID_rsassaPss)
return rsa_pss_to_ctx(NULL, pkctx, alg, NULL);
/* Workaround for some implementation that use a signature OID */
if (OBJ_find_sigid_algs(nid, NULL, &nid2)) {
if (nid2 == NID_rsaEncryption)
return 1;
}
return 0;
}
|
DoS
| 0
|
static int rsa_cms_verify(CMS_SignerInfo *si)
{
int nid, nid2;
X509_ALGOR *alg;
EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
nid = OBJ_obj2nid(alg->algorithm);
if (nid == NID_rsaEncryption)
return 1;
if (nid == NID_rsassaPss)
return rsa_pss_to_ctx(NULL, pkctx, alg, NULL);
/* Workaround for some implementation that use a signature OID */
if (OBJ_find_sigid_algs(nid, NULL, &nid2)) {
if (nid2 == NID_rsaEncryption)
return 1;
}
return 0;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,893
|
static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
EVP_PKEY *pkey)
{
/* Sanity check: make sure it is PSS */
if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss) {
RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
return -1;
}
if (rsa_pss_to_ctx(ctx, NULL, sigalg, pkey) > 0) {
/* Carry on */
return 2;
}
return -1;
}
|
DoS
| 0
|
static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
EVP_PKEY *pkey)
{
/* Sanity check: make sure it is PSS */
if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss) {
RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
return -1;
}
if (rsa_pss_to_ctx(ctx, NULL, sigalg, pkey) > 0) {
/* Carry on */
return 2;
}
return -1;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,894
|
static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md)
{
if (EVP_MD_type(md) == NID_sha1)
return 1;
*palg = X509_ALGOR_new();
if (!*palg)
return 0;
X509_ALGOR_set_md(*palg, md);
return 1;
}
|
DoS
| 0
|
static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md)
{
if (EVP_MD_type(md) == NID_sha1)
return 1;
*palg = X509_ALGOR_new();
if (!*palg)
return 0;
X509_ALGOR_set_md(*palg, md);
return 1;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,895
|
static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md)
{
X509_ALGOR *algtmp = NULL;
ASN1_STRING *stmp = NULL;
*palg = NULL;
if (EVP_MD_type(mgf1md) == NID_sha1)
return 1;
/* need to embed algorithm ID inside another */
if (!rsa_md_to_algor(&algtmp, mgf1md))
goto err;
if (!ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
goto err;
*palg = X509_ALGOR_new();
if (!*palg)
goto err;
X509_ALGOR_set0(*palg, OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
stmp = NULL;
err:
if (stmp)
ASN1_STRING_free(stmp);
if (algtmp)
X509_ALGOR_free(algtmp);
if (*palg)
return 1;
return 0;
}
|
DoS
| 0
|
static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md)
{
X509_ALGOR *algtmp = NULL;
ASN1_STRING *stmp = NULL;
*palg = NULL;
if (EVP_MD_type(mgf1md) == NID_sha1)
return 1;
/* need to embed algorithm ID inside another */
if (!rsa_md_to_algor(&algtmp, mgf1md))
goto err;
if (!ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
goto err;
*palg = X509_ALGOR_new();
if (!*palg)
goto err;
X509_ALGOR_set0(*palg, OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
stmp = NULL;
err:
if (stmp)
ASN1_STRING_free(stmp);
if (algtmp)
X509_ALGOR_free(algtmp);
if (*palg)
return 1;
return 0;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,896
|
static const EVP_MD *rsa_mgf1_to_md(X509_ALGOR *alg, X509_ALGOR *maskHash)
{
const EVP_MD *md;
if (!alg)
return EVP_sha1();
/* Check mask and lookup mask hash algorithm */
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1) {
RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_ALGORITHM);
return NULL;
}
if (!maskHash) {
RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_PARAMETER);
return NULL;
}
md = EVP_get_digestbyobj(maskHash->algorithm);
if (md == NULL) {
RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNKNOWN_MASK_DIGEST);
return NULL;
}
return md;
}
|
DoS
| 0
|
static const EVP_MD *rsa_mgf1_to_md(X509_ALGOR *alg, X509_ALGOR *maskHash)
{
const EVP_MD *md;
if (!alg)
return EVP_sha1();
/* Check mask and lookup mask hash algorithm */
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1) {
RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_ALGORITHM);
return NULL;
}
if (!maskHash) {
RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_PARAMETER);
return NULL;
}
md = EVP_get_digestbyobj(maskHash->algorithm);
if (md == NULL) {
RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNKNOWN_MASK_DIGEST);
return NULL;
}
return md;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,897
|
static RSA_OAEP_PARAMS *rsa_oaep_decode(const X509_ALGOR *alg,
X509_ALGOR **pmaskHash)
{
const unsigned char *p;
int plen;
RSA_OAEP_PARAMS *pss;
*pmaskHash = NULL;
if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
return NULL;
p = alg->parameter->value.sequence->data;
plen = alg->parameter->value.sequence->length;
pss = d2i_RSA_OAEP_PARAMS(NULL, &p, plen);
if (!pss)
return NULL;
*pmaskHash = rsa_mgf1_decode(pss->maskGenFunc);
return pss;
}
|
DoS
| 0
|
static RSA_OAEP_PARAMS *rsa_oaep_decode(const X509_ALGOR *alg,
X509_ALGOR **pmaskHash)
{
const unsigned char *p;
int plen;
RSA_OAEP_PARAMS *pss;
*pmaskHash = NULL;
if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
return NULL;
p = alg->parameter->value.sequence->data;
plen = alg->parameter->value.sequence->length;
pss = d2i_RSA_OAEP_PARAMS(NULL, &p, plen);
if (!pss)
return NULL;
*pmaskHash = rsa_mgf1_decode(pss->maskGenFunc);
return pss;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,898
|
static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
{
X509_ALGOR *alg = NULL;
switch (op) {
case ASN1_PKEY_CTRL_PKCS7_SIGN:
if (arg1 == 0)
PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
break;
case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
if (arg1 == 0)
PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
break;
#ifndef OPENSSL_NO_CMS
case ASN1_PKEY_CTRL_CMS_SIGN:
if (arg1 == 0)
return rsa_cms_sign(arg2);
else if (arg1 == 1)
return rsa_cms_verify(arg2);
break;
case ASN1_PKEY_CTRL_CMS_ENVELOPE:
if (arg1 == 0)
return rsa_cms_encrypt(arg2);
else if (arg1 == 1)
return rsa_cms_decrypt(arg2);
break;
case ASN1_PKEY_CTRL_CMS_RI_TYPE:
*(int *)arg2 = CMS_RECIPINFO_TRANS;
return 1;
#endif
case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
*(int *)arg2 = NID_sha256;
return 1;
default:
return -2;
}
if (alg)
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
|
DoS
| 0
|
static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
{
X509_ALGOR *alg = NULL;
switch (op) {
case ASN1_PKEY_CTRL_PKCS7_SIGN:
if (arg1 == 0)
PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
break;
case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
if (arg1 == 0)
PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
break;
#ifndef OPENSSL_NO_CMS
case ASN1_PKEY_CTRL_CMS_SIGN:
if (arg1 == 0)
return rsa_cms_sign(arg2);
else if (arg1 == 1)
return rsa_cms_verify(arg2);
break;
case ASN1_PKEY_CTRL_CMS_ENVELOPE:
if (arg1 == 0)
return rsa_cms_encrypt(arg2);
else if (arg1 == 1)
return rsa_cms_decrypt(arg2);
break;
case ASN1_PKEY_CTRL_CMS_RI_TYPE:
*(int *)arg2 = CMS_RECIPINFO_TRANS;
return 1;
#endif
case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
*(int *)arg2 = NID_sha256;
return 1;
default:
return -2;
}
if (alg)
X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
return 1;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
2,899
|
static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
X509_ALGOR **pmaskHash)
{
const unsigned char *p;
int plen;
RSA_PSS_PARAMS *pss;
*pmaskHash = NULL;
if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
return NULL;
p = alg->parameter->value.sequence->data;
plen = alg->parameter->value.sequence->length;
pss = d2i_RSA_PSS_PARAMS(NULL, &p, plen);
if (!pss)
return NULL;
*pmaskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
return pss;
}
|
DoS
| 0
|
static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
X509_ALGOR **pmaskHash)
{
const unsigned char *p;
int plen;
RSA_PSS_PARAMS *pss;
*pmaskHash = NULL;
if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
return NULL;
p = alg->parameter->value.sequence->data;
plen = alg->parameter->value.sequence->length;
pss = d2i_RSA_PSS_PARAMS(NULL, &p, plen);
if (!pss)
return NULL;
*pmaskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
return pss;
}
|
@@ -268,7 +268,7 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
{
const unsigned char *p;
int plen;
- if (alg == NULL)
+ if (alg == NULL || alg->parameter == NULL)
return NULL;
if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
return NULL;
| null | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.