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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
37,541 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
enum dma_data_direction data_direction)
{
struct se_device *se_dev = cmd->se_dev;
struct rd_dev *dev = RD_DEV(se_dev);
struct rd_dev_sg_table *table;
struct scatterlist *rd_sg;
struct sg_mapping_iter m;
u32 rd_offset;
u32 rd_size;
... | 255,021,081,405,958,700,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,542 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | static void rd_free_device(struct se_device *dev)
{
struct rd_dev *rd_dev = RD_DEV(dev);
rd_release_device_space(rd_dev);
kfree(rd_dev);
}
| 102,188,266,503,377,490,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,543 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | static sector_t rd_get_blocks(struct se_device *dev)
{
struct rd_dev *rd_dev = RD_DEV(dev);
unsigned long long blocks_long = ((rd_dev->rd_page_count * PAGE_SIZE) /
dev->dev_attrib.block_size) - 1;
return blocks_long;
}
| 339,376,310,680,856,380,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,544 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
{
struct rd_dev_sg_table *sg_table;
u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
sizeof(struct scatterlist));
i = page / sg_per_table;
if (i < rd_dev->sg_table_count) {
sg_table = &rd_dev->sg_table_array[i];
if ((sg_table->p... | 167,037,970,406,511,320,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,545 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | void rd_module_exit(void)
{
transport_subsystem_release(&rd_mcp_template);
}
| 154,987,111,264,879,770,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,546 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | int __init rd_module_init(void)
{
int ret;
ret = transport_subsystem_register(&rd_mcp_template);
if (ret < 0) {
return ret;
}
return 0;
}
| 289,530,867,964,366,360,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,547 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | rd_parse_cdb(struct se_cmd *cmd)
{
return sbc_parse_cdb(cmd, &rd_sbc_ops);
}
| 327,337,006,573,987,740,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,548 | linux | 4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4442dc8a92b8f9ad8ee9e7f8438f4c04c03a22dc | target/rd: Refactor rd_build_device_space + rd_release_device_space
This patch refactors rd_build_device_space() + rd_release_device_space()
into rd_allocate_sgl_table() + rd_release_device_space() so that they
may be used seperatly for setup + release of protection information
scatterlists.
Also add explicit memset ... | 0 | static ssize_t rd_show_configfs_dev_params(struct se_device *dev, char *b)
{
struct rd_dev *rd_dev = RD_DEV(dev);
ssize_t bl = sprintf(b, "TCM RamDisk ID: %u RamDisk Makeup: rd_mcp\n",
rd_dev->rd_dev_id);
bl += sprintf(b + bl, " PAGES/PAGE_SIZE: %u*%lu"
" SG_table_count: %u nullio: %d\n", rd_dev->rd... | 128,897,410,130,952,300,000,000,000,000,000,000,000 | target_core_rd.c | 66,009,037,141,069,600,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-4027 | The rd_build_device_space function in drivers/target/target_core_rd.c in the Linux kernel before 3.14 does not properly initialize a certain data structure, which allows local users to obtain sensitive information from ramdisk_mcp memory by leveraging access to a SCSI initiator. | https://nvd.nist.gov/vuln/detail/CVE-2014-4027 |
37,656 | miniupnp | 3a87aa2f10bd7f1408e1849bdb59c41dd63a9fe9 | https://github.com/miniupnp/miniupnp | https://github.com/miniupnp/miniupnp/commit/3a87aa2f10bd7f1408e1849bdb59c41dd63a9fe9 | miniwget.c: fixed potential buffer overrun | 0 | miniwget2(const char * host,
unsigned short port, const char * path,
int * size, char * addr_str, int addr_str_len,
unsigned int scope_id)
{
char * respbuffer;
#if 1
respbuffer = miniwget3(host, port, path, size,
addr_str, addr_str_len, "1.1", scope_id);
#else
respbuffer = ... | 255,428,998,374,450,360,000,000,000,000,000,000,000 | miniwget.c | 168,853,020,666,456,580,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3985 | The getHTTPResponse function in miniwget.c in MiniUPnP 1.9 allows remote attackers to cause a denial of service (crash) via crafted headers that trigger an out-of-bounds read. | https://nvd.nist.gov/vuln/detail/CVE-2014-3985 |
37,657 | miniupnp | 3a87aa2f10bd7f1408e1849bdb59c41dd63a9fe9 | https://github.com/miniupnp/miniupnp | https://github.com/miniupnp/miniupnp/commit/3a87aa2f10bd7f1408e1849bdb59c41dd63a9fe9 | miniwget.c: fixed potential buffer overrun | 0 | miniwget3(const char * host,
unsigned short port, const char * path,
int * size, char * addr_str, int addr_str_len,
const char * httpversion, unsigned int scope_id)
{
char buf[2048];
int s;
int n;
int len;
int sent;
void * content;
*size = 0;
s = connecthostport(host, port, sco... | 27,746,057,358,055,235,000,000,000,000,000,000,000 | miniwget.c | 168,853,020,666,456,580,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3985 | The getHTTPResponse function in miniwget.c in MiniUPnP 1.9 allows remote attackers to cause a denial of service (crash) via crafted headers that trigger an out-of-bounds read. | https://nvd.nist.gov/vuln/detail/CVE-2014-3985 |
37,658 | miniupnp | 3a87aa2f10bd7f1408e1849bdb59c41dd63a9fe9 | https://github.com/miniupnp/miniupnp | https://github.com/miniupnp/miniupnp/commit/3a87aa2f10bd7f1408e1849bdb59c41dd63a9fe9 | miniwget.c: fixed potential buffer overrun | 0 | parseURL(const char * url,
char * hostname, unsigned short * port,
char * * path, unsigned int * scope_id)
{
char * p1, *p2, *p3;
if(!url)
return 0;
p1 = strstr(url, "://");
if(!p1)
return 0;
p1 += 3;
if( (url[0]!='h') || (url[1]!='t')
||(url[2]!='t') || (url[3]!='p'))
return 0;
mems... | 197,502,045,390,166,740,000,000,000,000,000,000,000 | miniwget.c | 168,853,020,666,456,580,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3985 | The getHTTPResponse function in miniwget.c in MiniUPnP 1.9 allows remote attackers to cause a denial of service (crash) via crafted headers that trigger an out-of-bounds read. | https://nvd.nist.gov/vuln/detail/CVE-2014-3985 |
37,678 | file | 39c7ac1106be844a5296d3eb5971946cc09ffda0 | https://github.com/file/file | https://github.com/file/file/commit/39c7ac1106be844a5296d3eb5971946cc09ffda0 | Fix note bounds reading, Francisco Alonso / Red Hat | 0 | doshn(struct magic_set *ms, int clazz, int swap, int fd, off_t off, int num,
size_t size, off_t fsize, int *flags, int mach, int strtab)
{
Elf32_Shdr sh32;
Elf64_Shdr sh64;
int stripped = 1;
void *nbuf;
off_t noff, coff, name_off;
uint64_t cap_hw1 = 0; /* SunOS 5.x hardware capabilites */
uint64_t cap_sf1 = ... | 225,188,763,281,300,480,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3710 | The donote function in readelf.c in file through 5.20, as used in the Fileinfo component in PHP 5.4.34, does not ensure that sufficient note headers are present, which allows remote attackers to cause a denial of service (out-of-bounds read and application crash) via a crafted ELF file. | https://nvd.nist.gov/vuln/detail/CVE-2014-3710 |
37,973 | linux | d974baa398f34393db76be45f7d4d04fbdbb4a0a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d974baa398f34393db76be45f7d4d04fbdbb4a0a | x86,kvm,vmx: Preserve CR4 across VM entry
CR4 isn't constant; at least the TSD and PCE bits can vary.
TBH, treating CR0 and CR3 as constant scares me a bit, too, but it looks
like it's correct.
This adds a branch and a read from cr4 to each vm entry. Because it is
extremely likely that consecutive entries into the ... | 0 | static int vmx_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
{
struct vcpu_vmx *vmx = to_vmx(vcpu);
struct shared_msr_entry *msr;
int ret = 0;
u32 msr_index = msr_info->index;
u64 data = msr_info->data;
switch (msr_index) {
case MSR_EFER:
ret = kvm_set_msr_common(vcpu, msr_info);
break;
#ifdef C... | 283,199,806,263,742,760,000,000,000,000,000,000,000 | vmx.c | 315,703,567,300,192,370,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3690 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.17.2 on Intel processors does not ensure that the value in the CR4 control register remains the same after a VM entry, which allows host OS users to kill arbitrary processes or cause a denial of service (system disruption) by leveraging /dev/kvm acces... | https://nvd.nist.gov/vuln/detail/CVE-2014-3690 |
37,994 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | void sctp_inq_init(struct sctp_inq *queue)
{
INIT_LIST_HEAD(&queue->in_chunk_list);
queue->in_progress = NULL;
/* Create a task for delivering data. */
INIT_WORK(&queue->immediate, NULL);
}
| 205,014,922,212,023,980,000,000,000,000,000,000,000 | inqueue.c | 11,503,476,439,811,367,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
37,995 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | void sctp_inq_push(struct sctp_inq *q, struct sctp_chunk *chunk)
{
/* Directly call the packet handling routine. */
if (chunk->rcvr->dead) {
sctp_chunk_free(chunk);
return;
}
/* We are now calling this either from the soft interrupt
* or from the backlog processing.
* Eventually, we should clean up inqueue... | 15,271,922,335,776,912,000,000,000,000,000,000,000 | inqueue.c | 11,503,476,439,811,367,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
37,996 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | void sctp_inq_set_th_handler(struct sctp_inq *q, work_func_t callback)
{
INIT_WORK(&q->immediate, callback);
}
| 173,663,010,435,496,550,000,000,000,000,000,000,000 | inqueue.c | 11,503,476,439,811,367,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
37,997 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | static int sctp_eat_data(const struct sctp_association *asoc,
struct sctp_chunk *chunk,
sctp_cmd_seq_t *commands)
{
sctp_datahdr_t *data_hdr;
struct sctp_chunk *err;
size_t datalen;
sctp_verb_t deliver;
int tmp;
__u32 tsn;
struct sctp_tsnmap *map = (struct sctp_tsnmap *)&asoc->peer.tsn_map;
struct sock ... | 95,930,824,469,945,800,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
37,998 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_backbeat_8_3(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
union sctp_addr from_addr;
struct sctp_transport *link;
sctp_sender... | 232,162,853,692,940,050,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
37,999 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_discard_chunk(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
/* Make sure that the chunk has a valid length.
* Since we d... | 159,313,609,288,245,900,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,000 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_5_1B_init(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
struct sctp_chunk *repl;
struct sctp_association *new_asoc;
struct ... | 89,509,939,460,831,150,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,001 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_5_1C_ack(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
sctp_init_chunk_t *initchunk;
struct sc... | 237,869,475,859,392,860,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,002 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_5_1D_ce(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type, void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
struct sctp_association *new_asoc;
sctp_init_chunk_t *p... | 210,299,237,016,740,100,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,003 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_5_1E_ca(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type, void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
struct sctp_ulpevent *ev;
if (!sctp_vtag_verify(chunk,... | 263,685,091,354,630,900,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,004 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_5_2_4_dupcook(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
sctp_disposition_t retval;
struct sctp_chunk *chunk = arg;
struct sctp_association *new_asoc;
i... | 75,873,903,088,758,885,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,005 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_9_2_shut_ctsn(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
sctp_shutdownhdr_t *sdh;
__u32 ctsn;
if (!sctp_... | 330,606,868,377,731,370,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,006 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_9_2_shutdown(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
sctp_shutdownhdr_t *sdh;
sctp_disposition_t dispos... | 149,492,724,083,754,930,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,007 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_9_2_shutdown_ack(
struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = (struct sctp_chunk *) arg;
struct sctp_chunk *reply;
/* There are 2 ways of getting... | 36,605,907,622,466,753,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,008 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_9_2_start_shutdown(
struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *reply;
/* Once all its outstanding data has been acknowledged, the
* endpoint shall send... | 31,407,129,050,817,397,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,009 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_asconf(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type, void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
struct sctp_chunk *asconf_ack = NULL;
struct sctp_paramhdr *... | 315,914,797,679,923,550,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,010 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_asconf_ack(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type, void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *asconf_ack = arg;
struct sctp_chunk *last_asconf = asoc->addip_last_asconf;
struc... | 156,216,323,015,951,360,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,011 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | static sctp_disposition_t sctp_sf_do_dupcook_a(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
struct sctp_chunk *chunk,
sctp_cmd_seq_t *commands,
struct sctp_association *new_asoc)
{
sctp_init_chunk_t *peer_init;
struct sctp_ulpevent *ev;
struct sctp_ch... | 147,824,624,301,094,430,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,012 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_do_prm_asoc(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *repl;
struct sctp_association *my_asoc;
/* The comm... | 13,501,279,723,767,222,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,013 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | static sctp_disposition_t sctp_sf_do_unexpected_init(
struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg, sctp_cmd_seq_t *commands)
{
sctp_disposition_t retval;
struct sctp_chunk *chunk = arg;
struct sctp_chunk *repl;
struct sctp_associati... | 272,159,885,638,657,630,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,014 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_eat_data_6_2(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
sctp_arg_t force = SCTP_NOFORCE();
int error;
if (!sctp_vtag_verif... | 226,584,659,995,183,440,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,015 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_eat_fwd_tsn_fast(
struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
struct sctp_fwdtsn_hdr *fwdtsn_hdr;
struct sctp_fwdtsn_skip *skip;
__u16 len;
__... | 150,524,172,313,385,680,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,016 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_eat_sack_6_2(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *chunk = arg;
sctp_sackhdr_t *sackh;
__u32 ctsn;
if (!sctp_vtag_verify(chunk, as... | 263,599,324,964,814,330,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,017 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_ignore_other(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
pr_debug("%s: the event other type:%d is ignored\n",
__func__, type.other);
return SCTP_DISPOSITI... | 52,848,089,191,586,690,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,018 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_t1_cookie_timer_expire(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *repl = NULL;
int attempts = asoc->init_err_counter + 1;
... | 37,809,147,695,007,534,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,019 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_t1_init_timer_expire(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *repl = NULL;
struct sctp_bind_addr *bp;
int attempts = aso... | 159,390,631,340,977,000,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,020 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_t2_timer_expire(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *reply = NULL;
pr_debug("%s: timer T2 expired\n", __func__);
S... | 62,403,437,612,136,700,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,021 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_t5_timer_expire(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *reply = NULL;
pr_debug("%s: timer T5 expired\n", __func__);
S... | 115,455,934,298,699,370,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,022 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_timer_ignore(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
pr_debug("%s: timer %d ignored\n", __func__, type.chunk);
return SCTP_DISPOSITION_CONSUME;
}
| 32,656,150,131,069,315,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,023 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | sctp_disposition_t sctp_sf_unk_chunk(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *unk_chunk = arg;
struct sctp_chunk *err_chunk;
sctp_chunkhdr_t *... | 36,960,923,684,855,626,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,024 | linux | 26b87c7881006311828bb0ab271a551a62dcceb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/26b87c7881006311828bb0ab271a551a62dcceb4 | net: sctp: fix remote memory pressure from excessive queueing
This scenario is not limited to ASCONF, just taken as one
example triggering the issue. When receiving ASCONF probes
in the form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
----... | 0 | static sctp_disposition_t sctp_stop_t1_and_abort(struct net *net,
sctp_cmd_seq_t *commands,
__be16 error, int sk_err,
const struct sctp_association *asoc,
struct sctp_transport *transport)
{
pr_debug("%s: ABORT received (INIT)\n", __func__);
sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STAT... | 32,091,966,003,283,210,000,000,000,000,000,000,000 | sm_statefuns.c | 31,622,376,965,952,573,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3688 | The SCTP implementation in the Linux kernel before 3.17.4 allows remote attackers to cause a denial of service (memory consumption) by triggering a large number of chunks in an association's output queue, as demonstrated by ASCONF probes, related to net/sctp/inqueue.c and net/sctp/sm_statefuns.c. | https://nvd.nist.gov/vuln/detail/CVE-2014-3688 |
38,025 | linux | b69040d8e39f20d5215a03502a8e8b4c6ab78395 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b69040d8e39f20d5215a03502a8e8b4c6ab78395 | net: sctp: fix panic on duplicate ASCONF chunks
When receiving a e.g. semi-good formed connection scan in the
form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
-------------------- COOKIE-ECHO -------------------->
<-------------------- C... | 0 | void sctp_assoc_control_transport(struct sctp_association *asoc,
struct sctp_transport *transport,
sctp_transport_cmd_t command,
sctp_sn_error_t error)
{
struct sctp_ulpevent *event;
struct sockaddr_storage addr;
int spc_state = 0;
bool ulp_notify = true;
/* Record the transition on the transpor... | 184,146,756,117,001,800,000,000,000,000,000,000,000 | associola.c | 137,893,471,795,738,340,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3687 | The sctp_assoc_lookup_asconf_ack function in net/sctp/associola.c in the SCTP implementation in the Linux kernel through 3.17.2 allows remote attackers to cause a denial of service (panic) via duplicate ASCONF chunks that trigger an incorrect uncork within the side-effect interpreter. | https://nvd.nist.gov/vuln/detail/CVE-2014-3687 |
38,026 | linux | b69040d8e39f20d5215a03502a8e8b4c6ab78395 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b69040d8e39f20d5215a03502a8e8b4c6ab78395 | net: sctp: fix panic on duplicate ASCONF chunks
When receiving a e.g. semi-good formed connection scan in the
form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
-------------------- COOKIE-ECHO -------------------->
<-------------------- C... | 0 | static void sctp_select_active_and_retran_path(struct sctp_association *asoc)
{
struct sctp_transport *trans, *trans_pri = NULL, *trans_sec = NULL;
struct sctp_transport *trans_pf = NULL;
/* Look for the two most recently used active transports. */
list_for_each_entry(trans, &asoc->peer.transport_addr_list,
... | 303,657,509,911,242,700,000,000,000,000,000,000,000 | associola.c | 137,893,471,795,738,340,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3687 | The sctp_assoc_lookup_asconf_ack function in net/sctp/associola.c in the SCTP implementation in the Linux kernel through 3.17.2 allows remote attackers to cause a denial of service (panic) via duplicate ASCONF chunks that trigger an incorrect uncork within the side-effect interpreter. | https://nvd.nist.gov/vuln/detail/CVE-2014-3687 |
38,027 | linux | b69040d8e39f20d5215a03502a8e8b4c6ab78395 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b69040d8e39f20d5215a03502a8e8b4c6ab78395 | net: sctp: fix panic on duplicate ASCONF chunks
When receiving a e.g. semi-good formed connection scan in the
form of ...
-------------- INIT[ASCONF; ASCONF_ACK] ------------->
<----------- INIT-ACK[ASCONF; ASCONF_ACK] ------------
-------------------- COOKIE-ECHO -------------------->
<-------------------- C... | 0 | static struct sctp_transport *sctp_trans_elect_best(struct sctp_transport *curr,
struct sctp_transport *best)
{
u8 score_curr, score_best;
if (best == NULL || curr == best)
return curr;
score_curr = sctp_trans_score(curr);
score_best = sctp_trans_score(best);
/* First, try a score-based selection if... | 298,410,808,661,434,640,000,000,000,000,000,000,000 | associola.c | 137,893,471,795,738,340,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-3687 | The sctp_assoc_lookup_asconf_ack function in net/sctp/associola.c in the SCTP implementation in the Linux kernel through 3.17.2 allows remote attackers to cause a denial of service (panic) via duplicate ASCONF chunks that trigger an incorrect uncork within the side-effect interpreter. | https://nvd.nist.gov/vuln/detail/CVE-2014-3687 |
38,031 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool __check_direct_spte_mmio_pf(u64 spte)
{
/* It is valid if the spte is zapped. */
return spte == 0ull;
}
| 248,500,789,561,139,440,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,032 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void __clear_sp_write_flooding_count(struct kvm_mmu_page *sp)
{
sp->write_flooding_count = 0;
}
| 240,154,145,691,896,600,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,033 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int __direct_map(struct kvm_vcpu *vcpu, gpa_t v, int write,
int map_writable, int level, gfn_t gfn, pfn_t pfn,
bool prefault)
{
struct kvm_shadow_walk_iterator iterator;
struct kvm_mmu_page *sp;
int emulate = 0;
gfn_t pseudo_gfn;
for_each_shadow_entry(vcpu, (u64)gfn << PAGE_SHIFT, iterator) {
if (i... | 212,393,676,382,388,020,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,034 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void __direct_pte_prefetch(struct kvm_vcpu *vcpu,
struct kvm_mmu_page *sp, u64 *sptep)
{
u64 *spte, *start = NULL;
int i;
WARN_ON(!sp->role.direct);
i = (sptep - sp->spt) & ~(PTE_PREFETCH_NUM - 1);
spte = sp->spt + i;
for (i = 0; i < PTE_PREFETCH_NUM; i++, spte++) {
if (is_shadow_present_pte(*sp... | 130,986,813,981,003,560,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,035 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static u64 __get_spte_lockless(u64 *sptep)
{
return ACCESS_ONCE(*sptep);
}
| 277,284,414,278,620,250,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,036 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static unsigned long *__gfn_to_rmap(gfn_t gfn, int level,
struct kvm_memory_slot *slot)
{
unsigned long idx;
idx = gfn_to_index(gfn, slot->base_gfn, level);
return &slot->arch.rmap[level - PT_PAGE_TABLE_LEVEL][idx];
}
| 292,118,105,147,603,160,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,037 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int __kvm_sync_page(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
struct list_head *invalid_list, bool clear_unsync)
{
if (sp->role.cr4_pae != !!is_pae(vcpu)) {
kvm_mmu_prepare_zap_page(vcpu->kvm, sp, invalid_list);
return 1;
}
if (clear_unsync)
kvm_unlink_unsync_page(vcpu->kvm, sp);
if (vcpu... | 161,850,537,992,205,000,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,038 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void __kvm_unsync_page(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
{
trace_kvm_mmu_unsync_page(sp);
++vcpu->kvm->stat.mmu_unsync;
sp->unsync = 1;
kvm_mmu_mark_parents_unsync(sp);
}
| 322,492,519,354,015,440,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,039 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int __mmu_unsync_walk(struct kvm_mmu_page *sp,
struct kvm_mmu_pages *pvec)
{
int i, ret, nr_unsync_leaf = 0;
for_each_set_bit(i, sp->unsync_child_bitmap, 512) {
struct kvm_mmu_page *child;
u64 ent = sp->spt[i];
if (!is_shadow_present_pte(ent) || is_large_pte(ent))
goto clear_child_bitmap;
c... | 35,722,145,574,111,480,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,040 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool __rmap_write_protect(struct kvm *kvm, unsigned long *rmapp,
bool pt_protect)
{
u64 *sptep;
struct rmap_iterator iter;
bool flush = false;
for (sptep = rmap_get_first(*rmapp, &iter); sptep;) {
BUG_ON(!(*sptep & PT_PRESENT_MASK));
if (spte_write_protect(kvm, sptep, &flush, pt_protect)) {
spte... | 329,067,637,804,000,560,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,041 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void __set_spte(u64 *sptep, u64 spte)
{
*sptep = spte;
}
| 67,757,986,505,352,800,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,042 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void __set_spte(u64 *sptep, u64 spte)
{
union split_spte *ssptep, sspte;
ssptep = (union split_spte *)sptep;
sspte = (union split_spte)spte;
ssptep->spte_high = sspte.spte_high;
/*
* If we map the spte from nonpresent to present, We should store
* the high bits firstly, then set present bit, so cpu c... | 43,925,077,818,108,420,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,043 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void __update_clear_spte_fast(u64 *sptep, u64 spte)
{
union split_spte *ssptep, sspte;
ssptep = (union split_spte *)sptep;
sspte = (union split_spte)spte;
ssptep->spte_low = sspte.spte_low;
/*
* If we map the spte from present to nonpresent, we should clear
* present bit firstly to avoid vcpu fetch t... | 60,032,882,171,435,300,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,044 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static u64 __update_clear_spte_slow(u64 *sptep, u64 spte)
{
return xchg(sptep, spte);
}
| 280,090,140,425,491,720,000,000,000,000,000,000,000 | mmu.c | 71,266,076,254,608,070,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,045 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static u64 __update_clear_spte_slow(u64 *sptep, u64 spte)
{
union split_spte *ssptep, sspte, orig;
ssptep = (union split_spte *)sptep;
sspte = (union split_spte)spte;
/* xchg acts as a barrier before the setting of the high bits */
orig.spte_low = xchg(&ssptep->spte_low, sspte.spte_low);
orig.spte_high = ssptep... | 335,932,805,211,230,640,000,000,000,000,000,000,000 | mmu.c | 71,266,076,254,608,070,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,046 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool can_do_async_pf(struct kvm_vcpu *vcpu)
{
if (unlikely(!irqchip_in_kernel(vcpu->kvm) ||
kvm_event_needs_reinjection(vcpu)))
return false;
return kvm_x86_ops->interrupt_allowed(vcpu);
}
| 181,011,099,466,718,560,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,047 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool check_mmio_spte(struct kvm *kvm, u64 spte)
{
unsigned int kvm_gen, spte_gen;
kvm_gen = kvm_current_mmio_generation(kvm);
spte_gen = get_mmio_spte_generation(spte);
trace_check_mmio_spte(spte, kvm_gen, spte_gen);
return likely(kvm_gen == spte_gen);
}
| 169,963,061,933,291,550,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,048 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void clear_sp_write_flooding_count(u64 *spte)
{
struct kvm_mmu_page *sp = page_header(__pa(spte));
__clear_sp_write_flooding_count(sp);
}
| 127,454,371,942,434,650,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,049 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void count_spte_clear(u64 *sptep, u64 spte)
{
struct kvm_mmu_page *sp = page_header(__pa(sptep));
if (is_shadow_present_pte(spte))
return;
/* Ensure the spte is completely set before we increase the count */
smp_wmb();
sp->clear_spte_count++;
}
| 208,359,166,147,878,060,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,050 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void destroy_kvm_mmu(struct kvm_vcpu *vcpu)
{
ASSERT(vcpu);
if (VALID_PAGE(vcpu->arch.mmu.root_hpa))
/* mmu.free() should set root_hpa = INVALID_PAGE */
vcpu->arch.mmu.free(vcpu);
}
| 233,270,172,227,760,380,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,051 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool detect_write_flooding(struct kvm_mmu_page *sp)
{
/*
* Skip write-flooding detected for the sp whose level is 1, because
* it can become unsync, then the guest page is not write-protected.
*/
if (sp->role.level == PT_PAGE_TABLE_LEVEL)
return false;
return ++sp->write_flooding_count >= 3;
}
| 79,119,184,108,517,780,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,052 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool detect_write_misaligned(struct kvm_mmu_page *sp, gpa_t gpa,
int bytes)
{
unsigned offset, pte_size, misaligned;
pgprintk("misaligned: gpa %llx bytes %d role %x\n",
gpa, bytes, sp->role.word);
offset = offset_in_page(gpa);
pte_size = sp->role.cr4_pae ? 8 : 4;
/*
* Sometimes, the OS only ... | 59,359,163,955,416,000,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,053 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void direct_pte_prefetch(struct kvm_vcpu *vcpu, u64 *sptep)
{
struct kvm_mmu_page *sp;
/*
* Since it's no accessed bit on EPT, it's no way to
* distinguish between actually accessed translations
* and prefetched, so disable pte prefetch if EPT is
* enabled.
*/
if (!shadow_accessed_mask)
return;
... | 232,357,502,843,978,720,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,054 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int direct_pte_prefetch_many(struct kvm_vcpu *vcpu,
struct kvm_mmu_page *sp,
u64 *start, u64 *end)
{
struct page *pages[PTE_PREFETCH_NUM];
unsigned access = sp->role.access;
int i, ret;
gfn_t gfn;
gfn = kvm_mmu_page_get_gfn(sp, start - sp->spt);
if (!gfn_to_memslot_dirty_bitmap(vcpu, gfn, ... | 297,791,678,844,919,380,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,055 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void drop_large_spte(struct kvm_vcpu *vcpu, u64 *sptep)
{
if (__drop_large_spte(vcpu->kvm, sptep))
kvm_flush_remote_tlbs(vcpu->kvm);
}
| 39,900,316,487,237,320,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,056 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void drop_parent_pte(struct kvm_mmu_page *sp,
u64 *parent_pte)
{
mmu_page_remove_parent_pte(sp, parent_pte);
mmu_spte_clear_no_track(parent_pte);
}
| 164,388,476,193,227,490,000,000,000,000,000,000,000 | mmu.c | 71,266,076,254,608,070,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,057 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void drop_spte(struct kvm *kvm, u64 *sptep)
{
if (mmu_spte_clear_track_bits(sptep))
rmap_remove(kvm, sptep);
}
| 190,734,840,574,941,730,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,058 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool fast_page_fault(struct kvm_vcpu *vcpu, gva_t gva, int level,
u32 error_code)
{
struct kvm_shadow_walk_iterator iterator;
bool ret = false;
u64 spte = 0ull;
if (!page_fault_can_be_fast(vcpu, error_code))
return false;
walk_shadow_page_lockless_begin(vcpu);
for_each_shadow_entry_lockless(vcpu... | 328,306,665,914,119,440,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,059 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | fast_pf_fix_direct_spte(struct kvm_vcpu *vcpu, u64 *sptep, u64 spte)
{
struct kvm_mmu_page *sp = page_header(__pa(sptep));
gfn_t gfn;
WARN_ON(!sp->role.direct);
/*
* The gfn of direct spte is stable since it is calculated
* by sp->gfn.
*/
gfn = kvm_mmu_page_get_gfn(sp, sptep - sp->spt);
if (cmpxchg64(spt... | 158,332,186,228,760,770,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,060 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void free_mmu_pages(struct kvm_vcpu *vcpu)
{
free_page((unsigned long)vcpu->arch.mmu.pae_root);
if (vcpu->arch.mmu.lm_root != NULL)
free_page((unsigned long)vcpu->arch.mmu.lm_root);
}
| 326,163,983,868,638,560,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,061 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static u64 generation_mmio_spte_mask(unsigned int gen)
{
u64 mask;
WARN_ON(gen > MMIO_MAX_GEN);
mask = (gen & MMIO_GEN_LOW_MASK) << MMIO_SPTE_GEN_LOW_SHIFT;
mask |= ((u64)gen >> MMIO_GEN_LOW_SHIFT) << MMIO_SPTE_GEN_HIGH_SHIFT;
return mask;
}
| 329,543,198,177,617,050,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,062 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static unsigned get_mmio_spte_access(u64 spte)
{
u64 mask = generation_mmio_spte_mask(MMIO_MAX_GEN) | shadow_mmio_mask;
return (spte & ~mask) & ~PAGE_MASK;
}
| 124,560,192,354,791,520,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,063 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static unsigned int get_mmio_spte_generation(u64 spte)
{
unsigned int gen;
spte &= ~shadow_mmio_mask;
gen = (spte >> MMIO_SPTE_GEN_LOW_SHIFT) & MMIO_GEN_LOW_MASK;
gen |= (spte >> MMIO_SPTE_GEN_HIGH_SHIFT) << MMIO_GEN_LOW_SHIFT;
return gen;
}
| 294,956,097,424,598,660,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,064 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static gfn_t get_mmio_spte_gfn(u64 spte)
{
u64 mask = generation_mmio_spte_mask(MMIO_MAX_GEN) | shadow_mmio_mask;
return (spte & ~mask) >> PAGE_SHIFT;
}
| 48,645,509,173,903,900,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,065 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int get_mtrr_type(struct mtrr_state_type *mtrr_state,
u64 start, u64 end)
{
int i;
u64 base, mask;
u8 prev_match, curr_match;
int num_var_ranges = KVM_NR_VAR_MTRR;
if (!mtrr_state->enabled)
return 0xFF;
/* Make end inclusive end, instead of exclusive */
end--;
/* Look in fixed ranges. Just retur... | 298,278,616,765,610,700,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,066 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static u64 *get_written_sptes(struct kvm_mmu_page *sp, gpa_t gpa, int *nspte)
{
unsigned page_offset, quadrant;
u64 *spte;
int level;
page_offset = offset_in_page(gpa);
level = sp->role.level;
*nspte = 1;
if (!sp->role.cr4_pae) {
page_offset <<= 1; /* 32->64 */
/*
* A 32-bit pde maps 4MB while the shadow... | 224,597,198,545,899,120,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,067 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | gfn_to_memslot_dirty_bitmap(struct kvm_vcpu *vcpu, gfn_t gfn,
bool no_dirty_log)
{
struct kvm_memory_slot *slot;
slot = gfn_to_memslot(vcpu->kvm, gfn);
if (!slot || slot->flags & KVM_MEMSLOT_INVALID ||
(no_dirty_log && slot->dirty_bitmap))
slot = NULL;
return slot;
}
| 327,864,310,833,081,730,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,068 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static unsigned long *gfn_to_rmap(struct kvm *kvm, gfn_t gfn, int level)
{
struct kvm_memory_slot *slot;
slot = gfn_to_memslot(kvm, gfn);
return __gfn_to_rmap(gfn, level, slot);
}
| 1,794,231,770,310,815,300,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,069 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool handle_abnormal_pfn(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn,
pfn_t pfn, unsigned access, int *ret_val)
{
bool ret = true;
/* The pfn is invalid, report the error! */
if (unlikely(is_error_pfn(pfn))) {
*ret_val = kvm_handle_bad_page(vcpu, gfn, pfn);
goto exit;
}
if (unlikely(is_noslot_pfn(... | 104,054,141,984,699,240,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,070 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int handle_mmio_page_fault(struct kvm_vcpu *vcpu, u64 addr,
u32 error_code, bool direct)
{
int ret;
ret = handle_mmio_page_fault_common(vcpu, addr, direct);
WARN_ON(ret == RET_MMIO_PF_BUG);
return ret;
}
| 277,256,143,279,116,300,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,071 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | int handle_mmio_page_fault_common(struct kvm_vcpu *vcpu, u64 addr, bool direct)
{
u64 spte;
if (quickly_check_mmio_pf(vcpu, addr, direct))
return RET_MMIO_PF_EMULATE;
spte = walk_shadow_page_get_mmio_spte(vcpu, addr);
if (is_mmio_spte(spte)) {
gfn_t gfn = get_mmio_spte_gfn(spte);
unsigned access = get_mmio... | 122,107,988,299,268,980,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,072 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int has_wrprotected_page(struct kvm *kvm,
gfn_t gfn,
int level)
{
struct kvm_memory_slot *slot;
struct kvm_lpage_info *linfo;
slot = gfn_to_memslot(kvm, gfn);
if (slot) {
linfo = lpage_info_slot(gfn, slot, level);
return linfo->write_count;
}
return 1;
}
| 119,174,185,995,689,630,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,073 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int host_mapping_level(struct kvm *kvm, gfn_t gfn)
{
unsigned long page_size;
int i, ret = 0;
page_size = kvm_host_page_size(kvm, gfn);
for (i = PT_PAGE_TABLE_LEVEL;
i < (PT_PAGE_TABLE_LEVEL + KVM_NR_PAGE_SIZES); ++i) {
if (page_size >= KVM_HPAGE_SIZE(i))
ret = i;
else
break;
}
return re... | 196,537,341,343,379,400,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,074 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int init_kvm_mmu(struct kvm_vcpu *vcpu)
{
if (mmu_is_nested(vcpu))
return init_kvm_nested_mmu(vcpu);
else if (tdp_enabled)
return init_kvm_tdp_mmu(vcpu);
else
return init_kvm_softmmu(vcpu);
}
| 98,692,605,976,449,930,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,075 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int init_kvm_nested_mmu(struct kvm_vcpu *vcpu)
{
struct kvm_mmu *g_context = &vcpu->arch.nested_mmu;
g_context->get_cr3 = get_cr3;
g_context->get_pdptr = kvm_pdptr_read;
g_context->inject_page_fault = kvm_inject_page_fault;
/*
* Note that arch.mmu.gva_to_gpa translates l2_gva to l1_gpa... | 155,836,076,656,096,200,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,076 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int init_kvm_softmmu(struct kvm_vcpu *vcpu)
{
int r = kvm_init_shadow_mmu(vcpu, vcpu->arch.walk_mmu);
vcpu->arch.walk_mmu->set_cr3 = kvm_x86_ops->set_cr3;
vcpu->arch.walk_mmu->get_cr3 = get_cr3;
vcpu->arch.walk_mmu->get_pdptr = kvm_pdptr_read;
vcpu->arch.walk_mmu->inject_page_fa... | 29,100,989,107,999,610,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,077 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void init_shadow_page_table(struct kvm_mmu_page *sp)
{
int i;
for (i = 0; i < PT64_ENT_PER_PAGE; ++i)
sp->spt[i] = 0ull;
}
| 318,558,836,114,553,750,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,078 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static void inject_page_fault(struct kvm_vcpu *vcpu,
struct x86_exception *fault)
{
vcpu->arch.mmu.inject_page_fault(vcpu, fault);
}
| 86,939,005,032,722,600,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,079 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int is_cpuid_PSE36(void)
{
return 1;
}
| 22,233,841,801,070,563,000,000,000,000,000,000,000 | mmu.c | 71,266,076,254,608,070,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,080 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static int is_large_pte(u64 pte)
{
return pte & PT_PAGE_SIZE_MASK;
}
| 314,736,650,762,188,930,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,081 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static inline bool is_last_gpte(struct kvm_mmu *mmu, unsigned level, unsigned gpte)
{
unsigned index;
index = level - 1;
index |= (gpte & PT_PAGE_SIZE_MASK) >> (PT_PAGE_SIZE_SHIFT - 2);
return mmu->last_pte_bitmap & (1 << index);
}
| 222,566,373,595,275,470,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,082 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool is_mmio_page_fault(struct kvm_vcpu *vcpu, gva_t addr)
{
if (vcpu->arch.mmu.direct_map || mmu_is_nested(vcpu))
return vcpu_match_mmio_gpa(vcpu, addr);
return vcpu_match_mmio_gva(vcpu, addr);
}
| 228,240,187,940,173,950,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
38,083 | linux | bfd0a56b90005f8c8a004baf407ad90045c2b11e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bfd0a56b90005f8c8a004baf407ad90045c2b11e | nEPT: Nested INVEPT
If we let L1 use EPT, we should probably also support the INVEPT instruction.
In our current nested EPT implementation, when L1 changes its EPT table
for L2 (i.e., EPT12), L0 modifies the shadow EPT table (EPT02), and in
the course of this modification already calls INVEPT. But if last level
of sh... | 0 | static bool is_mmio_spte(u64 spte)
{
return (spte & shadow_mmio_mask) == shadow_mmio_mask;
}
| 73,917,197,781,478,510,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-3645 | arch/x86/kvm/vmx.c in the KVM subsystem in the Linux kernel before 3.12 does not have an exit handler for the INVEPT instruction, which allows guest OS users to cause a denial of service (guest OS crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2014-3645 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.