idx int64 | project string | commit_id string | project_url string | commit_url string | commit_message string | target int64 | func string | func_hash float64 | file_name string | file_hash float64 | cwe list | cve string | cve_desc string | nvd_url string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
505,189 | core | 1a29ed2f96da1be22fa5a4d96c7583aa81b8b060 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/1a29ed2f96da1be22fa5a4d96c7583aa81b8b060.patch | lib-auth: Fix memory leak in auth_client_request_abort()
This caused memory leaks when authentication was aborted. For example
with IMAP:
a AUTHENTICATE PLAIN
*
Broken by 9137c55411aa39d41c1e705ddc34d5bd26c65021 | 0 | void auth_client_request_continue(struct auth_client_request *request,
const char *data_base64)
{
struct const_iovec iov[3];
const char *prefix;
prefix = t_strdup_printf("CONT\t%u\t", request->id);
iov[0].iov_base = prefix;
iov[0].iov_len = strlen(prefix);
iov[1].iov_base = dat... | 51,819,266,407,330,750,000,000,000,000,000,000,000 | None | null | [
"CWE-284"
] | CVE-2017-15132 | A flaw was found in dovecot 2.0 up to 2.2.33 and 2.3.0. An abort of SASL authentication results in a memory leak in dovecot's auth client used by login processes. The leak has impact in high performance configuration where same login processes are reused and can cause the process to crash due to memory exhaustion. | https://nvd.nist.gov/vuln/detail/CVE-2017-15132 |
505,190 | core | 1a29ed2f96da1be22fa5a4d96c7583aa81b8b060 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/1a29ed2f96da1be22fa5a4d96c7583aa81b8b060.patch | lib-auth: Fix memory leak in auth_client_request_abort()
This caused memory leaks when authentication was aborted. For example
with IMAP:
a AUTHENTICATE PLAIN
*
Broken by 9137c55411aa39d41c1e705ddc34d5bd26c65021 | 0 | bool auth_client_request_is_aborted(struct auth_client_request *request)
{
return request->callback == NULL;
} | 105,379,357,491,760,600,000,000,000,000,000,000,000 | None | null | [
"CWE-284"
] | CVE-2017-15132 | A flaw was found in dovecot 2.0 up to 2.2.33 and 2.3.0. An abort of SASL authentication results in a memory leak in dovecot's auth client used by login processes. The leak has impact in high performance configuration where same login processes are reused and can cause the process to crash due to memory exhaustion. | https://nvd.nist.gov/vuln/detail/CVE-2017-15132 |
505,191 | core | 1a29ed2f96da1be22fa5a4d96c7583aa81b8b060 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/1a29ed2f96da1be22fa5a4d96c7583aa81b8b060.patch | lib-auth: Fix memory leak in auth_client_request_abort()
This caused memory leaks when authentication was aborted. For example
with IMAP:
a AUTHENTICATE PLAIN
*
Broken by 9137c55411aa39d41c1e705ddc34d5bd26c65021 | 0 | auth_client_request_new(struct auth_client *client,
const struct auth_request_info *request_info,
auth_request_callback_t *callback, void *context)
{
struct auth_client_request *request;
pool_t pool;
pool = pool_alloconly_create("auth client request", 512);
request = p_new(pool, struct auth_client_request, 1... | 447,381,922,113,685,650,000,000,000,000,000,000 | None | null | [
"CWE-284"
] | CVE-2017-15132 | A flaw was found in dovecot 2.0 up to 2.2.33 and 2.3.0. An abort of SASL authentication results in a memory leak in dovecot's auth client used by login processes. The leak has impact in high performance configuration where same login processes are reused and can cause the process to crash due to memory exhaustion. | https://nvd.nist.gov/vuln/detail/CVE-2017-15132 |
505,192 | core | 1a29ed2f96da1be22fa5a4d96c7583aa81b8b060 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/1a29ed2f96da1be22fa5a4d96c7583aa81b8b060.patch | lib-auth: Fix memory leak in auth_client_request_abort()
This caused memory leaks when authentication was aborted. For example
with IMAP:
a AUTHENTICATE PLAIN
*
Broken by 9137c55411aa39d41c1e705ddc34d5bd26c65021 | 0 | void auth_client_request_server_input(struct auth_client_request *request,
enum auth_request_status status,
const char *const *args)
{
const char *const *tmp, *base64_data = NULL;
if (request->callback == NULL) {
/* aborted already */
return;
}
switch (status) {
case AUTH_REQUEST_STATUS_O... | 76,132,364,000,225,430,000,000,000,000,000,000,000 | None | null | [
"CWE-284"
] | CVE-2017-15132 | A flaw was found in dovecot 2.0 up to 2.2.33 and 2.3.0. An abort of SASL authentication results in a memory leak in dovecot's auth client used by login processes. The leak has impact in high performance configuration where same login processes are reused and can cause the process to crash due to memory exhaustion. | https://nvd.nist.gov/vuln/detail/CVE-2017-15132 |
505,193 | core | 1a29ed2f96da1be22fa5a4d96c7583aa81b8b060 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/1a29ed2f96da1be22fa5a4d96c7583aa81b8b060.patch | lib-auth: Fix memory leak in auth_client_request_abort()
This caused memory leaks when authentication was aborted. For example
with IMAP:
a AUTHENTICATE PLAIN
*
Broken by 9137c55411aa39d41c1e705ddc34d5bd26c65021 | 0 | const char *auth_client_request_get_cookie(struct auth_client_request *request)
{
return request->conn->cookie;
} | 203,112,953,060,823,800,000,000,000,000,000,000,000 | None | null | [
"CWE-284"
] | CVE-2017-15132 | A flaw was found in dovecot 2.0 up to 2.2.33 and 2.3.0. An abort of SASL authentication results in a memory leak in dovecot's auth client used by login processes. The leak has impact in high performance configuration where same login processes are reused and can cause the process to crash due to memory exhaustion. | https://nvd.nist.gov/vuln/detail/CVE-2017-15132 |
505,194 | core | 1a29ed2f96da1be22fa5a4d96c7583aa81b8b060 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/1a29ed2f96da1be22fa5a4d96c7583aa81b8b060.patch | lib-auth: Fix memory leak in auth_client_request_abort()
This caused memory leaks when authentication was aborted. For example
with IMAP:
a AUTHENTICATE PLAIN
*
Broken by 9137c55411aa39d41c1e705ddc34d5bd26c65021 | 0 | time_t auth_client_request_get_create_time(struct auth_client_request *request)
{
return request->created;
} | 58,004,976,232,539,370,000,000,000,000,000,000,000 | None | null | [
"CWE-284"
] | CVE-2017-15132 | A flaw was found in dovecot 2.0 up to 2.2.33 and 2.3.0. An abort of SASL authentication results in a memory leak in dovecot's auth client used by login processes. The leak has impact in high performance configuration where same login processes are reused and can cause the process to crash due to memory exhaustion. | https://nvd.nist.gov/vuln/detail/CVE-2017-15132 |
505,217 | server | f5369faf5bbfb56b5e945836eb3f7c7ee88b4079 | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/f5369faf5bbfb56b5e945836eb3f7c7ee88b4079 | don't disable SSL when connecting via libmysqld | 0 | void mysql_read_default_options(struct st_mysql_options *options,
const char *filename,const char *group)
{
int argc;
char *argv_buff[1],**argv;
const char *groups[5];
DBUG_ENTER("mysql_read_default_options");
DBUG_PRINT("enter",("file: %s group: %s",filename,group ? group :"NULL"));
compile_time_asse... | 200,342,595,301,877,000,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-2767 | Vulnerability in the MySQL Server component of Oracle MySQL (subcomponent: Server: Security: Encryption). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior and 5.7.22 and prior. Difficult to exploit vulnerability allows low privileged attacker with network access via multiple protocols to comp... | https://nvd.nist.gov/vuln/detail/CVE-2018-2767 |
505,218 | server | f5369faf5bbfb56b5e945836eb3f7c7ee88b4079 | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/f5369faf5bbfb56b5e945836eb3f7c7ee88b4079 | don't disable SSL when connecting via libmysqld | 0 | static int send_client_reply_packet(MCPVIO_EXT *mpvio,
const uchar *data, int data_len)
{
MYSQL *mysql= mpvio->mysql;
NET *net= &mysql->net;
char *buff, *end;
/* see end= buff+32 below, fixed size of the packet is 32 bytes */
buff= my_alloca(33 + USERNAME_LENGTH + data_len... | 85,051,371,874,107,250,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-2767 | Vulnerability in the MySQL Server component of Oracle MySQL (subcomponent: Server: Security: Encryption). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior and 5.7.22 and prior. Difficult to exploit vulnerability allows low privileged attacker with network access via multiple protocols to comp... | https://nvd.nist.gov/vuln/detail/CVE-2018-2767 |
505,219 | server | f5369faf5bbfb56b5e945836eb3f7c7ee88b4079 | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/f5369faf5bbfb56b5e945836eb3f7c7ee88b4079 | don't disable SSL when connecting via libmysqld | 0 | mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
const char *key __attribute__((unused)),
const char *cert __attribute__((unused)),
const char *ca __attribute__((unused)),
const char *capath __attribute__((unused)),
const char *cipher __attribute__((unused)))
{
DBUG_ENTER("mysql... | 105,055,376,820,706,960,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-2767 | Vulnerability in the MySQL Server component of Oracle MySQL (subcomponent: Server: Security: Encryption). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior and 5.7.22 and prior. Difficult to exploit vulnerability allows low privileged attacker with network access via multiple protocols to comp... | https://nvd.nist.gov/vuln/detail/CVE-2018-2767 |
505,373 | server | 1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | protocol: verify that number of rows is correct | 0 | MYSQL_DATA *cli_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
unsigned int fields)
{
uint field;
ulong pkt_len;
ulong len;
uchar *cp;
char *to, *end_to;
MYSQL_DATA *result;
MYSQL_ROWS **prev_ptr,*cur;
NET *net = &mysql->net;
DBUG_ENTER("cli_read_rows");
if ((pkt_len= cli_safe_read(mysql)) ... | 325,161,994,765,950,120,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-3081 | Vulnerability in the MySQL Client component of Oracle MySQL (subcomponent: Client programs). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior, 5.7.22 and prior and 8.0.11 and prior. Difficult to exploit vulnerability allows high privileged attacker with network access via multiple protocols t... | https://nvd.nist.gov/vuln/detail/CVE-2018-3081 |
505,374 | server | 1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | protocol: verify that number of rows is correct | 0 | static int client_mpvio_read_packet(struct st_plugin_vio *mpv, uchar **buf)
{
MCPVIO_EXT *mpvio= (MCPVIO_EXT*)mpv;
MYSQL *mysql= mpvio->mysql;
ulong pkt_len;
/* there are cached data left, feed it to a plugin */
if (mpvio->cached_server_reply.pkt)
{
*buf= mpvio->cached_server_reply.pkt;
mpvio->cac... | 23,319,168,599,546,388,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-3081 | Vulnerability in the MySQL Client component of Oracle MySQL (subcomponent: Client programs). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior, 5.7.22 and prior and 8.0.11 and prior. Difficult to exploit vulnerability allows high privileged attacker with network access via multiple protocols t... | https://nvd.nist.gov/vuln/detail/CVE-2018-3081 |
505,375 | server | 1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | protocol: verify that number of rows is correct | 0 | int run_plugin_auth(MYSQL *mysql, char *data, uint data_len,
const char *data_plugin, const char *db)
{
const char *auth_plugin_name;
auth_plugin_t *auth_plugin;
MCPVIO_EXT mpvio;
ulong pkt_length;
int res;
DBUG_ENTER ("run_plugin_auth");
/* determine the default/init... | 335,354,768,817,761,080,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-3081 | Vulnerability in the MySQL Client component of Oracle MySQL (subcomponent: Client programs). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior, 5.7.22 and prior and 8.0.11 and prior. Difficult to exploit vulnerability allows high privileged attacker with network access via multiple protocols t... | https://nvd.nist.gov/vuln/detail/CVE-2018-3081 |
505,376 | server | 1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | protocol: verify that number of rows is correct | 0 | read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths)
{
uint field;
ulong pkt_len,len;
uchar *pos, *prev_pos, *end_pos;
NET *net= &mysql->net;
if ((pkt_len=cli_safe_read(mysql)) == packet_error)
return -1;
if (pkt_len <= 8 && net->read_pos[0] == 254)
{
if (pkt_len > 1) /* MySQL ... | 13,973,719,734,162,650,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-3081 | Vulnerability in the MySQL Client component of Oracle MySQL (subcomponent: Client programs). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior, 5.7.22 and prior and 8.0.11 and prior. Difficult to exploit vulnerability allows high privileged attacker with network access via multiple protocols t... | https://nvd.nist.gov/vuln/detail/CVE-2018-3081 |
505,377 | server | 1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | https://github.com/MariaDB/server | https://github.com/MariaDB/server/commit/1d58d184c2c4ddd8a3b2be6f86d76c4e57bbe14f | protocol: verify that number of rows is correct | 0 | unpack_fields(MYSQL *mysql, MYSQL_DATA *data,MEM_ROOT *alloc,uint fields,
my_bool default_value, uint server_capabilities)
{
MYSQL_ROWS *row;
MYSQL_FIELD *field,*result;
ulong lengths[9]; /* Max of fields */
DBUG_ENTER("unpack_fields");
field= result= (MYSQL_FIELD*) alloc_root(alloc,
(uint)... | 332,655,037,706,260,820,000,000,000,000,000,000,000 | None | null | [
"NVD-CWE-noinfo"
] | CVE-2018-3081 | Vulnerability in the MySQL Client component of Oracle MySQL (subcomponent: Client programs). Supported versions that are affected are 5.5.60 and prior, 5.6.40 and prior, 5.7.22 and prior and 8.0.11 and prior. Difficult to exploit vulnerability allows high privileged attacker with network access via multiple protocols t... | https://nvd.nist.gov/vuln/detail/CVE-2018-3081 |
505,415 | audiofile | 822b732fd31ffcb78f6920001e9b1fbd815fa712 | https://github.com/antlarr/audiofile | https://github.com/wtay/audiofile/commit/822b732fd31ffcb78f6920001e9b1fbd815fa712 | SimpleModule: set output chunk framecount after pull
After pulling the data, set the output chunk to the amount of
frames we pulled so that the next module in the chain has the correct
frame count.
Fixes #50 and #51 | 0 | void SimpleModule::runPull()
{
pull(m_outChunk->frameCount);
m_outChunk->frameCount = m_inChunk->frameCount;
run(*m_inChunk, *m_outChunk);
} | 46,489,266,912,818,470,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2018-17095 | An issue has been discovered in mpruett Audio File Library (aka audiofile) 0.3.6, 0.3.5, 0.3.4, 0.3.3, 0.3.2, 0.3.1, 0.3.0. A heap-based buffer overflow in Expand3To4Module::run has occurred when running sfconvert. | https://nvd.nist.gov/vuln/detail/CVE-2018-17095 |
505,457 | openssl | ee22257b1418438ebaf54df98af4e24f494d1809 | https://github.com/openssl/openssl | https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=ee22257b1418438ebaf54df98af4e24f494d1809 | Prevent over long nonces in ChaCha20-Poly1305
ChaCha20-Poly1305 is an AEAD cipher, and requires a unique nonce input for
every encryption operation. RFC 7539 specifies that the nonce value (IV)
should be 96 bits (12 bytes). OpenSSL allows a variable nonce length and
front pads the nonce with 0 bytes if it is less than... | 0 | static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
{
EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
if (actx)
OPENSSL_cleanse(ctx->cipher_data, sizeof(*actx) + Poly1305_ctx_size());
return 1;
} | 83,775,944,020,219,290,000,000,000,000,000,000,000 | None | null | [
"CWE-327"
] | CVE-2019-1543 | ChaCha20-Poly1305 is an AEAD cipher, and requires a unique nonce input for every encryption operation. RFC 7539 specifies that the nonce value (IV) should be 96 bits (12 bytes). OpenSSL allows a variable nonce length and front pads the nonce with 0 bytes if it is less than 12 bytes. However it also incorrectly allows a... | https://nvd.nist.gov/vuln/detail/CVE-2019-1543 |
505,458 | openssl | ee22257b1418438ebaf54df98af4e24f494d1809 | https://github.com/openssl/openssl | https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=ee22257b1418438ebaf54df98af4e24f494d1809 | Prevent over long nonces in ChaCha20-Poly1305
ChaCha20-Poly1305 is an AEAD cipher, and requires a unique nonce input for
every encryption operation. RFC 7539 specifies that the nonce value (IV)
should be 96 bits (12 bytes). OpenSSL allows a variable nonce length and
front pads the nonce with 0 bytes if it is less than... | 0 | static int chacha20_poly1305_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
void *ptr)
{
EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
switch(type) {
case EVP_CTRL_INIT:
if (actx == NULL)
actx = ctx->cipher_data
= OPENSSL_zalloc(sizeof(*act... | 195,239,588,748,239,930,000,000,000,000,000,000,000 | None | null | [
"CWE-327"
] | CVE-2019-1543 | ChaCha20-Poly1305 is an AEAD cipher, and requires a unique nonce input for every encryption operation. RFC 7539 specifies that the nonce value (IV) should be 96 bits (12 bytes). OpenSSL allows a variable nonce length and front pads the nonce with 0 bytes if it is less than 12 bytes. However it also incorrectly allows a... | https://nvd.nist.gov/vuln/detail/CVE-2019-1543 |
505,551 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | imap_parser_strdup(struct imap_parser *parser,
const void *data, size_t len)
{
char *ret;
ret = p_malloc(parser->pool, len + 1);
memcpy(ret, data, len);
return ret;
} | 141,578,078,344,487,730,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,552 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_read_literal_data(struct imap_parser *parser,
const unsigned char *data,
size_t data_size)
{
if (parser->literal_skip_crlf) {
/* skip \r\n or \n, anything else gives an error */
if (data_size == 0)
return FALSE;
if (*data == '\r') {
parser->line_size++;
data++; dat... | 283,718,361,757,878,160,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,553 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | int imap_parser_read_args(struct imap_parser *parser, unsigned int count,
enum imap_parser_flags flags,
const struct imap_arg **args_r)
{
parser->flags = flags;
if (parser->args_added_extra_eol) {
/* delete EOL */
array_pop_back(&parser->root_list);
parser->args_added_extra_eol = FALSE;
parser->lit... | 37,028,260,837,577,830,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,554 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_read_atom(struct imap_parser *parser,
const unsigned char *data, size_t data_size)
{
size_t i;
/* read until we've found space, CR or LF. */
for (i = parser->cur_pos; i < data_size; i++) {
if (data[i] == ' ' || is_linebreak(data[i])) {
imap_parser_save_arg(parser, data, i);
bre... | 15,894,514,371,431,377,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,555 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | void imap_parser_unref(struct imap_parser **_parser)
{
struct imap_parser *parser = *_parser;
*_parser = NULL;
i_assert(parser->refcount > 0);
if (--parser->refcount > 0)
return;
pool_unref(&parser->pool);
i_free(parser);
} | 164,352,713,776,699,210,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,556 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | const char *imap_parser_read_word(struct imap_parser *parser)
{
const unsigned char *data;
size_t i, data_size;
data = i_stream_get_data(parser->input, &data_size);
for (i = 0; i < data_size; i++) {
if (data[i] == ' ' || data[i] == '\r' || data[i] == '\n')
break;
}
if (i < data_size) {
data_size = i + (... | 275,445,312,596,851,570,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,557 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | void imap_parser_reset(struct imap_parser *parser)
{
p_clear(parser->pool);
parser->line_size = 0;
p_array_init(&parser->root_list, parser->pool, LIST_INIT_COUNT);
parser->cur_list = &parser->root_list;
parser->list_arg = NULL;
parser->cur_type = ARG_PARSE_NONE;
parser->cur_pos = 0;
parser->cur_resp_text = F... | 135,798,354,636,202,300,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,558 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_read_string(struct imap_parser *parser,
const unsigned char *data, size_t data_size)
{
size_t i;
/* read until we've found non-escaped ", CR or LF */
for (i = parser->cur_pos; i < data_size; i++) {
if (data[i] == '"') {
imap_parser_save_arg(parser, data, i);
i++; /* skip the... | 45,484,247,244,906,110,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,559 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_close_list(struct imap_parser *parser)
{
struct imap_arg *arg;
if (parser->list_arg == NULL) {
/* we're not inside list */
if ((parser->flags & IMAP_PARSE_FLAG_INSIDE_LIST) != 0) {
parser->eol = TRUE;
parser->cur_type = ARG_PARSE_NONE;
return TRUE;
}
parser->error_msg = "Unex... | 275,637,406,729,655,580,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,560 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | imap_parser_create(struct istream *input, struct ostream *output,
size_t max_line_size)
{
struct imap_parser *parser;
parser = i_new(struct imap_parser, 1);
parser->refcount = 1;
parser->pool = pool_alloconly_create(MEMPOOL_GROWING"IMAP parser",
1024);
parser->input = input;
parser->output = outpu... | 46,778,094,657,283,870,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,561 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_is_next_text(struct imap_parser *parser)
{
const struct imap_arg *arg;
size_t len;
if (parser->cur_list != &parser->root_list)
return FALSE;
arg = array_back(&parser->root_list);
if (arg->type != IMAP_ARG_ATOM)
return FALSE;
len = strlen(arg->_data.str);
return len > 0 && arg->_dat... | 164,818,902,333,995,580,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,562 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | bool imap_parser_get_literal_size(struct imap_parser *parser, uoff_t *size_r)
{
ARRAY_TYPE(imap_arg_list) *list;
struct imap_arg *last_arg;
last_arg = imap_parser_get_last_literal_size(parser, &list);
if (last_arg == NULL)
return FALSE;
return imap_arg_get_literal_size(last_arg, size_r);
} | 291,295,449,627,762,180,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,563 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | int imap_parser_finish_line(struct imap_parser *parser, unsigned int count,
enum imap_parser_flags flags,
const struct imap_arg **args_r)
{
const unsigned char *data;
size_t data_size;
int ret;
ret = imap_parser_read_args(parser, count, flags, args_r);
if (ret == -1)
return -1;
if (ret == -2) {
... | 47,702,154,230,476,460,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,564 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_skip_to_next(struct imap_parser *parser,
const unsigned char **data,
size_t *data_size)
{
size_t i;
for (i = parser->cur_pos; i < *data_size; i++) {
if ((*data)[i] != ' ')
break;
}
parser->line_size += i;
i_stream_skip(parser->input, i);
parser->cur_pos = 0;... | 294,037,723,126,880,000,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,565 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_read_literal(struct imap_parser *parser,
const unsigned char *data,
size_t data_size)
{
size_t i, prev_size;
/* expecting digits + "}" */
for (i = parser->cur_pos; i < data_size; i++) {
if (data[i] == '}') {
parser->line_size += i+1;
i_stream_skip(parser->input, i+1... | 11,507,451,319,445,728,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,566 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_is_next_resp_text(struct imap_parser *parser)
{
const struct imap_arg *arg;
if (parser->cur_list != &parser->root_list ||
array_count(parser->cur_list) != 1)
return FALSE;
arg = array_front(&parser->root_list);
if (arg->type != IMAP_ARG_ATOM)
return FALSE;
return strcasecmp(arg-... | 300,972,773,882,286,940,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,567 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static int finish_line(struct imap_parser *parser, unsigned int count,
const struct imap_arg **args_r)
{
struct imap_arg *arg;
int ret = array_count(&parser->root_list);
parser->line_size += parser->cur_pos;
i_stream_skip(parser->input, parser->cur_pos);
parser->cur_pos = 0;
parser->cur_resp_text = FALS... | 282,878,349,993,740,670,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,568 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | void imap_parser_read_last_literal(struct imap_parser *parser)
{
ARRAY_TYPE(imap_arg_list) *list;
struct imap_arg *last_arg;
i_assert(parser->literal_size_return);
last_arg = imap_parser_get_last_literal_size(parser, &list);
i_assert(last_arg != NULL);
parser->cur_type = ARG_PARSE_LITERAL_DATA_FORCED;
i_asser... | 326,243,340,736,717,800,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,569 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | imap_parser_get_last_literal_size(struct imap_parser *parser,
ARRAY_TYPE(imap_arg_list) **list_r)
{
ARRAY_TYPE(imap_arg_list) *list;
struct imap_arg *args;
unsigned int count;
list = &parser->root_list;
args = array_get_modifiable(&parser->root_list, &count);
i_assert(count > 1 && args[count-1].type == IMA... | 284,639,138,411,113,250,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,570 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_literal_end(struct imap_parser *parser)
{
if (parser->literal_minus && parser->literal_nonsync &&
parser->literal_size > 4096) {
parser->error_msg = "Non-synchronizing literal size too large";
parser->error = IMAP_PARSE_ERROR_LITERAL_TOO_BIG;
return FALSE;
}
if ((parser->flags & IMAP... | 272,788,133,033,480,030,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,571 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | void imap_parser_set_streams(struct imap_parser *parser, struct istream *input,
struct ostream *output)
{
parser->input = input;
parser->output = output;
} | 46,396,166,046,001,860,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,572 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_read_text(struct imap_parser *parser,
const unsigned char *data, size_t data_size)
{
size_t i;
/* read until end of line */
for (i = parser->cur_pos; i < data_size; i++) {
if (is_linebreak(data[i])) {
imap_parser_save_arg(parser, data, i);
break;
}
}
parser->cur_pos = i;
r... | 35,562,712,466,678,310,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,573 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static void imap_parser_open_list(struct imap_parser *parser)
{
parser->list_arg = imap_arg_create(parser);
parser->list_arg->type = IMAP_ARG_LIST;
p_array_init(&parser->list_arg->_data.list, parser->pool,
LIST_INIT_COUNT);
parser->cur_list = &parser->list_arg->_data.list;
parser->cur_type = ARG_PARSE_NONE... | 219,112,497,624,941,300,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,574 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool is_valid_atom_char(struct imap_parser *parser, char chr)
{
const char *error_msg;
if (IS_ATOM_PARSER_INPUT((unsigned char)chr))
error_msg = "Invalid characters in atom";
else if ((chr & 0x80) != 0)
error_msg = "8bit data in atom";
else
return TRUE;
if ((parser->flags & IMAP_PARSE_FLAG_ATOM_ALLC... | 192,305,982,959,126,700,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,575 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | void imap_parser_ref(struct imap_parser *parser)
{
i_assert(parser->refcount > 0);
parser->refcount++;
} | 315,967,584,833,220,700,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,576 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | const char *imap_parser_get_error(struct imap_parser *parser,
enum imap_parser_error *error_r)
{
if (error_r != NULL)
*error_r = parser->error;
return parser->error_msg;
} | 181,593,857,815,981,500,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,577 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static bool imap_parser_read_arg(struct imap_parser *parser)
{
const unsigned char *data;
size_t data_size;
data = i_stream_get_data(parser->input, &data_size);
if (data_size == 0)
return FALSE;
while (parser->cur_type == ARG_PARSE_NONE) {
/* we haven't started parsing yet */
if (!imap_parser_skip_to_next(... | 48,223,828,509,466,500,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,578 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | static struct imap_arg *imap_arg_create(struct imap_parser *parser)
{
struct imap_arg *arg;
arg = array_append_space(parser->cur_list);
arg->parent = parser->list_arg;
return arg;
} | 180,912,585,630,515,220,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,579 | core | 85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/85fcb895ca7f0bcb8ee72047fe0e1e78532ff90b | lib-imap: Don't accept strings with NULs
IMAP doesn't allow NULs except in binary literals. We'll still allow them
in regular literals as well, but just not in strings.
This fixes a bug with unescaping a string with NULs: str_unescape() could
have been called for memory that points outside the allocated string,
causi... | 0 | void imap_parser_enable_literal_minus(struct imap_parser *parser)
{
parser->literal_minus = TRUE;
} | 139,783,917,460,888,000,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,580 | core | f904cbdfec25582bc5e2a7435bf82ff769f2526a | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/f904cbdfec25582bc5e2a7435bf82ff769f2526a | lib-imap: Make sure str_unescape() won't be writing past allocated memory
The previous commit should already prevent this, but this makes sure it
can't become broken in the future either. It makes the performance a tiny
bit worse, but that's not practically noticeable. | 0 | static void imap_parser_save_arg(struct imap_parser *parser,
const unsigned char *data, size_t size)
{
struct imap_arg *arg;
char *str;
arg = imap_arg_create(parser);
switch (parser->cur_type) {
case ARG_PARSE_ATOM:
case ARG_PARSE_TEXT:
if (size == 3 && i_memcasecmp(data, "NIL", 3) == 0) {
/* NIL argu... | 319,976,838,263,992,040,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2019-11500 | In Dovecot before 2.2.36.4 and 2.3.x before 2.3.7.2 (and Pigeonhole before 0.5.7.2), protocol processing can fail for quoted strings. This occurs because '\0' characters are mishandled, and can lead to out-of-bounds writes and remote code execution. | https://nvd.nist.gov/vuln/detail/CVE-2019-11500 |
505,581 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_integer_mode(const char *mode)
{
int value = strtoul(mode, NULL, 8) & 0xffff;
return value;
} | 318,258,450,652,516,460,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,582 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_read(ssh_scp scp, void *buffer, size_t size)
{
int rc;
int code;
if (scp == NULL) {
return SSH_ERROR;
}
if (scp->state == SSH_SCP_READ_REQUESTED &&
scp->request_type == SSH_SCP_REQUEST_NEWFILE)
{
rc = ssh_scp_accept_request(scp);
if (rc == SSH_ERROR)... | 55,419,881,446,372,925,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,583 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_accept_request(ssh_scp scp)
{
char buffer[] = {0x00};
int rc;
if (scp == NULL) {
return SSH_ERROR;
}
if (scp->state != SSH_SCP_READ_REQUESTED) {
ssh_set_error(scp->session, SSH_FATAL,
"ssh_scp_deny_request called under invalid state");
retur... | 67,955,651,066,700,800,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,584 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_close(ssh_scp scp)
{
char buffer[128] = {0};
int rc;
if (scp == NULL) {
return SSH_ERROR;
}
if (scp->channel != NULL) {
if (ssh_channel_send_eof(scp->channel) == SSH_ERROR) {
scp->state = SSH_SCP_ERROR;
return SSH_ERROR;
}
/* avoi... | 166,672,184,543,508,340,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,585 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_request_get_permissions(ssh_scp scp)
{
if (scp == NULL) {
return -1;
}
return scp->request_mode;
} | 304,447,508,298,524,420,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,586 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | const char *ssh_scp_request_get_warning(ssh_scp scp)
{
if (scp == NULL) {
return NULL;
}
return scp->warning;
} | 48,459,608,806,450,920,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,587 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | void ssh_scp_free(ssh_scp scp)
{
if (scp == NULL) {
return;
}
if (scp->state != SSH_SCP_NEW) {
ssh_scp_close(scp);
}
if (scp->channel) {
ssh_channel_free(scp->channel);
}
SAFE_FREE(scp->location);
SAFE_FREE(scp->request_name);
SAFE_FREE(scp->warning);
S... | 97,018,147,557,570,500,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,588 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_pull_request(ssh_scp scp)
{
char buffer[MAX_BUF_SIZE] = {0};
char *mode = NULL;
char *p, *tmp;
uint64_t size;
char *name = NULL;
int rc;
if (scp == NULL) {
return SSH_ERROR;
}
if (scp->state != SSH_SCP_READ_INITED) {
ssh_set_error(scp->session, SSH_FATAL... | 52,014,090,404,325,695,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,589 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | size_t ssh_scp_request_get_size(ssh_scp scp)
{
if (scp == NULL) {
return 0;
}
return (size_t)scp->filelen;
} | 70,834,663,746,371,980,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,590 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_deny_request(ssh_scp scp, const char *reason)
{
char buffer[MAX_BUF_SIZE] = {0};
int rc;
if (scp == NULL) {
return SSH_ERROR;
}
if (scp->state != SSH_SCP_READ_REQUESTED) {
ssh_set_error(scp->session, SSH_FATAL,
"ssh_scp_deny_request called under in... | 44,955,017,955,188,040,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,591 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | char *ssh_scp_string_mode(int mode)
{
char buffer[16] = {0};
snprintf(buffer, sizeof(buffer), "%.4o", mode);
return strdup(buffer);
} | 300,581,484,316,447,860,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,592 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | const char *ssh_scp_request_get_filename(ssh_scp scp)
{
if (scp == NULL) {
return NULL;
}
return scp->request_name;
} | 122,250,728,337,213,410,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,593 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_read_string(ssh_scp scp, char *buffer, size_t len)
{
size_t read = 0;
int err = SSH_OK;
if (scp == NULL) {
return SSH_ERROR;
}
while (read < len - 1) {
err = ssh_channel_read(scp->channel, &buffer[read], 1, 0);
if (err == SSH_ERROR) {
break;
... | 144,153,200,811,338,150,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,594 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | int ssh_scp_push_file(ssh_scp scp, const char *filename, size_t size, int mode)
{
return ssh_scp_push_file64(scp, filename, (uint64_t) size, mode);
} | 8,247,269,624,497,462,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,595 | libssh | 4aea835974996b2deb011024c53f4ff4329a95b5 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=4aea835974996b2deb011024c53f4ff4329a95b5 | CVE-2019-14889: scp: Reformat scp.c
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 42c727d0c186a1e2fa84a31ab40e16e58b404ab3) | 0 | uint64_t ssh_scp_request_get_size64(ssh_scp scp)
{
if (scp == NULL) {
return 0;
}
return scp->filelen;
} | 68,577,273,198,540,490,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,640 | libssh | 391c78de9d0f7baec3a44d86a76f4e1324eb9529 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=391c78de9d0f7baec3a44d86a76f4e1324eb9529 | CVE-2019-14889: scp: Don't allow file path longer than 32kb
Signed-off-by: Andreas Schneider <asn@cryptomilk.org>
Reviewed-by: Jakub Jelen <jjelen@redhat.com>
(cherry picked from commit 0b5ee397260b6e08dffa2c1ce515a153aaeda765) | 0 | ssh_scp ssh_scp_new(ssh_session session, int mode, const char *location)
{
ssh_scp scp = NULL;
if (session == NULL) {
goto error;
}
scp = (ssh_scp)calloc(1, sizeof(struct ssh_scp_struct));
if (scp == NULL) {
ssh_set_error(session, SSH_FATAL,
"Error allocating ... | 286,788,993,408,247,450,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,641 | libssh | b0edec4e8d01ad73b0d26ad4070d7e1a1e86dfc8 | http://git.libssh.org/projects/libssh | https://git.libssh.org/projects/libssh.git/commit/?h=stable-0.8&id=b0edec4e8d01ad73b0d26ad4070d7e1a1e86dfc8 | CVE-2019-14889: scp: Quote location to be used on shell
Single quote file paths to be used on commands to be executed on remote
shell.
Fixes T181
Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
(cherry picked from commit 3830c7ae6eec751b7618d3fc159cb... | 0 | int ssh_scp_init(ssh_scp scp)
{
int rc;
char execbuffer[1024] = {0};
char *quoted_location = NULL;
size_t quoted_location_len = 0;
size_t scp_location_len;
if (scp == NULL) {
return SSH_ERROR;
}
if (scp->state != SSH_SCP_NEW) {
ssh_set_error(scp->session, SSH_FATAL,
... | 227,630,105,393,865,700,000,000,000,000,000,000,000 | None | null | [
"CWE-78"
] | CVE-2019-14889 | A flaw was found with the libssh API function ssh_scp_new() in versions before 0.9.3 and before 0.8.8. When the libssh SCP client connects to a server, the scp command, which includes a user-provided path, is executed on the server-side. In case the library is used in a way where users can influence the third parameter... | https://nvd.nist.gov/vuln/detail/CVE-2019-14889 |
505,662 | core | 3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | lib-mail: message_snippet_generate() - Fix potential crash when input ends with '>'
This happens only when the mail was large enough and full enough with
whitespace that message-parser returned multiple blocks before the snippet
was finished.
Broken by 74063ed8219d055489d5233b0c02a59886d2078c | 0 | static bool snippet_generate(struct snippet_context *ctx,
const unsigned char *data, size_t size)
{
size_t i, count;
struct snippet_data *target = &ctx->snippet;
if (ctx->html2text != NULL) {
buffer_set_used_size(ctx->plain_output, 0);
mail_html2text_more(ctx->html2text, data, size,
ctx->plain_o... | 26,832,768,748,089,570,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2020-7957 | The IMAP and LMTP components in Dovecot 2.3.9 before 2.3.9.3 mishandle snippet generation when many characters must be read to compute the snippet and a trailing > character exists. This causes a denial of service in which the recipient cannot read all of their messages. | https://nvd.nist.gov/vuln/detail/CVE-2020-7957 |
505,663 | core | 3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | lib-mail: message_snippet_generate() - Fix potential crash when input ends with '>'
This happens only when the mail was large enough and full enough with
whitespace that message-parser returned multiple blocks before the snippet
was finished.
Broken by 74063ed8219d055489d5233b0c02a59886d2078c | 0 | static void snippet_add_content(struct snippet_context *ctx,
struct snippet_data *target,
const unsigned char *data, size_t size,
size_t *count_r)
{
i_assert(target != NULL);
if (size == 0)
return;
if (size >= 3 &&
((data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF) ||
(data[0] == 0xB... | 158,289,765,351,447,300,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2020-7957 | The IMAP and LMTP components in Dovecot 2.3.9 before 2.3.9.3 mishandle snippet generation when many characters must be read to compute the snippet and a trailing > character exists. This causes a denial of service in which the recipient cannot read all of their messages. | https://nvd.nist.gov/vuln/detail/CVE-2020-7957 |
505,664 | core | 3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | lib-mail: message_snippet_generate() - Fix potential crash when input ends with '>'
This happens only when the mail was large enough and full enough with
whitespace that message-parser returned multiple blocks before the snippet
was finished.
Broken by 74063ed8219d055489d5233b0c02a59886d2078c | 0 | int message_snippet_generate(struct istream *input,
unsigned int max_snippet_chars,
string_t *snippet)
{
struct message_parser_ctx *parser;
struct message_part *parts;
struct message_decoder_context *decoder;
struct message_block raw_block, block;
struct snippet_context ctx;
pool_t pool;
int ret;... | 301,907,181,787,416,550,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2020-7957 | The IMAP and LMTP components in Dovecot 2.3.9 before 2.3.9.3 mishandle snippet generation when many characters must be read to compute the snippet and a trailing > character exists. This causes a denial of service in which the recipient cannot read all of their messages. | https://nvd.nist.gov/vuln/detail/CVE-2020-7957 |
505,665 | core | 3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | https://github.com/LibreOffice/core | https://github.com/dovecot/core/commit/3a55f35c208b5fd3d52c0a6272bd5b8717a2ae54 | lib-mail: message_snippet_generate() - Fix potential crash when input ends with '>'
This happens only when the mail was large enough and full enough with
whitespace that message-parser returned multiple blocks before the snippet
was finished.
Broken by 74063ed8219d055489d5233b0c02a59886d2078c | 0 | static void snippet_copy(const char *src, string_t *dst)
{
while (*src != '\0' && i_isspace(*src)) src++;
str_append(dst, src);
} | 102,027,493,625,461,790,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2020-7957 | The IMAP and LMTP components in Dovecot 2.3.9 before 2.3.9.3 mishandle snippet generation when many characters must be read to compute the snippet and a trailing > character exists. This causes a denial of service in which the recipient cannot read all of their messages. | https://nvd.nist.gov/vuln/detail/CVE-2020-7957 |
505,962 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static uint16_t tls1_get_group_id(EVP_PKEY *pkey)
{
int curve_nid = evp_pkey_get_EC_KEY_curve_nid(pkey);
if (curve_nid == NID_undef)
return 0;
return tls1_nid2group_id(curve_nid);
} | 263,160,537,343,655,050,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,963 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int tls_choose_sigalg(SSL *s, int fatalerrs)
{
const SIGALG_LOOKUP *lu = NULL;
int sig_idx = -1;
s->s3.tmp.cert = NULL;
s->s3.tmp.sigalg = NULL;
if (SSL_IS_TLS13(s)) {
lu = find_sig_alg(s, NULL, NULL);
if (lu == NULL) {
if (!fatalerrs)
return 1;
... | 205,210,499,015,326,870,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,964 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int tls1_check_cert_param(SSL *s, X509 *x, int check_ee_md)
{
uint16_t group_id;
EVP_PKEY *pkey;
pkey = X509_get0_pubkey(x);
if (pkey == NULL)
return 0;
/* If not EC nothing to do */
if (!EVP_PKEY_is_a(pkey, "EC"))
return 1;
/* Check compression */
if (!tls1_check_... | 318,147,788,866,360,300,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,965 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu, const EVP_MD **pmd)
{
const EVP_MD *md;
if (lu == NULL)
return 0;
/* lu->hash == NID_undef means no associated digest */
if (lu->hash == NID_undef) {
md = NULL;
} else {
md = ssl_md(ctx, lu->hash_idx);
if (md =... | 161,986,694,791,642,040,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,966 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int rsa_pss_check_min_key_size(SSL_CTX *ctx, const EVP_PKEY *pkey,
const SIGALG_LOOKUP *lu)
{
const EVP_MD *md;
if (pkey == NULL)
return 0;
if (!tls1_lookup_md(ctx, lu, &md) || md == NULL)
return 0;
if (EVP_PKEY_size(pkey) < RSA_PSS_MINIMUM_K... | 4,826,100,013,626,186,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,967 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static const SIGALG_LOOKUP *find_sig_alg(SSL *s, X509 *x, EVP_PKEY *pkey)
{
const SIGALG_LOOKUP *lu = NULL;
size_t i;
#ifndef OPENSSL_NO_EC
int curve = -1;
#endif
EVP_PKEY *tmppkey;
/* Look for a shared sigalgs matching possible certificates */
for (i = 0; i < s->shared_sigalgslen; i++) {
... | 22,152,895,836,582,516,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,968 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int tls12_sigalg_allowed(const SSL *s, int op, const SIGALG_LOOKUP *lu)
{
unsigned char sigalgstr[2];
int secbits;
/* See if sigalgs is recognised and if hash is enabled */
if (!tls1_lookup_md(s->ctx, lu, NULL))
return 0;
/* DSA is not allowed in TLS 1.3 */
if (SSL_IS_TLS13(s) &&... | 249,668,181,734,865,620,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,969 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int tls12_check_peer_sigalg(SSL *s, uint16_t sig, EVP_PKEY *pkey)
{
const uint16_t *sent_sigs;
const EVP_MD *md = NULL;
char sigalgstr[2];
size_t sent_sigslen, i, cidx;
int pkeyid = -1;
const SIGALG_LOOKUP *lu;
int secbits = 0;
/*
* TODO(3.0) Remove this when we adapted this functi... | 68,917,828,408,773,760,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,970 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int tls1_check_pkey_comp(SSL *s, EVP_PKEY *pkey)
{
const EC_KEY *ec;
const EC_GROUP *grp;
unsigned char comp_id;
size_t i;
/* If not an EC key nothing to check */
if (!EVP_PKEY_is_a(pkey, "EC"))
return 1;
ec = EVP_PKEY_get0_EC_KEY(pkey);
grp = EC_KEY_get0_group(ec);
... | 324,573,118,036,190,850,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,971 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | EVP_MAC_CTX *ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC *ctx)
{
return ctx->ctx;
} | 214,472,399,383,682,900,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,972 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
{
const X509_NAME *nm;
int i;
nm = X509_get_issuer_name(x);
for (i = 0; i < sk_X509_NAME_num(names); i++) {
if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
return 1;
}
return 0;
} | 118,490,500,274,426,000,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,973 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | size_t ssl_hmac_size(const SSL_HMAC *ctx)
{
if (ctx->ctx != NULL)
return EVP_MAC_size(ctx->ctx);
#ifndef OPENSSL_NO_DEPRECATED_3_0
if (ctx->old_ctx != NULL)
return HMAC_size(ctx->old_ctx);
#endif
return 0;
} | 61,807,478,901,603,970,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,974 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
int idx)
{
int i;
int rv = 0;
int check_flags = 0, strict_mode;
CERT_PKEY *cpk = NULL;
CERT *c = s->cert;
uint32_t *pvalid;
unsigned int suiteb_flags = tls1_suiteb(s);
/* idx == -1 means check... | 74,894,089,126,595,620,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,975 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int sigalg_security_bits(SSL_CTX *ctx, const SIGALG_LOOKUP *lu)
{
const EVP_MD *md = NULL;
int secbits = 0;
if (!tls1_lookup_md(ctx, lu, &md))
return 0;
if (md != NULL)
{
/* Security bits: half digest bits */
secbits = EVP_MD_size(md) * 4;
} else {
/* Valu... | 45,856,209,907,915,180,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,976 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | SSL_TICKET_STATUS tls_decrypt_ticket(SSL *s, const unsigned char *etick,
size_t eticklen, const unsigned char *sess_id,
size_t sesslen, SSL_SESSION **psess)
{
SSL_SESSION *sess = NULL;
unsigned char *sdec;
const unsigned char *p;
... | 45,822,024,250,980,200,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,977 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | void ssl_hmac_free(SSL_HMAC *ctx)
{
if (ctx != NULL) {
EVP_MAC_CTX_free(ctx->ctx);
#ifndef OPENSSL_NO_DEPRECATED_3_0
HMAC_CTX_free(ctx->old_ctx);
#endif
OPENSSL_free(ctx);
}
} | 295,171,203,310,948,770,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,978 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int tls1_check_sig_alg(SSL *s, X509 *x, int default_nid)
{
int sig_nid, use_pc_sigalgs = 0;
size_t i;
const SIGALG_LOOKUP *sigalg;
size_t sigalgslen;
if (default_nid == -1)
return 1;
sig_nid = X509_get_signature_nid(x);
if (default_nid)
return sig_nid == default_nid ? ... | 197,374,734,987,327,100,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,979 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL *s, int idx)
{
if (idx == -1) {
if (s->server) {
size_t i;
/* Work out index corresponding to ciphersuite */
for (i = 0; i < SSL_PKEY_NUM; i++) {
const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_... | 97,222,655,921,228,930,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,980 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int ssl_hmac_update(SSL_HMAC *ctx, const unsigned char *data, size_t len)
{
if (ctx->ctx != NULL)
return EVP_MAC_update(ctx->ctx, data, len);
#ifndef OPENSSL_NO_DEPRECATED_3_0
if (ctx->old_ctx != NULL)
return HMAC_Update(ctx->old_ctx, data, len);
#endif
return 0;
} | 75,013,274,690,491,400,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,981 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | static int check_cert_usable(SSL *s, const SIGALG_LOOKUP *sig, X509 *x,
EVP_PKEY *pkey)
{
const SIGALG_LOOKUP *lu;
int mdnid, pknid, supported;
size_t i;
/*
* If the given EVP_PKEY cannot supporting signing with this sigalg,
* the answer is simply 'no'.
*/
... | 96,666,268,143,793,830,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,982 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int ssl_hmac_final(SSL_HMAC *ctx, unsigned char *md, size_t *len,
size_t max_size)
{
if (ctx->ctx != NULL)
return EVP_MAC_final(ctx->ctx, md, len, max_size);
#ifndef OPENSSL_NO_DEPRECATED_3_0
if (ctx->old_ctx != NULL) {
unsigned int l;
if (HMAC_Final(ctx->old_ctx, md,... | 91,135,888,337,241,510,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,983 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int ssl_cipher_disabled(const SSL *s, const SSL_CIPHER *c, int op, int ecdhe)
{
if (c->algorithm_mkey & s->s3.tmp.mask_k
|| c->algorithm_auth & s->s3.tmp.mask_a)
return 1;
if (s->s3.tmp.max_ver == 0)
return 1;
if (!SSL_IS_DTLS(s)) {
int min_tls = c->min_tls;
/*
... | 183,513,078,114,465,540,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,984 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | int ssl_hmac_init(SSL_HMAC *ctx, void *key, size_t len, char *md)
{
OSSL_PARAM params[3], *p = params;
if (ctx->ctx != NULL) {
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, md, 0);
*p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, key, len);
*p = OSSL_PARAM_c... | 32,644,340,184,566,196,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,985 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx)
{
SSL_HMAC *ret = OPENSSL_zalloc(sizeof(*ret));
EVP_MAC *mac = NULL;
if (ret == NULL)
return NULL;
#ifndef OPENSSL_NO_DEPRECATED_3_0
if (ctx->ext.ticket_key_evp_cb == NULL
&& ctx->ext.ticket_key_cb != NULL) {
ret->old_ctx = HMAC_CTX... | 119,372,755,294,815,680,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
505,986 | openssl | a87f3fe01a5a894aa27ccd6a239155fd129988e4 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/a87f3fe01a5a894aa27ccd6a239155fd129988e4 | Fix NULL dereference in SSL_check_chain() for TLS 1.3
In the tls1_check_sig_alg() helper function, we loop through the list of
"signature_algorithms_cert" values received from the client and attempt
to look up each one in turn in our internal table that maps wire
codepoint to string-form name, digest and/or signature ... | 0 | HMAC_CTX *ssl_hmac_get0_HMAC_CTX(SSL_HMAC *ctx)
{
return ctx->old_ctx;
} | 101,353,045,994,224,240,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1967 | Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from t... | https://nvd.nist.gov/vuln/detail/CVE-2020-1967 |
506,632 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | int ASN1_item_ndef_i2d(const ASN1_VALUE *val, unsigned char **out,
const ASN1_ITEM *it)
{
return asn1_item_flags_i2d(val, out, it, ASN1_TFLG_NDEF);
} | 263,242,477,737,862,200,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
506,633 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | int ASN1_item_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
const ASN1_ITEM *it, int tag, int aclass)
{
const ASN1_TEMPLATE *tt = NULL;
int i, seqcontlen, seqlen, ndef = 1;
const ASN1_EXTERN_FUNCS *ef;
const ASN1_AUX *aux = it->funcs;
ASN1_aux_const_cb *asn1_cb = NULL;
... | 218,749,472,589,691,270,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
506,634 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | static int asn1_ex_i2c(const ASN1_VALUE **pval, unsigned char *cout, int *putype,
const ASN1_ITEM *it)
{
ASN1_BOOLEAN *tbool = NULL;
ASN1_STRING *strtmp;
ASN1_OBJECT *otmp;
int utype;
const unsigned char *cont;
unsigned char c;
int len;
const ASN1_PRIMITIVE_FUNCS *... | 271,566,255,452,932,500,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
506,635 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | int ASN1_item_i2d(const ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it)
{
return asn1_item_flags_i2d(val, out, it, 0);
} | 48,229,332,611,619,910,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
506,636 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | static int asn1_item_flags_i2d(const ASN1_VALUE *val, unsigned char **out,
const ASN1_ITEM *it, int flags)
{
if (out != NULL && *out == NULL) {
unsigned char *p, *buf;
int len;
len = ASN1_item_ex_i2d(&val, NULL, it, -1, flags);
if (len <= 0)
... | 280,021,383,143,881,660,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
506,637 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | static int asn1_i2d_ex_primitive(const ASN1_VALUE **pval, unsigned char **out,
const ASN1_ITEM *it, int tag, int aclass)
{
int len;
int utype;
int usetag;
int ndef = 0;
utype = it->utype;
/*
* Get length of content octets and maybe find out the underlying ... | 267,605,154,769,951,700,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
506,638 | openssl | 3db2c9f3e5fb9f649ebb4a55918398756310af43 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/3db2c9f3e5fb9f649ebb4a55918398756310af43 | Complain if we are attempting to encode with an invalid ASN.1 template
It never makes sense for multi-string or CHOICE types to have implicit
tagging. If we have a template that uses the in this way then we
should immediately fail.
Thanks to David Benjamin from Google for reporting this issue.
Reviewed-by: Tomas Mra... | 0 | static int asn1_template_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
const ASN1_TEMPLATE *tt, int tag, int iclass)
{
int i, ret, flags, ttag, tclass, ndef;
const ASN1_VALUE *tval;
flags = tt->flags;
/*
* If field is embedded then val needs fixing so it is a... | 7,897,630,637,200,756,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2020-1971 | The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL... | https://nvd.nist.gov/vuln/detail/CVE-2020-1971 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.