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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1,646 | openssl | b15f8769644b00ef7283521593360b7b2135cb63 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/b15f8769644b00ef7283521593360b7b2135cb63 | ECDH downgrade bug fix.
Fix bug where an OpenSSL client would accept a handshake using an
ephemeral ECDH ciphersuites with the server key exchange message omitted.
Thanks to Karthikeyan Bhargavan for reporting this issue.
CVE-2014-3572
Reviewed-by: Matt Caswell <matt@openssl.org> | 1 | int ssl3_get_key_exchange(SSL *s)
{
#ifndef OPENSSL_NO_RSA
unsigned char *q,md_buf[EVP_MAX_MD_SIZE*2];
#endif
EVP_MD_CTX md_ctx;
unsigned char *param,*p;
int al,j,ok;
long i,param_len,n,alg_k,alg_a;
EVP_PKEY *pkey=NULL;
const EVP_MD *md = NULL;
#ifndef OPENSSL_NO_RSA
RSA *rsa=NULL;
#endif
#ifndef OPENSSL_NO_DH... | 301,554,715,472,437,100,000,000,000,000,000,000,000 | None | null | [
"CWE-310"
] | CVE-2014-3572 | The ssl3_get_key_exchange function in s3_clnt.c in OpenSSL before 0.9.8zd, 1.0.0 before 1.0.0p, and 1.0.1 before 1.0.1k allows remote SSL servers to conduct ECDHE-to-ECDH downgrade attacks and trigger a loss of forward secrecy by omitting the ServerKeyExchange message. | https://nvd.nist.gov/vuln/detail/CVE-2014-3572 |
1,656 | nbd | 741495cb08503fd32a9d22648e63b64390c601f4 | https://github.com/yoe/nbd | https://github.com/yoe/nbd/commit/741495cb08503fd32a9d22648e63b64390c601f4 | nbd-server: handle modern-style negotiation in a child process
Previously, the modern style negotiation was carried out in the root
server (listener) process before forking the actual client handler. This
made it possible for a malfunctioning or evil client to terminate the
root process simply by querying a non-existe... | 1 | void serveloop(GArray* servers) {
struct sockaddr_storage addrin;
socklen_t addrinlen=sizeof(addrin);
int i;
int max;
fd_set mset;
fd_set rset;
/*
* Set up the master fd_set. The set of descriptors we need
* to select() for never changes anyway and it buys us a *lot*
* of time to only build this once. Ho... | 143,212,735,324,855,570,000,000,000,000,000,000,000 | nbd-server.c | 174,715,315,005,731,700,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-7441 | The modern style negotiation in Network Block Device (nbd-server) 2.9.22 through 3.3 allows remote attackers to cause a denial of service (root process termination) by (1) closing the connection during negotiation or (2) specifying a name for a non-existent export. | https://nvd.nist.gov/vuln/detail/CVE-2013-7441 |
1,657 | linux | 128394eff343fc6d2f32172f03e24829539c5835 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/128394eff343fc6d2f32172f03e24829539c5835 | sg_write()/bsg_write() is not fit to be called under KERNEL_DS
Both damn things interpret userland pointers embedded into the payload;
worse, they are actually traversing those. Leaving aside the bad
API design, this is very much _not_ safe to call with KERNEL_DS.
Bail out early if that happens.
Cc: stable@vger.kern... | 1 | bsg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
struct bsg_device *bd = file->private_data;
ssize_t bytes_written;
int ret;
dprintk("%s: write %Zd bytes\n", bd->name, count);
bsg_set_block(bd, file);
bytes_written = 0;
ret = __bsg_write(bd, buf, count, &bytes_written,
... | 107,643,057,290,525,440,000,000,000,000,000,000,000 | bsg.c | 6,609,762,736,419,196,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-10088 | The sg implementation in the Linux kernel through 4.9 does not properly restrict write operations in situations where the KERNEL_DS option is set, which allows local users to read or write to arbitrary kernel memory locations or cause a denial of service (use-after-free) by leveraging access to a /dev/sg device, relate... | https://nvd.nist.gov/vuln/detail/CVE-2016-10088 |
1,658 | linux | 128394eff343fc6d2f32172f03e24829539c5835 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/128394eff343fc6d2f32172f03e24829539c5835 | sg_write()/bsg_write() is not fit to be called under KERNEL_DS
Both damn things interpret userland pointers embedded into the payload;
worse, they are actually traversing those. Leaving aside the bad
API design, this is very much _not_ safe to call with KERNEL_DS.
Bail out early if that happens.
Cc: stable@vger.kern... | 1 | sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
int mxsize, cmd_size, k;
int input_size, blocking;
unsigned char opcode;
Sg_device *sdp;
Sg_fd *sfp;
Sg_request *srp;
struct sg_header old_hdr;
sg_io_hdr_t *hp;
unsigned char cmnd[SG_MAX_CDB_SIZE];
if ((!(sfp = (Sg_fd *) f... | 55,314,091,797,718,160,000,000,000,000,000,000,000 | sg.c | 199,371,262,027,085,440,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-10088 | The sg implementation in the Linux kernel through 4.9 does not properly restrict write operations in situations where the KERNEL_DS option is set, which allows local users to read or write to arbitrary kernel memory locations or cause a denial of service (use-after-free) by leveraging access to a /dev/sg device, relate... | https://nvd.nist.gov/vuln/detail/CVE-2016-10088 |
1,659 | linux | 79dc7e3f1cd323be4c81aa1a94faa1b3ed987fb2 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/79dc7e3f1cd323be4c81aa1a94faa1b3ed987fb2 | net: handle no dst on skb in icmp6_send
Andrey reported the following while fuzzing the kernel with syzkaller:
kasan: CONFIG_KASAN_INLINE enabled
kasan: GPF could be caused by NULL-ptr deref or user memory access
general protection fault: 0000 [#1] SMP KASAN
Modules linked in:
CPU: 0 PID: 3859 Comm: a.out Not tainted... | 1 | static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
const struct in6_addr *force_saddr)
{
struct net *net = dev_net(skb->dev);
struct inet6_dev *idev = NULL;
struct ipv6hdr *hdr = ipv6_hdr(skb);
struct sock *sk;
struct ipv6_pinfo *np;
const struct in6_addr *saddr = NULL;
struct dst... | 148,411,612,446,306,800,000,000,000,000,000,000,000 | icmp.c | 303,659,297,633,054,450,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-9919 | The icmp6_send function in net/ipv6/icmp.c in the Linux kernel through 4.8.12 omits a certain check of the dst data structure, which allows remote attackers to cause a denial of service (panic) via a fragmented IPv6 packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-9919 |
1,660 | libgsf | 95a8351a75758cf10b3bf6abae0b6b461f90d9e5 | https://github.com/GNOME/libgsf | https://github.com/GNOME/libgsf/commit/95a8351a75758cf10b3bf6abae0b6b461f90d9e5 | tar: fix crash on broken tar file. | 1 | tar_directory_for_file (GsfInfileTar *dir, const char *name, gboolean last)
{
const char *s = name;
while (1) {
const char *s0 = s;
char *dirname;
/* Find a directory component, if any. */
while (1) {
if (*s == 0) {
if (last && s != s0)
break;
else
return dir;
}
/* This is delibe... | 54,320,595,055,581,590,000,000,000,000,000,000,000 | gsf-infile-tar.c | 239,316,636,556,709,400,000,000,000,000,000,000,000 | [
"CWE-476"
] | CVE-2016-9888 | An error within the "tar_directory_for_file()" function (gsf-infile-tar.c) in GNOME Structured File Library before 1.14.41 can be exploited to trigger a Null pointer dereference and subsequently cause a crash via a crafted TAR file. | https://nvd.nist.gov/vuln/detail/CVE-2016-9888 |
1,661 | linux | 92964c79b357efd980812c4de5c1fd2ec8bb5520 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/92964c79b357efd980812c4de5c1fd2ec8bb5520 | netlink: Fix dump skb leak/double free
When we free cb->skb after a dump, we do it after releasing the
lock. This means that a new dump could have started in the time
being and we'll end up freeing their skb instead of ours.
This patch saves the skb and module before we unlock so we free
the right memory.
Fixes: 16... | 1 | static int netlink_dump(struct sock *sk)
{
struct netlink_sock *nlk = nlk_sk(sk);
struct netlink_callback *cb;
struct sk_buff *skb = NULL;
struct nlmsghdr *nlh;
int len, err = -ENOBUFS;
int alloc_min_size;
int alloc_size;
mutex_lock(nlk->cb_mutex);
if (!nlk->cb_running) {
err = -EINVAL;
goto errout_... | 196,001,105,598,532,200,000,000,000,000,000,000,000 | af_netlink.c | 181,510,954,759,435,270,000,000,000,000,000,000,000 | [
"CWE-415"
] | CVE-2016-9806 | Race condition in the netlink_dump function in net/netlink/af_netlink.c in the Linux kernel before 4.6.3 allows local users to cause a denial of service (double free) or possibly have unspecified other impact via a crafted application that makes sendmsg system calls, leading to a free operation associated with a new du... | https://nvd.nist.gov/vuln/detail/CVE-2016-9806 |
1,662 | linux | 3aa02cb664c5fb1042958c8d1aa8c35055a2ebc4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3aa02cb664c5fb1042958c8d1aa8c35055a2ebc4 | ALSA: pcm : Call kill_fasync() in stream lock
Currently kill_fasync() is called outside the stream lock in
snd_pcm_period_elapsed(). This is potentially racy, since the stream
may get released even during the irq handler is running. Although
snd_pcm_release_substream() calls snd_pcm_drop(), this doesn't
guarantee th... | 1 | void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime;
unsigned long flags;
if (PCM_RUNTIME_CHECK(substream))
return;
runtime = substream->runtime;
snd_pcm_stream_lock_irqsave(substream, flags);
if (!snd_pcm_running(substream) ||
snd_pcm_update_hw_ptr0(substre... | 161,224,995,451,594,300,000,000,000,000,000,000,000 | pcm_lib.c | 125,569,751,360,658,480,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-9794 | Race condition in the snd_pcm_period_elapsed function in sound/core/pcm_lib.c in the ALSA subsystem in the Linux kernel before 4.7 allows local users to cause a denial of service (use-after-free) or possibly have unspecified other impact via a crafted SNDRV_PCM_TRIGGER_START command. | https://nvd.nist.gov/vuln/detail/CVE-2016-9794 |
1,663 | linux | b98b0bc8c431e3ceb4b26b0dfc8db509518fb290 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b98b0bc8c431e3ceb4b26b0dfc8db509518fb290 | net: avoid signed overflows for SO_{SND|RCV}BUFFORCE
CAP_NET_ADMIN users should not be allowed to set negative
sk_sndbuf or sk_rcvbuf values, as it can lead to various memory
corruptions, crashes, OOM...
Note that before commit 82981930125a ("net: cleanups in
sock_setsockopt()"), the bug was even more serious, since ... | 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_setbindtodevice(sk, optval, o... | 66,744,804,628,888,285,000,000,000,000,000,000,000 | sock.c | 37,494,279,310,679,760,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-9793 | The sock_setsockopt function in net/core/sock.c in the Linux kernel before 4.8.14 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 c... | https://nvd.nist.gov/vuln/detail/CVE-2016-9793 |
1,664 | linux | 81cdb259fb6d8c1c4ecfeea389ff5a73c07f5755 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/81cdb259fb6d8c1c4ecfeea389ff5a73c07f5755 | KVM: x86: fix out-of-bounds accesses of rtc_eoi map
KVM was using arrays of size KVM_MAX_VCPUS with vcpu_id, but ID can be
bigger that the maximal number of VCPUs, resulting in out-of-bounds
access.
Found by syzkaller:
BUG: KASAN: slab-out-of-bounds in __apic_accept_irq+0xb33/0xb50 at addr [...]
Write of size 1 ... | 1 | static void rtc_irq_eoi_tracking_reset(struct kvm_ioapic *ioapic)
{
ioapic->rtc_status.pending_eoi = 0;
bitmap_zero(ioapic->rtc_status.dest_map.map, KVM_MAX_VCPUS);
}
| 131,623,410,041,848,010,000,000,000,000,000,000,000 | ioapic.c | 261,284,608,400,710,700,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-9777 | KVM in the Linux kernel before 4.8.12, when I/O APIC is enabled, does not properly restrict the VCPU index, which allows guest OS users to gain host OS privileges or cause a denial of service (out-of-bounds array access and host OS crash) via a crafted interrupt request, related to arch/x86/kvm/ioapic.c and arch/x86/kv... | https://nvd.nist.gov/vuln/detail/CVE-2016-9777 |
1,667 | linux | 9b57da0630c9fd36ed7a20fc0f98dc82cc0777fa | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9b57da0630c9fd36ed7a20fc0f98dc82cc0777fa | netfilter: ipv6: nf_defrag: drop mangled skb on ream error
Dmitry Vyukov reported GPF in network stack that Andrey traced down to
negative nh offset in nf_ct_frag6_queue().
Problem is that all network headers before fragment header are pulled.
Normal ipv6 reassembly will drop the skb when errors occur further down
th... | 1 | int nf_ct_frag6_gather(struct net *net, struct sk_buff *skb, u32 user)
{
struct net_device *dev = skb->dev;
int fhoff, nhoff, ret;
struct frag_hdr *fhdr;
struct frag_queue *fq;
struct ipv6hdr *hdr;
u8 prevhdr;
/* Jumbo payload inhibits frag. header */
if (ipv6_hdr(skb)->payload_len == 0) {
pr_debug("paylo... | 162,173,779,084,684,320,000,000,000,000,000,000,000 | nf_conntrack_reasm.c | 248,081,613,101,425,030,000,000,000,000,000,000,000 | [
"CWE-787"
] | CVE-2016-9755 | The netfilter subsystem in the Linux kernel before 4.9 mishandles IPv6 reassembly, which allows local users to cause a denial of service (integer overflow, out-of-bounds write, and GPF) or possibly have unspecified other impact via a crafted application that makes socket, connect, and writev system calls, related to ne... | https://nvd.nist.gov/vuln/detail/CVE-2016-9755 |
1,668 | linux | 9b57da0630c9fd36ed7a20fc0f98dc82cc0777fa | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9b57da0630c9fd36ed7a20fc0f98dc82cc0777fa | netfilter: ipv6: nf_defrag: drop mangled skb on ream error
Dmitry Vyukov reported GPF in network stack that Andrey traced down to
negative nh offset in nf_ct_frag6_queue().
Problem is that all network headers before fragment header are pulled.
Normal ipv6 reassembly will drop the skb when errors occur further down
th... | 1 | static unsigned int ipv6_defrag(void *priv,
struct sk_buff *skb,
const struct nf_hook_state *state)
{
int err;
#if IS_ENABLED(CONFIG_NF_CONNTRACK)
/* Previously seen (loopback)? */
if (skb->nfct && !nf_ct_is_template((struct nf_conn *)skb->nfct))
return NF_ACCEPT;
#endif
err = nf_ct_frag6_gather(state->... | 58,843,208,546,829,070,000,000,000,000,000,000,000 | nf_defrag_ipv6_hooks.c | 263,801,013,687,032,600,000,000,000,000,000,000,000 | [
"CWE-787"
] | CVE-2016-9755 | The netfilter subsystem in the Linux kernel before 4.9 mishandles IPv6 reassembly, which allows local users to cause a denial of service (integer overflow, out-of-bounds write, and GPF) or possibly have unspecified other impact via a crafted application that makes socket, connect, and writev system calls, related to ne... | https://nvd.nist.gov/vuln/detail/CVE-2016-9755 |
1,675 | linux | a0ac402cfcdc904f9772e1762b3fda112dcc56a0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a0ac402cfcdc904f9772e1762b3fda112dcc56a0 | Don't feed anything but regular iovec's to blk_rq_map_user_iov
In theory we could map other things, but there's a reason that function
is called "user_iov". Using anything else (like splice can do) just
confuses it.
Reported-and-tested-by: Johannes Thumshirn <jthumshirn@suse.de>
Cc: Al Viro <viro@ZenIV.linux.org.uk>... | 1 | int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
struct rq_map_data *map_data,
const struct iov_iter *iter, gfp_t gfp_mask)
{
bool copy = false;
unsigned long align = q->dma_pad_mask | queue_dma_alignment(q);
struct bio *bio = NULL;
struct iov_iter i;
int ret;
if (map_data)
copy ... | 26,597,385,003,267,720,000,000,000,000,000,000,000 | blk-map.c | 40,067,109,018,686,807,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-9576 | The blk_rq_map_user_iov function in block/blk-map.c in the Linux kernel before 4.8.14 does not properly restrict the type of iterator, which allows local users to read or write to arbitrary kernel memory locations or cause a denial of service (use-after-free) by leveraging access to a /dev/sg device. | https://nvd.nist.gov/vuln/detail/CVE-2016-9576 |
1,678 | libtiff | ae9365db1b271b62b35ce018eac8799b1d5e8a53 | https://github.com/vadz/libtiff | https://github.com/vadz/libtiff/commit/ae9365db1b271b62b35ce018eac8799b1d5e8a53 | * tools/tiffcrop.c: fix out-of-bound read of up to 3 bytes in
readContigTilesIntoBuffer(). Reported as MSVR 35092 by Axel Souchet
& Vishal Chauhan from the MSRC Vulnerabilities & Mitigations team. | 1 | static int readContigTilesIntoBuffer (TIFF* in, uint8* buf,
uint32 imagelength,
uint32 imagewidth,
uint32 tw, uint32 tl,
tsample_t spp, uint16 bps)
{
int status ... | 246,301,533,722,000,940,000,000,000,000,000,000,000 | None | null | [
"CWE-125"
] | CVE-2016-9539 | tools/tiffcrop.c in libtiff 4.0.6 has an out-of-bounds read in readContigTilesIntoBuffer(). Reported as MSVR 35092. | https://nvd.nist.gov/vuln/detail/CVE-2016-9539 |
1,680 | libtiff | 43c0b81a818640429317c80fea1e66771e85024b | https://github.com/vadz/libtiff | https://github.com/vadz/libtiff/commit/43c0b81a818640429317c80fea1e66771e85024b#diff-c8b4b355f9b5c06d585b23138e1c185f | * tools/tiffcp.c: fix read of undefined variable in case of missing
required tags. Found on test case of MSVR 35100.
* tools/tiffcrop.c: fix read of undefined buffer in
readContigStripsIntoBuffer() due to uint16 overflow. Probably not a
security issue but I can be wrong. Reported as MSVR 35100 by Axel
Souchet from the ... | 1 | static int readContigStripsIntoBuffer (TIFF* in, uint8* buf)
{
uint8* bufp = buf;
int32 bytes_read = 0;
uint16 strip, nstrips = TIFFNumberOfStrips(in);
uint32 stripsize = TIFFStripSize(in);
uint32 rows = 0;
uint32 rps = TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERST... | 271,787,766,249,009,200,000,000,000,000,000,000,000 | None | null | [
"CWE-190"
] | CVE-2016-9538 | tools/tiffcrop.c in libtiff 4.0.6 reads an undefined buffer in readContigStripsIntoBuffer() because of a uint16 integer overflow. Reported as MSVR 35100. | https://nvd.nist.gov/vuln/detail/CVE-2016-9538 |
1,704 | w3m | d43527cfa0dbb3ccefec4a6f7b32c1434739aa29 | https://github.com/tats/w3m | https://github.com/tats/w3m/commit/d43527cfa0dbb3ccefec4a6f7b32c1434739aa29 | Merge pull request #27 from kcwu/fix-strgrow
Fix potential heap buffer corruption due to Strgrow | 1 | Strgrow(Str x)
{
char *old = x->ptr;
int newlen;
newlen = x->length * 6 / 5;
if (newlen == x->length)
newlen += 2;
x->ptr = GC_MALLOC_ATOMIC(newlen);
x->area_size = newlen;
bcopy((void *)old, (void *)x->ptr, x->length);
GC_free(old);
}
| 127,289,135,144,358,380,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-9442 | An issue was discovered in the Tatsuya Kinoshita w3m fork before 0.5.3-31. w3m allows remote attackers to cause memory corruption in certain conditions via a crafted HTML page. | https://nvd.nist.gov/vuln/detail/CVE-2016-9442 |
1,706 | linux | 93362fa47fe98b62e4a34ab408c4a418432e7939 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/93362fa47fe98b62e4a34ab408c4a418432e7939 | sysctl: Drop reference added by grab_header in proc_sys_readdir
Fixes CVE-2016-9191, proc_sys_readdir doesn't drop reference
added by grab_header when return from !dir_emit_dots path.
It can cause any path called unregister_sysctl_table will
wait forever.
The calltrace of CVE-2016-9191:
[ 5535.960522] Call Trace:
[ ... | 1 | static int proc_sys_readdir(struct file *file, struct dir_context *ctx)
{
struct ctl_table_header *head = grab_header(file_inode(file));
struct ctl_table_header *h = NULL;
struct ctl_table *entry;
struct ctl_dir *ctl_dir;
unsigned long pos;
if (IS_ERR(head))
return PTR_ERR(head);
ctl_dir = container_of(head... | 225,602,089,609,046,580,000,000,000,000,000,000,000 | proc_sysctl.c | 174,833,638,602,164,460,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-9191 | The cgroup offline implementation in the Linux kernel through 4.8.11 mishandles certain drain operations, which allows local users to cause a denial of service (system hang) by leveraging access to a container environment for executing a crafted application, as demonstrated by trinity. | https://nvd.nist.gov/vuln/detail/CVE-2016-9191 |
1,710 | linux | 9590232bb4f4cc824f3425a6e1349afbe6d6d2b7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9590232bb4f4cc824f3425a6e1349afbe6d6d2b7 | staging/android/ion : fix a race condition in the ion driver
There is a use-after-free problem in the ion driver.
This is caused by a race condition in the ion_ioctl()
function.
A handle has ref count of 1 and two tasks on different
cpus calls ION_IOC_FREE simultaneously.
cpu 0 cpu ... | 1 | static long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
struct ion_client *client = filp->private_data;
struct ion_device *dev = client->dev;
struct ion_handle *cleanup_handle = NULL;
int ret = 0;
unsigned int dir;
union {
struct ion_fd_data fd;
struct ion_allocation_data allocation;
... | 33,118,785,611,393,110,000,000,000,000,000,000,000 | None | null | [
"CWE-416"
] | CVE-2016-9120 | Race condition in the ion_ioctl function in drivers/staging/android/ion/ion.c in the Linux kernel before 4.6 allows local users to gain privileges or cause a denial of service (use-after-free) by calling ION_IOC_FREE on two CPUs at the same time. | https://nvd.nist.gov/vuln/detail/CVE-2016-9120 |
1,711 | linux | 05692d7005a364add85c6e25a6c4447ce08f913a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05692d7005a364add85c6e25a6c4447ce08f913a | vfio/pci: Fix integer overflows, bitmask check
The VFIO_DEVICE_SET_IRQS ioctl did not sufficiently sanitize
user-supplied integers, potentially allowing memory corruption. This
patch adds appropriate integer overflow checks, checks the range bounds
for VFIO_IRQ_SET_DATA_NONE, and also verifies that only single element... | 1 | static long vfio_pci_ioctl(void *device_data,
unsigned int cmd, unsigned long arg)
{
struct vfio_pci_device *vdev = device_data;
unsigned long minsz;
if (cmd == VFIO_DEVICE_GET_INFO) {
struct vfio_device_info info;
minsz = offsetofend(struct vfio_device_info, num_irqs);
if (copy_from_user(&info, (void... | 14,003,092,725,819,900,000,000,000,000,000,000,000 | vfio_pci.c | 50,249,264,138,078,830,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-9083 | drivers/vfio/pci/vfio_pci.c in the Linux kernel through 4.8.11 allows local users to bypass integer overflow checks, and cause a denial of service (memory corruption) or have unspecified other impact, by leveraging access to a vfio PCI device file for a VFIO_DEVICE_SET_IRQS ioctl call, aka a "state machine confusion bu... | https://nvd.nist.gov/vuln/detail/CVE-2016-9083 |
1,712 | openssh-portable | ec165c392ca54317dbe3064a8c200de6531e89ad | https://github.com/openssh/openssh-portable | https://github.com/openssh/openssh-portable/commit/ec165c392ca54317dbe3064a8c200de6531e89ad | upstream commit
Unregister the KEXINIT handler after message has been
received. Otherwise an unauthenticated peer can repeat the KEXINIT and cause
allocation of up to 128MB -- until the connection is closed. Reported by
shilei-c at 360.cn
Upstream-ID: 43649ae12a27ef94290db16d1a98294588b75c05 | 1 | kex_input_kexinit(int type, u_int32_t seq, void *ctxt)
{
struct ssh *ssh = ctxt;
struct kex *kex = ssh->kex;
const u_char *ptr;
u_int i;
size_t dlen;
int r;
debug("SSH2_MSG_KEXINIT received");
if (kex == NULL)
return SSH_ERR_INVALID_ARGUMENT;
ptr = sshpkt_ptr(ssh, &dlen);
if ((r = sshbuf_put(kex->pee... | 339,023,894,075,827,400,000,000,000,000,000,000,000 | kex.c | 228,822,789,731,076,200,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2016-8858 | The kex_input_kexinit function in kex.c in OpenSSH 6.x and 7.x through 7.3 allows remote attackers to cause a denial of service (memory consumption) by sending many duplicate KEXINIT requests. NOTE: a third party reports that "OpenSSH upstream does not consider this as a security issue." | https://nvd.nist.gov/vuln/detail/CVE-2016-8858 |
1,715 | linux | ded89912156b1a47d940a0c954c43afbabd0c42c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ded89912156b1a47d940a0c954c43afbabd0c42c | brcmfmac: avoid potential stack overflow in brcmf_cfg80211_start_ap()
User-space can choose to omit NL80211_ATTR_SSID and only provide raw
IE TLV data. When doing so it can provide SSID IE with length exceeding
the allowed size. The driver further processes this IE copying it
into a local variable without checking the... | 1 | brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_ap_settings *settings)
{
s32 ie_offset;
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct brcmf_if *ifp = netdev_priv(ndev);
const struct brcmf_tlv *ssid_ie;
const struct brcmf_tlv *country_ie;
struct brcmf_ssid_l... | 107,596,959,318,646,240,000,000,000,000,000,000,000 | cfg80211.c | 239,830,303,826,032,670,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-8658 | Stack-based buffer overflow in the brcmf_cfg80211_start_ap function in drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c in the Linux kernel before 4.7.5 allows local users to cause a denial of service (system crash) or possibly have unspecified other impact via a long SSID Information Element in a command to... | https://nvd.nist.gov/vuln/detail/CVE-2016-8658 |
1,716 | linux | 84ac7260236a49c79eede91617700174c2c19b0c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/84ac7260236a49c79eede91617700174c2c19b0c | packet: fix race condition in packet_set_ring
When packet_set_ring creates a ring buffer it will initialize a
struct timer_list if the packet version is TPACKET_V3. This value
can then be raced by a different thread calling setsockopt to
set the version to TPACKET_V1 before packet_set_ring has finished.
This leads to... | 1 | static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring)
{
struct pgv *pg_vec = NULL;
struct packet_sock *po = pkt_sk(sk);
int was_running, order = 0;
struct packet_ring_buffer *rb;
struct sk_buff_head *rb_queue;
__be16 num;
int err = -EINVAL;
/* Added to avoid minima... | 180,651,518,307,462,070,000,000,000,000,000,000,000 | af_packet.c | 4,675,655,767,715,536,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-8655 | Race condition in net/packet/af_packet.c in the Linux kernel through 4.8.12 allows local users to gain privileges or cause a denial of service (use-after-free) by leveraging the CAP_NET_RAW capability to change a socket version, related to the packet_set_ring and packet_setsockopt functions. | https://nvd.nist.gov/vuln/detail/CVE-2016-8655 |
1,717 | linux | 84ac7260236a49c79eede91617700174c2c19b0c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/84ac7260236a49c79eede91617700174c2c19b0c | packet: fix race condition in packet_set_ring
When packet_set_ring creates a ring buffer it will initialize a
struct timer_list if the packet version is TPACKET_V3. This value
can then be raced by a different thread calling setsockopt to
set the version to TPACKET_V1 before packet_set_ring has finished.
This leads to... | 1 | packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
struct packet_sock *po = pkt_sk(sk);
int ret;
if (level != SOL_PACKET)
return -ENOPROTOOPT;
switch (optname) {
case PACKET_ADD_MEMBERSHIP:
case PACKET_DROP_MEMBERSHIP:
{
s... | 235,008,048,746,926,100,000,000,000,000,000,000,000 | af_packet.c | 4,675,655,767,715,536,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-8655 | Race condition in net/packet/af_packet.c in the Linux kernel through 4.8.12 allows local users to gain privileges or cause a denial of service (use-after-free) by leveraging the CAP_NET_RAW capability to change a socket version, related to the packet_set_ring and packet_setsockopt functions. | https://nvd.nist.gov/vuln/detail/CVE-2016-8655 |
1,718 | linux | 4afa5f9617927453ac04b24b584f6c718dfb4f45 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4afa5f9617927453ac04b24b584f6c718dfb4f45 | crypto: algif_hash - Only export and import on sockets with data
The hash_accept call fails to work on sockets that have not received
any data. For some algorithm implementations it may cause crashes.
This patch fixes this by ensuring that we only export and import on
sockets that have received data.
Cc: stable@vge... | 1 | static int hash_accept(struct socket *sock, struct socket *newsock, int flags)
{
struct sock *sk = sock->sk;
struct alg_sock *ask = alg_sk(sk);
struct hash_ctx *ctx = ask->private;
struct ahash_request *req = &ctx->req;
char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req))];
struct sock *sk2;
struct alg_... | 855,501,647,450,820,300,000,000,000,000,000,000 | algif_hash.c | 274,659,569,534,280,800,000,000,000,000,000,000,000 | [
"CWE-476"
] | CVE-2016-8646 | The hash_accept function in crypto/algif_hash.c in the Linux kernel before 4.3.6 allows local users to cause a denial of service (OOPS) by attempting to trigger use of in-kernel hash algorithms for a socket that has received zero bytes of data. | https://nvd.nist.gov/vuln/detail/CVE-2016-8646 |
1,719 | linux | ac6e780070e30e4c35bd395acfe9191e6268bdd3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac6e780070e30e4c35bd395acfe9191e6268bdd3 | tcp: take care of truncations done by sk_filter()
With syzkaller help, Marco Grassi found a bug in TCP stack,
crashing in tcp_collapse()
Root cause is that sk_filter() can truncate the incoming skb,
but TCP stack was not really expecting this to happen.
It probably was expecting a simple DROP or ACCEPT behavior.
We ... | 1 | int tcp_v4_rcv(struct sk_buff *skb)
{
struct net *net = dev_net(skb->dev);
const struct iphdr *iph;
const struct tcphdr *th;
bool refcounted;
struct sock *sk;
int ret;
if (skb->pkt_type != PACKET_HOST)
goto discard_it;
/* Count it even if it's bad */
__TCP_INC_STATS(net, TCP_MIB_INSEGS);
if (!pskb_may_pu... | 284,014,189,874,385,800,000,000,000,000,000,000,000 | tcp_ipv4.c | 172,691,742,001,660,820,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-8645 | The TCP stack in the Linux kernel before 4.8.10 mishandles skb truncation, which allows local users to cause a denial of service (system crash) via a crafted application that makes sendto system calls, related to net/ipv4/tcp_ipv4.c and net/ipv6/tcp_ipv6.c. | https://nvd.nist.gov/vuln/detail/CVE-2016-8645 |
1,724 | linux | d9092f52d7e61dd1557f2db2400ddb430e85937e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d9092f52d7e61dd1557f2db2400ddb430e85937e | kvm: x86: Check memopp before dereference (CVE-2016-8630)
Commit 41061cdb98 ("KVM: emulate: do not initialize memopp") removes a
check for non-NULL under incorrect assumptions. An undefined instruction
with a ModR/M byte with Mod=0 and R/M-5 (e.g. 0xc7 0x15) will attempt
to dereference a null pointer here.
Fixes: 410... | 1 | int x86_decode_insn(struct x86_emulate_ctxt *ctxt, void *insn, int insn_len)
{
int rc = X86EMUL_CONTINUE;
int mode = ctxt->mode;
int def_op_bytes, def_ad_bytes, goffset, simd_prefix;
bool op_prefix = false;
bool has_seg_override = false;
struct opcode opcode;
ctxt->memop.type = OP_NONE;
ctxt->memopp = NULL;
c... | 204,947,235,715,738,400,000,000,000,000,000,000,000 | emulate.c | 229,450,093,523,585,650,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-8630 | The x86_decode_insn function in arch/x86/kvm/emulate.c in the Linux kernel before 4.8.7, when KVM is enabled, allows local users to cause a denial of service (host OS crash) via a certain use of a ModR/M byte in an undefined instruction. | https://nvd.nist.gov/vuln/detail/CVE-2016-8630 |
1,725 | linux | c58d6c93680f28ac58984af61d0a7ebf4319c241 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c58d6c93680f28ac58984af61d0a7ebf4319c241 | netfilter: nfnetlink: correctly validate length of batch messages
If nlh->nlmsg_len is zero then an infinite loop is triggered because
'skb_pull(skb, msglen);' pulls zero bytes.
The calculation in nlmsg_len() underflows if 'nlh->nlmsg_len <
NLMSG_HDRLEN' which bypasses the length validation and will later
trigger an ... | 1 | static void nfnetlink_rcv_batch(struct sk_buff *skb, struct nlmsghdr *nlh,
u_int16_t subsys_id)
{
struct sk_buff *oskb = skb;
struct net *net = sock_net(skb->sk);
const struct nfnetlink_subsystem *ss;
const struct nfnl_callback *nc;
static LIST_HEAD(err_list);
u32 status;
int err;
if (subsys_id >= NFNL_SUB... | 284,681,399,279,689,300,000,000,000,000,000,000,000 | nfnetlink.c | 266,157,007,856,312,750,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-7917 | The nfnetlink_rcv_batch function in net/netfilter/nfnetlink.c in the Linux kernel before 4.5 does not check whether a batch message's length field is large enough, which allows local users to obtain sensitive information from kernel memory or cause a denial of service (infinite loop or out-of-bounds read) by leveraging... | https://nvd.nist.gov/vuln/detail/CVE-2016-7917 |
1,726 | linux | 50220dead1650609206efe91f0cc116132d59b3f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/50220dead1650609206efe91f0cc116132d59b3f | HID: core: prevent out-of-bound readings
Plugging a Logitech DJ receiver with KASAN activated raises a bunch of
out-of-bound readings.
The fields are allocated up to MAX_USAGE, meaning that potentially, we do
not have enough fields to fit the incoming values.
Add checks and silence KASAN.
Signed-off-by: Benjamin Tis... | 1 | static void hid_input_field(struct hid_device *hid, struct hid_field *field,
__u8 *data, int interrupt)
{
unsigned n;
unsigned count = field->report_count;
unsigned offset = field->report_offset;
unsigned size = field->report_size;
__s32 min = field->logical_minimum;
__s32 max = field->logical_maximum;
__... | 188,242,288,363,672,830,000,000,000,000,000,000,000 | hid-core.c | 315,690,708,720,987,600,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-7915 | The hid_input_field function in drivers/hid/hid-core.c in the Linux kernel before 4.6 allows physically proximate attackers to obtain sensitive information from kernel memory or cause a denial of service (out-of-bounds read) by connecting a device, as demonstrated by a Logitech DJ receiver. | https://nvd.nist.gov/vuln/detail/CVE-2016-7915 |
1,727 | linux | 8d4a2ec1e0b41b0cf9a0c5cd4511da7f8e4f3de2 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d4a2ec1e0b41b0cf9a0c5cd4511da7f8e4f3de2 | assoc_array: don't call compare_object() on a node
Changes since V1: fixed the description and added KASan warning.
In assoc_array_insert_into_terminal_node(), we call the
compare_object() method on all non-empty slots, even when they're
not leaves, passing a pointer to an unexpected structure to
compare_object(). Cu... | 1 | static bool assoc_array_insert_into_terminal_node(struct assoc_array_edit *edit,
const struct assoc_array_ops *ops,
const void *index_key,
struct assoc_array_walk_result *result)
{
struct assoc_array_shortcut *shortcut, *new_s0;
struct assoc_array_node *node, *new_n0, *new_n1, *side;
struct a... | 107,205,147,767,459,400,000,000,000,000,000,000,000 | assoc_array.c | 22,582,493,732,100,015,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-7914 | The assoc_array_insert_into_terminal_node function in lib/assoc_array.c in the Linux kernel before 4.5.3 does not check whether a slot is a leaf, which allows local users to obtain sensitive information from kernel memory or cause a denial of service (invalid pointer dereference and out-of-bounds read) via an applicati... | https://nvd.nist.gov/vuln/detail/CVE-2016-7914 |
1,728 | linux | 8dfbcc4351a0b6d2f2d77f367552f48ffefafe18 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8dfbcc4351a0b6d2f2d77f367552f48ffefafe18 | [media] xc2028: avoid use after free
If struct xc2028_config is passed without a firmware name,
the following trouble may happen:
[11009.907205] xc2028 5-0061: type set to XCeive xc2028/xc3028 tuner
[11009.907491] ==================================================================
[11009.907750] BUG: KASAN: use-after-... | 1 | static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
{
struct xc2028_data *priv = fe->tuner_priv;
struct xc2028_ctrl *p = priv_cfg;
int rc = 0;
tuner_dbg("%s called\n", __func__);
mutex_lock(&priv->lock);
/*
* Copy the config data.
* For the firmware name, keep a local... | 55,587,506,258,633,540,000,000,000,000,000,000,000 | tuner-xc2028.c | 144,392,756,984,583,100,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-7913 | The xc2028_set_config function in drivers/media/tuners/tuner-xc2028.c in the Linux kernel before 4.6 allows local users to gain privileges or cause a denial of service (use-after-free) via vectors involving omission of the firmware name from a certain data structure. | https://nvd.nist.gov/vuln/detail/CVE-2016-7913 |
1,729 | linux | 38740a5b87d53ceb89eb2c970150f6e94e00373a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/38740a5b87d53ceb89eb2c970150f6e94e00373a | usb: gadget: f_fs: Fix use-after-free
When using asynchronous read or write operations on the USB endpoints the
issuer of the IO request is notified by calling the ki_complete() callback
of the submitted kiocb when the URB has been completed.
Calling this ki_complete() callback will free kiocb. Make sure that the
str... | 1 | static void ffs_user_copy_worker(struct work_struct *work)
{
struct ffs_io_data *io_data = container_of(work, struct ffs_io_data,
work);
int ret = io_data->req->status ? io_data->req->status :
io_data->req->actual;
if (io_data->read && ret > 0) {
use_mm(io_data->mm);
ret = copy_to_iter(io_d... | 325,805,134,765,406,900,000,000,000,000,000,000,000 | f_fs.c | 210,013,898,798,065,750,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-7912 | Use-after-free vulnerability in the ffs_user_copy_worker function in drivers/usb/gadget/function/f_fs.c in the Linux kernel before 4.5.3 allows local users to gain privileges by accessing an I/O data structure after a certain callback call. | https://nvd.nist.gov/vuln/detail/CVE-2016-7912 |
1,730 | linux | 8ba8682107ee2ca3347354e018865d8e1967c5f4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8ba8682107ee2ca3347354e018865d8e1967c5f4 | block: fix use-after-free in sys_ioprio_get()
get_task_ioprio() accesses the task->io_context without holding the task
lock and thus can race with exit_io_context(), leading to a
use-after-free. The reproducer below hits this within a few seconds on
my 4-core QEMU VM:
#define _GNU_SOURCE
#include <assert.h>
#include ... | 1 | static int get_task_ioprio(struct task_struct *p)
{
int ret;
ret = security_task_getioprio(p);
if (ret)
goto out;
ret = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, IOPRIO_NORM);
if (p->io_context)
ret = p->io_context->ioprio;
out:
return ret;
}
| 258,186,631,754,045,350,000,000,000,000,000,000,000 | ioprio.c | 20,495,164,370,427,705,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-7911 | Race condition in the get_task_ioprio function in block/ioprio.c in the Linux kernel before 4.6.6 allows local users to gain privileges or cause a denial of service (use-after-free) via a crafted ioprio_get system call. | https://nvd.nist.gov/vuln/detail/CVE-2016-7911 |
1,731 | linux | 77da160530dd1dc94f6ae15a981f24e5f0021e84 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/77da160530dd1dc94f6ae15a981f24e5f0021e84 | block: fix use-after-free in seq file
I got a KASAN report of use-after-free:
==================================================================
BUG: KASAN: use-after-free in klist_iter_exit+0x61/0x70 at addr ffff8800b6581508
Read of size 8 by task trinity-c1/315
======================================... | 1 | static void disk_seqf_stop(struct seq_file *seqf, void *v)
{
struct class_dev_iter *iter = seqf->private;
/* stop is called even after start failed :-( */
if (iter) {
class_dev_iter_exit(iter);
kfree(iter);
}
}
| 299,775,501,717,424,660,000,000,000,000,000,000,000 | genhd.c | 241,520,307,378,534,750,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-7910 | Use-after-free vulnerability in the disk_seqf_stop function in block/genhd.c in the Linux kernel before 4.7.1 allows local users to gain privileges by leveraging the execution of a certain stop operation even if the corresponding start operation had failed. | https://nvd.nist.gov/vuln/detail/CVE-2016-7910 |
1,732 | libgd | 40bec0f38f50e8510f5bb71a82f516d46facde03 | https://github.com/libgd/libgd | https://github.com/libgd/libgd/commit/40bec0f38f50e8510f5bb71a82f516d46facde03 | Merge branch 'pull-request/296' | 1 | BGD_DECLARE(void) gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quality)
{
uint8_t *argb;
int x, y;
uint8_t *p;
uint8_t *out;
size_t out_size;
if (im == NULL) {
return;
}
if (!gdImageTrueColor(im)) {
gd_error("Paletter image not supported by webp");
return;
}
if (quality == -1) {
quality =... | 134,338,295,145,600,240,000,000,000,000,000,000,000 | None | null | [
"CWE-190"
] | CVE-2016-7568 | Integer overflow in the gdImageWebpCtx function in gd_webp.c in the GD Graphics Library (aka libgd) through 2.2.3, as used in PHP through 7.0.11, allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via crafted imagewebp and imagedestroy calls. | https://nvd.nist.gov/vuln/detail/CVE-2016-7568 |
1,733 | php-src | c4cca4c20e75359c9a13a1f9a36cb7b4e9601d29 | https://github.com/php/php-src | https://github.com/php/php-src/commit/c4cca4c20e75359c9a13a1f9a36cb7b4e9601d29?w=1 | Fix bug #73065: Out-Of-Bounds Read in php_wddx_push_element of wddx.c | 1 | static void php_wddx_push_element(void *user_data, const XML_Char *name, const XML_Char **atts)
{
st_entry ent;
wddx_stack *stack = (wddx_stack *)user_data;
if (!strcmp(name, EL_PACKET)) {
int i;
if (atts) for (i=0; atts[i]; i++) {
if (!strcmp(atts[i], EL_VERSION)) {
/* nothing for now */
}
}
} el... | 138,332,882,986,529,270,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-7418 | The php_wddx_push_element function in ext/wddx/wddx.c in PHP before 5.6.26 and 7.x before 7.0.11 allows remote attackers to cause a denial of service (invalid pointer access and out-of-bounds read) or possibly have unspecified other impact via an incorrect boolean element in a wddxPacket XML document, leading to mishan... | https://nvd.nist.gov/vuln/detail/CVE-2016-7418 |
1,737 | php-src | 6d55ba265637d6adf0ba7e9c9ef11187d1ec2f5b | https://github.com/php/php-src | https://github.com/php/php-src/commit/6d55ba265637d6adf0ba7e9c9ef11187d1ec2f5b?w=1 | Fix bug #73007: add locale length check | 1 | PHP_FUNCTION( msgfmt_format_message )
{
zval *args;
UChar *spattern = NULL;
int spattern_len = 0;
char *pattern = NULL;
int pattern_len = 0;
const char *slocale = NULL;
int slocale_len = 0;
MessageFormatter_object mf = {0};
MessageFormatter_object *mfo = &mf;
/* Parse... | 138,237,320,751,157,490,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-7416 | ext/intl/msgformat/msgformat_format.c in PHP before 5.6.26 and 7.x before 7.0.11 does not properly restrict the locale length provided to the Locale class in the ICU library, which allows remote attackers to cause a denial of service (application crash) or possibly have unspecified other impact via a MessageFormatter::... | https://nvd.nist.gov/vuln/detail/CVE-2016-7416 |
1,739 | php-src | 28f80baf3c53e267c9ce46a2a0fadbb981585132 | https://github.com/php/php-src | https://github.com/php/php-src/commit/28f80baf3c53e267c9ce46a2a0fadbb981585132?w=1 | Fix bug #72293 - Heap overflow in mysqlnd related to BIT fields | 1 | php_mysqlnd_rowp_read_text_protocol_aux(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
unsigned int field_count, const MYSQLND_FIELD * fields_metadata,
zend_bool as_int_or_float, zend_bool copy_data, MYSQLND_STATS * stats TSRMLS_DC)
{
unsigned int i;
zend_bool last_field_was_string = FALS... | 190,243,804,462,372,060,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-7412 | ext/mysqlnd/mysqlnd_wireprotocol.c in PHP before 5.6.26 and 7.x before 7.0.11 does not verify that a BIT field has the UNSIGNED_FLAG flag, which allows remote MySQL servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via crafted field metadata. | https://nvd.nist.gov/vuln/detail/CVE-2016-7412 |
1,744 | libarchive | 6e06b1c89dd0d16f74894eac4cfc1327a06ee4a0 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/6e06b1c89dd0d16f74894eac4cfc1327a06ee4a0 | Fix a potential crash issue discovered by Alexander Cherepanov:
It seems bsdtar automatically handles stacked compression. This is a
nice feature but it could be problematic when it's completely
unlimited. Most clearly it's illustrated with quines:
$ curl -sRO http://www.maximumcompression.com/selfgz.gz
$ (ulimit -v... | 1 | choose_filters(struct archive_read *a)
{
int number_bidders, i, bid, best_bid;
struct archive_read_filter_bidder *bidder, *best_bidder;
struct archive_read_filter *filter;
ssize_t avail;
int r;
for (;;) {
number_bidders = sizeof(a->bidders) / sizeof(a->bidders[0]);
best_bid = 0;
best_bidder = NU... | 187,470,736,725,719,080,000,000,000,000,000,000,000 | None | null | [
"CWE-399"
] | CVE-2016-7166 | libarchive before 3.2.0 does not limit the number of recursive decompressions, which allows remote attackers to cause a denial of service (memory consumption and application crash) via a crafted gzip file. | https://nvd.nist.gov/vuln/detail/CVE-2016-7166 |
1,745 | openjpeg | c16bc057ba3f125051c9966cf1f5b68a05681de4 | https://github.com/uclouvain/openjpeg | https://github.com/uclouvain/openjpeg/commit/c16bc057ba3f125051c9966cf1f5b68a05681de4 | Fix an integer overflow issue (#809)
Prevent an integer overflow issue in function opj_pi_create_decode of
pi.c. | 1 | opj_pi_iterator_t *opj_pi_create_decode(opj_image_t *p_image,
opj_cp_t *p_cp,
OPJ_UINT32 p_tile_no)
{
/* loop */
OPJ_UINT32 pino;
OPJ_UINT32 compno, resno;
/* to store w, h, dx and dy fro all components and resolutions */
OPJ_UINT32 * l_tmp_data;
OPJ_UINT32 ** l_tmp_ptr;
/* encoding pramete... | 331,884,484,169,803,600,000,000,000,000,000,000,000 | pi.c | 85,117,321,979,618,870,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-7163 | Integer overflow in the opj_pi_create_decode function in pi.c in OpenJPEG allows remote attackers to execute arbitrary code via a crafted JP2 file, which triggers an out-of-bounds read or write. | https://nvd.nist.gov/vuln/detail/CVE-2016-7163 |
1,746 | curl | curl-7_50_2~32 | https://github.com/curl/curl | https://github.com/curl/curl/commit/curl-7_50_2~32 | nss: refuse previously loaded certificate from file
... when we are not asked to use a certificate from file | 1 | static SECStatus SelectClientCert(void *arg, PRFileDesc *sock,
struct CERTDistNamesStr *caNames,
struct CERTCertificateStr **pRetCert,
struct SECKEYPrivateKeyStr **pRetKey)
{
struct ssl_connect_data *connssl = (stru... | 183,626,236,930,701,920,000,000,000,000,000,000,000 | nss.c | 12,471,031,817,769,896,000,000,000,000,000,000,000 | [
"CWE-287"
] | CVE-2016-7141 | curl and libcurl before 7.50.2, when built with NSS and the libnsspem.so library is available at runtime, allow remote attackers to hijack the authentication of a TLS connection by leveraging reuse of a previously loaded client certificate from file for a connection for which no certificate has been set, a different vu... | https://nvd.nist.gov/vuln/detail/CVE-2016-7141 |
1,750 | php-src | 698a691724c0a949295991e5df091ce16f899e02 | https://github.com/php/php-src | https://github.com/php/php-src/commit/698a691724c0a949295991e5df091ce16f899e02?w=1 | Fix bug #72750: wddx_deserialize null dereference | 1 | static void php_wddx_pop_element(void *user_data, const XML_Char *name)
{
st_entry *ent1, *ent2;
wddx_stack *stack = (wddx_stack *)user_data;
HashTable *target_hash;
zend_class_entry **pce;
zval *obj;
zval *tmp;
TSRMLS_FETCH();
/* OBJECTS_FIXME */
if (stack->top == 0) {
return;
}
if (!strc... | 289,440,307,254,825,080,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2016-7130 | The php_wddx_pop_element function in ext/wddx/wddx.c in PHP before 5.6.25 and 7.x before 7.0.10 allows remote attackers to cause a denial of service (NULL pointer dereference and application crash) or possibly have unspecified other impact via an invalid base64 binary value, as demonstrated by a wddx_deserialize call t... | https://nvd.nist.gov/vuln/detail/CVE-2016-7130 |
1,751 | php-src | 426aeb2808955ee3d3f52e0cfb102834cdb836a5 | https://github.com/php/php-src | https://github.com/php/php-src/commit/426aeb2808955ee3d3f52e0cfb102834cdb836a5?w=1 | Fix bug #72749: wddx_deserialize allows illegal memory access | 1 | static void php_wddx_process_data(void *user_data, const XML_Char *s, int len)
{
st_entry *ent;
wddx_stack *stack = (wddx_stack *)user_data;
TSRMLS_FETCH();
if (!wddx_stack_is_empty(stack) && !stack->done) {
wddx_stack_top(stack, (void**)&ent);
switch (ent->type) {
case ST_STRING:
if (Z_STRLEN_P(ent->da... | 189,109,834,750,109,700,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2016-7129 | The php_wddx_process_data function in ext/wddx/wddx.c in PHP before 5.6.25 and 7.x before 7.0.10 allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via an invalid ISO 8601 time value, as demonstrated by a wddx_deserialize call that mishandles a dateTime e... | https://nvd.nist.gov/vuln/detail/CVE-2016-7129 |
1,752 | php-src | 1bd103df00f49cf4d4ade2cfe3f456ac058a4eae | https://github.com/php/php-src | https://github.com/php/php-src/commit/1bd103df00f49cf4d4ade2cfe3f456ac058a4eae?w=1 | Fix bug #72730 - imagegammacorrect allows arbitrary write access | 1 | PHP_FUNCTION(imagegammacorrect)
{
zval *IM;
gdImagePtr im;
int i;
double input, output;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rdd", &IM, &input, &output) == FAILURE) {
return;
}
ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
if (gdImageTrueColor(im)) {
int x, y, c;
... | 139,742,999,262,680,890,000,000,000,000,000,000,000 | gd.c | 187,233,488,818,011,500,000,000,000,000,000,000,000 | [
"CWE-787"
] | CVE-2016-7127 | The imagegammacorrect function in ext/gd/gd.c in PHP before 5.6.25 and 7.x before 7.0.10 does not properly validate gamma values, which allows remote attackers to cause a denial of service (out-of-bounds write) or possibly have unspecified other impact by providing different signs for the second and third arguments. | https://nvd.nist.gov/vuln/detail/CVE-2016-7127 |
1,753 | php-src | b6f13a5ef9d6280cf984826a5de012a32c396cd4 | https://github.com/php/php-src | https://github.com/php/php-src/commit/b6f13a5ef9d6280cf984826a5de012a32c396cd4?w=1 | None | 1 | PHP_FUNCTION(imagetruecolortopalette)
{
zval *IM;
zend_bool dither;
long ncolors;
gdImagePtr im;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rbl", &IM, &dither, &ncolors) == FAILURE) {
return;
}
ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
if (ncolors <= 0) {
php_error_docr... | 181,878,688,249,174,300,000,000,000,000,000,000,000 | None | null | [
"CWE-787"
] | CVE-2016-7126 | The imagetruecolortopalette function in ext/gd/gd.c in PHP before 5.6.25 and 7.x before 7.0.10 does not properly validate the number of colors, which allows remote attackers to cause a denial of service (select_colors allocation error and out-of-bounds write) or possibly have unspecified other impact via a large value ... | https://nvd.nist.gov/vuln/detail/CVE-2016-7126 |
1,758 | linux | 34b88a68f26a75e4fded796f1a49c40f82234b7d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/34b88a68f26a75e4fded796f1a49c40f82234b7d | net: Fix use after free in the recvmmsg exit path
The syzkaller fuzzer hit the following use-after-free:
Call Trace:
[<ffffffff8175ea0e>] __asan_report_load8_noabort+0x3e/0x40 mm/kasan/report.c:295
[<ffffffff851cc31a>] __sys_recvmmsg+0x6fa/0x7f0 net/socket.c:2261
[< inline >] SYSC_recvmmsg net/sock... | 1 | int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
unsigned int flags, struct timespec *timeout)
{
int fput_needed, err, datagrams;
struct socket *sock;
struct mmsghdr __user *entry;
struct compat_mmsghdr __user *compat_entry;
struct msghdr msg_sys;
struct timespec end_time;
if (tim... | 32,465,179,856,289,110,000,000,000,000,000,000,000 | socket.c | 323,406,668,974,979,600,000,000,000,000,000,000,000 | [
"CWE-19"
] | CVE-2016-7117 | Use-after-free vulnerability in the __sys_recvmmsg function in net/socket.c in the Linux kernel before 4.5.2 allows remote attackers to execute arbitrary code via vectors involving a recvmmsg system call that is mishandled during error processing. | https://nvd.nist.gov/vuln/detail/CVE-2016-7117 |
1,759 | MAC-Telnet | b69d11727d4f0f8cf719c79e3fb700f55ca03e9a | https://github.com/haakonnessjoen/MAC-Telnet | https://github.com/haakonnessjoen/MAC-Telnet/commit/b69d11727d4f0f8cf719c79e3fb700f55ca03e9a | Merge pull request #20 from eyalitki/master
2nd round security fixes from eyalitki | 1 | static int handle_packet(unsigned char *data, int data_len) {
struct mt_mactelnet_hdr pkthdr;
/* Minimal size checks (pings are not supported here) */
if (data_len < MT_HEADER_LEN){
return -1;
}
parse_packet(data, &pkthdr);
/* We only care about packets with correct sessionkey */
if (pkthdr.seskey != session... | 321,429,272,328,439,870,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-7115 | Buffer overflow in the handle_packet function in mactelnet.c in the client in MAC-Telnet 0.4.3 and earlier allows remote TELNET servers to execute arbitrary code via a long string in an MT_CPTYPE_PASSSALT control packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-7115 |
1,790 | linux | 10eec60ce79187686e052092e5383c99b4420a20 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/10eec60ce79187686e052092e5383c99b4420a20 | vfs: ioctl: prevent double-fetch in dedupe ioctl
This prevents a double-fetch from user space that can lead to to an
undersized allocation and heap overflow.
Fixes: 54dbc1517237 ("vfs: hoist the btrfs deduplication ioctl to the vfs")
Signed-off-by: Scott Bauer <sbauer@plzdonthack.me>
Signed-off-by: Linus Torvalds <to... | 1 | static long ioctl_file_dedupe_range(struct file *file, void __user *arg)
{
struct file_dedupe_range __user *argp = arg;
struct file_dedupe_range *same = NULL;
int ret;
unsigned long size;
u16 count;
if (get_user(count, &argp->dest_count)) {
ret = -EFAULT;
goto out;
}
size = offsetof(struct file_dedupe_ran... | 177,427,685,205,348,800,000,000,000,000,000,000,000 | ioctl.c | 238,069,660,354,633,780,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-6516 | Race condition in the ioctl_file_dedupe_range function in fs/ioctl.c in the Linux kernel through 4.7 allows local users to cause a denial of service (heap-based buffer overflow) or possibly gain privileges by changing a certain count value, aka a "double fetch" vulnerability. | https://nvd.nist.gov/vuln/detail/CVE-2016-6516 |
1,791 | openssh-portable | fcd135c9df440bcd2d5870405ad3311743d78d97 | https://github.com/openssh/openssh-portable | https://github.com/openssh/openssh-portable/commit/fcd135c9df440bcd2d5870405ad3311743d78d97 | upstream commit
Skip passwords longer than 1k in length so clients can't
easily DoS sshd by sending very long passwords, causing it to spend CPU
hashing them. feedback djm@, ok markus@.
Brought to our attention by tomas.kuthan at oracle.com, shilei-c at
360.cn and coredump at autistici.org
Upstream-ID: d0af7d4a2190b... | 1 | auth_password(Authctxt *authctxt, const char *password)
{
struct passwd * pw = authctxt->pw;
int result, ok = authctxt->valid;
#if defined(USE_SHADOW) && defined(HAS_SHADOW_EXPIRE)
static int expire_checked = 0;
#endif
#ifndef HAVE_CYGWIN
if (pw->pw_uid == 0 && options.permit_root_login != PERMIT_YES)
ok =... | 319,587,561,961,095,600,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2016-6515 | The auth_password function in auth-passwd.c in sshd in OpenSSH before 7.3 does not limit password lengths for password authentication, which allows remote attackers to cause a denial of service (crypt CPU consumption) via a long string. | https://nvd.nist.gov/vuln/detail/CVE-2016-6515 |
1,792 | ImageMagick | dd84447b63a71fa8c3f47071b09454efc667767b | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/dd84447b63a71fa8c3f47071b09454efc667767b | Prevent buffer overflow (bug report from Ibrahim el-sayed) | 1 | static MagickBooleanType Get8BIMProperty(const Image *image,const char *key,
ExceptionInfo *exception)
{
char
*attribute,
format[MagickPathExtent],
name[MagickPathExtent],
*resource;
const StringInfo
*profile;
const unsigned char
*info;
long
start,
stop;
MagickBooleanType... | 80,477,753,582,958,770,000,000,000,000,000,000,000 | property.c | 46,131,985,438,510,870,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-6491 | Buffer overflow in the Get8BIMProperty function in MagickCore/property.c in ImageMagick before 6.9.5-4 and 7.x before 7.0.2-6 allows remote attackers to cause a denial of service (out-of-bounds read, memory leak, and crash) via a crafted image. | https://nvd.nist.gov/vuln/detail/CVE-2016-6491 |
1,795 | collectd | b589096f907052b3a4da2b9ccc9b0e2e888dfc18 | https://github.com/collectd/collectd | https://github.com/collectd/collectd/commit/b589096f907052b3a4da2b9ccc9b0e2e888dfc18 | network plugin: Fix heap overflow in parse_packet().
Emilien Gaspar has identified a heap overflow in parse_packet(), the
function used by the network plugin to parse incoming network packets.
This is a vulnerability in collectd, though the scope is not clear at
this point. At the very least specially crafted network... | 1 | static int parse_packet (sockent_t *se, /* {{{ */
void *buffer, size_t buffer_size, int flags,
const char *username)
{
int status;
value_list_t vl = VALUE_LIST_INIT;
notification_t n;
#if HAVE_LIBGCRYPT
int packet_was_signed = (flags & PP_SIGNED);
int packet_was_encrypted = (flags & PP_ENCRYPTED);
in... | 268,201,944,099,933,340,000,000,000,000,000,000,000 | network.c | 301,004,326,594,565,760,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-6254 | Heap-based buffer overflow in the parse_packet function in network.c in collectd before 5.4.3 and 5.x before 5.5.2 allows remote attackers to cause a denial of service (daemon crash) or possibly execute arbitrary code via a crafted network packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-6254 |
1,796 | libarchive | 3014e198 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/3014e198 | Issue 711: Be more careful about verifying filename lengths when writing ISO9660 archives
* Don't cast size_t to int, since this can lead to overflow
on machines where sizeof(int) < sizeof(size_t)
* Check a + b > limit by writing it as
a > limit || b > limit || a + b > limit
to avoid problems when a + b wraps... | 1 | isoent_gen_joliet_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
unsigned char *p;
size_t l;
int r;
int ffmax, parent_len;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node_joliet, isoent_cmp_key_joliet
};
... | 98,797,913,130,701,970,000,000,000,000,000,000,000 | archive_write_set_format_iso9660.c | 22,023,816,518,742,655,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-6250 | Integer overflow in the ISO9660 writer in libarchive before 3.2.1 allows remote attackers to cause a denial of service (application crash) or execute arbitrary code via vectors related to verifying filename lengths when writing an ISO9660 archive, which trigger a buffer overflow. | https://nvd.nist.gov/vuln/detail/CVE-2016-6250 |
1,804 | linux | 9409e22acdfc9153f88d9b1ed2bd2a5b34d2d3ca | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9409e22acdfc9153f88d9b1ed2bd2a5b34d2d3ca | vfs: rename: check backing inode being equal
If a file is renamed to a hardlink of itself POSIX specifies that rename(2)
should do nothing and return success.
This condition is checked in vfs_rename(). However it won't detect hard
links on overlayfs where these are given separate inodes on the overlayfs
layer.
Over... | 1 | int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry,
struct inode **delegated_inode, unsigned int flags)
{
int error;
bool is_dir = d_is_dir(old_dentry);
const unsigned char *old_name;
struct inode *source = old_dentry->d_inode;
struct i... | 125,343,890,223,537,840,000,000,000,000,000,000,000 | namei.c | 194,268,518,459,072,760,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-6198 | The filesystem layer in the Linux kernel before 4.5.5 proceeds with post-rename operations after an OverlayFS file is renamed to a self-hardlink, which allows local users to cause a denial of service (system crash) via a rename system call, related to fs/namei.c and fs/open.c. | https://nvd.nist.gov/vuln/detail/CVE-2016-6198 |
1,807 | linux | 30a46a4647fd1df9cf52e43bf467f0d9265096ca | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/30a46a4647fd1df9cf52e43bf467f0d9265096ca | apparmor: fix oops, validate buffer size in apparmor_setprocattr()
When proc_pid_attr_write() was changed to use memdup_user apparmor's
(interface violating) assumption that the setprocattr buffer was always
a single page was violated.
The size test is not strictly speaking needed as proc_pid_attr_write()
will reject... | 1 | static int apparmor_setprocattr(struct task_struct *task, char *name,
void *value, size_t size)
{
struct common_audit_data sa;
struct apparmor_audit_data aad = {0,};
char *command, *args = value;
size_t arg_size;
int error;
if (size == 0)
return -EINVAL;
/* args points to a PAGE_SIZE buffer, AppAr... | 94,069,181,006,806,240,000,000,000,000,000,000,000 | lsm.c | 292,105,851,096,993,260,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-6187 | The apparmor_setprocattr function in security/apparmor/lsm.c in the Linux kernel before 4.6.5 does not validate the buffer size, which allows local users to gain privileges by triggering an AppArmor setprocattr hook. | https://nvd.nist.gov/vuln/detail/CVE-2016-6187 |
1,808 | linux | 096cdc6f52225835ff503f987a0d68ef770bb78e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/096cdc6f52225835ff503f987a0d68ef770bb78e | platform/chrome: cros_ec_dev - double fetch bug in ioctl
We verify "u_cmd.outsize" and "u_cmd.insize" but we need to make sure
that those values have not changed between the two copy_from_user()
calls. Otherwise it could lead to a buffer overflow.
Additionally, cros_ec_cmd_xfer() can set s_cmd->insize to a lower val... | 1 | static long ec_device_ioctl_xcmd(struct cros_ec_dev *ec, void __user *arg)
{
long ret;
struct cros_ec_command u_cmd;
struct cros_ec_command *s_cmd;
if (copy_from_user(&u_cmd, arg, sizeof(u_cmd)))
return -EFAULT;
if ((u_cmd.outsize > EC_MAX_MSG_BYTES) ||
(u_cmd.insize > EC_MAX_MSG_BYTES))
return -EINVAL;... | 163,172,745,704,404,350,000,000,000,000,000,000,000 | cros_ec_dev.c | 103,010,045,391,424,050,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2016-6156 | Race condition in the ec_device_ioctl_xcmd function in drivers/platform/chrome/cros_ec_dev.c in the Linux kernel before 4.7 allows local users to cause a denial of service (out-of-bounds array access) by changing a certain size value, aka a "double fetch" vulnerability. | https://nvd.nist.gov/vuln/detail/CVE-2016-6156 |
1,810 | linux | 532c34b5fbf1687df63b3fcd5b2846312ac943c6 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/532c34b5fbf1687df63b3fcd5b2846312ac943c6 | s390/sclp_ctl: fix potential information leak with /dev/sclp
The sclp_ctl_ioctl_sccb function uses two copy_from_user calls to
retrieve the sclp request from user space. The first copy_from_user
fetches the length of the request which is stored in the first two
bytes of the request. The second copy_from_user gets the ... | 1 | static int sclp_ctl_ioctl_sccb(void __user *user_area)
{
struct sclp_ctl_sccb ctl_sccb;
struct sccb_header *sccb;
int rc;
if (copy_from_user(&ctl_sccb, user_area, sizeof(ctl_sccb)))
return -EFAULT;
if (!sclp_ctl_cmdw_supported(ctl_sccb.cmdw))
return -EOPNOTSUPP;
sccb = (void *) get_zeroed_page(GFP_KER... | 210,420,001,045,995,120,000,000,000,000,000,000,000 | sclp_ctl.c | 33,795,353,629,654,793,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2016-6130 | Race condition in the sclp_ctl_ioctl_sccb function in drivers/s390/char/sclp_ctl.c in the Linux kernel before 4.6 allows local users to obtain sensitive information from kernel memory by changing a certain length value, aka a "double fetch" vulnerability. | https://nvd.nist.gov/vuln/detail/CVE-2016-6130 |
1,811 | libarchive | 3ad08e01b4d253c66ae56414886089684155af22 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/3ad08e01b4d253c66ae56414886089684155af22 | Issue 717: Fix integer overflow when computing location of volume descriptor
The multiplication here defaulted to 'int' but calculations
of file positions should always use int64_t. A simple cast
suffices to fix this since the base location is always 32 bits
for ISO, so multiplying by the sector size will never over... | 1 | choose_volume(struct archive_read *a, struct iso9660 *iso9660)
{
struct file_info *file;
int64_t skipsize;
struct vd *vd;
const void *block;
char seenJoliet;
vd = &(iso9660->primary);
if (!iso9660->opt_support_joliet)
iso9660->seenJoliet = 0;
if (iso9660->seenJoliet &&
vd->location > iso9660->joliet.locati... | 79,794,590,550,957,910,000,000,000,000,000,000,000 | archive_read_support_format_iso9660.c | 161,757,426,250,598,000,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-5844 | Integer overflow in the ISO parser in libarchive before 3.2.1 allows remote attackers to cause a denial of service (application crash) via a crafted ISO file. | https://nvd.nist.gov/vuln/detail/CVE-2016-5844 |
1,812 | linux | 93a2001bdfd5376c3dc2158653034c20392d15c5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/93a2001bdfd5376c3dc2158653034c20392d15c5 | HID: hiddev: validate num_values for HIDIOCGUSAGES, HIDIOCSUSAGES commands
This patch validates the num_values parameter from userland during the
HIDIOCGUSAGES and HIDIOCSUSAGES commands. Previously, if the report id was set
to HID_REPORT_ID_UNKNOWN, we would fail to validate the num_values parameter
leading to a heap... | 1 | static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
{
struct hid_device *hid = hiddev->hid;
struct hiddev_report_info rinfo;
struct hiddev_usage_ref_multi *uref_multi = NULL;
struct hiddev_usage_ref *uref;
struct hid_report *report;
struct hid_field *field;
int ... | 48,668,317,957,594,940,000,000,000,000,000,000,000 | hiddev.c | 214,175,292,621,757,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-5829 | Multiple heap-based buffer overflows in the hiddev_ioctl_usage function in drivers/hid/usbhid/hiddev.c in the Linux kernel through 4.6.3 allow local users to cause a denial of service or possibly have unspecified other impact via a crafted (1) HIDIOCGUSAGES or (2) HIDIOCSUSAGES ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2016-5829 |
1,813 | php-src | a44c89e8af7c2410f4bfc5e097be2a5d0639a60c | https://github.com/php/php-src | http://github.com/php/php-src/commit/a44c89e8af7c2410f4bfc5e097be2a5d0639a60c?w=1 | Fix bug #72340: Double Free Courruption in wddx_deserialize | 1 | static void php_wddx_process_data(void *user_data, const XML_Char *s, int len)
{
st_entry *ent;
wddx_stack *stack = (wddx_stack *)user_data;
TSRMLS_FETCH();
if (!wddx_stack_is_empty(stack) && !stack->done) {
wddx_stack_top(stack, (void**)&ent);
switch (ent->type) {
case ST_STRING:
if (Z_STRLEN_P(ent->da... | 248,167,914,886,720,230,000,000,000,000,000,000,000 | None | null | [
"CWE-415"
] | CVE-2016-5772 | Double free vulnerability in the php_wddx_process_data function in wddx.c in the WDDX extension in PHP before 5.5.37, 5.6.x before 5.6.23, and 7.x before 7.0.8 allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted XML data that is mishandled in a wddx_de... | https://nvd.nist.gov/vuln/detail/CVE-2016-5772 |
1,814 | php-src | 3f627e580acfdaf0595ae3b115b8bec677f203ee | https://github.com/php/php-src | http://github.com/php/php-src/commit/3f627e580acfdaf0595ae3b115b8bec677f203ee?w=1 | Fixed ##72433: Use After Free Vulnerability in PHP's GC algorithm and unserialize | 1 | PHP_MINIT_FUNCTION(spl_array)
{
REGISTER_SPL_STD_CLASS_EX(ArrayObject, spl_array_object_new, spl_funcs_ArrayObject);
REGISTER_SPL_IMPLEMENTS(ArrayObject, Aggregate);
REGISTER_SPL_IMPLEMENTS(ArrayObject, ArrayAccess);
REGISTER_SPL_IMPLEMENTS(ArrayObject, Serializable);
REGISTER_SPL_IMPLEMENTS(ArrayObject, Countable... | 253,420,511,984,728,500,000,000,000,000,000,000,000 | spl_array.c | 252,840,016,822,366,870,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-5771 | spl_array.c in the SPL extension in PHP before 5.5.37 and 5.6.x before 5.6.23 improperly interacts with the unserialize implementation and garbage collection, which allows remote attackers to execute arbitrary code or cause a denial of service (use-after-free and application crash) via crafted serialized data. | https://nvd.nist.gov/vuln/detail/CVE-2016-5771 |
1,849 | php-src | 7245bff300d3fa8bacbef7897ff080a6f1c23eba | https://github.com/php/php-src | http://github.com/php/php-src/commit/7245bff300d3fa8bacbef7897ff080a6f1c23eba?w=1 | Fix bug #72262 - do not overflow int | 1 | SPL_METHOD(SplFileObject, fread)
{
spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
long length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &length) == FAILURE) {
return;
}
if (length <= 0) {
php_error_docref(NULL TSRMLS_CC, E_WARN... | 244,608,472,582,836,800,000,000,000,000,000,000,000 | spl_directory.c | 188,841,539,753,934,600,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-5770 | Integer overflow in the SplFileObject::fread function in spl_directory.c in the SPL extension in PHP before 5.5.37 and 5.6.x before 5.6.23 allows remote attackers to cause a denial of service or possibly have unspecified other impact via a large integer argument, a related issue to CVE-2016-5096. | https://nvd.nist.gov/vuln/detail/CVE-2016-5770 |
1,895 | php-src | 5b597a2e5b28e2d5a52fc1be13f425f08f47cb62 | https://github.com/php/php-src | http://github.com/php/php-src/commit/5b597a2e5b28e2d5a52fc1be13f425f08f47cb62?w=1 | Fix bug #72402: _php_mb_regex_ereg_replace_exec - double free | 1 | static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOptionType options, int is_callable)
{
zval **arg_pattern_zval;
char *arg_pattern;
int arg_pattern_len;
char *replace;
int replace_len;
zend_fcall_info arg_replace_fci;
zend_fcall_info_cache arg_replace_fci_cache;
char *string;
i... | 273,115,938,524,087,840,000,000,000,000,000,000,000 | php_mbregex.c | 70,273,313,402,533,685,000,000,000,000,000,000,000 | [
"CWE-415"
] | CVE-2016-5768 | Double free vulnerability in the _php_mb_regex_ereg_replace_exec function in php_mbregex.c in the mbstring extension in PHP before 5.5.37, 5.6.x before 5.6.23, and 7.x before 7.0.8 allows remote attackers to execute arbitrary code or cause a denial of service (application crash) by leveraging a callback exception. | https://nvd.nist.gov/vuln/detail/CVE-2016-5768 |
1,903 | php-src | c395c6e5d7e8df37a21265ff76e48fe75ceb5ae6 | https://github.com/php/php-src | http://github.com/php/php-src/commit/c395c6e5d7e8df37a21265ff76e48fe75ceb5ae6?w=1 | iFixed bug #72446 - Integer Overflow in gdImagePaletteToTrueColor() resulting in heap overflow | 1 | gdImagePtr gdImageCreate (int sx, int sy)
{
int i;
gdImagePtr im;
if (overflow2(sx, sy)) {
return NULL;
}
if (overflow2(sizeof(unsigned char *), sy)) {
return NULL;
}
im = (gdImage *) gdCalloc(1, sizeof(gdImage));
/* Row-major ever since gd 1.3 */
im->pixels = (unsigned char **) gdMalloc(sizeof(u... | 115,776,571,225,885,950,000,000,000,000,000,000,000 | gd.c | 46,573,213,927,881,730,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-5767 | Integer overflow in the gdImageCreate function in gd.c in the GD Graphics Library (aka libgd) before 2.0.34RC1, as used in PHP before 5.5.37, 5.6.x before 5.6.23, and 7.x before 7.0.8, allows remote attackers to cause a denial of service (heap-based buffer overflow and application crash) or possibly have unspecified ot... | https://nvd.nist.gov/vuln/detail/CVE-2016-5767 |
1,907 | php-src | 7722455726bec8c53458a32851d2a87982cf0eac | https://github.com/php/php-src | http://github.com/php/php-src/commit/7722455726bec8c53458a32851d2a87982cf0eac?w=1 | Fixed #72339 Integer Overflow in _gd2GetHeader() resulting in heap overflow | 1 | static int _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(php_gd_error("Reading gd2 header info"));
for (i = 0; i < 4; i++) {
ch = gdGetC(in);
if (ch == EO... | 108,321,245,757,292,700,000,000,000,000,000,000,000 | gd_gd2.c | 21,651,511,292,434,190,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-5766 | Integer overflow in the _gd2GetHeader function in gd_gd2.c in the GD Graphics Library (aka libgd) before 2.2.3, as used in PHP before 5.5.37, 5.6.x before 5.6.23, and 7.x before 7.0.8, allows remote attackers to cause a denial of service (heap-based buffer overflow and application crash) or possibly have unspecified ot... | https://nvd.nist.gov/vuln/detail/CVE-2016-5766 |
1,908 | linux | 9bf292bfca94694a721449e3fd752493856710f6 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9bf292bfca94694a721449e3fd752493856710f6 | misc: mic: Fix for double fetch security bug in VOP driver
The MIC VOP driver does two successive reads from user space to read a
variable length data structure. Kernel memory corruption can result if
the data structure changes between the two reads. This patch disallows
the chance of this happening.
Bugzilla: https:... | 1 | static long vop_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
struct vop_vdev *vdev = f->private_data;
struct vop_info *vi = vdev->vi;
void __user *argp = (void __user *)arg;
int ret;
switch (cmd) {
case MIC_VIRTIO_ADD_DEVICE:
{
struct mic_device_desc dd, *dd_config;
if (copy_from_user(&dd, ... | 42,020,854,998,596,270,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-5728 | Race condition in the vop_ioctl function in drivers/misc/mic/vop/vop_vringh.c in the MIC VOP driver in the Linux kernel before 4.6.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (memory corruption and system crash) by changing a certain header, aka a "double fetch" ... | https://nvd.nist.gov/vuln/detail/CVE-2016-5728 |
1,909 | linux | 75ff39ccc1bd5d3c455b6822ab09e533c551f758 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/75ff39ccc1bd5d3c455b6822ab09e533c551f758 | tcp: make challenge acks less predictable
Yue Cao claims that current host rate limiting of challenge ACKS
(RFC 5961) could leak enough information to allow a patient attacker
to hijack TCP sessions. He will soon provide details in an academic
paper.
This patch increases the default limit from 100 to 1000, and adds
s... | 1 | static void tcp_send_challenge_ack(struct sock *sk, const struct sk_buff *skb)
{
/* unprotected vars, we dont care of overwrites */
static u32 challenge_timestamp;
static unsigned int challenge_count;
struct tcp_sock *tp = tcp_sk(sk);
u32 now;
/* First check our per-socket dupack rate limit. */
if (tcp_oo... | 320,924,418,498,212,000,000,000,000,000,000,000,000 | tcp_input.c | 33,022,065,887,978,390,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-5696 | net/ipv4/tcp_input.c in the Linux kernel before 4.7 does not properly determine the rate of challenge ACK segments, which makes it easier for remote attackers to hijack TCP sessions via a blind in-window attack. | https://nvd.nist.gov/vuln/detail/CVE-2016-5696 |
1,910 | ImageMagick | 5511ef530576ed18fd636baa3bb4eda3d667665d | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/5511ef530576ed18fd636baa3bb4eda3d667665d | Add additional checks to DCM reader to prevent data-driven faults (bug report from Hanno Böck | 1 | static Image *ReadDCMImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
explicit_vr[MagickPathExtent],
implicit_vr[MagickPathExtent],
magick[MagickPathExtent],
photometric[MagickPathExtent];
DCMStreamInfo
*stream_info;
Image
*image;
int
*bluemap,
datum,
*gr... | 40,219,157,448,116,547,000,000,000,000,000,000,000 | dcm.c | 282,395,254,250,022,830,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-5689 | The DCM reader in ImageMagick before 6.9.4-5 and 7.x before 7.0.1-7 allows remote attackers to have unspecified impact by leveraging lack of NULL pointer checks. | https://nvd.nist.gov/vuln/detail/CVE-2016-5689 |
1,914 | linux | aa93d1fee85c890a34f2510a310e55ee76a27848 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/aa93d1fee85c890a34f2510a310e55ee76a27848 | media: fix airspy usb probe error path
Fix a memory leak on probe error of the airspy usb device driver.
The problem is triggered when more than 64 usb devices register with
v4l2 of type VFL_TYPE_SDR or VFL_TYPE_SUBDEV.
The memory leak is caused by the probe function of the airspy driver
mishandeling errors and not ... | 1 | static int airspy_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct airspy *s;
int ret;
u8 u8tmp, buf[BUF_SIZE];
s = kzalloc(sizeof(struct airspy), GFP_KERNEL);
if (s == NULL) {
dev_err(&intf->dev, "Could not allocate memory for state\n");
return -ENOMEM;
}
mutex_init(&s->v4l2_lo... | 201,482,838,855,407,340,000,000,000,000,000,000,000 | airspy.c | 271,094,106,681,489,230,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-5400 | Memory leak in the airspy_probe function in drivers/media/usb/airspy/airspy.c in the airspy USB driver in the Linux kernel before 4.7 allows local users to cause a denial of service (memory consumption) via a crafted USB device that emulates many VFL_TYPE_SDR or VFL_TYPE_SUBDEV devices and performs many connect and dis... | https://nvd.nist.gov/vuln/detail/CVE-2016-5400 |
1,919 | wireshark | 2c13e97d656c1c0ac4d76eb9d307664aae0e0cf7 | https://github.com/wireshark/wireshark | https://github.com/wireshark/wireshark/commit/2c13e97d656c1c0ac4d76eb9d307664aae0e0cf7 | The WTAP_ENCAP_ETHERNET dissector needs to be passed a struct eth_phdr.
We now require that. Make it so.
Bug: 12440
Change-Id: Iffee520976b013800699bde3c6092a3e86be0d76
Reviewed-on: https://code.wireshark.org/review/15424
Reviewed-by: Guy Harris <guy@alum.mit.edu> | 1 | dissect_pktap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *pktap_tree = NULL;
proto_item *ti = NULL;
tvbuff_t *next_tvb;
int offset = 0;
guint32 pkt_len, rectype, dlt;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PKTAP");
col_clear(pinfo->cinfo, COL_INFO);
pkt_len = tvb_get_letohl(tvb,... | 60,167,683,222,163,160,000,000,000,000,000,000,000 | packet-pktap.c | 74,355,000,406,750,550,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-5358 | epan/dissectors/packet-pktap.c in the Ethernet dissector in Wireshark 2.x before 2.0.4 mishandles the packet-header data type, which allows remote attackers to cause a denial of service (application crash) via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-5358 |
1,925 | wireshark | a66628e425db725df1ac52a3c573a03357060ddd | https://github.com/wireshark/wireshark | https://github.com/wireshark/wireshark/commit/a66628e425db725df1ac52a3c573a03357060ddd | Don't treat the packet length as unsigned.
The scanf family of functions are as annoyingly bad at handling unsigned
numbers as strtoul() is - both of them are perfectly willing to accept a
value beginning with a negative sign as an unsigned value. When using
strtoul(), you can compensate for this by explicitly checki... | 1 | parse_cosine_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
char *line, int *err, gchar **err_info)
{
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
int num_items_scanned;
int yy, mm, dd, hr, min, sec, csec;
guint pkt_len;
int pro, off, pri, rm, error;
guint code1, code2;
cha... | 775,128,632,240,788,800,000,000,000,000,000,000 | cosine.c | 260,698,406,841,229,670,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-5356 | wiretap/cosine.c in the CoSine file parser in Wireshark 1.12.x before 1.12.12 and 2.x before 2.0.4 mishandles sscanf unsigned-integer processing, which allows remote attackers to cause a denial of service (application crash) via a crafted file. | https://nvd.nist.gov/vuln/detail/CVE-2016-5356 |
1,926 | wireshark | 3270dfac43da861c714df76513456b46765ff47f | https://github.com/wireshark/wireshark | https://github.com/wireshark/wireshark/commit/3270dfac43da861c714df76513456b46765ff47f | Don't treat the packet length as unsigned.
The scanf family of functions are as annoyingly bad at handling unsigned
numbers as strtoul() is - both of them are perfectly willing to accept a
value beginning with a negative sign as an unsigned value. When using
strtoul(), you can compensate for this by explicitly checki... | 1 | parse_toshiba_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
char line[TOSHIBA_LINE_LENGTH];
int num_items_scanned;
guint pkt_len;
int pktnum, hr, min, sec, csec;
char channel[10], direction[10];
int ... | 46,587,021,802,752,220,000,000,000,000,000,000,000 | toshiba.c | 331,447,668,869,948,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-5355 | wiretap/toshiba.c in the Toshiba file parser in Wireshark 1.12.x before 1.12.12 and 2.x before 2.0.4 mishandles sscanf unsigned-integer processing, which allows remote attackers to cause a denial of service (application crash) via a crafted file. | https://nvd.nist.gov/vuln/detail/CVE-2016-5355 |
1,930 | wireshark | 7d7190695ce2ff269fdffb04e87139995cde21f4 | https://github.com/wireshark/wireshark | https://github.com/wireshark/wireshark/commit/7d7190695ce2ff269fdffb04e87139995cde21f4 | UMTS_FP: fix handling reserved C/T value
The spec puts the reserved value at 0xf but our internal table has 'unknown' at
0; since all the other values seem to be offset-by-one, just take the modulus
0xf to avoid running off the end of the table.
Bug: 12191
Change-Id: I83c8fb66797bbdee52a2246fb1eea6e37cbc7eb0
Reviewed... | 1 | fp_set_per_packet_inf_from_conv(umts_fp_conversation_info_t *p_conv_data,
tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree _U_)
{
fp_info *fpi;
guint8 tfi, c_t;
int offset = 0, i=0, j=0, num_tbs, chan, tb_size, tb_bit_off;
gboo... | 193,271,014,369,532,400,000,000,000,000,000,000,000 | packet-umts_fp.c | 301,117,539,260,110,400,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-5353 | epan/dissectors/packet-umts_fp.c in the UMTS FP dissector in Wireshark 1.12.x before 1.12.12 and 2.x before 2.0.4 mishandles the reserved C/T value, which allows remote attackers to cause a denial of service (application crash) via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-5353 |
1,931 | wireshark | b6d838eebf4456192360654092e5587c5207f185 | https://github.com/wireshark/wireshark | https://github.com/wireshark/wireshark/commit/b6d838eebf4456192360654092e5587c5207f185 | Sanity check eapol_len in AirPDcapDecryptWPABroadcastKey
Bug: 12175
Change-Id: Iaf977ba48f8668bf8095800a115ff9a3472dd893
Reviewed-on: https://code.wireshark.org/review/15326
Petri-Dish: Michael Mann <mmann78@netscape.net>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Alexis La Goutte <a... | 1 | AirPDcapDecryptWPABroadcastKey(const EAPOL_RSN_KEY *pEAPKey, guint8 *decryption_key, PAIRPDCAP_SEC_ASSOCIATION sa, guint eapol_len)
{
guint8 key_version;
guint8 *key_data;
guint8 *szEncryptedKey;
guint16 key_bytes_len = 0; /* Length of the total key data field */
guint16 key_len; /* Actua... | 249,501,140,671,775,100,000,000,000,000,000,000,000 | airpdcap.c | 135,102,669,786,164,510,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-5352 | epan/crypt/airpdcap.c in the IEEE 802.11 dissector in Wireshark 2.x before 2.0.4 mishandles certain length values, which allows remote attackers to cause a denial of service (application crash) via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-5352 |
1,932 | wireshark | 9b0b20b8d5f8c9f7839d58ff6c5900f7e19283b4 | https://github.com/wireshark/wireshark | https://github.com/wireshark/wireshark/commit/9b0b20b8d5f8c9f7839d58ff6c5900f7e19283b4 | Make sure EAPOL body is big enough for a EAPOL_RSN_KEY.
A pointer to a EAPOL_RSN_KEY is set on the packet presuming the
whole EAPOL_RSN_KEY is there. That's not always the case for
fuzzed/malicious captures.
Bug: 11585
Change-Id: Ib94b8aceef444c7820e43b969596efdb8dbecccd
Reviewed-on: https://code.wireshark.org/revie... | 1 | static INT AirPDcapScanForKeys(
PAIRPDCAP_CONTEXT ctx,
const guint8 *data,
const guint mac_header_len,
const guint tot_len,
AIRPDCAP_SEC_ASSOCIATION_ID id
)
{
const UCHAR *addr;
guint bodyLength;
PAIRPDCAP_SEC_ASSOCIATION sta_sa;
PAIRPDCAP_SEC_ASSOCIATION sa;
guint offset = 0;
... | 240,174,644,621,715,030,000,000,000,000,000,000,000 | airpdcap.c | 178,616,951,686,308,540,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-5351 | epan/crypt/airpdcap.c in the IEEE 802.11 dissector in Wireshark 1.12.x before 1.12.12 and 2.x before 2.0.4 mishandles the lack of an EAPOL_RSN_KEY, which allows remote attackers to cause a denial of service (application crash) via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2016-5351 |
1,935 | linux | 4116def2337991b39919f3b448326e21c40e0dbb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4116def2337991b39919f3b448326e21c40e0dbb | rds: fix an infoleak in rds_inc_info_copy
The last field "flags" of object "minfo" is not initialized.
Copying this object out may leak kernel stack data.
Assign 0 to it to avoid leak.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Acked-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>
Signed-off-by: David S. Miller... | 1 | void rds_inc_info_copy(struct rds_incoming *inc,
struct rds_info_iterator *iter,
__be32 saddr, __be32 daddr, int flip)
{
struct rds_info_message minfo;
minfo.seq = be64_to_cpu(inc->i_hdr.h_sequence);
minfo.len = be32_to_cpu(inc->i_hdr.h_len);
if (flip) {
minfo.laddr = daddr;
minfo.faddr = sa... | 333,555,213,106,388,200,000,000,000,000,000,000,000 | recv.c | 196,002,549,294,029,070,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-5244 | The rds_inc_info_copy function in net/rds/recv.c in the Linux kernel through 4.6.3 does not initialize a certain structure member, which allows remote attackers to obtain sensitive information from kernel stack memory by reading an RDS message. | https://nvd.nist.gov/vuln/detail/CVE-2016-5244 |
1,936 | linux | 5d2be1422e02ccd697ccfcd45c85b4a26e6178e2 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d2be1422e02ccd697ccfcd45c85b4a26e6178e2 | tipc: fix an infoleak in tipc_nl_compat_link_dump
link_info.str is a char array of size 60. Memory after the NULL
byte is not initialized. Sending the whole object out can cause
a leak.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | static int tipc_nl_compat_link_dump(struct tipc_nl_compat_msg *msg,
struct nlattr **attrs)
{
struct nlattr *link[TIPC_NLA_LINK_MAX + 1];
struct tipc_link_info link_info;
int err;
if (!attrs[TIPC_NLA_LINK])
return -EINVAL;
err = nla_parse_nested(link, TIPC_NLA_LINK_MAX, attrs[TIPC_NLA_LINK],
N... | 22,483,029,912,805,243,000,000,000,000,000,000,000 | netlink_compat.c | 119,355,885,410,724,360,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-5243 | The tipc_nl_compat_link_dump function in net/tipc/netlink_compat.c in the Linux kernel through 4.6.3 does not properly copy a certain string, which allows local users to obtain sensitive information from kernel stack memory by reading a Netlink message. | https://nvd.nist.gov/vuln/detail/CVE-2016-5243 |
1,940 | libimobiledevice | df1f5c4d70d0c19ad40072f5246ca457e7f9849e | https://github.com/libimobiledevice/libimobiledevice | https://github.com/libimobiledevice/libimobiledevice/commit/df1f5c4d70d0c19ad40072f5246ca457e7f9849e | common: [security fix] Make sure sockets only listen locally | 1 | int socket_create(uint16_t port)
{
int sfd = -1;
int yes = 1;
#ifdef WIN32
WSADATA wsa_data;
if (!wsa_init) {
if (WSAStartup(MAKEWORD(2,2), &wsa_data) != ERROR_SUCCESS) {
fprintf(stderr, "WSAStartup failed!\n");
ExitProcess(-1);
}
wsa_init = 1;
}
#endif
struct sockaddr_in saddr;
if (0 > (sfd = socke... | 174,992,331,678,357,600,000,000,000,000,000,000,000 | socket.c | 5,143,455,029,250,239,000,000,000,000,000,000,000 | [
"CWE-284"
] | CVE-2016-5104 | The socket_create function in common/socket.c in libimobiledevice and libusbmuxd allows remote attackers to bypass intended access restrictions and communicate with services on iOS devices by connecting to an IPv4 TCP socket. | https://nvd.nist.gov/vuln/detail/CVE-2016-5104 |
1,941 | php-src | abd159cce48f3e34f08e4751c568e09677d5ec9c | https://github.com/php/php-src | https://github.com/php/php-src/commit/abd159cce48f3e34f08e4751c568e09677d5ec9c?w=1 | Fix bug #72114 - int/size_t confusion in fread | 1 | PHPAPI PHP_FUNCTION(fread)
{
zval *arg1;
long len;
php_stream *stream;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &arg1, &len) == FAILURE) {
RETURN_FALSE;
}
PHP_STREAM_TO_ZVAL(stream, &arg1);
if (len <= 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length parameter must be greater than... | 267,862,534,182,931,460,000,000,000,000,000,000,000 | file.c | 61,201,000,865,043,630,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-5096 | Integer overflow in the fread function in ext/standard/file.c in PHP before 5.5.36 and 5.6.x before 5.6.22 allows remote attackers to cause a denial of service or possibly have unspecified other impact via a large integer in the second argument. | https://nvd.nist.gov/vuln/detail/CVE-2016-5096 |
1,949 | php-src | 0da8b8b801f9276359262f1ef8274c7812d3dfda | https://github.com/php/php-src | https://github.com/php/php-src/commit/0da8b8b801f9276359262f1ef8274c7812d3dfda?w=1 | Fix bug #72135 - don't create strings with lengths outside int range | 1 | static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all)
{
char *str, *hint_charset = NULL;
int str_len, hint_charset_len = 0;
size_t new_len;
long flags = ENT_COMPAT;
char *replaced;
zend_bool double_encode = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls!b", &str, &str_len, &flags, ... | 304,507,025,606,054,900,000,000,000,000,000,000,000 | html.c | 185,037,864,091,738,220,000,000,000,000,000,000,000 | [
"CWE-190"
] | CVE-2016-5094 | Integer overflow in the php_html_entities function in ext/standard/html.c in PHP before 5.5.36 and 5.6.x before 5.6.22 allows remote attackers to cause a denial of service or possibly have unspecified other impact by triggering a large output string from the htmlspecialchars function. | https://nvd.nist.gov/vuln/detail/CVE-2016-5094 |
1,964 | php-src | 97eff7eb57fc2320c267a949cffd622c38712484 | https://github.com/php/php-src | https://github.com/php/php-src/commit/97eff7eb57fc2320c267a949cffd622c38712484?w=1 | Fix bug #72241: get_icu_value_internal out-of-bounds read | 1 | PHP_FUNCTION(locale_accept_from_http)
{
UEnumeration *available;
char *http_accept = NULL;
int http_accept_len;
UErrorCode status = 0;
int len;
char resultLocale[INTL_MAX_LOCALE_LEN+1];
UAcceptResult outResult;
if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s", &http_accept, &http_accept_len) == FAILURE... | 229,704,843,578,137,100,000,000,000,000,000,000,000 | locale_methods.c | 304,415,109,677,498,050,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-5093 | The get_icu_value_internal function in ext/intl/locale/locale_methods.c in PHP before 5.5.36, 5.6.x before 5.6.22, and 7.x before 7.0.7 does not ensure the presence of a '\0' character, which allows remote attackers to cause a denial of service (out-of-bounds read) or possibly have unspecified other impact via a crafte... | https://nvd.nist.gov/vuln/detail/CVE-2016-5093 |
1,973 | php-src | 97eff7eb57fc2320c267a949cffd622c38712484 | https://github.com/php/php-src | https://github.com/php/php-src/commit/97eff7eb57fc2320c267a949cffd622c38712484?w=1 | Fix bug #72241: get_icu_value_internal out-of-bounds read | 1 | static char* get_icu_value_internal( const char* loc_name , char* tag_name, int* result , int fromParseLocale)
{
char* tag_value = NULL;
int32_t tag_value_len = 512;
int singletonPos = 0;
char* mod_loc_name = NULL;
int grOffset = 0;
int32_t buflen = 512;
UErrorCode status ... | 258,636,481,049,794,200,000,000,000,000,000,000,000 | locale_methods.c | 118,305,450,747,253,400,000,000,000,000,000,000,000 | [
"CWE-125"
] | CVE-2016-5093 | The get_icu_value_internal function in ext/intl/locale/locale_methods.c in PHP before 5.5.36, 5.6.x before 5.6.22, and 7.x before 7.0.7 does not ensure the presence of a '\0' character, which allows remote attackers to cause a denial of service (out-of-bounds read) or possibly have unspecified other impact via a crafte... | https://nvd.nist.gov/vuln/detail/CVE-2016-5093 |
1,991 | linux | 45e093ae2830cd1264677d47ff9a95a71f5d9f9c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/45e093ae2830cd1264677d47ff9a95a71f5d9f9c | tipc: check nl sock before parsing nested attributes
Make sure the socket for which the user is listing publication exists
before parsing the socket netlink attributes.
Prior to this patch a call without any socket caused a NULL pointer
dereference in tipc_nl_publ_dump().
Tested-and-reported-by: Baozeng Ding <splovi... | 1 | int tipc_nl_publ_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
int err;
u32 tsk_portid = cb->args[0];
u32 last_publ = cb->args[1];
u32 done = cb->args[2];
struct net *net = sock_net(skb->sk);
struct tipc_sock *tsk;
if (!tsk_portid) {
struct nlattr **attrs;
struct nlattr *sock[TIPC_NLA_SOCK_MAX + ... | 109,108,179,952,697,830,000,000,000,000,000,000,000 | socket.c | 147,330,032,818,011,570,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-4951 | The tipc_nl_publ_dump function in net/tipc/socket.c in the Linux kernel through 4.6 does not verify socket existence, which allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via a dumpit operation. | https://nvd.nist.gov/vuln/detail/CVE-2016-4951 |
1,992 | linux | 99d825822eade8d827a1817357cbf3f889a552d6 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/99d825822eade8d827a1817357cbf3f889a552d6 | get_rock_ridge_filename(): handle malformed NM entries
Payloads of NM entries are not supposed to contain NUL. When we run
into such, only the part prior to the first NUL goes into the
concatenation (i.e. the directory entry name being encoded by a bunch
of NM entries). We do stop when the amount collected so far + ... | 1 | int get_rock_ridge_filename(struct iso_directory_record *de,
char *retname, struct inode *inode)
{
struct rock_state rs;
struct rock_ridge *rr;
int sig;
int retnamlen = 0;
int truncate = 0;
int ret = 0;
if (!ISOFS_SB(inode->i_sb)->s_rock)
return 0;
*retname = 0;
init_rock_state(&rs, inode);
s... | 93,758,422,006,208,340,000,000,000,000,000,000,000 | rock.c | 282,024,907,067,004,600,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-4913 | The get_rock_ridge_filename function in fs/isofs/rock.c in the Linux kernel before 4.5.5 mishandles NM (aka alternate name) entries containing \0 characters, which allows local users to obtain sensitive information from kernel memory or possibly have unspecified other impact via a crafted isofs filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2016-4913 |
1,995 | libarchive | fd7e0c02 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/fd7e0c02 | Reject cpio symlinks that exceed 1MB | 1 | archive_read_format_cpio_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct cpio *cpio;
const void *h;
struct archive_string_conv *sconv;
size_t namelength;
size_t name_pad;
int r;
cpio = (struct cpio *)(a->format->data);
sconv = cpio->opt_sconv;
if (sconv == NULL) {
if (!cpio->in... | 116,133,945,221,878,200,000,000,000,000,000,000,000 | archive_read_support_format_cpio.c | 177,814,792,440,499,570,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2016-4809 | The archive_read_format_cpio_read_header function in archive_read_support_format_cpio.c in libarchive before 3.2.1 allows remote attackers to cause a denial of service (application crash) via a CPIO archive with a large symlink. | https://nvd.nist.gov/vuln/detail/CVE-2016-4809 |
1,996 | linux | 1f461dcdd296eecedaffffc6bae2bfa90bd7eb89 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1f461dcdd296eecedaffffc6bae2bfa90bd7eb89 | ppp: take reference on channels netns
Let channels hold a reference on their network namespace.
Some channel types, like ppp_async and ppp_synctty, can have their
userspace controller running in a different namespace. Therefore they
can't rely on them to preclude their netns from being removed from
under them.
======... | 1 | int ppp_register_net_channel(struct net *net, struct ppp_channel *chan)
{
struct channel *pch;
struct ppp_net *pn;
pch = kzalloc(sizeof(struct channel), GFP_KERNEL);
if (!pch)
return -ENOMEM;
pn = ppp_pernet(net);
pch->ppp = NULL;
pch->chan = chan;
pch->chan_net = net;
chan->ppp = pch;
init_ppp_file... | 200,851,677,246,187,520,000,000,000,000,000,000,000 | ppp_generic.c | 33,074,513,998,217,310,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2016-4805 | Use-after-free vulnerability in drivers/net/ppp/ppp_generic.c in the Linux kernel before 4.5.2 allows local users to cause a denial of service (memory corruption and system crash, or spinlock) or possibly have unspecified other impact by removing a network namespace, related to the ppp_register_net_channel and ppp_unre... | https://nvd.nist.gov/vuln/detail/CVE-2016-4805 |
1,998 | dosfstools | e8eff147e9da1185f9afd5b25948153a3b97cf52 | https://github.com/dosfstools/dosfstools | https://github.com/dosfstools/dosfstools/commit/e8eff147e9da1185f9afd5b25948153a3b97cf52 | read_boot(): Handle excessive FAT size specifications
The variable used for storing the FAT size (in bytes) was an unsigned
int. Since the size in sectors read from the BPB was not sufficiently
checked, this could end up being zero after multiplying it with the
sector size while some offsets still stayed excessive. Ul... | 1 | void read_boot(DOS_FS * fs)
{
struct boot_sector b;
unsigned total_sectors;
unsigned short logical_sector_size, sectors;
unsigned fat_length;
unsigned total_fat_entries;
off_t data_size;
fs_read(0, sizeof(b), &b);
logical_sector_size = GET_UNALIGNED_W(b.sector_size);
if (!logi... | 186,977,352,067,923,180,000,000,000,000,000,000,000 | boot.c | 197,145,767,489,226,020,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-4804 | The read_boot function in boot.c in dosfstools before 4.0 allows attackers to cause a denial of service (crash) via a crafted filesystem, which triggers a heap-based buffer overflow in the (1) read_fat function or an out-of-bounds heap read in (2) get_fat function. | https://nvd.nist.gov/vuln/detail/CVE-2016-4804 |
2,001 | linux | 79e48650320e6fba48369fccf13fd045315b19b8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/79e48650320e6fba48369fccf13fd045315b19b8 | net: fix a kernel infoleak in x25 module
Stack object "dte_facilities" is allocated in x25_rx_call_request(),
which is supposed to be initialized in x25_negotiate_facilities.
However, 5 fields (8 bytes in total) are not initialized. This
object is then copied to userland via copy_to_user, thus infoleak
occurs.
Signed... | 1 | int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk,
struct x25_facilities *new, struct x25_dte_facilities *dte)
{
struct x25_sock *x25 = x25_sk(sk);
struct x25_facilities *ours = &x25->facilities;
struct x25_facilities theirs;
int len;
memset(&theirs, 0, sizeof(theirs));
memcpy(new, ours, siz... | 288,890,073,918,554,100,000,000,000,000,000,000,000 | x25_facilities.c | 175,536,494,937,069,540,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-4580 | The x25_negotiate_facilities function in net/x25/x25_facilities.c in the Linux kernel before 4.5.5 does not properly initialize a certain data structure, which allows attackers to obtain sensitive information from kernel stack memory via an X.25 Call Request. | https://nvd.nist.gov/vuln/detail/CVE-2016-4580 |
2,002 | linux | e4ec8cc8039a7063e24204299b462bd1383184a5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e4ec8cc8039a7063e24204299b462bd1383184a5 | ALSA: timer: Fix leak in events via snd_timer_user_tinterrupt
The stack object “r1” has a total size of 32 bytes. Its field
“event” and “val” both contain 4 bytes padding. These 8 bytes
padding bytes are sent to user without being initialized.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Signed-off-by: Takashi Iwai <t... | 1 | static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
unsigned long resolution,
unsigned long ticks)
{
struct snd_timer_user *tu = timeri->callback_data;
struct snd_timer_tread *r, r1;
struct timespec tstamp;
int prev, append = 0;
memset(&tstamp, 0, sizeof(tstamp));
spin_lo... | 124,304,214,797,495,180,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-2016-4578 | sound/core/timer.c in the Linux kernel through 4.6 does not initialize certain r1 data structures, which allows local users to obtain sensitive information from kernel stack memory via crafted use of the ALSA timer interface, related to the (1) snd_timer_user_ccallback and (2) snd_timer_user_tinterrupt functions. | https://nvd.nist.gov/vuln/detail/CVE-2016-4578 |
2,003 | linux | cec8f96e49d9be372fdb0c3836dcf31ec71e457e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cec8f96e49d9be372fdb0c3836dcf31ec71e457e | ALSA: timer: Fix leak in SNDRV_TIMER_IOCTL_PARAMS
The stack object “tread” has a total size of 32 bytes. Its field
“event” and “val” both contain 4 bytes padding. These 8 bytes
padding bytes are sent to user without being initialized.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Signed-off-by: Takashi Iwai <tiwai@suse... | 1 | static int snd_timer_user_params(struct file *file,
struct snd_timer_params __user *_params)
{
struct snd_timer_user *tu;
struct snd_timer_params params;
struct snd_timer *t;
struct snd_timer_read *tr;
struct snd_timer_tread *ttr;
int err;
tu = file->private_data;
if (!tu->timeri)
return -EBADFD;
t = t... | 239,787,913,206,909,500,000,000,000,000,000,000,000 | timer.c | 67,637,640,137,585,530,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-4569 | The snd_timer_user_params function in sound/core/timer.c in the Linux kernel through 4.6 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via crafted use of the ALSA timer interface. | https://nvd.nist.gov/vuln/detail/CVE-2016-4569 |
2,010 | ImageMagick | 726812fa2fa7ce16bcf58f6e115f65427a1c0950 | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/726812fa2fa7ce16bcf58f6e115f65427a1c0950 | Prevent buffer overflow in magick/draw.c | 1 | static MagickBooleanType DrawDashPolygon(const DrawInfo *draw_info,
const PrimitiveInfo *primitive_info,Image *image,ExceptionInfo *exception)
{
DrawInfo
*clone_info;
double
length,
maximum_length,
offset,
scale,
total_length;
MagickStatusType
status;
PrimitiveInfo
*dash_pol... | 278,418,562,021,844,360,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-4564 | The DrawImage function in MagickCore/draw.c in ImageMagick before 6.9.4-0 and 7.x before 7.0.1-2 makes an incorrect function call in attempting to locate the next token, which allows remote attackers to cause a denial of service (buffer overflow and application crash) or possibly have unspecified other impact via a cra... | https://nvd.nist.gov/vuln/detail/CVE-2016-4564 |
2,011 | ImageMagick | 726812fa2fa7ce16bcf58f6e115f65427a1c0950 | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/726812fa2fa7ce16bcf58f6e115f65427a1c0950 | Prevent buffer overflow in magick/draw.c | 1 | MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info,
ExceptionInfo *exception)
{
#define RenderImageTag "Render/Image"
AffineMatrix
affine,
current;
char
keyword[MagickPathExtent],
geometry[MagickPathExtent],
pattern[MagickPathExtent],
*primitive,
*token;... | 214,572,375,985,539,270,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-4564 | The DrawImage function in MagickCore/draw.c in ImageMagick before 6.9.4-0 and 7.x before 7.0.1-2 makes an incorrect function call in attempting to locate the next token, which allows remote attackers to cause a denial of service (buffer overflow and application crash) or possibly have unspecified other impact via a cra... | https://nvd.nist.gov/vuln/detail/CVE-2016-4564 |
2,014 | ImageMagick | 726812fa2fa7ce16bcf58f6e115f65427a1c0950 | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/726812fa2fa7ce16bcf58f6e115f65427a1c0950 | Prevent buffer overflow in magick/draw.c | 1 | static PrimitiveInfo *TraceStrokePolygon(const DrawInfo *draw_info,
const PrimitiveInfo *primitive_info)
{
typedef struct _LineSegment
{
double
p,
q;
} LineSegment;
LineSegment
dx,
dy,
inverse_slope,
slope,
theta;
MagickBooleanType
closed_path;
double
delta_t... | 315,690,379,769,147,360,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2016-4564 | The DrawImage function in MagickCore/draw.c in ImageMagick before 6.9.4-0 and 7.x before 7.0.1-2 makes an incorrect function call in attempting to locate the next token, which allows remote attackers to cause a denial of service (buffer overflow and application crash) or possibly have unspecified other impact via a cra... | https://nvd.nist.gov/vuln/detail/CVE-2016-4564 |
2,020 | linux | 8358b02bf67d3a5d8a825070e1aa73f25fb2e4c7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8358b02bf67d3a5d8a825070e1aa73f25fb2e4c7 | bpf: fix double-fdput in replace_map_fd_with_map_ptr()
When bpf(BPF_PROG_LOAD, ...) was invoked with a BPF program whose bytecode
references a non-map file descriptor as a map file descriptor, the error
handling code called fdput() twice instead of once (in __bpf_map_get() and
in replace_map_fd_with_map_ptr()). If the... | 1 | static int replace_map_fd_with_map_ptr(struct verifier_env *env)
{
struct bpf_insn *insn = env->prog->insnsi;
int insn_cnt = env->prog->len;
int i, j;
for (i = 0; i < insn_cnt; i++, insn++) {
if (BPF_CLASS(insn->code) == BPF_LDX &&
(BPF_MODE(insn->code) != BPF_MEM || insn->imm != 0)) {
verbose("BPF_LDX ... | 273,118,594,432,448,770,000,000,000,000,000,000,000 | verifier.c | 191,264,986,849,802,150,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-4557 | The replace_map_fd_with_map_ptr function in kernel/bpf/verifier.c in the Linux kernel before 4.5.5 does not properly maintain an fd data structure, which allows local users to gain privileges or cause a denial of service (use-after-free) via crafted BPF instructions that reference an incorrect file descriptor. | https://nvd.nist.gov/vuln/detail/CVE-2016-4557 |
2,021 | linux | 5f8e44741f9f216e33736ea4ec65ca9ac03036e6 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5f8e44741f9f216e33736ea4ec65ca9ac03036e6 | net: fix infoleak in rtnetlink
The stack object “map” has a total size of 32 bytes. Its last 4
bytes are padding generated by compiler. These padding bytes are
not initialized and sent out via “nla_put”.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
{
struct rtnl_link_ifmap map = {
.mem_start = dev->mem_start,
.mem_end = dev->mem_end,
.base_addr = dev->base_addr,
.irq = dev->irq,
.dma = dev->dma,
.port = dev->if_port,
};
if (nla_put(skb, IF... | 88,210,912,937,139,420,000,000,000,000,000,000,000 | rtnetlink.c | 304,302,998,298,579,250,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-4486 | The rtnl_fill_link_ifmap function in net/core/rtnetlink.c in the Linux kernel before 4.5.5 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory by reading a Netlink message. | https://nvd.nist.gov/vuln/detail/CVE-2016-4486 |
2,022 | linux | b8670c09f37bdf2847cc44f36511a53afc6161fd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b8670c09f37bdf2847cc44f36511a53afc6161fd | net: fix infoleak in llc
The stack object “info” has a total size of 12 bytes. Its last byte
is padding which is not initialized and leaked via “put_cmsg”.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | static void llc_cmsg_rcv(struct msghdr *msg, struct sk_buff *skb)
{
struct llc_sock *llc = llc_sk(skb->sk);
if (llc->cmsg_flags & LLC_CMSG_PKTINFO) {
struct llc_pktinfo info;
info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex;
llc_pdu_decode_dsap(skb, &info.lpi_sap);
llc_pdu_decode_da(skb, info.lpi_mac)... | 265,988,475,058,809,480,000,000,000,000,000,000,000 | af_llc.c | 114,091,511,487,822,400,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-4485 | The llc_cmsg_rcv function in net/llc/af_llc.c in the Linux kernel before 4.5.5 does not initialize a certain data structure, which allows attackers to obtain sensitive information from kernel stack memory by reading a message. | https://nvd.nist.gov/vuln/detail/CVE-2016-4485 |
2,023 | linux | 681fef8380eb818c0b845fca5d2ab1dcbab114ee | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/681fef8380eb818c0b845fca5d2ab1dcbab114ee | USB: usbfs: fix potential infoleak in devio
The stack object “ci” has a total size of 8 bytes. Its last 3 bytes
are padding bytes which are not initialized and leaked to userland
via “copy_to_user”.
Signed-off-by: Kangjie Lu <kjlu@gatech.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 1 | static int proc_connectinfo(struct usb_dev_state *ps, void __user *arg)
{
struct usbdevfs_connectinfo ci = {
.devnum = ps->dev->devnum,
.slow = ps->dev->speed == USB_SPEED_LOW
};
if (copy_to_user(arg, &ci, sizeof(ci)))
return -EFAULT;
return 0;
}
| 94,713,218,675,784,140,000,000,000,000,000,000,000 | devio.c | 150,665,955,136,899,330,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2016-4482 | The proc_connectinfo function in drivers/usb/core/devio.c in the Linux kernel through 4.6 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted USBDEVFS_CONNECTINFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2016-4482 |
2,024 | atheme | 87580d767868360d2fed503980129504da84b63e | https://github.com/atheme/atheme | https://github.com/atheme/atheme/commit/87580d767868360d2fed503980129504da84b63e | Do not copy more bytes than were allocated | 1 | void xmlrpc_char_encode(char *outbuffer, const char *s1)
{
long unsigned int i;
unsigned char c;
char buf2[15];
mowgli_string_t *s = mowgli_string_create();
*buf2 = '\0';
*outbuffer = '\0';
if ((!(s1) || (*(s1) == '\0')))
{
return;
}
for (i = 0; s1[i] != '\0'; i++)
{
c = s1[i];
if (c > 127)
{
sn... | 43,536,472,075,997,620,000,000,000,000,000,000,000 | xmlrpclib.c | 209,647,623,324,171,000,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-4478 | Buffer overflow in the xmlrpc_char_encode function in modules/transport/xmlrpc/xmlrpclib.c in Atheme before 7.2.7 allows remote attackers to cause a denial of service via vectors related to XMLRPC response encoding. | https://nvd.nist.gov/vuln/detail/CVE-2016-4478 |
2,025 | linux | 38327424b40bcebe2de92d07312c89360ac9229a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/38327424b40bcebe2de92d07312c89360ac9229a | KEYS: potential uninitialized variable
If __key_link_begin() failed then "edit" would be uninitialized. I've
added a check to fix that.
This allows a random user to crash the kernel, though it's quite
difficult to achieve. There are three ways it can be done as the user
would have to cause an error to occur in __ke... | 1 | int key_reject_and_link(struct key *key,
unsigned timeout,
unsigned error,
struct key *keyring,
struct key *authkey)
{
struct assoc_array_edit *edit;
struct timespec now;
int ret, awaken, link_ret = 0;
key_check(key);
key_check(keyring);
awaken = 0;
ret = -EBUSY;
if (keyring) {
if (keyring->res... | 256,806,618,522,082,730,000,000,000,000,000,000,000 | key.c | 16,508,077,423,529,737,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2016-4470 | The key_reject_and_link function in security/keys/key.c in the Linux kernel through 4.6.3 does not ensure that a certain data structure is initialized, which allows local users to cause a denial of service (system crash) via vectors involving a crafted keyctl request2 command. | https://nvd.nist.gov/vuln/detail/CVE-2016-4470 |
2,066 | iperf | 91f2fa59e8ed80dfbf400add0164ee0e508e412a | https://github.com/esnet/iperf | https://github.com/esnet/iperf/commit/91f2fa59e8ed80dfbf400add0164ee0e508e412a | Fix a buffer overflow / heap corruption issue that could occur if a
malformed JSON string was passed on the control channel. This issue,
present in the cJSON library, was already fixed upstream, so was
addressed here in iperf3 by importing a newer version of cJSON (plus
local ESnet modifications).
Discovered and repo... | 1 | static const char *parse_string( cJSON *item, const char *str )
{
const char *ptr = str + 1;
char *ptr2;
char *out;
int len = 0;
unsigned uc, uc2;
if ( *str != '\"' ) {
/* Not a string! */
ep = str;
return 0;
}
/* Skip escaped quotes. */
while ( *ptr != '\"' && *ptr && ++len )
if ( *ptr++ == '\\' )... | 202,681,723,794,535,540,000,000,000,000,000,000,000 | cjson.c | 211,459,362,401,629,130,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-4303 | The parse_string function in cjson.c in the cJSON library mishandles UTF8/16 strings, which allows remote attackers to cause a denial of service (crash) or execute arbitrary code via a non-hex character in a JSON string, which triggers a heap-based buffer overflow. | https://nvd.nist.gov/vuln/detail/CVE-2016-4303 |
2,077 | libarchive | 05caadc7eedbef471ac9610809ba683f0c698700 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/05caadc7eedbef471ac9610809ba683f0c698700 | Issue 719: Fix for TALOS-CAN-154
A RAR file with an invalid zero dictionary size was not being
rejected, leading to a zero-sized allocation for the dictionary
storage which was then overwritten during the dictionary initialization.
Thanks to the Open Source and Threat Intelligence project at Cisco for
reporting this... | 1 | parse_codes(struct archive_read *a)
{
int i, j, val, n, r;
unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags;
unsigned int maxorder;
struct huffman_code precode;
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
free_codes(a);
/* Skip to the next byte */
r... | 325,675,593,910,182,270,000,000,000,000,000,000,000 | archive_read_support_format_rar.c | 97,898,541,607,838,170,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-4302 | Heap-based buffer overflow in the parse_codes function in archive_read_support_format_rar.c in libarchive before 3.2.1 allows remote attackers to execute arbitrary code via a RAR file with a zero-sized dictionary. | https://nvd.nist.gov/vuln/detail/CVE-2016-4302 |
2,078 | libarchive | a550daeecf6bc689ade371349892ea17b5b97c77 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/a550daeecf6bc689ade371349892ea17b5b97c77 | Fix libarchive/archive_read_support_format_mtree.c:1388:11: error: array subscript is above array bounds | 1 | parse_device(dev_t *pdev, struct archive *a, char *val)
{
#define MAX_PACK_ARGS 3
unsigned long numbers[MAX_PACK_ARGS];
char *p, *dev;
int argc;
pack_t *pack;
dev_t result;
const char *error = NULL;
memset(pdev, 0, sizeof(*pdev));
if ((dev = strchr(val, ',')) != NULL) {
/*
* Device's major/minor are given... | 140,177,069,250,601,300,000,000,000,000,000,000,000 | archive_read_support_format_mtree.c | 289,329,355,082,132,950,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2016-4301 | Stack-based buffer overflow in the parse_device function in archive_read_support_format_mtree.c in libarchive before 3.2.1 allows remote attackers to execute arbitrary code via a crafted mtree file. | https://nvd.nist.gov/vuln/detail/CVE-2016-4301 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.