https://cve.radiocsirt.org Contains only the most 10 recent entries. http://www.rssboard.org/rss-specification python-feedgen en Sat, 03 Oct 2026 23:44:06 +0000 https://cve.radiocsirt.org/vuln/certfr-2017-avi-482 certfr-2017-avi-482 https://cve.radiocsirt.org/vuln/certfr-2017-avi-482 https://cve.radiocsirt.org/vuln/cnvd-2018-00596 cnvd-2018-00596 https://cve.radiocsirt.org/vuln/cnvd-2018-00596 https://cve.radiocsirt.org/vuln/euvd-2026-80904 EUVD-2026-80904 https://cve.radiocsirt.org/vuln/euvd-2026-80904 https://cve.radiocsirt.org/vuln/fkie_cve-2017-1000410 <p>The Linux kernel version 3.3-rc1 and later is affected by a vulnerability lies in the processing of incoming L2CAP commands - ConfigRequest, and ConfigResponse messages. This info leak is a result of uninitialized stack variables that may be returned to an attacker in their uninitialized state. By manipulating the code flows that precede the handling of these configuration messages, an attacker can also gain some control over which data will be held in the uninitialized stack variables. This can allow him to bypass KASLR, and stack canaries protection - as both pointers and stack canaries may be leaked in this manner. Combining this vulnerability (for example) with the previously disclosed RCE vulnerability in L2CAP configuration parsing (CVE-2017-1000251) may allow an attacker to exploit the RCE against kernels which were built with the above mitigations. These are the specifics of this vulnerability: In the function l2cap_parse_conf_rsp and in the function l2cap_parse_conf_req the following variable is declared without initialization: struct l2cap_conf_efs efs; In addition, when parsing input configuration parameters in both of these functions, the switch case for handling EFS elements may skip the memcpy call that will write to the efs variable: ... case L2CAP_CONF_EFS: if (olen == sizeof(efs)) memcpy(&amp;efs, (void *)val, olen); ... The olen in the above if is attacker controlled, and regardless of that if, in both of these functions the efs variable would eventually be add…</p> <p>The Linux kernel version 3.3-rc1 and later is affected by a vulnerability lies in the processing of incoming L2CAP commands - ConfigRequest, and ConfigResponse messages. This info leak is a result of uninitialized stack variables that may be returned to an attacker in their uninitialized state. By manipulating the code flows that precede the handling of these configuration messages, an attacker can also gain some control over which data will be held in the uninitialized stack variables. This can allow him to bypass KASLR, and stack canaries protection - as both pointers and stack canaries may be leaked in this manner. Combining this vulnerability (for example) with the previously disclosed RCE vulnerability in L2CAP configuration parsing (CVE-2017-1000251) may allow an attacker to exploit the RCE against kernels which were built with the above mitigations. These are the specifics of this vulnerability: In the function l2cap_parse_conf_rsp and in the function l2cap_parse_conf_req the following variable is declared without initialization: struct l2cap_conf_efs efs; In addition, when parsing input configuration parameters in both of these functions, the switch case for handling EFS elements may skip the memcpy call that will write to the efs variable: ... case L2CAP_CONF_EFS: if (olen == sizeof(efs)) memcpy(&amp;efs, (void *)val, olen); ... The olen in the above if is attacker controlled, and regardless of that if, in both of these functions the efs variable would eventually be add…</p> https://cve.radiocsirt.org/vuln/fkie_cve-2017-1000410 https://cve.radiocsirt.org/vuln/ghsa-6jqp-hcfj-vjh3 <p>The Linux kernel version 3.3-rc1 and later is affected by a vulnerability lies in the processing of incoming L2CAP commands - ConfigRequest, and ConfigResponse messages. This info leak is a result of uninitialized stack variables that may be returned to an attacker in their uninitialized state. By manipulating the code flows that precede the handling of these configuration messages, an attacker can also gain some control over which data will be held in the uninitialized stack variables. This can allow him to bypass KASLR, and stack canaries protection - as both pointers and stack canaries may be leaked in this manner. Combining this vulnerability (for example) with the previously disclosed RCE vulnerability in L2CAP configuration parsing (CVE-2017-1000251) may allow an attacker to exploit the RCE against kernels which were built with the above mitigations. These are the specifics of this vulnerability: In the function l2cap_parse_conf_rsp and in the function l2cap_parse_conf_req the following variable is declared without initialization: struct l2cap_conf_efs efs; In addition, when parsing input configuration parameters in both of these functions, the switch case for handling EFS elements may skip the memcpy call that will write to the efs variable: ... case L2CAP_CONF_EFS: if (olen == sizeof(efs)) memcpy(&amp;efs, (void *)val, olen); ... The olen in the above if is attacker controlled, and regardless of that if, in both of these functions the efs variable would eventually be add…</p> <p>The Linux kernel version 3.3-rc1 and later is affected by a vulnerability lies in the processing of incoming L2CAP commands - ConfigRequest, and ConfigResponse messages. This info leak is a result of uninitialized stack variables that may be returned to an attacker in their uninitialized state. By manipulating the code flows that precede the handling of these configuration messages, an attacker can also gain some control over which data will be held in the uninitialized stack variables. This can allow him to bypass KASLR, and stack canaries protection - as both pointers and stack canaries may be leaked in this manner. Combining this vulnerability (for example) with the previously disclosed RCE vulnerability in L2CAP configuration parsing (CVE-2017-1000251) may allow an attacker to exploit the RCE against kernels which were built with the above mitigations. These are the specifics of this vulnerability: In the function l2cap_parse_conf_rsp and in the function l2cap_parse_conf_req the following variable is declared without initialization: struct l2cap_conf_efs efs; In addition, when parsing input configuration parameters in both of these functions, the switch case for handling EFS elements may skip the memcpy call that will write to the efs variable: ... case L2CAP_CONF_EFS: if (olen == sizeof(efs)) memcpy(&amp;efs, (void *)val, olen); ... The olen in the above if is attacker controlled, and regardless of that if, in both of these functions the efs variable would eventually be add…</p> https://cve.radiocsirt.org/vuln/ghsa-6jqp-hcfj-vjh3 https://cve.radiocsirt.org/vuln/gsd-2017-1000410 gsd-2017-1000410 https://cve.radiocsirt.org/vuln/gsd-2017-1000410 https://cve.radiocsirt.org/vuln/rhsa-2018:0654 <p>hw: cpu: speculative execution bounds-check bypass kernel: Buffer overflow in mp_override_legacy_irq() kernel: memory leak when merging buffers in SCSI IO vectors kernel: NULL pointer dereference due to KEYCTL_READ on negative key kernel: net: double-free and memory corruption in get_net_ns_by_id() kernel: Incorrect updates of uninstantiated keys crash the kernel Kernel: KVM: oops when checking KVM_CAP_PPC_HTM on PPC platform Kernel: ipsec: xfrm: use-after-free leading to potential privilege escalation kernel: Missing capabilities check in net/netfilter/nfnetlink_cthelper.c allows for unprivileged access to systemwide nfnl_cthelper_list structure kernel: Missing namespace check in net/netlink/af_netlink.c allows for network monitors to observe systemwide activity kernel: Arbitrary stack overwrite causing oops via crafted signal frame kernel: Stack information leak in the EFS element kernel: Integer overflow in futex.c:futux_requeue can lead to denial of service or unspecified impact kernel: Race condition in sound system can lead to denial of service</p> <p>hw: cpu: speculative execution bounds-check bypass kernel: Buffer overflow in mp_override_legacy_irq() kernel: memory leak when merging buffers in SCSI IO vectors kernel: NULL pointer dereference due to KEYCTL_READ on negative key kernel: net: double-free and memory corruption in get_net_ns_by_id() kernel: Incorrect updates of uninstantiated keys crash the kernel Kernel: KVM: oops when checking KVM_CAP_PPC_HTM on PPC platform Kernel: ipsec: xfrm: use-after-free leading to potential privilege escalation kernel: Missing capabilities check in net/netfilter/nfnetlink_cthelper.c allows for unprivileged access to systemwide nfnl_cthelper_list structure kernel: Missing namespace check in net/netlink/af_netlink.c allows for network monitors to observe systemwide activity kernel: Arbitrary stack overwrite causing oops via crafted signal frame kernel: Stack information leak in the EFS element kernel: Integer overflow in futex.c:futux_requeue can lead to denial of service or unspecified impact kernel: Race condition in sound system can lead to denial of service</p> https://cve.radiocsirt.org/vuln/rhsa-2018:0654 https://cve.radiocsirt.org/vuln/rhsa-2018:1062 <p>kernel: unlimiting the stack disables ASLR kernel: media: use-after-free in [tuner-xc2028] media driver kernel: Buffer overflow in firewire driver via crafted incoming packets hw: cpu: speculative execution branch target injection hw: cpu: speculative execution permission faults handling kernel: drm/vmwgfx: fix integer overflow in vmw_surface_define_ioctl() kernel: Use-after-free vulnerability in DCCP socket kernel: Incorrect type conversion for size during dma allocation Kernel: kvm: nVMX: L2 guest could access hardware(L0) CR8 register kernel: memory leak when merging buffers in SCSI IO vectors kernel: v4l2: disabled memory access protection mechanism allowing privilege escalation kernel: Buffer over-read in keyring subsystem allows exposing potentially sensitive information to local attacker kernel: Missing permission check in move_pages system call kernel: Null pointer dereference in rngapi_reset function kernel: vfs: BUG in truncate_inode_pages_range() and fuse client kernel: Use-after-free in userfaultfd_event_wait_completion function in userfaultfd.c kernel: Improper error handling of VM_SHARED hugetlbfs mapping in mm/hugetlb.c kernel: net: double-free and memory corruption in get_net_ns_by_id() kernel: Use-after-free in snd_seq_ioctl_create_port() kernel: dereferencing NULL payload with nonzero length kernel: Missing capabilities check in net/netfilter/nfnetlink_cthelper.c allows for unprivileged access to systemwide nfnl_cthelper_list structure kernel: Missing names…</p> <p>kernel: unlimiting the stack disables ASLR kernel: media: use-after-free in [tuner-xc2028] media driver kernel: Buffer overflow in firewire driver via crafted incoming packets hw: cpu: speculative execution branch target injection hw: cpu: speculative execution permission faults handling kernel: drm/vmwgfx: fix integer overflow in vmw_surface_define_ioctl() kernel: Use-after-free vulnerability in DCCP socket kernel: Incorrect type conversion for size during dma allocation Kernel: kvm: nVMX: L2 guest could access hardware(L0) CR8 register kernel: memory leak when merging buffers in SCSI IO vectors kernel: v4l2: disabled memory access protection mechanism allowing privilege escalation kernel: Buffer over-read in keyring subsystem allows exposing potentially sensitive information to local attacker kernel: Missing permission check in move_pages system call kernel: Null pointer dereference in rngapi_reset function kernel: vfs: BUG in truncate_inode_pages_range() and fuse client kernel: Use-after-free in userfaultfd_event_wait_completion function in userfaultfd.c kernel: Improper error handling of VM_SHARED hugetlbfs mapping in mm/hugetlb.c kernel: net: double-free and memory corruption in get_net_ns_by_id() kernel: Use-after-free in snd_seq_ioctl_create_port() kernel: dereferencing NULL payload with nonzero length kernel: Missing capabilities check in net/netfilter/nfnetlink_cthelper.c allows for unprivileged access to systemwide nfnl_cthelper_list structure kernel: Missing names…</p> https://cve.radiocsirt.org/vuln/rhsa-2018:1062 https://cve.radiocsirt.org/vuln/suse-su-2017:3398-1 <p>Security update for the Linux Kernel</p> <p>Security update for the Linux Kernel</p> https://cve.radiocsirt.org/vuln/suse-su-2017:3398-1 https://cve.radiocsirt.org/vuln/ubuntu-cve-2017-1000410 <p><strong>Affected:</strong> Ubuntu:14.04:LTS: linux, Ubuntu:14.04:LTS: linux-aws, Ubuntu:14.04:LTS: linux-lts-xenial, Ubuntu:16.04:LTS: linux, Ubuntu:16.04:LTS: linux-aws, Ubuntu:16.04:LTS: linux-azure, Ubuntu:16.04:LTS: linux-gcp, Ubuntu:16.04:LTS: linux-gke, Ubuntu:16.04:LTS: linux-hwe, Ubuntu:16.04:LTS: linux-kvm and 11 more</p> <p>The Linux kernel version 3.3-rc1 and later is affected by a vulnerability lies in the processing of incoming L2CAP commands - ConfigRequest, and ConfigResponse messages. This info leak is a result of uninitialized stack variables that may be returned to an attacker in their uninitialized state. By manipulating the code flows that precede the handling of these configuration messages, an attacker can also gain some control over which data will be held in the uninitialized stack variables. This can allow him to bypass KASLR, and stack canaries protection - as both pointers and stack canaries may be leaked in this manner. Combining this vulnerability (for example) with the previously disclosed RCE vulnerability in L2CAP configuration parsing (CVE-2017-1000251) may allow an attacker to exploit the RCE against kernels which were built with the above mitigations. These are the specifics of this vulnerability: In the function l2cap_parse_conf_rsp and in the function l2cap_parse_conf_req the following variable is declared without initialization: struct l2cap_conf_efs efs; In addition, when parsing input configuration parameters in both of these functions, the switch case for handling EFS elements may skip the memcpy call that will write to the efs variable: ... case L2CAP_CONF_EFS: if (olen == sizeof(efs)) memcpy(&amp;efs, (void *)val, olen); ... The olen in the above if is attacker controlled, and regardless of that if, in both of these functions the efs variable would eventually be add…</p> <p><strong>Affected:</strong> Ubuntu:14.04:LTS: linux, Ubuntu:14.04:LTS: linux-aws, Ubuntu:14.04:LTS: linux-lts-xenial, Ubuntu:16.04:LTS: linux, Ubuntu:16.04:LTS: linux-aws, Ubuntu:16.04:LTS: linux-azure, Ubuntu:16.04:LTS: linux-gcp, Ubuntu:16.04:LTS: linux-gke, Ubuntu:16.04:LTS: linux-hwe, Ubuntu:16.04:LTS: linux-kvm and 11 more</p> <p>The Linux kernel version 3.3-rc1 and later is affected by a vulnerability lies in the processing of incoming L2CAP commands - ConfigRequest, and ConfigResponse messages. This info leak is a result of uninitialized stack variables that may be returned to an attacker in their uninitialized state. By manipulating the code flows that precede the handling of these configuration messages, an attacker can also gain some control over which data will be held in the uninitialized stack variables. This can allow him to bypass KASLR, and stack canaries protection - as both pointers and stack canaries may be leaked in this manner. Combining this vulnerability (for example) with the previously disclosed RCE vulnerability in L2CAP configuration parsing (CVE-2017-1000251) may allow an attacker to exploit the RCE against kernels which were built with the above mitigations. These are the specifics of this vulnerability: In the function l2cap_parse_conf_rsp and in the function l2cap_parse_conf_req the following variable is declared without initialization: struct l2cap_conf_efs efs; In addition, when parsing input configuration parameters in both of these functions, the switch case for handling EFS elements may skip the memcpy call that will write to the efs variable: ... case L2CAP_CONF_EFS: if (olen == sizeof(efs)) memcpy(&amp;efs, (void *)val, olen); ... The olen in the above if is attacker controlled, and regardless of that if, in both of these functions the efs variable would eventually be add…</p> https://cve.radiocsirt.org/vuln/ubuntu-cve-2017-1000410