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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
38,084 | 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_obsolete_sp(struct kvm *kvm, struct kvm_mmu_page *sp)
{
return unlikely(sp->mmu_valid_gen != kvm->arch.mmu_valid_gen);
}
| 34,174,374,253,702,985,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,085 | 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_shadow_present_pte(u64 pte)
{
return pte & PT_PRESENT_MASK && !is_mmio_spte(pte);
}
| 106,260,671,817,142,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,086 | 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 kvm_age_hva(struct kvm *kvm, unsigned long hva)
{
return kvm_handle_hva(kvm, hva, hva, kvm_age_rmapp);
}
| 130,309,977,169,313,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,087 | 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_age_rmapp(struct kvm *kvm, unsigned long *rmapp,
struct kvm_memory_slot *slot, unsigned long data)
{
u64 *sptep;
struct rmap_iterator uninitialized_var(iter);
int young = 0;
/*
* In case of absence of EPT Access and Dirty Bits supports,
* emulate the accessed bit for EPT, by checking if this... | 244,819,147,331,331,570,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,088 | 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_arch_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn)
{
struct kvm_arch_async_pf arch;
arch.token = (vcpu->arch.apf.id++ << 12) | vcpu->vcpu_id;
arch.gfn = gfn;
arch.direct_map = vcpu->arch.mmu.direct_map;
arch.cr3 = vcpu->arch.mmu.get_cr3(vcpu);
return kvm_setup_async_pf(vcpu, gva, gf... | 99,521,685,347,828,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,089 | 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 | void kvm_disable_tdp(void)
{
tdp_enabled = false;
}
| 308,083,772,139,017,740,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,090 | 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 | void kvm_enable_tdp(void)
{
tdp_enabled = true;
}
| 325,896,388,088,105,170,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,091 | 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_handle_bad_page(struct kvm_vcpu *vcpu, gfn_t gfn, pfn_t pfn)
{
/*
* Do not cache the mmio info caused by writing the readonly gfn
* into the spte otherwise read access on readonly gfn also can
* caused mmio page fault and treat it as mmio access.
* Return 1 to tell kvm to emulate it.
*/
if (p... | 305,382,998,371,491,100,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,092 | 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_handle_hva(struct kvm *kvm, unsigned long hva,
unsigned long data,
int (*handler)(struct kvm *kvm, unsigned long *rmapp,
struct kvm_memory_slot *slot,
unsigned long data))
{
return kvm_handle_hva_range(kvm, hva, hva + 1, data, handler);
}
| 25,507,325,998,735,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,093 | 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_handle_hva_range(struct kvm *kvm,
unsigned long start,
unsigned long end,
unsigned long data,
int (*handler)(struct kvm *kvm,
unsigned long *rmapp,
struct kvm_memory_slot *slot,
unsigned long data))
{
int j;
int ret = 0;
struct kvm_memslots *slots;
... | 135,566,418,809,161,740,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,094 | 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 kvm_has_zapped_obsolete_pages(struct kvm *kvm)
{
return unlikely(!list_empty_careful(&kvm->arch.zapped_obsolete_pages));
}
| 36,041,408,633,198,913,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,095 | 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 kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context,
bool execonly)
{
ASSERT(vcpu);
ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa));
context->shadow_root_level = kvm_x86_ops->get_tdp_level();
context->nx = true;
context->new_cr3 = paging_new_cr3;
context->page_fault = ept_page_fault;
cont... | 71,062,780,685,013,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,096 | 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 kvm_init_shadow_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context)
{
int r;
bool smep = kvm_read_cr4_bits(vcpu, X86_CR4_SMEP);
ASSERT(vcpu);
ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa));
if (!is_paging(vcpu))
r = nonpaging_init_context(vcpu, context);
else if (is_long_mode(vcpu))
r = paging64_init_conte... | 164,179,502,492,373,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,097 | 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 struct kvm_mmu_page *kvm_mmu_alloc_page(struct kvm_vcpu *vcpu,
u64 *parent_pte, int direct)
{
struct kvm_mmu_page *sp;
sp = mmu_memory_cache_alloc(&vcpu->arch.mmu_page_header_cache);
sp->spt = mmu_memory_cache_alloc(&vcpu->arch.mmu_page_cache);
if (!direct)
sp->gfns = mmu_memory_cache_alloc(&v... | 104,925,167,083,183,270,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,098 | 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_mmu_audit(struct kvm_vcpu *vcpu, int point) { }
| 9,442,207,437,349,403,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,099 | 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 | unsigned int kvm_mmu_calculate_mmu_pages(struct kvm *kvm)
{
unsigned int nr_mmu_pages;
unsigned int nr_pages = 0;
struct kvm_memslots *slots;
struct kvm_memory_slot *memslot;
slots = kvm_memslots(kvm);
kvm_for_each_memslot(memslot, slots)
nr_pages += memslot->npages;
nr_mmu_pages = nr_pages * KVM_PERMILLE_... | 277,030,793,631,728,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,100 | 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 | void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int goal_nr_mmu_pages)
{
LIST_HEAD(invalid_list);
spin_lock(&kvm->mmu_lock);
if (kvm->arch.n_used_mmu_pages > goal_nr_mmu_pages) {
/* Need to free some mmu pages to achieve the goal. */
while (kvm->arch.n_used_mmu_pages > goal_nr_mmu_pages)
if (!prepar... | 189,689,140,182,966,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,101 | 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_mmu_commit_zap_page(struct kvm *kvm,
struct list_head *invalid_list)
{
struct kvm_mmu_page *sp, *nsp;
if (list_empty(invalid_list))
return;
/*
* wmb: make sure everyone sees our modifications to the page tables
* rmb: make sure we see changes to vcpu->mode
*/
smp_mb();
/*
* Wai... | 119,956,679,924,609,340,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,102 | 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 kvm_mmu_create(struct kvm_vcpu *vcpu)
{
ASSERT(vcpu);
vcpu->arch.walk_mmu = &vcpu->arch.mmu;
vcpu->arch.mmu.root_hpa = INVALID_PAGE;
vcpu->arch.mmu.translate_gpa = translate_gpa;
vcpu->arch.nested_mmu.translate_gpa = translate_nested_gpa;
return alloc_mmu_pages(vcpu);
}
| 318,619,469,008,925,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,103 | 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 | void kvm_mmu_destroy(struct kvm_vcpu *vcpu)
{
ASSERT(vcpu);
destroy_kvm_mmu(vcpu);
free_mmu_pages(vcpu);
mmu_free_memory_caches(vcpu);
}
| 235,441,513,612,709,820,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,104 | 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 | void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu)
{
++vcpu->stat.tlb_flush;
kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
}
| 32,232,039,761,532,716,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,105 | 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 struct kvm_mmu_page *kvm_mmu_get_page(struct kvm_vcpu *vcpu,
gfn_t gfn,
gva_t gaddr,
unsigned level,
int direct,
unsigned access,
u64 *parent_pte)
{
union kvm_mmu_page_role role;
unsigned quadrant;
struct kvm_mmu_page *sp;
bool need_sync = false;
... | 135,174,269,913,126,450,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,106 | 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 kvm_mmu_get_spte_hierarchy(struct kvm_vcpu *vcpu, u64 addr, u64 sptes[4])
{
struct kvm_shadow_walk_iterator iterator;
u64 spte;
int nr_sptes = 0;
walk_shadow_page_lockless_begin(vcpu);
for_each_shadow_entry_lockless(vcpu, addr, iterator, spte) {
sptes[iterator.level-1] = spte;
nr_sptes++;
if (!is_shadow... | 287,787,423,616,076,500,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,107 | 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 | void kvm_mmu_invalidate_mmio_sptes(struct kvm *kvm)
{
/*
* The very rare case: if the generation-number is round,
* zap all shadow pages.
*/
if (unlikely(kvm_current_mmio_generation(kvm) >= MMIO_MAX_GEN)) {
printk_ratelimited(KERN_INFO "kvm: zapping shadow pages for mmio generation wraparound\n");
kvm_mmu_i... | 311,758,157,229,727,220,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,108 | 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 | void kvm_mmu_invalidate_zap_all_pages(struct kvm *kvm)
{
spin_lock(&kvm->mmu_lock);
trace_kvm_mmu_invalidate_zap_all_pages(kvm);
kvm->arch.mmu_valid_gen++;
/*
* Notify all vcpus to reload its shadow page table
* and flush TLB. Then all vcpus will switch to new
* shadow page table with the new mmu_valid_gen.
... | 41,600,275,172,355,190,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,109 | 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 | void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva)
{
vcpu->arch.mmu.invlpg(vcpu, gva);
kvm_mmu_flush_tlb(vcpu);
++vcpu->stat.invlpg;
}
| 46,820,213,636,602,910,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,110 | 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 kvm_mmu_load(struct kvm_vcpu *vcpu)
{
int r;
r = mmu_topup_memory_caches(vcpu);
if (r)
goto out;
r = mmu_alloc_roots(vcpu);
kvm_mmu_sync_roots(vcpu);
if (r)
goto out;
/* set_cr3() should ensure TLB has been flushed */
vcpu->arch.mmu.set_cr3(vcpu, vcpu->arch.mmu.root_hpa);
out:
return r;
}
| 336,655,050,307,712,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,111 | 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_mmu_mark_parents_unsync(struct kvm_mmu_page *sp)
{
pte_list_walk(&sp->parent_ptes, mark_unsync);
}
| 335,485,121,722,184,760,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,112 | 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 kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t cr2, u32 error_code,
void *insn, int insn_len)
{
int r, emulation_type = EMULTYPE_RETRY;
enum emulation_result er;
r = vcpu->arch.mmu.page_fault(vcpu, cr2, error_code, false);
if (r < 0)
goto out;
if (!r) {
r = 1;
goto out;
}
if (is_mmio_page_... | 235,255,625,875,833,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,113 | 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 kvm_mmu_page_get_gfn(struct kvm_mmu_page *sp, int index)
{
if (!sp->role.direct)
return sp->gfns[index];
return sp->gfn + (index << ((sp->role.level - 1) * PT64_LEVEL_BITS));
}
| 251,590,260,371,995,800,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,114 | 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_mmu_page_set_gfn(struct kvm_mmu_page *sp, int index, gfn_t gfn)
{
if (sp->role.direct)
BUG_ON(gfn != kvm_mmu_page_get_gfn(sp, index));
else
sp->gfns[index] = gfn;
}
| 282,318,776,971,751,340,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,115 | 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_mmu_page_unlink_children(struct kvm *kvm,
struct kvm_mmu_page *sp)
{
unsigned i;
for (i = 0; i < PT64_ENT_PER_PAGE; ++i)
mmu_page_zap_pte(kvm, sp, sp->spt + i);
}
| 29,724,749,568,177,747,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,116 | 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_mmu_pages_init(struct kvm_mmu_page *parent,
struct mmu_page_path *parents,
struct kvm_mmu_pages *pvec)
{
parents->parent[parent->role.level-1] = NULL;
pvec->nr = 0;
}
| 145,445,594,162,550,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,117 | 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_mmu_prepare_zap_page(struct kvm *kvm, struct kvm_mmu_page *sp,
struct list_head *invalid_list)
{
int ret;
trace_kvm_mmu_prepare_zap_page(sp);
++kvm->stat.mmu_shadow_zapped;
ret = mmu_zap_unsync_children(kvm, sp, invalid_list);
kvm_mmu_page_unlink_children(kvm, sp);
kvm_mmu_unlink_parents(k... | 191,930,857,694,578,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,118 | 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 | void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
const u8 *new, int bytes)
{
gfn_t gfn = gpa >> PAGE_SHIFT;
union kvm_mmu_page_role mask = { .word = 0 };
struct kvm_mmu_page *sp;
LIST_HEAD(invalid_list);
u64 entry, gentry, *spte;
int npte;
bool remote_flush, local_flush, zap_page;
/*
* If we... | 263,611,665,399,334,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,119 | 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_mmu_put_page(struct kvm_mmu_page *sp, u64 *parent_pte)
{
mmu_page_remove_parent_pte(sp, parent_pte);
}
| 294,098,693,002,363,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,120 | 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 kvm_mmu_reset_context(struct kvm_vcpu *vcpu)
{
destroy_kvm_mmu(vcpu);
return init_kvm_mmu(vcpu);
}
| 260,397,684,383,219,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,121 | 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 | void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
u64 dirty_mask, u64 nx_mask, u64 x_mask)
{
shadow_user_mask = user_mask;
shadow_accessed_mask = accessed_mask;
shadow_dirty_mask = dirty_mask;
shadow_nx_mask = nx_mask;
shadow_x_mask = x_mask;
}
| 284,278,932,106,281,100,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,122 | 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 | void kvm_mmu_set_mmio_spte_mask(u64 mmio_mask)
{
shadow_mmio_mask = mmio_mask;
}
| 315,063,211,775,668,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,123 | 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 kvm_mmu_setup(struct kvm_vcpu *vcpu)
{
ASSERT(vcpu);
ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa));
return init_kvm_mmu(vcpu);
}
| 50,764,420,991,400,350,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,124 | 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 | void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot)
{
struct kvm_memory_slot *memslot;
gfn_t last_gfn;
int i;
memslot = id_to_memslot(kvm->memslots, slot);
last_gfn = memslot->base_gfn + memslot->npages - 1;
spin_lock(&kvm->mmu_lock);
for (i = PT_PAGE_TABLE_LEVEL;
i < PT_PAGE_TABLE_LEVEL + ... | 314,603,701,140,333,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,125 | 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 | void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu)
{
spin_lock(&vcpu->kvm->mmu_lock);
mmu_sync_roots(vcpu);
spin_unlock(&vcpu->kvm->mmu_lock);
}
| 271,703,880,911,315,170,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,126 | 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_mmu_unlink_parents(struct kvm *kvm, struct kvm_mmu_page *sp)
{
u64 *sptep;
struct rmap_iterator iter;
while ((sptep = rmap_get_first(sp->parent_ptes, &iter)))
drop_parent_pte(sp, sptep);
}
| 85,419,565,871,328,990,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,127 | 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 | void kvm_mmu_unload(struct kvm_vcpu *vcpu)
{
mmu_free_roots(vcpu);
}
| 36,757,235,233,818,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,128 | 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 kvm_mmu_unprotect_page(struct kvm *kvm, gfn_t gfn)
{
struct kvm_mmu_page *sp;
LIST_HEAD(invalid_list);
int r;
pgprintk("%s: looking for gfn %llx\n", __func__, gfn);
r = 0;
spin_lock(&kvm->mmu_lock);
for_each_gfn_indirect_valid_sp(kvm, sp, gfn) {
pgprintk("%s: gfn %llx role %x\n", __func__, gfn,
sp->ro... | 118,425,897,566,250,920,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,129 | 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 void kvm_mod_used_mmu_pages(struct kvm *kvm, int nr)
{
kvm->arch.n_used_mmu_pages += nr;
percpu_counter_add(&kvm_total_used_mmu_pages, nr);
}
| 160,421,395,106,270,430,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,130 | 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 kvm_page_table_hashfn(gfn_t gfn)
{
return gfn & ((1 << KVM_MMU_HASH_SHIFT) - 1);
}
| 76,353,517,236,539,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,131 | 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_send_hwpoison_signal(unsigned long address, struct task_struct *tsk)
{
siginfo_t info;
info.si_signo = SIGBUS;
info.si_errno = 0;
info.si_code = BUS_MCEERR_AR;
info.si_addr = (void __user *)address;
info.si_addr_lsb = PAGE_SHIFT;
send_sig_info(SIGBUS, &info, tsk);
}
| 278,151,040,719,594,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,132 | 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_set_pte_rmapp(struct kvm *kvm, unsigned long *rmapp,
struct kvm_memory_slot *slot, unsigned long data)
{
u64 *sptep;
struct rmap_iterator iter;
int need_flush = 0;
u64 new_spte;
pte_t *ptep = (pte_t *)data;
pfn_t new_pfn;
WARN_ON(pte_huge(*ptep));
new_pfn = pte_pfn(*ptep);
for (sptep =... | 38,902,930,533,073,500,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,133 | 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 | void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte)
{
kvm_handle_hva(kvm, hva, (unsigned long)&pte, kvm_set_pte_rmapp);
}
| 286,242,022,681,860,830,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,134 | 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)
{
return __kvm_sync_page(vcpu, sp, invalid_list, true);
}
| 264,484,785,127,681,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,135 | 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_sync_pages(struct kvm_vcpu *vcpu, gfn_t gfn)
{
struct kvm_mmu_page *s;
LIST_HEAD(invalid_list);
bool flush = false;
for_each_gfn_indirect_valid_sp(vcpu->kvm, s, gfn) {
if (!s->unsync)
continue;
WARN_ON(s->role.level != PT_PAGE_TABLE_LEVEL);
kvm_unlink_unsync_page(vcpu->kvm, s);
if ((s-... | 265,586,497,200,672,460,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,136 | 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 kvm_test_age_hva(struct kvm *kvm, unsigned long hva)
{
return kvm_handle_hva(kvm, hva, 0, kvm_test_age_rmapp);
}
| 242,506,042,233,382,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,137 | 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_test_age_rmapp(struct kvm *kvm, unsigned long *rmapp,
struct kvm_memory_slot *slot, unsigned long data)
{
u64 *sptep;
struct rmap_iterator iter;
int young = 0;
/*
* If there's no access bit in the secondary pte set by the
* hardware it's up to gup-fast/gup to set the access bit in
* t... | 168,181,536,206,660,530,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,138 | 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_unlink_unsync_page(struct kvm *kvm, struct kvm_mmu_page *sp)
{
WARN_ON(!sp->unsync);
trace_kvm_mmu_sync_page(sp);
sp->unsync = 0;
--kvm->stat.mmu_unsync;
}
| 198,726,447,560,140,050,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,139 | 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 kvm_unmap_hva(struct kvm *kvm, unsigned long hva)
{
return kvm_handle_hva(kvm, hva, 0, kvm_unmap_rmapp);
}
| 232,913,827,953,596,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,140 | 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_pages(struct kvm_vcpu *vcpu, gfn_t gfn)
{
struct kvm_mmu_page *s;
for_each_gfn_indirect_valid_sp(vcpu->kvm, s, gfn) {
if (s->unsync)
continue;
WARN_ON(s->role.level != PT_PAGE_TABLE_LEVEL);
__kvm_unsync_page(vcpu, s);
}
}
| 93,554,769,633,635,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,141 | 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 struct kvm_lpage_info *lpage_info_slot(gfn_t gfn,
struct kvm_memory_slot *slot,
int level)
{
unsigned long idx;
idx = gfn_to_index(gfn, slot->base_gfn, level);
return &slot->arch.lpage_info[level - 2][idx];
}
| 4,724,845,825,605,549,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,142 | 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 mapping_level(struct kvm_vcpu *vcpu, gfn_t large_gfn)
{
int host_level, level, max_level;
host_level = host_mapping_level(vcpu->kvm, large_gfn);
if (host_level == PT_PAGE_TABLE_LEVEL)
return host_level;
max_level = min(kvm_x86_ops->get_lpage_level(), host_level);
for (level = PT_DIRECTORY_LEVEL; l... | 302,067,907,429,319,860,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,143 | 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 mapping_level_dirty_bitmap(struct kvm_vcpu *vcpu, gfn_t large_gfn)
{
return !gfn_to_memslot_dirty_bitmap(vcpu, large_gfn, true);
}
| 331,997,407,663,081,580,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,144 | 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 mark_mmio_spte(struct kvm *kvm, u64 *sptep, u64 gfn,
unsigned access)
{
unsigned int gen = kvm_current_mmio_generation(kvm);
u64 mask = generation_mmio_spte_mask(gen);
access &= ACC_WRITE_MASK | ACC_USER_MASK;
mask |= shadow_mmio_mask | access | gfn << PAGE_SHIFT;
trace_mark_mmio_spte(sptep, gf... | 249,895,305,663,628,500,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,145 | 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 mark_unsync(u64 *spte)
{
struct kvm_mmu_page *sp;
unsigned int index;
sp = page_header(__pa(spte));
index = spte - sp->spt;
if (__test_and_set_bit(index, sp->unsync_child_bitmap))
return;
if (sp->unsync_children++)
return;
kvm_mmu_mark_parents_unsync(sp);
}
| 169,246,482,056,356,150,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,146 | 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_alloc_direct_roots(struct kvm_vcpu *vcpu)
{
struct kvm_mmu_page *sp;
unsigned i;
if (vcpu->arch.mmu.shadow_root_level == PT64_ROOT_LEVEL) {
spin_lock(&vcpu->kvm->mmu_lock);
make_mmu_pages_available(vcpu);
sp = kvm_mmu_get_page(vcpu, 0, 0, PT64_ROOT_LEVEL,
1, ACC_ALL, NULL);
++sp->ro... | 186,111,800,119,027,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,147 | 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_alloc_roots(struct kvm_vcpu *vcpu)
{
if (vcpu->arch.mmu.direct_map)
return mmu_alloc_direct_roots(vcpu);
else
return mmu_alloc_shadow_roots(vcpu);
}
| 117,787,880,417,739,350,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,148 | 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_alloc_shadow_roots(struct kvm_vcpu *vcpu)
{
struct kvm_mmu_page *sp;
u64 pdptr, pm_mask;
gfn_t root_gfn;
int i;
root_gfn = vcpu->arch.mmu.get_cr3(vcpu) >> PAGE_SHIFT;
if (mmu_check_root(vcpu, root_gfn))
return 1;
/*
* Do we shadow a long mode page table? If so we need to
* write-protect t... | 25,196,867,340,840,455,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,149 | 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 mmu_audit_disable(void) { }
| 48,860,161,471,505,675,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,150 | 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 mmu_destroy_caches(void)
{
if (pte_list_desc_cache)
kmem_cache_destroy(pte_list_desc_cache);
if (mmu_page_header_cache)
kmem_cache_destroy(mmu_page_header_cache);
}
| 108,290,949,840,277,860,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,151 | 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 mmu_free_memory_cache(struct kvm_mmu_memory_cache *mc,
struct kmem_cache *cache)
{
while (mc->nobjs)
kmem_cache_free(cache, mc->objects[--mc->nobjs]);
}
| 82,335,417,765,462,410,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,152 | 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 mmu_free_memory_cache_page(struct kvm_mmu_memory_cache *mc)
{
while (mc->nobjs)
free_page((unsigned long)mc->objects[--mc->nobjs]);
}
| 245,409,806,595,900,850,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,153 | 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 mmu_free_memory_caches(struct kvm_vcpu *vcpu)
{
mmu_free_memory_cache(&vcpu->arch.mmu_pte_list_desc_cache,
pte_list_desc_cache);
mmu_free_memory_cache_page(&vcpu->arch.mmu_page_cache);
mmu_free_memory_cache(&vcpu->arch.mmu_page_header_cache,
mmu_page_header_cache);
}
| 212,534,006,780,255,500,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,154 | 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 mmu_free_pte_list_desc(struct pte_list_desc *pte_list_desc)
{
kmem_cache_free(pte_list_desc_cache, pte_list_desc);
}
| 159,056,669,696,316,570,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,155 | 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 *mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc)
{
void *p;
BUG_ON(!mc->nobjs);
p = mc->objects[--mc->nobjs];
return p;
}
| 301,797,978,722,323,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,156 | 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_memory_cache_free_objects(struct kvm_mmu_memory_cache *cache)
{
return cache->nobjs;
}
| 41,949,624,348,399,185,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,157 | 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_need_write_protect(struct kvm_vcpu *vcpu, gfn_t gfn,
bool can_unsync)
{
struct kvm_mmu_page *s;
bool need_unsync = false;
for_each_gfn_indirect_valid_sp(vcpu->kvm, s, gfn) {
if (!can_unsync)
return 1;
if (s->role.level != PT_PAGE_TABLE_LEVEL)
return 1;
if (!s->unsync)
need_unsy... | 84,721,871,030,502,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,158 | 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 mmu_page_add_parent_pte(struct kvm_vcpu *vcpu,
struct kvm_mmu_page *sp, u64 *parent_pte)
{
if (!parent_pte)
return;
pte_list_add(vcpu, parent_pte, &sp->parent_ptes);
}
| 290,207,998,326,942,930,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,159 | 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 mmu_page_remove_parent_pte(struct kvm_mmu_page *sp,
u64 *parent_pte)
{
pte_list_remove(parent_pte, &sp->parent_ptes);
}
| 215,085,036,591,677,530,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,160 | 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 mmu_page_zap_pte(struct kvm *kvm, struct kvm_mmu_page *sp,
u64 *spte)
{
u64 pte;
struct kvm_mmu_page *child;
pte = *spte;
if (is_shadow_present_pte(pte)) {
if (is_last_spte(pte, sp->role.level)) {
drop_spte(kvm, spte);
if (is_large_pte(pte))
--kvm->stat.lpages;
} else {
child =... | 226,297,935,938,052,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,161 | 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_pages_add(struct kvm_mmu_pages *pvec, struct kvm_mmu_page *sp,
int idx)
{
int i;
if (sp->unsync)
for (i=0; i < pvec->nr; i++)
if (pvec->page[i].sp == sp)
return 0;
pvec->page[pvec->nr].sp = sp;
pvec->page[pvec->nr].idx = idx;
pvec->nr++;
return (pvec->nr == KVM_PAGE_ARRAY_NR);
}
| 165,034,910,524,179,400,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,162 | 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 mmu_pages_clear_parents(struct mmu_page_path *parents)
{
struct kvm_mmu_page *sp;
unsigned int level = 0;
do {
unsigned int idx = parents->idx[level];
sp = parents->parent[level];
if (!sp)
return;
--sp->unsync_children;
WARN_ON((int)sp->unsync_children < 0);
__clear_bit(idx, sp->unsync_... | 100,750,600,625,907,960,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,163 | 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_pages_next(struct kvm_mmu_pages *pvec,
struct mmu_page_path *parents,
int i)
{
int n;
for (n = i+1; n < pvec->nr; n++) {
struct kvm_mmu_page *sp = pvec->page[n].sp;
if (sp->role.level == PT_PAGE_TABLE_LEVEL) {
parents->idx[0] = pvec->page[n].idx;
return n;
}
parents->parent[s... | 105,778,992,344,466,620,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,164 | 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 mmu_pte_write_flush_tlb(struct kvm_vcpu *vcpu, bool zap_page,
bool remote_flush, bool local_flush)
{
if (zap_page)
return;
if (remote_flush)
kvm_flush_remote_tlbs(vcpu->kvm);
else if (local_flush)
kvm_mmu_flush_tlb(vcpu);
}
| 10,068,739,512,955,752,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,165 | 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 mmu_pte_write_new_pte(struct kvm_vcpu *vcpu,
struct kvm_mmu_page *sp, u64 *spte,
const void *new)
{
if (sp->role.level != PT_PAGE_TABLE_LEVEL) {
++vcpu->kvm->stat.mmu_pde_zapped;
return;
}
++vcpu->kvm->stat.mmu_pte_updated;
vcpu->arch.mmu.update_pte(vcpu, sp, spte, new);
}
| 241,656,832,742,515,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,166 | 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 mmu_set_spte(struct kvm_vcpu *vcpu, u64 *sptep,
unsigned pte_access, int write_fault, int *emulate,
int level, gfn_t gfn, pfn_t pfn, bool speculative,
bool host_writable)
{
int was_rmapped = 0;
int rmap_count;
pgprintk("%s: spte %llx write_fault %d gfn %llx\n", __func__,
*sptep, write_fau... | 43,639,368,803,726,110,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,167 | 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_shrink(struct shrinker *shrink, struct shrink_control *sc)
{
struct kvm *kvm;
int nr_to_scan = sc->nr_to_scan;
if (nr_to_scan == 0)
goto out;
raw_spin_lock(&kvm_lock);
list_for_each_entry(kvm, &vm_list, vm_list) {
int idx;
LIST_HEAD(invalid_list);
/*
* Never scan more than sc->nr_to_s... | 320,500,700,584,359,340,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,168 | 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 mmu_spte_clear_no_track(u64 *sptep)
{
__update_clear_spte_fast(sptep, 0ull);
}
| 325,641,891,167,867,500,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,169 | 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_spte_clear_track_bits(u64 *sptep)
{
pfn_t pfn;
u64 old_spte = *sptep;
if (!spte_has_volatile_bits(old_spte))
__update_clear_spte_fast(sptep, 0ull);
else
old_spte = __update_clear_spte_slow(sptep, 0ull);
if (!is_rmap_spte(old_spte))
return 0;
pfn = spte_to_pfn(old_spte);
/*
* KVM does n... | 56,360,001,945,220,170,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,170 | 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 mmu_spte_get_lockless(u64 *sptep)
{
return __get_spte_lockless(sptep);
}
| 58,504,088,656,215,360,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,171 | 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 mmu_spte_set(u64 *sptep, u64 new_spte)
{
WARN_ON(is_shadow_present_pte(*sptep));
__set_spte(sptep, new_spte);
}
| 264,530,947,035,107,060,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,172 | 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 mmu_spte_update(u64 *sptep, u64 new_spte)
{
u64 old_spte = *sptep;
bool ret = false;
WARN_ON(!is_rmap_spte(new_spte));
if (!is_shadow_present_pte(old_spte)) {
mmu_spte_set(sptep, new_spte);
return ret;
}
if (!spte_has_volatile_bits(old_spte))
__update_clear_spte_fast(sptep, new_spte);
else
... | 116,486,992,607,379,830,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,173 | 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 mmu_sync_children(struct kvm_vcpu *vcpu,
struct kvm_mmu_page *parent)
{
int i;
struct kvm_mmu_page *sp;
struct mmu_page_path parents;
struct kvm_mmu_pages pages;
LIST_HEAD(invalid_list);
kvm_mmu_pages_init(parent, &parents, &pages);
while (mmu_unsync_walk(parent, &pages)) {
bool protected... | 52,684,304,645,876,070,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,174 | 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 mmu_sync_roots(struct kvm_vcpu *vcpu)
{
int i;
struct kvm_mmu_page *sp;
if (vcpu->arch.mmu.direct_map)
return;
if (!VALID_PAGE(vcpu->arch.mmu.root_hpa))
return;
vcpu_clear_mmio_info(vcpu, ~0ul);
kvm_mmu_audit(vcpu, AUDIT_PRE_SYNC);
if (vcpu->arch.mmu.root_level == PT64_ROOT_LEVEL) {
hpa_t ro... | 112,027,606,425,109,920,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,175 | 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_topup_memory_cache_page(struct kvm_mmu_memory_cache *cache,
int min)
{
void *page;
if (cache->nobjs >= min)
return 0;
while (cache->nobjs < ARRAY_SIZE(cache->objects)) {
page = (void *)__get_free_page(GFP_KERNEL);
if (!page)
return -ENOMEM;
cache->objects[cache->nobjs++] = page;... | 306,835,598,172,344,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,176 | 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_topup_memory_caches(struct kvm_vcpu *vcpu)
{
int r;
r = mmu_topup_memory_cache(&vcpu->arch.mmu_pte_list_desc_cache,
pte_list_desc_cache, 8 + PTE_PREFETCH_NUM);
if (r)
goto out;
r = mmu_topup_memory_cache_page(&vcpu->arch.mmu_page_cache, 8);
if (r)
goto out;
r = mmu_topup_memory_cache(&v... | 68,530,614,695,900,540,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,177 | 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)
{
if (!sp->unsync_children)
return 0;
mmu_pages_add(pvec, sp, 0);
return __mmu_unsync_walk(sp, pvec);
}
| 257,695,625,904,844,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,178 | 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_zap_unsync_children(struct kvm *kvm,
struct kvm_mmu_page *parent,
struct list_head *invalid_list)
{
int i, zapped = 0;
struct mmu_page_path parents;
struct kvm_mmu_pages pages;
if (parent->role.level == PT_PAGE_TABLE_LEVEL)
return 0;
kvm_mmu_pages_init(parent, &parents, &pages);
w... | 99,780,832,515,319,820,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,179 | 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 need_remote_flush(u64 old, u64 new)
{
if (!is_shadow_present_pte(old))
return false;
if (!is_shadow_present_pte(new))
return true;
if ((old ^ new) & PT64_BASE_ADDR_MASK)
return true;
old ^= shadow_nx_mask;
new ^= shadow_nx_mask;
return (old & ~new & PT64_PERM_MASK) != 0;
}
| 231,504,048,178,780,870,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,180 | 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 gpa_t nonpaging_gva_to_gpa(struct kvm_vcpu *vcpu, gva_t vaddr,
u32 access, struct x86_exception *exception)
{
if (exception)
exception->error_code = 0;
return vaddr;
}
| 52,782,752,847,631,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,181 | 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 gpa_t nonpaging_gva_to_gpa_nested(struct kvm_vcpu *vcpu, gva_t vaddr,
u32 access,
struct x86_exception *exception)
{
if (exception)
exception->error_code = 0;
return vcpu->arch.nested_mmu.translate_gpa(vcpu, vaddr, access);
}
| 279,360,417,979,304,340,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,182 | 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 nonpaging_invlpg(struct kvm_vcpu *vcpu, gva_t gva)
{
}
| 78,338,522,044,922,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,183 | 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 nonpaging_map(struct kvm_vcpu *vcpu, gva_t v, u32 error_code,
gfn_t gfn, bool prefault)
{
int r;
int level;
int force_pt_level;
pfn_t pfn;
unsigned long mmu_seq;
bool map_writable, write = error_code & PFERR_WRITE_MASK;
force_pt_level = mapping_level_dirty_bitmap(vcpu, gfn);
if (likely(!force_pt... | 25,691,041,066,907,330,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.