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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2,079 | libarchive | e79ef306afe332faf22e9b442a2c6b59cb175573 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/e79ef306afe332faf22e9b442a2c6b59cb175573 | Issue #718: Fix TALOS-CAN-152
If a 7-Zip archive declares a rediculously large number of substreams,
it can overflow an internal counter, leading a subsequent memory
allocation to be too small for the substream data.
Thanks to the Open Source and Threat Intelligence project at Cisco
for reporting this issue. | 1 | read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss,
struct _7z_folder *f, size_t numFolders)
{
const unsigned char *p;
uint64_t *usizes;
size_t unpack_streams;
int type;
unsigned i;
uint32_t numDigests;
memset(ss, 0, sizeof(*ss));
for (i = 0; i < numFolders; i++)
f[i].numUnpackStr... | 169,108,747,701,727,020,000,000,000,000,000,000,000 | archive_read_support_format_7zip.c | 116,655,796,222,679,960,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-4300 | Integer overflow in the read_SubStreamsInfo function in archive_read_support_format_7zip.c in libarchive before 3.2.1 allows remote attackers to execute arbitrary code via a 7zip file with a large number of substreams, which triggers a heap-based buffer overflow. | https://nvd.nist.gov/vuln/detail/CVE-2016-4300 |
2,080 | linux | b348d7dddb6c4fbfc810b7a0626e8ec9e29f7cbb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b348d7dddb6c4fbfc810b7a0626e8ec9e29f7cbb | USB: usbip: fix potential out-of-bounds write
Fix potential out-of-bounds write to urb->transfer_buffer
usbip handles network communication directly in the kernel. When receiving a
packet from its peer, usbip code parses headers according to protocol. As
part of this parsing urb->actual_length is filled. Since the inp... | 1 | int usbip_recv_xbuff(struct usbip_device *ud, struct urb *urb)
{
int ret;
int size;
if (ud->side == USBIP_STUB) {
/* the direction of urb must be OUT. */
if (usb_pipein(urb->pipe))
return 0;
size = urb->transfer_buffer_length;
} else {
/* the direction of urb must be IN. */
if (usb_pipeout(urb->pipe)... | 169,401,871,138,519,960,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-3955 | The usbip_recv_xbuff function in drivers/usb/usbip/usbip_common.c in the Linux kernel before 4.5.3 allows remote attackers to cause a denial of service (out-of-bounds write) or possibly have unspecified other impact via a crafted length value in a USB/IP packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-3955 |
2,081 | linux | 4d06dd537f95683aba3651098ae288b7cbff8274 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4d06dd537f95683aba3651098ae288b7cbff8274 | cdc_ncm: do not call usbnet_link_change from cdc_ncm_bind
usbnet_link_change will call schedule_work and should be
avoided if bind is failing. Otherwise we will end up with
scheduled work referring to a netdev which has gone away.
Instead of making the call conditional, we can just defer
it to usbnet_probe, using the... | 1 | static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf)
{
int ret;
/* MBIM backwards compatible function? */
if (cdc_ncm_select_altsetting(intf) != CDC_NCM_COMM_ALTSETTING_NCM)
return -ENODEV;
/* The NCM data altsetting is fixed, so we hard-coded it.
* Additionally, generic NCM devices ar... | 286,704,641,831,086,000,000,000,000,000,000,000,000 | cdc_ncm.c | 107,934,168,350,224,250,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3951 | Double free vulnerability in drivers/net/usb/cdc_ncm.c in the Linux kernel before 4.5 allows physically proximate attackers to cause a denial of service (system crash) or possibly have unspecified other impact by inserting a USB device with an invalid USB descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-3951 |
2,100 | linux | 9842df62004f366b9fed2423e24df10542ee0dc5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9842df62004f366b9fed2423e24df10542ee0dc5 | KVM: MTRR: remove MSR 0x2f8
MSR 0x2f8 accessed the 124th Variable Range MTRR ever since MTRR support
was introduced by 9ba075a664df ("KVM: MTRR support").
0x2f8 became harmful when 910a6aae4e2e ("KVM: MTRR: exactly define the
size of variable MTRRs") shrinked the array of VR MTRRs from 256 to 8,
which made access to ... | 1 | static bool msr_mtrr_valid(unsigned msr)
{
switch (msr) {
case 0x200 ... 0x200 + 2 * KVM_NR_VAR_MTRR - 1:
case MSR_MTRRfix64K_00000:
case MSR_MTRRfix16K_80000:
case MSR_MTRRfix16K_A0000:
case MSR_MTRRfix4K_C0000:
case MSR_MTRRfix4K_C8000:
case MSR_MTRRfix4K_D0000:
case MSR_MTRRfix4K_D8000:
case MSR_MTRRfix4K_... | 102,963,413,536,679,700,000,000,000,000,000,000,000 | mtrr.c | 76,338,732,130,362,965,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-3713 | The msr_mtrr_valid function in arch/x86/kvm/mtrr.c in the Linux kernel before 4.6.1 supports MSR 0x2f8, which allows guest OS users to read or write to the kvm_arch_vcpu data structure, and consequently obtain sensitive information or cause a denial of service (system crash), via a crafted ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2016-3713 |
2,102 | linux | a4a5ed2835e8ea042868b7401dced3f517cafa76 | https://github.com/torvalds/linux | https://github.com/mjg59/linux/commit/a4a5ed2835e8ea042868b7401dced3f517cafa76 | None | 1 | void __init acpi_initrd_override(void *data, size_t size)
{
int sig, no, table_nr = 0, total_offset = 0;
long offset = 0;
struct acpi_table_header *table;
char cpio_path[32] = "kernel/firmware/acpi/";
struct cpio_data file;
if (data == NULL || size == 0)
return;
for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) ... | 192,398,408,080,324,780,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2016-3699 | The Linux kernel, as used in Red Hat Enterprise Linux 7.2 and Red Hat Enterprise MRG 2 and when booted with UEFI Secure Boot enabled, allows local users to bypass intended Secure Boot restrictions and execute untrusted code by appending ACPI tables to the initrd. | https://nvd.nist.gov/vuln/detail/CVE-2016-3699 |
2,106 | linux | 8b8addf891de8a00e4d39fc32f93f7c5eb8feceb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8b8addf891de8a00e4d39fc32f93f7c5eb8feceb | x86/mm/32: Enable full randomization on i386 and X86_32
Currently on i386 and on X86_64 when emulating X86_32 in legacy mode, only
the stack and the executable are randomized but not other mmapped files
(libraries, vDSO, etc.). This patch enables randomization for the
libraries, vDSO and mmap requests on i386 and in X... | 1 | void arch_pick_mmap_layout(struct mm_struct *mm)
{
unsigned long random_factor = 0UL;
if (current->flags & PF_RANDOMIZE)
random_factor = arch_mmap_rnd();
mm->mmap_legacy_base = mmap_legacy_base(random_factor);
if (mmap_is_legacy()) {
mm->mmap_base = mm->mmap_legacy_base;
mm->get_unmapped_area = arch_... | 267,173,138,507,466,800,000,000,000,000,000,000,000 | None | null | [
"CWE-254"
] | CVE-2016-3672 | The arch_pick_mmap_layout function in arch/x86/mm/mmap.c in the Linux kernel through 4.5.2 does not properly randomize the legacy base address, which makes it easier for local users to defeat the intended restrictions on the ADDR_NO_RANDOMIZE flag, and bypass the ASLR protection mechanism for a setuid or setgid program... | https://nvd.nist.gov/vuln/detail/CVE-2016-3672 |
2,111 | linux | 5a07975ad0a36708c6b0a5b9fea1ff811d0b0c1f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5a07975ad0a36708c6b0a5b9fea1ff811d0b0c1f | USB: digi_acceleport: do sanity checking for the number of ports
The driver can be crashed with devices that expose crafted descriptors
with too few endpoints.
See: http://seclists.org/bugtraq/2016/Mar/61
Signed-off-by: Oliver Neukum <ONeukum@suse.com>
[johan: fix OOB endpoint check and add error messages ]
Cc: stab... | 1 | static int digi_startup(struct usb_serial *serial)
{
struct digi_serial *serial_priv;
int ret;
serial_priv = kzalloc(sizeof(*serial_priv), GFP_KERNEL);
if (!serial_priv)
return -ENOMEM;
spin_lock_init(&serial_priv->ds_serial_lock);
serial_priv->ds_oob_port_num = serial->type->num_ports;
serial_priv->d... | 92,921,252,960,895,370,000,000,000,000,000,000,000 | digi_acceleport.c | 48,588,831,952,256,350,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3140 | The digi_port_init function in drivers/usb/serial/digi_acceleport.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted endpoints value in a USB device descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-3140 |
2,112 | linux | 8835ba4a39cf53f705417b3b3a94eb067673f2c9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8835ba4a39cf53f705417b3b3a94eb067673f2c9 | USB: cdc-acm: more sanity checking
An attack has become available which pretends to be a quirky
device circumventing normal sanity checks and crashes the kernel
by an insufficient number of interfaces. This patch adds a check
to the code path for quirky devices.
Signed-off-by: Oliver Neukum <ONeukum@suse.com>
CC: sta... | 1 | static int acm_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_cdc_union_desc *union_header = NULL;
struct usb_cdc_country_functional_desc *cfd = NULL;
unsigned char *buffer = intf->altsetting->extra;
int buflen = intf->altsetting->extralen;
struct usb_interface *control_inter... | 335,035,965,676,808,180,000,000,000,000,000,000,000 | cdc-acm.c | 196,077,235,851,485,950,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3138 | The acm_probe function in drivers/usb/class/cdc-acm.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a USB device without both a control and a data endpoint descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-3138 |
2,113 | linux | c55aee1bf0e6b6feec8b2927b43f7a09a6d5f754 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c55aee1bf0e6b6feec8b2927b43f7a09a6d5f754 | USB: cypress_m8: add endpoint sanity check
An attack using missing endpoints exists.
CVE-2016-3137
Signed-off-by: Oliver Neukum <ONeukum@suse.com>
CC: stable@vger.kernel.org
Signed-off-by: Johan Hovold <johan@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 1 | static int cypress_generic_port_probe(struct usb_serial_port *port)
{
struct usb_serial *serial = port->serial;
struct cypress_private *priv;
priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->comm_is_ok = !0;
spin_lock_init(&priv->lock);
if (kfifo_alloc(&priv-... | 117,115,164,139,605,750,000,000,000,000,000,000,000 | cypress_m8.c | 185,821,559,057,352,680,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3137 | drivers/usb/serial/cypress_m8.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a USB device without both an interrupt-in and an interrupt-out endpoint descriptor, related to the cypress_generic_port_probe and cypress_op... | https://nvd.nist.gov/vuln/detail/CVE-2016-3137 |
2,114 | linux | c55aee1bf0e6b6feec8b2927b43f7a09a6d5f754 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c55aee1bf0e6b6feec8b2927b43f7a09a6d5f754 | USB: cypress_m8: add endpoint sanity check
An attack using missing endpoints exists.
CVE-2016-3137
Signed-off-by: Oliver Neukum <ONeukum@suse.com>
CC: stable@vger.kernel.org
Signed-off-by: Johan Hovold <johan@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 1 | static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port)
{
struct cypress_private *priv = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
unsigned long flags;
int result = 0;
if (!priv->comm_is_ok)
return -EIO;
/* clear halts before open */
usb_clear_halt(serial... | 24,933,462,448,207,740,000,000,000,000,000,000,000 | cypress_m8.c | 185,821,559,057,352,680,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3137 | drivers/usb/serial/cypress_m8.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a USB device without both an interrupt-in and an interrupt-out endpoint descriptor, related to the cypress_generic_port_probe and cypress_op... | https://nvd.nist.gov/vuln/detail/CVE-2016-3137 |
2,115 | linux | 4e9a0b05257f29cf4b75f3209243ed71614d062e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4e9a0b05257f29cf4b75f3209243ed71614d062e | USB: mct_u232: add sanity checking in probe
An attack using the lack of sanity checking in probe is known. This
patch checks for the existence of a second port.
CVE-2016-3136
Signed-off-by: Oliver Neukum <ONeukum@suse.com>
CC: stable@vger.kernel.org
[johan: add error message ]
Signed-off-by: Johan Hovold <johan@kern... | 1 | static int mct_u232_port_probe(struct usb_serial_port *port)
{
struct mct_u232_private *priv;
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
/* Use second interrupt-in endpoint for reading. */
priv->read_urb = port->serial->port[1]->interrupt_in_urb;
priv->read_urb->context = ... | 198,666,769,052,711,000,000,000,000,000,000,000,000 | mct_u232.c | 126,483,507,316,033,960,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3136 | The mct_u232_msr_to_state function in drivers/usb/serial/mct_u232.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted USB device without two interrupt-in endpoint descriptors. | https://nvd.nist.gov/vuln/detail/CVE-2016-3136 |
2,116 | linux | d157bd761585605b7882935ffb86286919f62ea1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d157bd761585605b7882935ffb86286919f62ea1 | netfilter: x_tables: check for size overflow
Ben Hawkes says:
integer overflow in xt_alloc_table_info, which on 32-bit systems can
lead to small structure allocation and a copy_from_user based heap
corruption.
Reported-by: Ben Hawkes <hawkes@google.com>
Signed-off-by: Florian Westphal <fw@strlen.de>
Signed-off-by:... | 1 | struct xt_table_info *xt_alloc_table_info(unsigned int size)
{
struct xt_table_info *info = NULL;
size_t sz = sizeof(*info) + size;
/* Pedantry: prevent them from hitting BUG() in vmalloc.c --RR */
if ((SMP_ALIGN(size) >> PAGE_SHIFT) + 2 > totalram_pages)
return NULL;
if (sz <= (PAGE_SIZE << PAGE_ALLOC_C... | 123,369,081,460,672,790,000,000,000,000,000,000,000 | x_tables.c | 15,814,788,980,344,083,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2016-3135 | Integer overflow in the xt_alloc_table_info function in net/netfilter/x_tables.c in the Linux kernel through 4.5.2 on 32-bit platforms allows local users to gain privileges or cause a denial of service (heap memory corruption) via an IPT_SO_SET_REPLACE setsockopt call. | https://nvd.nist.gov/vuln/detail/CVE-2016-3135 |
2,130 | php-src | 28a6ed9f9a36b9c517e4a8a429baf4dd382fc5d5 | https://github.com/php/php-src | http://github.com/php/php-src/commit/28a6ed9f9a36b9c517e4a8a429baf4dd382fc5d5?w=1 | Fix bug #71735: Double-free in SplDoublyLinkedList::offsetSet | 1 | SPL_METHOD(SplDoublyLinkedList, offsetSet)
{
zval *zindex, *value;
spl_dllist_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &zindex, &value) == FAILURE) {
return;
}
intern = Z_SPLDLLIST_P(getThis());
if (Z_TYPE_P(zindex) == IS_NULL) {
/* $obj[] = ... */
spl_ptr_lli... | 324,100,465,917,832,940,000,000,000,000,000,000,000 | None | null | [
"CWE-415"
] | CVE-2016-3132 | Double free vulnerability in the SplDoublyLinkedList::offsetSet function in ext/spl/spl_dllist.c in PHP 7.x before 7.0.6 allows remote attackers to execute arbitrary code via a crafted index. | https://nvd.nist.gov/vuln/detail/CVE-2016-3132 |
2,131 | krb5 | 93b4a6306a0026cf1cc31ac4bd8a49ba5d034ba7 | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/93b4a6306a0026cf1cc31ac4bd8a49ba5d034ba7 | Fix S4U2Self KDC crash when anon is restricted
In validate_as_request(), when enforcing restrict_anonymous_to_tgt,
use client.princ instead of request->client; the latter is NULL when
validating S4U2Self requests.
CVE-2016-3120:
In MIT krb5 1.9 and later, an authenticated attacker can cause krb5kdc
to dereference a ... | 1 | validate_as_request(kdc_realm_t *kdc_active_realm,
register krb5_kdc_req *request, krb5_db_entry client,
krb5_db_entry server, krb5_timestamp kdc_time,
const char **status, krb5_pa_data ***e_data)
{
int errcode;
krb5_error_code ret;
/*
* If a... | 67,017,454,586,486,290,000,000,000,000,000,000,000 | kdc_util.c | 132,323,104,047,921,250,000,000,000,000,000,000,000 | [
"CWE-476"
] | CVE-2016-3120 | The validate_as_request function in kdc_util.c in the Key Distribution Center (KDC) in MIT Kerberos 5 (aka krb5) before 1.13.6 and 1.4.x before 1.14.3, when restrict_anonymous_to_tgt is enabled, uses an incorrect client data structure, which allows remote authenticated users to cause a denial of service (NULL pointer d... | https://nvd.nist.gov/vuln/detail/CVE-2016-3120 |
2,132 | krb5 | 08c642c09c38a9c6454ab43a9b53b2a89b9eef99 | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/08c642c09c38a9c6454ab43a9b53b2a89b9eef99 | Fix LDAP null deref on empty arg [CVE-2016-3119]
In the LDAP KDB module's process_db_args(), strtok_r() may return NULL
if there is an empty string in the db_args array. Check for this case
and avoid dereferencing a null pointer.
CVE-2016-3119:
In MIT krb5 1.6 and later, an authenticated attacker with permission
to... | 1 | process_db_args(krb5_context context, char **db_args, xargs_t *xargs,
OPERATION optype)
{
int i=0;
krb5_error_code st=0;
char *arg=NULL, *arg_val=NULL;
char **dptr=NULL;
unsigned int arg_val_len=0;
if (db_args) ... | 14,345,514,354,298,604,000,000,000,000,000,000,000 | ldap_principal2.c | 231,627,571,456,055,550,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-3119 | The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon cra... | https://nvd.nist.gov/vuln/detail/CVE-2016-3119 |
2,134 | libgd | 2bb97f407c1145c850416a3bfbcc8cf124e68a19 | https://github.com/libgd/libgd | https://github.com/libgd/libgd/commit/2bb97f407c1145c850416a3bfbcc8cf124e68a19 | gd2: handle corrupt images better (CVE-2016-3074)
Make sure we do some range checking on corrupted chunks.
Thanks to Hans Jerry Illikainen <hji@dyntopia.com> for indepth report
and reproducer information. Made for easy test case writing :). | 1 | _gd2GetHeader (gdIOCtxPtr in, int *sx, int *sy,
int *cs, int *vers, int *fmt, int *ncx, int *ncy,
t_chunk_info ** chunkIdx)
{
int i;
int ch;
char id[5];
t_chunk_info *cidx;
int sidx;
int nc;
GD2_DBG (printf ("Reading gd2 header info\n"));
for (i = 0; i < 4; i++) {
ch = gdGetC (... | 166,042,292,574,051,100,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2016-3074 | Integer signedness error in GD Graphics Library 2.1.1 (aka libgd or libgd2) allows remote attackers to cause a denial of service (crash) or potentially execute arbitrary code via crafted compressed gd2 data, which triggers a heap-based buffer overflow. | https://nvd.nist.gov/vuln/detail/CVE-2016-3074 |
2,137 | FFmpeg | 689e59b7ffed34eba6159dcc78e87133862e3746 | https://github.com/FFmpeg/FFmpeg | https://github.com/FFmpeg/FFmpeg/commit/689e59b7ffed34eba6159dcc78e87133862e3746 | mov: reset dref_count on realloc to keep values consistent.
This fixes a potential crash.
Signed-off-by: Michael Niedermayer <michaelni@gmx.at> | 1 | static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
MOVStreamContext *sc;
int entries, i, j;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data;
avio_rb32(pb); // version + flags
entries = avio_rb... | 79,747,855,433,813,770,000,000,000,000,000,000,000 | mov.c | 89,945,014,034,723,900,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-3062 | The mov_read_dref function in libavformat/mov.c in Libav before 11.7 and FFmpeg before 0.11 allows remote attackers to cause a denial of service (memory corruption) or execute arbitrary code via the entries value in a dref box in an MP4 file. | https://nvd.nist.gov/vuln/detail/CVE-2016-3062 |
2,141 | linux | cac9b50b0d75a1d50d6c056ff65c005f3224c8e0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cac9b50b0d75a1d50d6c056ff65c005f3224c8e0 | USB: visor: fix null-deref at probe
Fix null-pointer dereference at probe should a (malicious) Treo device
lack the expected endpoints.
Specifically, the Treo port-setup hack was dereferencing the bulk-in and
interrupt-in urbs without first making sure they had been allocated by
core.
Fixes: 1da177e4c3f4 ("Linux-2.6... | 1 | static int treo_attach(struct usb_serial *serial)
{
struct usb_serial_port *swap_port;
/* Only do this endpoint hack for the Handspring devices with
* interrupt in endpoints, which for now are the Treo devices. */
if (!((le16_to_cpu(serial->dev->descriptor.idVendor)
== HANDSPRING_VENDOR_ID) ||
(le16_to_cp... | 198,842,744,337,888,960,000,000,000,000,000,000,000 | visor.c | 261,946,761,120,480,700,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-2782 | The treo_attach function in drivers/usb/serial/visor.c in the Linux kernel before 4.5 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a (1) bulk-in or (2) interrupt-in endpoint. | https://nvd.nist.gov/vuln/detail/CVE-2016-2782 |
2,149 | linux | b5a663aa426f4884c71cd8580adae73f33570f0d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5a663aa426f4884c71cd8580adae73f33570f0d | ALSA: timer: Harden slave timer list handling
A slave timer instance might be still accessible in a racy way while
operating the master instance as it lacks of locking. Since the
master operation is mostly protected with timer->lock, we should cope
with it while changing the slave instance, too. Also, some linked
li... | 1 | static int _snd_timer_stop(struct snd_timer_instance * timeri,
int keep_flag, int event)
{
struct snd_timer *timer;
unsigned long flags;
if (snd_BUG_ON(!timeri))
return -ENXIO;
if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
if (!keep_flag) {
spin_lock_irqsave(&slave_active_lock, flags);
timeri->... | 198,967,134,467,265,500,000,000,000,000,000,000,000 | timer.c | 233,862,501,943,978,640,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-2548 | sound/core/timer.c in the Linux kernel before 4.4.1 retains certain linked lists after a close or stop action, which allows local users to cause a denial of service (system crash) via a crafted ioctl call, related to the (1) snd_timer_close and (2) _snd_timer_stop functions. | https://nvd.nist.gov/vuln/detail/CVE-2016-2548 |
2,151 | linux | b5a663aa426f4884c71cd8580adae73f33570f0d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5a663aa426f4884c71cd8580adae73f33570f0d | ALSA: timer: Harden slave timer list handling
A slave timer instance might be still accessible in a racy way while
operating the master instance as it lacks of locking. Since the
master operation is mostly protected with timer->lock, we should cope
with it while changing the slave instance, too. Also, some linked
li... | 1 | int snd_timer_close(struct snd_timer_instance *timeri)
{
struct snd_timer *timer = NULL;
struct snd_timer_instance *slave, *tmp;
if (snd_BUG_ON(!timeri))
return -ENXIO;
/* force to stop the timer */
snd_timer_stop(timeri);
if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
/* wait, until the active callback is ... | 191,662,303,613,238,740,000,000,000,000,000,000,000 | timer.c | 233,862,501,943,978,640,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-2548 | sound/core/timer.c in the Linux kernel before 4.4.1 retains certain linked lists after a close or stop action, which allows local users to cause a denial of service (system crash) via a crafted ioctl call, related to the (1) snd_timer_close and (2) _snd_timer_stop functions. | https://nvd.nist.gov/vuln/detail/CVE-2016-2548 |
2,157 | linux | ee8413b01045c74340aa13ad5bdf905de32be736 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ee8413b01045c74340aa13ad5bdf905de32be736 | ALSA: timer: Fix double unlink of active_list
ALSA timer instance object has a couple of linked lists and they are
unlinked unconditionally at snd_timer_stop(). Meanwhile
snd_timer_interrupt() unlinks it, but it calls list_del() which leaves
the element list itself unchanged. This ends up with unlinking twice,
and i... | 1 | void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left)
{
struct snd_timer_instance *ti, *ts, *tmp;
unsigned long resolution, ticks;
struct list_head *p, *ack_list_head;
unsigned long flags;
int use_tasklet = 0;
if (timer == NULL)
return;
spin_lock_irqsave(&timer->lock, flags);
/* reme... | 165,319,567,416,196,800,000,000,000,000,000,000,000 | timer.c | 66,297,701,640,317,620,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2016-2545 | The snd_timer_interrupt function in sound/core/timer.c in the Linux kernel before 4.4.1 does not properly maintain a certain linked list, which allows local users to cause a denial of service (race condition and system crash) via a crafted ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2016-2545 |
2,158 | linux | 3567eb6af614dac436c4b16a8d426f9faed639b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3567eb6af614dac436c4b16a8d426f9faed639b3 | ALSA: seq: Fix race at timer setup and close
ALSA sequencer code has an open race between the timer setup ioctl and
the close of the client. This was triggered by syzkaller fuzzer, and
a use-after-free was caught there as a result.
This patch papers over it by adding a proper queue->timer_mutex lock
around the timer... | 1 | static void queue_delete(struct snd_seq_queue *q)
{
/* stop and release the timer */
snd_seq_timer_stop(q->timer);
snd_seq_timer_close(q);
/* wait until access free */
snd_use_lock_sync(&q->use_lock);
/* release resources... */
snd_seq_prioq_delete(&q->tickq);
snd_seq_prioq_delete(&q->timeq);
snd_seq_t... | 178,529,605,273,024,480,000,000,000,000,000,000,000 | seq_queue.c | 75,888,079,069,082,210,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2016-2544 | Race condition in the queue_delete function in sound/core/seq/seq_queue.c in the Linux kernel before 4.4.1 allows local users to cause a denial of service (use-after-free and system crash) by making an ioctl call at a certain time. | https://nvd.nist.gov/vuln/detail/CVE-2016-2544 |
2,159 | linux | 030e2c78d3a91dd0d27fef37e91950dde333eba1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/030e2c78d3a91dd0d27fef37e91950dde333eba1 | ALSA: seq: Fix missing NULL check at remove_events ioctl
snd_seq_ioctl_remove_events() calls snd_seq_fifo_clear()
unconditionally even if there is no FIFO assigned, and this leads to
an Oops due to NULL dereference. The fix is just to add a proper NULL
check.
Reported-by: Dmitry Vyukov <dvyukov@google.com>
Tested-by... | 1 | static int snd_seq_ioctl_remove_events(struct snd_seq_client *client,
void __user *arg)
{
struct snd_seq_remove_events info;
if (copy_from_user(&info, arg, sizeof(info)))
return -EFAULT;
/*
* Input mostly not implemented XXX.
*/
if (info.remove_mode & SNDRV_SEQ_REMOVE_INPUT) {
/*
* No restr... | 154,168,597,763,000,470,000,000,000,000,000,000,000 | None | null | [
"CWE-703"
] | CVE-2016-2543 | The snd_seq_ioctl_remove_events function in sound/core/seq/seq_clientmgr.c in the Linux kernel before 4.4.1 does not verify FIFO assignment before proceeding with FIFO clearing, which allows local users to cause a denial of service (NULL pointer dereference and OOPS) via a crafted ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2016-2543 |
2,160 | kamailio | f50c9c853e7809810099c970780c30b0765b0643 | https://github.com/kamailio/kamailio | https://github.com/kamailio/kamailio/commit/f50c9c853e7809810099c970780c30b0765b0643 | seas: safety check for target buffer size before copying message in encode_msg()
- avoid buffer overflow for large SIP messages
- reported by Stelios Tsampas | 1 | int encode_msg(struct sip_msg *msg,char *payload,int len)
{
int i,j,k,u,request;
unsigned short int h;
struct hdr_field* hf;
struct msg_start* ms;
struct sip_uri miuri;
char *myerror=NULL;
ptrdiff_t diff;
if(len < MAX_ENCODED_MSG + MAX_MESSAGE_LEN)
return -1;
if(parse_headers(msg,H... | 307,752,200,007,300,920,000,000,000,000,000,000,000 | encode_msg.c | 134,975,203,358,462,500,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-2385 | Heap-based buffer overflow in the encode_msg function in encode_msg.c in the SEAS module in Kamailio (formerly OpenSER and SER) before 4.3.5 allows remote attackers to cause a denial of service (memory corruption and process crash) or possibly execute arbitrary code via a large SIP packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-2385 |
2,161 | linux | 07d86ca93db7e5cdf4743564d98292042ec21af7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07d86ca93db7e5cdf4743564d98292042ec21af7 | ALSA: usb-audio: avoid freeing umidi object twice
The 'umidi' object will be free'd on the error path by snd_usbmidi_free()
when tearing down the rawmidi interface. So we shouldn't try to free it
in snd_usbmidi_create() after having registered the rawmidi interface.
Found by KASAN.
Signed-off-by: Andrey Konovalov <a... | 1 | int snd_usbmidi_create(struct snd_card *card,
struct usb_interface *iface,
struct list_head *midi_list,
const struct snd_usb_audio_quirk *quirk)
{
struct snd_usb_midi *umidi;
struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS];
int out_ports, in_ports;
int i, err;
umidi = kz... | 186,007,020,350,234,550,000,000,000,000,000,000,000 | midi.c | 58,837,838,038,525,350,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-2384 | Double free vulnerability in the snd_usbmidi_create function in sound/usb/midi.c in the Linux kernel before 4.5 allows physically proximate attackers to cause a denial of service (panic) or possibly have unspecified other impact via vectors involving an invalid USB descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-2384 |
2,162 | linux | a1b14d27ed0965838350f1377ff97c93ee383492 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a1b14d27ed0965838350f1377ff97c93ee383492 | bpf: fix branch offset adjustment on backjumps after patching ctx expansion
When ctx access is used, the kernel often needs to expand/rewrite
instructions, so after that patching, branch offsets have to be
adjusted for both forward and backward jumps in the new eBPF program,
but for backward jumps it fails to account ... | 1 | static void adjust_branches(struct bpf_prog *prog, int pos, int delta)
{
struct bpf_insn *insn = prog->insnsi;
int insn_cnt = prog->len;
int i;
for (i = 0; i < insn_cnt; i++, insn++) {
if (BPF_CLASS(insn->code) != BPF_JMP ||
BPF_OP(insn->code) == BPF_CALL ||
BPF_OP(insn->code) == BPF_EXIT)
continu... | 86,907,338,874,595,770,000,000,000,000,000,000,000 | verifier.c | 174,489,182,060,393,200,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-2383 | The adjust_branches function in kernel/bpf/verifier.c in the Linux kernel before 4.5 does not consider the delta in the backward-jump case, which allows local users to obtain sensitive information from kernel memory by creating a packet filter and then loading crafted BPF instructions. | https://nvd.nist.gov/vuln/detail/CVE-2016-2383 |
2,178 | git | 34fa79a6cde56d6d428ab0d3160cb094ebad3305 | https://github.com/git/git | https://github.com/git/git/commit/34fa79a6cde56d6d428ab0d3160cb094ebad3305 | prefer memcpy to strcpy
When we already know the length of a string (e.g., because
we just malloc'd to fit it), it's nicer to use memcpy than
strcpy, as it makes it more obvious that we are not going to
overflow the buffer (because the size we pass matches the
size in the allocation).
This also eliminates calls to st... | 1 | char *path_name(const struct name_path *path, const char *name)
{
const struct name_path *p;
char *n, *m;
int nlen = strlen(name);
int len = nlen + 1;
for (p = path; p; p = p->up) {
if (p->elem_len)
len += p->elem_len + 1;
}
n = xmalloc(len);
m = n + len - (nlen + 1);
strcpy(m, name);
for (p = path;... | 244,617,430,946,765,540,000,000,000,000,000,000,000 | revision.c | 139,882,901,556,130,910,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-2315 | revision.c in git before 2.7.4 uses an incorrect integer data type, which allows remote attackers to execute arbitrary code via a (1) long filename or (2) many nested trees, leading to a heap-based buffer overflow. | https://nvd.nist.gov/vuln/detail/CVE-2016-2315 |
2,179 | linux | 4ec0ef3a82125efc36173062a50624550a900ae0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4ec0ef3a82125efc36173062a50624550a900ae0 | USB: iowarrior: fix oops with malicious USB descriptors
The iowarrior driver expects at least one valid endpoint. If given
malicious descriptors that specify 0 for the number of endpoints,
it will crash in the probe function. Ensure there is at least
one endpoint on the interface before using it.
The full report of... | 1 | static int iowarrior_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(interface);
struct iowarrior *dev = NULL;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
int i;
int retval = -ENOMEM;
/* allocate me... | 184,277,450,702,665,200,000,000,000,000,000,000,000 | iowarrior.c | 43,223,000,391,687,380,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-2188 | The iowarrior_probe function in drivers/usb/misc/iowarrior.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted endpoints value in a USB device descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-2188 |
2,180 | linux | 162f98dea487206d9ab79fc12ed64700667a894d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/162f98dea487206d9ab79fc12ed64700667a894d | Input: gtco - fix crash on detecting device without endpoints
The gtco driver expects at least one valid endpoint. If given malicious
descriptors that specify 0 for the number of endpoints, it will crash in
the probe function. Ensure there is at least one endpoint on the interface
before using it.
Also let's fix a mi... | 1 | static int gtco_probe(struct usb_interface *usbinterface,
const struct usb_device_id *id)
{
struct gtco *gtco;
struct input_dev *input_dev;
struct hid_descriptor *hid_desc;
char *report;
int result = 0, retry;
int error;
struct usb_endpoint_d... | 91,802,595,213,563,340,000,000,000,000,000,000,000 | gtco.c | 272,997,561,883,214,830,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-2187 | The gtco_probe function in drivers/input/tablet/gtco.c in the Linux kernel through 4.5.2 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted endpoints value in a USB device descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-2187 |
2,181 | linux | 9c6ba456711687b794dcf285856fc14e2c76074f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9c6ba456711687b794dcf285856fc14e2c76074f | Input: powermate - fix oops with malicious USB descriptors
The powermate driver expects at least one valid USB endpoint in its
probe function. If given malicious descriptors that specify 0 for
the number of endpoints, it will crash. Validate the number of
endpoints on the interface before using them.
The full repor... | 1 | static int powermate_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev (intf);
struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint;
struct powermate_device *pm;
struct input_dev *input_dev;
int pipe, maxp;
int error = -EN... | 222,563,563,219,301,300,000,000,000,000,000,000,000 | powermate.c | 76,926,132,104,944,360,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-2186 | The powermate_probe function in drivers/input/misc/powermate.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted endpoints value in a USB device descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-2186 |
2,182 | linux | 950336ba3e4a1ffd2ca60d29f6ef386dd2c7351d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/950336ba3e4a1ffd2ca60d29f6ef386dd2c7351d | Input: ati_remote2 - fix crashes on detecting device with invalid descriptor
The ati_remote2 driver expects at least two interfaces with one
endpoint each. If given malicious descriptor that specify one
interface or no endpoints, it will crash in the probe function.
Ensure there is at least two interfaces and one endp... | 1 | static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(interface);
struct usb_host_interface *alt = interface->cur_altsetting;
struct ati_remote2 *ar2;
int r;
if (alt->desc.bInterfaceNumber)
return -ENODEV;
ar2 = kzalloc(si... | 67,491,629,253,766,480,000,000,000,000,000,000,000 | ati_remote2.c | 263,372,229,415,855,000,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-2185 | The ati_remote2_probe function in drivers/input/misc/ati_remote2.c in the Linux kernel before 4.5.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted endpoints value in a USB device descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-2185 |
2,184 | linux | f43bfaeddc79effbf3d0fcb53ca477cca66f3db8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f43bfaeddc79effbf3d0fcb53ca477cca66f3db8 | atl2: Disable unimplemented scatter/gather feature
atl2 includes NETIF_F_SG in hw_features even though it has no support
for non-linear skbs. This bug was originally harmless since the
driver does not claim to implement checksum offload and that used to
be a requirement for SG.
Now that SG and checksum offload are i... | 1 | static int atl2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
struct net_device *netdev;
struct atl2_adapter *adapter;
static int cards_found;
unsigned long mmio_start;
int mmio_len;
int err;
cards_found = 0;
err = pci_enable_device(pdev);
if (err)
return err;
/*
* atl2 is a shared-hig... | 15,763,019,659,237,995,000,000,000,000,000,000,000 | atl2.c | 62,900,487,325,653,490,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-2117 | The atl2_probe function in drivers/net/ethernet/atheros/atlx/atl2.c in the Linux kernel through 4.5.2 incorrectly enables scatter/gather I/O, which allows remote attackers to obtain sensitive information from kernel memory by reading packet data. | https://nvd.nist.gov/vuln/detail/CVE-2016-2117 |
2,185 | linux | 613317bd212c585c20796c10afe5daaa95d4b0a1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/613317bd212c585c20796c10afe5daaa95d4b0a1 | EVM: Use crypto_memneq() for digest comparisons
This patch fixes vulnerability CVE-2016-2085. The problem exists
because the vm_verify_hmac() function includes a use of memcmp().
Unfortunately, this allows timing side channel attacks; specifically
a MAC forgery complexity drop from 2^128 to 2^12. This patch changes
... | 1 | static enum integrity_status evm_verify_hmac(struct dentry *dentry,
const char *xattr_name,
char *xattr_value,
size_t xattr_value_len,
struct integrity_iint_cache *iint)
{
struct evm_ima_xattr_data *xattr_data = NULL;
struct evm_ima_xattr_data calc;
enum integrity_status evm_s... | 88,333,432,303,897,410,000,000,000,000,000,000,000 | evm_main.c | 81,031,715,794,005,370,000,000,000,000,000,000,000 | [
"CWE-19"
] | CVE-2016-2085 | The evm_verify_hmac function in security/integrity/evm/evm_main.c in the Linux kernel before 4.5 does not properly copy data, which makes it easier for local users to forge MAC values via a timing side-channel attack. | https://nvd.nist.gov/vuln/detail/CVE-2016-2085 |
2,186 | linux | 8b8a321ff72c785ed5e8b4cf6eda20b35d427390 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8b8a321ff72c785ed5e8b4cf6eda20b35d427390 | tcp: fix zero cwnd in tcp_cwnd_reduction
Patch 3759824da87b ("tcp: PRR uses CRB mode by default and SS mode
conditionally") introduced a bug that cwnd may become 0 when both
inflight and sndcnt are 0 (cwnd = inflight + sndcnt). This may lead
to a div-by-zero if the connection starts another cwnd reduction
phase by set... | 1 | static void tcp_cwnd_reduction(struct sock *sk, const int prior_unsacked,
int fast_rexmit, int flag)
{
struct tcp_sock *tp = tcp_sk(sk);
int sndcnt = 0;
int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);
int newly_acked_sacked = prior_unsacked -
(tp->packets_out - tp->sacked_out);
tp->pr... | 136,149,861,517,984,150,000,000,000,000,000,000,000 | tcp_input.c | 150,702,089,358,866,060,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2016-2070 | The tcp_cwnd_reduction function in net/ipv4/tcp_input.c in the Linux kernel before 4.3.5 allows remote attackers to cause a denial of service (divide-by-zero error and system crash) via crafted TCP traffic. | https://nvd.nist.gov/vuln/detail/CVE-2016-2070 |
2,190 | linux | 0d62e9dd6da45bbf0f33a8617afc5fe774c8f45f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0d62e9dd6da45bbf0f33a8617afc5fe774c8f45f | ASN.1: Fix non-match detection failure on data overrun
If the ASN.1 decoder is asked to parse a sequence of objects, non-optional
matches get skipped if there's no more data to be had rather than a
data-overrun error being reported.
This is due to the code segment that decides whether to skip optional
matches (ie. ma... | 1 | int asn1_ber_decoder(const struct asn1_decoder *decoder,
void *context,
const unsigned char *data,
size_t datalen)
{
const unsigned char *machine = decoder->machine;
const asn1_action_t *actions = decoder->actions;
size_t machlen = decoder->machlen;
enum asn1_opcode op;
unsigned char tag = 0, ... | 281,485,108,536,962,730,000,000,000,000,000,000,000 | asn1_decoder.c | 60,105,720,755,512,370,000,000,000,000,000,000,000 | [
"CWE-310"
] | CVE-2016-2053 | The asn1_ber_decoder function in lib/asn1_decoder.c in the Linux kernel before 4.3 allows attackers to cause a denial of service (panic) via an ASN.1 BER file that lacks a public key, leading to mishandling by the public_key_verify_signature function in crypto/asymmetric_keys/public_key.c. | https://nvd.nist.gov/vuln/detail/CVE-2016-2053 |
2,191 | linux | f5364c150aa645b3d7daa21b5c0b9feaa1c9cd6d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f5364c150aa645b3d7daa21b5c0b9feaa1c9cd6d | Merge branch 'stacking-fixes' (vfs stacking fixes from Jann)
Merge filesystem stacking fixes from Jann Horn.
* emailed patches from Jann Horn <jannh@google.com>:
sched: panic on corrupted stack end
ecryptfs: forbid opening files without mmap handler
proc: prevent stacking filesystems on top | 1 | int ecryptfs_privileged_open(struct file **lower_file,
struct dentry *lower_dentry,
struct vfsmount *lower_mnt,
const struct cred *cred)
{
struct ecryptfs_open_req req;
int flags = O_LARGEFILE;
int rc = 0;
init_completion(&req.done);
req.lower_file = lower_file;
req.path.dentry = lower_de... | 220,567,525,408,729,400,000,000,000,000,000,000,000 | kthread.c | 262,656,286,475,236,060,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-1583 | The ecryptfs_privileged_open function in fs/ecryptfs/kthread.c in the Linux kernel before 4.6.3 allows local users to gain privileges or cause a denial of service (stack memory consumption) via vectors involving crafted mmap calls for /proc pathnames, leading to recursive pagefault handling. | https://nvd.nist.gov/vuln/detail/CVE-2016-1583 |
2,192 | linux | f5364c150aa645b3d7daa21b5c0b9feaa1c9cd6d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f5364c150aa645b3d7daa21b5c0b9feaa1c9cd6d | Merge branch 'stacking-fixes' (vfs stacking fixes from Jann)
Merge filesystem stacking fixes from Jann Horn.
* emailed patches from Jann Horn <jannh@google.com>:
sched: panic on corrupted stack end
ecryptfs: forbid opening files without mmap handler
proc: prevent stacking filesystems on top | 1 | static struct dentry *proc_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data)
{
int err;
struct super_block *sb;
struct pid_namespace *ns;
char *options;
if (flags & MS_KERNMOUNT) {
ns = (struct pid_namespace *)data;
options = NULL;
} else {
ns = task_active_pid_ns(curren... | 22,816,658,102,788,136,000,000,000,000,000,000,000 | root.c | 66,270,550,699,839,220,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-1583 | The ecryptfs_privileged_open function in fs/ecryptfs/kthread.c in the Linux kernel before 4.6.3 allows local users to gain privileges or cause a denial of service (stack memory consumption) via vectors involving crafted mmap calls for /proc pathnames, leading to recursive pagefault handling. | https://nvd.nist.gov/vuln/detail/CVE-2016-1583 |
2,193 | linux | f5364c150aa645b3d7daa21b5c0b9feaa1c9cd6d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f5364c150aa645b3d7daa21b5c0b9feaa1c9cd6d | Merge branch 'stacking-fixes' (vfs stacking fixes from Jann)
Merge filesystem stacking fixes from Jann Horn.
* emailed patches from Jann Horn <jannh@google.com>:
sched: panic on corrupted stack end
ecryptfs: forbid opening files without mmap handler
proc: prevent stacking filesystems on top | 1 | static inline void schedule_debug(struct task_struct *prev)
{
#ifdef CONFIG_SCHED_STACK_END_CHECK
BUG_ON(task_stack_end_corrupted(prev));
#endif
if (unlikely(in_atomic_preempt_off())) {
__schedule_bug(prev);
preempt_count_set(PREEMPT_DISABLED);
}
rcu_sleep_check();
profile_hit(SCHED_PROFILING, __builti... | 48,505,379,334,574,200,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-1583 | The ecryptfs_privileged_open function in fs/ecryptfs/kthread.c in the Linux kernel before 4.6.3 allows local users to gain privileges or cause a denial of service (stack memory consumption) via vectors involving crafted mmap calls for /proc pathnames, leading to recursive pagefault handling. | https://nvd.nist.gov/vuln/detail/CVE-2016-1583 |
2,194 | libarchive | d0331e8e5b05b475f20b1f3101fe1ad772d7e7e7 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/d0331e8e5b05b475f20b1f3101fe1ad772d7e7e7 | Issue #656: Fix CVE-2016-1541, VU#862384
When reading OS X metadata entries in Zip archives that were stored
without compression, libarchive would use the uncompressed entry size
to allocate a buffer but would use the compressed entry size to limit
the amount of data copied into that buffer. Since the compressed
and... | 1 | zip_read_mac_metadata(struct archive_read *a, struct archive_entry *entry,
struct zip_entry *rsrc)
{
struct zip *zip = (struct zip *)a->format->data;
unsigned char *metadata, *mp;
int64_t offset = archive_filter_bytes(&a->archive, 0);
size_t remaining_bytes, metadata_bytes;
ssize_t hsize;
int ret = ARCHIVE_OK... | 83,728,023,161,742,490,000,000,000,000,000,000,000 | archive_read_support_format_zip.c | 321,320,380,826,748,560,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-1541 | Heap-based buffer overflow in the zip_read_mac_metadata function in archive_read_support_format_zip.c in libarchive before 3.2.0 allows remote attackers to execute arbitrary code via crafted entry-size values in a ZIP archive. | https://nvd.nist.gov/vuln/detail/CVE-2016-1541 |
2,195 | linux | 999653786df6954a31044528ac3f7a5dadca08f4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/999653786df6954a31044528ac3f7a5dadca08f4 | nfsd: check permissions when setting ACLs
Use set_posix_acl, which includes proper permission checks, instead of
calling ->set_acl directly. Without this anyone may be able to grant
themselves permissions to a file by setting the ACL.
Lock the inode to make the new checks atomic with respect to set_acl.
(Also, nfsd ... | 1 | static __be32 nfsacld_proc_setacl(struct svc_rqst * rqstp,
struct nfsd3_setaclargs *argp,
struct nfsd_attrstat *resp)
{
struct inode *inode;
svc_fh *fh;
__be32 nfserr = 0;
int error;
dprintk("nfsd: SETACL(2acl) %s\n", SVCFH_fmt(&argp->fh));
fh = fh_copy(&resp->fh, &argp->fh);
nfserr = fh_verify(rqstp, &r... | 273,153,740,180,211,870,000,000,000,000,000,000,000 | nfs2acl.c | 71,480,567,602,086,585,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-1237 | nfsd in the Linux kernel through 4.6.3 allows local users to bypass intended file-permission restrictions by setting a POSIX ACL, related to nfs2acl.c, nfs3acl.c, and nfs4acl.c. | https://nvd.nist.gov/vuln/detail/CVE-2016-1237 |
2,196 | linux | 999653786df6954a31044528ac3f7a5dadca08f4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/999653786df6954a31044528ac3f7a5dadca08f4 | nfsd: check permissions when setting ACLs
Use set_posix_acl, which includes proper permission checks, instead of
calling ->set_acl directly. Without this anyone may be able to grant
themselves permissions to a file by setting the ACL.
Lock the inode to make the new checks atomic with respect to set_acl.
(Also, nfsd ... | 1 | static __be32 nfsd3_proc_setacl(struct svc_rqst * rqstp,
struct nfsd3_setaclargs *argp,
struct nfsd3_attrstat *resp)
{
struct inode *inode;
svc_fh *fh;
__be32 nfserr = 0;
int error;
fh = fh_copy(&resp->fh, &argp->fh);
nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_SATTR);
if (nfserr)
goto out;
inod... | 90,832,810,491,214,460,000,000,000,000,000,000,000 | nfs3acl.c | 39,223,685,366,412,307,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-1237 | nfsd in the Linux kernel through 4.6.3 allows local users to bypass intended file-permission restrictions by setting a POSIX ACL, related to nfs2acl.c, nfs3acl.c, and nfs4acl.c. | https://nvd.nist.gov/vuln/detail/CVE-2016-1237 |
2,197 | linux | 999653786df6954a31044528ac3f7a5dadca08f4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/999653786df6954a31044528ac3f7a5dadca08f4 | nfsd: check permissions when setting ACLs
Use set_posix_acl, which includes proper permission checks, instead of
calling ->set_acl directly. Without this anyone may be able to grant
themselves permissions to a file by setting the ACL.
Lock the inode to make the new checks atomic with respect to set_acl.
(Also, nfsd ... | 1 | nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
struct nfs4_acl *acl)
{
__be32 error;
int host_error;
struct dentry *dentry;
struct inode *inode;
struct posix_acl *pacl = NULL, *dpacl = NULL;
unsigned int flags = 0;
/* Get inode */
error = fh_verify(rqstp, fhp, 0, NFSD_MAY_SATTR);
if (error)
... | 214,645,545,890,968,060,000,000,000,000,000,000,000 | nfs4acl.c | 268,799,433,190,121,900,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-1237 | nfsd in the Linux kernel through 4.6.3 allows local users to bypass intended file-permission restrictions by setting a POSIX ACL, related to nfs2acl.c, nfs3acl.c, and nfs4acl.c. | https://nvd.nist.gov/vuln/detail/CVE-2016-1237 |
2,198 | linux | ab676b7d6fbf4b294bf198fb27ade5b0e865c7ce | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ab676b7d6fbf4b294bf198fb27ade5b0e865c7ce | pagemap: do not leak physical addresses to non-privileged userspace
As pointed by recent post[1] on exploiting DRAM physical imperfection,
/proc/PID/pagemap exposes sensitive information which can be used to do
attacks.
This disallows anybody without CAP_SYS_ADMIN to read the pagemap.
[1] http://googleprojectzero.bl... | 1 | static int pagemap_open(struct inode *inode, struct file *file)
{
pr_warn_once("Bits 55-60 of /proc/PID/pagemap entries are about "
"to stop being page-shift some time soon. See the "
"linux/Documentation/vm/pagemap.txt for details.\n");
return 0;
}
| 103,258,194,490,197,500,000,000,000,000,000,000,000 | task_mmu.c | 251,899,587,674,851,180,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-0823 | The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721. | https://nvd.nist.gov/vuln/detail/CVE-2016-0823 |
2,199 | linux | 23567fd052a9abb6d67fe8e7a9ccdd9800a540f2 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/23567fd052a9abb6d67fe8e7a9ccdd9800a540f2 | KEYS: Fix keyring ref leak in join_session_keyring()
This fixes CVE-2016-0728.
If a thread is asked to join as a session keyring the keyring that's already
set as its session, we leak a keyring reference.
This can be tested with the following program:
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>... | 1 | long join_session_keyring(const char *name)
{
const struct cred *old;
struct cred *new;
struct key *keyring;
long ret, serial;
new = prepare_creds();
if (!new)
return -ENOMEM;
old = current_cred();
/* if no name is provided, install an anonymous keyring */
if (!name) {
ret = install_session_keyring_to_cr... | 40,169,950,584,792,017,000,000,000,000,000,000,000 | process_keys.c | 217,210,212,436,007,030,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-0728 | The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands. | https://nvd.nist.gov/vuln/detail/CVE-2016-0728 |
2,204 | linux | 76cc404bfdc0d419c720de4daaf2584542734f42 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/76cc404bfdc0d419c720de4daaf2584542734f42 | [PATCH] arm: fix handling of F_OFD_... in oabi_fcntl64()
Cc: stable@vger.kernel.org # 3.15+
Reviewed-by: Jeff Layton <jeff.layton@primarydata.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> | 1 | asmlinkage long sys_oabi_fcntl64(unsigned int fd, unsigned int cmd,
unsigned long arg)
{
struct oabi_flock64 user;
struct flock64 kernel;
mm_segment_t fs = USER_DS; /* initialized to kill a warning */
unsigned long local_arg = arg;
int ret;
switch (cmd) {
case F_OFD_GETLK:
case F_OFD_SETLK:
case ... | 329,184,014,551,991,750,000,000,000,000,000,000,000 | sys_oabi-compat.c | 13,795,461,115,047,124,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-8966 | arch/arm/kernel/sys_oabi-compat.c in the Linux kernel before 4.4 allows local users to gain privileges via a crafted (1) F_OFD_GETLK, (2) F_OFD_SETLK, or (3) F_OFD_SETLKW command in an fcntl64 system call. | https://nvd.nist.gov/vuln/detail/CVE-2015-8966 |
2,205 | linux | dd42bf1197144ede075a9d4793123f7689e164bc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/dd42bf1197144ede075a9d4793123f7689e164bc | tty: Prevent ldisc drivers from re-using stale tty fields
Line discipline drivers may mistakenly misuse ldisc-related fields
when initializing. For example, a failure to initialize tty->receive_room
in the N_GIGASET_M101 line discipline was recently found and fixed [1].
Now, the N_X25 line discipline has been discover... | 1 | static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
{
down_write(&tty->termios_rwsem);
tty->termios.c_line = num;
up_write(&tty->termios_rwsem);
}
| 319,178,631,571,357,830,000,000,000,000,000,000,000 | tty_ldisc.c | 62,841,087,254,304,390,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-8964 | The tty_set_termios_ldisc function in drivers/tty/tty_ldisc.c in the Linux kernel before 4.5 allows local users to obtain sensitive information from kernel memory by reading a tty data structure. | https://nvd.nist.gov/vuln/detail/CVE-2015-8964 |
2,209 | linux | f3951a3709ff50990bf3e188c27d346792103432 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3951a3709ff50990bf3e188c27d346792103432 | sg: Fix double-free when drives detach during SG_IO
In sg_common_write(), we free the block request and return -ENODEV if
the device is detached in the middle of the SG_IO ioctl().
Unfortunately, sg_finish_rem_req() also tries to free srp->rq, so we
end up freeing rq->cmd in the already free rq object, and then free
... | 1 | sg_common_write(Sg_fd * sfp, Sg_request * srp,
unsigned char *cmnd, int timeout, int blocking)
{
int k, at_head;
Sg_device *sdp = sfp->parentdp;
sg_io_hdr_t *hp = &srp->header;
srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */
hp->status = 0;
hp->masked_status = 0;
hp->msg_status = 0;
hp->info = 0... | 77,181,910,056,798,740,000,000,000,000,000,000,000 | sg.c | 155,715,153,181,324,460,000,000,000,000,000,000,000 | [
"CWE-415"
] | CVE-2015-8962 | Double free vulnerability in the sg_common_write function in drivers/scsi/sg.c in the Linux kernel before 4.4 allows local users to gain privileges or cause a denial of service (memory corruption and system crash) by detaching a device during an SG_IO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2015-8962 |
2,210 | linux | 6934da9238da947628be83635e365df41064b09b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6934da9238da947628be83635e365df41064b09b | ext4: fix potential use after free in __ext4_journal_stop
There is a use-after-free possibility in __ext4_journal_stop() in the
case that we free the handle in the first jbd2_journal_stop() because
we're referencing handle->h_err afterwards. This was introduced in
9705acd63b125dee8b15c705216d7186daea4625 and it is wro... | 1 | int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
{
struct super_block *sb;
int err;
int rc;
if (!ext4_handle_valid(handle)) {
ext4_put_nojournal(handle);
return 0;
}
if (!handle->h_transaction) {
err = jbd2_journal_stop(handle);
return handle->h_err ? handle->h_err : e... | 309,442,467,316,867,250,000,000,000,000,000,000,000 | ext4_jbd2.c | 21,107,129,184,008,160,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2015-8961 | The __ext4_journal_stop function in fs/ext4/ext4_jbd2.c in the Linux kernel before 4.3.3 allows local users to gain privileges or cause a denial of service (use-after-free) by leveraging improper access to a certain error field. | https://nvd.nist.gov/vuln/detail/CVE-2015-8961 |
2,211 | linux | 951b6a0717db97ce420547222647bcc40bf1eacd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/951b6a0717db97ce420547222647bcc40bf1eacd | Bluetooth: Fix potential NULL dereference in RFCOMM bind callback
addr can be NULL and it should not be dereferenced before NULL checking.
Signed-off-by: Jaganath Kanakkassery <jaganath.k@samsung.com>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org> | 1 | static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
{
struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
struct sock *sk = sock->sk;
int chan = sa->rc_channel;
int err = 0;
BT_DBG("sk %p %pMR", sk, &sa->rc_bdaddr);
if (!addr || addr->sa_family != AF_BLUETOOTH)
return ... | 31,335,887,280,867,650,000,000,000,000,000,000,000 | sock.c | 262,646,104,353,259,580,000,000,000,000,000,000,000 | [
"CWE-476"
] | CVE-2015-8956 | The rfcomm_sock_bind function in net/bluetooth/rfcomm/sock.c in the Linux kernel before 4.2 allows local users to obtain sensitive information or cause a denial of service (NULL pointer dereference) via vectors involving a bind system call on a Bluetooth RFCOMM socket. | https://nvd.nist.gov/vuln/detail/CVE-2015-8956 |
2,214 | linux | ab79efab0a0ba01a74df782eb7fa44b044dae8b5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ab79efab0a0ba01a74df782eb7fa44b044dae8b5 | ovl: fix dentry reference leak
In ovl_copy_up_locked(), newdentry is leaked if the function exits through
out_cleanup as this just to out after calling ovl_cleanup() - which doesn't
actually release the ref on newdentry.
The out_cleanup segment should instead exit through out2 as certainly
newdentry leaks - and possi... | 1 | static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir,
struct dentry *dentry, struct path *lowerpath,
struct kstat *stat, struct iattr *attr,
const char *link)
{
struct inode *wdir = workdir->d_inode;
struct inode *udir = upperdir->d_inode;
struct dentry *newdentry ... | 101,790,856,959,696,370,000,000,000,000,000,000,000 | copy_up.c | 148,213,014,245,758,890,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-8953 | fs/overlayfs/copy_up.c in the Linux kernel before 4.2.6 uses an incorrect cleanup code path, which allows local users to cause a denial of service (dentry reference leak) via filesystem operations on a large file in a lower overlayfs layer. | https://nvd.nist.gov/vuln/detail/CVE-2015-8953 |
2,217 | php-src | 996faf964bba1aec06b153b370a7f20d3dd2bb8b | https://github.com/php/php-src | https://github.com/php/php-src/commit/996faf964bba1aec06b153b370a7f20d3dd2bb8b?w=1 | Update header handling to RFC 7230 | 1 | SAPI_API int sapi_header_op(sapi_header_op_enum op, void *arg TSRMLS_DC)
{
sapi_header_struct sapi_header;
char *colon_offset;
char *header_line;
uint header_line_len;
int http_response_code;
if (SG(headers_sent) && !SG(request_info).no_headers) {
const char *output_start_filename = php_output_get_start_filena... | 297,048,742,078,064,120,000,000,000,000,000,000,000 | SAPI.c | 55,661,527,170,310,200,000,000,000,000,000,000,000 | [
"CWE-79"
] | CVE-2015-8935 | The sapi_header_op function in main/SAPI.c in PHP before 5.4.38, 5.5.x before 5.5.22, and 5.6.x before 5.6.6 supports deprecated line folding without considering browser compatibility, which allows remote attackers to conduct cross-site scripting (XSS) attacks against Internet Explorer by leveraging (1) %0A%20 or (2) %... | https://nvd.nist.gov/vuln/detail/CVE-2015-8935 |
2,218 | libgd | 4751b606fa38edc456d627140898a7ec679fcc24 | https://github.com/libgd/libgd | https://github.com/libgd/libgd/commit/4751b606fa38edc456d627140898a7ec679fcc24 | gdImageScaleTwoPass memory leak fix
Fixing memory leak in gdImageScaleTwoPass, as reported by @cmb69 and
confirmed by @vapier. This bug actually bit me in production and I'm
very thankful that it was reported with an easy fix.
Fixes #173. | 1 | gdImageScaleTwoPass(const gdImagePtr src, const unsigned int new_width,
const unsigned int new_height)
{
const unsigned int src_width = src->sx;
const unsigned int src_height = src->sy;
gdImagePtr tmp_im = NULL;
gdImagePtr dst = NULL;
/* First, handle the trivial case. */
if (src_... | 239,805,181,915,502,050,000,000,000,000,000,000,000 | gd_interpolation.c | 4,848,383,815,680,541,500,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-8877 | The gdImageScaleTwoPass function in gd_interpolation.c in the GD Graphics Library (aka libgd) before 2.2.0, as used in PHP before 5.6.12, uses inconsistent allocate and free approaches, which allows remote attackers to cause a denial of service (memory consumption) via a crafted call, as demonstrated by a call to the P... | https://nvd.nist.gov/vuln/detail/CVE-2015-8877 |
2,219 | file | 6713ca45e7757297381f4b4cdb9cf5e624a9ad36 | https://github.com/file/file | https://github.com/file/file/commit/6713ca45e7757297381f4b4cdb9cf5e624a9ad36 | PR/454: Fix memory corruption when the continuation level jumps by more than
20 in a single step. | 1 | file_check_mem(struct magic_set *ms, unsigned int level)
{
size_t len;
if (level >= ms->c.len) {
len = (ms->c.len += 20) * sizeof(*ms->c.li);
ms->c.li = CAST(struct level_info *, (ms->c.li == NULL) ?
malloc(len) :
realloc(ms->c.li, len));
if (ms->c.li == NULL) {
file_oomem(ms, len);
ret... | 37,015,776,179,791,950,000,000,000,000,000,000,000 | funcs.c | 247,884,554,659,100,300,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-8865 | The file_check_mem function in funcs.c in file before 5.23, as used in the Fileinfo component in PHP before 5.5.34, 5.6.x before 5.6.20, and 7.x before 7.0.5, mishandles continuation-level jumps, which allows context-dependent attackers to cause a denial of service (buffer overflow and application crash) or possibly ex... | https://nvd.nist.gov/vuln/detail/CVE-2015-8865 |
2,221 | jq | 8eb1367ca44e772963e704a700ef72ae2e12babd | https://github.com/stedolan/jq | https://github.com/stedolan/jq/commit/8eb1367ca44e772963e704a700ef72ae2e12babd | Heap buffer overflow in tokenadd() (fix #105)
This was an off-by one: the NUL terminator byte was not allocated on
resize. This was triggered by JSON-encoded numbers longer than 256
bytes. | 1 | static void tokenadd(struct jv_parser* p, char c) {
assert(p->tokenpos <= p->tokenlen);
if (p->tokenpos == p->tokenlen) {
p->tokenlen = p->tokenlen*2 + 256;
p->tokenbuf = jv_mem_realloc(p->tokenbuf, p->tokenlen);
}
assert(p->tokenpos < p->tokenlen);
p->tokenbuf[p->tokenpos++] = c;
}
| 102,885,964,769,614,870,000,000,000,000,000,000,000 | jv_parse.c | 175,409,213,026,670,600,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-8863 | Off-by-one error in the tokenadd function in jv_parse.c in jq allows remote attackers to cause a denial of service (crash) via a long JSON-encoded number, which triggers a heap-based buffer overflow. | https://nvd.nist.gov/vuln/detail/CVE-2015-8863 |
2,224 | linux | 7f821fc9c77a9b01fe7b1d6e72717b33d8d64142 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7f821fc9c77a9b01fe7b1d6e72717b33d8d64142 | powerpc/tm: Check for already reclaimed tasks
Currently we can hit a scenario where we'll tm_reclaim() twice. This
results in a TM bad thing exception because the second reclaim occurs
when not in suspend mode.
The scenario in which this can happen is the following. We attempt to
deliver a signal to userspace. To ... | 1 | static void tm_reclaim_thread(struct thread_struct *thr,
struct thread_info *ti, uint8_t cause)
{
unsigned long msr_diff = 0;
/*
* If FP/VSX registers have been already saved to the
* thread_struct, move them to the transact_fp array.
* We clear the TIF_RESTORE_TM bit since after the reclaim
* the t... | 100,255,729,192,226,000,000,000,000,000,000,000,000 | process.c | 205,611,454,501,543,500,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2015-8845 | The tm_reclaim_thread function in arch/powerpc/kernel/process.c in the Linux kernel before 4.4.1 on powerpc platforms does not ensure that TM suspend mode exists before proceeding with a tm_reclaim call, which allows local users to cause a denial of service (TM Bad Thing exception and panic) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-8845 |
2,239 | linux | 94f9cd81436c85d8c3a318ba92e236ede73752fc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/94f9cd81436c85d8c3a318ba92e236ede73752fc | netfilter: nf_nat_redirect: add missing NULL pointer check
Commit 8b13eddfdf04cbfa561725cfc42d6868fe896f56 ("netfilter: refactor NAT
redirect IPv4 to use it from nf_tables") has introduced a trivial logic
change which can result in the following crash.
BUG: unable to handle kernel NULL pointer dereference at 00000000... | 1 | nf_nat_redirect_ipv4(struct sk_buff *skb,
const struct nf_nat_ipv4_multi_range_compat *mr,
unsigned int hooknum)
{
struct nf_conn *ct;
enum ip_conntrack_info ctinfo;
__be32 newdst;
struct nf_nat_range newrange;
NF_CT_ASSERT(hooknum == NF_INET_PRE_ROUTING ||
hooknum == NF_INET_LOCAL_OUT);
ct... | 63,053,819,853,057,460,000,000,000,000,000,000,000 | nf_nat_redirect.c | 273,058,852,035,029,880,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-8787 | The nf_nat_redirect_ipv4 function in net/netfilter/nf_nat_redirect.c in the Linux kernel before 4.4 allows remote attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by sending certain IPv4 packets to an incompletely configured interface, a relate... | https://nvd.nist.gov/vuln/detail/CVE-2015-8787 |
2,240 | linux | 3ca8138f014a913f98e6ef40e939868e1e9ea876 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3ca8138f014a913f98e6ef40e939868e1e9ea876 | fuse: break infinite loop in fuse_fill_write_pages()
I got a report about unkillable task eating CPU. Further
investigation shows, that the problem is in the fuse_fill_write_pages()
function. If iov's first segment has zero length, we get an infinite
loop, because we never reach iov_iter_advance() call.
Fix this by c... | 1 | static ssize_t fuse_fill_write_pages(struct fuse_req *req,
struct address_space *mapping,
struct iov_iter *ii, loff_t pos)
{
struct fuse_conn *fc = get_fuse_conn(mapping->host);
unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
size_t count = 0;
int err;
req->in.argpages = 1;
req->page_descs[0].... | 294,235,460,800,861,680,000,000,000,000,000,000,000 | file.c | 211,377,916,038,697,840,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-8785 | The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov. | https://nvd.nist.gov/vuln/detail/CVE-2015-8785 |
2,241 | libtiff | b18012dae552f85dcc5c57d3bf4e997a15b1cc1c | https://github.com/vadz/libtiff | https://github.com/vadz/libtiff/commit/b18012dae552f85dcc5c57d3bf4e997a15b1cc1c | * libtiff/tif_next.c: fix potential out-of-bound write in NeXTDecode()
triggered by http://lcamtuf.coredump.cx/afl/vulns/libtiff5.tif
(bugzilla #2508) | 1 | NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
static const char module[] = "NeXTDecode";
unsigned char *bp, *op;
tmsize_t cc;
uint8* row;
tmsize_t scanline, n;
(void) s;
/*
* Each scanline is assumed to start off as all
* white (we assume a PhotometricInterpretation
* of ``min-is-black'').
... | 79,488,190,277,959,365,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2015-8784 | The NeXTDecode function in tif_next.c in LibTIFF allows remote attackers to cause a denial of service (out-of-bounds write) via a crafted TIFF image, as demonstrated by libtiff5.tif. | https://nvd.nist.gov/vuln/detail/CVE-2015-8784 |
2,268 | krb5 | b863de7fbf080b15e347a736fdda0a82d42f4f6b | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/b863de7fbf080b15e347a736fdda0a82d42f4f6b | Check for null kadm5 policy name [CVE-2015-8630]
In kadm5_create_principal_3() and kadm5_modify_principal(), check for
entry->policy being null when KADM5_POLICY is included in the mask.
CVE-2015-8630:
In MIT krb5 1.12 and later, an authenticated attacker with permission
to modify a principal entry can cause kadmind... | 1 | kadm5_create_principal_3(void *server_handle,
kadm5_principal_ent_t entry, long mask,
int n_ks_tuple, krb5_key_salt_tuple *ks_tuple,
char *password)
{
krb5_db_entry *kdb;
osa_princ_ent_rec adb;
kadm5_policy_en... | 241,581,982,310,294,040,000,000,000,000,000,000,000 | svr_principal.c | 220,412,209,520,526,820,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-8630 | The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specify... | https://nvd.nist.gov/vuln/detail/CVE-2015-8630 |
2,269 | krb5 | b863de7fbf080b15e347a736fdda0a82d42f4f6b | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/b863de7fbf080b15e347a736fdda0a82d42f4f6b | Check for null kadm5 policy name [CVE-2015-8630]
In kadm5_create_principal_3() and kadm5_modify_principal(), check for
entry->policy being null when KADM5_POLICY is included in the mask.
CVE-2015-8630:
In MIT krb5 1.12 and later, an authenticated attacker with permission
to modify a principal entry can cause kadmind... | 1 | kadm5_modify_principal(void *server_handle,
kadm5_principal_ent_t entry, long mask)
{
int ret, ret2, i;
kadm5_policy_ent_rec pol;
krb5_boolean have_pol = FALSE;
krb5_db_entry *kdb;
krb5_tl_data *tl_data_orig;
osa_princ... | 273,531,622,744,848,060,000,000,000,000,000,000,000 | svr_principal.c | 220,412,209,520,526,820,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-8630 | The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specify... | https://nvd.nist.gov/vuln/detail/CVE-2015-8630 |
2,270 | krb5 | df17a1224a3406f57477bcd372c61e04c0e5a5bb | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/df17a1224a3406f57477bcd372c61e04c0e5a5bb | Verify decoded kadmin C strings [CVE-2015-8629]
In xdr_nullstring(), check that the decoded string is terminated with
a zero byte and does not contain any internal zero bytes.
CVE-2015-8629:
In all versions of MIT krb5, an authenticated attacker can cause
kadmind to read beyond the end of allocated memory by sending... | 1 | bool_t xdr_nullstring(XDR *xdrs, char **objp)
{
u_int size;
if (xdrs->x_op == XDR_ENCODE) {
if (*objp == NULL)
size = 0;
else
size = strlen(*objp) + 1;
}
if (! xdr_u_int(xdrs, &size)) {
return FALSE;
}
switch (xdrs->x_op) {
case XDR_DECODE:
if (size == 0) {
... | 312,213,523,298,414,670,000,000,000,000,000,000,000 | kadm_rpc_xdr.c | 286,240,059,814,617,800,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-8629 | The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via ... | https://nvd.nist.gov/vuln/detail/CVE-2015-8629 |
2,271 | linux | 5233252fce714053f0151680933571a2da9cbfb4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5233252fce714053f0151680933571a2da9cbfb4 | bluetooth: Validate socket address length in sco_sock_bind().
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
int addr_len)
{
struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
struct sock *sk = sock->sk;
int err = 0;
BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
if (!addr || addr->sa_family != AF_BLUETOOTH)
return -EINVAL;
lock_sock(sk);... | 321,314,287,858,179,840,000,000,000,000,000,000,000 | sco.c | 130,640,662,370,797,550,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-8575 | The sco_sock_bind function in net/bluetooth/sco.c in the Linux kernel before 4.3.4 does not verify an address length, which allows local users to obtain sensitive information from kernel memory and bypass the KASLR protection mechanism via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-8575 |
2,272 | linux | 096fe9eaea40a17e125569f9e657e34cdb6d73bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/096fe9eaea40a17e125569f9e657e34cdb6d73bd | KEYS: Fix handling of stored error in a negatively instantiated user key
If a user key gets negatively instantiated, an error code is cached in the
payload area. A negatively instantiated key may be then be positively
instantiated by updating it with valid data. However, the ->update key
type method must be aware th... | 1 | static int encrypted_update(struct key *key, struct key_preparsed_payload *prep)
{
struct encrypted_key_payload *epayload = key->payload.data[0];
struct encrypted_key_payload *new_epayload;
char *buf;
char *new_master_desc = NULL;
const char *format = NULL;
size_t datalen = prep->datalen;
int ret = 0;
if (... | 273,212,551,994,244,770,000,000,000,000,000,000,000 | encrypted.c | 54,525,955,971,976,580,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-8539 | The KEYS subsystem in the Linux kernel before 4.4 allows local users to gain privileges or cause a denial of service (BUG) via crafted keyctl commands that negatively instantiate a key, related to security/keys/encrypted-keys/encrypted.c, security/keys/trusted.c, and security/keys/user_defined.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-8539 |
2,273 | linux | 096fe9eaea40a17e125569f9e657e34cdb6d73bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/096fe9eaea40a17e125569f9e657e34cdb6d73bd | KEYS: Fix handling of stored error in a negatively instantiated user key
If a user key gets negatively instantiated, an error code is cached in the
payload area. A negatively instantiated key may be then be positively
instantiated by updating it with valid data. However, the ->update key
type method must be aware th... | 1 | static int trusted_update(struct key *key, struct key_preparsed_payload *prep)
{
struct trusted_key_payload *p = key->payload.data[0];
struct trusted_key_payload *new_p;
struct trusted_key_options *new_o;
size_t datalen = prep->datalen;
char *datablob;
int ret = 0;
if (!p->migratable)
return -EPERM;... | 295,894,163,410,544,320,000,000,000,000,000,000,000 | trusted.c | 221,061,637,993,863,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-8539 | The KEYS subsystem in the Linux kernel before 4.4 allows local users to gain privileges or cause a denial of service (BUG) via crafted keyctl commands that negatively instantiate a key, related to security/keys/encrypted-keys/encrypted.c, security/keys/trusted.c, and security/keys/user_defined.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-8539 |
2,274 | linux | 096fe9eaea40a17e125569f9e657e34cdb6d73bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/096fe9eaea40a17e125569f9e657e34cdb6d73bd | KEYS: Fix handling of stored error in a negatively instantiated user key
If a user key gets negatively instantiated, an error code is cached in the
payload area. A negatively instantiated key may be then be positively
instantiated by updating it with valid data. However, the ->update key
type method must be aware th... | 1 | int user_update(struct key *key, struct key_preparsed_payload *prep)
{
struct user_key_payload *upayload, *zap;
size_t datalen = prep->datalen;
int ret;
ret = -EINVAL;
if (datalen <= 0 || datalen > 32767 || !prep->data)
goto error;
/* construct a replacement payload */
ret = -ENOMEM;
upayload = kmalloc(size... | 150,125,670,513,652,380,000,000,000,000,000,000,000 | user_defined.c | 334,071,985,264,321,620,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-8539 | The KEYS subsystem in the Linux kernel before 4.4 allows local users to gain privileges or cause a denial of service (BUG) via crafted keyctl commands that negatively instantiate a key, related to security/keys/encrypted-keys/encrypted.c, security/keys/trusted.c, and security/keys/user_defined.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-8539 |
2,296 | linux | cb3232138e37129e88240a98a1d2aba2187ff57c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cb3232138e37129e88240a98a1d2aba2187ff57c | USB: serial: visor: fix crash on detecting device without write_urbs
The visor driver crashes in clie_5_attach() when a specially crafted USB
device without bulk-out endpoint is detected. This fix adds a check that
the device has proper configuration expected by the driver.
Reported-by: Ralf Spenneberg <ralf@spennebe... | 1 | static int clie_5_attach(struct usb_serial *serial)
{
struct usb_serial_port *port;
unsigned int pipe;
int j;
/* TH55 registers 2 ports.
Communication in from the UX50/TH55 uses bulk_in_endpointAddress
from port 0. Communication out to the UX50/TH55 uses
bulk_out_endpointAddress from port 1
Lets d... | 302,546,870,172,646,940,000,000,000,000,000,000,000 | visor.c | 330,059,420,467,391,720,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-7566 | The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint. | https://nvd.nist.gov/vuln/detail/CVE-2015-7566 |
2,297 | linux | b4a1b4f5047e4f54e194681125c74c0aa64d637d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b4a1b4f5047e4f54e194681125c74c0aa64d637d | KEYS: Fix race between read and revoke
This fixes CVE-2015-7550.
There's a race between keyctl_read() and keyctl_revoke(). If the revoke
happens between keyctl_read() checking the validity of a key and the key's
semaphore being taken, then the key type read method will see a revoked key.
This causes a problem for t... | 1 | long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen)
{
struct key *key;
key_ref_t key_ref;
long ret;
/* find the key first */
key_ref = lookup_user_key(keyid, 0, 0);
if (IS_ERR(key_ref)) {
ret = -ENOKEY;
goto error;
}
key = key_ref_to_ptr(key_ref);
/* see if we can read it direct... | 182,054,607,697,593,500,000,000,000,000,000,000,000 | keyctl.c | 110,726,076,335,712,920,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-7550 | The keyctl_read_key function in security/keys/keyctl.c in the Linux kernel before 4.3.4 does not properly use a semaphore, which allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via a crafted application that leverages a race condition... | https://nvd.nist.gov/vuln/detail/CVE-2015-7550 |
2,298 | linux | 8e20cf2bce122ce9262d6034ee5d5b76fbb92f96 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8e20cf2bce122ce9262d6034ee5d5b76fbb92f96 | Input: aiptek - fix crash on detecting device without endpoints
The aiptek driver crashes in aiptek_probe() when a specially crafted USB
device without endpoints is detected. This fix adds a check that the device
has proper configuration expected by the driver. Also an error return value
is changed to more matching on... | 1 | aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct usb_device *usbdev = interface_to_usbdev(intf);
struct usb_endpoint_descriptor *endpoint;
struct aiptek *aiptek;
struct input_dev *inputdev;
int i;
int speeds[] = { 0,
AIPTEK_PROGRAMMABLE_DELAY_50,
AIPTEK_PROGRAMMABLE_DELAY_400,... | 116,279,422,032,136,150,000,000,000,000,000,000,000 | None | null | [
"CWE-401"
] | CVE-2015-7515 | The aiptek_probe function in drivers/input/tablet/aiptek.c in the Linux kernel before 4.4 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) via a crafted USB device that lacks endpoints. | https://nvd.nist.gov/vuln/detail/CVE-2015-7515 |
2,299 | linux | 0185604c2d82c560dab2f2933a18f797e74ab5a8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0185604c2d82c560dab2f2933a18f797e74ab5a8 | KVM: x86: Reload pit counters for all channels when restoring state
Currently if userspace restores the pit counters with a count of 0
on channels 1 or 2 and the guest attempts to read the count on those
channels, then KVM will perform a mod of 0 and crash. This will ensure
that 0 values are converted to 65536 as per... | 1 | static int kvm_vm_ioctl_set_pit(struct kvm *kvm, struct kvm_pit_state *ps)
{
mutex_lock(&kvm->arch.vpit->pit_state.lock);
memcpy(&kvm->arch.vpit->pit_state, ps, sizeof(struct kvm_pit_state));
kvm_pit_load_count(kvm, 0, ps->channels[0].count, 0);
mutex_unlock(&kvm->arch.vpit->pit_state.lock);
return 0;
}
| 208,694,431,467,498,260,000,000,000,000,000,000,000 | x86.c | 35,499,916,013,815,720,000,000,000,000,000,000,000 | [
"CWE-369"
] | CVE-2015-7513 | arch/x86/kvm/x86.c in the Linux kernel before 4.4 does not reset the PIT counter values during state restoration, which allows guest OS users to cause a denial of service (divide-by-zero error and host OS crash) via a zero value, related to the kvm_vm_ioctl_set_pit and kvm_vm_ioctl_set_pit2 functions. | https://nvd.nist.gov/vuln/detail/CVE-2015-7513 |
2,300 | linux | 0185604c2d82c560dab2f2933a18f797e74ab5a8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0185604c2d82c560dab2f2933a18f797e74ab5a8 | KVM: x86: Reload pit counters for all channels when restoring state
Currently if userspace restores the pit counters with a count of 0
on channels 1 or 2 and the guest attempts to read the count on those
channels, then KVM will perform a mod of 0 and crash. This will ensure
that 0 values are converted to 65536 as per... | 1 | static int kvm_vm_ioctl_set_pit2(struct kvm *kvm, struct kvm_pit_state2 *ps)
{
int start = 0;
u32 prev_legacy, cur_legacy;
mutex_lock(&kvm->arch.vpit->pit_state.lock);
prev_legacy = kvm->arch.vpit->pit_state.flags & KVM_PIT_FLAGS_HPET_LEGACY;
cur_legacy = ps->flags & KVM_PIT_FLAGS_HPET_LEGACY;
if (!prev_leg... | 246,557,586,103,248,000,000,000,000,000,000,000,000 | x86.c | 35,499,916,013,815,720,000,000,000,000,000,000,000 | [
"CWE-369"
] | CVE-2015-7513 | arch/x86/kvm/x86.c in the Linux kernel before 4.4 does not reset the PIT counter values during state restoration, which allows guest OS users to cause a denial of service (divide-by-zero error and host OS crash) via a zero value, related to the kvm_vm_ioctl_set_pit and kvm_vm_ioctl_set_pit2 functions. | https://nvd.nist.gov/vuln/detail/CVE-2015-7513 |
2,301 | linux | cd4a40174b71acd021877341684d8bb1dc8ea4ae | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cd4a40174b71acd021877341684d8bb1dc8ea4ae | mnt: Fail collect_mounts when applied to unmounted mounts
The only users of collect_mounts are in audit_tree.c
In audit_trim_trees and audit_add_tree_rule the path passed into
collect_mounts is generated from kern_path passed an audit_tree
pathname which is guaranteed to be an absolute path. In those cases
collect_... | 1 | struct vfsmount *collect_mounts(struct path *path)
{
struct mount *tree;
namespace_lock();
tree = copy_tree(real_mount(path->mnt), path->dentry,
CL_COPY_ALL | CL_PRIVATE);
namespace_unlock();
if (IS_ERR(tree))
return ERR_CAST(tree);
return &tree->mnt;
}
| 19,334,538,589,789,937,000,000,000,000,000,000,000 | namespace.c | 291,925,216,484,681,430,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-4177 | The collect_mounts function in fs/namespace.c in the Linux kernel before 4.0.5 does not properly consider that it may execute after a path has been unmounted, which allows local users to cause a denial of service (system crash) by leveraging user-namespace root access for an MNT_DETACH umount2 system call. | https://nvd.nist.gov/vuln/detail/CVE-2015-4177 |
2,303 | linux | cf872776fc84128bb779ce2b83a37c884c3203ae | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cf872776fc84128bb779ce2b83a37c884c3203ae | tty: Fix hang at ldsem_down_read()
When a controlling tty is being hung up and the hang up is
waiting for a just-signalled tty reader or writer to exit, and a new tty
reader/writer tries to acquire an ldisc reference concurrently with the
ldisc reference release from the signalled reader/writer, the hangup
can hang. T... | 1 | static inline int ldsem_cmpxchg(long *old, long new, struct ld_semaphore *sem)
{
long tmp = *old;
*old = atomic_long_cmpxchg(&sem->count, *old, new);
return *old == tmp;
}
| 228,392,180,986,723,300,000,000,000,000,000,000,000 | tty_ldsem.c | 229,283,372,989,827,300,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-4170 | Race condition in the ldsem_cmpxchg function in drivers/tty/tty_ldsem.c in the Linux kernel before 3.13-rc4-next-20131218 allows local users to cause a denial of service (ldsem_down_read and ldsem_down_write deadlock) by establishing a new tty thread during shutdown of a previous tty thread. | https://nvd.nist.gov/vuln/detail/CVE-2015-4170 |
2,308 | linux | a2f18db0c68fec96631c10cad9384c196e9008ac | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a2f18db0c68fec96631c10cad9384c196e9008ac | netfilter: nf_tables: fix flush ruleset chain dependencies
Jumping between chains doesn't mix well with flush ruleset. Rules
from a different chain and set elements may still refer to us.
[ 353.373791] ------------[ cut here ]------------
[ 353.373845] kernel BUG at net/netfilter/nf_tables_api.c:1159!
[ 353.373896... | 1 | static int nft_flush_table(struct nft_ctx *ctx)
{
int err;
struct nft_chain *chain, *nc;
struct nft_set *set, *ns;
list_for_each_entry_safe(chain, nc, &ctx->table->chains, list) {
ctx->chain = chain;
err = nft_delrule_by_chain(ctx);
if (err < 0)
goto out;
err = nft_delchain(ctx);
if (err < 0)... | 176,778,942,905,014,950,000,000,000,000,000,000,000 | nf_tables_api.c | 246,685,646,410,565,340,000,000,000,000,000,000,000 | [
"CWE-19"
] | CVE-2015-1573 | The nft_flush_table function in net/netfilter/nf_tables_api.c in the Linux kernel before 3.18.5 mishandles the interaction between cross-chain jumps and ruleset flushes, which allows local users to cause a denial of service (panic) by leveraging the CAP_NET_ADMIN capability. | https://nvd.nist.gov/vuln/detail/CVE-2015-1573 |
2,309 | linux | 2c5816b4beccc8ba709144539f6fdd764f8fa49c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2c5816b4beccc8ba709144539f6fdd764f8fa49c | cuse: fix memory leak
The problem is that fuse_dev_alloc() acquires an extra reference to cc.fc,
and the original ref count is never dropped.
Reported-by: Colin Ian King <colin.king@canonical.com>
Signed-off-by: Miklos Szeredi <miklos@szeredi.hu>
Fixes: cc080e9e9be1 ("fuse: introduce per-instance fuse_dev structure")... | 1 | static int cuse_channel_release(struct inode *inode, struct file *file)
{
struct fuse_dev *fud = file->private_data;
struct cuse_conn *cc = fc_to_cc(fud->fc);
int rc;
/* remove from the conntbl, no more access from this point on */
mutex_lock(&cuse_lock);
list_del_init(&cc->list);
mutex_unlock(&cuse_lock);
/*... | 206,651,427,646,572,480,000,000,000,000,000,000,000 | None | null | [
"CWE-399"
] | CVE-2015-1339 | Memory leak in the cuse_channel_release function in fs/fuse/cuse.c in the Linux kernel before 4.4 allows local users to cause a denial of service (memory consumption) or possibly have unspecified other impact by opening /dev/cuse many times. | https://nvd.nist.gov/vuln/detail/CVE-2015-1339 |
2,310 | linux | 6217e5ede23285ddfee10d2e4ba0cc2d4c046205 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6217e5ede23285ddfee10d2e4ba0cc2d4c046205 | ALSA: compress: fix an integer overflow check
I previously added an integer overflow check here but looking at it now,
it's still buggy.
The bug happens in snd_compr_allocate_buffer(). We multiply
".fragments" and ".fragment_size" and that doesn't overflow but then we
save it in an unsigned int so it truncates the h... | 1 | static int snd_compress_check_input(struct snd_compr_params *params)
{
/* first let's check the buffer parameter's */
if (params->buffer.fragment_size == 0 ||
params->buffer.fragments > SIZE_MAX / params->buffer.fragment_size)
return -EINVAL;
/* now codec parameters */
if (params->codec.id == 0 || param... | 77,147,876,717,907,740,000,000,000,000,000,000,000 | compress_offload.c | 155,400,925,010,501,580,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2014-9904 | The snd_compress_check_input function in sound/core/compress_offload.c in the ALSA subsystem in the Linux kernel before 3.17 does not properly check for an integer overflow, which allows local users to cause a denial of service (insufficient memory allocation) or possibly have unspecified other impact via a crafted SND... | https://nvd.nist.gov/vuln/detail/CVE-2014-9904 |
2,311 | linux | 4efbc454ba68def5ef285b26ebfcfdb605b52755 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4efbc454ba68def5ef285b26ebfcfdb605b52755 | sched: Fix information leak in sys_sched_getattr()
We're copying the on-stack structure to userspace, but forgot to give
the right number of bytes to copy. This allows the calling process to
obtain up to PAGE_SIZE bytes from the stack (and possibly adjacent
kernel memory).
This fix copies only as much as we actually ... | 1 | static int sched_read_attr(struct sched_attr __user *uattr,
struct sched_attr *attr,
unsigned int usize)
{
int ret;
if (!access_ok(VERIFY_WRITE, uattr, usize))
return -EFAULT;
/*
* If we're handed a smaller struct than we know of,
* ensure all the unknown bits are 0 - i.e. old
* user-space does... | 339,536,197,997,710,340,000,000,000,000,000,000,000 | core.c | 151,467,961,382,598,860,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2014-9903 | The sched_read_attr function in kernel/sched/core.c in the Linux kernel 3.14-rc before 3.14-rc4 uses an incorrect size, which allows local users to obtain sensitive information from kernel stack memory via a crafted sched_getattr system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-9903 |
2,312 | linux | c88e739b1fad662240e99ecbd0bdaac871717987 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c88e739b1fad662240e99ecbd0bdaac871717987 | [media] media: info leak in __media_device_enum_links()
These structs have holes and reserved struct members which aren't
cleared. I've added a memset() so we don't leak stack information.
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Sign... | 1 | static long __media_device_enum_links(struct media_device *mdev,
struct media_links_enum *links)
{
struct media_entity *entity;
entity = find_entity(mdev, links->entity);
if (entity == NULL)
return -EINVAL;
if (links->pads) {
unsigned int p;
for (p = 0; p < entity->num_pads; p++) {
struct m... | 154,830,867,138,233,740,000,000,000,000,000,000,000 | media-device.c | 146,889,600,851,495,100,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2014-9895 | drivers/media/media-device.c in the Linux kernel before 3.11, as used in Android before 2016-08-05 on Nexus 5 and 7 (2013) devices, does not properly initialize certain data structures, which allows local users to obtain sensitive information via a crafted application, aka Android internal bug 28750150 and Qualcomm int... | https://nvd.nist.gov/vuln/detail/CVE-2014-9895 |
2,323 | libgd | 4f65a3e4eedaffa1efcf9ee1eb08f0b504fbc31a | https://github.com/libgd/libgd | https://github.com/libgd/libgd/commit/4f65a3e4eedaffa1efcf9ee1eb08f0b504fbc31a | Fixed memory overrun bug in gdImageScaleTwoPass
_gdContributionsCalc would compute a window size and then adjust
the left and right positions of the window to make a window within
that size. However, it was storing the values in the struct *before*
it made the adjustment. This change fixes that. | 1 | static inline LineContribType *_gdContributionsCalc(unsigned int line_size, unsigned int src_size, double scale_d, const interpolation_method pFilter)
{
double width_d;
double scale_f_d = 1.0;
const double filter_width_d = DEFAULT_BOX_RADIUS;
int windows_size;
unsigned int u;
LineContribType *res;
if (scale_d ... | 41,848,651,368,514,130,000,000,000,000,000,000,000 | gd_interpolation.c | 295,564,444,943,955,560,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2013-7456 | gd_interpolation.c in the GD Graphics Library (aka libgd) before 2.1.1, as used in PHP before 5.5.36, 5.6.x before 5.6.22, and 7.x before 7.0.7, allows remote attackers to cause a denial of service (out-of-bounds read) or possibly have unspecified other impact via a crafted image that is mishandled by the imagescale fu... | https://nvd.nist.gov/vuln/detail/CVE-2013-7456 |
2,324 | Little-CMS | fefaaa43c382eee632ea3ad0cfa915335140e1db | https://github.com/mm2/Little-CMS | https://github.com/mm2/Little-CMS/commit/fefaaa43c382eee632ea3ad0cfa915335140e1db | Fix a double free on error recovering | 1 | cmsPipeline* DefaultICCintents(cmsContext ContextID,
cmsUInt32Number nProfiles,
cmsUInt32Number TheIntents[],
cmsHPROFILE hProfiles[],
cmsBool BPC[],
... | 120,973,636,847,525,110,000,000,000,000,000,000,000 | None | null | [
"CWE-94"
] | CVE-2013-7455 | Double free vulnerability in the DefaultICCintents function in cmscnvrt.c in liblcms2 in Little CMS 2.x before 2.6 allows remote attackers to execute arbitrary code via a malformed ICC profile that triggers an error in the default intent handler. | https://nvd.nist.gov/vuln/detail/CVE-2013-7455 |
2,337 | linux | 82981930125abfd39d7c8378a9cfdf5e1be2002b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/82981930125abfd39d7c8378a9cfdf5e1be2002b | net: cleanups in sock_setsockopt()
Use min_t()/max_t() macros, reformat two comments, use !!test_bit() to
match !!sock_flag()
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | int sock_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
int val;
int valbool;
struct linger ling;
int ret = 0;
/*
* Options without arguments
*/
if (optname == SO_BINDTODEVICE)
return sock_bindtodevice(sk, optval, optl... | 84,799,346,879,089,590,000,000,000,000,000,000,000 | sock.c | 21,744,962,430,969,506,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-6704 | The sock_setsockopt function in net/core/sock.c in the Linux kernel before 3.5 mishandles negative values of sk_sndbuf and sk_rcvbuf, which allows local users to cause a denial of service (memory corruption and system crash) or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability for a craf... | https://nvd.nist.gov/vuln/detail/CVE-2012-6704 |
2,338 | linux | b35cc8225845112a616e3a2266d2fde5ab13d3ab | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b35cc8225845112a616e3a2266d2fde5ab13d3ab | ALSA: compress_core: integer overflow in snd_compr_allocate_buffer()
These are 32 bit values that come from the user, we need to check for
integer overflows or we could end up allocating a smaller buffer than
expected.
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de> | 1 | static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
struct snd_compr_params *params)
{
unsigned int buffer_size;
void *buffer;
buffer_size = params->buffer.fragment_size * params->buffer.fragments;
if (stream->ops->copy) {
buffer = NULL;
/* if copy is defined the driver will be requir... | 320,223,001,183,825,300,000,000,000,000,000,000,000 | compress_offload.c | 5,078,957,457,841,432,600,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2012-6703 | Integer overflow in the snd_compr_allocate_buffer function in sound/core/compress_offload.c in the ALSA subsystem in the Linux kernel before 3.6-rc6-next-20120917 allows local users to cause a denial of service (insufficient memory allocation) or possibly have unspecified other impact via a crafted SNDRV_COMPRESS_SET_P... | https://nvd.nist.gov/vuln/detail/CVE-2012-6703 |
2,342 | linux | 20e1db19db5d6b9e4e83021595eab0dc8f107bef | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/20e1db19db5d6b9e4e83021595eab0dc8f107bef | netlink: fix possible spoofing from non-root processes
Non-root user-space processes can send Netlink messages to other
processes that are well-known for being subscribed to Netlink
asynchronous notifications. This allows ilegitimate non-root
process to send forged messages to Netlink subscribers.
The userspace proce... | 1 | static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
struct msghdr *msg, size_t len)
{
struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
struct sock *sk = sock->sk;
struct netlink_sock *nlk = nlk_sk(sk);
struct sockaddr_nl *addr = msg->msg_name;
u32 dst_pid;
u32 dst_group;
struct sk_buff *sk... | 169,493,009,832,141,550,000,000,000,000,000,000,000 | af_netlink.c | 222,021,278,280,246,500,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2012-6689 | The netlink_sendmsg function in net/netlink/af_netlink.c in the Linux kernel before 3.5.5 does not validate the dst_pid field, which allows local users to have an unspecified impact by spoofing Netlink messages. | https://nvd.nist.gov/vuln/detail/CVE-2012-6689 |
2,343 | linux | c290f8358acaeffd8e0c551ddcc24d1206143376 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c290f8358acaeffd8e0c551ddcc24d1206143376 | TTY: drop driver reference in tty_open fail path
When tty_driver_lookup_tty fails in tty_open, we forget to drop a
reference to the tty driver. This was added by commit 4a2b5fddd5 (Move
tty lookup/reopen to caller).
Fix that by adding tty_driver_kref_put to the fail path.
I will refactor the code later. This is for ... | 1 | static int tty_open(struct inode *inode, struct file *filp)
{
struct tty_struct *tty = NULL;
int noctty, retval;
struct tty_driver *driver;
int index;
dev_t device = inode->i_rdev;
unsigned saved_flags = filp->f_flags;
nonseekable_open(inode, filp);
retry_open:
noctty = filp->f_flags & O_NOCTTY;
index = -1;... | 2,589,888,721,444,243,200,000,000,000,000,000,000 | tty_io.c | 285,070,847,913,278,200,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2011-5321 | The tty_open function in drivers/tty/tty_io.c in the Linux kernel before 3.1.1 mishandles a driver-lookup failure, which allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via crafted access to a device file under the /dev/pts directory. | https://nvd.nist.gov/vuln/detail/CVE-2011-5321 |
2,346 | linux | ba3021b2c79b2fa9114f92790a99deb27a65b728 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ba3021b2c79b2fa9114f92790a99deb27a65b728 | ALSA: timer: Fix missing queue indices reset at SNDRV_TIMER_IOCTL_SELECT
snd_timer_user_tselect() reallocates the queue buffer dynamically, but
it forgot to reset its indices. Since the read may happen
concurrently with ioctl and snd_timer_user_tselect() allocates the
buffer via kmalloc(), this may lead to the leak o... | 1 | static int snd_timer_user_tselect(struct file *file,
struct snd_timer_select __user *_tselect)
{
struct snd_timer_user *tu;
struct snd_timer_select tselect;
char str[32];
int err = 0;
tu = file->private_data;
if (tu->timeri) {
snd_timer_close(tu->timeri);
tu->timeri = NULL;
}
if (copy_from_user(&tsel... | 18,027,996,916,287,280,000,000,000,000,000,000,000 | timer.c | 102,836,771,800,390,000,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2017-1000380 | sound/core/timer.c in the Linux kernel before 4.11.5 is vulnerable to a data race in the ALSA /dev/snd/timer driver resulting in local users being able to read information belonging to other users, i.e., uninitialized memory contents may be disclosed when a read and an ioctl happen at the same time. | https://nvd.nist.gov/vuln/detail/CVE-2017-1000380 |
2,347 | linux | 36ae3c0a36b7456432fedce38ae2f7bd3e01a563 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/36ae3c0a36b7456432fedce38ae2f7bd3e01a563 | KVM: Don't accept obviously wrong gsi values via KVM_IRQFD
We cannot add routes for gsi values >= KVM_MAX_IRQ_ROUTES -- see
kvm_set_irq_routing(). Hence, there is no sense in accepting them
via KVM_IRQFD. Prevent them from entering the system in the first
place.
Signed-off-by: Jan H. Schönherr <jschoenh@amazon.de>
Si... | 1 | kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args)
{
if (args->flags & ~(KVM_IRQFD_FLAG_DEASSIGN | KVM_IRQFD_FLAG_RESAMPLE))
return -EINVAL;
if (args->flags & KVM_IRQFD_FLAG_DEASSIGN)
return kvm_irqfd_deassign(kvm, args);
return kvm_irqfd_assign(kvm, args);
}
| 83,207,294,150,061,300,000,000,000,000,000,000,000 | eventfd.c | 202,797,016,146,185,400,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2017-1000252 | The KVM subsystem in the Linux kernel through 4.13.3 allows guest OS users to cause a denial of service (assertion failure, and hypervisor hang or crash) via an out-of bounds guest_irq value, related to arch/x86/kvm/vmx.c and virt/kvm/eventfd.c. | https://nvd.nist.gov/vuln/detail/CVE-2017-1000252 |
2,354 | file | 35c94dc6acc418f1ad7f6241a6680e5327495793 | https://github.com/file/file | https://github.com/file/file/commit/35c94dc6acc418f1ad7f6241a6680e5327495793 | Fix always true condition (Thomas Jarosch) | 1 | do_bid_note(struct magic_set *ms, unsigned char *nbuf, uint32_t type,
int swap __attribute__((__unused__)), uint32_t namesz, uint32_t descsz,
size_t noff, size_t doff, int *flags)
{
if (namesz == 4 && strcmp((char *)&nbuf[noff], "GNU") == 0 &&
type == NT_GNU_BUILD_ID && (descsz >= 4 || descsz <= 20)) {... | 125,277,570,129,377,140,000,000,000,000,000,000,000 | readelf.c | 30,360,017,589,846,504,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2017-1000249 | An issue in file() was introduced in commit 9611f31313a93aa036389c5f3b15eea53510d4d1 (Oct 2016) lets an attacker overwrite a fixed 20 bytes stack buffer with a specially crafted .notes section in an ELF binary. This was fixed in commit 35c94dc6acc418f1ad7f6241a6680e5327495793 (Aug 2017). | https://nvd.nist.gov/vuln/detail/CVE-2017-1000249 |
2,355 | lynx-snapshots | 280a61b300a1614f6037efc0902ff7ecf17146e9 | https://github.com/ThomasDickey/lynx-snapshots | https://github.com/ThomasDickey/lynx-snapshots/commit/280a61b300a1614f6037efc0902ff7ecf17146e9 | snapshot of project "lynx", label v2-8-9dev_15b | 1 | void HTML_put_string(HTStructured * me, const char *s)
{
#ifdef USE_PRETTYSRC
char *translated_string = NULL;
#endif
if (s == NULL || (LYMapsOnly && me->sp[0].tag_number != HTML_OBJECT))
return;
#ifdef USE_PRETTYSRC
if (psrc_convert_string) {
StrAllocCopy(translated_string, s);
TRANSLATE_AND_UNESCA... | 185,287,537,479,326,960,000,000,000,000,000,000,000 | HTML.c | 198,530,681,004,127,600,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2017-1000211 | Lynx before 2.8.9dev.16 is vulnerable to a use after free in the HTML parser resulting in memory disclosure, because HTML_put_string() can append a chunk onto itself. | https://nvd.nist.gov/vuln/detail/CVE-2017-1000211 |
2,356 | tcmu-runner | e2d953050766ac538615a811c64b34358614edce | https://github.com/open-iscsi/tcmu-runner | https://github.com/open-iscsi/tcmu-runner/commit/e2d953050766ac538615a811c64b34358614edce | fixed local DoS when UnregisterHandler was called for a not existing handler
Any user with DBUS access could cause a SEGFAULT in tcmu-runner by
running something like this:
dbus-send --system --print-reply --dest=org.kernel.TCMUService1 /org/kernel/TCMUService1/HandlerManager1 org.kernel.TCMUService1.HandlerManager1.... | 1 | on_unregister_handler(TCMUService1HandlerManager1 *interface,
GDBusMethodInvocation *invocation,
gchar *subtype,
gpointer user_data)
{
struct tcmur_handler *handler = find_handler_by_subtype(subtype);
struct dbus_info *info = handler->opaque;
if (!handler) {
g_dbus_method_invocation_... | 116,020,867,554,130,670,000,000,000,000,000,000,000 | main.c | 46,183,894,636,527,310,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2017-1000201 | The tcmu-runner daemon in tcmu-runner version 1.0.5 to 1.2.0 is vulnerable to a local denial of service attack | https://nvd.nist.gov/vuln/detail/CVE-2017-1000201 |
2,360 | tcmu-runner | bb80e9c7a798f035768260ebdadffb6eb0786178 | https://github.com/open-iscsi/tcmu-runner | https://github.com/open-iscsi/tcmu-runner/commit/bb80e9c7a798f035768260ebdadffb6eb0786178 | only allow dynamic UnregisterHandler for external handlers, thereby fixing DoS
Trying to unregister an internal handler ended up in a SEGFAULT, because
the tcmur_handler->opaque was NULL. Way to reproduce:
dbus-send --system --print-reply --dest=org.kernel.TCMUService1 /org/kernel/TCMUService1/HandlerManager1 org.ker... | 1 | on_unregister_handler(TCMUService1HandlerManager1 *interface,
GDBusMethodInvocation *invocation,
gchar *subtype,
gpointer user_data)
{
struct tcmur_handler *handler = find_handler_by_subtype(subtype);
struct dbus_info *info = handler ? handler->opaque : NULL;
if (!handler) {
g_dbus_method_... | 274,977,298,780,246,000,000,000,000,000,000,000,000 | main.c | 223,399,176,575,332,300,000,000,000,000,000,000,000 | [
"CWE-476"
] | CVE-2017-1000200 | tcmu-runner version 1.0.5 to 1.2.0 is vulnerable to a dbus triggered NULL pointer dereference in the tcmu-runner daemon's on_unregister_handler() function resulting in denial of service | https://nvd.nist.gov/vuln/detail/CVE-2017-1000200 |
2,361 | tcmu-runner | 61bd03e600d2abf309173e9186f4d465bb1b7157 | https://github.com/open-iscsi/tcmu-runner | https://github.com/open-iscsi/tcmu-runner/commit/61bd03e600d2abf309173e9186f4d465bb1b7157 | glfs: discard glfs_check_config
Signed-off-by: Prasanna Kumar Kalever <prasanna.kalever@redhat.com> | 1 | static bool glfs_check_config(const char *cfgstring, char **reason)
{
char *path;
glfs_t *fs = NULL;
glfs_fd_t *gfd = NULL;
gluster_server *hosts = NULL; /* gluster server defination */
bool result = true;
path = strchr(cfgstring, '/');
if (!path) {
if (asprintf(reason, "No path found") == -1)
*reason = NUL... | 23,917,343,011,042,043,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2017-1000198 | tcmu-runner daemon version 0.9.0 to 1.2.0 is vulnerable to invalid memory references in the handler_glfs.so handler resulting in denial of service | https://nvd.nist.gov/vuln/detail/CVE-2017-1000198 |
2,366 | linux | ea25f914dc164c8d56b36147ecc86bc65f83c469 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ea25f914dc164c8d56b36147ecc86bc65f83c469 | bpf: fix missing error return in check_stack_boundary()
Prevent indirect stack accesses at non-constant addresses, which would
permit reading and corrupting spilled pointers.
Fixes: f1174f77b50c ("bpf/verifier: rework value tracking")
Signed-off-by: Jann Horn <jannh@google.com>
Signed-off-by: Alexei Starovoitov <ast@... | 1 | static int check_stack_boundary(struct bpf_verifier_env *env, int regno,
int access_size, bool zero_size_allowed,
struct bpf_call_arg_meta *meta)
{
struct bpf_verifier_state *state = env->cur_state;
struct bpf_reg_state *regs = state->regs;
int off, i, slot, spi;
if (regs[regno].type != PTR_TO_STACK) {
/... | 100,968,769,887,024,980,000,000,000,000,000,000,000 | verifier.c | 226,370,249,483,327,000,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2017-17857 | The check_stack_boundary function in kernel/bpf/verifier.c in the Linux kernel through 4.14.8 allows local users to cause a denial of service (memory corruption) or possibly have unspecified other impact by leveraging mishandling of invalid variable stack read operations. | https://nvd.nist.gov/vuln/detail/CVE-2017-17857 |
2,367 | linux | a5ec6ae161d72f01411169a938fa5f8baea16e8f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a5ec6ae161d72f01411169a938fa5f8baea16e8f | bpf: force strict alignment checks for stack pointers
Force strict alignment checks for stack pointers because the tracking of
stack spills relies on it; unaligned stack accesses can lead to corruption
of spilled registers, which is exploitable.
Fixes: f1174f77b50c ("bpf/verifier: rework value tracking")
Signed-off-b... | 1 | static int check_ptr_alignment(struct bpf_verifier_env *env,
const struct bpf_reg_state *reg,
int off, int size)
{
bool strict = env->strict_alignment;
const char *pointer_desc = "";
switch (reg->type) {
case PTR_TO_PACKET:
case PTR_TO_PACKET_META:
/* Special case, because of NET_IP_ALIGN. G... | 132,971,837,477,051,940,000,000,000,000,000,000,000 | verifier.c | 226,370,249,483,327,000,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2017-17856 | kernel/bpf/verifier.c in the Linux kernel through 4.14.8 allows local users to cause a denial of service (memory corruption) or possibly have unspecified other impact by leveraging the lack of stack-pointer alignment enforcement. | https://nvd.nist.gov/vuln/detail/CVE-2017-17856 |
2,368 | linux | 179d1c5602997fef5a940c6ddcf31212cbfebd14 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/179d1c5602997fef5a940c6ddcf31212cbfebd14 | bpf: don't prune branches when a scalar is replaced with a pointer
This could be made safe by passing through a reference to env and checking
for env->allow_ptr_leaks, but it would only work one way and is probably
not worth the hassle - not doing it will not directly lead to program
rejection.
Fixes: f1174f77b50c ("... | 1 | static bool regsafe(struct bpf_reg_state *rold, struct bpf_reg_state *rcur,
struct idpair *idmap)
{
if (!(rold->live & REG_LIVE_READ))
/* explored state didn't use this */
return true;
if (memcmp(rold, rcur, offsetof(struct bpf_reg_state, live)) == 0)
return true;
if (rold->type == NOT_INIT)
/* explo... | 312,414,542,843,290,360,000,000,000,000,000,000,000 | verifier.c | 226,370,249,483,327,000,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2017-17864 | kernel/bpf/verifier.c in the Linux kernel through 4.14.8 mishandles states_equal comparisons between the pointer data type and the UNKNOWN_VALUE data type, which allows local users to obtain potentially sensitive address information, aka a "pointer leak." | https://nvd.nist.gov/vuln/detail/CVE-2017-17864 |
2,371 | linux | 4374f256ce8182019353c0c639bb8d0695b4c941 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4374f256ce8182019353c0c639bb8d0695b4c941 | bpf/verifier: fix bounds calculation on BPF_RSH
Incorrect signed bounds were being computed.
If the old upper signed bound was positive and the old lower signed bound was
negative, this could cause the new upper signed bound to be too low,
leading to security issues.
Fixes: b03c9f9fdc37 ("bpf/verifier: track signed a... | 1 | static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
struct bpf_reg_state *dst_reg,
struct bpf_reg_state src_reg)
{
struct bpf_reg_state *regs = cur_regs(env);
u8 opcode = BPF_OP(insn->code);
bool src_known, dst_known;
s64 smin_val, smax_val;
u64 ... | 322,783,137,603,102,700,000,000,000,000,000,000,000 | verifier.c | 226,661,195,244,082,530,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2017-17853 | kernel/bpf/verifier.c in the Linux kernel through 4.14.8 allows local users to cause a denial of service (memory corruption) or possibly have unspecified other impact by leveraging incorrect BPF_RSH signed bounds calculations. | https://nvd.nist.gov/vuln/detail/CVE-2017-17853 |
2,372 | linux | 468f6eafa6c44cb2c5d8aad35e12f06c240a812a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/468f6eafa6c44cb2c5d8aad35e12f06c240a812a | bpf: fix 32-bit ALU op verification
32-bit ALU ops operate on 32-bit values and have 32-bit outputs.
Adjust the verifier accordingly.
Fixes: f1174f77b50c ("bpf/verifier: rework value tracking")
Signed-off-by: Jann Horn <jannh@google.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Daniel Borkman... | 1 | static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
struct bpf_reg_state *dst_reg,
struct bpf_reg_state src_reg)
{
struct bpf_reg_state *regs = cur_regs(env);
u8 opcode = BPF_OP(insn->code);
bool src_known, dst_known;
s64 smin_val, smax_val;
... | 338,721,747,458,807,660,000,000,000,000,000,000,000 | verifier.c | 83,767,931,785,469,610,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2017-17852 | kernel/bpf/verifier.c in the Linux kernel through 4.14.8 allows local users to cause a denial of service (memory corruption) or possibly have unspecified other impact by leveraging mishandling of 32-bit ALU ops. | https://nvd.nist.gov/vuln/detail/CVE-2017-17852 |
2,373 | linux | 4dca6ea1d9432052afb06baf2e3ae78188a4410b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4dca6ea1d9432052afb06baf2e3ae78188a4410b | KEYS: add missing permission check for request_key() destination
When the request_key() syscall is not passed a destination keyring, it
links the requested key (if constructed) into the "default" request-key
keyring. This should require Write permission to the keyring. However,
there is actually no permission check.... | 1 | static void construct_get_dest_keyring(struct key **_dest_keyring)
{
struct request_key_auth *rka;
const struct cred *cred = current_cred();
struct key *dest_keyring = *_dest_keyring, *authkey;
kenter("%p", dest_keyring);
/* find the appropriate keyring */
if (dest_keyring) {
/* the caller supplied on... | 275,435,868,270,037,720,000,000,000,000,000,000,000 | request_key.c | 97,996,113,605,534,320,000,000,000,000,000,000,000 | [
"CWE-862"
] | CVE-2017-17807 | The KEYS subsystem in the Linux kernel before 4.14.6 omitted an access-control check when adding a key to the current task's "default request-key keyring" via the request_key() system call, allowing a local user to use a sequence of crafted system calls to add keys to a keyring with only Search permission (not Write pe... | https://nvd.nist.gov/vuln/detail/CVE-2017-17807 |
2,375 | linux | af3ff8045bbf3e32f1a448542e73abb4c8ceb6f1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/af3ff8045bbf3e32f1a448542e73abb4c8ceb6f1 | crypto: hmac - require that the underlying hash algorithm is unkeyed
Because the HMAC template didn't check that its underlying hash
algorithm is unkeyed, trying to use "hmac(hmac(sha3-512-generic))"
through AF_ALG or through KEYCTL_DH_COMPUTE resulted in the inner HMAC
being used without having been keyed, resulting ... | 1 | static int hmac_create(struct crypto_template *tmpl, struct rtattr **tb)
{
struct shash_instance *inst;
struct crypto_alg *alg;
struct shash_alg *salg;
int err;
int ds;
int ss;
err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH);
if (err)
return err;
salg = shash_attr_alg(tb[1], 0, 0);
if (IS_ERR(sa... | 288,299,611,161,677,800,000,000,000,000,000,000,000 | hmac.c | 108,333,954,641,339,710,000,000,000,000,000,000,000 | [
"CWE-787"
] | CVE-2017-17806 | The HMAC implementation (crypto/hmac.c) in the Linux kernel before 4.14.8 does not validate that the underlying cryptographic hash algorithm is unkeyed, allowing a local attacker able to use the AF_ALG-based hash interface (CONFIG_CRYPTO_USER_API_HASH) and the SHA-3 hash algorithm (CONFIG_CRYPTO_SHA3) to cause a kernel... | https://nvd.nist.gov/vuln/detail/CVE-2017-17806 |
2,377 | linux | ecaaab5649781c5a0effdaf298a925063020500e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ecaaab5649781c5a0effdaf298a925063020500e | crypto: salsa20 - fix blkcipher_walk API usage
When asked to encrypt or decrypt 0 bytes, both the generic and x86
implementations of Salsa20 crash in blkcipher_walk_done(), either when
doing 'kfree(walk->buffer)' or 'free_page((unsigned long)walk->page)',
because walk->buffer and walk->page have not been initialized.
... | 1 | static int encrypt(struct blkcipher_desc *desc,
struct scatterlist *dst, struct scatterlist *src,
unsigned int nbytes)
{
struct blkcipher_walk walk;
struct crypto_blkcipher *tfm = desc->tfm;
struct salsa20_ctx *ctx = crypto_blkcipher_ctx(tfm);
int err;
blkcipher_walk_init(&walk, dst, src, nbytes);
err ... | 328,829,554,120,722,250,000,000,000,000,000,000,000 | salsa20_glue.c | 200,266,005,959,158,550,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2017-17805 | The Salsa20 encryption algorithm in the Linux kernel before 4.14.8 does not correctly handle zero-length inputs, allowing a local attacker able to use the AF_ALG-based skcipher interface (CONFIG_CRYPTO_USER_API_SKCIPHER) to cause a denial of service (uninitialized-memory free and kernel crash) or have unspecified other... | https://nvd.nist.gov/vuln/detail/CVE-2017-17805 |
2,378 | linux | ecaaab5649781c5a0effdaf298a925063020500e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ecaaab5649781c5a0effdaf298a925063020500e | crypto: salsa20 - fix blkcipher_walk API usage
When asked to encrypt or decrypt 0 bytes, both the generic and x86
implementations of Salsa20 crash in blkcipher_walk_done(), either when
doing 'kfree(walk->buffer)' or 'free_page((unsigned long)walk->page)',
because walk->buffer and walk->page have not been initialized.
... | 1 | static int encrypt(struct blkcipher_desc *desc,
struct scatterlist *dst, struct scatterlist *src,
unsigned int nbytes)
{
struct blkcipher_walk walk;
struct crypto_blkcipher *tfm = desc->tfm;
struct salsa20_ctx *ctx = crypto_blkcipher_ctx(tfm);
int err;
blkcipher_walk_init(&walk, dst, src, nbytes);
err ... | 38,637,576,161,082,234,000,000,000,000,000,000,000 | salsa20_generic.c | 88,388,879,794,122,190,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2017-17805 | The Salsa20 encryption algorithm in the Linux kernel before 4.14.8 does not correctly handle zero-length inputs, allowing a local attacker able to use the AF_ALG-based skcipher interface (CONFIG_CRYPTO_USER_API_SKCIPHER) to cause a denial of service (uninitialized-memory free and kernel crash) or have unspecified other... | https://nvd.nist.gov/vuln/detail/CVE-2017-17805 |
2,379 | linux | 8f659a03a0ba9289b9aeb9b4470e6fb263d6f483 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8f659a03a0ba9289b9aeb9b4470e6fb263d6f483 | net: ipv4: fix for a race condition in raw_sendmsg
inet->hdrincl is racy, and could lead to uninitialized stack pointer
usage, so its value should be read only once.
Fixes: c008ba5bdc9f ("ipv4: Avoid reading user iov twice after raw_probe_proto_opt")
Signed-off-by: Mohamed Ghannam <simo.ghannam@gmail.com>
Reviewed-by... | 1 | static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
{
struct inet_sock *inet = inet_sk(sk);
struct net *net = sock_net(sk);
struct ipcm_cookie ipc;
struct rtable *rt = NULL;
struct flowi4 fl4;
int free = 0;
__be32 daddr;
__be32 saddr;
u8 tos;
int err;
struct ip_options_data opt_copy;
... | 148,099,251,020,650,170,000,000,000,000,000,000,000 | raw.c | 754,726,640,040,924,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2017-17712 | The raw_sendmsg() function in net/ipv4/raw.c in the Linux kernel through 4.14.6 has a race condition in inet->hdrincl that leads to uninitialized stack pointer usage; this allows a local user to execute code and gain privileges. | https://nvd.nist.gov/vuln/detail/CVE-2017-17712 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.